agent-gear 1.1.10 → 1.2.0

package/tests/acp-spawner.test.ts

@@ -11,6 +11,7 @@ vi.mock('os', () => ({
 vi.mock('child_process', () => ({
   spawn: vi.fn(),
   execFileSync: vi.fn(() => '/usr/bin/opencode'),
+  execFile: vi.fn(),
 }));
 
 vi.mock('fs', async (importOriginal) => {
@@ -19,7 +20,7 @@ vi.mock('fs', async (importOriginal) => {
 });
 
 import { AcpSpawner } from '../../src/acp/spawner.js';
-import { spawn, execFileSync } from 'child_process';
+import { spawn, execFileSync, execFile } from 'child_process';
 import { existsSync } from 'fs';
 
 function createMockChildProcess(): ChildProcess & EventEmitter {
@@ -31,6 +32,7 @@ function createMockChildProcess(): ChildProcess & EventEmitter {
   Object.defineProperty(proc, 'stdout', { value: stdoutMock, writable: true });
   Object.defineProperty(proc, 'stderr', { value: new Readable({ read() {} }), writable: true });
   Object.defineProperty(proc, 'kill', { value: vi.fn().mockReturnValue(true), writable: true });
+  Object.defineProperty(proc, 'pid', { value: 12345, writable: true });
   return proc;
 }
 
@@ -60,6 +62,7 @@ describe('AcpSpawner', () => {
       spawner.start();
       expect(spawn).toHaveBeenCalledWith('/usr/bin/opencode', ['acp'], {
         cwd: '/tmp/project',
+        detached: true,
         stdio: ['pipe', 'pipe', 'pipe'],
       });
     });
@@ -130,26 +133,39 @@ describe('AcpSpawner', () => {
   });
 
   describe('stop', () => {
-    it('should send SIGTERM to process', () => {
+    let processKillSpy: ReturnType<typeof vi.spyOn>;
+
+    beforeEach(() => {
+      processKillSpy = vi.spyOn(process, 'kill').mockReturnValue(true as any);
+    });
+
+    afterEach(() => {
+      processKillSpy.mockRestore();
+    });
+
+    it('should send SIGTERM to process group', () => {
       spawner.start();
+      const pid = mockProcess.pid;
       spawner.stop();
-      expect(mockProcess.kill).toHaveBeenCalledWith('SIGTERM');
+      expect(processKillSpy).toHaveBeenCalledWith(-pid, 'SIGTERM');
     });
 
     it('should send SIGKILL after 5s if process has not exited', () => {
       spawner.start();
+      const pid = mockProcess.pid;
       spawner.stop();
-      expect(mockProcess.kill).toHaveBeenCalledWith('SIGTERM');
+      expect(processKillSpy).toHaveBeenCalledWith(-pid, 'SIGTERM');
       vi.advanceTimersByTime(5000);
-      expect(mockProcess.kill).toHaveBeenCalledWith('SIGKILL');
+      expect(processKillSpy).toHaveBeenCalledWith(-pid, 'SIGKILL');
     });
 
     it('should not send SIGKILL if process already exited', () => {
       spawner.start();
+      const pid = mockProcess.pid;
       spawner.stop();
       mockProcess.emit('exit', 0, null);
       vi.advanceTimersByTime(5000);
-      expect(mockProcess.kill).toHaveBeenCalledTimes(1);
+      expect(processKillSpy).not.toHaveBeenCalledWith(-pid, 'SIGKILL');
     });
 
     it('should handle stop when no process', () => {
@@ -205,14 +221,14 @@ describe('AcpSpawner', () => {
         expect(execFileSync).toHaveBeenCalledWith('where', ['copilot'], { encoding: 'utf8', timeout: 1000 });
       });
 
-      it('should return full path from `where`', () => {
+      it('should return full path from `where` and use shell for .cmd', () => {
         vi.mocked(execFileSync).mockReturnValue('C:\\Users\\ash\\AppData\\Roaming\\npm\\copilot.cmd\r\n');
         const sp = new AcpSpawner({ sessionId: 's', cwd: 'C:\\project', command: 'copilot', args: ['--acp', '--stdio'] });
         sp.start();
         expect(spawn).toHaveBeenCalledWith(
           'C:\\Users\\ash\\AppData\\Roaming\\npm\\copilot.cmd',
           ['--acp', '--stdio'],
-          expect.objectContaining({ shell: true }),
+          expect.objectContaining({ cwd: 'C:\\project', stdio: ['pipe', 'pipe', 'pipe'], shell: true }),
         );
       });
 
@@ -221,7 +237,7 @@ describe('AcpSpawner', () => {
         vi.mocked(existsSync).mockImplementation((p: string) => p === 'copilot.cmd');
         const sp = new AcpSpawner({ sessionId: 's', cwd: 'C:\\project', command: 'copilot' });
         sp.start();
-        expect(spawn).toHaveBeenCalledWith('copilot.cmd', expect.any(Array), expect.objectContaining({ shell: true }));
+        expect(spawn).toHaveBeenCalledWith('copilot.cmd', expect.any(Array), expect.objectContaining({ cwd: 'C:\\project' }));
       });
 
       it('should return bare command as last resort', () => {
@@ -229,42 +245,58 @@ describe('AcpSpawner', () => {
         vi.mocked(existsSync).mockReturnValue(false);
         const sp = new AcpSpawner({ sessionId: 's', cwd: 'C:\\project', command: 'copilot' });
         sp.start();
-        expect(spawn).toHaveBeenCalledWith('copilot', expect.any(Array), expect.objectContaining({ shell: true }));
+        expect(spawn).toHaveBeenCalledWith('copilot', expect.any(Array), expect.objectContaining({ cwd: 'C:\\project' }));
       });
     });
 
     describe('start', () => {
-      it('should spawn with shell: true', () => {
+      it('should spawn .cmd with shell: true on Windows (Node EINVAL on shell-less .cmd)', () => {
         vi.mocked(execFileSync).mockReturnValue('C:\\npm\\copilot.cmd\r\n');
         const sp = new AcpSpawner({ sessionId: 's', cwd: 'C:\\project', command: 'copilot' });
         sp.start();
         expect(spawn).toHaveBeenCalledWith(
-          expect.any(String),
+          'C:\\npm\\copilot.cmd',
           expect.any(Array),
-          expect.objectContaining({ shell: true }),
+          expect.objectContaining({ cwd: 'C:\\project', shell: true }),
         );
       });
-    });
 
-    describe('stop', () => {
-      it('should call kill() without signal on Windows', () => {
-        const sp = new AcpSpawner({ sessionId: 's', cwd: 'C:\\project', command: 'copilot' });
-        vi.mocked(execFileSync).mockReturnValue('C:\\npm\\copilot.cmd\r\n');
+      it('should spawn .bat with shell: true on Windows', () => {
+        vi.mocked(execFileSync).mockReturnValue('C:\\npm\\agent.bat\r\n');
+        const sp = new AcpSpawner({ sessionId: 's', cwd: 'C:\\project', command: 'agent' });
         sp.start();
-        sp.stop();
-        expect(mockProcess.kill).toHaveBeenCalledWith();
-        expect(mockProcess.kill).not.toHaveBeenCalledWith('SIGTERM');
+        expect(spawn).toHaveBeenCalledWith(
+          'C:\\npm\\agent.bat',
+          expect.any(Array),
+          expect.objectContaining({ cwd: 'C:\\project', shell: true }),
+        );
       });
 
-      it('should call kill() again after 5s on Windows', () => {
+      it('should spawn a real .exe directly without shell on Windows', () => {
+        vi.mocked(execFileSync).mockReturnValue('C:\\tools\\opencode.exe\r\n');
+        const sp = new AcpSpawner({ sessionId: 's', cwd: 'C:\\project', command: 'opencode' });
+        sp.start();
+        const spawnOptions = vi.mocked(spawn).mock.calls[0][2];
+        expect(spawn).toHaveBeenCalledWith('C:\\tools\\opencode.exe', expect.any(Array), expect.objectContaining({ cwd: 'C:\\project' }));
+        expect(spawnOptions).not.toHaveProperty('shell');
+      });
+    });
+
+    describe('stop', () => {
+      it('should use taskkill on Windows instead of signal kill', () => {
+        vi.mocked(execFile).mockImplementation((_cmd: any, _args: any, cb: any) => {
+          if (typeof cb === 'function') cb(null, '', '');
+          return {} as any;
+        });
+        const processKillSpy = vi.spyOn(process, 'kill').mockReturnValue(true as any);
         const sp = new AcpSpawner({ sessionId: 's', cwd: 'C:\\project', command: 'copilot' });
         vi.mocked(execFileSync).mockReturnValue('C:\\npm\\copilot.cmd\r\n');
         sp.start();
         sp.stop();
-        expect(mockProcess.kill).toHaveBeenCalledTimes(1);
-        vi.advanceTimersByTime(5000);
-        expect(mockProcess.kill).toHaveBeenCalledTimes(2);
-        expect(mockProcess.kill).not.toHaveBeenCalledWith('SIGKILL');
+        // On Windows, stop() should call taskkill, not POSIX signals
+        expect(processKillSpy).not.toHaveBeenCalledWith(expect.anything(), 'SIGTERM');
+        expect(processKillSpy).not.toHaveBeenCalledWith(expect.anything(), 'SIGKILL');
+        processKillSpy.mockRestore();
       });
     });
   });

package/tests/fs-handler.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { FsHandler } from '../src/fs-handler.js';
+
+// 真实 fs 集成测试（不 mock）：removeDir 的安全语义只有真实文件系统能覆盖
+// （验收报告建议项 #31：isPathSafe/removeDir 零用例）
+
+describe('FsHandler.removeDir（真实 fs）', () => {
+  const created: string[] = [];
+
+  function makeDir(): string {
+    const dir = mkdtempSync(join(tmpdir(), 'fs-handler-test-'));
+    created.push(dir);
+    return dir;
+  }
+
+  afterEach(() => {
+    for (const dir of created.splice(0)) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('拒绝删除 .git 为目录的路径（git 主工作区），目录保持完整', async () => {
+    const handler = new FsHandler();
+    const repoRoot = makeDir();
+    mkdirSync(join(repoRoot, '.git'));
+    writeFileSync(join(repoRoot, 'index.ts'), 'export {}');
+    handler.registerAllowedPath(repoRoot);
+
+    const result = await handler.removeDir(repoRoot);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('main working tree');
+    expect(existsSync(join(repoRoot, '.git'))).toBe(true);
+    expect(existsSync(join(repoRoot, 'index.ts'))).toBe(true);
+  });
+
+  it('允许删除 .git 为文件的已注册路径（linked worktree）', async () => {
+    const handler = new FsHandler();
+    const worktreeDir = makeDir();
+    // linked worktree 的 .git 是指向主仓库 gitdir 的普通文件
+    writeFileSync(join(worktreeDir, '.git'), 'gitdir: /repo/.git/worktrees/feat-1');
+    writeFileSync(join(worktreeDir, 'index.ts'), 'export {}');
+    handler.registerAllowedPath(worktreeDir);
+
+    const result = await handler.removeDir(worktreeDir);
+
+    expect(result.success).toBe(true);
+    expect(existsSync(worktreeDir)).toBe(false);
+  });
+
+  it('拒绝删除未注册的路径', async () => {
+    const handler = new FsHandler();
+    const dir = makeDir();
+
+    const result = await handler.removeDir(dir);
+
+    expect(result.success).toBe(false);
+    expect(existsSync(dir)).toBe(true);
+  });
+});

package/tests/socketio-client.test.ts

@@ -28,6 +28,76 @@ vi.mock('../src/acp/sync-bridge.js', () => ({
   AcpSyncBridge: MockAcpSyncBridge,
 }));
 
+const { bridgeInstances } = vi.hoisted(() => ({
+  bridgeInstances: [] as Array<{ sessionId: string; emit: (event: string, payload: unknown) => boolean }>,
+}));
+
+vi.mock('../src/acp/bridge.js', async () => {
+  const { EventEmitter } = await import('events');
+  class FakeAcpSessionBridge extends EventEmitter {
+    sessionId: string;
+    constructor(_socket: unknown, options: { sessionId: string }, _spawner: unknown) {
+      super();
+      this.sessionId = options.sessionId;
+      bridgeInstances.push(this as never);
+    }
+    async start() {
+      this.emit('acp:initialized', {
+        sessionId: this.sessionId,
+        acpSessionId: 'acp-ext-1',
+        modes: [],
+        availableModels: [],
+        configOptions: [],
+        authMethods: [],
+      });
+    }
+    async resume() {
+      this.emit('acp:initialized', {
+        sessionId: this.sessionId,
+        acpSessionId: 'acp-ext-1',
+        modes: [],
+        availableModels: [],
+        configOptions: [],
+        authMethods: [],
+      });
+    }
+    async stop() {
+      this.emit('acp:stopped', { sessionId: this.sessionId, reason: 'user_close' });
+    }
+    sendInput() {}
+    cancel() {}
+  }
+  return { AcpSessionBridge: FakeAcpSessionBridge };
+});
+
+vi.mock('../src/acp/spawner.js', () => ({
+  AcpSpawner: class {
+    pid = 4321;
+    constructor(_options: unknown) {}
+    start() {}
+    stop() {}
+    get closed() { return Promise.resolve(); }
+  },
+}));
+
+vi.mock('../src/acp/detector.js', () => ({
+  acpDetector: {
+    detect: vi.fn(async () => []),
+    getSpawnerConfig: vi.fn(() => ({ command: 'opencode', args: ['acp'] })),
+  },
+}));
+
+vi.mock('../src/acp/process-registry.js', () => ({
+  processRegistry: {
+    register: vi.fn(),
+    deregister: vi.fn(),
+    get: vi.fn(),
+    list: vi.fn(() => []),
+    listEntries: vi.fn(() => []),
+  },
+  isProcessAlive: vi.fn(() => true),
+}));
+
 vi.mock('socket.io-client', () => ({
   io: vi.fn(),
 }));
@@ -66,6 +136,8 @@ import { io } from 'socket.io-client';
 import { clearConfigKey } from '../src/config.js';
 import * as os from 'os';
 import { readdir, access } from 'fs/promises';
+import { fsHandler } from '../src/fs-handler.js';
+import { processRegistry, isProcessAlive } from '../src/acp/process-registry.js';
 
 function createMockSocket() {
   const handlers: Record<string, (...args: unknown[]) => void> = {};
@@ -527,4 +599,220 @@ describe('SocketIO Client', () => {
       });
     });
   });
+
+  describe('acp:start registry 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;
+    }
+
+    async function startSession(mockSocket: ReturnType<typeof createMockSocket>, sessionId: string, cwd: string) {
+      mockSocket._trigger('acp:start', {
+        requestId: 'req-start',
+        sessionId,
+        serverType: 'opencode',
+        cwd,
+      });
+      await vi.waitFor(() => {
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:start:result', expect.objectContaining({ sessionId, success: true }));
+      });
+    }
+
+    it('registers the session cwd as an allowed fs path', async () => {
+      const registerSpy = vi.spyOn(fsHandler, 'registerAllowedPath');
+      const mockSocket = setup();
+
+      await startSession(mockSocket, 'sess-1', '/home/user/wt-1');
+
+      expect(registerSpy).toHaveBeenCalledWith('/home/user/wt-1');
+    });
+
+    it('stops the previous bridge when acp:start arrives for the same sessionId again', async () => {
+      const mockSocket = setup();
+      await startSession(mockSocket, 'sess-1', '/home/user/wt-1');
+      const oldBridge = bridgeInstances[0] as unknown as { stop: () => Promise<void> };
+      const stopSpy = vi.spyOn(oldBridge, 'stop');
+
+      // 同 sessionId 再次 acp:start（如超时重试/兜底 resume 后迟到）：旧 bridge 必须先停，
+      // 否则同会话双进程、旧 bridge 泄漏
+      mockSocket._trigger('acp:start', {
+        requestId: 'req-start-2',
+        sessionId: 'sess-1',
+        serverType: 'opencode',
+        cwd: '/home/user/wt-1',
+      });
+
+      await vi.waitFor(() => {
+        expect(stopSpy).toHaveBeenCalled();
+      });
+      await vi.waitFor(() => {
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:start:result', expect.objectContaining({
+          requestId: 'req-start-2',
+          sessionId: 'sess-1',
+          success: true,
+        }));
+      });
+      expect(bridgeInstances).toHaveLength(2);
+    });
+
+    it('deregisters the PID when the bridge emits acp:stopped', async () => {
+      const mockSocket = setup();
+      await startSession(mockSocket, 'sess-1', '/home/user/wt-1');
+      vi.mocked(processRegistry.deregister).mockClear();
+
+      bridgeInstances[0].emit('acp:stopped', { sessionId: 'sess-1', reason: 'user_close' });
+
+      expect(processRegistry.deregister).toHaveBeenCalledWith('sess-1');
+    });
+
+    it('deregisters the PID on the acp:stop bridge path', async () => {
+      const mockSocket = setup();
+      await startSession(mockSocket, 'sess-1', '/home/user/wt-1');
+      vi.mocked(processRegistry.deregister).mockClear();
+
+      mockSocket._trigger('acp:stop', { sessionId: 'sess-1' });
+
+      await vi.waitFor(() => {
+        expect(processRegistry.deregister).toHaveBeenCalledWith('sess-1');
+      });
+    });
+  });
+
+  describe('acp:stop fallback kill', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+      vi.mocked(os.platform).mockReturnValue('linux');
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    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('kills by registry PID and probes liveness before SIGKILL', async () => {
+      const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true as never);
+      vi.mocked(processRegistry.get).mockReturnValue({ pid: 2222, cwd: '/x', acpServerType: 'opencode', startedAt: '2026-01-01' });
+      vi.mocked(isProcessAlive).mockReturnValue(true);
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:stop', { sessionId: 'sess-x', ackRequired: true });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(killSpy).toHaveBeenCalledWith(-2222, 'SIGTERM');
+      expect(processRegistry.deregister).toHaveBeenCalledWith('sess-x');
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:stopped', {
+        sessionId: 'sess-x',
+        reason: 'user_close',
+        killed: true,
+      });
+
+      await vi.advanceTimersByTimeAsync(5000);
+      expect(isProcessAlive).toHaveBeenCalledWith(2222);
+      expect(killSpy).toHaveBeenCalledWith(-2222, 'SIGKILL');
+    });
+
+    it('skips SIGKILL when the process is already dead (PID reuse guard)', async () => {
+      const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true as never);
+      vi.mocked(processRegistry.get).mockReturnValue({ pid: 2222, cwd: '/x', acpServerType: 'opencode', startedAt: '2026-01-01' });
+      vi.mocked(isProcessAlive).mockReturnValue(false);
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:stop', { sessionId: 'sess-x' });
+      await vi.advanceTimersByTimeAsync(0);
+      expect(killSpy).toHaveBeenCalledWith(-2222, 'SIGTERM');
+
+      await vi.advanceTimersByTimeAsync(5000);
+      expect(killSpy).not.toHaveBeenCalledWith(-2222, 'SIGKILL');
+    });
+
+    it('ignores malformed payloads with a warning', async () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true as never);
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:stop', { ackRequired: true });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(warnSpy).toHaveBeenCalled();
+      expect(killSpy).not.toHaveBeenCalled();
+      expect(mockSocket.emit).not.toHaveBeenCalledWith('acp:stopped', expect.anything());
+    });
+  });
+
+  describe('acp:reconcile', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+      vi.mocked(os.platform).mockReturnValue('linux');
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    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('kills orphan registry entries and probes liveness before SIGKILL', async () => {
+      const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true as never);
+      vi.mocked(processRegistry.listEntries).mockReturnValue([
+        { sessionId: 's1', pid: 3333, cwd: '/x', acpServerType: 'opencode', startedAt: '2026-01-01' },
+      ]);
+      vi.mocked(isProcessAlive).mockReturnValue(false);
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:reconcile', { activeSessionIds: [], pendingKillSessionIds: [] });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(killSpy).toHaveBeenCalledWith(-3333, 'SIGTERM');
+      expect(processRegistry.deregister).toHaveBeenCalledWith('s1');
+
+      await vi.advanceTimersByTimeAsync(5000);
+      expect(isProcessAlive).toHaveBeenCalledWith(3333);
+      expect(killSpy).not.toHaveBeenCalledWith(-3333, 'SIGKILL');
+    });
+
+    it('keeps sessions listed in activeSessionIds', async () => {
+      const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true as never);
+      vi.mocked(processRegistry.listEntries).mockReturnValue([
+        { sessionId: 's1', pid: 3333, cwd: '/x', acpServerType: 'opencode', startedAt: '2026-01-01' },
+      ]);
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:reconcile', { activeSessionIds: ['s1'], pendingKillSessionIds: [] });
+      await vi.advanceTimersByTimeAsync(5000);
+
+      expect(killSpy).not.toHaveBeenCalled();
+      expect(processRegistry.deregister).not.toHaveBeenCalled();
+    });
+
+    it('ignores malformed payloads with a warning', async () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true as never);
+      const mockSocket = setup();
+      // connectToServer seeds the fs whitelist via listEntries once; clear it
+      vi.mocked(processRegistry.listEntries).mockClear();
+
+      mockSocket._trigger('acp:reconcile', { activeSessionIds: 'oops', pendingKillSessionIds: null });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(warnSpy).toHaveBeenCalled();
+      expect(processRegistry.listEntries).not.toHaveBeenCalled();
+      expect(killSpy).not.toHaveBeenCalled();
+    });
+  });
 });