agent-gear 1.1.2 → 1.1.5

package/src/gateway.ts

@@ -0,0 +1,195 @@
+import net from 'node:net';
+import type { Socket } from 'socket.io-client';
+
+interface Tunnel {
+  id: string;
+  port: number;
+  localSocket: net.Socket | null;
+  serverSocket: Socket;
+  pendingRequestId?: string | null;
+  responseBuffer: Buffer[];
+  responseTimer?: ReturnType<typeof setTimeout> | null;
+}
+
+const RECONNECT_INTERVAL_MS = 3000;
+const HTTP_RESPONSE_COLLECT_MS = 100;
+
+export class GatewayManager {
+  private tunnels: Map<string, Tunnel> = new Map();
+  private reconnectTimers: Map<string, ReturnType<typeof setTimeout>> = new Map();
+
+  async createTunnel(tunnelId: string, port: number, serverSocket: Socket): Promise<void> {
+    this.tunnels.set(tunnelId, { id: tunnelId, port, localSocket: null, serverSocket, responseBuffer: [] });
+    await this.connect(tunnelId, true);
+  }
+
+  private async connect(tunnelId: string, isInitial: boolean): Promise<void> {
+    const tunnel = this.tunnels.get(tunnelId);
+    if (!tunnel) return;
+
+    const localSocket = net.connect({ host: '127.0.0.1', port: tunnel.port });
+    localSocket.setKeepAlive(true, 5000);
+
+    return new Promise<void>((resolve) => {
+      const onError = (err: Error) => {
+        console.error(`Gateway tunnel error: tunnelId=${tunnelId} error=${err.message}`);
+        localSocket.destroy();
+        this.scheduleReconnect(tunnelId);
+        resolve();
+      };
+
+      localSocket.once('error', onError);
+
+      localSocket.once('connect', () => {
+        localSocket.removeListener('error', onError);
+
+        tunnel.localSocket = localSocket;
+        console.log(`Gateway tunnel connected: tunnelId=${tunnelId} port=${tunnel.port}`);
+
+        if (isInitial) {
+          tunnel.serverSocket.emit('port-forward:created', { tunnelId, success: true });
+        }
+
+        localSocket.on('data', (data: Buffer) => {
+          if (tunnel.pendingRequestId) {
+            tunnel.responseBuffer.push(data);
+            if (tunnel.responseTimer) clearTimeout(tunnel.responseTimer);
+            tunnel.responseTimer = setTimeout(() => this.flushResponse(tunnel), HTTP_RESPONSE_COLLECT_MS);
+          } else {
+            tunnel.serverSocket.emit('port-forward:data', {
+              tunnelId,
+              data: data.toString('base64'),
+            });
+          }
+        });
+
+        localSocket.on('close', () => {
+          console.log(`Gateway local socket closed: tunnelId=${tunnelId}`);
+          tunnel.localSocket = null;
+          this.scheduleReconnect(tunnelId);
+        });
+
+        localSocket.on('error', (err: Error) => {
+          console.error(`Gateway local socket error: tunnelId=${tunnelId} error=${err.message}`);
+          tunnel.serverSocket.emit('port-forward:error', { tunnelId, error: err.message });
+        });
+
+        resolve();
+      });
+    });
+  }
+
+  private flushResponse(tunnel: Tunnel): void {
+    if (!tunnel.pendingRequestId) return;
+    const combined = Buffer.concat(tunnel.responseBuffer);
+    tunnel.responseBuffer = [];
+    const requestId = tunnel.pendingRequestId;
+    tunnel.pendingRequestId = null;
+    tunnel.responseTimer = null;
+
+    tunnel.serverSocket.emit('port-forward:data', {
+      tunnelId: tunnel.id,
+      data: Buffer.from(JSON.stringify({
+        type: 'http-response',
+        requestId,
+        body: combined.toString('base64'),
+      })).toString('base64'),
+    });
+  }
+
+  private scheduleReconnect(tunnelId: string): void {
+    if (!this.tunnels.has(tunnelId) || this.reconnectTimers.has(tunnelId)) return;
+
+    console.log(`Gateway scheduling reconnection: tunnelId=${tunnelId}`);
+    const timer = setTimeout(() => {
+      this.reconnectTimers.delete(tunnelId);
+      this.connect(tunnelId, false);
+    }, RECONNECT_INTERVAL_MS);
+
+    this.reconnectTimers.set(tunnelId, timer);
+  }
+
+  handleTunnelData(tunnelId: string, data: string): void {
+    const tunnel = this.tunnels.get(tunnelId);
+    if (!tunnel) {
+      console.warn(`Gateway data for unknown tunnel: tunnelId=${tunnelId}`);
+      return;
+    }
+
+    const buffer = Buffer.from(data, 'base64');
+    let parsed: any;
+    try {
+      parsed = JSON.parse(buffer.toString('utf8'));
+    } catch {
+      if (tunnel.localSocket) {
+        tunnel.localSocket.write(buffer);
+      }
+      return;
+    }
+
+    if (parsed.type === 'http-request') {
+      const { method, path, headers, body } = parsed;
+      let rawRequest = `${method} ${path} HTTP/1.1\r\n`;
+      for (const [key, value] of Object.entries(headers || {})) {
+        rawRequest += `${key}: ${value}\r\n`;
+      }
+      rawRequest += `Host: 127.0.0.1:${tunnel.port}\r\n`;
+      rawRequest += 'Connection: close\r\n';
+      rawRequest += '\r\n';
+      if (body) rawRequest += Buffer.from(body, 'base64').toString('utf8');
+
+      tunnel.pendingRequestId = parsed.requestId;
+      tunnel.responseBuffer = [];
+
+      if (tunnel.localSocket) {
+        tunnel.localSocket.write(rawRequest);
+      }
+      return;
+    }
+
+    if (tunnel.localSocket) {
+      tunnel.localSocket.write(buffer);
+    }
+  }
+
+  closeTunnel(tunnelId: string): void {
+    const tunnel = this.tunnels.get(tunnelId);
+    if (!tunnel) return;
+
+    console.log(`Gateway closing tunnel: tunnelId=${tunnelId}`);
+
+    const timer = this.reconnectTimers.get(tunnelId);
+    if (timer) {
+      clearTimeout(timer);
+      this.reconnectTimers.delete(tunnelId);
+    }
+
+    this.tunnels.delete(tunnelId);
+
+    if (tunnel.localSocket) {
+      tunnel.localSocket.destroy();
+    }
+    tunnel.serverSocket.emit('port-forward:close', { tunnelId });
+  }
+
+  closeAll(): void {
+    console.log(`Gateway closing all tunnels: count=${this.tunnels.size}`);
+
+    for (const [tunnelId, tunnel] of [...this.tunnels]) {
+      const timer = this.reconnectTimers.get(tunnelId);
+      if (timer) {
+        clearTimeout(timer);
+        this.reconnectTimers.delete(tunnelId);
+      }
+
+      this.tunnels.delete(tunnelId);
+
+      if (tunnel.localSocket) {
+        tunnel.localSocket.destroy();
+      }
+      tunnel.serverSocket.emit('port-forward:close', { tunnelId: tunnel.id });
+    }
+  }
+}
+
+export const gatewayManager = new GatewayManager();

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;
 }
 
@@ -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-detector.test.ts

@@ -32,71 +32,148 @@ describe('AcpDetector', () => {
   });
 
   describe('detect', () => {
-    it('should detect opencode and github_copilot when both available', async () => {
+    it('should detect all 7 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');
+      mockExecSuccessOnce('mimo 0.1.0\n');
+      mockExecSuccessOnce('kimi 1.0.0\n');
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(2);
+      expect(result).toHaveLength(7);
       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' });
+      expect(result[5]).toEqual({ type: 'mimo_code', available: true, version: '0.1.0' });
+      expect(result[6]).toEqual({ type: 'kimi_code', available: true, version: '1.0.0' });
     });
 
     it('should detect as unavailable when command fails', async () => {
       mockExecFailureOnce();
       mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(2);
+      expect(result).toHaveLength(7);
       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 });
+      expect(result[5]).toEqual({ type: 'mimo_code', available: false });
+      expect(result[6]).toEqual({ type: 'kimi_code', 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();
+      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(7);
+      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 });
+      expect(result[5]).toEqual({ type: 'mimo_code', available: false });
+      expect(result[6]).toEqual({ type: 'kimi_code', 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();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
 
       const result = await detector.detect();
 
-      expect(result[0].version).toBe('unknown');
-      expect(result[1].version).toBe('unknown');
+      expect(result).toHaveLength(7);
+      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');
+      mockExecFailureOnce();
       mockExecFailureOnce();
 
       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(7);
+      expect(result[4]).toEqual({ type: 'codex', available: true, version: '0.5.0' });
     });
 
-    it('should detect only copilot when opencode fails', async () => {
+    it('should detect mimo_code only when other servers fail', async () => {
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecSuccessOnce('mimo 0.1.0\n');
       mockExecFailureOnce();
-      mockExecSuccessOnce('copilot 1.0.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).toHaveLength(7);
+      expect(result[5]).toEqual({ type: 'mimo_code', available: true, version: '0.1.0' });
     });
 
+    it('should detect kimi_code only when other servers fail', async () => {
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecSuccessOnce('kimi 2.0.0\n');
+
+      const result = await detector.detect();
+
+      expect(result).toHaveLength(7);
+      expect(result[6]).toEqual({ type: 'kimi_code', available: true, version: '2.0.0' });
+    });
+
+    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');
+      mockExecSuccessOnce('MiMo CLI v1.0.0\n');
+      mockExecSuccessOnce('kimi 2.0.0\n');
+
+      const result = await detector.detect();
 
+      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');
+      expect(result[5].version).toBe('1.0.0');
+      expect(result[6].version).toBe('2.0.0');
+    });
   });
 
   describe('getSpawnerConfig', () => {
@@ -110,6 +187,31 @@ 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 mimo_code spawner config', () => {
+      const config = detector.getSpawnerConfig('mimo_code');
+      expect(config).toEqual({ command: 'mimo', args: ['acp'] });
+    });
+
+    it('should return kimi_code spawner config', () => {
+      const config = detector.getSpawnerConfig('kimi_code');
+      expect(config).toEqual({ command: 'kimi', args: ['acp'] });
+    });
+
     it('should return opencode as default for unknown serverType', () => {
       const config = detector.getSpawnerConfig('unknown_server');
       expect(config).toEqual({ command: 'opencode', args: ['acp'] });

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":""}