agent-gear 1.1.6 → 1.1.8

package/src/acp/prober.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { mockNewSession, mockInitialize } = vi.hoisted(() => {
+  const mockNewSession = vi.fn().mockResolvedValue({ sessionId: 'acp-probe-1' });
+  const mockInitialize = vi.fn().mockResolvedValue({ protocolVersion: 1 });
+  return { mockNewSession, mockInitialize };
+});
+
+vi.mock('@agentclientprotocol/sdk', () => ({
+  ndJsonStream: vi.fn(() => ({})),
+  ClientSideConnection: vi.fn(function () {
+    return {
+      initialize: mockInitialize,
+      newSession: mockNewSession,
+      prompt: vi.fn().mockResolvedValue({ stopReason: 'end_turn' }),
+      cancel: vi.fn().mockResolvedValue(undefined),
+      closeSession: vi.fn().mockResolvedValue({}),
+      setSessionMode: vi.fn().mockResolvedValue({}),
+      setSessionConfigOption: vi.fn().mockResolvedValue({}),
+    };
+  }),
+}));
+
+const mockSpawnerStop = vi.fn();
+vi.mock('./spawner.js', () => ({
+  AcpSpawner: vi.fn(function () {
+    return {
+      start: vi.fn(),
+      stop: mockSpawnerStop,
+      isRunning: vi.fn().mockReturnValue(true),
+      stdin: new WritableStream(),
+      stdout: new ReadableStream(),
+      closed: Promise.resolve(),
+    };
+  }),
+}));
+
+import { probeAcpServerOptions } from './prober.js';
+
+describe('probeAcpServerOptions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('session/new 返回 modes + configOptions 时提取 Mode/模型选项并关闭进程', async () => {
+    mockInitialize.mockResolvedValue({ protocolVersion: 1 });
+    mockNewSession.mockResolvedValue({
+      sessionId: 'acp-probe-1',
+      modes: {
+        availableModes: [
+          { id: 'code', name: 'Code', description: '编码模式' },
+          { id: 'ask', name: 'Ask' },
+        ],
+        currentModeId: 'code',
+      },
+      configOptions: [
+        {
+          id: 'model',
+          name: 'Model',
+          category: 'model',
+          type: 'select',
+          currentValue: 'gpt-5',
+          options: [
+            { value: 'gpt-5', name: 'GPT-5' },
+            { value: 'claude-4', name: 'Claude 4' },
+          ],
+        },
+      ],
+    });
+
+    const result = await probeAcpServerOptions('opencode');
+
+    expect(result.modes).toEqual([
+      { id: 'code', name: 'Code', description: '编码模式' },
+      { id: 'ask', name: 'Ask', description: undefined },
+    ]);
+    expect(result.currentModeId).toBe('code');
+    expect(result.availableModels).toEqual([
+      { id: 'gpt-5', name: 'GPT-5' },
+      { id: 'claude-4', name: 'Claude 4' },
+    ]);
+    expect(result.currentModelId).toBe('gpt-5');
+    expect(mockSpawnerStop).toHaveBeenCalled();
+  });
+
+  it('Agent 无 modes/models 时返回空数组而非失败', async () => {
+    mockNewSession.mockResolvedValue({ sessionId: 'acp-probe-2' });
+
+    const result = await probeAcpServerOptions('opencode');
+
+    expect(result.modes).toEqual([]);
+    expect(result.availableModels).toEqual([]);
+    expect(result.currentModeId).toBeNull();
+    expect(result.currentModelId).toBeNull();
+  });
+
+  it('initialize 失败时 reject 并关闭进程', async () => {
+    mockInitialize.mockRejectedValueOnce(new Error('handshake failed'));
+
+    await expect(probeAcpServerOptions('opencode')).rejects.toThrow('handshake failed');
+    expect(mockSpawnerStop).toHaveBeenCalled();
+  });
+});

package/src/acp/prober.ts

@@ -0,0 +1,73 @@
+import { homedir } from 'os';
+import type { Socket } from 'socket.io-client';
+import { acpDetector } from './detector.js';
+import { AcpSpawner } from './spawner.js';
+import { AcpSessionBridge, type AcpInitializedPayload } from './bridge.js';
+
+export interface AcpServerOptionsProbeResult {
+  modes: Array<{ id: string; name: string; description?: string }>;
+  availableModels: Array<{ id: string; name: string; provider?: string }>;
+  currentModeId: string | null;
+  currentModelId: string | null;
+}
+
+/**
+ * 空实例探测：临时拉起指定 ACP 工具进程（initialize + session/new），
+ * 收集 Mode/模型选项后立即关闭。用于配置阶段动态获取可选选项，
+ * 避免用户手填 modeId/modelId。
+ *
+ * 探测会话不与服务端交互：bridge 发出的 socket 事件全部丢弃。
+ * 任一环节失败（CLI 不存在 / 需要认证 / 超时）都会 reject，由调用方降级处理。
+ */
+export async function probeAcpServerOptions(
+  serverType: string,
+  timeoutMs = 20000,
+): Promise<AcpServerOptionsProbeResult> {
+  const sessionId = `probe-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const config = acpDetector.getSpawnerConfig(serverType);
+  const cwd = homedir();
+  const spawner = new AcpSpawner({ sessionId, cwd, command: config.command, args: config.args });
+  const noopSocket = { emit: () => false } as unknown as Socket;
+  const bridge = new AcpSessionBridge(noopSocket, { sessionId, cwd }, spawner);
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      finish(() => reject(new Error(`probe timeout after ${timeoutMs}ms: ${serverType}`)));
+    }, timeoutMs);
+
+    const cleanup = () => {
+      clearTimeout(timer);
+      bridge.stop().catch(() => { /* ignore */ });
+      spawner.stop();
+    };
+
+    const finish = (fn: () => void) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      fn();
+    };
+
+    bridge.on('acp:initialized', (payload: AcpInitializedPayload) => {
+      finish(() =>
+        resolve({
+          modes: payload.modes ?? [],
+          availableModels: payload.availableModels ?? [],
+          currentModeId: payload.currentModeId ?? null,
+          currentModelId: payload.currentModelId ?? null,
+        }),
+      );
+    });
+
+    bridge.on('acp:stopped', (payload: { reason: string; error?: string }) => {
+      finish(() =>
+        reject(new Error(payload.error ?? `ACP process stopped during probe: ${payload.reason}`)),
+      );
+    });
+
+    bridge.start().catch((error: unknown) => {
+      finish(() => reject(error instanceof Error ? error : new Error(String(error))));
+    });
+  });
+}

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

@@ -124,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

@@ -7,6 +7,7 @@ import { homedir } from 'os';
 import { Heartbeat } from './heartbeat.js';
 import { clearConfigKey, saveKeyToConfig, saveEndpointToConfig, getResumeTokenFromConfig, saveResumeTokenToConfig, clearResumeTokenFromConfig } from './config.js';
 import { acpDetector } from './acp/detector.js';
+import { probeAcpServerOptions } from './acp/prober.js';
 import { AcpSpawner } from './acp/spawner.js';
 import { AcpSessionBridge } from './acp/bridge.js';
 import { AcpSyncBridge } from './acp/sync-bridge.js';
@@ -18,6 +19,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);
@@ -42,12 +44,18 @@ interface AcpCheckPayload {
   requestId: string;
 }
 
+interface AcpProbeOptionsPayload {
+  requestId: string;
+  serverType: string;
+}
+
 interface AcpStartPayload {
   requestId: string;
   sessionId: string;
   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[];
 }
 
@@ -56,6 +64,19 @@ interface AcpMessagePayload {
   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 {
   sessionId: string;
 }
@@ -103,6 +124,7 @@ interface AcpResumePayload {
   externalSessionId: string;
   serverType: string;
   cwd: string;
+  mcpEndpoint?: { url: string; token: string; serverNames: string[] };
   additionalDirectories?: string[];
 }
 
@@ -243,8 +265,31 @@ export function connectToServer(
     });
   });
 
+  // 空实例探测：拉起指定工具的临时会话，收集 Mode/模型选项后关闭
+  socket.on('acp:probe-options', async (data: AcpProbeOptionsPayload) => {
+    console.log(`[ACP ctrl] acp:probe-options received: requestId=${data.requestId} serverType=${data.serverType}`);
+    try {
+      const options = await probeAcpServerOptions(data.serverType);
+      console.log(`[ACP ctrl] probe-options success: serverType=${data.serverType} modes=${options.modes.length} models=${options.availableModels.length}`);
+      socket.emit('acp:probe-options:result', {
+        requestId: data.requestId,
+        serverType: data.serverType,
+        success: true,
+        ...options,
+      });
+    } catch (error) {
+      console.warn(`[ACP ctrl] probe-options failed: serverType=${data.serverType} error=${(error as Error).message}`);
+      socket.emit('acp:probe-options:result', {
+        requestId: data.requestId,
+        serverType: data.serverType,
+        success: false,
+        error: (error as Error).message,
+      });
+    }
+  });
+
   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);
@@ -252,6 +297,7 @@ export function connectToServer(
         sessionId: data.sessionId,
         cwd: data.cwd,
         mcpServers: data.mcpServers,
+        mcpEndpoint: data.mcpEndpoint,
         additionalDirectories: data.additionalDirectories,
       }, spawner);
 
@@ -261,6 +307,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);
@@ -292,7 +342,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,
@@ -318,13 +368,14 @@ 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);
 
@@ -334,6 +385,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);
@@ -360,6 +415,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,
@@ -769,11 +825,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) => {