mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-13 11:40:53 +08:00
BaaRai
24c8ea13c0
Add a rea skill (skill-gated MCP): agents get binary and application package reverse engineering through a rea MCP server, with tools kept deferred so the 172-tool catalog never bloats the prompt until the skill loads. Remote MCP servers now take timeout_seconds (default 120): analysis servers with minutes-long tool calls were cut off mid-call by the fixed 120s client timeout. Applies to the Streamable HTTP transport; wired through discovery, the ScopeSentry sync client, the API and the MCP dialog. Closes #8
91 lines
2.8 KiB
Go
91 lines
2.8 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"time"
|
|
|
|
"github.com/Autumn-27/artex/db"
|
|
"github.com/Autumn-27/artex/mcphttp"
|
|
"github.com/Autumn-27/norma/mcp"
|
|
actool "github.com/Autumn-27/norma/tool"
|
|
)
|
|
|
|
// mcpClient is the shared surface of a connected MCP server (stdio, Streamable HTTP,
|
|
// or legacy SSE),
|
|
// so tools/list and cleanup are handled uniformly regardless of transport.
|
|
type mcpClient interface {
|
|
Tools(context.Context) ([]actool.CoreTool, error)
|
|
Close() error
|
|
}
|
|
|
|
// connectMCP dials one MCP server per its transport. Callers must Close the client.
|
|
func connectMCP(ctx context.Context, m *db.MCPServer) (mcpClient, error) {
|
|
switch m.Transport {
|
|
case "stdio":
|
|
if m.Command == "" {
|
|
return nil, fmt.Errorf("stdio transport is missing a command")
|
|
}
|
|
return mcp.NewStdioClient(ctx, m.Name, m.Command, jsonStrMap(m.Env), jsonStrSlice(m.Args)...)
|
|
case "http":
|
|
if m.URL == "" {
|
|
return nil, fmt.Errorf("http transport is missing a URL")
|
|
}
|
|
// env map doubles as HTTP headers (e.g. Authorization).
|
|
return mcphttp.New(ctx, m.Name, m.URL, jsonStrMap(m.Env), m.Insecure, m.TimeoutSeconds)
|
|
case "sse":
|
|
if m.URL == "" {
|
|
return nil, fmt.Errorf("sse transport is missing a URL")
|
|
}
|
|
return mcphttp.NewSSE(ctx, m.Name, m.URL, jsonStrMap(m.Env), m.Insecure)
|
|
default:
|
|
return nil, fmt.Errorf("unknown transport %q", m.Transport)
|
|
}
|
|
}
|
|
|
|
// discoverAndCacheMCP connects to one MCP, lists its tools, and persists the tool
|
|
// names to mcp_tools_cache so the UI shows them without a live connection.
|
|
func (s *Server) discoverAndCacheMCP(ctx context.Context, m *db.MCPServer) error {
|
|
cl, err := connectMCP(ctx, m)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer cl.Close()
|
|
ts, err := cl.Tools(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tools := make([]db.MCPTool, 0, len(ts))
|
|
for _, t := range ts {
|
|
tools = append(tools, db.MCPTool{Name: t.Name(), Description: t.Description()})
|
|
}
|
|
if err := s.m.pg.SaveMCPTools(m.ID, tools); err != nil {
|
|
return err
|
|
}
|
|
log.Printf("[mcp] %s discovered %d tools and cached them", m.Name, len(tools))
|
|
return nil
|
|
}
|
|
|
|
// discoverEmptyMCPsOnStartup fills the tool cache for any enabled MCP that has none
|
|
// yet (notably the seeded browser MCP on first run). Runs sequentially in one
|
|
// goroutine so we never spawn many stdio servers (npx) at once, and never blocks
|
|
// startup. Best-effort: a failure leaves the cache empty to retry next start.
|
|
func (s *Server) discoverEmptyMCPsOnStartup() {
|
|
servers, err := s.m.pg.ListMCP()
|
|
if err != nil {
|
|
log.Printf("[mcp] startup auto-discovery: failed to read the list: %v", err)
|
|
return
|
|
}
|
|
for _, m := range servers {
|
|
if !m.Enabled || len(m.Tools) > 0 {
|
|
continue
|
|
}
|
|
ctx, cancel := context.WithTimeout(s.ctx, 90*time.Second)
|
|
if err := s.discoverAndCacheMCP(ctx, m); err != nil {
|
|
log.Printf("[mcp] startup auto-discovery of %s failed: %v", m.Name, err)
|
|
}
|
|
cancel()
|
|
}
|
|
}
|