agent-gear 1.1.1 → 1.1.4

package/src/socketio-client.ts

@@ -13,7 +13,7 @@ import { AcpSyncBridge } from './acp/sync-bridge.js';
 import { gitHandler } from './git-handler.js';
 import { worktreeHandler } from './worktree-handler.js';
 import { fsHandler } from './fs-handler.js';
-import { portForwardManager } from './port-forward.js';
+import { gatewayManager } from './gateway.js';
 
 const CONTROLLER_VERSION = '1.1.1';
 const acpBridges = new Map<string, AcpSessionBridge>();
@@ -83,12 +83,14 @@ interface AcpResumePayload {
 
 interface AcpListSessionsPayload {
   requestId: string;
+  serverType: string;
   cwd: string;
 }
 
 interface AcpLoadSessionPayload {
   requestId: string;
   sessionId: string;
+  serverType: string;
   cwd: string;
 }
 
@@ -243,10 +245,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);
       };
@@ -306,10 +308,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);
       };
@@ -343,8 +345,10 @@ export function connectToServer(
   });
 
   socket.on('acp:list-sessions', async (data: AcpListSessionsPayload) => {
-    console.log(`[ACP sync] acp:list-sessions received: requestId=${data.requestId} cwd=${data.cwd}`);
-    const bridge = new AcpSyncBridge({ cwd: data.cwd });
+    const serverType = data.serverType ?? 'opencode';
+    console.log(`[ACP sync] acp:list-sessions received: requestId=${data.requestId} serverType=${serverType} cwd=${data.cwd}`);
+    const spawner = createSpawner(serverType, `sync_${Date.now()}`, data.cwd);
+    const bridge = new AcpSyncBridge({ cwd: data.cwd }, spawner);
     try {
       await bridge.connect();
       const result = await bridge.listSessions(data.cwd);
@@ -371,8 +375,10 @@ export function connectToServer(
   });
 
   socket.on('acp:load-session', async (data: AcpLoadSessionPayload) => {
-    console.log(`[ACP] load-session received: requestId=${data.requestId} sessionId=${data.sessionId} cwd=${data.cwd}`);
-    const bridge = new AcpSyncBridge({ cwd: data.cwd });
+    const serverType = data.serverType ?? 'opencode';
+    console.log(`[ACP] load-session received: requestId=${data.requestId} sessionId=${data.sessionId} serverType=${serverType} cwd=${data.cwd}`);
+    const spawner = createSpawner(serverType, `sync_${Date.now()}`, data.cwd);
+    const bridge = new AcpSyncBridge({ cwd: data.cwd }, spawner);
     try {
       await bridge.connect();
       const { config, updates } = await bridge.loadSession(data.sessionId, data.cwd);
@@ -585,19 +591,19 @@ export function connectToServer(
     socket.emit('git:commit:result', { requestId: data.requestId, ...result });
   });
 
-  // Port Forward events
+  // Port Forward events (event names kept unchanged for backward compatibility)
   socket.on('port-forward:create', async (data: { tunnelId: string; port: number }) => {
-    console.log(`Port forward create requested: tunnelId=${data.tunnelId} port=${data.port}`);
-    await portForwardManager.createTunnel(data.tunnelId, data.port, socket);
+    console.log(`Gateway tunnel create requested: tunnelId=${data.tunnelId} port=${data.port}`);
+    await gatewayManager.createTunnel(data.tunnelId, data.port, socket);
   });
 
   socket.on('port-forward:data', (data: { tunnelId: string; data: string }) => {
-    portForwardManager.handleTunnelData(data.tunnelId, data.data);
+    gatewayManager.handleTunnelData(data.tunnelId, data.data);
   });
 
   socket.on('port-forward:close', (data: { tunnelId: string }) => {
-    console.log(`Port forward close: tunnelId=${data.tunnelId}`);
-    portForwardManager.closeTunnel(data.tunnelId);
+    console.log(`Gateway tunnel close: tunnelId=${data.tunnelId}`);
+    gatewayManager.closeTunnel(data.tunnelId);
   });
 
   socket.on('acp:permission:response', (data: {
@@ -614,7 +620,7 @@ export function connectToServer(
   socket.on('disconnect', (reason) => {
     console.log(`Disconnected: ${reason}`);
     heartbeat.stop();
-    portForwardManager.closeAll();
+    gatewayManager.closeAll();
     permissionRequestBridge.clear();
   });
 

package/tests/acp-bridge.test.ts

@@ -536,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/acp-detector.test.ts

@@ -32,71 +32,98 @@ describe('AcpDetector', () => {
   });
 
   describe('detect', () => {
-    it('should detect opencode and github_copilot when both available', async () => {
+    it('should detect all 5 servers when all available', async () => {
       mockExecSuccessOnce('opencode v1.2.3\n');
       mockExecSuccessOnce('copilot 1.0.0\n');
+      mockExecSuccessOnce('claude-agent-acp 0.1.0\n');
+      mockExecSuccessOnce('gemini 2.0.0\n');
+      mockExecSuccessOnce('codex-acp 0.5.0\n');
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(2);
+      expect(result).toHaveLength(5);
       expect(result[0]).toEqual({ type: 'opencode', available: true, version: '1.2.3' });
       expect(result[1]).toEqual({ type: 'github_copilot', available: true, version: '1.0.0' });
+      expect(result[2]).toEqual({ type: 'claude_code', available: true, version: '0.1.0' });
+      expect(result[3]).toEqual({ type: 'gemini_cli', available: true, version: '2.0.0' });
+      expect(result[4]).toEqual({ type: 'codex', available: true, version: '0.5.0' });
     });
 
     it('should detect as unavailable when command fails', async () => {
       mockExecFailureOnce();
       mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(2);
+      expect(result).toHaveLength(5);
       expect(result[0]).toEqual({ type: 'opencode', available: false });
       expect(result[1]).toEqual({ type: 'github_copilot', available: false });
+      expect(result[2]).toEqual({ type: 'claude_code', available: false });
+      expect(result[3]).toEqual({ type: 'gemini_cli', available: false });
+      expect(result[4]).toEqual({ type: 'codex', available: false });
     });
 
-    it('should parse version with different formats', async () => {
-      mockExecSuccessOnce('OpenCode version 2.0.1\n');
-      mockExecSuccessOnce('copilot 3.0.0\n');
+    it('should detect claude_code only when other servers fail', async () => {
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecSuccessOnce('claude-agent-acp 0.1.0\n');
+      mockExecFailureOnce();
+      mockExecFailureOnce();
 
       const result = await detector.detect();
 
-      expect(result[0].version).toBe('2.0.1');
-      expect(result[1].version).toBe('3.0.0');
+      expect(result).toHaveLength(5);
+      expect(result[0]).toEqual({ type: 'opencode', available: false });
+      expect(result[1]).toEqual({ type: 'github_copilot', available: false });
+      expect(result[2]).toEqual({ type: 'claude_code', available: true, version: '0.1.0' });
+      expect(result[3]).toEqual({ type: 'gemini_cli', available: false });
+      expect(result[4]).toEqual({ type: 'codex', available: false });
     });
 
-    it('should return unknown version when format not recognized', async () => {
-      mockExecSuccessOnce('some output without version\n');
-      mockExecSuccessOnce('copilot output\n');
+    it('should detect gemini_cli only when other servers fail', async () => {
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecSuccessOnce('gemini 2.0.0\n');
+      mockExecFailureOnce();
 
       const result = await detector.detect();
 
-      expect(result[0].version).toBe('unknown');
-      expect(result[1].version).toBe('unknown');
+      expect(result).toHaveLength(5);
+      expect(result[3]).toEqual({ type: 'gemini_cli', available: true, version: '2.0.0' });
     });
 
-    it('should detect only opencode when copilot fails', async () => {
-      mockExecSuccessOnce('opencode v1.2.3\n');
+    it('should detect codex only when other servers fail', async () => {
+      mockExecFailureOnce();
+      mockExecFailureOnce();
       mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecSuccessOnce('codex-acp 0.5.0\n');
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual({ type: 'opencode', available: true, version: '1.2.3' });
-      expect(result[1]).toEqual({ type: 'github_copilot', available: false });
+      expect(result).toHaveLength(5);
+      expect(result[4]).toEqual({ type: 'codex', available: true, version: '0.5.0' });
     });
 
-    it('should detect only copilot when opencode fails', async () => {
-      mockExecFailureOnce();
-      mockExecSuccessOnce('copilot 1.0.0\n');
+    it('should parse version with different formats', async () => {
+      mockExecSuccessOnce('OpenCode version 2.0.1\n');
+      mockExecSuccessOnce('copilot 3.0.0\n');
+      mockExecSuccessOnce('v0.1.0\n');
+      mockExecSuccessOnce('Gemini 2.0.0\n');
+      mockExecSuccessOnce('codex-acp version 0.5.0\n');
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual({ type: 'opencode', available: false });
-      expect(result[1]).toEqual({ type: 'github_copilot', available: true, version: '1.0.0' });
+      expect(result[0].version).toBe('2.0.1');
+      expect(result[1].version).toBe('3.0.0');
+      expect(result[2].version).toBe('0.1.0');
+      expect(result[3].version).toBe('2.0.0');
+      expect(result[4].version).toBe('0.5.0');
     });
-
-
   });
 
   describe('getSpawnerConfig', () => {
@@ -110,6 +137,21 @@ describe('AcpDetector', () => {
       expect(config).toEqual({ command: 'copilot', args: ['--acp', '--stdio'] });
     });
 
+    it('should return claude_code spawner config', () => {
+      const config = detector.getSpawnerConfig('claude_code');
+      expect(config).toEqual({ command: 'claude-agent-acp', args: [] });
+    });
+
+    it('should return gemini_cli spawner config', () => {
+      const config = detector.getSpawnerConfig('gemini_cli');
+      expect(config).toEqual({ command: 'gemini', args: ['--acp'] });
+    });
+
+    it('should return codex spawner config', () => {
+      const config = detector.getSpawnerConfig('codex');
+      expect(config).toEqual({ command: 'codex-acp', args: [] });
+    });
+
     it('should return opencode as default for unknown serverType', () => {
       const config = detector.getSpawnerConfig('unknown_server');
       expect(config).toEqual({ command: 'opencode', args: ['acp'] });

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/dist/port-forward.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"port-forward.d.ts","sourceRoot":"","sources":["../src/port-forward.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAQ/C,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,OAAO,CAAkC;IAE3C,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDvF,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAStD,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQnC,QAAQ,IAAI,IAAI;CAOjB;AAED,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}

package/dist/port-forward.js

@@ -1,68 +0,0 @@
-import net from 'node:net';
-export class PortForwardManager {
-    tunnels = new Map();
-    async createTunnel(tunnelId, port, serverSocket) {
-        const localSocket = net.connect({ host: '127.0.0.1', port });
-        return new Promise((resolve) => {
-            const onError = (err) => {
-                console.error(`Port forward tunnel error: tunnelId=${tunnelId} error=${err.message}`);
-                serverSocket.emit('port-forward:created', {
-                    tunnelId,
-                    success: false,
-                    error: err.message,
-                });
-                localSocket.destroy();
-                resolve();
-            };
-            localSocket.once('error', onError);
-            localSocket.once('connect', () => {
-                localSocket.removeListener('error', onError);
-                this.tunnels.set(tunnelId, { id: tunnelId, port, localSocket });
-                console.log(`Port forward tunnel created: tunnelId=${tunnelId} port=${port}`);
-                serverSocket.emit('port-forward:created', { tunnelId, success: true });
-                localSocket.on('data', (data) => {
-                    serverSocket.emit('port-forward:data', {
-                        tunnelId,
-                        data: data.toString('base64'),
-                    });
-                });
-                localSocket.on('close', () => {
-                    console.log(`Port forward local socket closed: tunnelId=${tunnelId}`);
-                    this.tunnels.delete(tunnelId);
-                    serverSocket.emit('port-forward:close', { tunnelId });
-                });
-                localSocket.on('error', (err) => {
-                    console.error(`Port forward local socket error: tunnelId=${tunnelId} error=${err.message}`);
-                    this.tunnels.delete(tunnelId);
-                    serverSocket.emit('port-forward:error', { tunnelId, error: err.message });
-                });
-                resolve();
-            });
-        });
-    }
-    handleTunnelData(tunnelId, data) {
-        const tunnel = this.tunnels.get(tunnelId);
-        if (!tunnel) {
-            console.warn(`Port forward data for unknown tunnel: tunnelId=${tunnelId}`);
-            return;
-        }
-        tunnel.localSocket.write(Buffer.from(data, 'base64'));
-    }
-    closeTunnel(tunnelId) {
-        const tunnel = this.tunnels.get(tunnelId);
-        if (!tunnel)
-            return;
-        console.log(`Port forward closing tunnel: tunnelId=${tunnelId}`);
-        tunnel.localSocket.destroy();
-        this.tunnels.delete(tunnelId);
-    }
-    closeAll() {
-        console.log(`Port forward closing all tunnels: count=${this.tunnels.size}`);
-        for (const tunnel of this.tunnels.values()) {
-            tunnel.localSocket.destroy();
-        }
-        this.tunnels.clear();
-    }
-}
-export const portForwardManager = new PortForwardManager();
-//# sourceMappingURL=port-forward.js.map

package/dist/port-forward.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"port-forward.js","sourceRoot":"","sources":["../src/port-forward.ts"],"names":[],"mappings":"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"}

package/dist/port-forward.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=port-forward.test.d.ts.map

package/dist/port-forward.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"port-forward.test.d.ts","sourceRoot":"","sources":["../src/port-forward.test.ts"],"names":[],"mappings":""}