surf-cli 2.8.0 → 2.9.0

package/native/abort.cjs

@@ -0,0 +1,65 @@
+class RequestAbortError extends Error {
+  constructor(message = "Request cancelled") {
+    super(message);
+    this.name = "RequestAbortError";
+    this.code = "SURF_REQUEST_ABORTED";
+  }
+}
+
+function abortError(signal, fallback = "Request cancelled") {
+  if (signal?.reason instanceof Error && signal.reason.name !== "AbortError") return signal.reason;
+  return new RequestAbortError(fallback);
+}
+
+function throwIfAborted(signal, fallback) {
+  if (signal?.aborted) throw abortError(signal, fallback);
+}
+
+function raceAbort(promiseOrFactory, signal, fallback) {
+  if (!signal) return typeof promiseOrFactory === "function" ? promiseOrFactory() : promiseOrFactory;
+  throwIfAborted(signal, fallback);
+  const promise = typeof promiseOrFactory === "function" ? promiseOrFactory() : promiseOrFactory;
+  if (signal.aborted) return Promise.reject(abortError(signal, fallback));
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError(signal, fallback));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve(promise).then(
+      (value) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      },
+    );
+  });
+}
+
+function abortableDelay(ms, signal, fallback) {
+  throwIfAborted(signal, fallback);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(abortError(signal, fallback));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+module.exports = { RequestAbortError, abortError, abortableDelay, raceAbort, throwIfAborted };

package/native/ai-queue.cjs

@@ -0,0 +1,64 @@
+const { abortError } = require("./abort.cjs");
+
+class BoundedAiQueue {
+  constructor({ maxQueued = 8, spacingMs = 2000, audit = () => {}, run = (handler) => handler() } = {}) {
+    this.maxQueued = maxQueued;
+    this.spacingMs = spacingMs;
+    this.audit = audit;
+    this.run = run;
+    this.items = [];
+    this.active = false;
+  }
+
+  enqueue(handler, request) {
+    return new Promise((resolve, reject) => {
+      if (request?.signal.aborted) {
+        reject(abortError(request.signal));
+        return;
+      }
+      if (this.items.length >= this.maxQueued) {
+        reject(new Error("AI request queue is full"));
+        return;
+      }
+      const item = { handler, request, resolve, reject, abortCleanup: null };
+      const onAbort = () => {
+        const index = this.items.indexOf(item);
+        if (index === -1) return;
+        this.items.splice(index, 1);
+        item.abortCleanup = null;
+        reject(abortError(request.signal));
+        this.audit({ event: "request", context: request.context, request, outcome: "queued-cancel" });
+      };
+      if (request?.signal) {
+        request.signal.addEventListener("abort", onAbort, { once: true });
+        item.abortCleanup = () => request.signal.removeEventListener("abort", onAbort);
+      }
+      this.items.push(item);
+      this.#process();
+    });
+  }
+
+  get queued() {
+    return this.items.length;
+  }
+
+  async #process() {
+    if (this.active || this.items.length === 0) return;
+    this.active = true;
+    const item = this.items.shift();
+    item.abortCleanup?.();
+    try {
+      if (item.request?.signal.aborted) throw abortError(item.request.signal);
+      const result = await this.run(item.handler, item.request);
+      if (item.request?.signal.aborted) throw abortError(item.request.signal);
+      item.resolve(result);
+    } catch (error) {
+      item.reject(error);
+    } finally {
+      this.active = false;
+      setTimeout(() => this.#process(), this.spacingMs);
+    }
+  }
+}
+
+module.exports = { BoundedAiQueue };

package/native/aistudio-build.cjs

@@ -1,4 +1,5 @@
 const fs = require("fs");
+const { raceAbort, throwIfAborted } = require("./abort.cjs");
 const { execFileSync } = require("child_process");
 const {
   delay,
@@ -483,26 +484,29 @@ async function build({
   cdpCommand,
   searchDownloads,
   log = () => {},
+  signal,
 }) {
+  throwIfAborted(signal);
+  const guardedSearchDownloads = (...args) => raceAbort(() => searchDownloads(...args), signal);
   const startedAt = Date.now();
   const timeoutMs = Number.isFinite(timeout) ? timeout : 600000;
   const requestedModel = normalizeModelString(model || "");
   const resolvedModel = requestedModel || DEFAULT_MODEL;
 
-  const cookieResult = await getCookies();
+  const cookieResult = await raceAbort(getCookies, signal);
   const cookies = cookieResult?.cookies || [];
   if (!hasRequiredCookies(cookies)) {
     throw new Error("Sign into Google in Chrome first.");
   }
 
-  const tabInfo = await createTab(AISTUDIO_APPS_URL);
+  const tabInfo = await raceAbort(() => createTab(AISTUDIO_APPS_URL), signal);
   const tabId = tabInfo?.tabId;
   if (!tabId) {
     throw new Error(`Failed to create AI Studio tab: ${JSON.stringify(tabInfo)}`);
   }
 
-  const cdp = (expression) => cdpEvaluate(tabId, expression);
-  const inputCdp = (method, params) => cdpCommand(tabId, method, params);
+  const cdp = (expression) => raceAbort(() => cdpEvaluate(tabId, expression), signal);
+  const inputCdp = (method, params) => raceAbort(() => cdpCommand(tabId, method, params), signal);
 
   let buildDuration = null;
   let zipPath = null;
@@ -510,7 +514,7 @@ async function build({
   let modelUsed = resolvedModel;
 
   try {
-    await waitForBuildPageReady(cdp, 30000);
+    await raceAbort(waitForBuildPageReady(cdp, 30000), signal);
 
     if (requestedModel) {
       const applied = await selectModelInAdvancedSettings(cdp, inputCdp, requestedModel, log);
@@ -518,20 +522,20 @@ async function build({
     }
 
     await typePromptAndBuild(cdp, inputCdp, prompt);
-    const completion = await waitForBuildCompletion(cdp, timeoutMs, log);
+    const completion = await raceAbort(waitForBuildCompletion(cdp, timeoutMs, log), signal);
     buildDuration = completion.buildDuration;
 
-    await activateCodeTab(cdp, inputCdp);
-    await waitForDownloadButton(cdp, 5000);
+    await raceAbort(activateCodeTab(cdp, inputCdp), signal);
+    await raceAbort(waitForDownloadButton(cdp, 5000), signal);
 
-    const beforeDownloads = await searchDownloads({
+    const beforeDownloads = await guardedSearchDownloads({
       limit: 1,
       orderBy: ["-startTime"],
     });
     const latestIdBefore = beforeDownloads?.[0]?.id || 0;
 
-    await clickDownloadButton(cdp);
-    zipPath = await waitForDownloadComplete(searchDownloads, latestIdBefore, 30000);
+    await raceAbort(clickDownloadButton(cdp), signal);
+    zipPath = await waitForDownloadComplete(guardedSearchDownloads, latestIdBefore, 30000);
 
     if (output) {
       const outputDir = String(output);
@@ -553,8 +557,12 @@ async function build({
       tookMs: Date.now() - startedAt,
     };
   } finally {
-    if (!keepOpen) {
-      await closeTab(tabId).catch(() => {});
+    if (!keepOpen || signal?.aborted) {
+      try {
+        await closeTab(tabId);
+      } catch (error) {
+        log(`Failed to close AI Studio Build tab ${tabId}: ${error?.message || error}`);
+      }
     }
   }
 }

package/native/aistudio-client.cjs

@@ -33,6 +33,7 @@ const {
   waitForGenerateResponseFromNetwork,
   waitForResponse,
 } = require("./aistudio-response.cjs");
+const { raceAbort, throwIfAborted } = require("./abort.cjs");
 
 const DEFAULT_MODEL = "gemini-3.1-pro-preview";
 
@@ -310,22 +311,27 @@ async function query(options) {
     cdpCommand,
     readNetworkEntries,
     log = () => {},
+    signal,
   } = options;
+  throwIfAborted(signal);
 
+  const guardedReadNetworkEntries = readNetworkEntries
+    ? (...args) => raceAbort(() => readNetworkEntries(...args), signal)
+    : readNetworkEntries;
   const startTime = Date.now();
   log("Starting AI Studio query");
 
   const resolvedModel = normalizeModelString(model) || DEFAULT_MODEL;
   log(`Requested model: ${resolvedModel}`);
 
-  const { cookies } = await getCookies();
+  const { cookies } = await raceAbort(getCookies, signal);
   if (!hasRequiredCookies(cookies)) {
     throw new Error("Google login required - sign into Google in Chrome first");
   }
   log(`Got ${cookies.length} cookies`);
 
   const createdUrl = buildAiStudioUrl(resolvedModel);
-  const tabInfo = await createTab(createdUrl);
+  const tabInfo = await raceAbort(() => createTab(createdUrl), signal);
   const { tabId } = tabInfo || {};
 
   if (!tabId) {
@@ -333,21 +339,21 @@ async function query(options) {
   }
   log(`Created tab ${tabId}`);
 
-  const cdp = (expr) => cdpEvaluate(tabId, expr);
-  const inputCdp = (method, params) => cdpCommand(tabId, method, params);
+  const cdp = (expr) => raceAbort(() => cdpEvaluate(tabId, expr), signal);
+  const inputCdp = (method, params) => raceAbort(() => cdpCommand(tabId, method, params), signal);
 
   let baselineGenerateEntryIds = new Set();
 
   try {
-    await waitForPageLoad(cdp);
+    await raceAbort(waitForPageLoad(cdp), signal);
     log("Page loaded");
 
-    await waitForStudioReady(cdp);
+    await raceAbort(waitForStudioReady(cdp), signal);
     log("AI Studio ready");
 
     if (typeof readNetworkEntries === 'function') {
       try {
-        const baselineNetwork = await readNetworkEntries(tabId);
+        const baselineNetwork = await guardedReadNetworkEntries(tabId);
         const baselineEntries = Array.isArray(baselineNetwork?.entries)
           ? baselineNetwork.entries
           : Array.isArray(baselineNetwork?.requests)
@@ -362,6 +368,7 @@ async function query(options) {
 
         log(`Network baseline ready (${baselineGenerateEntryIds.size} GenerateContent entries)`);
       } catch (e) {
+        if (signal?.aborted) throw e;
         log(`Network baseline failed: ${e.message || e}`);
       }
     }
@@ -369,6 +376,7 @@ async function query(options) {
     try {
       await enableUnformattedMarkdownView(cdp, log);
     } catch (e) {
+      if (signal?.aborted) throw e;
       log(`Markdown toggle failed: ${e.message}`);
     }
 
@@ -387,8 +395,8 @@ async function query(options) {
       try {
         log(`Runtime model param missing; retrying direct navigation: ${createdUrl}`);
         await inputCdp('Page.navigate', { url: createdUrl });
-        await waitForPageLoad(cdp);
-        await waitForStudioReady(cdp);
+        await raceAbort(waitForPageLoad(cdp), signal);
+        await raceAbort(waitForStudioReady(cdp), signal);
         runtimeUrl = await evaluate(cdp, 'location.href');
         runtimeModelParam = await evaluate(cdp, `(() => {
           try {
@@ -398,6 +406,7 @@ async function query(options) {
           }
         })()`);
       } catch (e) {
+        if (signal?.aborted) throw e;
         log(`Direct model URL navigation retry failed: ${e.message || e}`);
       }
     }
@@ -408,7 +417,10 @@ async function query(options) {
       log(`Model via UI (no URL param): requested="${resolvedModel}"`);
     }
 
-    const currentModelInfo = await readCurrentModelInfo(cdp).catch(() => ({ found: false, label: '', modelId: '' }));
+    const currentModelInfo = await readCurrentModelInfo(cdp).catch((error) => {
+      if (signal?.aborted) throw error;
+      return { found: false, label: '', modelId: '' };
+    });
 
     log(`AI Studio URL: ${runtimeUrl}`);
     if (currentModelInfo?.label) {
@@ -427,8 +439,9 @@ async function query(options) {
 
     if (!modelApplied && usedUrlParam) {
       try {
-        modelApplied = await waitForModelToApply(cdp, resolvedModel, log);
+        modelApplied = await raceAbort(waitForModelToApply(cdp, resolvedModel, log), signal);
       } catch (e) {
+        if (signal?.aborted) throw e;
         log(`Model apply wait failed: ${e.message}`);
       }
     }
@@ -436,19 +449,20 @@ async function query(options) {
     if (!modelApplied) {
       try {
         log(`Attempting UI model selection fallback: ${resolvedModel}`);
-        await selectModel(cdp, resolvedModel, log);
-        modelApplied = await waitForModelToApply(cdp, resolvedModel, log, 10000);
+        await raceAbort(selectModel(cdp, resolvedModel, log), signal);
+        modelApplied = await raceAbort(waitForModelToApply(cdp, resolvedModel, log, 10000), signal);
       } catch (e) {
+        if (signal?.aborted) throw e;
         log(`UI model selection fallback failed: ${e.message}`);
       }
     }
 
-    await closeModelSelectorIfOpen(cdp, log);
+    await raceAbort(closeModelSelectorIfOpen(cdp, log), signal);
 
-    await typePrompt(cdp, inputCdp, prompt);
+    await raceAbort(typePrompt(cdp, inputCdp, prompt), signal);
     log("Prompt typed");
 
-    await submitPrompt(cdp, inputCdp);
+    await raceAbort(submitPrompt(cdp, inputCdp), signal);
     log("Submitted, waiting for response...");
 
     let response;
@@ -457,10 +471,11 @@ async function query(options) {
       try {
         const networkResult = await waitForGenerateResponseFromNetwork({
           tabId,
-          readNetworkEntries,
+          readNetworkEntries: guardedReadNetworkEntries,
           timeoutMs: timeout,
           baselineEntryIds: baselineGenerateEntryIds,
           prompt,
+          signal,
           log,
         });
 
@@ -474,13 +489,14 @@ async function query(options) {
           `${networkResult.requestId ? ` (request ${networkResult.requestId})` : ''}`
         );
       } catch (networkErr) {
+        if (signal?.aborted) throw networkErr;
         log(`Network extraction failed, falling back to DOM: ${networkErr.message || networkErr}`);
 
         const remainingTimeoutMs = Math.max(timeout - (Date.now() - startTime), 10000);
-        response = await waitForResponse(cdp, remainingTimeoutMs, prompt, log);
+        response = await raceAbort(waitForResponse(cdp, remainingTimeoutMs, prompt, log), signal);
       }
     } else {
-      response = await waitForResponse(cdp, timeout, prompt, log);
+      response = await raceAbort(waitForResponse(cdp, timeout, prompt, log), signal);
     }
 
     const thinkingInfo = response.thinkingTime ? ` (thought for ${response.thinkingTime}s)` : '';
@@ -493,7 +509,11 @@ async function query(options) {
       tookMs: Date.now() - startTime,
     };
   } finally {
-    await closeTab(tabId).catch(() => {});
+    try {
+      await closeTab(tabId);
+    } catch (error) {
+      log(`Failed to close AI Studio tab ${tabId}: ${error?.message || error}`);
+    }
   }
 }
 

package/native/browser-lock.cjs

@@ -11,8 +11,8 @@ function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
-function getBrowserLockDir(socketPath, tempDir) {
-  const hash = crypto.createHash("sha256").update(socketPath).digest("hex").slice(0, 16);
+function getBrowserLockDir(endpointKey, tempDir) {
+  const hash = crypto.createHash("sha256").update(endpointKey).digest("hex").slice(0, 16);
   return path.join(tempDir, `surf-lock-${hash}`);
 }
 

package/native/chatgpt-client.cjs

@@ -1,4 +1,5 @@
 const path = require("path");
+const { abortableDelay, raceAbort, throwIfAborted } = require("./abort.cjs");
 
 const CHATGPT_URL = "https://chatgpt.com/";
 
@@ -14,8 +15,8 @@ const SELECTORS = {
   cloudflareScript: 'script[src*="/challenge-platform/"]',
 };
 
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function delay(ms, signal) {
+  return abortableDelay(ms, signal);
 }
 
 function buildClickDispatcher() {
@@ -189,8 +190,10 @@ function isChatGPTResponseComplete(snapshot, stableCycles, stableMs) {
   return stableCycles >= 6 && stableMs >= 1200;
 }
 
-async function evaluate(cdp, expression) {
+async function evaluate(cdp, expression, signal) {
+  throwIfAborted(signal);
   const result = await cdp(expression);
+  throwIfAborted(signal);
   if (result.exceptionDetails) {
     const desc = result.exceptionDetails.exception?.description || 
                  result.exceptionDetails.text || 
@@ -203,14 +206,15 @@ async function evaluate(cdp, expression) {
   return result.result?.value;
 }
 
-async function waitForPageLoad(cdp, timeoutMs = 45000) {
+async function waitForPageLoad(cdp, timeoutMs = 45000, signal) {
+  throwIfAborted(signal);
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const ready = await evaluate(cdp, "document.readyState");
     if (ready === "complete" || ready === "interactive") {
       return;
     }
-    await delay(100);
+    await delay(100, signal);
   }
   throw new Error("Page did not load in time");
 }
@@ -252,7 +256,8 @@ async function checkLoginStatus(cdp) {
   return result || { status: 0 };
 }
 
-async function waitForPromptReady(cdp, timeoutMs = 30000) {
+async function waitForPromptReady(cdp, timeoutMs = 30000, signal) {
+  throwIfAborted(signal);
   const deadline = Date.now() + timeoutMs;
   const selectors = JSON.stringify(SELECTORS.promptTextarea.split(", "));
   while (Date.now() < deadline) {
@@ -270,7 +275,7 @@ async function waitForPromptReady(cdp, timeoutMs = 30000) {
       })()`
     );
     if (found) return true;
-    await delay(200);
+    await delay(200, signal);
   }
   return false;
 }
@@ -302,7 +307,8 @@ function resolveChatGPTModelMenuOption(items, desiredModel) {
   }) || null;
 }
 
-async function selectModel(cdp, desiredModel, timeoutMs = 8000) {
+async function selectModel(cdp, desiredModel, timeoutMs = 8000, signal) {
+  throwIfAborted(signal);
   const modelButton = await evaluate(
     cdp,
     `(() => {
@@ -321,7 +327,7 @@ async function selectModel(cdp, desiredModel, timeoutMs = 8000) {
       if (btn) dispatchClickSequence(btn);
     })()`
   );
-  await delay(300);
+  await delay(300, signal);
 
   const normalizedModel = normalizeChatGPTModelChoice(desiredModel);
   const deadline = Date.now() + timeoutMs;
@@ -361,7 +367,7 @@ async function selectModel(cdp, desiredModel, timeoutMs = 8000) {
             if (item) dispatchClickSequence(item);
           })()`
         );
-        await delay(200);
+        await delay(200, signal);
         return match.label;
       }
 
@@ -379,13 +385,14 @@ async function selectModel(cdp, desiredModel, timeoutMs = 8000) {
       );
     }
 
-    await delay(100);
+    await delay(100, signal);
   }
 
   throw new Error(`Model not found: ${desiredModel} (timeout)`);
 }
 
-async function typePrompt(cdp, inputCdp, prompt) {
+async function typePrompt(cdp, inputCdp, prompt, signal) {
+  throwIfAborted(signal);
   const selectors = JSON.stringify(SELECTORS.promptTextarea.split(", "));
   const encodedPrompt = JSON.stringify(prompt);
   const focused = await evaluate(
@@ -416,7 +423,7 @@ async function typePrompt(cdp, inputCdp, prompt) {
     throw new Error("Failed to focus prompt textarea");
   }
   await inputCdp("Input.insertText", { text: prompt });
-  await delay(300);
+  await delay(300, signal);
   const verified = await evaluate(
     cdp,
     `(() => {
@@ -449,7 +456,8 @@ async function typePrompt(cdp, inputCdp, prompt) {
   }
 }
 
-async function clickSend(cdp, inputCdp) {
+async function clickSend(cdp, inputCdp, signal) {
+  throwIfAborted(signal);
   const selectors = SELECTORS.sendButton.split(", ");
   const selectorsJson = JSON.stringify(selectors);
   const deadline = Date.now() + 8000;
@@ -475,7 +483,7 @@ async function clickSend(cdp, inputCdp) {
     );
     if (result === "clicked") return true;
     if (result === "missing") break;
-    await delay(100);
+    await delay(100, signal);
   }
   await inputCdp("Input.dispatchKeyEvent", {
     type: "keyDown",
@@ -574,8 +582,10 @@ async function waitForResponse(
   cdp,
   timeoutMs = 2700000,
   baselineAssistant,
-  baselineAssistantCount
+  baselineAssistantCount,
+  signal
 ) {
+  throwIfAborted(signal);
   const deadline = Date.now() + timeoutMs;
   let previousText = "";
   let stableCycles = 0;
@@ -588,7 +598,7 @@ async function waitForResponse(
     const snapshot = await readChatGPTResponseSnapshot(cdp);
 
     if (!snapshot) {
-      await delay(400);
+      await delay(400, signal);
       continue;
     }
 
@@ -602,7 +612,7 @@ async function waitForResponse(
     );
 
     if (!hasNewAssistantContent) {
-      await delay(400);
+      await delay(400, signal);
       continue;
     }
 
@@ -630,7 +640,7 @@ async function waitForResponse(
       };
     }
 
-    await delay(400);
+    await delay(400, signal);
   }
 
   throw new Error("Response timeout");
@@ -649,26 +659,31 @@ async function query(options) {
     cdpCommand,
     uploadFile,
     log = () => {},
+    signal,
   } = options;
+  throwIfAborted(signal);
+  const guardedUploadFile = uploadFile
+    ? (...args) => raceAbort(() => uploadFile(...args), signal)
+    : uploadFile;
   const startTime = Date.now();
   log("Starting ChatGPT query");
-  const { cookies } = await getCookies();
+  const { cookies } = await raceAbort(getCookies, signal);
   if (!hasRequiredCookies(cookies)) {
     throw new Error("ChatGPT login required");
   }
   log(`Got ${cookies.length} cookies`);
-  const tabInfo = await createTab();
+  const tabInfo = await raceAbort(createTab, signal);
   const { tabId } = tabInfo;
   if (!tabId) {
     throw new Error("Failed to create ChatGPT tab");
   }
   log(`Created tab ${tabId}`);
   
-  const cdp = (expr) => cdpEvaluate(tabId, expr);
-  const inputCdp = (method, params) => cdpCommand(tabId, method, params);
+  const cdp = (expr) => raceAbort(() => cdpEvaluate(tabId, expr), signal);
+  const inputCdp = (method, params) => raceAbort(() => cdpCommand(tabId, method, params), signal);
   
   try {
-    await waitForPageLoad(cdp);
+    await waitForPageLoad(cdp, 45000, signal);
     log("Page loaded");
     if (await isCloudflareBlocked(cdp)) {
       throw new Error("Cloudflare challenge detected - complete in browser");
@@ -685,13 +700,13 @@ async function query(options) {
       throw new Error("ChatGPT login required");
     }
     log("Login verified");
-    const promptReady = await waitForPromptReady(cdp);
+    const promptReady = await waitForPromptReady(cdp, 30000, signal);
     if (!promptReady) {
       throw new Error("Prompt textarea not ready");
     }
     log("Prompt ready");
     if (model) {
-      const selectedLabel = await selectModel(cdp, model);
+      const selectedLabel = await selectModel(cdp, model, 8000, signal);
       log(`Selected model: ${selectedLabel}`);
     }
     if (file) {
@@ -701,7 +716,7 @@ async function query(options) {
       const files = Array.isArray(file) ? file : [file];
       const absFiles = files.map((filePath) => path.resolve(process.cwd(), filePath));
       log(`Uploading ${absFiles.length} file(s) to ChatGPT...`);
-      const uploadResult = await uploadFile(tabId, absFiles);
+      const uploadResult = await guardedUploadFile(tabId, absFiles);
       if (uploadResult?.error) {
         throw new Error(`ChatGPT file upload failed: ${uploadResult.error}`);
       }
@@ -709,18 +724,19 @@ async function query(options) {
         throw new Error("ChatGPT file upload failed: upload did not report success");
       }
       log("File uploaded, waiting for ChatGPT attachment processing...");
-      await delay(1500);
+      await delay(1500, signal);
     }
-    await typePrompt(cdp, inputCdp, prompt);
+    await typePrompt(cdp, inputCdp, prompt, signal);
     log("Prompt typed");
     const baseline = normalizeResponseSnapshot(await readChatGPTResponseSnapshot(cdp));
-    await clickSend(cdp, inputCdp);
+    await clickSend(cdp, inputCdp, signal);
     log("Prompt sent, waiting for response...");
     const response = await waitForResponse(
       cdp,
       timeout,
       baseline.latestAssistant,
-      baseline.assistantCount
+      baseline.assistantCount,
+      signal
     );
     log(`Response received (${response.text.length} chars)`);
     return {