surf-cli 2.8.0 → 2.10.0

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");
@@ -648,27 +658,33 @@ async function query(options) {
     cdpEvaluate,
     cdpCommand,
     uploadFile,
+    beforeSubmit,
     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 +701,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 +717,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 +725,20 @@ 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);
+    if (beforeSubmit) await raceAbort(beforeSubmit, signal);
+    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 {