agent-gear 1.3.0 → 2.1.0

package/tests/endpoint-compat.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import { createServer, type Server as HttpServer } from 'node:http';
+import { Server as IOServer, type Socket as ServerSocket } from 'socket.io';
+
+// 只测连接层：屏蔽守护进程的其余副作用（本地 MCP 回环服务、心跳定时器、~/.zag 配置写入）。
+vi.mock('../src/mcp/local-server.js', () => ({
+  LocalMcpServer: class {
+    port = 0;
+    start = vi.fn(async () => {});
+    stop = vi.fn(async () => {});
+  },
+}));
+
+vi.mock('../src/heartbeat.js', () => ({
+  Heartbeat: class {
+    start = vi.fn();
+    stop = vi.fn();
+  },
+}));
+
+vi.mock('../src/config.js', () => ({
+  clearConfigKey: vi.fn(),
+  saveKeyToConfig: vi.fn(),
+  saveEndpointToConfig: vi.fn(),
+  getResumeTokenFromConfig: vi.fn(() => undefined),
+  saveResumeTokenToConfig: vi.fn(),
+  clearResumeTokenFromConfig: vi.fn(),
+}));
+
+import { connectToServer, parseEndpoint, extractHandshakeToken, stripTokenFromEndpoint } from '../src/socketio-client.js';
+import type { Socket } from 'socket.io-client';
+
+interface Harness {
+  port: number;
+  handshakes: Array<Record<string, string>>;
+  auths: Array<Record<string, unknown>>;
+  registerPayloads: unknown[];
+  url: (path?: string) => string;
+  close: () => Promise<void>;
+}
+
+const openSockets: Socket[] = [];
+
+async function startServer(): Promise<Harness> {
+  const httpServer: HttpServer = createServer();
+  const ioServer = new IOServer(httpServer);
+  const handshakes: Array<Record<string, string>> = [];
+  const auths: Array<Record<string, unknown>> = [];
+  const registerPayloads: unknown[] = [];
+
+  const attach = (nspName: string) => {
+    const nsp = ioServer.of(nspName);
+    nsp.use((socket, next) => {
+      handshakes.push(socket.handshake.query as Record<string, string>);
+      auths.push(socket.handshake.auth as Record<string, unknown>);
+      next();
+    });
+    nsp.on('connection', (socket: ServerSocket) => {
+      socket.on('register', (payload: unknown) => {
+        registerPayloads.push(payload);
+        socket.emit('registered', { controllerId: 'test-controller' });
+      });
+    });
+  };
+  attach('/');
+  attach('/worker');
+
+  await new Promise<void>((resolve) => httpServer.listen(0, '127.0.0.1', () => resolve()));
+  const address = httpServer.address();
+  if (!address || typeof address === 'string') throw new Error('failed to bind test server');
+  const port = address.port;
+
+  return {
+    port,
+    handshakes,
+    auths,
+    registerPayloads,
+    url: (path = '') => `http://127.0.0.1:${port}${path}`,
+    close: async () => {
+      await ioServer.close();
+      await new Promise<void>((resolve) => httpServer.close(() => resolve()));
+    },
+  };
+}
+
+afterEach(async () => {
+  for (const socket of openSockets.splice(0)) {
+    socket.close();
+  }
+});
+
+describe('parseEndpoint', () => {
+  it('T-P1：旧 endpoint 解析为默认 namespace `/` 且无 query', () => {
+    const parsed = parseEndpoint('http://host:4001');
+    expect(parsed.namespace).toBe('/');
+    expect(parsed.query).toEqual({});
+    expect(parsed.origin).toBe('http://host:4001');
+  });
+
+  it('T-P2：新 endpoint 解析出 `/worker` namespace 与 token query', () => {
+    const parsed = parseEndpoint('wss://cloud.example.com/worker?token=abc');
+    expect(parsed.namespace).toBe('/worker');
+    expect(parsed.query).toEqual({ token: 'abc' });
+    expect(parsed.origin).toBe('wss://cloud.example.com');
+  });
+
+  it('忽略尾部斜杠、保留多 query 参数', () => {
+    const parsed = parseEndpoint('wss://cloud.example.com/worker/?token=a.b&x=1');
+    expect(parsed.namespace).toBe('/worker');
+    expect(parsed.query).toEqual({ token: 'a.b', x: '1' });
+  });
+
+  it('extractHandshakeToken 取 query token；stripTokenFromEndpoint 移除之而保留其他参数', () => {
+    expect(extractHandshakeToken('wss://h/worker?token=a.b')).toBe('a.b');
+    expect(extractHandshakeToken('wss://h/worker')).toBeUndefined();
+    expect(extractHandshakeToken('not-a-url')).toBeUndefined();
+
+    expect(stripTokenFromEndpoint('wss://h/worker?token=a.b&x=1')).toBe('wss://h/worker?x=1');
+    expect(stripTokenFromEndpoint('wss://h/worker')).toBe('wss://h/worker');
+  });
+});
+
+describe('connectToServer endpoint 兼容（真实 socket.io 服务端）', () => {
+  it('T-P1：旧 endpoint 连接默认 namespace、handshake 无 token（兼容锚点）', async () => {
+    const server = await startServer();
+    try {
+      const socket = connectToServer(server.url(), 'zag_k_legacy');
+
+      openSockets.push(socket);
+
+      await new Promise<void>((resolve, reject) => {
+        socket.on('connect', () => resolve());
+        socket.on('connect_error', (err) => reject(err));
+        setTimeout(() => reject(new Error('connect timeout')), 3000);
+      });
+
+      // 原生解析：无 pathname → 默认 namespace `/`
+      expect(socket.nsp).toBe('/');
+      const handshake = server.handshakes.at(-1);
+      expect(handshake?.token).toBeUndefined();
+    } finally {
+      await server.close();
+    }
+  });
+
+  it('T-P2：新 endpoint（`/worker?token=abc`）握手成功，token 经 auth 传递且不进 URL', async () => {
+    const server = await startServer();
+    try {
+      const socket = connectToServer(server.url('/worker?token=abc'), 'ignored-by-cloud');
+      openSockets.push(socket);
+
+      await new Promise<void>((resolve, reject) => {
+        socket.on('connect', () => resolve());
+        socket.on('connect_error', (err) => reject(err));
+        setTimeout(() => reject(new Error('connect timeout')), 3000);
+      });
+
+      expect(socket.nsp).toBe('/worker');
+      const auth = server.auths.at(-1);
+      expect(auth?.token).toBe('abc');
+      // token 不再经 handshake query / URL 传递
+      expect(server.handshakes.at(-1)?.token).toBeUndefined();
+
+      // register 仍照常发送（cloud-controller 侧忽略 key，保持握手兼容）
+      await vi.waitFor(() => {
+        expect(server.registerPayloads.length).toBeGreaterThan(0);
+      });
+    } finally {
+      await server.close();
+    }
+  });
+
+  it('T-P3：无 query token 的新 endpoint 用 key 作为握手 auth token（cloud-controller 场景）', async () => {
+    const server = await startServer();
+    try {
+      const socket = connectToServer(server.url('/worker'), 'container-1.secret');
+      openSockets.push(socket);
+
+      await new Promise<void>((resolve, reject) => {
+        socket.on('connect', () => resolve());
+        socket.on('connect_error', (err) => reject(err));
+        setTimeout(() => reject(new Error('connect timeout')), 3000);
+      });
+
+      expect(socket.nsp).toBe('/worker');
+      expect(server.auths.at(-1)?.token).toBe('container-1.secret');
+      expect(server.handshakes.at(-1)?.token).toBeUndefined();
+    } finally {
+      await server.close();
+    }
+  });
+});

package/tests/socketio-client.test.ts

@@ -9,6 +9,11 @@ const { mockStart, mockStop, MockHeartbeat } = vi.hoisted(() => {
   return { mockStart: start, mockStop: stop, MockHeartbeat: HB };
 });
 
+const { relayInstances, localServerInstances } = vi.hoisted(() => ({
+  relayInstances: [] as Array<Record<string, ReturnType<typeof vi.fn>>>,
+  localServerInstances: [] as Array<{ start: ReturnType<typeof vi.fn>; stop: ReturnType<typeof vi.fn>; port: number }>,
+}));
+
 const { MockAcpSyncBridge, mockBridge } = vi.hoisted(() => {
   const bridge = {
     connect: vi.fn().mockResolvedValue(undefined),
@@ -106,6 +111,32 @@ vi.mock('../src/heartbeat.js', () => ({
   Heartbeat: MockHeartbeat,
 }));
 
+vi.mock('../src/mcp/relay.js', () => ({
+  McpRelay: class {
+    registerSession = vi.fn();
+    unregisterSession = vi.fn();
+    handleDisconnect = vi.fn();
+    handleMcpResponse = vi.fn();
+    hasSession = vi.fn(() => true);
+    hasServer = vi.fn(() => true);
+    forward = vi.fn();
+    constructor() {
+      relayInstances.push(this as never);
+    }
+  },
+}));
+
+vi.mock('../src/mcp/local-server.js', () => ({
+  LocalMcpServer: class {
+    port = 0;
+    start = vi.fn(async () => {});
+    stop = vi.fn(async () => {});
+    constructor() {
+      localServerInstances.push(this as never);
+    }
+  },
+}));
+
 vi.mock('../src/config.js', () => ({
   clearConfigKey: vi.fn(),
   saveKeyToConfig: vi.fn(),
@@ -159,6 +190,8 @@ beforeEach(() => {
   vi.clearAllMocks();
   mockStart.mockClear();
   mockStop.mockClear();
+  relayInstances.length = 0;
+  localServerInstances.length = 0;
   vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
   vi.spyOn(console, 'log').mockImplementation(() => {});
   vi.spyOn(console, 'error').mockImplementation(() => {});
@@ -181,6 +214,7 @@ describe('SocketIO Client', () => {
         reconnection: true,
         reconnectionDelay: 1000,
         reconnectionDelayMax: 60000,
+        auth: { token: 'zag_k_1_abc123' },
       });
     });
 
@@ -195,7 +229,7 @@ describe('SocketIO Client', () => {
       expect(mockSocket.emit).toHaveBeenCalledWith('register', {
         key: 'zag_k_1_abc123',
         hostname: 'my-machine',
-        version: '1.1.1',
+        version: '2.1.0',
         resumeToken: undefined,
         homeDir: '/home/user',
         platform: 'linux',
@@ -213,7 +247,7 @@ describe('SocketIO Client', () => {
       expect(mockSocket.emit).toHaveBeenCalledWith('register', {
         key: 'zag_k_1_abc123',
         hostname: 'test-machine',
-        version: '1.1.1',
+        version: '2.1.0',
         resumeToken: undefined,
         homeDir: '/home/user',
         platform: 'linux',
@@ -819,4 +853,161 @@ describe('SocketIO Client', () => {
       expect(killSpy).not.toHaveBeenCalled();
     });
   });
+
+  describe('MCP local endpoint lifecycle', () => {
+    function setup() {
+      bridgeInstances.length = 0;
+      const mockSocket = createMockSocket();
+      vi.mocked(io).mockReturnValue(mockSocket as never);
+      connectToServer('http://localhost:4001', 'zag_k_1_abc123');
+      return mockSocket;
+    }
+
+    it('starts the local loopback server exactly once at daemon startup and never stops on disconnect', async () => {
+      const mockSocket = setup();
+      const server = localServerInstances[0];
+      expect(server).toBeDefined();
+      expect(server.start).toHaveBeenCalledTimes(1);
+
+      // 断线→重连后服务不停止、端口不变（存活会话注入的旧 URL 仍可用）
+      mockSocket._trigger('disconnect', 'transport close');
+      expect(server.stop).not.toHaveBeenCalled();
+      mockSocket._trigger('connect');
+      expect(server.start).toHaveBeenCalledTimes(1);
+      // disconnect 仅触发 relay 快速失败（503），不触碰 HTTP 服务
+      const relay = relayInstances[0];
+      expect(relay.handleDisconnect).toHaveBeenCalled();
+    });
+
+    it('registers the session endpoint and injects the loopback port on acp:start', async () => {
+      const mockSocket = setup();
+      localServerInstances[0].port = 34567;
+      const relay = relayInstances[0];
+
+      mockSocket._trigger('acp:start', {
+        requestId: 'req-mcp',
+        sessionId: 'sess-mcp',
+        serverType: 'opencode',
+        cwd: '/home/user/wt',
+        mcpEndpoint: { token: 'tok-1', serverNames: ['tools', 'proxy'] },
+      });
+
+      await vi.waitFor(() => {
+        expect(relay.registerSession).toHaveBeenCalledWith('sess-mcp', {
+          token: 'tok-1',
+          serverNames: ['tools', 'proxy'],
+        });
+      });
+      await vi.waitFor(() => {
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:start:result', expect.objectContaining({ sessionId: 'sess-mcp', success: true }));
+      });
+    });
+
+    it('fails loudly (does not inject port 0) when the loopback server is not listening', async () => {
+      const mockSocket = setup();
+      localServerInstances[0].port = 0;
+      const relay = relayInstances[0];
+
+      mockSocket._trigger('acp:start', {
+        requestId: 'req-mcp0',
+        sessionId: 'sess-mcp0',
+        serverType: 'opencode',
+        cwd: '/home/user/wt',
+        mcpEndpoint: { token: 'tok-0', serverNames: ['tools'] },
+      });
+
+      await vi.waitFor(() => {
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:start:result', expect.objectContaining({
+          sessionId: 'sess-mcp0',
+          success: false,
+        }));
+      });
+      // registerSession 不得被调用（端口校验失败，不注入坏 URL）
+      expect(relay.registerSession).not.toHaveBeenCalledWith('sess-mcp0', expect.anything());
+    });
+
+    it('routes mcp:response to the relay', async () => {
+      const mockSocket = setup();
+      const relay = relayInstances[0];
+
+      mockSocket._trigger('mcp:response', { requestId: 'mcpreq_1', status: 200, body: { jsonrpc: '2.0', id: 1, result: {} } });
+
+      expect(relay.handleMcpResponse).toHaveBeenCalledWith('mcpreq_1', 200, { jsonrpc: '2.0', id: 1, result: {} });
+    });
+
+    it('outputs an upgrade guide and exits on VERSION_MISMATCH', () => {
+      const mockSocket = setup();
+      const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      mockSocket._trigger('error', { code: 'VERSION_MISMATCH', message: 'Version mismatch' });
+
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('upgrade agent-controller'));
+      expect(mockSocket.disconnect).toHaveBeenCalled();
+      expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it('unregisters the session endpoint when the agent process exits on its own (onStopped)', async () => {
+      const mockSocket = setup();
+      localServerInstances[0].port = 34567;
+      const relay = relayInstances[0];
+
+      mockSocket._trigger('acp:start', {
+        requestId: 'req-exit',
+        sessionId: 'sess-exit',
+        serverType: 'opencode',
+        cwd: '/home/user/wt',
+        mcpEndpoint: { token: 'tok-x', serverNames: ['tools'] },
+      });
+      await vi.waitFor(() => {
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:start:result', expect.objectContaining({ sessionId: 'sess-exit', success: true }));
+      });
+
+      vi.mocked(relay.unregisterSession).mockClear();
+      bridgeInstances[0].emit('acp:stopped', { sessionId: 'sess-exit', reason: 'user_close' });
+
+      expect(relay.unregisterSession).toHaveBeenCalledWith('sess-exit');
+    });
+
+    it('unregisters the session endpoint on acp:stop', async () => {
+      const mockSocket = setup();
+      localServerInstances[0].port = 34567;
+      const relay = relayInstances[0];
+
+      mockSocket._trigger('acp:start', {
+        requestId: 'req-stop',
+        sessionId: 'sess-stop',
+        serverType: 'opencode',
+        cwd: '/home/user/wt',
+        mcpEndpoint: { token: 'tok-s', serverNames: ['tools'] },
+      });
+      await vi.waitFor(() => {
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:start:result', expect.objectContaining({ sessionId: 'sess-stop', success: true }));
+      });
+
+      vi.mocked(relay.unregisterSession).mockClear();
+      mockSocket._trigger('acp:stop', { sessionId: 'sess-stop' });
+
+      await vi.waitFor(() => {
+        expect(relay.unregisterSession).toHaveBeenCalledWith('sess-stop');
+      });
+    });
+
+    it('unregisters the session endpoint on acp:reconcile kill', async () => {
+      const mockSocket = setup();
+      vi.mocked(processRegistry.listEntries).mockReturnValue([
+        { sessionId: 's-recon', pid: 4444, cwd: '/x', acpServerType: 'opencode', startedAt: '2026-01-01' },
+      ]);
+      const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true as never);
+      vi.mocked(isProcessAlive).mockReturnValue(false);
+      const relay = relayInstances[0];
+      vi.mocked(relay.unregisterSession).mockClear();
+
+      mockSocket._trigger('acp:reconcile', { activeSessionIds: [], pendingKillSessionIds: [] });
+
+      await vi.waitFor(() => {
+        expect(relay.unregisterSession).toHaveBeenCalledWith('s-recon');
+      });
+      expect(killSpy).toHaveBeenCalledWith(-4444, 'SIGTERM');
+    });
+  });
 });