chainlesschain 0.45.64 → 0.45.65

package/src/runtime/agent-runtime.js

@@ -15,12 +15,28 @@ import { startChatRepl } from "../gateways/repl/chat-repl.js";
 import { ChainlessChainWSServer } from "../gateways/ws/ws-server.js";
 import { WSSessionManager } from "../gateways/ws/ws-session-gateway.js";
 import { createWebUIServer } from "../gateways/ui/web-ui-server.js";
-import {
-  findProjectRoot,
-  loadProjectConfig,
-} from "../lib/project-detector.js";
+import { MCPClient, MCPServerConfig } from "../lib/mcp-client.js";
+import sharedManagedToolPolicy from "./coding-agent-managed-tool-policy.cjs";
+import { findProjectRoot, loadProjectConfig } from "../lib/project-detector.js";
 import { loadConfig } from "../lib/config-manager.js";
 
+const {
+  DEFAULT_ALLOWED_MCP_SERVER_NAMES,
+  createTrustedMcpServerMap,
+  resolveMcpServerPolicy,
+} = sharedManagedToolPolicy;
+
+const BUILTIN_CODING_AGENT_MCP_REGISTRY = Object.freeze({
+  trustedServers: [
+    {
+      id: "weather",
+      securityLevel: "low",
+      requiredPermissions: ["network:http"],
+      capabilities: ["tools", "resources"],
+    },
+  ],
+});
+
 function openBrowser(url) {
   try {
     const platform = process.platform;
@@ -48,11 +64,15 @@ export class AgentRuntime {
       startChatRepl: deps.startChatRepl || startChatRepl,
       bootstrap: deps.bootstrap || bootstrap,
       createServer:
-        deps.createServer ||
-        ((options) => new ChainlessChainWSServer(options)),
+        deps.createServer || ((options) => new ChainlessChainWSServer(options)),
       createSessionManager:
         deps.createSessionManager ||
         ((options) => new WSSessionManager(options)),
+      createMcpClient: deps.createMcpClient || (() => new MCPClient()),
+      createMcpServerConfig:
+        deps.createMcpServerConfig || ((db) => new MCPServerConfig(db)),
+      mcpServerRegistry:
+        deps.mcpServerRegistry || BUILTIN_CODING_AGENT_MCP_REGISTRY,
       createWebServer:
         deps.createWebServer || ((options) => createWebUIServer(options)),
       findProjectRoot: deps.findProjectRoot || findProjectRoot,
@@ -105,22 +125,29 @@ export class AgentRuntime {
       return this.startAgentSession();
     }
 
-    throw new Error(`resumeSession is not supported for runtime kind "${this.kind}".`);
+    throw new Error(
+      `resumeSession is not supported for runtime kind "${this.kind}".`,
+    );
   }
 
   async runTurn(input, meta = {}) {
     if (typeof this.deps.runTurn !== "function") {
-      throw new Error(`runTurn is not configured for runtime kind "${this.kind}".`);
+      throw new Error(
+        `runTurn is not configured for runtime kind "${this.kind}".`,
+      );
     }
 
     const startedAt = Date.now();
-    this.emit(RUNTIME_EVENTS.TURN_START, createAgentTurnRecord({
-      kind: this.kind,
-      input,
-      meta,
-      sessionId: this.policy.sessionId || null,
-      startedAt,
-    }));
+    this.emit(
+      RUNTIME_EVENTS.TURN_START,
+      createAgentTurnRecord({
+        kind: this.kind,
+        input,
+        meta,
+        sessionId: this.policy.sessionId || null,
+        startedAt,
+      }),
+    );
 
     const result = await this.deps.runTurn({
       input,
@@ -130,15 +157,18 @@ export class AgentRuntime {
       context: this.context,
     });
 
-    this.emit(RUNTIME_EVENTS.TURN_END, createAgentTurnRecord({
-      kind: this.kind,
-      input,
-      meta,
-      result,
-      sessionId: this.policy.sessionId || null,
-      startedAt,
-      endedAt: Date.now(),
-    }));
+    this.emit(
+      RUNTIME_EVENTS.TURN_END,
+      createAgentTurnRecord({
+        kind: this.kind,
+        input,
+        meta,
+        result,
+        sessionId: this.policy.sessionId || null,
+        startedAt,
+        endedAt: Date.now(),
+      }),
+    );
 
     return result;
   }
@@ -169,14 +199,8 @@ export class AgentRuntime {
 
   async startServer() {
     const { logger: runtimeLogger } = this.deps;
-    const {
-      port,
-      maxConnections,
-      timeout,
-      token,
-      allowRemote,
-      project,
-    } = this.policy;
+    const { port, maxConnections, timeout, token, allowRemote, project } =
+      this.policy;
     let { host } = this.policy;
 
     if (Number.isNaN(port) || port < 1 || port > 65535) {
@@ -191,9 +215,11 @@ export class AgentRuntime {
     }
 
     let db = null;
+    let rawDb = null;
     try {
       const ctx = await this.deps.bootstrap({ skipDb: false });
-      db = ctx.db?.getDb?.() || null;
+      rawDb = ctx.db?.getDatabase?.() || ctx.db?.getDb?.() || null;
+      db = rawDb;
     } catch (_err) {
       runtimeLogger.log(
         chalk.yellow(
@@ -202,9 +228,16 @@ export class AgentRuntime {
       );
     }
 
+    const mcpClient = await this._initializeCodingAgentMcpClient(rawDb, {
+      logger: runtimeLogger,
+    });
+
     const sessionManager = this.deps.createSessionManager({
       db,
       defaultProjectRoot: project,
+      mcpClient,
+      allowedMcpServerNames: DEFAULT_ALLOWED_MCP_SERVER_NAMES,
+      mcpServerRegistry: this.deps.mcpServerRegistry,
     });
 
     const server = this.deps.createServer({
@@ -217,7 +250,9 @@ export class AgentRuntime {
     });
 
     server.on("connection", ({ clientId, ip }) => {
-      runtimeLogger.log(chalk.green(`  + Client connected: ${clientId} (${ip})`));
+      runtimeLogger.log(
+        chalk.green(`  + Client connected: ${clientId} (${ip})`),
+      );
     });
 
     server.on("disconnection", ({ clientId, reason }) => {
@@ -250,6 +285,9 @@ export class AgentRuntime {
       runtimeLogger.log(
         "\n" + chalk.yellow("Shutting down WebSocket server..."),
       );
+      if (mcpClient && typeof mcpClient.disconnectAll === "function") {
+        await mcpClient.disconnectAll().catch(() => undefined);
+      }
       await server.stop();
       process.exit(0);
     };
@@ -305,14 +343,15 @@ export class AgentRuntime {
       ? this.deps.loadProjectConfig(projectRoot)
       : null;
     const projectName =
-      projectConfig?.name ||
-      (projectRoot ? path.basename(projectRoot) : null);
+      projectConfig?.name || (projectRoot ? path.basename(projectRoot) : null);
     const mode = projectRoot ? "project" : "global";
 
     let db = null;
+    let rawDb = null;
     try {
       const ctx = await this.deps.bootstrap({ skipDb: false });
-      db = ctx.db?.getDb?.() || null;
+      rawDb = ctx.db?.getDatabase?.() || ctx.db?.getDb?.() || null;
+      db = rawDb;
     } catch (_err) {
       runtimeLogger.log(
         chalk.yellow(
@@ -322,10 +361,16 @@ export class AgentRuntime {
     }
 
     const appConfig = this.deps.loadConfig();
+    const mcpClient = await this._initializeCodingAgentMcpClient(rawDb, {
+      logger: runtimeLogger,
+    });
     const sessionManager = this.deps.createSessionManager({
       db,
       defaultProjectRoot: projectRoot || process.cwd(),
       config: appConfig,
+      mcpClient,
+      allowedMcpServerNames: DEFAULT_ALLOWED_MCP_SERVER_NAMES,
+      mcpServerRegistry: this.deps.mcpServerRegistry,
     });
 
     const wsServer = this.deps.createServer({
@@ -395,6 +440,9 @@ export class AgentRuntime {
 
     const shutdown = async () => {
       runtimeLogger.log("\n" + chalk.yellow("Shutting down UI server..."));
+      if (mcpClient && typeof mcpClient.disconnectAll === "function") {
+        await mcpClient.disconnectAll().catch(() => undefined);
+      }
       await Promise.all([
         new Promise((resolve) => httpServer.close(resolve)),
         wsServer.stop(),
@@ -414,4 +462,59 @@ export class AgentRuntime {
       projectName,
     };
   }
+
+  async _initializeCodingAgentMcpClient(db, options = {}) {
+    if (!db) {
+      return null;
+    }
+
+    const trustedMcpServers = createTrustedMcpServerMap(
+      this.deps.mcpServerRegistry,
+    );
+    const configStore = this.deps.createMcpServerConfig(db);
+    const autoConnectServers =
+      typeof configStore?.getAutoConnect === "function"
+        ? configStore.getAutoConnect()
+        : [];
+    const eligibleServers = autoConnectServers.filter(
+      (server) =>
+        resolveMcpServerPolicy(
+          server?.name,
+          { state: "connected" },
+          {
+            allowedMcpServerNames: DEFAULT_ALLOWED_MCP_SERVER_NAMES,
+            trustedMcpServers,
+          },
+        ).allowed,
+    );
+
+    if (eligibleServers.length === 0) {
+      return null;
+    }
+
+    const mcpClient = this.deps.createMcpClient();
+    let connectedCount = 0;
+
+    for (const server of eligibleServers) {
+      try {
+        await mcpClient.connect(server.name, server);
+        connectedCount += 1;
+      } catch (err) {
+        options.logger?.log?.(
+          chalk.yellow(
+            `  Warning: MCP server "${server.name}" auto-connect failed: ${err.message}`,
+          ),
+        );
+      }
+    }
+
+    if (connectedCount === 0) {
+      if (typeof mcpClient.disconnectAll === "function") {
+        await mcpClient.disconnectAll().catch(() => undefined);
+      }
+      return null;
+    }
+
+    return mcpClient;
+  }
 }

package/src/runtime/coding-agent-contract.js

@@ -0,0 +1,294 @@
+import { ToolRegistry, createDefaultToolRegistry } from "../tools/registry.js";
+import sharedCodingAgentPolicy from "./coding-agent-policy.cjs";
+
+const { TOOL_POLICY_METADATA } = sharedCodingAgentPolicy;
+
+const CODING_AGENT_TOOL_CONTRACTS = Object.freeze([
+  {
+    name: "read_file",
+    title: "Read File",
+    kind: "filesystem",
+    tier: "mvp",
+    ...TOOL_POLICY_METADATA.read_file,
+    permissions: {
+      level: "readonly",
+      scopes: ["filesystem:read"],
+    },
+    telemetry: {
+      category: "filesystem",
+      tags: ["tool:read_file", "contract:coding-agent", "tier:mvp"],
+    },
+  },
+  {
+    name: "write_file",
+    title: "Write File",
+    kind: "filesystem",
+    tier: "mvp",
+    ...TOOL_POLICY_METADATA.write_file,
+    permissions: {
+      level: "elevated",
+      scopes: ["filesystem:write"],
+    },
+    telemetry: {
+      category: "filesystem",
+      tags: ["tool:write_file", "contract:coding-agent", "tier:mvp"],
+    },
+  },
+  {
+    name: "edit_file",
+    title: "Edit File",
+    kind: "filesystem",
+    tier: "mvp",
+    ...TOOL_POLICY_METADATA.edit_file,
+    permissions: {
+      level: "elevated",
+      scopes: ["filesystem:write"],
+    },
+    telemetry: {
+      category: "filesystem",
+      tags: ["tool:edit_file", "contract:coding-agent", "tier:mvp"],
+    },
+  },
+  {
+    name: "run_shell",
+    title: "Run Shell",
+    kind: "shell",
+    tier: "mvp",
+    ...TOOL_POLICY_METADATA.run_shell,
+    runtimeDescriptor: "shell",
+    permissions: {
+      level: "elevated",
+      scopes: ["process:spawn", "filesystem:workspace"],
+    },
+    telemetry: {
+      category: "shell",
+      tags: ["tool:run_shell", "contract:coding-agent", "tier:mvp"],
+    },
+  },
+  {
+    name: "git",
+    title: "Git",
+    kind: "git",
+    tier: "mvp",
+    ...TOOL_POLICY_METADATA.git,
+    runtimeDescriptor: "git",
+    permissions: {
+      level: "elevated",
+      scopes: ["process:spawn", "filesystem:workspace", "vcs:git"],
+    },
+    telemetry: {
+      category: "git",
+      tags: ["tool:git", "contract:coding-agent", "tier:mvp"],
+    },
+  },
+  {
+    name: "search_files",
+    title: "Search Files",
+    kind: "filesystem",
+    tier: "mvp",
+    ...TOOL_POLICY_METADATA.search_files,
+    permissions: {
+      level: "readonly",
+      scopes: ["filesystem:read", "search:content"],
+    },
+    telemetry: {
+      category: "filesystem",
+      tags: ["tool:search_files", "contract:coding-agent", "tier:mvp"],
+    },
+  },
+  {
+    name: "list_dir",
+    title: "List Directory",
+    kind: "filesystem",
+    tier: "mvp",
+    ...TOOL_POLICY_METADATA.list_dir,
+    permissions: {
+      level: "readonly",
+      scopes: ["filesystem:read"],
+    },
+    telemetry: {
+      category: "filesystem",
+      tags: ["tool:list_dir", "contract:coding-agent", "tier:mvp"],
+    },
+  },
+  {
+    name: "run_skill",
+    title: "Run Skill",
+    kind: "skill",
+    tier: "extension",
+    ...TOOL_POLICY_METADATA.run_skill,
+    permissions: {
+      level: "standard",
+      scopes: ["skill:invoke"],
+    },
+    telemetry: {
+      category: "skill",
+      tags: ["tool:run_skill", "contract:coding-agent", "tier:extension"],
+    },
+  },
+  {
+    name: "list_skills",
+    title: "List Skills",
+    kind: "skill",
+    tier: "extension",
+    ...TOOL_POLICY_METADATA.list_skills,
+    permissions: {
+      level: "readonly",
+      scopes: ["skill:read"],
+    },
+    telemetry: {
+      category: "skill",
+      tags: ["tool:list_skills", "contract:coding-agent", "tier:extension"],
+    },
+  },
+  {
+    name: "run_code",
+    title: "Run Code",
+    kind: "code",
+    tier: "extension",
+    ...TOOL_POLICY_METADATA.run_code,
+    permissions: {
+      level: "elevated",
+      scopes: ["process:spawn", "filesystem:workspace", "runtime:script"],
+    },
+    telemetry: {
+      category: "code",
+      tags: ["tool:run_code", "contract:coding-agent", "tier:extension"],
+    },
+  },
+  {
+    name: "spawn_sub_agent",
+    title: "Spawn Sub Agent",
+    kind: "agent",
+    tier: "extension",
+    ...TOOL_POLICY_METADATA.spawn_sub_agent,
+    permissions: {
+      level: "elevated",
+      scopes: ["agent:spawn"],
+    },
+    telemetry: {
+      category: "agent",
+      tags: ["tool:spawn_sub_agent", "contract:coding-agent", "tier:extension"],
+    },
+  },
+]);
+
+export const CODING_AGENT_MVP_TOOL_NAMES = Object.freeze(
+  CODING_AGENT_TOOL_CONTRACTS.filter((tool) => tool.tier === "mvp").map(
+    (tool) => tool.name,
+  ),
+);
+
+export const CODING_AGENT_EXTENSION_TOOL_NAMES = Object.freeze(
+  CODING_AGENT_TOOL_CONTRACTS.filter((tool) => tool.tier === "extension").map(
+    (tool) => tool.name,
+  ),
+);
+
+const TOOL_CONTRACT_MAP = new Map(
+  CODING_AGENT_TOOL_CONTRACTS.map((tool) => [tool.name, tool]),
+);
+const runtimeRegistry = createDefaultToolRegistry();
+
+function cloneValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function getFallbackToolContract(name) {
+  return {
+    name,
+    title: name,
+    kind: "legacy",
+    tier: "legacy",
+    riskLevel: "medium",
+    availableInPlanMode: false,
+    planModeBehavior: "blocked",
+    requiresPlanApproval: false,
+    approvalFlow: "policy",
+    permissions: {
+      level: "standard",
+      scopes: [],
+    },
+    telemetry: {
+      category: "legacy",
+      tags: [`tool:${name}`, "contract:coding-agent", "tier:legacy"],
+    },
+  };
+}
+
+export function getCodingAgentToolContract(name) {
+  const tool = TOOL_CONTRACT_MAP.get(name);
+  return tool ? cloneValue(tool) : null;
+}
+
+export function getCodingAgentToolContracts({ tier = null } = {}) {
+  return CODING_AGENT_TOOL_CONTRACTS.filter((tool) => {
+    if (tier && tool.tier !== tier) {
+      return false;
+    }
+    return true;
+  }).map(cloneValue);
+}
+
+export function listCodingAgentToolNames({ tier = null } = {}) {
+  return getCodingAgentToolContracts({ tier }).map((tool) => tool.name);
+}
+
+export function isCodingAgentMvpTool(name) {
+  return CODING_AGENT_MVP_TOOL_NAMES.includes(name);
+}
+
+export function getCodingAgentToolPolicy(name) {
+  const tool = TOOL_CONTRACT_MAP.get(name);
+  if (!tool) {
+    return null;
+  }
+
+  return {
+    tier: tool.tier,
+    riskLevel: tool.riskLevel,
+    availableInPlanMode: tool.availableInPlanMode,
+    planModeBehavior: tool.planModeBehavior || "standard",
+    requiresPlanApproval: tool.requiresPlanApproval,
+    approvalFlow: tool.approvalFlow,
+    permissions: cloneValue(tool.permissions),
+  };
+}
+
+export function mapCodingAgentToolDefinition(definition = {}, options = {}) {
+  const fn = definition.function || {};
+  const name = fn.name;
+  if (!name) {
+    throw new Error("Coding agent tool definition requires function.name.");
+  }
+
+  const contract =
+    getCodingAgentToolContract(name) || getFallbackToolContract(name);
+
+  return {
+    name,
+    title: contract.title || name,
+    kind: contract.kind,
+    description: fn.description || "",
+    schema: fn.parameters || { type: "object", properties: {} },
+    permissions: cloneValue(contract.permissions),
+    telemetry: cloneValue(contract.telemetry),
+    source: options.source || "agent-core",
+  };
+}
+
+export function createCodingAgentToolRegistry(definitions = [], options = {}) {
+  const registry = new ToolRegistry();
+  definitions.forEach((definition) => {
+    registry.register(mapCodingAgentToolDefinition(definition, options));
+  });
+  return registry;
+}
+
+export function getCodingAgentRuntimeDescriptor(toolName) {
+  const descriptorName = TOOL_CONTRACT_MAP.get(toolName)?.runtimeDescriptor;
+  if (!descriptorName) {
+    return null;
+  }
+  return runtimeRegistry.get(descriptorName) || null;
+}