agent-gear 1.1.5 → 1.1.7

package/src/acp/spawner.ts

@@ -29,7 +29,7 @@ export class AcpSpawner {
 
   start(): void {
     const cmd = this.resolveCommand();
-    console.log(`Starting ACP server ${cmd}`)
+    console.log(`Starting ACP server: session=${this.sessionId} cmd=${cmd} args=${JSON.stringify(this.args)} cwd=${this.cwd}`);
     mkdirSync(this.cwd, { recursive: true });
 
     const spawnOptions: SpawnOptions = {
@@ -43,17 +43,17 @@ export class AcpSpawner {
     this.process = spawn(cmd, this.args, spawnOptions);
 
     this.process.stderr?.on('data', (data: Buffer) => {
-      console.error(`ACP stderr: ${data.toString()}`);
+      console.error(`ACP stderr (session=${this.sessionId}): ${data.toString()}`);
     });
 
     this.process.on('exit', (code, signal) => {
-      console.log(`ACP process exited with code ${code} and signal ${signal}`);
+      console.log(`ACP process exited: session=${this.sessionId} code=${code} signal=${signal} cmd=${cmd} args=${JSON.stringify(this.args)}`);
       this.process = null;
       this.resolveClosed?.();
     });
 
     this.process.on('error', (error) => {
-      console.error('ACP process error:', error);
+      console.error(`ACP process error (session=${this.sessionId}, cmd=${cmd}):`, error);
     });
   }
 

package/src/acp/sync-bridge.ts

@@ -29,6 +29,7 @@ export class AcpSyncBridge implements acp.Client {
   private spawner: AcpSpawner;
   private connection: acp.ClientSideConnection | null = null;
   private updates: acp.SessionNotification[] = [];
+  private capabilities: acp.AgentCapabilities | null = null;
 
   constructor(options: AcpSyncBridgeOptions, spawner?: AcpSpawner) {
     this.spawner = spawner ?? new AcpSpawner({
@@ -53,15 +54,30 @@ export class AcpSyncBridge implements acp.Client {
       clientInfo: { name: 'agent-gear', version: '1.0.0' },
     });
 
-    await withTimeout(
+    const result = await withTimeout(
       Promise.race([initPromise, exitPromise]),
       timeoutMs,
       `ACP connect timed out after ${timeoutMs}ms`,
     );
+    this.capabilities = result.agentCapabilities ?? null;
   }
 
-  async listSessions(cwd: string): Promise<acp.ListSessionsResponse> {
-    return this.connection!.listSessions({ cwd });
+  supportsDelete(): boolean {
+    return Boolean(this.capabilities?.sessionCapabilities?.delete);
+  }
+
+  async listSessions(cwd: string, cursor?: string | null): Promise<acp.ListSessionsResponse> {
+    if (!this.connection) {
+      throw new Error('ACP connection not established');
+    }
+    return this.connection.listSessions({ cwd, ...(cursor ? { cursor } : {}) });
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    if (!this.connection) {
+      throw new Error('ACP connection not established');
+    }
+    await this.connection.deleteSession({ sessionId });
   }
 
   async loadSession(
@@ -108,4 +124,12 @@ export class AcpSyncBridge implements acp.Client {
   async requestPermission(): Promise<acp.RequestPermissionResponse> {
     return { outcome: { outcome: 'cancelled' } };
   }
+
+  async unstable_createElicitation(): Promise<acp.CreateElicitationResponse> {
+    return { action: 'cancel' };
+  }
+
+  async unstable_completeElicitation(): Promise<void> {
+    // no-op
+  }
 }

package/src/commands/mcp-proxy.ts

@@ -7,6 +7,92 @@ interface McpProxyOptions {
   command: string;
 }
 
+interface JsonRpcRequest {
+  jsonrpc?: string;
+  id?: unknown;
+  method?: string;
+  [key: string]: unknown;
+}
+
+const FORWARD_TIMEOUT_MS = 30_000;
+
+// JSON-RPC notifications have no id and MUST NOT be waited on: per the MCP
+// spec the server never responds to them. Waiting would stall every hop of
+// the forward chain for the full timeout.
+function isNotification(request: JsonRpcRequest): boolean {
+  return request.id === undefined || request.id === null;
+}
+
+// Persistent line-buffered JSON-RPC dispatcher over a child process' stdio.
+// Responses are matched to requests by id, so chunked responses (a single
+// 'data' event is NOT guaranteed to contain exactly one complete JSON
+// message) and concurrent in-flight requests are handled correctly.
+export function createStdioDispatcher(child: ChildProcess) {
+  let buffer = '';
+  const pending = new Map<unknown, { resolve: (value: unknown) => void; reject: (reason: Error) => void; timeout: NodeJS.Timeout; method: string }>();
+
+  child.stdout?.on('data', (data: Buffer) => {
+    buffer += data.toString();
+    let idx;
+    while ((idx = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
+      if (!line) continue;
+      let msg: { id?: unknown; error?: { message?: string } };
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        console.error(`[MCP proxy] ignoring non-JSON line from child: ${line.slice(0, 200)}`);
+        continue;
+      }
+      const entry = pending.get(msg.id);
+      if (!entry) {
+        console.error(`[MCP proxy] ignoring response with unknown id: ${JSON.stringify(msg.id)}`);
+        continue;
+      }
+      clearTimeout(entry.timeout);
+      pending.delete(msg.id);
+      console.log(`[MCP proxy] response: method=${entry.method} id=${JSON.stringify(msg.id)}${msg.error ? ` error=${msg.error.message}` : ''}`);
+      entry.resolve(msg);
+    }
+  });
+
+  const rejectAll = (reason: Error) => {
+    for (const [, entry] of pending) {
+      clearTimeout(entry.timeout);
+      entry.reject(reason);
+    }
+    pending.clear();
+  };
+
+  child.on('exit', (code) => {
+    console.log(`[MCP proxy] MCP command exited with code ${code}, rejecting ${pending.size} pending request(s)`);
+    rejectAll(new Error(`MCP command exited with code ${code}`));
+  });
+
+  return {
+    forward(request: JsonRpcRequest): Promise<unknown> {
+      const method = request.method ?? '(unknown)';
+      if (isNotification(request)) {
+        // Fire-and-forget: deliver the notification (e.g. notifications/initialized
+        // completes the MCP handshake) but do not wait for a response.
+        console.log(`[MCP proxy] forwarding notification: method=${method}`);
+        child.stdin?.write(JSON.stringify(request) + '\n');
+        return Promise.resolve(null);
+      }
+      console.log(`[MCP proxy] forwarding request: method=${method} id=${JSON.stringify(request.id)}`);
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pending.delete(request.id);
+          reject(new Error(`Request timeout waiting for ${method}`));
+        }, FORWARD_TIMEOUT_MS);
+        pending.set(request.id, { resolve, reject, timeout, method });
+        child.stdin?.write(JSON.stringify(request) + '\n');
+      });
+    },
+  };
+}
+
 export async function startMcpRegistration(options: McpProxyOptions): Promise<void> {
   const { server, key, command } = options;
 
@@ -45,10 +131,6 @@ export async function startMcpRegistration(options: McpProxyOptions): Promise<vo
     console.error('Failed to start MCP command:', err.message);
   });
 
-  child.on('exit', (code) => {
-    console.log(`MCP command exited with code ${code}`);
-  });
-
   // 3. Establish WebSocket connection
   const socket = ioClient(`${server}/mcp-proxy`, {
     transports: ['websocket'],
@@ -69,16 +151,18 @@ export async function startMcpRegistration(options: McpProxyOptions): Promise<vo
   });
 
   // 4. Bridge requests
-  socket.on('proxy:request', async (data: { requestId: string; request: any }) => {
+  const dispatcher = createStdioDispatcher(child);
+  socket.on('proxy:request', async (data: { requestId: string; request: JsonRpcRequest }) => {
     try {
-      const response = await forwardToChild(child, data.request);
+      const response = await dispatcher.forward(data.request);
       socket.emit('proxy:response', { requestId: data.requestId, response });
     } catch (err: any) {
+      console.error(`[MCP proxy] forward failed: method=${data.request?.method} id=${JSON.stringify(data.request?.id)} error=${err.message}`);
       socket.emit('proxy:response', {
         requestId: data.requestId,
         response: {
           jsonrpc: '2.0',
-          id: data.request.id,
+          id: data.request.id ?? null,
           error: { code: -32603, message: err.message },
         },
       });
@@ -105,24 +189,3 @@ export async function startMcpRegistration(options: McpProxyOptions): Promise<vo
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
 }
-
-function forwardToChild(child: ChildProcess, request: any): Promise<any> {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(new Error('Request timeout'));
-    }, 30000);
-
-    const onData = (data: Buffer) => {
-      clearTimeout(timeout);
-      child.stdout?.removeListener('data', onData);
-      try {
-        resolve(JSON.parse(data.toString()));
-      } catch {
-        reject(new Error('Invalid JSON response from MCP command'));
-      }
-    };
-
-    child.stdout?.on('data', onData);
-    child.stdin?.write(JSON.stringify(request) + '\n');
-  });
-}

package/src/socketio-client.ts

@@ -18,6 +18,7 @@ import { gatewayManager } from './gateway.js';
 const CONTROLLER_VERSION = '1.1.1';
 const acpBridges = new Map<string, AcpSessionBridge>();
 const permissionRequestBridge = new Map<string, AcpSessionBridge>();
+const elicitationRequestBridge = new Map<string, AcpSessionBridge>();
 
 function createSpawner(serverType: string, sessionId: string, cwd: string): AcpSpawner {
   const config = acpDetector.getSpawnerConfig(serverType);
@@ -48,11 +49,26 @@ interface AcpStartPayload {
   serverType: string;
   cwd: string;
   mcpServers?: Array<{ name: string; command: string; args?: string[]; env?: Array<{ name: string; value: string }> }>;
+  mcpEndpoint?: { url: string; token: string; serverNames: string[] };
+  additionalDirectories?: string[];
 }
 
 interface AcpMessagePayload {
   sessionId: string;
-  message: { type: string; content: string };
+  message: { type: string; content: string; attachments?: Array<Record<string, unknown>> };
+}
+
+// Summarize the MCP configuration of an acp:start/acp:resume payload for logs,
+// without leaking the endpoint token.
+function describeMcpConfig(data: { mcpServers?: unknown[]; mcpEndpoint?: { url: string; serverNames?: string[] } }): string {
+  const parts: string[] = [];
+  if (data.mcpServers && data.mcpServers.length > 0) {
+    parts.push(`mcpServers=${data.mcpServers.length}`);
+  }
+  if (data.mcpEndpoint) {
+    parts.push(`mcpEndpoint(url=${data.mcpEndpoint.url}, serverNames=${JSON.stringify(data.mcpEndpoint.serverNames ?? null)})`);
+  }
+  return parts.length > 0 ? `mcp=[${parts.join(' ')}]` : 'mcp=[none]';
 }
 
 interface AcpCancelPayload {
@@ -63,6 +79,29 @@ interface AcpStopPayload {
   sessionId: string;
 }
 
+interface AcpSetConfigOptionPayload {
+  sessionId: string;
+  configId: string;
+  value: string | boolean;
+}
+
+interface AcpDeleteHistorySessionPayload {
+  requestId: string;
+  sessionId: string;
+  externalSessionId: string;
+  cwd: string;
+  serverType?: string;
+}
+
+interface AcpAuthenticatePayload {
+  sessionId: string;
+  methodId: string;
+}
+
+interface AcpLogoutPayload {
+  sessionId: string;
+}
+
 interface AcpSetModePayload {
   sessionId: string;
   modeId: string;
@@ -79,12 +118,15 @@ interface AcpResumePayload {
   externalSessionId: string;
   serverType: string;
   cwd: string;
+  mcpEndpoint?: { url: string; token: string; serverNames: string[] };
+  additionalDirectories?: string[];
 }
 
 interface AcpListSessionsPayload {
   requestId: string;
   serverType: string;
   cwd: string;
+  cursor?: string | null;
 }
 
 interface AcpLoadSessionPayload {
@@ -218,7 +260,7 @@ export function connectToServer(
   });
 
   socket.on('acp:start', async (data: AcpStartPayload) => {
-    console.log(`[ACP ctrl] acp:start received: requestId=${data.requestId} sessionId=${data.sessionId} serverType=${data.serverType} cwd=${data.cwd}`);
+    console.log(`[ACP ctrl] acp:start received: requestId=${data.requestId} sessionId=${data.sessionId} serverType=${data.serverType} cwd=${data.cwd} ${describeMcpConfig(data)}`);
 
     try {
       const spawner = createSpawner(data.serverType, data.sessionId, data.cwd);
@@ -226,6 +268,8 @@ export function connectToServer(
         sessionId: data.sessionId,
         cwd: data.cwd,
         mcpServers: data.mcpServers,
+        mcpEndpoint: data.mcpEndpoint,
+        additionalDirectories: data.additionalDirectories,
       }, spawner);
 
       acpBridges.set(data.sessionId, bridge);
@@ -234,6 +278,10 @@ export function connectToServer(
         permissionRequestBridge.set(requestId, bridge);
       });
 
+      bridge.on('elicitation:sent', (requestId: string) => {
+        elicitationRequestBridge.set(requestId, bridge);
+      });
+
       const onInitialized = (payload: Record<string, unknown>) => {
         if (payload.sessionId !== data.sessionId) return;
         bridge.off('acp:initialized', onInitialized);
@@ -250,6 +298,13 @@ export function connectToServer(
         if (payload.currentModel) result.currentModel = payload.currentModel;
         result.availableModels = payload.availableModels ?? [];
         if (payload.currentModelId) result.currentModelId = payload.currentModelId;
+        result.configOptions = payload.configOptions ?? [];
+        if (payload.promptCapabilities) result.promptCapabilities = payload.promptCapabilities;
+        if (payload.agentInfo) result.agentInfo = payload.agentInfo;
+        if (payload.authMethods) result.authMethods = payload.authMethods;
+        if (payload.supportsAdditionalDirectories != null) {
+          result.supportsAdditionalDirectories = payload.supportsAdditionalDirectories;
+        }
         socket.emit('acp:start:result', result);
       };
 
@@ -258,7 +313,7 @@ export function connectToServer(
         bridge.off('acp:initialized', onInitialized);
         bridge.off('acp:stopped', onStopped);
         acpBridges.delete(data.sessionId);
-        console.log(`[ACP ctrl] emitting acp:start:result: requestId=${data.requestId} sessionId=${data.sessionId} success=false`);
+        console.log(`[ACP ctrl] emitting acp:start:result: requestId=${data.requestId} sessionId=${data.sessionId} success=false reason=${payload.reason} error=${payload.error ?? 'n/a'}`);
         socket.emit('acp:start:result', {
           requestId: data.requestId,
           sessionId: data.sessionId,
@@ -284,13 +339,15 @@ export function connectToServer(
   });
 
   socket.on('acp:resume', async (data: AcpResumePayload) => {
-    console.log(`[ACP ctrl] acp:resume received: requestId=${data.requestId} sessionId=${data.sessionId} serverType=${data.serverType} externalSessionId=${data.externalSessionId}`);
+    console.log(`[ACP ctrl] acp:resume received: requestId=${data.requestId} sessionId=${data.sessionId} serverType=${data.serverType} externalSessionId=${data.externalSessionId} ${describeMcpConfig(data)}`);
 
     try {
       const spawner = createSpawner(data.serverType, data.sessionId, data.cwd);
       const bridge = new AcpSessionBridge(socket, {
         sessionId: data.sessionId,
         cwd: data.cwd,
+        mcpEndpoint: data.mcpEndpoint,
+        additionalDirectories: data.additionalDirectories,
       }, spawner);
 
       acpBridges.set(data.sessionId, bridge);
@@ -299,6 +356,10 @@ export function connectToServer(
         permissionRequestBridge.set(requestId, bridge);
       });
 
+      bridge.on('elicitation:sent', (requestId: string) => {
+        elicitationRequestBridge.set(requestId, bridge);
+      });
+
       const onInitialized = (payload: Record<string, unknown>) => {
         if (payload.sessionId !== data.sessionId) return;
         bridge.off('acp:initialized', onInitialized);
@@ -313,6 +374,10 @@ export function connectToServer(
         if (payload.currentModel) result.currentModel = payload.currentModel;
         result.availableModels = payload.availableModels ?? [];
         if (payload.currentModelId) result.currentModelId = payload.currentModelId;
+        result.configOptions = payload.configOptions ?? [];
+        if (payload.promptCapabilities) result.promptCapabilities = payload.promptCapabilities;
+        if (payload.agentInfo) result.agentInfo = payload.agentInfo;
+        if (payload.authMethods) result.authMethods = payload.authMethods;
         socket.emit('acp:resume:result', result);
       };
 
@@ -321,6 +386,7 @@ export function connectToServer(
         bridge.off('acp:initialized', onInitialized);
         bridge.off('acp:stopped', onStopped);
         acpBridges.delete(data.sessionId);
+        console.log(`[ACP ctrl] emitting acp:resume:result: requestId=${data.requestId} sessionId=${data.sessionId} success=false reason=${payload.reason} error=${payload.error ?? 'n/a'}`);
         socket.emit('acp:resume:result', {
           requestId: data.requestId,
           sessionId: data.sessionId,
@@ -351,7 +417,7 @@ export function connectToServer(
     const bridge = new AcpSyncBridge({ cwd: data.cwd }, spawner);
     try {
       await bridge.connect();
-      const result = await bridge.listSessions(data.cwd);
+      const result = await bridge.listSessions(data.cwd, data.cursor);
       await bridge.disconnect();
       socket.emit('acp:list-sessions:result', {
         requestId: data.requestId,
@@ -362,6 +428,7 @@ export function connectToServer(
           cwd: s.cwd,
           updatedAt: s.updatedAt ?? null,
         })),
+        ...(result.nextCursor ? { nextCursor: result.nextCursor } : {}),
       });
     } catch (error) {
       await bridge.disconnect().catch(() => {});
@@ -509,6 +576,118 @@ export function connectToServer(
     }
   });
 
+  socket.on('acp:set-config-option', (data: AcpSetConfigOptionPayload) => {
+    console.log(`[ACP] acp:set-config-option received: sessionId=${data.sessionId} configId=${data.configId}`);
+    const bridge = acpBridges.get(data.sessionId);
+    if (!bridge) {
+      socket.emit('acp:set-config-option:result', {
+        sessionId: data.sessionId,
+        success: false,
+        configId: data.configId,
+        error: 'ACP bridge not found for session',
+      });
+      return;
+    }
+    // 成功时 bridge 内部已用响应快照更新 configOptions 并 emit acp:config-options
+    bridge.setConfigOption(data.configId, data.value).then(
+      () => {
+        socket.emit('acp:set-config-option:result', {
+          sessionId: data.sessionId,
+          success: true,
+          configId: data.configId,
+        });
+      },
+      (err) => {
+        console.error(`[ACP] setConfigOption failed: ${(err as Error).message}`);
+        socket.emit('acp:set-config-option:result', {
+          sessionId: data.sessionId,
+          success: false,
+          configId: data.configId,
+          error: (err as Error).message,
+        });
+      },
+    );
+  });
+
+  socket.on('acp:delete-history-session', async (data: AcpDeleteHistorySessionPayload) => {
+    const serverType = data.serverType ?? 'opencode';
+    console.log(`[ACP sync] acp:delete-history-session received: sessionId=${data.externalSessionId} cwd=${data.cwd}`);
+    const spawner = createSpawner(serverType, `sync_${Date.now()}`, data.cwd);
+    const bridge = new AcpSyncBridge({ cwd: data.cwd }, spawner);
+    try {
+      await bridge.connect();
+      if (!bridge.supportsDelete()) {
+        await bridge.disconnect().catch(() => {});
+        socket.emit('acp:delete-history-session:result', {
+          requestId: data.requestId,
+          sessionId: data.sessionId,
+          success: false,
+          supported: false,
+          error: 'Session delete not supported by agent',
+        });
+        return;
+      }
+      await bridge.deleteSession(data.externalSessionId);
+      await bridge.disconnect();
+      socket.emit('acp:delete-history-session:result', {
+        requestId: data.requestId,
+        sessionId: data.sessionId,
+        success: true,
+        supported: true,
+      });
+    } catch (error) {
+      await bridge.disconnect().catch(() => {});
+      console.error(`[ACP sync] delete-history-session failed: ${(error as Error).message}`);
+      socket.emit('acp:delete-history-session:result', {
+        requestId: data.requestId,
+        sessionId: data.sessionId,
+        success: false,
+        supported: true,
+        error: (error as Error).message,
+      });
+    }
+  });
+
+  socket.on('acp:authenticate', async (data: AcpAuthenticatePayload) => {
+    console.log(`[ACP] acp:authenticate received: sessionId=${data.sessionId} methodId=${data.methodId}`);
+    const bridge = acpBridges.get(data.sessionId);
+    try {
+      if (!bridge) throw new Error('ACP bridge not found for session');
+      await bridge.authenticate(data.methodId);
+      socket.emit('acp:authenticate:result', {
+        sessionId: data.sessionId,
+        success: true,
+      });
+    } catch (error) {
+      console.error(`[ACP] authenticate failed: ${(error as Error).message}`);
+      socket.emit('acp:authenticate:result', {
+        sessionId: data.sessionId,
+        success: false,
+        error: (error as Error).message,
+      });
+    }
+  });
+
+  socket.on('acp:logout', async (data: AcpLogoutPayload) => {
+    console.log(`[ACP] acp:logout received: sessionId=${data.sessionId}`);
+    const bridge = acpBridges.get(data.sessionId);
+    try {
+      if (!bridge) throw new Error('ACP bridge not found for session');
+      await bridge.logout();
+      socket.emit('acp:logout:result', {
+        sessionId: data.sessionId,
+        success: true,
+      });
+    } catch (error) {
+      console.error(`[ACP] logout failed: ${(error as Error).message}`);
+      socket.emit('acp:logout:result', {
+        sessionId: data.sessionId,
+        success: false,
+        error: (error as Error).message,
+      });
+    }
+  });
+
   // File system events
   socket.on('fs:browse', async (data: FsBrowsePayload) => {
     console.log(`FS browse requested: requestId=${data.requestId} path=${data.path}`);
@@ -617,11 +796,24 @@ export function connectToServer(
     }
   });
 
+  socket.on('acp:elicitation:response', (data: {
+    requestId: string;
+    action: 'accept' | 'decline' | 'cancel';
+    content?: Record<string, unknown>;
+  }) => {
+    const bridge = elicitationRequestBridge.get(data.requestId);
+    if (bridge) {
+      elicitationRequestBridge.delete(data.requestId);
+      bridge.handleElicitationResponse(data.requestId, data.action, data.content);
+    }
+  });
+
   socket.on('disconnect', (reason) => {
     console.log(`Disconnected: ${reason}`);
     heartbeat.stop();
     gatewayManager.closeAll();
     permissionRequestBridge.clear();
+    elicitationRequestBridge.clear();
   });
 
   socket.on('connect_error', (err) => {