surf-cli 2.13.1 → 2.15.0

package/native/browser-scheduler.cjs

@@ -0,0 +1,348 @@
+const { surfError } = require("./surf-error.cjs");
+
+const DEFAULT_MAX_QUEUED = 64;
+const DEFAULT_MAX_PER_LANE = 16;
+const DEFAULT_QUEUE_TIMEOUT_MS = 60000;
+const WRITE_SCOPES = new Set(["browser-write", "provider"]);
+
+function normalizeResourceKeys(resourceKeys) {
+  if (!Array.isArray(resourceKeys)) return [];
+  return [...new Set(resourceKeys.filter((key) => typeof key === "string" && key).map(String))].sort();
+}
+
+class BrowserScheduler {
+  constructor({
+    maxQueued = DEFAULT_MAX_QUEUED,
+    maxPerLane = DEFAULT_MAX_PER_LANE,
+    queueTimeoutMs = DEFAULT_QUEUE_TIMEOUT_MS,
+    audit = () => {},
+  } = {}) {
+    this.maxQueued = maxQueued;
+    this.maxPerLane = maxPerLane;
+    this.queueTimeoutMs = queueTimeoutMs;
+    this.audit = audit;
+    this.queue = [];
+    this.activeTabs = new Map();
+    this.activeReaders = new Set();
+    this.activeWriter = null;
+    this.activeResources = new Map();
+    this.sequence = 0;
+  }
+
+  acquire({ scope, laneKey, resourceKeys = [], wait = true, signal, request, session } = {}) {
+    const normalizedResources = normalizeResourceKeys(resourceKeys);
+    if (scope === "host" && normalizedResources.length === 0) {
+      return Promise.resolve(this.#token({
+        scope,
+        laneKey,
+        resourceKeys: normalizedResources,
+        request,
+        session,
+        queuedAt: Date.now(),
+      }));
+    }
+    if (scope === "tab" && !laneKey) {
+      return Promise.reject(surfError("target_required", "tab-scoped command requires a resolved tab"));
+    }
+    if (!scope || !["host", "tab", "browser-read", "browser-write", "provider"].includes(scope)) {
+      return Promise.reject(surfError("scheduler_scope_invalid", `invalid browser scheduler scope: ${scope}`));
+    }
+    if (signal?.aborted) return Promise.reject(signal.reason || surfError("request_cancelled", "Request cancelled"));
+
+    const entry = {
+      id: ++this.sequence,
+      scope,
+      laneKey,
+      resourceKeys: normalizedResources,
+      wait,
+      signal,
+      request,
+      session,
+      queuedAt: Date.now(),
+      resolve: null,
+      reject: null,
+      timer: null,
+      abortCleanup: null,
+    };
+
+    if (this.#canGrantImmediately(entry)) {
+      return Promise.resolve(this.#grant(entry));
+    }
+    if (!wait) {
+      const blockedResources = this.#blockedResourceKeys(entry);
+      if (blockedResources.length > 0) {
+        return Promise.reject(surfError("resource_busy", `shared resource is busy: ${blockedResources.join(", ")}`, {
+          laneKey,
+          session,
+          resourceKeys: blockedResources,
+          retryable: true,
+          queue: this.stats({ laneKey, resourceKeys: normalizedResources }),
+          recoveryCommand: session ? `surf session.info ${session}` : "surf session.list --refresh",
+        }));
+      }
+      const browserBlocked = Boolean(this.activeWriter) || this.#hasQueuedWriter() || WRITE_SCOPES.has(scope);
+      const code = browserBlocked ? "browser_busy" : "tab_busy";
+      const message = browserBlocked
+        ? "a browser-wide writer is active or waiting"
+        : `tab lane is busy: ${laneKey}`;
+      return Promise.reject(surfError(code, message, {
+        laneKey,
+        session,
+        retryable: true,
+        queue: this.stats({ laneKey, resourceKeys: normalizedResources }),
+        recoveryCommand: session ? `surf session.info ${session}` : "surf session.list --refresh",
+      }));
+    }
+    if (this.queue.length >= this.maxQueued) {
+      return Promise.reject(surfError("queue_full", "browser scheduler queue is full", { retryable: true }));
+    }
+    if (scope === "tab") {
+      const laneDepth = this.queue.filter((queued) => queued.scope === "tab" && queued.laneKey === laneKey).length;
+      if (laneDepth >= this.maxPerLane) {
+        return Promise.reject(surfError("queue_full", `tab lane queue is full: ${laneKey}`, {
+          laneKey,
+          retryable: true,
+        }));
+      }
+    }
+
+    return new Promise((resolve, reject) => {
+      entry.resolve = resolve;
+      entry.reject = reject;
+      entry.timer = setTimeout(() => {
+        this.#removeQueued(entry);
+        reject(surfError("queue_timeout", "timed out waiting for browser admission", {
+          laneKey,
+          session,
+          resourceKeys: normalizedResources,
+          retryable: true,
+          queue: this.stats({ laneKey, resourceKeys: normalizedResources }),
+          recoveryCommand: session ? `surf session.info ${session}` : "surf session.list --refresh",
+        }));
+        this.audit({
+          event: "scheduler",
+          outcome: "queue-timeout",
+          request,
+          scope,
+          laneKey,
+          resourceKeys: normalizedResources,
+        });
+        this.#drain();
+      }, this.queueTimeoutMs);
+      if (signal) {
+        const onAbort = () => {
+          if (!this.#removeQueued(entry)) return;
+          reject(signal.reason || surfError("request_cancelled", "Request cancelled"));
+          this.audit({
+            event: "scheduler",
+            outcome: "queue-cancel",
+            request,
+            scope,
+            laneKey,
+            resourceKeys: normalizedResources,
+          });
+          this.#drain();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        entry.abortCleanup = () => signal.removeEventListener("abort", onAbort);
+      }
+      this.queue.push(entry);
+      this.audit({
+        event: "scheduler",
+        outcome: "queued",
+        request,
+        scope,
+        laneKey,
+        resourceKeys: normalizedResources,
+        queueDepth: this.queue.length,
+      });
+      this.#drain();
+    });
+  }
+
+  stats({ laneKey, resourceKeys = [] } = {}) {
+    const queuedByLane = {};
+    for (const entry of this.queue) {
+      if (entry.scope !== "tab") continue;
+      queuedByLane[entry.laneKey] = (queuedByLane[entry.laneKey] || 0) + 1;
+    }
+    const writer = this.activeWriter
+      ? {
+          scope: this.activeWriter.scope,
+          session: this.activeWriter.session || null,
+          acquiredAt: this.activeWriter.acquiredAt,
+        }
+      : null;
+    const queuedWriters = this.queue.filter((entry) => WRITE_SCOPES.has(entry.scope));
+    const normalizedResources = normalizeResourceKeys(resourceKeys);
+    const activeResources = [...this.activeResources.entries()].map(([key, token]) => ({
+      key,
+      scope: token.scope,
+      laneKey: token.laneKey || null,
+      session: token.session || null,
+      acquiredAt: token.acquiredAt,
+    }));
+    return {
+      activeTabLanes: [...this.activeTabs.entries()].map(([key, token]) => ({
+        laneKey: key,
+        session: token.session || null,
+        acquiredAt: token.acquiredAt,
+      })),
+      activeReaders: this.activeReaders.size,
+      writerActive: Boolean(writer),
+      writer,
+      activeResources,
+      blockedResourceKeys: normalizedResources.filter((key) => this.activeResources.has(key)),
+      queued: this.queue.length,
+      queuedWriters: queuedWriters.length,
+      queuedWriterSessions: queuedWriters.map((entry) => entry.session || null),
+      queuedByLane,
+      lane: laneKey ? {
+        laneKey,
+        active: this.activeTabs.has(laneKey),
+        queued: queuedByLane[laneKey] || 0,
+        blockedBy: this.activeWriter || queuedWriters.length > 0
+          ? "browser-writer"
+          : this.activeTabs.has(laneKey)
+            ? "own-tab"
+            : null,
+      } : undefined,
+    };
+  }
+
+  #blockedResourceKeys(entry) {
+    return entry.resourceKeys.filter((key) => this.activeResources.has(key));
+  }
+
+  #hasQueuedWriter() {
+    return this.queue.some((entry) => WRITE_SCOPES.has(entry.scope));
+  }
+
+  #canGrantImmediately(entry) {
+    if (this.queue.length > 0) return false;
+    if (this.#blockedResourceKeys(entry).length > 0) return false;
+    if (entry.scope === "host") return true;
+    if (WRITE_SCOPES.has(entry.scope)) {
+      return !this.activeWriter && this.activeReaders.size === 0 && this.activeTabs.size === 0;
+    }
+    if (this.activeWriter || this.#hasQueuedWriter()) return false;
+    if (entry.scope === "browser-read") return true;
+    return !this.activeTabs.has(entry.laneKey);
+  }
+
+  #grant(entry) {
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.abortCleanup?.();
+    const token = this.#token(entry);
+    if (WRITE_SCOPES.has(entry.scope)) this.activeWriter = token;
+    else if (entry.scope === "browser-read") this.activeReaders.add(token);
+    else if (entry.scope === "tab") this.activeTabs.set(entry.laneKey, token);
+    for (const key of entry.resourceKeys) this.activeResources.set(key, token);
+    this.audit({
+      event: "scheduler",
+      outcome: "acquired",
+      request: entry.request,
+      scope: entry.scope,
+      laneKey: entry.laneKey,
+      resourceKeys: entry.resourceKeys,
+      queueMs: Date.now() - entry.queuedAt,
+    });
+    return token;
+  }
+
+  #token(entry) {
+    let released = false;
+    const token = {
+      scope: entry.scope,
+      laneKey: entry.laneKey,
+      resourceKeys: entry.resourceKeys,
+      session: entry.session,
+      queuedAt: entry.queuedAt,
+      acquiredAt: Date.now(),
+      release: () => {
+        if (released) return;
+        released = true;
+        if (WRITE_SCOPES.has(entry.scope)) {
+          if (this.activeWriter === token) this.activeWriter = null;
+        } else if (entry.scope === "browser-read") this.activeReaders.delete(token);
+        else if (entry.scope === "tab" && this.activeTabs.get(entry.laneKey) === token) {
+          this.activeTabs.delete(entry.laneKey);
+        }
+        for (const key of entry.resourceKeys) {
+          if (this.activeResources.get(key) === token) this.activeResources.delete(key);
+        }
+        this.audit({
+          event: "scheduler",
+          outcome: "released",
+          request: entry.request,
+          scope: entry.scope,
+          laneKey: entry.laneKey,
+          resourceKeys: entry.resourceKeys,
+          session: entry.session,
+        });
+        this.#drain();
+      },
+    };
+    return token;
+  }
+
+  #removeQueued(entry) {
+    const index = this.queue.indexOf(entry);
+    if (index === -1) return false;
+    this.queue.splice(index, 1);
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.abortCleanup?.();
+    return true;
+  }
+
+  #drain() {
+    for (let index = 0; index < this.queue.length;) {
+      const entry = this.queue[index];
+      if (entry.scope !== "host" || this.#blockedResourceKeys(entry).length > 0) {
+        index += 1;
+        continue;
+      }
+      this.queue.splice(index, 1);
+      entry.resolve(this.#grant(entry));
+    }
+
+    if (this.activeWriter) return;
+    const writerIndex = this.queue.findIndex((entry) => WRITE_SCOPES.has(entry.scope));
+    if (writerIndex !== -1) {
+      const writer = this.queue[writerIndex];
+      if (
+        this.activeReaders.size > 0 ||
+        this.activeTabs.size > 0 ||
+        this.#blockedResourceKeys(writer).length > 0
+      ) return;
+      this.queue.splice(writerIndex, 1);
+      writer.resolve(this.#grant(writer));
+      return;
+    }
+
+    for (let index = 0; index < this.queue.length;) {
+      const entry = this.queue[index];
+      if (this.#blockedResourceKeys(entry).length > 0) {
+        index += 1;
+        continue;
+      }
+      let grant = false;
+      if (entry.scope === "browser-read") grant = true;
+      else if (entry.scope === "tab") grant = !this.activeTabs.has(entry.laneKey);
+      if (!grant) {
+        index += 1;
+        continue;
+      }
+      this.queue.splice(index, 1);
+      entry.resolve(this.#grant(entry));
+    }
+  }
+}
+
+module.exports = {
+  BrowserScheduler,
+  DEFAULT_MAX_PER_LANE,
+  DEFAULT_MAX_QUEUED,
+  DEFAULT_QUEUE_TIMEOUT_MS,
+  normalizeResourceKeys,
+};

package/native/browser-session-store.cjs

@@ -0,0 +1,271 @@
+const crypto = require("crypto");
+const {
+  atomicWriteJson,
+  getPrivateStateRoot,
+  privateStatePath,
+  readPrivateJson,
+} = require("./private-state.cjs");
+const { surfError } = require("./surf-error.cjs");
+
+const STORE_VERSION = 1;
+const SESSION_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+
+function normalizeName(name) {
+  return String(name || "").toLowerCase();
+}
+
+function validateSessionName(name) {
+  if (typeof name !== "string" || !SESSION_NAME_PATTERN.test(name)) {
+    throw surfError(
+      "session_name_invalid",
+      "session name must be 1-64 characters using letters, numbers, dot, underscore, or hyphen",
+    );
+  }
+  return name;
+}
+
+function emptyState() {
+  return { version: STORE_VERSION, browsers: {} };
+}
+
+class BrowserSessionStore {
+  constructor({ filePath = privateStatePath("browser-sessions.json"), root = getPrivateStateRoot(), now = () => new Date().toISOString() } = {}) {
+    this.filePath = filePath;
+    this.root = root;
+    this.now = now;
+  }
+
+  load() {
+    let state;
+    try {
+      state = readPrivateJson(this.filePath, emptyState(), { root: this.root });
+    } catch (error) {
+      throw surfError("state_read_failed", `failed to read browser sessions: ${error.message}`, { cause: error });
+    }
+    if (!state || state.version !== STORE_VERSION || !state.browsers || typeof state.browsers !== "object") {
+      throw surfError("state_read_failed", `browser session state is invalid: ${this.filePath}`);
+    }
+    return state;
+  }
+
+  save(state) {
+    try {
+      atomicWriteJson(this.filePath, state, { root: this.root });
+    } catch (error) {
+      throw surfError("state_write_failed", `failed to save browser sessions: ${error.message}`, {
+        cause: error,
+      });
+    }
+  }
+
+  bucket(state, browserInstanceId, create = false) {
+    if (!browserInstanceId) throw surfError("extension_identity_missing", "browser instance identity is unavailable");
+    let bucket = state.browsers[browserInstanceId];
+    if (!bucket && create) {
+      bucket = { sessions: {}, namedTabs: {} };
+      state.browsers[browserInstanceId] = bucket;
+    }
+    return bucket || { sessions: {}, namedTabs: {} };
+  }
+
+  list(identity) {
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, false);
+    return Object.values(bucket.sessions || {})
+      .map((entry) => ({ ...entry }))
+      .sort((left, right) => left.name.localeCompare(right.name));
+  }
+
+  get(identity, name) {
+    validateSessionName(name);
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, false);
+    const record = bucket.sessions?.[normalizeName(name)];
+    return record ? { ...record } : null;
+  }
+
+  findByTab(identity, tabId, exceptName) {
+    const exceptKey = exceptName ? normalizeName(exceptName) : null;
+    return this.list(identity).find((record) => (
+      record.tabId === tabId &&
+      record.browserEpoch === identity.browserEpoch &&
+      normalizeName(record.name) !== exceptKey &&
+      !record.invalidReason
+    )) || null;
+  }
+
+  create(identity, name, values) {
+    validateSessionName(name);
+    const key = normalizeName(name);
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, true);
+    if (bucket.sessions[key]) {
+      throw surfError("session_exists", `session already exists: ${name}`, {
+        session: name,
+        recoveryCommand: `surf session.ensure ${name}`,
+      });
+    }
+    const timestamp = this.now();
+    const record = {
+      ...values,
+      bindingId: crypto.randomUUID(),
+      name,
+      browserInstanceId: identity.browserInstanceId,
+      browserEpoch: identity.browserEpoch,
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      lastValidatedAt: values.lastValidatedAt || timestamp,
+    };
+    bucket.sessions[key] = record;
+    this.save(state);
+    return { ...record };
+  }
+
+  replace(identity, name, values) {
+    validateSessionName(name);
+    const key = normalizeName(name);
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, true);
+    const existing = bucket.sessions[key];
+    const timestamp = this.now();
+    const record = {
+      ...existing,
+      ...values,
+      bindingId: existing?.bindingId || crypto.randomUUID(),
+      name: existing?.name || name,
+      browserInstanceId: identity.browserInstanceId,
+      browserEpoch: identity.browserEpoch,
+      createdAt: existing?.createdAt || timestamp,
+      updatedAt: timestamp,
+      lastValidatedAt: values.lastValidatedAt || timestamp,
+    };
+    delete record.invalidReason;
+    delete record.invalidatedAt;
+    bucket.sessions[key] = record;
+    this.save(state);
+    return { ...record };
+  }
+
+  update(identity, name, patch) {
+    const existing = this.get(identity, name);
+    if (!existing) throw surfError("session_unknown", `unknown session: ${name}`, { session: name });
+    return this.replace(identity, name, { ...existing, ...patch, updatedAt: this.now() });
+  }
+
+  remove(identity, name) {
+    validateSessionName(name);
+    const key = normalizeName(name);
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, false);
+    const existing = bucket.sessions?.[key];
+    if (!existing) return null;
+    delete bucket.sessions[key];
+    this.save(state);
+    return { ...existing };
+  }
+
+  invalidateByTab(identity, tabId, reason = "tab_gone") {
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, false);
+    let changed = false;
+    for (const record of Object.values(bucket.sessions || {})) {
+      if (record.tabId !== tabId) continue;
+      record.invalidReason = reason;
+      record.invalidatedAt = this.now();
+      record.updatedAt = record.invalidatedAt;
+      changed = true;
+    }
+    for (const [key, entry] of Object.entries(bucket.namedTabs || {})) {
+      if (entry.tabId === tabId) {
+        delete bucket.namedTabs[key];
+        changed = true;
+      }
+    }
+    if (changed) this.save(state);
+    return changed;
+  }
+
+  invalidateByWindow(identity, windowId, reason = "window_gone") {
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, false);
+    let changed = false;
+    for (const record of Object.values(bucket.sessions || {})) {
+      if (record.windowId !== windowId) continue;
+      record.invalidReason = reason;
+      record.invalidatedAt = this.now();
+      record.updatedAt = record.invalidatedAt;
+      changed = true;
+    }
+    for (const [key, entry] of Object.entries(bucket.namedTabs || {})) {
+      if (entry.windowId === windowId) {
+        delete bucket.namedTabs[key];
+        changed = true;
+      }
+    }
+    if (changed) this.save(state);
+    return changed;
+  }
+
+  updateTabMetadata(identity, tabId, patch) {
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, false);
+    let changed = false;
+    for (const record of Object.values(bucket.sessions || {})) {
+      if (record.tabId !== tabId) continue;
+      Object.assign(record, patch, { updatedAt: this.now() });
+      changed = true;
+    }
+    if (changed) this.save(state);
+    return changed;
+  }
+
+  setNamedTab(identity, name, values) {
+    validateSessionName(name);
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, true);
+    bucket.namedTabs[normalizeName(name)] = {
+      name,
+      browserEpoch: identity.browserEpoch,
+      updatedAt: this.now(),
+      ...values,
+    };
+    this.save(state);
+    return { ...bucket.namedTabs[normalizeName(name)] };
+  }
+
+  getNamedTab(identity, name) {
+    validateSessionName(name);
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, false);
+    const entry = bucket.namedTabs?.[normalizeName(name)];
+    return entry ? { ...entry } : null;
+  }
+
+  listNamedTabs(identity) {
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, false);
+    return Object.values(bucket.namedTabs || {})
+      .map((entry) => ({ ...entry }))
+      .sort((left, right) => left.name.localeCompare(right.name));
+  }
+
+  removeNamedTab(identity, name) {
+    validateSessionName(name);
+    const state = this.load();
+    const bucket = this.bucket(state, identity.browserInstanceId, false);
+    const key = normalizeName(name);
+    const entry = bucket.namedTabs?.[key];
+    if (!entry) return null;
+    delete bucket.namedTabs[key];
+    this.save(state);
+    return { ...entry };
+  }
+}
+
+module.exports = {
+  BrowserSessionStore,
+  SESSION_NAME_PATTERN,
+  STORE_VERSION,
+  normalizeName,
+  validateSessionName,
+};

package/native/chatgpt-client-selection.cjs

@@ -1,15 +1,25 @@
-const CHATGPT_EFFORT_CHOICES = ["light", "standard", "extended", "heavy"];
+const CHATGPT_EFFORT_CHOICES = ["light", "standard", "extended", "heavy", "pro"];
+const CHATGPT_MODEL_ALIASES = new Map([
+  ["instant", "instant"],
+  ["gpt53", "instant"],
+  ["thinking", "thinking"],
+  ["gpt54thinking", "thinking"],
+  ["pro", "gpt56sol"],
+  ["gpt54pro", "pro"],
+  ["55", "gpt55"],
+  ["gpt55", "gpt55"],
+  ["chatgpt55", "gpt55"],
+  ["56sol", "gpt56sol"],
+  ["gpt56sol", "gpt56sol"],
+  ["chatgpt56sol", "gpt56sol"],
+]);
 
 function normalizeChatGPTModelChoice(desiredModel) {
   const normalized = String(desiredModel || "")
     .toLowerCase()
     .replace(/[^a-z0-9]/g, "");
 
-  if (["instant", "gpt53"].includes(normalized)) return "instant";
-  if (["thinking", "gpt54thinking"].includes(normalized)) return "thinking";
-  if (["pro", "gpt54pro"].includes(normalized)) return "pro";
-
-  return normalized;
+  return CHATGPT_MODEL_ALIASES.get(normalized) || normalized;
 }
 
 function normalizeChatGPTEffortChoice(desiredEffort) {
@@ -29,7 +39,9 @@ function normalizedWords(value) {
 function modelCandidateMatches(item, targetModel) {
   const values = [item?.label, item?.testId?.replace(/^model-switcher-/, "")].filter(Boolean);
   return values.some((value) => {
-    if (normalizeChatGPTModelChoice(value) === targetModel) return true;
+    const normalizedValue = normalizeChatGPTModelChoice(value);
+    if (normalizedValue === targetModel) return true;
+    if (targetModel.startsWith("gpt") && normalizedValue.includes(targetModel)) return true;
     const variants = ["instant", "thinking", "pro"].filter((variant) =>
       normalizedWords(value).includes(variant),
     );
@@ -58,9 +70,7 @@ function resolveChatGPTModelMenuOption(items, desiredModel) {
   return uniqueMatch(
     items,
     (item) =>
-      item?.role === "menuitemradio" &&
-      typeof item?.testId === "string" &&
-      item.testId.startsWith("model-switcher-") &&
+      ["button", "menuitem", "menuitemradio", "radio"].includes(item?.role) &&
       modelCandidateMatches(item, targetModel),
   );
 }