@dotsetlabs/dotclaw 1.9.0 → 2.1.0

package/container/agent-runner/src/ipc.ts

@@ -408,38 +408,7 @@ export function createIpcHandlers(ctx: IpcContext, config: IpcConfig) {
     },
 
     async runTask(taskId: string) {
-      return requestResponse('run_task', { task_id: taskId }, config);
-    },
-
-    async spawnJob(args: {
-      prompt: string;
-      context_mode?: 'group' | 'isolated';
-      timeout_ms?: number;
-      max_tool_steps?: number;
-      tool_allow?: string[];
-      tool_deny?: string[];
-      model_override?: string;
-      priority?: number;
-      tags?: string[];
-      target_group?: string;
-    }) {
-      return requestResponse('spawn_job', args as Record<string, unknown>, config);
-    },
-
-    async jobStatus(jobId: string) {
-      return requestResponse('job_status', { job_id: jobId }, config);
-    },
-
-    async listJobs(args: { status?: string; limit?: number; target_group?: string }) {
-      return requestResponse('list_jobs', args as Record<string, unknown>, config);
-    },
-
-    async cancelJob(jobId: string) {
-      return requestResponse('cancel_job', { job_id: jobId }, config);
-    },
-
-    async jobUpdate(args: { job_id: string; message: string; level?: string; notify?: boolean; data?: Record<string, unknown> }) {
-      return requestResponse('job_update', args as Record<string, unknown>, config);
+      return requestResponse('run_task', { task_id: taskId }, config, 900_000);
     },
 
     async setModel(args: { model: string; scope?: 'global' | 'group' | 'user'; target_id?: string }) {
@@ -500,6 +469,7 @@ export function createIpcHandlers(ctx: IpcContext, config: IpcConfig) {
         userId: args.userId,
         target_group: args.target_group
       }, config);
-    }
+    },
+
   };
 }

package/container/agent-runner/src/mcp-client.ts

@@ -0,0 +1,222 @@
+/**
+ * Minimal MCP (Model Context Protocol) client implementation.
+ * Supports stdio transport for connecting to MCP-compatible tool servers.
+ */
+
+import { spawn, ChildProcess } from 'child_process';
+
+export interface McpTool {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export interface McpCallResult {
+  content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
+  isError?: boolean;
+}
+
+type JsonRpcRequest = {
+  jsonrpc: '2.0';
+  id: number;
+  method: string;
+  params?: Record<string, unknown>;
+};
+
+type JsonRpcResponse = {
+  jsonrpc: '2.0';
+  id: number;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+};
+
+export class McpStdioClient {
+  private proc: ChildProcess | null = null;
+  private nextId = 1;
+  private pending = new Map<number, { resolve: (value: unknown) => void; reject: (err: Error) => void }>();
+  private buffer = '';
+  private connected = false;
+  private connectPromise: Promise<void> | null = null;
+  private command: string;
+  private args: string[];
+  private env: Record<string, string>;
+  private timeoutMs: number;
+
+  constructor(options: {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeoutMs?: number;
+  }) {
+    this.command = options.command;
+    this.args = options.args || [];
+    this.env = options.env || {};
+    this.timeoutMs = options.timeoutMs || 10_000;
+  }
+
+  async connect(): Promise<void> {
+    if (this.connected) return;
+    if (this.connectPromise) return this.connectPromise;
+
+    this.connectPromise = this.doConnect();
+    try {
+      await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+
+  private async doConnect(): Promise<void> {
+    // Resolve env vars that reference process.env
+    const resolvedEnv: Record<string, string> = {};
+    for (const [key, value] of Object.entries(this.env)) {
+      resolvedEnv[key] = value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, envKey: string) => {
+        return process.env[envKey] || '';
+      });
+    }
+
+    this.proc = spawn(this.command, this.args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, ...resolvedEnv }
+    });
+
+    this.proc.stdout!.on('data', (data: Buffer) => {
+      this.buffer += data.toString();
+      this.processBuffer();
+    });
+
+    this.proc.stderr!.on('data', (data: Buffer) => {
+      console.error(`[mcp-client] stderr: ${data.toString().slice(0, 200)}`);
+    });
+
+    this.proc.on('close', () => {
+      this.connected = false;
+      for (const [, pending] of this.pending) {
+        pending.reject(new Error('MCP server process closed'));
+      }
+      this.pending.clear();
+    });
+
+    this.proc.on('error', (err) => {
+      console.error(`[mcp-client] process error: ${err.message}`);
+      this.connected = false;
+      for (const [, pending] of this.pending) {
+        pending.reject(new Error(`MCP server process error: ${err.message}`));
+      }
+      this.pending.clear();
+    });
+
+    // Initialize MCP connection
+    await this.sendRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'dotclaw', version: '2.0.0' }
+    });
+
+    // Send initialized notification
+    this.sendNotification('notifications/initialized');
+
+    this.connected = true;
+  }
+
+  private processBuffer(): void {
+    // Try to parse JSON-RPC messages from the buffer
+    // MCP uses newline-delimited JSON
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed) as JsonRpcResponse;
+        if (msg.id !== undefined && this.pending.has(msg.id)) {
+          const handler = this.pending.get(msg.id)!;
+          this.pending.delete(msg.id);
+          if (msg.error) {
+            handler.reject(new Error(msg.error.message));
+          } else {
+            handler.resolve(msg.result);
+          }
+        }
+      } catch {
+        // Skip malformed lines
+      }
+    }
+  }
+
+  private sendRequest(method: string, params?: Record<string, unknown>): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      if (!this.proc || !this.proc.stdin) {
+        reject(new Error('MCP client not connected'));
+        return;
+      }
+
+      const id = this.nextId++;
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id,
+        method,
+        params
+      };
+
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`MCP request timeout: ${method}`));
+      }, this.timeoutMs);
+
+      this.pending.set(id, {
+        resolve: (value) => {
+          clearTimeout(timeout);
+          resolve(value);
+        },
+        reject: (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        }
+      });
+
+      this.proc.stdin.write(JSON.stringify(request) + '\n');
+    });
+  }
+
+  private sendNotification(method: string, params?: Record<string, unknown>): void {
+    if (!this.proc || !this.proc.stdin) return;
+    const notification = {
+      jsonrpc: '2.0',
+      method,
+      params
+    };
+    this.proc.stdin.write(JSON.stringify(notification) + '\n');
+  }
+
+  async listTools(): Promise<McpTool[]> {
+    const result = await this.sendRequest('tools/list') as { tools?: McpTool[] };
+    return result?.tools || [];
+  }
+
+  async callTool(name: string, args: Record<string, unknown>): Promise<McpCallResult> {
+    const result = await this.sendRequest('tools/call', {
+      name,
+      arguments: args
+    }) as McpCallResult;
+    return result;
+  }
+
+  async close(): Promise<void> {
+    this.connected = false;
+    if (this.proc) {
+      this.proc.stdin?.end();
+      this.proc.kill('SIGTERM');
+      this.proc = null;
+    }
+    for (const [, pending] of this.pending) {
+      pending.reject(new Error('MCP client closed'));
+    }
+    this.pending.clear();
+  }
+
+  get isConnected(): boolean {
+    return this.connected;
+  }
+}

package/container/agent-runner/src/mcp-registry.ts

@@ -0,0 +1,163 @@
+/**
+ * MCP Tool Registry — discovers tools from MCP servers and creates SDK Tool definitions.
+ * Tools are prefixed with mcp_ext__<server>__<tool> to avoid collisions with built-in tools.
+ */
+
+import { tool as sdkTool, type Tool } from '@openrouter/sdk';
+import { z } from 'zod';
+import { McpStdioClient, type McpTool, type McpCallResult } from './mcp-client.js';
+import type { AgentRuntimeConfig } from './agent-config.js';
+
+type ToolConfig = {
+  name: string;
+  description?: string;
+  inputSchema: z.ZodTypeAny;
+  outputSchema?: z.ZodTypeAny;
+  execute: unknown;
+};
+
+const tool = sdkTool as unknown as (config: ToolConfig) => Tool;
+
+type McpServerConfig = NonNullable<AgentRuntimeConfig['agent']['mcp']['servers']>[number];
+
+// Convert JSON Schema to a Zod object schema (best-effort)
+function jsonSchemaToZod(schema: Record<string, unknown>): z.ZodTypeAny {
+  if (!schema || typeof schema !== 'object') return z.any();
+
+  const type = schema.type as string | undefined;
+  const properties = schema.properties as Record<string, Record<string, unknown>> | undefined;
+  const required = (schema.required as string[]) || [];
+
+  if (type === 'object' && properties) {
+    const shape: Record<string, z.ZodTypeAny> = {};
+    for (const [key, propSchema] of Object.entries(properties)) {
+      let field = jsonSchemaToZod(propSchema);
+      if (!required.includes(key)) {
+        field = field.optional();
+      }
+      if (propSchema.description && typeof propSchema.description === 'string') {
+        field = field.describe(propSchema.description);
+      }
+      shape[key] = field;
+    }
+    return z.object(shape).passthrough();
+  }
+
+  switch (type) {
+    case 'string': {
+      if (schema.enum && Array.isArray(schema.enum) && schema.enum.length > 0) {
+        return z.enum(schema.enum as [string, ...string[]]);
+      }
+      return z.string();
+    }
+    case 'number':
+    case 'integer':
+      return z.number();
+    case 'boolean':
+      return z.boolean();
+    case 'array': {
+      const items = schema.items as Record<string, unknown> | undefined;
+      return z.array(items ? jsonSchemaToZod(items) : z.any());
+    }
+    default:
+      return z.any();
+  }
+}
+
+export class McpToolRegistry {
+  private clients = new Map<string, McpStdioClient>();
+  private serverConfigs: McpServerConfig[];
+  private connectionTimeoutMs: number;
+  private discoveredTools: Tool[] = [];
+
+  constructor(config: AgentRuntimeConfig['agent']['mcp']) {
+    this.serverConfigs = config.servers || [];
+    this.connectionTimeoutMs = config.connectionTimeoutMs;
+  }
+
+  async discoverTools(wrapExecute: <TInput, TOutput>(name: string, execute: (args: TInput) => Promise<TOutput>) => (args: TInput) => Promise<TOutput>): Promise<Tool[]> {
+    if (this.serverConfigs.length === 0) return [];
+
+    const tools: Tool[] = [];
+
+    for (const serverConfig of this.serverConfigs) {
+      if (!serverConfig.command) continue;
+
+      try {
+        const client = new McpStdioClient({
+          command: serverConfig.command,
+          args: serverConfig.args,
+          env: serverConfig.env,
+          timeoutMs: this.connectionTimeoutMs
+        });
+
+        this.clients.set(serverConfig.name, client);
+
+        const mcpTools = await this.discoverServerTools(client);
+
+        for (const mcpTool of mcpTools) {
+          const toolName = `mcp_ext__${serverConfig.name}__${mcpTool.name}`;
+          const inputSchema = jsonSchemaToZod(mcpTool.inputSchema);
+
+          const sdkToolInstance = tool({
+            name: toolName,
+            description: mcpTool.description || `MCP tool from ${serverConfig.name}`,
+            inputSchema,
+            outputSchema: z.object({
+              content: z.array(z.object({
+                type: z.string(),
+                text: z.string().optional()
+              })).optional(),
+              isError: z.boolean().optional(),
+              error: z.string().optional()
+            }),
+            execute: wrapExecute(toolName, async (args: Record<string, unknown>) => {
+              return this.callMcpTool(serverConfig.name, mcpTool.name, args);
+            })
+          });
+
+          tools.push(sdkToolInstance as Tool);
+        }
+
+        console.log(`[mcp-registry] Discovered ${mcpTools.length} tools from ${serverConfig.name}`);
+      } catch (err) {
+        console.error(`[mcp-registry] Failed to connect to MCP server ${serverConfig.name}: ${err instanceof Error ? err.message : String(err)}`);
+        const failedClient = this.clients.get(serverConfig.name);
+        this.clients.delete(serverConfig.name);
+        if (failedClient) { try { await failedClient.close(); } catch { /* ignore */ } }
+      }
+    }
+
+    this.discoveredTools = tools;
+    return tools;
+  }
+
+  private async discoverServerTools(client: McpStdioClient): Promise<McpTool[]> {
+    await client.connect();
+    return client.listTools();
+  }
+
+  private async callMcpTool(serverName: string, toolName: string, args: Record<string, unknown>): Promise<McpCallResult & { error?: string }> {
+    const client = this.clients.get(serverName);
+    if (!client) {
+      return { content: [], isError: true, error: `MCP server ${serverName} not found` };
+    }
+
+    if (!client.isConnected) {
+      await client.connect();
+    }
+
+    return client.callTool(toolName, args);
+  }
+
+  async closeAll(): Promise<void> {
+    for (const [, client] of this.clients) {
+      await client.close();
+    }
+    this.clients.clear();
+  }
+
+  getDiscoveredTools(): Tool[] {
+    return this.discoveredTools;
+  }
+}