surf-cli 2.17.0 → 2.19.0

package/native/host.cjs

@@ -20,6 +20,7 @@ const { createOracleHost } = require("./oracle-host.cjs");
 
 const IS_WIN = process.platform === "win32";
 const { SOCKET_PATH, SURF_TMP } = require("./socket-path.cjs");
+const { takeFrames } = require("./stdin-frames.cjs");
 const { parseListenEndpoint } = require("./listener.cjs");
 const { getStateDir } = require("./remote-auth.cjs");
 const { createFrameParser, createServerAuthSession, createSocketWriter, isClientAuthorized, writeFrame, MAX_FRAME_BYTES } = require("./remote-transport.cjs");
@@ -49,9 +50,17 @@ const { resolveArgs, runPlaybookOp } = require("./playbook-runtime.cjs");
 const { resolveOp } = require("./playbooks.cjs");
 const { commandMetadata, redactCommandArgs } = require("./workflow-definition.cjs");
 const { BrowserScheduler } = require("./browser-scheduler.cjs");
-const { BrowserSessionStore, validateSessionName } = require("./browser-session-store.cjs");
+const { BrowserSessionStore, parseDurationMs, validateSessionName } = require("./browser-session-store.cjs");
+const { applySocketPermissions, resolveSocketPermissions } = require("./socket-permissions.cjs");
 const { classifyTool } = require("./tool-scope.cjs");
 const { fromExtensionError, surfError } = require("./surf-error.cjs");
+const {
+  DEFAULT_VIDEO_FPS,
+  VideoRecorder,
+  VideoRecorderError,
+  parseVideoFps,
+  validateVideoOutputPath,
+} = require("./video-recorder.cjs");
 const MAX_CLIENT_FRAME_BYTES = MAX_FRAME_BYTES;
 const TEST_REQUEST_DEADLINE_MS = process.env.SURF_TEST_MODE === "1" && Number.isFinite(Number(process.env.SURF_TEST_REQUEST_DEADLINE_MS))
   ? Number(process.env.SURF_TEST_REQUEST_DEADLINE_MS)
@@ -61,7 +70,15 @@ if (IS_WIN) { try { fs.mkdirSync(SURF_TMP, { recursive: true }); } catch {} }
 // The endpoint passed here is already validated by the caller. Keeping this
 // lifecycle separate lets tests use an ephemeral loopback port without adding
 // a localhost escape hatch to SURF_LISTEN parsing.
-function createListenerLifecycle({ localPath, tcpEndpoint, handler, onReady, onFatal }) {
+function createListenerLifecycle({
+  localPath,
+  tcpEndpoint,
+  handler,
+  onReady,
+  onFatal,
+  socketMode = process.env.SURF_SOCKET_MODE,
+  socketGroup = process.env.SURF_SOCKET_GROUP,
+}) {
   const localServer = net.createServer(handler);
   const tcpServer = tcpEndpoint ? net.createServer(handler) : null;
   let shuttingDown = false;
@@ -85,9 +102,10 @@ function createListenerLifecycle({ localPath, tcpEndpoint, handler, onReady, onF
     if (startPromise) return startPromise;
     startPromise = (async () => {
       try {
+        const socketPermissions = IS_WIN ? null : resolveSocketPermissions(socketMode, socketGroup);
         await listen(localServer, localPath);
         if (shuttingDown) return false;
-        if (!IS_WIN) { try { fs.chmodSync(localPath, 0o600); } catch {} }
+        if (!IS_WIN) applySocketPermissions(localPath, socketPermissions);
         if (tcpServer) {
           await listen(tcpServer, tcpEndpoint);
           if (shuttingDown) return false;
@@ -382,6 +400,11 @@ const pendingToolRequests = new RequestPendingMap({ getRequest: () => requestSto
 const activeStreams = new Map();
 const socketContexts = new WeakMap();
 const socketWriters = new WeakMap();
+let activeVideoRecorder = null;
+let videoStopPromise = null;
+let videoStopFailure = false;
+let lastVideoError = null;
+let lastVideoResult = null;
 let requestCounter = 0;
 const browserSessionStore = new BrowserSessionStore();
 let browserIdentity = null;
@@ -394,7 +417,12 @@ function setBrowserIdentity(value) {
     browserIdentity.browserInstanceId !== value.browserInstanceId ||
     browserIdentity.browserEpoch !== value.browserEpoch
   );
-  if (identityChanged) transientFrameContexts.clear();
+  if (identityChanged) {
+    transientFrameContexts.clear();
+    if (activeVideoRecorder) {
+      void settleVideoFailure(activeVideoRecorder, new VideoRecorderError("video_extension_reloaded", "Surf extension identity changed while video recording was active"));
+    }
+  }
   browserIdentity = {
     browserInstanceId: value.browserInstanceId,
     browserEpoch: value.browserEpoch,
@@ -429,6 +457,9 @@ function handleTargetEvent(message) {
     if (message.event === "tab-removed" && Number.isInteger(message.tabId)) {
       clearTransientFrameContextsByTab(message.tabId);
       browserSessionStore.invalidateByTab(browserIdentity, message.tabId, "tab_gone");
+      if (activeVideoRecorder?.tabId === message.tabId) {
+        void settleVideoFailure(activeVideoRecorder, new VideoRecorderError("video_tab_gone", `Recorded tab ${message.tabId} was closed`));
+      }
       for (const [streamId, stream] of activeStreams) {
         if (stream.tabId === message.tabId) stopActiveStream(streamId, { notifyExtension: false });
       }
@@ -437,6 +468,9 @@ function handleTargetEvent(message) {
     if (message.event === "window-removed" && Number.isInteger(message.windowId)) {
       clearTransientFrameContextsByWindow(message.windowId);
       browserSessionStore.invalidateByWindow(browserIdentity, message.windowId, "window_gone");
+      if (activeVideoRecorder?.windowId === message.windowId) {
+        void settleVideoFailure(activeVideoRecorder, new VideoRecorderError("video_window_gone", `Recorded window ${message.windowId} was closed`));
+      }
       for (const [streamId, stream] of activeStreams) {
         if (stream.windowId === message.windowId) stopActiveStream(streamId, { notifyExtension: false });
       }
@@ -550,6 +584,196 @@ async function requestExtensionOrThrow(request, tool, message, timeoutMs = 30000
   return result;
 }
 
+function videoOptions(args = {}) {
+  const fps = parseVideoFps(args.fps, DEFAULT_VIDEO_FPS);
+  const output = validateVideoOutputPath(args.output, { createParent: false });
+  return { fps, output };
+}
+
+function videoStatus() {
+  if (activeVideoRecorder) return activeVideoRecorder.recorder.status();
+  return {
+    status: "idle",
+    ...(lastVideoError
+      ? { error: lastVideoError.message, errorCode: lastVideoError.code }
+      : {}),
+    ...(lastVideoResult ? { lastResult: lastVideoResult } : {}),
+  };
+}
+
+function rememberVideoFailure(error) {
+  const normalized = error instanceof VideoRecorderError
+    ? error
+    : new VideoRecorderError(
+      typeof error?.code === "string" ? error.code : "video_failed",
+      error?.message || String(error),
+    );
+  lastVideoError = normalized;
+  lastVideoResult = null;
+  return normalized;
+}
+
+async function settleVideoFailure(entry, error) {
+  if (!entry || activeVideoRecorder !== entry) return;
+  rememberVideoFailure(error);
+  if (videoStopPromise) return videoStopPromise;
+
+  videoStopFailure = true;
+  const promise = (async () => {
+    if (entry.extensionStarted) {
+      try {
+        writeMessage({ type: "VIDEO_STOP", recorderId: entry.recorderId, tabId: entry.tabId });
+      } catch {}
+    }
+    await entry.recorder.dispose();
+  })();
+  let settled;
+  settled = promise.finally(() => {
+    if (activeVideoRecorder === entry) activeVideoRecorder = null;
+    if (videoStopPromise === settled) {
+      videoStopPromise = null;
+      videoStopFailure = false;
+    }
+  });
+  videoStopPromise = settled;
+  await settled.catch(() => {});
+}
+
+async function startVideoRecording(args, msg, request) {
+  const { fps, output } = videoOptions(args);
+  if (activeVideoRecorder || videoStopPromise) {
+    throw new VideoRecorderError("video_active", "A video recording is already active for this native host");
+  }
+  const tabId = request.target?.tabId || msg.tabId;
+  if (!tabId) throw new VideoRecorderError("video_target_required", "video start requires a selected tab");
+
+  const recorderId = `video_${Date.now()}_${++requestCounter}`;
+  let entry;
+  const recorder = new VideoRecorder({
+    output,
+    fps,
+    tabId,
+    recorderId,
+    onFailure: (error, failedRecorder) => {
+      if (entry?.recorder === failedRecorder) void settleVideoFailure(entry, error);
+    },
+  });
+  entry = {
+    recorder,
+    recorderId,
+    tabId,
+    windowId: request.target?.windowId || msg.windowId,
+    extensionStarted: false,
+  };
+  activeVideoRecorder = entry;
+
+  try {
+    await recorder.start();
+    await requestExtensionOrThrow(request, "video.start", {
+      type: "VIDEO_START",
+      tabId,
+      recorderId,
+      fps,
+      quality: 80,
+      everyNthFrame: 1,
+      strictTarget: request.target?.strict === true,
+    });
+    entry.extensionStarted = true;
+    if (recorder.state === "failed" || activeVideoRecorder !== entry) {
+      throw recorder.failure || new VideoRecorderError("video_failed", "Video recorder failed while starting");
+    }
+    return { ...recorder.status(), status: "active" };
+  } catch (error) {
+    rememberVideoFailure(error);
+    if (entry.extensionStarted) {
+      try { writeMessage({ type: "VIDEO_STOP", recorderId, tabId }); } catch {}
+    }
+    await recorder.dispose().catch(() => {});
+    if (activeVideoRecorder === entry) activeVideoRecorder = null;
+    if (videoStopPromise) {
+      await videoStopPromise.catch(() => {});
+      videoStopPromise = null;
+      videoStopFailure = false;
+    }
+    throw error;
+  }
+}
+
+async function stopVideoRecording(request) {
+  if (videoStopPromise) {
+    const pending = videoStopPromise;
+    const failed = videoStopFailure;
+    const result = await pending;
+    if (failed) throw lastVideoError || new VideoRecorderError("video_failed", "Video recording failed");
+    return result;
+  }
+  const entry = activeVideoRecorder;
+  if (!entry) throw new VideoRecorderError("video_not_active", "No active video recording");
+
+  videoStopFailure = false;
+  const promise = (async () => {
+    let extensionError = null;
+    if (entry.extensionStarted) {
+      try {
+        await requestExtensionOrThrow(request, "video.stop", {
+          type: "VIDEO_STOP",
+          recorderId: entry.recorderId,
+          tabId: entry.tabId,
+        }, 30000, true);
+      } catch (error) {
+        // The tab may disappear between the stop request and its response. The
+        // native encoder can still finalize the file, so preserve that result.
+        extensionError = error;
+      }
+    }
+
+    let result;
+    try {
+      result = await entry.recorder.stop();
+    } catch (error) {
+      rememberVideoFailure(error);
+      throw error;
+    }
+    lastVideoError = null;
+    lastVideoResult = { ...result, status: "stopped" };
+    // A detached/gone page should not turn an otherwise finalized local file
+    // into a failed stop. Keep the extension detail available as a warning.
+    if (extensionError) lastVideoResult.warning = extensionError.message;
+    return lastVideoResult;
+  })();
+  let settled;
+  settled = promise.finally(() => {
+    if (activeVideoRecorder === entry) activeVideoRecorder = null;
+    if (videoStopPromise === settled) {
+      videoStopPromise = null;
+      videoStopFailure = false;
+    }
+  });
+  videoStopPromise = settled;
+  return settled;
+}
+
+async function handleVideoRequest(tool, args, msg, request) {
+  if (tool === "video.start") return startVideoRecording(args, msg, request);
+  if (tool === "video.stop") return stopVideoRecording(request);
+  if (tool === "video.status") return videoStatus();
+  if (tool === "video.restart") {
+    const options = videoOptions(args);
+    const existing = activeVideoRecorder;
+    if (!existing) throw new VideoRecorderError("video_not_active", "No active video recording to restart");
+    const stopped = await stopVideoRecording(request);
+    const result = await startVideoRecording({ output: options.output, fps: options.fps }, {
+      ...msg,
+      tabId: existing.tabId,
+    }, {
+      ...request,
+      target: { ...(request.target || {}), tabId: existing.tabId, strict: true },
+    });
+    return { ...result, previous: stopped.path };
+  }
+  throw new VideoRecorderError("video_command_unknown", `Unknown video command: ${tool}`);
+}
+
 function positiveId(value, name) {
   if (value === undefined || value === null || value === "") return undefined;
   const parsed = Number(value);
@@ -756,11 +980,13 @@ async function resolveSessionTarget(request, identity, name) {
       recoveryCommand: `surf session.rebind ${record.name} --tab-id ${record.tabId} --replace`,
     });
   }
+  const accessedAt = new Date().toISOString();
   const updated = browserSessionStore.replace(identity, record.name, {
     ...record,
     lastUrl: inspected.url || record.lastUrl,
     lastTitle: inspected.title || record.lastTitle,
-    lastValidatedAt: new Date().toISOString(),
+    lastAccessedAt: accessedAt,
+    lastValidatedAt: accessedAt,
   });
   return {
     source: "session",
@@ -847,6 +1073,7 @@ async function resolveRequestTarget(msg, request, classification) {
 
 async function prepareToolRequest(msg, request) {
   const args = msg.params?.args || {};
+  if (request.tool === "video.start" || request.tool === "video.restart") videoOptions(args);
   const classification = classifyTool(request.tool, args);
   request.scope = classification.scope;
   request.classification = classification;
@@ -891,6 +1118,7 @@ async function sessionRecordStatus(identity, request, record, refresh = false) {
           ...record,
           lastUrl: inspected.url || record.lastUrl,
           lastTitle: inspected.title || record.lastTitle,
+          lastAccessedAt: record.lastAccessedAt || record.updatedAt || record.createdAt,
           lastValidatedAt: new Date().toISOString(),
         });
       }
@@ -910,6 +1138,158 @@ async function sessionRecordStatus(identity, request, record, refresh = false) {
   };
 }
 
+function sessionActivity(record) {
+  const value = record.lastAccessedAt || record.updatedAt || record.createdAt;
+  if (typeof value !== "string" || !value) return null;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? { value, timestamp } : null;
+}
+
+function cleanupEntry(record, { reason, targetAction, idleMs, lastAccessedAt, ...details }) {
+  return {
+    name: record.name,
+    tabId: record.tabId,
+    windowId: record.windowId,
+    ownership: record.ownership || "adopted",
+    reason,
+    targetAction,
+    targetClosed: targetAction === "close",
+    ...(lastAccessedAt ? { lastAccessedAt } : {}),
+    ...(idleMs !== undefined ? { idleMs } : {}),
+    ...details,
+  };
+}
+
+async function cleanupBrowserSessions(identity, request, args) {
+  const rawIdleAfter = args["idle-after"];
+  const idleAfterMs = parseDurationMs(rawIdleAfter);
+  const dryRun = args["dry-run"] === true;
+  const now = Date.now();
+  const records = browserSessionStore.list(identity);
+  const operations = [];
+  const retained = [];
+  let inspected = 0;
+
+  for (const record of records) {
+    const activity = sessionActivity(record);
+    const common = {
+      lastAccessedAt: activity?.value || record.lastAccessedAt || record.updatedAt || record.createdAt,
+    };
+
+    if (record.browserEpoch !== identity.browserEpoch) {
+      operations.push({
+        record,
+        closeTarget: false,
+        entry: cleanupEntry(record, { ...common, reason: "epoch-stale", targetAction: "already-gone" }),
+      });
+      continue;
+    }
+
+    if (record.invalidReason === "tab_gone" || record.invalidReason === "window_gone") {
+      operations.push({
+        record,
+        closeTarget: false,
+        entry: cleanupEntry(record, { ...common, reason: "target-gone", targetAction: "already-gone" }),
+      });
+      continue;
+    }
+
+    if (record.invalidReason) {
+      retained.push(cleanupEntry(record, { ...common, reason: "invalid", targetAction: "kept" }));
+      continue;
+    }
+
+    let inspectedTarget;
+    try {
+      inspectedTarget = await inspectBrowserTab(request, record.tabId);
+      inspected += 1;
+    } catch (error) {
+      if (error?.code === "tab_gone") {
+        operations.push({
+          record,
+          closeTarget: false,
+          entry: cleanupEntry(record, { ...common, reason: "target-gone", targetAction: "already-gone" }),
+        });
+        continue;
+      }
+      throw error;
+    }
+
+    if (record.windowId && inspectedTarget.windowId !== record.windowId) {
+      retained.push(cleanupEntry(record, {
+        ...common,
+        reason: "binding-mismatch",
+        targetAction: "kept",
+        currentWindowId: inspectedTarget.windowId,
+      }));
+      continue;
+    }
+
+    if (inspectedTarget.active !== false) {
+      retained.push(cleanupEntry(record, { ...common, reason: "active", targetAction: "kept" }));
+      continue;
+    }
+
+    if (!activity || now <= activity.timestamp) {
+      retained.push(cleanupEntry(record, { ...common, reason: "activity-unknown", targetAction: "kept" }));
+      continue;
+    }
+
+    const idleMs = now - activity.timestamp;
+    if (idleMs <= idleAfterMs) {
+      retained.push(cleanupEntry(record, { ...common, reason: "not-idle", targetAction: "kept", idleMs }));
+      continue;
+    }
+
+    const closeTarget = record.ownership === "surf-created";
+    operations.push({
+      record,
+      closeTarget,
+      entry: cleanupEntry(record, {
+        ...common,
+        reason: "idle",
+        targetAction: closeTarget ? "close" : "keep",
+        idleMs,
+      }),
+    });
+  }
+
+  if (!dryRun) {
+    for (const operation of operations) {
+      if (operation.closeTarget) {
+        try {
+          const result = await requestExtensionOrThrow(request, "session.cleanup", {
+            type: "SESSION_CLOSE_TARGET",
+            tabId: operation.record.tabId,
+          }, 30000, true);
+          if (result?.alreadyGone === true) {
+            operation.entry.targetAction = "already-gone";
+            operation.entry.targetClosed = false;
+            operation.entry.reason = "target-gone";
+          }
+        } catch (error) {
+          if (error?.code !== "tab_gone") throw error;
+          operation.entry.targetAction = "already-gone";
+          operation.entry.targetClosed = false;
+          operation.entry.reason = "target-gone";
+        }
+      }
+      browserSessionStore.remove(identity, operation.record.name);
+    }
+  }
+
+  return {
+    success: true,
+    dryRun,
+    idleAfter: String(rawIdleAfter).trim(),
+    idleAfterMs,
+    scanned: records.length,
+    inspected,
+    removed: operations.map(({ entry }) => entry),
+    retained,
+  };
+}
+
 async function createSessionBinding(request, identity, name, args, previous = null) {
   const mode = args.tab === true ? "tab" : args.window === true ? "window" : previous?.mode || "window";
   if (args.tab === true && args.window === true) {
@@ -931,6 +1311,7 @@ async function createSessionBinding(request, identity, name, args, previous = nu
       browserEpoch: identity.browserEpoch,
       mode,
       ownership: "surf-created",
+      lastAccessedAt: new Date().toISOString(),
       lastUrl: created.url || url,
       lastTitle: created.title,
       groupId: created.groupId,
@@ -953,7 +1334,7 @@ async function createSessionBinding(request, identity, name, args, previous = nu
 async function handleBrowserSessionCommand(tool, args, request) {
   const identity = await requireBrowserIdentity();
   const name = args.name;
-  if (tool !== "session.list") validateSessionName(name);
+  if (tool !== "session.list" && tool !== "session.cleanup") validateSessionName(name);
 
   if (tool === "session.new") {
     if (browserSessionStore.get(identity, name)) {
@@ -992,6 +1373,10 @@ async function handleBrowserSessionCommand(tool, args, request) {
     return { sessions, browser: identity, scheduler: browserScheduler.stats() };
   }
 
+  if (tool === "session.cleanup") {
+    return cleanupBrowserSessions(identity, request, args);
+  }
+
   const existing = browserSessionStore.get(identity, name);
   if (!existing) {
     throw surfError("session_unknown", `Unknown session: ${name}`, {
@@ -1047,6 +1432,7 @@ async function handleBrowserSessionCommand(tool, args, request) {
       browserEpoch: identity.browserEpoch,
       mode: "tab",
       ownership: "adopted",
+      lastAccessedAt: new Date().toISOString(),
       lastUrl: inspected.url,
       lastTitle: inspected.title,
       frameContext: null,
@@ -1380,7 +1766,12 @@ function sendToolResponse(socket, id, result, error) {
     }
     if (request?.notice) response.notice = request.notice;
     if (formattedError) response.error = formattedError;
-    else response.result = { content: formatToolContent(output, log, { suppressImages: Boolean(context?.isRemote) }) };
+    else {
+      response.result = { content: formatToolContent(output, log, { suppressImages: Boolean(context?.isRemote) }) };
+      if (request?.tool === "tab.new" && Number.isInteger(output?.tabId) && output.tabId > 0) {
+        response.result.tabId = output.tabId;
+      }
+    }
     if (!context?.closed) await sendSocket(socket, response);
   })().catch((sendError) => log(`Error sending tool_response: ${sendError.message}`));
 }
@@ -1500,6 +1891,12 @@ function handleToolRequest(msg, socket, requestContext = requestStorage.getStore
       .catch((error) => sendToolResponse(socket, originalId, null, error.message));
     return;
   }
+  if (tool.startsWith("video.")) {
+    handleVideoRequest(tool, args || {}, msg, requestContext)
+      .then((result) => sendToolResponse(socket, originalId, result, null))
+      .catch((error) => sendToolResponse(socket, originalId, null, error));
+    return;
+  }
   
   const extensionMsg = mapToolToMessage(tool, args, tabId);
   if (!extensionMsg) {
@@ -2414,25 +2811,23 @@ function writeMessage(msg) {
 let inputBuffer = Buffer.alloc(0);
 
 function processInput() {
-  while (inputBuffer.length >= 4) {
-    const msgLen = inputBuffer.readUInt32LE(0);
-    if (inputBuffer.length < 4 + msgLen) break;
-    
-    const jsonStr = inputBuffer.slice(4, 4 + msgLen).toString("utf8");
-    inputBuffer = inputBuffer.slice(4 + msgLen);
-    
+  // Take every complete frame out of the buffer before dispatching: one
+  // chunk routinely carries a TARGET_EVENT and the reply to a tool request.
+  const { frames, rest } = takeFrames(inputBuffer);
+  inputBuffer = rest;
+  for (const jsonStr of frames) {
     try {
       const msg = JSON.parse(jsonStr);
       log(`Received from extension: ${msg.type || "unknown"}${msg.id !== undefined ? ` id=${msg.id}` : ""}`);
 
       if (msg.type === "EXTENSION_HELLO") {
         setBrowserIdentity(msg);
-        return;
+        continue;
       }
 
       if (msg.type === "TARGET_EVENT") {
         handleTargetEvent(msg);
-        return;
+        continue;
       }
       
       if (msg.type === "GET_AUTH") {
@@ -2456,12 +2851,12 @@ function processInput() {
             hint: "Failed to read auth credentials. Run 'pi --login anthropic' in terminal to authenticate."
           });
         }
-        return;
+        continue;
       }
       
       if (msg.type === "API_REQUEST") {
         handleApiRequest(msg, writeMessage);
-        return;
+        continue;
       }
 
       if (msg.type === "PLAYBOOK_WATCH_EVENT") {
@@ -2474,7 +2869,24 @@ function processInput() {
           tabId: msg.tabId,
           timestamp: msg.timestamp || new Date().toISOString(),
         });
-        return;
+        continue;
+      }
+
+      if (msg.type === "VIDEO_FRAME") {
+        if (activeVideoRecorder && msg.recorderId === activeVideoRecorder.recorderId && msg.tabId === activeVideoRecorder.tabId) {
+          activeVideoRecorder.recorder.addFrame(msg.data, Number.isFinite(msg.receivedAt) ? msg.receivedAt : Date.now());
+        }
+        continue;
+      }
+
+      if (msg.type === "VIDEO_ERROR") {
+        if (activeVideoRecorder && (!msg.recorderId || msg.recorderId === activeVideoRecorder.recorderId)) {
+          void settleVideoFailure(activeVideoRecorder, new VideoRecorderError(
+            typeof msg.errorCode === "string" ? msg.errorCode : "video_extension_error",
+            msg.error || "Video screencast failed",
+          ));
+        }
+        continue;
       }
       
       if (msg.type === "STREAM_EVENT") {
@@ -2486,7 +2898,7 @@ function processInput() {
             stream.socket.destroy(error);
           });
         }
-        return;
+        continue;
       }
 
       if (msg.type === "STREAM_ERROR") {
@@ -2499,7 +2911,7 @@ function processInput() {
             })
             .finally(() => stopActiveStream(msg.streamId));
         }
-        return;
+        continue;
       }
       
       
@@ -2512,13 +2924,13 @@ function processInput() {
           if (topLevelResponse && request?.context) {
             completeOwnedRequest(request.context, request.id, "cleanup-settled");
           }
-          return;
+          continue;
         }
         handleFrameContextFailure(pending.request, msg);
         updateFrameContextFromResult(pending.request, pending.tool, msg);
         if (pending.resolve || pending.onComplete) {
           pendingToolRequests.resolve(msg.id, msg);
-          return;
+          continue;
         }
         pendingToolRequests.delete(msg.id);
         {
@@ -2527,7 +2939,11 @@ function processInput() {
           const tabId = storedTabId || msg._resolvedTabId;
           const failAutoScreenshot = (message) => pending.autoScreenshotOutput
             ? sendToolResponse(socket, originalId, null, `Auto-screenshot failed: ${message}`)
-            : sendToolResponse(socket, originalId, { ...msg, autoScreenshotError: message }, null);
+            : sendToolResponse(socket, originalId, {
+                ...msg,
+                screenshotError: message,
+                autoScreenshotError: message,
+              }, null);
           
           if (pending.networkExport && Array.isArray(msg.entries)) {
             try {
@@ -2618,7 +3034,7 @@ function processInput() {
                 }
               })
               .catch((error) => failAutoScreenshot(error.message));
-            return;
+            continue;
           } else if (autoScreenshot && pending.autoScreenshotOutput && !msg.error) {
             failAutoScreenshot(tabId ? "screenshot response was invalid" : "no tab available");
           } else if (msg.results && msg.savePath) {
@@ -2936,9 +3352,18 @@ function shutdown(code = 0) {
   if (shuttingDown) return;
   shuttingDown = true;
   const cleanupPromises = [...connectedSockets].map((socket) => socket.transferCleanup?.() || Promise.resolve());
+  const videoEntry = activeVideoRecorder;
+  const videoCleanup = videoStopPromise || (videoEntry
+    ? (async () => {
+      if (videoEntry.extensionStarted) {
+        try { writeMessage({ type: "VIDEO_STOP", recorderId: videoEntry.recorderId, tabId: videoEntry.tabId }); } catch {}
+      }
+      await videoEntry.recorder.dispose().catch(() => {});
+    })()
+    : Promise.resolve());
   for (const socket of connectedSockets) socket.destroy();
   pendingRequests.clear(); pendingToolRequests.clear(); activeStreams.clear();
-  Promise.allSettled([...cleanupPromises, Promise.resolve(listenerLifecycle?.shutdown())]).finally(scheduleExit);
+  Promise.allSettled([...cleanupPromises, videoCleanup, Promise.resolve(listenerLifecycle?.shutdown())]).finally(scheduleExit);
 }
 function failStartup(error, endpoint) {
   log(`Listener startup failed (${endpoint}): ${error.message}`);