agent-gear 1.0.4 → 1.1.1

package/src/acp/bridge.ts

@@ -38,6 +38,11 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
   private textChunkBuffer = '';
   private textChunkTimer: ReturnType<typeof setTimeout> | null = null;
   private initializing = false;
+  private stopped = false;
+  private pendingPermissions = new Map<string, {
+    resolve: (response: acp.RequestPermissionResponse) => void;
+    timeout: NodeJS.Timeout;
+  }>();
 
   constructor(socket: Socket, options: AcpBridgeOptions, spawner?: AcpSpawner) {
     super();
@@ -173,19 +178,29 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
   }
 
   private async processPrompt(message: QueuedInput): Promise<void> {
-    if (!this.connection || !this.acpSessionId) return;
+    if (!this.connection || !this.acpSessionId || this.stopped) return;
 
     this.activePrompt = this.connection.prompt({
       sessionId: this.acpSessionId,
       prompt: [{ type: 'text' as const, text: message.content }],
     });
 
+    this.socket.emit('acp:prompt:start', { sessionId: this.sessionId });
+
+    let stopReason = 'end_turn';
     try {
-      await this.activePrompt;
+      const result = await this.activePrompt;
+      stopReason = result?.stopReason ?? 'end_turn';
     } catch {
-      // cancelled or error
+      stopReason = 'error';
     } finally {
       this.activePrompt = null;
+      if (!this.stopped) {
+        this.socket.emit('acp:prompt:complete', {
+          sessionId: this.sessionId,
+          stopReason,
+        });
+      }
       if (this.inputQueue.length > 0) {
         this.processPrompt(this.inputQueue.shift()!);
       }
@@ -267,12 +282,37 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
   async requestPermission(
     params: acp.RequestPermissionRequest,
   ): Promise<acp.RequestPermissionResponse> {
-    return {
-      outcome: {
-        outcome: 'selected',
-        optionId: params.options.find((o) => o.kind === 'allow_once')?.optionId ?? params.options[0]?.optionId ?? 'reject',
-      },
-    };
+    const requestId = `perm_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.pendingPermissions.delete(requestId);
+        resolve({ outcome: { outcome: 'cancelled' } });
+      }, 65_000);
+
+      this.pendingPermissions.set(requestId, { resolve, timeout });
+
+      this.socket.emit('acp:permission', {
+        requestId,
+        sessionId: this.sessionId,
+        toolCall: params.toolCall,
+        options: params.options,
+      });
+
+      this.emit('permission:sent', requestId);
+    });
+  }
+
+  handlePermissionResponse(requestId: string, outcome: acp.RequestPermissionOutcome): void {
+    const pending = this.pendingPermissions.get(requestId);
+    if (!pending) {
+      console.warn(`Permission request ${requestId} not found`);
+      return;
+    }
+
+    clearTimeout(pending.timeout);
+    this.pendingPermissions.delete(requestId);
+    pending.resolve({ outcome });
   }
 
   // ── text buffering ──
@@ -306,11 +346,13 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
   }
 
   private emitStopped(reason: string, exitCode?: number): void {
+    this.stopped = true;
     this.socket.emit('acp:stopped', { sessionId: this.sessionId, reason, exitCode });
     this.emit('acp:stopped', { sessionId: this.sessionId, reason, exitCode });
   }
 
   private handleError(error: unknown): void {
+    this.stopped = true;
     const msg = error instanceof Error ? error.message : String(error);
     this.socket.emit('acp:stopped', {
       sessionId: this.sessionId,

package/src/config.ts

@@ -10,6 +10,7 @@ export interface ConfigData {
   key?: { value: string };
   server?: { endpoint: string };
   controller?: { name: string };
+  resumeToken?: { value: string };
 }
 
 export function readConfig(): ConfigData {
@@ -73,3 +74,20 @@ export function resolveEndpoint(cliEndpoint?: string): string | undefined {
   if (envEndpoint) return envEndpoint;
   return getEndpointFromConfig();
 }
+
+export function getResumeTokenFromConfig(): string | undefined {
+  const config = readConfig();
+  return config.resumeToken?.value;
+}
+
+export function saveResumeTokenToConfig(token: string): void {
+  const config = readConfig();
+  config.resumeToken = { value: token };
+  writeConfig(config);
+}
+
+export function clearResumeTokenFromConfig(): void {
+  const config = readConfig();
+  delete config.resumeToken;
+  writeConfig(config);
+}

package/src/port-forward.test.ts

@@ -0,0 +1,202 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('node:net', () => ({
+  default: {
+    connect: vi.fn(),
+  },
+}));
+
+import net from 'node:net';
+import { PortForwardManager } from './port-forward.js';
+
+function createMockLocalSocket() {
+  const handlers = new Map<string, Function>();
+  return {
+    once: vi.fn((event: string, handler: Function) => {
+      handlers.set(event, handler);
+    }),
+    on: vi.fn((event: string, handler: Function) => {
+      handlers.set(event, handler);
+    }),
+    removeListener: vi.fn(),
+    destroy: vi.fn(),
+    write: vi.fn(),
+    emit: vi.fn(),
+    _handlers: handlers,
+    _trigger(event: string, ...args: unknown[]) {
+      const handler = handlers.get(event);
+      if (handler) handler(...args);
+    },
+  };
+}
+
+function createMockServerSocket() {
+  return {
+    emit: vi.fn(),
+  };
+}
+
+describe('PortForwardManager', () => {
+  let portForwardManager: PortForwardManager;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    portForwardManager = new PortForwardManager();
+  });
+
+  describe('createTunnel', () => {
+    it('should send port-forward:created(success: true) and store tunnel on connection success', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = portForwardManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      expect(net.connect).toHaveBeenCalledWith({ host: '127.0.0.1', port: 3000 });
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:created', {
+        tunnelId: 'tunnel-1',
+        success: true,
+      });
+    });
+
+    it('should send port-forward:created(success: false, error) and destroy socket on connection failure', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = portForwardManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('error', new Error('ECONNREFUSED'));
+      await promise;
+
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:created', {
+        tunnelId: 'tunnel-1',
+        success: false,
+        error: 'ECONNREFUSED',
+      });
+      expect(mockLocalSocket.destroy).toHaveBeenCalled();
+    });
+
+    it('should send port-forward:data with base64 encoded data when local socket receives data', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = portForwardManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      const testData = Buffer.from('hello world');
+      mockLocalSocket._trigger('data', testData);
+
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:data', {
+        tunnelId: 'tunnel-1',
+        data: testData.toString('base64'),
+      });
+    });
+
+    it('should send port-forward:close and remove tunnel when local socket closes', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = portForwardManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      mockLocalSocket._trigger('close');
+
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:close', {
+        tunnelId: 'tunnel-1',
+      });
+    });
+
+    it('should send port-forward:error and remove tunnel when local socket errors after connect', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = portForwardManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      mockLocalSocket._trigger('error', new Error('ECONNRESET'));
+
+      expect(mockServerSocket.emit).toHaveBeenCalledWith('port-forward:error', {
+        tunnelId: 'tunnel-1',
+        error: 'ECONNRESET',
+      });
+    });
+  });
+
+  describe('handleTunnelData', () => {
+    it('should write base64 decoded data to the corresponding local socket', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = portForwardManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      const base64Data = Buffer.from('test payload').toString('base64');
+      portForwardManager.handleTunnelData('tunnel-1', base64Data);
+
+      expect(mockLocalSocket.write).toHaveBeenCalledWith(Buffer.from('test payload'));
+    });
+
+    it('should log warning and ignore for unknown tunnelId', () => {
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      portForwardManager.handleTunnelData('unknown-tunnel', 'data');
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('unknown tunnel'),
+      );
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe('closeTunnel', () => {
+    it('should destroy local socket and remove tunnel from map', async () => {
+      const mockLocalSocket = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect).mockReturnValue(mockLocalSocket as never);
+
+      const promise = portForwardManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      mockLocalSocket._trigger('connect');
+      await promise;
+
+      portForwardManager.closeTunnel('tunnel-1');
+
+      expect(mockLocalSocket.destroy).toHaveBeenCalled();
+    });
+
+    it('should silently ignore unknown tunnelId', () => {
+      expect(() => portForwardManager.closeTunnel('unknown-tunnel')).not.toThrow();
+    });
+  });
+
+  describe('closeAll', () => {
+    it('should close all tunnels and clear the map', async () => {
+      const socket1 = createMockLocalSocket();
+      const socket2 = createMockLocalSocket();
+      const mockServerSocket = createMockServerSocket();
+      vi.mocked(net.connect)
+        .mockReturnValueOnce(socket1 as never)
+        .mockReturnValueOnce(socket2 as never);
+
+      const promise1 = portForwardManager.createTunnel('tunnel-1', 3000, mockServerSocket as never);
+      socket1._trigger('connect');
+      await promise1;
+
+      const promise2 = portForwardManager.createTunnel('tunnel-2', 4000, mockServerSocket as never);
+      socket2._trigger('connect');
+      await promise2;
+
+      portForwardManager.closeAll();
+
+      expect(socket1.destroy).toHaveBeenCalled();
+      expect(socket2.destroy).toHaveBeenCalled();
+    });
+  });
+});

package/src/port-forward.ts

@@ -0,0 +1,88 @@
+import net from 'node:net';
+import type { Socket } from 'socket.io-client';
+
+interface Tunnel {
+  id: string;
+  port: number;
+  localSocket: net.Socket;
+}
+
+export class PortForwardManager {
+  private tunnels: Map<string, Tunnel> = new Map();
+
+  async createTunnel(tunnelId: string, port: number, serverSocket: Socket): Promise<void> {
+    const localSocket = net.connect({ host: '127.0.0.1', port });
+
+    return new Promise<void>((resolve) => {
+      const onError = (err: Error) => {
+        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: Buffer) => {
+          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: Error) => {
+          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: string, data: string): void {
+    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: string): void {
+    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(): void {
+    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();

package/src/socketio-client.ts

@@ -1,10 +1,11 @@
 import { io as createSocketIOClient, type Socket } from 'socket.io-client';
+import * as acp from '@agentclientprotocol/sdk';
 import { hostname, platform } from 'os';
 import { readdir, access } from 'fs/promises';
 import { join } from 'path';
 import { homedir } from 'os';
 import { Heartbeat } from './heartbeat.js';
-import { clearConfigKey, saveKeyToConfig, saveEndpointToConfig } from './config.js';
+import { clearConfigKey, saveKeyToConfig, saveEndpointToConfig, getResumeTokenFromConfig, saveResumeTokenToConfig, clearResumeTokenFromConfig } from './config.js';
 import { acpDetector } from './acp/detector.js';
 import { AcpSpawner } from './acp/spawner.js';
 import { AcpSessionBridge } from './acp/bridge.js';
@@ -12,9 +13,11 @@ 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';
 
-const CONTROLLER_VERSION = '1.0.4';
+const CONTROLLER_VERSION = '1.1.1';
 const acpBridges = new Map<string, AcpSessionBridge>();
+const permissionRequestBridge = new Map<string, AcpSessionBridge>();
 
 function createSpawner(serverType: string, sessionId: string, cwd: string): AcpSpawner {
   const config = acpDetector.getSpawnerConfig(serverType);
@@ -23,6 +26,7 @@ function createSpawner(serverType: string, sessionId: string, cwd: string): AcpS
 
 interface RegisteredPayload {
   controllerId: string;
+  resumeToken?: string;
 }
 
 interface ErrorPayload {
@@ -154,22 +158,32 @@ export function connectToServer(
 
   socket.on('connect', () => {
     console.log(`Connected to ${endpoint}`);
+    const resumeToken = getResumeTokenFromConfig();
     socket.emit('register', {
       key,
       hostname: controllerName,
       version: CONTROLLER_VERSION,
+      resumeToken,
     });
   });
 
   socket.on('registered', (data: RegisteredPayload) => {
     console.log(`Controller registered: ${data.controllerId}`);
+    if (data.resumeToken) {
+      saveResumeTokenToConfig(data.resumeToken);
+      console.log('Resume token saved to config');
+    }
     heartbeat.start(() => socket.emit('heartbeat'));
   });
 
   socket.on('error', (data: ErrorPayload) => {
     console.error(`Server error: ${data.code} - ${data.message}`);
     if (data.code === 'KEY_ALREADY_ONLINE') {
-      console.error('This key is already in use on another machine.');
+      console.log('Clearing resume token and retrying connection...');
+      clearResumeTokenFromConfig();
+      // Don't exit, let the reconnection logic handle it
+      socket.disconnect();
+      return;
     }
     socket.disconnect();
     process.exit(1);
@@ -214,6 +228,10 @@ export function connectToServer(
 
       acpBridges.set(data.sessionId, bridge);
 
+      bridge.on('permission:sent', (requestId: string) => {
+        permissionRequestBridge.set(requestId, bridge);
+      });
+
       const onInitialized = (payload: Record<string, unknown>) => {
         if (payload.sessionId !== data.sessionId) return;
         bridge.off('acp:initialized', onInitialized);
@@ -275,6 +293,10 @@ export function connectToServer(
 
       acpBridges.set(data.sessionId, bridge);
 
+      bridge.on('permission:sent', (requestId: string) => {
+        permissionRequestBridge.set(requestId, bridge);
+      });
+
       const onInitialized = (payload: Record<string, unknown>) => {
         if (payload.sessionId !== data.sessionId) return;
         bridge.off('acp:initialized', onInitialized);
@@ -563,9 +585,37 @@ export function connectToServer(
     socket.emit('git:commit:result', { requestId: data.requestId, ...result });
   });
 
+  // Port Forward events
+  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);
+  });
+
+  socket.on('port-forward:data', (data: { tunnelId: string; data: string }) => {
+    portForwardManager.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);
+  });
+
+  socket.on('acp:permission:response', (data: {
+    requestId: string;
+    outcome: { outcome: string; optionId?: string };
+  }) => {
+    const bridge = permissionRequestBridge.get(data.requestId);
+    if (bridge) {
+      permissionRequestBridge.delete(data.requestId);
+      bridge.handlePermissionResponse(data.requestId, data.outcome as acp.RequestPermissionOutcome);
+    }
+  });
+
   socket.on('disconnect', (reason) => {
     console.log(`Disconnected: ${reason}`);
     heartbeat.stop();
+    portForwardManager.closeAll();
+    permissionRequestBridge.clear();
   });
 
   socket.on('connect_error', (err) => {

package/tests/acp-bridge.test.ts

@@ -331,6 +331,67 @@ describe('AcpSessionBridge', () => {
 
       expect(mc().prompt).toHaveBeenCalledTimes(2);
     });
+
+    it('should emit acp:prompt:start when prompt begins', async () => {
+      const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
+
+      mc().prompt.mockReturnValue(new Promise(() => {}));
+      bridge.sendInput({ type: 'text', content: 'Hello' });
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:prompt:start', {
+        sessionId: 'sess-1',
+      });
+    });
+
+    it('should emit acp:prompt:complete when prompt ends successfully', async () => {
+      const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
+
+      bridge.sendInput({ type: 'text', content: 'Hello' });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:prompt:complete', {
+        sessionId: 'sess-1',
+        stopReason: 'end_turn',
+      });
+    });
+
+    it('should emit acp:prompt:complete with error stopReason on prompt failure', async () => {
+      const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
+
+      mc().prompt.mockRejectedValueOnce(new Error('prompt failed'));
+      bridge.sendInput({ type: 'text', content: 'Hello' });
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:prompt:complete', {
+        sessionId: 'sess-1',
+        stopReason: 'error',
+      });
+    });
+
+    it('should not emit acp:prompt:complete after stop', async () => {
+      const bridge = createBridge();
+      bridge.start();
+      await vi.advanceTimersByTimeAsync(0);
+
+      mc().prompt.mockReturnValue(new Promise(() => {}));
+      bridge.sendInput({ type: 'text', content: 'Hello' });
+
+      mockSocket.emit.mockClear();
+      bridge.stop();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:stopped', expect.objectContaining({
+        sessionId: 'sess-1',
+        reason: 'user_close',
+      }));
+      expect(mockSocket.emit).not.toHaveBeenCalledWith('acp:prompt:complete', expect.anything());
+    });
   });
 
   describe('sessionUpdate handling', () => {
@@ -388,18 +449,45 @@ describe('AcpSessionBridge', () => {
   });
 
   describe('requestPermission', () => {
-    it('should auto-accept with allow_once', async () => {
+    it('should emit acp:permission and wait for response', async () => {
       const bridge = createBridge();
-      const result = await bridge.requestPermission({
-        options: [
-          { optionId: 'opt-1', kind: 'allow_once', label: 'Allow' },
-          { optionId: 'opt-2', kind: 'reject', label: 'Reject' },
-        ],
+      const options = [
+        { optionId: 'opt-1', kind: 'allow_once', label: 'Allow' },
+        { optionId: 'opt-2', kind: 'reject', label: 'Reject' },
+      ];
+
+      const promise = bridge.requestPermission({
+        options,
+        toolCall: { toolCallId: 'tc-1' },
       } as never);
 
-      expect(result).toEqual({
-        outcome: { outcome: 'selected', optionId: 'opt-1' },
-      });
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:permission', expect.objectContaining({
+        sessionId: 'sess-1',
+        toolCall: { toolCallId: 'tc-1' },
+        options,
+      }));
+
+      const emitCall = mockSocket.emit.mock.calls.find((c: unknown[]) => c[0] === 'acp:permission');
+      const requestId = (emitCall![1] as { requestId: string }).requestId;
+
+      bridge.handlePermissionResponse(requestId, { outcome: 'selected', optionId: 'opt-1' });
+
+      const result = await promise;
+      expect(result).toEqual({ outcome: { outcome: 'selected', optionId: 'opt-1' } });
+    });
+
+    it('should resolve with cancelled on 65s timeout', async () => {
+      const bridge = createBridge();
+
+      const promise = bridge.requestPermission({
+        options: [{ optionId: 'opt-1', kind: 'allow_once', label: 'Allow' }],
+        toolCall: { toolCallId: 'tc-1' },
+      } as never);
+
+      await vi.advanceTimersByTimeAsync(65_000);
+
+      const result = await promise;
+      expect(result).toEqual({ outcome: { outcome: 'cancelled' } });
     });
   });