surf-cli 2.7.2 → 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

@@ -0,0 +1,169 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULT_STALE_MS = 30000;
+const DEFAULT_TIMEOUT_MS = 60000;
+const DEFAULT_MIN_WAIT_MS = 50;
+const DEFAULT_MAX_WAIT_MS = 1000;
+
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function getBrowserLockDir(endpointKey, tempDir) {
+  const hash = crypto.createHash("sha256").update(endpointKey).digest("hex").slice(0, 16);
+  return path.join(tempDir, `surf-lock-${hash}`);
+}
+
+function createToken() {
+  if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  return crypto.randomBytes(16).toString("hex");
+}
+
+function readLockOwner(lockDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(lockDir, "owner.json"), "utf8"));
+  } catch (error) {
+    if (error && (error.code === "ENOENT" || error instanceof SyntaxError)) return null;
+    throw error;
+  }
+}
+
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return Boolean(error && error.code === "EPERM");
+  }
+}
+
+function writeLockOwner(lockDir, socketPath, token) {
+  fs.writeFileSync(
+    path.join(lockDir, "owner.json"),
+    JSON.stringify({ pid: process.pid, token, socketPath, createdAt: new Date().toISOString() }),
+  );
+}
+
+function removeLockDir(lockDir) {
+  fs.rmSync(lockDir, { recursive: true, force: true });
+}
+
+function getLockTimestamp(lockDir, owner) {
+  const target = owner ? path.join(lockDir, "owner.json") : lockDir;
+  try {
+    return fs.statSync(target).mtimeMs;
+  } catch (error) {
+    if (error && error.code === "ENOENT") return 0;
+    throw error;
+  }
+}
+
+function ownerMatches(left, right) {
+  if (!left && !right) return true;
+  return Boolean(left && right && left.token && left.token === right.token);
+}
+
+function tryCreateStaleClaim(lockDir, staleMs, now = Date.now()) {
+  const claimDir = path.join(lockDir, "stale-claim");
+  try {
+    fs.mkdirSync(claimDir);
+    return claimDir;
+  } catch (error) {
+    if (!error || error.code !== "EEXIST") throw error;
+    try {
+      if (now - fs.statSync(claimDir).mtimeMs > staleMs) {
+        fs.rmSync(claimDir, { recursive: true, force: true });
+      }
+    } catch (claimError) {
+      if (!claimError || claimError.code !== "ENOENT") throw claimError;
+    }
+    return null;
+  }
+}
+
+function claimAndRemoveStaleLock(lockDir, staleMs, now = Date.now()) {
+  let lockStats;
+  try {
+    lockStats = fs.statSync(lockDir);
+  } catch (error) {
+    if (error && error.code === "ENOENT") return false;
+    throw error;
+  }
+
+  const inspectedOwner = readLockOwner(lockDir);
+  if (inspectedOwner && isProcessAlive(inspectedOwner.pid)) return false;
+  if (now - getLockTimestamp(lockDir, inspectedOwner) <= staleMs) return false;
+
+  const claimDir = tryCreateStaleClaim(lockDir, staleMs, now);
+  if (!claimDir) return false;
+
+  try {
+    const currentOwner = readLockOwner(lockDir);
+    if (!ownerMatches(inspectedOwner, currentOwner)) return false;
+    if (currentOwner && isProcessAlive(currentOwner.pid)) return false;
+    if (!currentOwner && Date.now() - lockStats.mtimeMs <= staleMs) return false;
+
+    removeLockDir(lockDir);
+    return true;
+  } finally {
+    try {
+      fs.rmSync(claimDir, { recursive: true, force: true });
+    } catch {}
+  }
+}
+
+function acquireBrowserLock(socketPath, tempDir, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+  const sleep = options.sleep ?? sleepSync;
+  const lockDir = getBrowserLockDir(socketPath, tempDir);
+  const startedAt = Date.now();
+  let waitMs = options.minWaitMs ?? DEFAULT_MIN_WAIT_MS;
+  const maxWaitMs = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+
+  while (true) {
+    const token = createToken();
+    try {
+      fs.mkdirSync(lockDir, { recursive: false, mode: 0o700 });
+      try {
+        writeLockOwner(lockDir, socketPath, token);
+      } catch (error) {
+        removeLockDir(lockDir);
+        throw error;
+      }
+      let released = false;
+      return {
+        lockDir,
+        release() {
+          if (released) return;
+          released = true;
+          const owner = readLockOwner(lockDir);
+          if (owner && owner.token === token) removeLockDir(lockDir);
+        },
+      };
+    } catch (error) {
+      if (!error || error.code !== "EEXIST") throw error;
+    }
+
+    if (claimAndRemoveStaleLock(lockDir, staleMs)) continue;
+
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new Error(
+        `Timed out waiting for browser lock after ${Math.round(timeoutMs / 1000)}s. Use --no-lock to bypass.`,
+      );
+    }
+
+    sleep(waitMs);
+    waitMs = Math.min(Math.round(waitMs * 1.5), maxWaitMs);
+  }
+}
+
+module.exports = {
+  DEFAULT_STALE_MS,
+  DEFAULT_TIMEOUT_MS,
+  acquireBrowserLock,
+  getBrowserLockDir,
+};