@cloudcli-ai/cloudcli 1.36.3 → 1.37.1

package/server/modules/websocket/services/chat-websocket.service.ts

@@ -3,13 +3,21 @@ import path from 'node:path';
 import type { WebSocket } from 'ws';
 
 import { sessionsDb } from '@/modules/database/index.js';
+import { providerModelsService } from '@/modules/providers/index.js';
 import { chatRunRegistry } from '@/modules/websocket/services/chat-run-registry.service.js';
 import { connectedClients, WS_OPEN_STATE } from '@/modules/websocket/services/websocket-state.service.js';
-import { getGlobalImageAssetsDir, normalizeImageDescriptors } from '@/shared/image-attachments.js';
+import {
+  getGlobalImageAssetsDir,
+  isImageAttachmentDescriptor,
+  normalizeAttachmentDescriptors,
+  type ChatAttachmentDescriptor,
+} from '@/shared/image-attachments.js';
 import type {
   AnyRecord,
   AuthenticatedWebSocketRequest,
   LLMProvider,
+  ProviderPermissionDecision,
+  ProviderRuntimeWriter,
 } from '@/shared/types.js';
 import { parseIncomingJsonObject } from '@/shared/utils.js';
 
@@ -23,10 +31,13 @@ import { parseIncomingJsonObject } from '@/shared/utils.js';
  *
  * Exported for tests; `assetsRootOverride` exists only for them.
  */
-export function filterImagesToUploadStore(images: unknown, assetsRootOverride?: string): AnyRecord[] {
+export function filterAttachmentsToUploadStore(
+  attachments: unknown,
+  assetsRootOverride?: string,
+): ChatAttachmentDescriptor[] {
   const assetsRoot = path.resolve(assetsRootOverride ?? getGlobalImageAssetsDir());
 
-  return normalizeImageDescriptors(images).filter((descriptor) => {
+  return normalizeAttachmentDescriptors(attachments).filter((descriptor) => {
     // Relative paths are anchored in the store; absolute ones must already be in it.
     const resolved = path.resolve(assetsRoot, descriptor.path);
     const relative = path.relative(assetsRoot, resolved);
@@ -38,43 +49,37 @@ export function filterImagesToUploadStore(images: unknown, assetsRootOverride?:
       !relative.includes('/');
 
     if (!isDirectChild) {
-      console.warn(`[Chat] Dropping image outside the upload store: ${descriptor.path}`);
+      console.warn(`[Chat] Dropping attachment outside the upload store: ${descriptor.path}`);
     }
     return isDirectChild;
   });
 }
 
-/**
- * One provider runtime entry point. All five runtimes share this signature,
- * which lets the chat handler dispatch through a provider-keyed map instead
- * of provider-specific branches.
- */
-type ProviderSpawnFn = (
-  command: string,
-  options: AnyRecord,
-  writer: unknown
-) => Promise<unknown>;
+/** Backward-compatible image filter consumed by existing websocket tests. */
+export function filterImagesToUploadStore(
+  images: unknown,
+  assetsRootOverride?: string,
+): ChatAttachmentDescriptor[] {
+  return filterAttachmentsToUploadStore(images, assetsRootOverride);
+}
+
+/** Application boundary for dispatching provider runs and approvals. */
+type ProviderRuntimeGateway = {
+  hasRuntime(provider: string): boolean;
+  run(
+    provider: LLMProvider,
+    command: string,
+    options: AnyRecord,
+    writer: ProviderRuntimeWriter,
+  ): Promise<unknown>;
+  abort(provider: LLMProvider, sessionId: string): Promise<boolean>;
+  resolveToolApproval(requestId: string, payload: ProviderPermissionDecision): void;
+  getPendingApprovalsForSession(sessionId: string): unknown[];
+};
 
 type ChatWebSocketDependencies = {
-  /** Provider runtimes keyed by provider id. */
-  spawnFns: Record<LLMProvider, ProviderSpawnFn>;
-  /**
-   * Abort functions keyed by provider id. They are addressed with the
-   * provider-native session id (that is how runtimes key their process maps).
-   * The Claude abort is async; the rest are sync — both shapes are accepted.
-   */
-  abortFns: Record<LLMProvider, (providerSessionId: string) => boolean | Promise<boolean>>;
-  resolveToolApproval: (
-    requestId: string,
-    payload: {
-      allow: boolean;
-      updatedInput?: unknown;
-      message?: string;
-      rememberEntry?: unknown;
-    }
-  ) => void;
-  /** Claude-only today: pending tool approvals included in `chat_subscribed`. */
-  getPendingApprovalsForSession: (providerSessionId: string) => unknown[];
+  /** Central dispatcher for every provider SDK/CLI runtime. */
+  runtime: ProviderRuntimeGateway;
 };
 
 /**
@@ -162,8 +167,7 @@ async function handleChatSend(
   }
 
   const provider = session.provider as LLMProvider;
-  const spawnFn = dependencies.spawnFns[provider];
-  if (!spawnFn) {
+  if (!dependencies.runtime.hasRuntime(provider)) {
     sendProtocolError(ws, 'UNSUPPORTED_PROVIDER', `Provider "${provider}" is not available.`, sessionId);
     return;
   }
@@ -189,23 +193,46 @@ async function handleChatSend(
   const clientOptions = (data.options ?? {}) as AnyRecord;
   const command = typeof data.content === 'string' ? data.content : '';
 
-  // The provider runtimes receive the provider-native session id (that is the
-  // id their CLI/SDK understands for resume). Brand-new sessions have no
-  // provider id yet, so the runtime starts fresh and announces one, which the
-  // gateway writer captures and maps back to the app session id.
+  // Record what this turn runs with so reopening the session later restores the
+  // same model and reasoning effort, and so the resume path has a
+  // session-scoped model answer to use.
+  if (typeof clientOptions.model === 'string' && clientOptions.model.trim()) {
+    providerModelsService.setSessionModel(provider, sessionId, clientOptions.model);
+  }
+  if (typeof clientOptions.effort === 'string' && clientOptions.effort.trim()) {
+    providerModelsService.setSessionEffort(provider, sessionId, clientOptions.effort);
+  }
+
+  const attachmentCandidates = [
+    ...normalizeAttachmentDescriptors(clientOptions.images),
+    ...normalizeAttachmentDescriptors(clientOptions.files),
+    ...normalizeAttachmentDescriptors(clientOptions.attachments),
+  ];
+  const verifiedAttachments = filterAttachmentsToUploadStore(attachmentCandidates);
+  const uniqueAttachments = verifiedAttachments.filter(
+    (descriptor, index, all) => all.findIndex((candidate) => candidate.path === descriptor.path) === index,
+  );
+
+  // The provider runtimes receive the stable app session id. When their
+  // CLI/SDK needs the provider-native id for resume, they resolve it from the
+  // session row themselves (sessionsService.resolveProviderSessionId).
+  // Brand-new sessions have no provider id yet, so the runtime starts fresh
+  // and announces one, which the gateway writer captures and maps back to the
+  // app session id.
   const runtimeOptions: AnyRecord = {
     ...clientOptions,
-    // Image attachments are re-validated server-side: only files inside the
-    // global upload store may reach the provider runtimes' file reads.
-    images: filterImagesToUploadStore(clientOptions.images),
-    sessionId: session.provider_session_id ?? undefined,
-    resume: Boolean(session.provider_session_id),
+    // Attachments are re-validated server-side: only direct children of the
+    // global upload store may reach provider runtimes or their file tools.
+    attachments: uniqueAttachments,
+    images: uniqueAttachments.filter(isImageAttachmentDescriptor),
+    files: uniqueAttachments.filter((descriptor) => !isImageAttachmentDescriptor(descriptor)),
+    sessionId,
     cwd: clientOptions.cwd ?? session.project_path ?? undefined,
     projectPath: session.project_path ?? clientOptions.projectPath,
   };
 
   try {
-    await spawnFn(command, runtimeOptions, run.writer);
+    await dependencies.runtime.run(provider, command, runtimeOptions, run.writer);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`[Chat] Provider runtime "${provider}" failed`, { sessionId, error: message });
@@ -241,11 +268,7 @@ async function handleChatAbort(
     return;
   }
 
-  const abortFn = dependencies.abortFns[run.provider];
-  let success = false;
-  if (abortFn && run.providerSessionId) {
-    success = Boolean(await abortFn(run.providerSessionId));
-  }
+  const success = await dependencies.runtime.abort(run.provider, sessionId);
 
   chatRunRegistry.completeRun(sessionId, {
     exitCode: success ? 0 : 1,
@@ -294,16 +317,9 @@ function handleChatSubscribe(
       chatRunRegistry.attachConnection(sessionId, ws);
     }
 
-    // Pending approvals are tracked under the provider-native id inside the
-    // Claude runtime; remap their sessionId so the client only sees app ids.
-    const pendingPermissions = (run?.providerSessionId
-      ? dependencies.getPendingApprovalsForSession(run.providerSessionId)
-      : []
-    ).map((approval) =>
-      approval && typeof approval === 'object'
-        ? { ...(approval as AnyRecord), sessionId }
-        : approval,
-    );
+    // Pending approvals are tracked under the app session id inside the
+    // Claude runtime, so they can be looked up directly.
+    const pendingPermissions = dependencies.runtime.getPendingApprovalsForSession(sessionId);
 
     sendJson(ws, {
       kind: 'chat_subscribed',
@@ -336,7 +352,7 @@ function handlePermissionResponse(data: AnyRecord, dependencies: ChatWebSocketDe
     return;
   }
 
-  dependencies.resolveToolApproval(data.requestId, {
+  dependencies.runtime.resolveToolApproval(data.requestId, {
     allow: Boolean(data.allow),
     updatedInput: data.updatedInput,
     message: typeof data.message === 'string' ? data.message : undefined,

package/server/modules/websocket/services/shell-websocket.service.ts

@@ -33,16 +33,79 @@ type PtySessionEntry = {
 const ptySessionsMap = new Map<string, PtySessionEntry>();
 const PTY_SESSION_TIMEOUT = 30 * 60 * 1000;
 const SHELL_URL_PARSE_BUFFER_LIMIT = 32768;
+const ANSI_ESCAPE_SEQUENCE_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g;
+const TRAILING_URL_PUNCTUATION_REGEX = /[)\]}>.,;:!?]+$/;
+
+function stripAnsiSequences(value: string): string {
+  return value.replace(ANSI_ESCAPE_SEQUENCE_REGEX, '');
+}
+
+function normalizeDetectedUrl(url: string): string | null {
+  const cleanedUrl = url.trim().replace(TRAILING_URL_PUNCTUATION_REGEX, '');
+  if (!cleanedUrl) {
+    return null;
+  }
+
+  try {
+    const parsedUrl = new URL(cleanedUrl);
+    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+      return null;
+    }
+    return parsedUrl.toString();
+  } catch {
+    return null;
+  }
+}
+
+function extractUrlsFromText(value: string): string[] {
+  const directMatches = value.match(/https?:\/\/[^\s<>"'`\\\x1b\x07]+/gi) ?? [];
+
+  // Terminal width can split a URL across lines, so valid URL characters on
+  // immediately following lines are joined before the URL is validated.
+  const wrappedMatches: string[] = [];
+  const urlContinuationPattern = /^[A-Za-z0-9\-._~:/?#\[\]@!$&'()*+,;=%]+$/;
+  const lines = value.split(/\r?\n/);
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex].trim();
+    const startMatch = line.match(/https?:\/\/[^\s<>"'`\\\x1b\x07]+/i);
+    if (!startMatch) {
+      continue;
+    }
+
+    let combinedUrl = startMatch[0];
+    let continuationIndex = lineIndex + 1;
+    while (continuationIndex < lines.length) {
+      const continuation = lines[continuationIndex].trim();
+      if (!continuation || !urlContinuationPattern.test(continuation)) {
+        break;
+      }
+      combinedUrl += continuation;
+      continuationIndex += 1;
+    }
+
+    wrappedMatches.push(combinedUrl);
+  }
+
+  return Array.from(new Set([...directMatches, ...wrappedMatches]));
+}
+
+function shouldAutoOpenUrlFromOutput(value: string): boolean {
+  const normalizedOutput = value.toLowerCase();
+  return (
+    normalizedOutput.includes("browser didn't open") ||
+    normalizedOutput.includes('open this url') ||
+    normalizedOutput.includes('continue in your browser') ||
+    normalizedOutput.includes('press enter to open') ||
+    normalizedOutput.includes('open_url:')
+  );
+}
 
 type ShellWebSocketDependencies = {
   resolveProviderSessionId: (
     sessionId: string,
     provider: string,
   ) => string | null | undefined;
-  stripAnsiSequences: (content: string) => string;
-  normalizeDetectedUrl: (url: string) => string | null;
-  extractUrlsFromText: (content: string) => string[];
-  shouldAutoOpenUrlFromOutput: (content: string) => boolean;
+  spawnPty?: typeof pty.spawn;
 };
 
 /**
@@ -220,7 +283,8 @@ function prioritizeUserNpmGlobalBin(env: NodeJS.ProcessEnv): { key: string; valu
 }
 
 /**
- * Handles websocket connections used by the standalone shell terminal UI.
+ * Used by this module's websocket gateway to connect the standalone Shell UI
+ * to a retained PTY while keeping process lifecycle ownership on the server.
  */
 export function handleShellConnection(
   ws: WebSocket,
@@ -284,6 +348,7 @@ export function handleShellConnection(
           shellProcess = existingSession.pty;
           if (existingSession.timeoutId) {
             clearTimeout(existingSession.timeoutId);
+            existingSession.timeoutId = null;
           }
 
           ws.send(
@@ -334,7 +399,7 @@ export function handleShellConnection(
         const termRows = readNumber(data.rows, 24);
         const prioritizedPath = prioritizeUserNpmGlobalBin(process.env);
 
-        shellProcess = pty.spawn(shell, shellArgs, {
+        shellProcess = (dependencies.spawnPty ?? pty.spawn)(shell, shellArgs, {
           name: 'xterm-256color',
           cols: termCols,
           rows: termRows,
@@ -376,7 +441,7 @@ export function handleShellConnection(
 
           if (session.ws && session.ws.readyState === WebSocket.OPEN) {
             let outputData = chunk;
-            const cleanChunk = dependencies.stripAnsiSequences(chunk);
+            const cleanChunk = stripAnsiSequences(chunk);
             urlDetectionBuffer = `${urlDetectionBuffer}${cleanChunk}`.slice(-SHELL_URL_PARSE_BUFFER_LIMIT);
 
             outputData = outputData.replace(
@@ -385,7 +450,7 @@ export function handleShellConnection(
             );
 
             const emitAuthUrl = (detectedUrl: string, autoOpen = false) => {
-              const normalizedUrl = dependencies.normalizeDetectedUrl(detectedUrl);
+              const normalizedUrl = normalizeDetectedUrl(detectedUrl);
               if (!normalizedUrl) {
                 return;
               }
@@ -403,8 +468,8 @@ export function handleShellConnection(
               }
             };
 
-            const normalizedDetectedUrls = dependencies.extractUrlsFromText(urlDetectionBuffer)
-              .map((url) => dependencies.normalizeDetectedUrl(url))
+            const normalizedDetectedUrls = extractUrlsFromText(urlDetectionBuffer)
+              .map((url) => normalizeDetectedUrl(url))
               .filter((url): url is string => Boolean(url));
 
             const dedupedDetectedUrls = Array.from(new Set(normalizedDetectedUrls)).filter(
@@ -415,7 +480,7 @@ export function handleShellConnection(
             dedupedDetectedUrls.forEach((url) => emitAuthUrl(url, false));
 
             if (
-              dependencies.shouldAutoOpenUrlFromOutput(cleanChunk) &&
+              shouldAutoOpenUrlFromOutput(cleanChunk) &&
               dedupedDetectedUrls.length > 0
             ) {
               const bestUrl = dedupedDetectedUrls.reduce((longest, current) =>
@@ -522,9 +587,20 @@ export function handleShellConnection(
       return;
     }
 
+    // Mobile networks can deliver an old socket's close after its replacement
+    // has attached. Only the socket that currently owns the PTY may detach it.
+    if (session.ws !== ws) {
+      return;
+    }
+
     session.ws = null;
+    if (session.timeoutId) {
+      clearTimeout(session.timeoutId);
+    }
     session.timeoutId = setTimeout(() => {
-      if (ptySessionsMap.get(ptySessionKey as string) !== session) {
+      // A reconnect may win just as this timer becomes runnable. Re-check the
+      // active socket so a queued cleanup can never kill a reattached PTY.
+      if (ptySessionsMap.get(ptySessionKey as string) !== session || session.ws !== null) {
         return;
       }
 

package/server/modules/websocket/services/websocket-server.service.ts

@@ -1,6 +1,6 @@
 import type { Server as HttpServer } from 'node:http';
 
-import { WebSocketServer, type VerifyClientCallbackSync } from 'ws';
+import { WebSocket, WebSocketServer, type VerifyClientCallbackSync } from 'ws';
 
 import { handleChatConnection } from '@/modules/websocket/services/chat-websocket.service.js';
 import { verifyWebSocketClient } from '@/modules/websocket/services/websocket-auth.service.js';
@@ -16,9 +16,69 @@ type WebSocketServerDependencies = {
   getPluginPort: Parameters<typeof handlePluginWsProxy>[2];
 };
 
+/**
+ * Used by this module's websocket gateway to keep active transports alive and
+ * close half-open connections so their route-specific clients can reconnect.
+ */
+export function attachWebSocketHeartbeat(
+  ws: WebSocket,
+  intervalMs = 30_000,
+  scheduler = {
+    setInterval,
+    clearInterval,
+  },
+): () => void {
+  let isAlive = true;
+  let stopped = false;
+
+  const markAlive = () => {
+    isAlive = true;
+  };
+
+  const stopHeartbeat = () => {
+    if (stopped) {
+      return;
+    }
+
+    stopped = true;
+    scheduler.clearInterval(heartbeat);
+    ws.off('pong', markAlive);
+    ws.off('close', stopHeartbeat);
+    ws.off('error', stopHeartbeat);
+  };
+
+  ws.on('pong', markAlive);
+  ws.on('close', stopHeartbeat);
+  ws.on('error', stopHeartbeat);
+
+  const heartbeat = scheduler.setInterval(() => {
+    if (ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+
+    // A socket that did not answer the previous ping is half-open from the
+    // server's perspective. Terminating it emits close and lets clients resume.
+    if (!isAlive) {
+      stopHeartbeat();
+      ws.terminate();
+      return;
+    }
+
+    isAlive = false;
+    try {
+      ws.ping();
+    } catch {
+      stopHeartbeat();
+      ws.terminate();
+    }
+  }, intervalMs);
+
+  return stopHeartbeat;
+}
+
 /**
  * Creates and wires the server-wide websocket gateway used for chat, shell, and
- * plugin proxy routes.
+ * plugin proxy routes. Exported through the websocket module for server startup.
  */
 export function createWebSocketServer(
   server: HttpServer,
@@ -32,23 +92,7 @@ export function createWebSocketServer(
   });
 
   wss.on('connection', (ws, request) => {
-    // Keep WebSocket alive across reverse-proxy idle timeouts (Cloudflare ~100s,
-    // AWS ALB 60s, nginx 60s, etc.). Without app-level pings these connections
-    // are silently torn down even when the UI is active, causing repeated
-    // reconnect cycles. ws library heartbeat is opt-in.
-    const HEARTBEAT_INTERVAL_MS = 30_000;
-    const heartbeat = setInterval(() => {
-      if (ws.readyState === ws.OPEN) {
-        try {
-          ws.ping();
-        } catch {
-          // socket may have been closed concurrently — interval will be cleared below
-        }
-      }
-    }, HEARTBEAT_INTERVAL_MS);
-    const stopHeartbeat = () => clearInterval(heartbeat);
-    ws.on('close', stopHeartbeat);
-    ws.on('error', stopHeartbeat);
+    attachWebSocketHeartbeat(ws);
 
     const incomingRequest = request as AuthenticatedWebSocketRequest;
     const url = incomingRequest.url ?? '/';

package/server/modules/websocket/tests/{chat-image-filter.test.ts → chat-attachment-filter.test.ts}

@@ -3,7 +3,10 @@ import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
-import { filterImagesToUploadStore } from '@/modules/websocket/services/chat-websocket.service.js';
+import {
+  filterAttachmentsToUploadStore,
+  filterImagesToUploadStore,
+} from '@/modules/websocket/services/chat-websocket.service.js';
 
 const STORE = path.join(os.tmpdir(), 'cloudcli-assets-store');
 
@@ -37,8 +40,20 @@ test('paths outside the store, traversal, and subdirs are dropped', () => {
   assert.deepEqual(result, []);
 });
 
-test('malformed payloads yield no images', () => {
+test('malformed payloads yield no attachments', () => {
   assert.deepEqual(filterImagesToUploadStore(undefined, STORE), []);
   assert.deepEqual(filterImagesToUploadStore('nope', STORE), []);
   assert.deepEqual(filterImagesToUploadStore([{ name: 'no-path' }, 42], STORE), []);
 });
+
+test('general files inside the upload store preserve their metadata', () => {
+  const inside = path.join(STORE, 'brief.pdf');
+  const result = filterAttachmentsToUploadStore(
+    [{ path: inside, name: 'brief.pdf', mimeType: 'application/pdf', size: 2048 }],
+    STORE,
+  );
+
+  assert.deepEqual(result, [
+    { path: inside, name: 'brief.pdf', mimeType: 'application/pdf', size: 2048 },
+  ]);
+});

package/server/modules/websocket/tests/shell-websocket.service.test.ts

@@ -0,0 +1,119 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import test from 'node:test';
+
+import { WebSocket } from 'ws';
+
+import { handleShellConnection } from '@/modules/websocket/services/shell-websocket.service.js';
+
+function createFakeSocket() {
+  const socket = new EventEmitter() as EventEmitter & {
+    readyState: number;
+    frames: string[];
+    send: (data: string) => void;
+  };
+  socket.readyState = WebSocket.OPEN;
+  socket.frames = [];
+  socket.send = (data: string) => socket.frames.push(data);
+  return socket;
+}
+
+function createFakePty() {
+  let dataListener: ((data: string) => void) | null = null;
+  let exitListener: ((event: { exitCode: number; signal?: number }) => void) | null = null;
+
+  return {
+    killed: false,
+    onData(listener: (data: string) => void) {
+      dataListener = listener;
+      return { dispose: () => undefined };
+    },
+    onExit(listener: (event: { exitCode: number; signal?: number }) => void) {
+      exitListener = listener;
+      return { dispose: () => undefined };
+    },
+    emitData(data: string) {
+      dataListener?.(data);
+    },
+    emitExit() {
+      exitListener?.({ exitCode: 0 });
+    },
+    write() {},
+    resize() {},
+    kill() {
+      this.killed = true;
+    },
+  };
+}
+
+test('a stale socket close cannot detach the socket that replaced it', () => {
+  const pty = createFakePty();
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => pty as never,
+  };
+  const initMessage = JSON.stringify({
+    type: 'init',
+    projectPath: process.cwd(),
+    sessionId: `stale-close-${Date.now()}`,
+    hasSession: false,
+    provider: 'plain-shell',
+    isPlainShell: true,
+    initialCommand: 'test-command',
+  });
+
+  const firstSocket = createFakeSocket();
+  handleShellConnection(firstSocket as never, dependencies);
+  firstSocket.emit('message', initMessage);
+
+  const replacementSocket = createFakeSocket();
+  handleShellConnection(replacementSocket as never, dependencies);
+  replacementSocket.emit('message', initMessage);
+  replacementSocket.frames.length = 0;
+
+  // This ordering reproduces a delayed close from a backgrounded mobile tab.
+  firstSocket.emit('close');
+  pty.emitData('output-after-stale-close');
+
+  assert.equal(pty.killed, false);
+  assert.equal(replacementSocket.frames.length, 1);
+  assert.match(replacementSocket.frames[0], /output-after-stale-close/);
+
+  pty.emitExit();
+});
+
+test('shell output detects and normalizes a wrapped authentication URL', () => {
+  const pty = createFakePty();
+  const socket = createFakeSocket();
+  const dependencies = {
+    resolveProviderSessionId: () => null,
+    spawnPty: () => pty as never,
+  };
+
+  handleShellConnection(socket as never, dependencies);
+  socket.emit(
+    'message',
+    JSON.stringify({
+      type: 'init',
+      projectPath: process.cwd(),
+      sessionId: `wrapped-url-${Date.now()}`,
+      hasSession: false,
+      provider: 'plain-shell',
+      isPlainShell: true,
+      initialCommand: 'test-command',
+    })
+  );
+  socket.frames.length = 0;
+
+  pty.emitData("Continue in your browser: https://example.com/authorize?\ncode=abc\x1b[0m");
+
+  const frames = socket.frames.map((frame) => JSON.parse(frame) as Record<string, unknown>);
+  const authenticationFrame = frames.find((frame) => frame.type === 'auth_url');
+  assert.deepEqual(authenticationFrame, {
+    type: 'auth_url',
+    url: 'https://example.com/authorize?code=abc',
+    autoOpen: false,
+  });
+
+  pty.emitExit();
+});