agent-gear 1.1.0 → 1.1.2

package/src/config.ts

@@ -10,6 +10,7 @@ export interface ConfigData {
   key?: { value: string };
   server?: { endpoint: string };
   controller?: { name: string };
+  resumeToken?: { value: string };
 }
 
 export function readConfig(): ConfigData {
@@ -73,3 +74,20 @@ export function resolveEndpoint(cliEndpoint?: string): string | undefined {
   if (envEndpoint) return envEndpoint;
   return getEndpointFromConfig();
 }
+
+export function getResumeTokenFromConfig(): string | undefined {
+  const config = readConfig();
+  return config.resumeToken?.value;
+}
+
+export function saveResumeTokenToConfig(token: string): void {
+  const config = readConfig();
+  config.resumeToken = { value: token };
+  writeConfig(config);
+}
+
+export function clearResumeTokenFromConfig(): void {
+  const config = readConfig();
+  delete config.resumeToken;
+  writeConfig(config);
+}

package/src/index.ts

@@ -4,6 +4,8 @@ import { hostname } from 'os';
 import { resolveKey, resolveEndpoint, saveKeyToConfig, saveEndpointToConfig } from './config.js';
 import { connectToServer } from './socketio-client.js';
 import { writePid, removePid, isRunning } from './daemon.js';
+import { startMcpRegistration } from './commands/mcp-proxy.js';
+import { startMcpProxy } from './commands/mcp.js';
 
 const program = new Command();
 
@@ -56,4 +58,30 @@ program
     });
   });
 
+program
+  .command('mcp-proxy')
+  .description('Register a local MCP command as a proxy')
+  .requiredOption('--mcp-server <endpoint>', 'Server endpoint URL')
+  .requiredOption('--mcp-key <key>', 'MCP Proxy Key')
+  .requiredOption('--command <command>', 'Local MCP command to proxy')
+  .action(async (options) => {
+    await startMcpRegistration({
+      server: options.mcpServer,
+      key: options.mcpKey,
+      command: options.command,
+    });
+  });
+
+program
+  .command('mcp')
+  .description('Start stdio MCP proxy (HTTP to stdio)')
+  .requiredOption('--endpoint <url>', 'MCP forwarder endpoint URL')
+  .requiredOption('--token <token>', 'Bearer token for authentication')
+  .action(async (options) => {
+    await startMcpProxy({
+      endpoint: options.endpoint,
+      token: options.token,
+    });
+  });
+
 program.parse();

package/src/socketio-client.ts

@@ -1,10 +1,11 @@
 import { io as createSocketIOClient, type Socket } from 'socket.io-client';
+import * as acp from '@agentclientprotocol/sdk';
 import { hostname, platform } from 'os';
 import { readdir, access } from 'fs/promises';
 import { join } from 'path';
 import { homedir } from 'os';
 import { Heartbeat } from './heartbeat.js';
-import { clearConfigKey, saveKeyToConfig, saveEndpointToConfig } from './config.js';
+import { clearConfigKey, saveKeyToConfig, saveEndpointToConfig, getResumeTokenFromConfig, saveResumeTokenToConfig, clearResumeTokenFromConfig } from './config.js';
 import { acpDetector } from './acp/detector.js';
 import { AcpSpawner } from './acp/spawner.js';
 import { AcpSessionBridge } from './acp/bridge.js';
@@ -14,8 +15,9 @@ import { worktreeHandler } from './worktree-handler.js';
 import { fsHandler } from './fs-handler.js';
 import { portForwardManager } from './port-forward.js';
 
-const CONTROLLER_VERSION = '1.0.4';
+const CONTROLLER_VERSION = '1.1.1';
 const acpBridges = new Map<string, AcpSessionBridge>();
+const permissionRequestBridge = new Map<string, AcpSessionBridge>();
 
 function createSpawner(serverType: string, sessionId: string, cwd: string): AcpSpawner {
   const config = acpDetector.getSpawnerConfig(serverType);
@@ -24,6 +26,7 @@ function createSpawner(serverType: string, sessionId: string, cwd: string): AcpS
 
 interface RegisteredPayload {
   controllerId: string;
+  resumeToken?: string;
 }
 
 interface ErrorPayload {
@@ -155,22 +158,32 @@ export function connectToServer(
 
   socket.on('connect', () => {
     console.log(`Connected to ${endpoint}`);
+    const resumeToken = getResumeTokenFromConfig();
     socket.emit('register', {
       key,
       hostname: controllerName,
       version: CONTROLLER_VERSION,
+      resumeToken,
     });
   });
 
   socket.on('registered', (data: RegisteredPayload) => {
     console.log(`Controller registered: ${data.controllerId}`);
+    if (data.resumeToken) {
+      saveResumeTokenToConfig(data.resumeToken);
+      console.log('Resume token saved to config');
+    }
     heartbeat.start(() => socket.emit('heartbeat'));
   });
 
   socket.on('error', (data: ErrorPayload) => {
     console.error(`Server error: ${data.code} - ${data.message}`);
     if (data.code === 'KEY_ALREADY_ONLINE') {
-      console.error('This key is already in use on another machine.');
+      console.log('Clearing resume token and retrying connection...');
+      clearResumeTokenFromConfig();
+      // Don't exit, let the reconnection logic handle it
+      socket.disconnect();
+      return;
     }
     socket.disconnect();
     process.exit(1);
@@ -215,6 +228,10 @@ export function connectToServer(
 
       acpBridges.set(data.sessionId, bridge);
 
+      bridge.on('permission:sent', (requestId: string) => {
+        permissionRequestBridge.set(requestId, bridge);
+      });
+
       const onInitialized = (payload: Record<string, unknown>) => {
         if (payload.sessionId !== data.sessionId) return;
         bridge.off('acp:initialized', onInitialized);
@@ -226,10 +243,10 @@ export function connectToServer(
           success: true,
           externalSessionId: payload.acpSessionId,
         };
-        if (payload.modes) result.modes = payload.modes;
+        result.modes = payload.modes ?? [];
         if (payload.currentModeId) result.currentModeId = payload.currentModeId;
         if (payload.currentModel) result.currentModel = payload.currentModel;
-        if (payload.availableModels) result.availableModels = payload.availableModels;
+        result.availableModels = payload.availableModels ?? [];
         if (payload.currentModelId) result.currentModelId = payload.currentModelId;
         socket.emit('acp:start:result', result);
       };
@@ -276,6 +293,10 @@ export function connectToServer(
 
       acpBridges.set(data.sessionId, bridge);
 
+      bridge.on('permission:sent', (requestId: string) => {
+        permissionRequestBridge.set(requestId, bridge);
+      });
+
       const onInitialized = (payload: Record<string, unknown>) => {
         if (payload.sessionId !== data.sessionId) return;
         bridge.off('acp:initialized', onInitialized);
@@ -285,10 +306,10 @@ export function connectToServer(
           sessionId: data.sessionId,
           success: true,
         };
-        if (payload.modes) result.modes = payload.modes;
+        result.modes = payload.modes ?? [];
         if (payload.currentModeId) result.currentModeId = payload.currentModeId;
         if (payload.currentModel) result.currentModel = payload.currentModel;
-        if (payload.availableModels) result.availableModels = payload.availableModels;
+        result.availableModels = payload.availableModels ?? [];
         if (payload.currentModelId) result.currentModelId = payload.currentModelId;
         socket.emit('acp:resume:result', result);
       };
@@ -579,10 +600,22 @@ export function connectToServer(
     portForwardManager.closeTunnel(data.tunnelId);
   });
 
+  socket.on('acp:permission:response', (data: {
+    requestId: string;
+    outcome: { outcome: string; optionId?: string };
+  }) => {
+    const bridge = permissionRequestBridge.get(data.requestId);
+    if (bridge) {
+      permissionRequestBridge.delete(data.requestId);
+      bridge.handlePermissionResponse(data.requestId, data.outcome as acp.RequestPermissionOutcome);
+    }
+  });
+
   socket.on('disconnect', (reason) => {
     console.log(`Disconnected: ${reason}`);
     heartbeat.stop();
     portForwardManager.closeAll();
+    permissionRequestBridge.clear();
   });
 
   socket.on('connect_error', (err) => {

package/tests/acp-bridge.test.ts

@@ -449,18 +449,45 @@ describe('AcpSessionBridge', () => {
   });
 
   describe('requestPermission', () => {
-    it('should auto-accept with allow_once', async () => {
+    it('should emit acp:permission and wait for response', async () => {
       const bridge = createBridge();
-      const result = await bridge.requestPermission({
-        options: [
-          { optionId: 'opt-1', kind: 'allow_once', label: 'Allow' },
-          { optionId: 'opt-2', kind: 'reject', label: 'Reject' },
-        ],
+      const options = [
+        { optionId: 'opt-1', kind: 'allow_once', label: 'Allow' },
+        { optionId: 'opt-2', kind: 'reject', label: 'Reject' },
+      ];
+
+      const promise = bridge.requestPermission({
+        options,
+        toolCall: { toolCallId: 'tc-1' },
       } as never);
 
-      expect(result).toEqual({
-        outcome: { outcome: 'selected', optionId: 'opt-1' },
-      });
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:permission', expect.objectContaining({
+        sessionId: 'sess-1',
+        toolCall: { toolCallId: 'tc-1' },
+        options,
+      }));
+
+      const emitCall = mockSocket.emit.mock.calls.find((c: unknown[]) => c[0] === 'acp:permission');
+      const requestId = (emitCall![1] as { requestId: string }).requestId;
+
+      bridge.handlePermissionResponse(requestId, { outcome: 'selected', optionId: 'opt-1' });
+
+      const result = await promise;
+      expect(result).toEqual({ outcome: { outcome: 'selected', optionId: 'opt-1' } });
+    });
+
+    it('should resolve with cancelled on 65s timeout', async () => {
+      const bridge = createBridge();
+
+      const promise = bridge.requestPermission({
+        options: [{ optionId: 'opt-1', kind: 'allow_once', label: 'Allow' }],
+        toolCall: { toolCallId: 'tc-1' },
+      } as never);
+
+      await vi.advanceTimersByTimeAsync(65_000);
+
+      const result = await promise;
+      expect(result).toEqual({ outcome: { outcome: 'cancelled' } });
     });
   });
 
@@ -509,26 +536,26 @@ describe('AcpSessionBridge', () => {
   });
 
   describe('extractAvailableModels', () => {
-    it('should return null when models is null', () => {
+    it('should return empty array when models is null', () => {
       const bridge = createBridge();
 
       // Access private method via bracket notation
       const result = (bridge as unknown as Record<string, unknown>).extractAvailableModels(null);
-      expect(result).toBeNull();
+      expect(result).toEqual([]);
     });
 
-    it('should return null when models is undefined', () => {
+    it('should return empty array when models is undefined', () => {
       const bridge = createBridge();
 
       const result = (bridge as unknown as Record<string, unknown>).extractAvailableModels(undefined);
-      expect(result).toBeNull();
+      expect(result).toEqual([]);
     });
 
-    it('should return null when availableModels is missing', () => {
+    it('should return empty array when availableModels is missing', () => {
       const bridge = createBridge();
 
       const result = (bridge as unknown as Record<string, unknown>).extractAvailableModels({});
-      expect(result).toBeNull();
+      expect(result).toEqual([]);
     });
   });
 });

package/tests/commands/mcp-proxy.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('child_process', () => ({
+  spawn: vi.fn().mockReturnValue({
+    stdin: { write: vi.fn() },
+    stdout: { on: vi.fn(), removeListener: vi.fn() },
+    on: vi.fn(),
+    kill: vi.fn(),
+  }),
+}));
+
+vi.mock('socket.io-client', () => ({
+  io: vi.fn().mockReturnValue({
+    on: vi.fn(),
+    emit: vi.fn(),
+    disconnect: vi.fn(),
+    connected: true,
+  }),
+}));
+
+vi.mock('readline', () => ({
+  createInterface: vi.fn().mockReturnValue({
+    on: vi.fn(),
+  }),
+}));
+
+import { startMcpRegistration } from '../../src/commands/mcp-proxy.js';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+    json: () => Promise.resolve({ success: true, proxyId: 'proxy_1', serverId: 'server_1' }),
+  }));
+  vi.stubGlobal('process', {
+    ...process,
+    env: { HOSTNAME: 'test-host' },
+    on: vi.fn(),
+    exit: vi.fn(),
+  });
+});
+
+describe('mcp-proxy command', () => {
+  it('should register with server and spawn child process', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await startMcpRegistration({
+      server: 'http://localhost:4001',
+      key: 'mcp_test-key',
+      command: 'npx @modelcontextprotocol/server-github',
+    });
+
+    expect(fetch).toHaveBeenCalledWith('http://localhost:4001/api/mcp-proxy/register', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        key: 'mcp_test-key',
+        hostname: 'test-host',
+        command: 'npx @modelcontextprotocol/server-github',
+        serverName: '@modelcontextprotocol/server-github',
+      }),
+    });
+
+    consoleSpy.mockRestore();
+  });
+
+  it('should exit if registration fails', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      json: () => Promise.resolve({ success: false, error: 'Invalid key' }),
+    }));
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+
+    await startMcpRegistration({
+      server: 'http://localhost:4001',
+      key: 'invalid-key',
+      command: 'npx @modelcontextprotocol/server-github',
+    });
+
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    consoleErrorSpy.mockRestore();
+    processExitSpy.mockRestore();
+  });
+
+  it('should use correct option names for CLI parsing', () => {
+    // This test verifies that the CLI options are correctly named
+    // to avoid conflicts with global options
+    const { Command } = require('commander');
+    const program = new Command();
+    
+    program
+      .command('mcp-proxy')
+      .description('Register a local MCP command as a proxy')
+      .requiredOption('--mcp-server <endpoint>', 'Server endpoint URL')
+      .requiredOption('--mcp-key <key>', 'MCP Proxy Key')
+      .requiredOption('--command <command>', 'Local MCP command to proxy');
+
+    // Verify the command has the correct options
+    const cmd = program.commands.find((c: any) => c.name() === 'mcp-proxy');
+    expect(cmd).toBeDefined();
+    
+    const options = cmd.options.map((o: any) => o.long);
+    expect(options).toContain('--mcp-server');
+    expect(options).toContain('--mcp-key');
+    expect(options).toContain('--command');
+    
+    // Verify these don't conflict with global options
+    expect(options).not.toContain('--key');
+    expect(options).not.toContain('--server');
+  });
+});

package/tests/commands/mcp.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('readline', () => ({
+  createInterface: vi.fn().mockReturnValue({
+    on: vi.fn(),
+  }),
+}));
+
+import { startMcpProxy } from '../../src/commands/mcp.js';
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+    json: () => Promise.resolve({ jsonrpc: '2.0', id: 1, result: { tools: [] } }),
+  }));
+  vi.stubGlobal('process', {
+    ...process,
+    stdout: { write: vi.fn() },
+    exit: vi.fn(),
+  });
+});
+
+describe('mcp command', () => {
+  it('should start stdio proxy with endpoint and token', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const readline = await import('readline');
+    const mockRl = {
+      on: vi.fn(),
+    };
+    vi.mocked(readline.createInterface).mockReturnValue(mockRl as never);
+
+    await startMcpProxy({
+      endpoint: 'http://localhost:3002/mcp/session-1',
+      token: 'test-token',
+    });
+
+    expect(readline.createInterface).toHaveBeenCalledWith({ input: process.stdin });
+    expect(mockRl.on).toHaveBeenCalledWith('line', expect.any(Function));
+    expect(mockRl.on).toHaveBeenCalledWith('close', expect.any(Function));
+
+    consoleSpy.mockRestore();
+  });
+});

package/tests/socketio-client.test.ts

@@ -21,6 +21,9 @@ vi.mock('../src/config.js', () => ({
   clearConfigKey: vi.fn(),
   saveKeyToConfig: vi.fn(),
   saveEndpointToConfig: vi.fn(),
+  getResumeTokenFromConfig: vi.fn(),
+  saveResumeTokenToConfig: vi.fn(),
+  clearResumeTokenFromConfig: vi.fn(),
 }));
 
 vi.mock('os', () => ({
@@ -101,7 +104,8 @@ describe('SocketIO Client', () => {
       expect(mockSocket.emit).toHaveBeenCalledWith('register', {
         key: 'zag_k_1_abc123',
         hostname: 'my-machine',
-        version: '1.0.4',
+        version: '1.1.1',
+        resumeToken: undefined,
       });
     });
 
@@ -116,7 +120,8 @@ describe('SocketIO Client', () => {
       expect(mockSocket.emit).toHaveBeenCalledWith('register', {
         key: 'zag_k_1_abc123',
         hostname: 'test-machine',
-        version: '1.0.4',
+        version: '1.1.1',
+        resumeToken: undefined,
       });
     });