agent-gear 1.1.4 → 1.1.6

package/tests/acp-detector.test.ts

@@ -32,21 +32,25 @@ describe('AcpDetector', () => {
   });
 
   describe('detect', () => {
-    it('should detect all 5 servers when all 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(5);
+      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 () => {
@@ -55,15 +59,19 @@ describe('AcpDetector', () => {
       mockExecFailureOnce();
       mockExecFailureOnce();
       mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(5);
+      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 detect claude_code only when other servers fail', async () => {
@@ -72,15 +80,19 @@ describe('AcpDetector', () => {
       mockExecSuccessOnce('claude-agent-acp 0.1.0\n');
       mockExecFailureOnce();
       mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(5);
+      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 detect gemini_cli only when other servers fail', async () => {
@@ -89,10 +101,12 @@ describe('AcpDetector', () => {
       mockExecFailureOnce();
       mockExecSuccessOnce('gemini 2.0.0\n');
       mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(5);
+      expect(result).toHaveLength(7);
       expect(result[3]).toEqual({ type: 'gemini_cli', available: true, version: '2.0.0' });
     });
 
@@ -102,19 +116,53 @@ describe('AcpDetector', () => {
       mockExecFailureOnce();
       mockExecFailureOnce();
       mockExecSuccessOnce('codex-acp 0.5.0\n');
+      mockExecFailureOnce();
+      mockExecFailureOnce();
 
       const result = await detector.detect();
 
-      expect(result).toHaveLength(5);
+      expect(result).toHaveLength(7);
       expect(result[4]).toEqual({ type: 'codex', available: true, version: '0.5.0' });
     });
 
+    it('should detect mimo_code only when other servers fail', async () => {
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecFailureOnce();
+      mockExecSuccessOnce('mimo 0.1.0\n');
+      mockExecFailureOnce();
+
+      const result = await detector.detect();
+
+      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();
 
@@ -123,6 +171,8 @@ describe('AcpDetector', () => {
       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');
     });
   });
 
@@ -152,6 +202,16 @@ describe('AcpDetector', () => {
       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/tests/acp-sync-bridge.test.ts

@@ -4,8 +4,9 @@ function buildMockConn() {
   return {
     initialize: vi.fn<[unknown], Promise<{ protocolVersion: number }>>().mockResolvedValue({ protocolVersion: 1 }),
     newSession: vi.fn<[unknown], Promise<{ sessionId: string }>>().mockResolvedValue({ sessionId: 'sync-sess-1' }),
-    listSessions: vi.fn<[unknown], Promise<{ sessions: Array<{ sessionId: string; title: string | null; cwd: string; updatedAt: string | null }> }>>()
+    listSessions: vi.fn<[unknown], Promise<{ sessions: Array<{ sessionId: string; title: string | null; cwd: string; updatedAt: string | null }>; nextCursor?: string | null }>>()
       .mockResolvedValue({ sessions: [{ sessionId: 'hist-1', title: 'Session 1', cwd: '/home/user', updatedAt: '2026-01-01T00:00:00Z' }] }),
+    deleteSession: vi.fn<[unknown], Promise<object>>().mockResolvedValue({}),
     loadSession: vi.fn<[unknown], Promise<object>>().mockResolvedValue({}),
     cancel: vi.fn<[unknown], Promise<void>>().mockResolvedValue(undefined),
     closeSession: vi.fn<[unknown], Promise<object>>().mockResolvedValue({}),
@@ -128,6 +129,43 @@ describe('AcpSyncBridge', () => {
 
       expect(result.sessions).toEqual([]);
     });
+
+    it('should throw when not connected', async () => {
+      const bridge = createBridge(new MockAcpSpawner());
+      await expect(bridge.listSessions('/home/user')).rejects.toThrow('ACP connection not established');
+    });
+
+    it('should pass cursor to ACP and return nextCursor', async () => {
+      mc().listSessions.mockResolvedValue({
+        sessions: [{ sessionId: 'hist-2', title: 'Session 2', cwd: '/home/user', updatedAt: null }],
+        nextCursor: 'cursor-2',
+      });
+      const mockSpawner = new MockAcpSpawner();
+      const bridge = createBridge(mockSpawner);
+      await bridge.connect();
+
+      const result = await bridge.listSessions('/home/user', 'cursor-1');
+
+      expect(mc().listSessions).toHaveBeenCalledWith({ cwd: '/home/user', cursor: 'cursor-1' });
+      expect(result.nextCursor).toBe('cursor-2');
+    });
+  });
+
+  describe('deleteSession', () => {
+    it('should call ACP deleteSession with the given session ID', async () => {
+      const mockSpawner = new MockAcpSpawner();
+      const bridge = createBridge(mockSpawner);
+      await bridge.connect();
+
+      await bridge.deleteSession('hist-1');
+
+      expect(mc().deleteSession).toHaveBeenCalledWith({ sessionId: 'hist-1' });
+    });
+
+    it('should throw when not connected', async () => {
+      const bridge = createBridge(new MockAcpSpawner());
+      await expect(bridge.deleteSession('hist-1')).rejects.toThrow();
+    });
   });
 
   describe('loadSession', () => {

package/tests/socketio-client.test.ts

@@ -9,6 +9,25 @@ const { mockStart, mockStop, MockHeartbeat } = vi.hoisted(() => {
   return { mockStart: start, mockStop: stop, MockHeartbeat: HB };
 });
 
+const { MockAcpSyncBridge, mockBridge } = vi.hoisted(() => {
+  const bridge = {
+    connect: vi.fn().mockResolvedValue(undefined),
+    disconnect: vi.fn().mockResolvedValue(undefined),
+    listSessions: vi.fn(),
+    deleteSession: vi.fn(),
+    supportsDelete: vi.fn(),
+    start: vi.fn(),
+    stop: vi.fn(),
+    resume: vi.fn(),
+  };
+  const Cls = vi.fn(function () { return bridge; });
+  return { MockAcpSyncBridge: Cls, mockBridge: bridge };
+});
+
+vi.mock('../src/acp/sync-bridge.js', () => ({
+  AcpSyncBridge: MockAcpSyncBridge,
+}));
+
 vi.mock('socket.io-client', () => ({
   io: vi.fn(),
 }));
@@ -316,4 +335,196 @@ describe('SocketIO Client', () => {
       });
     });
   });
+
+  describe('acp:list-sessions', () => {
+    function setup() {
+      mockBridge.connect.mockClear();
+      mockBridge.disconnect.mockClear();
+      mockBridge.listSessions.mockClear();
+      const mockSocket = createMockSocket();
+      vi.mocked(io).mockReturnValue(mockSocket as never);
+      connectToServer('http://localhost:4001', 'zag_k_1_abc123');
+      mockSocket._trigger('connect');
+      mockSocket._trigger('registered', { controllerId: 'ctrl-1' });
+      return mockSocket;
+    }
+
+    it('should pass cursor and emit nextCursor in result', async () => {
+      mockBridge.listSessions.mockResolvedValue({
+        sessions: [{ sessionId: 'hist-2', title: 'Session 2', cwd: '/home/user', updatedAt: null }],
+        nextCursor: 'cursor-2',
+      });
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:list-sessions', {
+        requestId: 'req-1',
+        serverType: 'opencode',
+        cwd: '/home/user',
+        cursor: 'cursor-1',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockBridge.listSessions).toHaveBeenCalledWith('/home/user', 'cursor-1');
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:list-sessions:result', {
+          requestId: 'req-1',
+          success: true,
+          sessions: [{ sessionId: 'hist-2', title: 'Session 2', cwd: '/home/user', updatedAt: null }],
+          nextCursor: 'cursor-2',
+        });
+      });
+    });
+
+    it('should omit nextCursor when absent', async () => {
+      mockBridge.listSessions.mockResolvedValue({
+        sessions: [{ sessionId: 'hist-1', title: 'Session 1', cwd: '/home/user', updatedAt: null }],
+      });
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:list-sessions', {
+        requestId: 'req-2',
+        serverType: 'opencode',
+        cwd: '/home/user',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockBridge.listSessions).toHaveBeenCalledWith('/home/user', undefined);
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:list-sessions:result', {
+          requestId: 'req-2',
+          success: true,
+          sessions: [{ sessionId: 'hist-1', title: 'Session 1', cwd: '/home/user', updatedAt: null }],
+        });
+      });
+    });
+
+    it('should emit failure result on error', async () => {
+      mockBridge.listSessions.mockRejectedValue(new Error('boom'));
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:list-sessions', {
+        requestId: 'req-3',
+        serverType: 'opencode',
+        cwd: '/home/user',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:list-sessions:result', {
+          requestId: 'req-3',
+          success: false,
+          error: 'boom',
+        });
+      });
+    });
+  });
+
+  describe('acp:set-config-option', () => {
+    it('should emit failure result when bridge not found', async () => {
+      const mockSocket = createMockSocket();
+      vi.mocked(io).mockReturnValue(mockSocket as never);
+      connectToServer('http://localhost:4001', 'zag_k_1_abc123');
+      mockSocket._trigger('connect');
+      mockSocket._trigger('registered', { controllerId: 'ctrl-1' });
+
+      mockSocket._trigger('acp:set-config-option', {
+        sessionId: 'unknown-sess',
+        configId: 'opt-1',
+        value: 'val-1',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:set-config-option:result', {
+          sessionId: 'unknown-sess',
+          success: false,
+          configId: 'opt-1',
+          error: 'ACP bridge not found for session',
+        });
+      });
+    });
+  });
+
+  describe('acp:delete-history-session', () => {
+    function setup() {
+      mockBridge.connect.mockClear();
+      mockBridge.disconnect.mockClear();
+      mockBridge.deleteSession.mockClear();
+      mockBridge.supportsDelete.mockClear();
+      const mockSocket = createMockSocket();
+      vi.mocked(io).mockReturnValue(mockSocket as never);
+      connectToServer('http://localhost:4001', 'zag_k_1_abc123');
+      mockSocket._trigger('connect');
+      mockSocket._trigger('registered', { controllerId: 'ctrl-1' });
+      return mockSocket;
+    }
+
+    it('should delete session via sync bridge when supported', async () => {
+      mockBridge.supportsDelete.mockReturnValue(true);
+      mockBridge.deleteSession.mockResolvedValue(undefined);
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:delete-history-session', {
+        requestId: 'req-1',
+        sessionId: 'db-id-1',
+        externalSessionId: 'ext-1',
+        cwd: '/home/user',
+        serverType: 'opencode',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockBridge.connect).toHaveBeenCalled();
+        expect(mockBridge.supportsDelete).toHaveBeenCalled();
+        expect(mockBridge.deleteSession).toHaveBeenCalledWith('ext-1');
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:delete-history-session:result', {
+          requestId: 'req-1',
+          sessionId: 'db-id-1',
+          success: true,
+          supported: true,
+        });
+      });
+    });
+
+    it('should report unsupported without deleting when agent lacks capability', async () => {
+      mockBridge.supportsDelete.mockReturnValue(false);
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:delete-history-session', {
+        requestId: 'req-2',
+        sessionId: 'db-id-2',
+        externalSessionId: 'ext-2',
+        cwd: '/home/user',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockBridge.deleteSession).not.toHaveBeenCalled();
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:delete-history-session:result', {
+          requestId: 'req-2',
+          sessionId: 'db-id-2',
+          success: false,
+          supported: false,
+          error: 'Session delete not supported by agent',
+        });
+      });
+    });
+
+    it('should emit failure result on error', async () => {
+      mockBridge.supportsDelete.mockReturnValue(true);
+      mockBridge.deleteSession.mockRejectedValue(new Error('boom'));
+      const mockSocket = setup();
+
+      mockSocket._trigger('acp:delete-history-session', {
+        requestId: 'req-3',
+        sessionId: 'db-id-3',
+        externalSessionId: 'ext-3',
+        cwd: '/home/user',
+      });
+
+      await vi.waitFor(() => {
+        expect(mockSocket.emit).toHaveBeenCalledWith('acp:delete-history-session:result', {
+          requestId: 'req-3',
+          sessionId: 'db-id-3',
+          success: false,
+          supported: true,
+          error: 'boom',
+        });
+      });
+    });
+  });
 });