agent-gear 1.1.5 → 1.1.7

package/tests/acp-bridge.test.ts

@@ -9,7 +9,9 @@ function buildMockConn() {
     cancel: vi.fn<[unknown], Promise<void>>().mockResolvedValue(undefined),
     closeSession: vi.fn<[unknown], Promise<object>>().mockResolvedValue({}),
     setSessionMode: vi.fn<[unknown], Promise<object>>().mockResolvedValue({}),
-    unstable_setSessionModel: vi.fn<[unknown], Promise<object>>().mockResolvedValue({}),
+    setSessionConfigOption: vi.fn<[unknown], Promise<object>>().mockResolvedValue({}),
+    authenticate: vi.fn<[unknown], Promise<object>>().mockResolvedValue({}),
+    logout: vi.fn<[unknown], Promise<object>>().mockResolvedValue({}),
   };
 }
 
@@ -18,9 +20,13 @@ let mockConnInstance = buildMockConn();
 vi.mock('@agentclientprotocol/sdk', () => ({
   ndJsonStream: vi.fn(() => ({})),
   ClientSideConnection: vi.fn(function () { return mockConnInstance; }),
+  CreateElicitationRequest: {
+    isForm: (v: { mode?: string }) => v.mode === 'form',
+    isUrl: (v: { mode?: string }) => v.mode === 'url',
+  },
 }));
 
-import { AcpSessionBridge } from '../../src/acp/bridge.js';
+import { AcpSessionBridge, extractConfigOptions } from '../../src/acp/bridge.js';
 
 class MockAcpSpawner {
   start = vi.fn();
@@ -74,8 +80,13 @@ describe('AcpSessionBridge', () => {
       expect(mockSpawner.start).toHaveBeenCalledOnce();
       expect(mc().initialize).toHaveBeenCalledWith({
         protocolVersion: 1,
-        clientCapabilities: {},
-        clientInfo: { name: 'agent-gear', version: '1.0.0' },
+        clientCapabilities: {
+          session: {
+            configOptions: { boolean: {} },
+          },
+          elicitation: { form: {}, url: {} },
+        },
+        clientInfo: { name: 'agent-gear', version: '1.1.5' },
       });
       expect(mc().newSession).toHaveBeenCalledWith({
         cwd: '/home/user',
@@ -121,10 +132,16 @@ describe('AcpSessionBridge', () => {
     it('should include currentModel in acp:initialized when available', async () => {
       mockConnInstance.newSession = vi.fn().mockResolvedValue({
         sessionId: 'acp-sess-abc',
-        models: {
-          availableModels: [{ modelId: 'gpt-4', name: 'GPT-4' }],
-          currentModelId: 'gpt-4',
-        },
+        configOptions: [
+          {
+            id: 'model',
+            name: 'Model',
+            category: 'model',
+            type: 'select',
+            currentValue: 'gpt-4',
+            options: [{ value: 'gpt-4', name: 'GPT-4' }],
+          },
+        ],
       });
       const bridge = createBridge();
       const emitSpy = vi.fn();
@@ -141,13 +158,19 @@ describe('AcpSessionBridge', () => {
     it('should include availableModels and currentModelId in acp:initialized', async () => {
       mockConnInstance.newSession = vi.fn().mockResolvedValue({
         sessionId: 'acp-sess-abc',
-        models: {
-          availableModels: [
-            { modelId: 'gpt-4', name: 'GPT-4' },
-            { modelId: 'claude-3', name: 'Claude 3' },
-          ],
-          currentModelId: 'claude-3',
-        },
+        configOptions: [
+          {
+            id: 'model',
+            name: 'Model',
+            category: 'model',
+            type: 'select',
+            currentValue: 'claude-3',
+            options: [
+              { value: 'gpt-4', name: 'GPT-4' },
+              { value: 'claude-3', name: 'Claude 3' },
+            ],
+          },
+        ],
       });
       const bridge = createBridge();
       const emitSpy = vi.fn();
@@ -165,6 +188,22 @@ describe('AcpSessionBridge', () => {
       }));
     });
 
+    it('should map auth method without type field to kind agent', async () => {
+      mc().initialize.mockResolvedValue({
+        protocolVersion: 1,
+        authMethods: [{ id: 'oauth', description: 'Login with agent' }],
+      });
+      const bridge = createBridge();
+
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:auth:required', {
+        sessionId: 'sess-1',
+        authMethods: [{ id: 'oauth', kind: 'agent', description: null, url: null }],
+      });
+    });
+
     it('should emit acp:stopped on initialize failure', async () => {
       mc().initialize.mockRejectedValue(new Error('init failed'));
       const bridge = createBridge();
@@ -201,6 +240,7 @@ describe('AcpSessionBridge', () => {
       expect(mc().resumeSession).toHaveBeenCalledWith({
         sessionId: 'existing-sess-id',
         cwd: '/home/user',
+        mcpServers: [],
       });
       expect(emitSpy).toHaveBeenCalledWith(expect.objectContaining({
         sessionId: 'sess-1',
@@ -491,6 +531,119 @@ describe('AcpSessionBridge', () => {
     });
   });
 
+  describe('unstable_createElicitation', () => {
+    it('form 模式：emit acp:elicitation 并在响应后 resolve accept + content', async () => {
+      const bridge = createBridge();
+      const requestedSchema = {
+        type: 'object',
+        properties: { name: { type: 'string' } },
+        required: ['name'],
+      };
+
+      const promise = bridge.unstable_createElicitation({
+        mode: 'form',
+        message: 'Need your name',
+        sessionId: 'acp-sess-abc',
+        toolCallId: 'tc-1',
+        requestedSchema,
+      } as never);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:elicitation', expect.objectContaining({
+        sessionId: 'sess-1',
+        mode: 'form',
+        message: 'Need your name',
+        toolCallId: 'tc-1',
+        requestedSchema,
+      }));
+
+      const emitCall = mockSocket.emit.mock.calls.find((c: unknown[]) => c[0] === 'acp:elicitation');
+      const requestId = (emitCall![1] as { requestId: string }).requestId;
+      expect(requestId).toMatch(/^elic_/);
+
+      bridge.handleElicitationResponse(requestId, 'accept', { name: 'ash' });
+
+      const result = await promise;
+      expect(result).toEqual({ action: 'accept', content: { name: 'ash' } });
+    });
+
+    it('url 模式：透传 elicitationId 与 url', async () => {
+      const bridge = createBridge();
+
+      const promise = bridge.unstable_createElicitation({
+        mode: 'url',
+        message: 'Authorize access',
+        sessionId: 'acp-sess-abc',
+        elicitationId: 'elic-agent-1',
+        url: 'https://example.com/auth',
+      } as never);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:elicitation', expect.objectContaining({
+        sessionId: 'sess-1',
+        mode: 'url',
+        message: 'Authorize access',
+        elicitationId: 'elic-agent-1',
+        url: 'https://example.com/auth',
+      }));
+
+      const emitCall = mockSocket.emit.mock.calls.find((c: unknown[]) => c[0] === 'acp:elicitation');
+      const requestId = (emitCall![1] as { requestId: string }).requestId;
+      bridge.handleElicitationResponse(requestId, 'decline');
+
+      const result = await promise;
+      expect(result).toEqual({ action: 'decline' });
+    });
+
+    it('custom/未知模式：立即返回 cancel 且不 emit socket 事件', async () => {
+      const bridge = createBridge();
+
+      const result = await bridge.unstable_createElicitation({
+        mode: '_vendor_custom',
+        message: 'custom request',
+        sessionId: 'acp-sess-abc',
+      } as never);
+
+      expect(result).toEqual({ action: 'cancel' });
+      expect(mockSocket.emit).not.toHaveBeenCalledWith('acp:elicitation', expect.anything());
+    });
+
+    it('65s 超时自动 resolve cancel', async () => {
+      const bridge = createBridge();
+
+      const promise = bridge.unstable_createElicitation({
+        mode: 'form',
+        message: 'm',
+        sessionId: 'acp-sess-abc',
+        requestedSchema: { type: 'object' },
+      } as never);
+
+      await vi.advanceTimersByTimeAsync(65_000);
+
+      const result = await promise;
+      expect(result).toEqual({ action: 'cancel' });
+    });
+
+    it('handleElicitationResponse 未知 requestId 打 warn 不抛错', () => {
+      const bridge = createBridge();
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      expect(() => bridge.handleElicitationResponse('elic_unknown', 'cancel')).not.toThrow();
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('elic_unknown'));
+    });
+  });
+
+  describe('unstable_completeElicitation', () => {
+    it('emit acp:elicitation:complete', async () => {
+      const bridge = createBridge();
+
+      await bridge.unstable_completeElicitation({ elicitationId: 'elic-agent-1' } as never);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:elicitation:complete', {
+        sessionId: 'sess-1',
+        elicitationId: 'elic-agent-1',
+      });
+    });
+  });
+
   describe('setMode', () => {
     it('should call connection.setSessionMode', async () => {
       const bridge = createBridge();
@@ -511,51 +664,236 @@ describe('AcpSessionBridge', () => {
       await expect(bridge.setMode('mode-1')).resolves.toBeUndefined();
       expect(mc().setSessionMode).not.toHaveBeenCalled();
     });
+
+    it('should use setSessionConfigOption when mode config option exists', async () => {
+      mockConnInstance.newSession = vi.fn().mockResolvedValue({
+        sessionId: 'acp-sess-abc',
+        configOptions: [
+          {
+            id: 'mode',
+            name: 'Mode',
+            category: 'mode',
+            type: 'select',
+            currentValue: 'code',
+            options: [{ value: 'code', name: 'Code' }, { value: 'plan', name: 'Plan' }],
+          },
+        ],
+      });
+      const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
+
+      await bridge.setMode('plan');
+
+      expect(mc().setSessionConfigOption).toHaveBeenCalledWith({
+        sessionId: 'acp-sess-abc',
+        configId: 'mode',
+        value: 'plan',
+      });
+    });
   });
 
   describe('setModel', () => {
-    it('should call connection.unstable_setSessionModel with correct params', async () => {
+    it('should call setSessionConfigOption when model config option exists', async () => {
+      mockConnInstance.newSession = vi.fn().mockResolvedValue({
+        sessionId: 'acp-sess-abc',
+        configOptions: [
+          {
+            id: 'model',
+            name: 'Model',
+            category: 'model',
+            type: 'select',
+            currentValue: 'gpt-4',
+            options: [{ value: 'gpt-4', name: 'GPT-4' }, { value: 'claude-3', name: 'Claude 3' }],
+          },
+        ],
+      });
       const bridge = createBridge();
       bridge.start();
       await vi.advanceTimersByTimeAsync(0);
 
-      await bridge.setModel('model-2');
+      await bridge.setModel('claude-3');
 
-      expect(mc().unstable_setSessionModel).toHaveBeenCalledWith({
+      expect(mc().setSessionConfigOption).toHaveBeenCalledWith({
         sessionId: 'acp-sess-abc',
-        modelId: 'model-2',
+        configId: 'model',
+        value: 'claude-3',
       });
     });
 
+    it('should throw when initialized but no model config option', async () => {
+      const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
+
+      await expect(bridge.setModel('model-1')).rejects.toThrow(
+        'Model switching is not supported',
+      );
+      expect(mc().setSessionConfigOption).not.toHaveBeenCalled();
+    });
+
     it('should not throw when not initialized', async () => {
       const bridge = createBridge();
 
       await expect(bridge.setModel('model-1')).resolves.toBeUndefined();
-      expect(mc().unstable_setSessionModel).not.toHaveBeenCalled();
     });
   });
 
-  describe('extractAvailableModels', () => {
-    it('should return empty array when models is null', () => {
+  describe('setConfigOption', () => {
+    it('should call connection.setSessionConfigOption with boolean value', async () => {
       const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
+
+      await bridge.setConfigOption('opt-1', true);
 
-      // Access private method via bracket notation
-      const result = (bridge as unknown as Record<string, unknown>).extractAvailableModels(null);
-      expect(result).toEqual([]);
+      expect(mc().setSessionConfigOption).toHaveBeenCalledWith({
+        sessionId: 'acp-sess-abc',
+        configId: 'opt-1',
+        value: true,
+        type: 'boolean',
+      });
     });
 
-    it('should return empty array when models is undefined', () => {
+    it('should call connection.setSessionConfigOption with select value', async () => {
       const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
 
-      const result = (bridge as unknown as Record<string, unknown>).extractAvailableModels(undefined);
-      expect(result).toEqual([]);
+      await bridge.setConfigOption('opt-2', 'val-1');
+
+      expect(mc().setSessionConfigOption).toHaveBeenCalledWith({
+        sessionId: 'acp-sess-abc',
+        configId: 'opt-2',
+        value: 'val-1',
+      });
     });
 
-    it('should return empty array when availableModels is missing', () => {
+    it('should update snapshot and emit acp:config-options from set_config_option response', async () => {
+      mockConnInstance.setSessionConfigOption = vi.fn().mockResolvedValue({
+        configOptions: [
+          {
+            id: 'flags',
+            name: 'Flags',
+            category: null,
+            type: 'boolean',
+            currentValue: true,
+          },
+        ],
+      });
       const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
 
-      const result = (bridge as unknown as Record<string, unknown>).extractAvailableModels({});
-      expect(result).toEqual([]);
+      await bridge.setConfigOption('flags', 'true');
+
+      expect(bridge.getConfigOptions()).toEqual([
+        {
+          id: 'flags',
+          name: 'Flags',
+          description: null,
+          category: null,
+          type: 'boolean',
+          currentValue: 'true',
+          options: [],
+        },
+      ]);
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:config-options', {
+        sessionId: 'sess-1',
+        configOptions: bridge.getConfigOptions(),
+      });
+    });
+
+    it('should not emit acp:config-options when response has no configOptions', async () => {
+      mockConnInstance.setSessionConfigOption = vi.fn().mockResolvedValue({});
+      const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
+
+      await bridge.setConfigOption('opt-2', 'val-1');
+
+      expect(mockSocket.emit).not.toHaveBeenCalledWith('acp:config-options', expect.anything());
+    });
+  });
+
+  describe('extractConfigOptions', () => {
+    it('should return empty array when configOptions is null or undefined', () => {
+      expect(extractConfigOptions(null)).toEqual([]);
+      expect(extractConfigOptions(undefined)).toEqual([]);
+    });
+
+    it('should flatten grouped select options with group name prefix', () => {
+      const result = extractConfigOptions([
+        {
+          id: 'model',
+          name: 'Model',
+          category: 'model',
+          type: 'select',
+          currentValue: 'gpt-4',
+          options: [
+            {
+              group: 'openai',
+              name: 'OpenAI',
+              options: [
+                { value: 'gpt-4', name: 'GPT-4' },
+                { value: 'gpt-4o', name: 'GPT-4o' },
+              ],
+            },
+            {
+              group: 'anthropic',
+              name: 'Anthropic',
+              options: [{ value: 'claude-3', name: 'Claude 3' }],
+            },
+          ],
+        },
+      ]);
+
+      expect(result[0].options).toEqual([
+        { value: 'gpt-4', name: 'OpenAI/GPT-4' },
+        { value: 'gpt-4o', name: 'OpenAI/GPT-4o' },
+        { value: 'claude-3', name: 'Anthropic/Claude 3' },
+      ]);
+    });
+
+    it('should map select and boolean config options', () => {
+      const result = extractConfigOptions([
+        {
+          id: 'model',
+          name: 'Model',
+          category: 'model',
+          type: 'select',
+          currentValue: 'gpt-4',
+          options: [{ value: 'gpt-4', name: 'GPT-4' }],
+        },
+        {
+          id: 'flags',
+          name: 'Flags',
+          category: null,
+          type: 'boolean',
+          currentValue: true,
+        },
+      ]);
+
+      expect(result).toEqual([
+        {
+          id: 'model',
+          name: 'Model',
+          description: null,
+          category: 'model',
+          type: 'select',
+          currentValue: 'gpt-4',
+          options: [{ value: 'gpt-4', name: 'GPT-4' }],
+        },
+        {
+          id: 'flags',
+          name: 'Flags',
+          description: null,
+          category: null,
+          type: 'boolean',
+          currentValue: 'true',
+          options: [],
+        },
+      ]);
     });
   });
 });

package/tests/acp-spawner.test.ts

@@ -68,7 +68,34 @@ describe('AcpSpawner', () => {
       spawner.start();
       const stderr = mockProcess.stderr as Readable;
       stderr.emit('data', Buffer.from('some warning\n'));
-      expect(consoleErrorSpy).toHaveBeenCalledWith('ACP stderr: some warning\n');
+      expect(consoleErrorSpy).toHaveBeenCalledWith('ACP stderr (session=sess-1): some warning\n');
+    });
+
+    it('should log resolved command, args and cwd on start', () => {
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      spawner.start();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Starting ACP server: session=sess-1 cmd=/usr/bin/opencode args=["acp"] cwd=/tmp/project',
+      );
+    });
+
+    it('should log exit code, signal and spawn params on process exit', () => {
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      spawner.start();
+      mockProcess.emit('exit', 1, null);
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'ACP process exited: session=sess-1 code=1 signal=null cmd=/usr/bin/opencode args=["acp"]',
+      );
+    });
+
+    it('should log process error with session and command', () => {
+      spawner.start();
+      const error = new Error('spawn opencode ENOENT');
+      mockProcess.emit('error', error);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'ACP process error (session=sess-1, cmd=/usr/bin/opencode):',
+        error,
+      );
     });
 
     it('should resolve closed on process exit', async () => {

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', () => {