pi-oracle 0.7.4 → 0.7.6

package/extensions/oracle/shared/process-helpers.mjs

@@ -5,6 +5,7 @@
 // Invariants/Assumptions: Process identity is validated with `ps -o lstart=` to defend against PID reuse on macOS.
 
 import { spawn, execFileSync } from "node:child_process";
+import { sweetCookieSafeStoragePasswordScrubbedEnv } from "./browser-profile-helpers.mjs";
 
 /** @typedef {import("./process-helpers.d.mts").OracleTrackedProcessOptions} OracleTrackedProcessOptions */
 /** @typedef {import("./process-helpers.d.mts").OracleDetachedProcessHandle} OracleDetachedProcessHandle */
@@ -20,7 +21,16 @@ function sleep(ms) {
 export function readProcessStartedAt(pid) {
   if (!pid || pid <= 0) return undefined;
   try {
-    const startedAt = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8" }).trim();
+    if (process.platform === "win32") {
+      const startedAt = execFileSync("powershell.exe", [
+        "-NoLogo",
+        "-NoProfile",
+        "-Command",
+        `$p = Get-Process -Id ${Number(pid)} -ErrorAction SilentlyContinue; if ($p) { $p.StartTime.ToUniversalTime().ToString('o') }`,
+      ], { encoding: "utf8", env: sweetCookieSafeStoragePasswordScrubbedEnv() }).trim();
+      return startedAt || undefined;
+    }
+    const startedAt = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", env: sweetCookieSafeStoragePasswordScrubbedEnv() }).trim();
     return startedAt || undefined;
   } catch {
     return undefined;
@@ -118,6 +128,7 @@ export async function terminateTrackedProcess(pid, startedAt, options = {}) {
 export async function spawnDetachedNodeProcess(scriptPath, args = []) {
   const child = spawn(process.execPath, [scriptPath, ...args], {
     detached: true,
+    env: sweetCookieSafeStoragePasswordScrubbedEnv(),
     stdio: "ignore",
   });
   child.unref();

package/extensions/oracle/shared/state-coordination-helpers.mjs

@@ -167,7 +167,7 @@ function readLockProcessPid(path) {
  * @returns {boolean}
  */
 function isStateDirExistsError(error) {
-  return Boolean(error && typeof error === "object" && "code" in error && (error.code === "EEXIST" || error.code === "ENOTEMPTY"));
+  return Boolean(error && typeof error === "object" && "code" in error && (error.code === "EEXIST" || error.code === "ENOTEMPTY" || (process.platform === "win32" && error.code === "EPERM")));
 }
 
 /**
@@ -248,7 +248,13 @@ export async function acquireStateLock(stateDir, kind, key, metadata, timeoutMs
  */
 export async function releaseStatePath(path) {
   if (!path) return;
-  await rm(path, { recursive: true, force: true }).catch(() => undefined);
+  const deadline = Date.now() + (process.platform === "win32" ? 5_000 : 1_000);
+  while (true) {
+    await rm(path, { recursive: true, force: true }).catch(() => undefined);
+    if (!existsSync(path)) return;
+    if (Date.now() >= deadline) return;
+    await sleep(POLL_MS);
+  }
 }
 
 /**

package/extensions/oracle/worker/auth-bootstrap.mjs

@@ -2,14 +2,18 @@
 // Responsibilities: Copy/import cookies, classify auth pages, drive lightweight account-selection flows, and persist diagnostics for auth failures.
 // Scope: Auth bootstrap worker only; long-running oracle job execution stays in run-job.mjs and shared lifecycle/state helpers stay elsewhere.
 // Usage: Spawned by /oracle-auth to prepare the shared auth seed profile used by future oracle jobs.
-// Invariants/Assumptions: Runs against a local macOS Chromium-family profile, preserves private diagnostics, and must fail clearly when auth state cannot be verified.
+// Invariants/Assumptions: Runs against a local Chromium-family profile, preserves private diagnostics, and must fail clearly when auth state cannot be verified.
 import { withLock } from "./state-locks.mjs";
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { appendFile, chmod, lstat, mkdir, mkdtemp, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { getCookies } from "@steipete/sweet-cookie";
+import {
+  assertNotKnownBrowserUserDataPath,
+  sweetCookieSafeStoragePasswordScrubbedEnv,
+} from "../shared/browser-profile-helpers.mjs";
 import { ensureAccountCookie, filterImportableAuthCookies } from "./auth-cookie-policy.mjs";
 import { getCookiesFromConfiguredChromiumSource } from "./chromium-cookie-source.mjs";
 import { buildAllowedChatGptOrigins } from "./chatgpt-ui-helpers.mjs";
@@ -58,7 +62,6 @@ let URL_PATH = "(oracle-auth url path unavailable)";
 let SNAPSHOT_PATH = "(oracle-auth snapshot path unavailable)";
 let BODY_PATH = "(oracle-auth body path unavailable)";
 let SCREENSHOT_PATH = "(oracle-auth screenshot path unavailable)";
-const REAL_CHROME_USER_DATA_DIR = resolve(homedir(), "Library", "Application Support", "Google", "Chrome");
 const DEFAULT_ORACLE_STATE_DIR = "/tmp/pi-oracle-state";
 const ORACLE_STATE_DIR = process.env.PI_ORACLE_STATE_DIR?.trim() || DEFAULT_ORACLE_STATE_DIR;
 const STALE_STAGING_PROFILE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
@@ -140,12 +143,30 @@ async function log(message) {
   await chmod(LOG_PATH, 0o600).catch(() => undefined);
 }
 
+function killProcessTree(child) {
+  if (process.platform === "win32" && child.pid) {
+    spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore", windowsHide: true }).on("error", () => undefined);
+    return;
+  }
+  child.kill("SIGTERM");
+}
+
+function killProcess(child) {
+  if (process.platform === "win32" && child.pid) {
+    spawn("taskkill", ["/pid", String(child.pid), "/f"], { stdio: "ignore", windowsHide: true }).on("error", () => undefined);
+    return;
+  }
+  child.kill("SIGKILL");
+}
+
 function spawnCommand(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     const { timeoutMs = AGENT_BROWSER_COMMAND_TIMEOUT_MS, ...spawnOptions } = options;
     const child = spawn(command, args, {
       stdio: ["pipe", "pipe", "pipe"],
       ...spawnOptions,
+      env: sweetCookieSafeStoragePasswordScrubbedEnv(spawnOptions.env),
+      shell: spawnOptions.shell ?? process.platform === "win32",
     });
     let stdout = "";
     let stderr = "";
@@ -155,8 +176,8 @@ function spawnCommand(command, args, options = {}) {
     if (typeof timeoutMs === "number" && timeoutMs > 0) {
       killTimer = setTimeout(() => {
         timedOut = true;
-        child.kill("SIGTERM");
-        killGraceTimer = setTimeout(() => child.kill("SIGKILL"), AGENT_BROWSER_KILL_GRACE_MS);
+        killProcessTree(child);
+        killGraceTimer = setTimeout(() => killProcess(child), AGENT_BROWSER_KILL_GRACE_MS);
         killGraceTimer.unref?.();
       }, timeoutMs);
       killTimer.unref?.();
@@ -263,16 +284,15 @@ async function sweepStaleStagingProfiles(targetDir) {
 
 async function createProfilePlan(profileDir) {
   const targetDir = resolve(profileDir);
-  if (!targetDir.startsWith("/")) {
+  if (!isAbsolute(targetDir)) {
     throw new Error(`Oracle profileDir must be an absolute path: ${profileDir}`);
   }
   if (targetDir === "/" || targetDir === homedir()) {
     throw new Error(`Oracle profileDir is unsafe: ${targetDir}`);
   }
-  if (targetDir === REAL_CHROME_USER_DATA_DIR || targetDir.startsWith(`${REAL_CHROME_USER_DATA_DIR}/`)) {
-    throw new Error(`Oracle profileDir must not point into the real Chrome user-data directory: ${targetDir}`);
-  }
-
+  assertNotKnownBrowserUserDataPath(targetDir, "Oracle profileDir", {
+    cookieSources: { chromeProfile: config.auth.chromeProfile, chromeCookiePath: config.auth.chromeCookiePath },
+  });
   const stagingDir = `${targetDir}.staging-${Date.now()}`;
   const backupDir = `${targetDir}.prev`;
   await mkdir(dirname(targetDir), { recursive: true, mode: 0o700 });
@@ -552,6 +572,11 @@ function formatAuthFailureGuidance(error) {
       "3. Quit the browser fully.",
       "4. Re-run /oracle-auth.",
     );
+    if (process.platform === "linux") {
+      lines.push(
+        "5. If Chromium encrypted-cookie warnings mention the Linux keyring, install/configure secret-tool or kwallet-query, or set SWEET_COOKIE_LINUX_KEYRING / SWEET_COOKIE_CHROME_SAFE_STORAGE_PASSWORD / SWEET_COOKIE_BRAVE_SAFE_STORAGE_PASSWORD for this run before rerunning.",
+      );
+    }
   }
 
   lines.push(
@@ -592,6 +617,10 @@ async function readRawSourceCookies() {
 
 async function readSourceCookies() {
   await log(`Reading ${providerName()} cookies from ${cookieSourceLabel()}`);
+  // Sweet Cookie reads Linux safe-storage overrides directly from process.env.
+  // Keep the worker's environment stable for the rest of this short-lived
+  // bootstrap process, but scrub every helper/browser subprocess via
+  // spawnCommand's sweetCookieSafeStoragePasswordScrubbedEnv().
   const { cookies, warnings } = await readRawSourceCookies();
 
   if (warnings.length) {

package/extensions/oracle/worker/chatgpt-ui-helpers.d.mts

@@ -11,6 +11,8 @@ export declare const CHATGPT_CANONICAL_APP_ORIGINS: readonly string[];
 
 export declare function buildAllowedChatGptOrigins(chatUrl: string, authUrl?: string): string[];
 export declare function matchesModelFamilyLabel(label: string | undefined, family: OracleUiModelFamily): boolean;
+export declare function matchesRequestedModelControlLabel(label: string | undefined, selection: OracleUiSelection): boolean;
+export declare function matchesCompactIntelligenceOpenerLabel(label: string | undefined): boolean;
 export declare function requestedEffortLabel(selection: OracleUiSelection): string | undefined;
 export declare function effortSelectionVisible(snapshot: string, effortLabel: string | undefined): boolean;
 export declare function thinkingChipVisible(snapshot: string): boolean;

package/extensions/oracle/worker/chatgpt-ui-helpers.mjs

@@ -29,11 +29,15 @@ const AUTO_SWITCH_LABEL = "Auto-switch to Thinking";
 const THINKING_EFFORT_COMBOBOX_LABEL = "Thinking effort";
 const PRO_THINKING_EFFORT_COMBOBOX_LABEL = "Pro thinking effort";
 const EFFORT_LABELS = new Set(["Light", "Standard", "Extended", "Heavy"]);
+const COMPACT_INTELLIGENCE_MENU_PATTERN = /Intelligence.*Instant.*Medium.*High.*Pro/i;
+const COMPACT_INTELLIGENCE_CONTROL_PATTERN = /^(?:Instant(?:\s+5s)?|Medium(?:\s+5\s*[–-]\s*30s)?|High(?:\s+15\s*[–-]\s*60s)?|Pro(?:\s+5\+\s*min)?)$/i;
+const COMPACT_INTELLIGENCE_OPENER_PATTERN = /^(?:Instant|Medium|High|Pro)$/i;
 const BARE_EFFORT_PATTERN = /^(light|standard|extended|heavy)(?:, click to remove)?$/i;
 const INSTANT_CHIP_PATTERN = /^instant(?:, click to remove)?$/i;
 const THINKING_CHIP_PATTERN = /^(?:(light|standard|extended|heavy)\s+)?thinking(?:, click to remove)?$/i;
 const PRO_CHIP_PATTERN = /^(?:(light|standard|extended|heavy)\s+)?pro(?:, click to remove)?$/i;
 const MODEL_FAMILY_CONTROL_KINDS = new Set(["button", "radio", "menuitemradio"]);
+const COMPACT_INTELLIGENCE_CONTROL_KINDS = new Set(["menuitemradio"]);
 
 /**
  * @param {string | undefined} url
@@ -151,9 +155,134 @@ function parseComposerChipSelection(label) {
   return undefined;
 }
 
+function parseCompactIntelligenceSelection(label) {
+  if (/click to remove/i.test(String(label || ""))) return undefined;
+  const normalized = normalizeChipLabel(label);
+  if (!COMPACT_INTELLIGENCE_CONTROL_PATTERN.test(normalized)) return undefined;
+
+  if (/^Instant(?:\s+5s)?$/i.test(normalized)) {
+    return {
+      modelFamily: /** @type {OracleUiModelFamily} */ ("instant"),
+      compactTier: "instant",
+    };
+  }
+  if (/^Medium(?:\s+5\s*[–-]\s*30s)?$/i.test(normalized)) {
+    return {
+      modelFamily: /** @type {OracleUiModelFamily} */ ("thinking"),
+      effort: /** @type {import("./chatgpt-ui-helpers.d.mts").OracleUiEffort} */ ("standard"),
+      compactTier: "medium",
+    };
+  }
+  if (/^High(?:\s+15\s*[–-]\s*60s)?$/i.test(normalized)) {
+    return {
+      modelFamily: /** @type {OracleUiModelFamily} */ ("thinking"),
+      effort: /** @type {import("./chatgpt-ui-helpers.d.mts").OracleUiEffort} */ ("extended"),
+      compactTier: "high",
+    };
+  }
+  if (/^Pro(?:\s+5\+\s*min)?$/i.test(normalized)) {
+    return {
+      modelFamily: /** @type {OracleUiModelFamily} */ ("pro"),
+      compactTier: "pro",
+    };
+  }
+
+  return undefined;
+}
+
+function hasRemovableComposerModelChip(entries) {
+  return entries.some(
+    (entry) => entry.kind === "button" && /click to remove/i.test(String(entry.label || "")) && parseComposerChipSelection(entry.label),
+  );
+}
+
+function hasCompactIntelligenceMenuContext(entries) {
+  return entries.some((entry) => !entry.disabled && entry.kind === "menu" && COMPACT_INTELLIGENCE_MENU_PATTERN.test(normalizeText(entry.label)))
+    || entries.some((entry) => !entry.disabled && entry.kind === "menuitemradio" && checkedState(entry) === true && /\d/.test(String(entry.label || "")) && parseCompactIntelligenceSelection(entry.label));
+}
+
+function hasLegacyEffortCombobox(entries) {
+  return entries.some((entry) => {
+    if (entry.disabled || entry.kind !== "combobox") return false;
+    const label = normalizeText(entry.label).toLowerCase();
+    return label === THINKING_EFFORT_COMBOBOX_LABEL.toLowerCase() || label === PRO_THINKING_EFFORT_COMBOBOX_LABEL.toLowerCase();
+  });
+}
+
+function compactSelectionFromEntry(entry, _entries, _options = {}) {
+  if (entry.disabled || !COMPACT_INTELLIGENCE_CONTROL_KINDS.has(entry.kind || "")) return undefined;
+  if (!/\d/.test(String(entry.label || ""))) return undefined;
+  return parseCompactIntelligenceSelection(entry.label);
+}
+
+function compactSelectionMatchesRequested(selection, compactSelection) {
+  if (!compactSelection || compactSelection.modelFamily !== selection.modelFamily) return false;
+
+  if (selection.modelFamily === "instant") {
+    // The compact Intelligence picker has no explicit auto-switch toggle. Treat
+    // Instant 5s as the closest available target for both instant presets.
+    return compactSelection.compactTier === "instant";
+  }
+
+  if (selection.modelFamily === "pro") {
+    // The compact picker exposes one Pro tier instead of separate Pro efforts.
+    return compactSelection.compactTier === "pro";
+  }
+
+  if (selection.modelFamily === "thinking") {
+    const requestedEffort = selection.effort || "standard";
+    if (compactSelection.compactTier === "medium") return requestedEffort === "light" || requestedEffort === "standard";
+    if (compactSelection.compactTier === "high") return requestedEffort === "extended" || requestedEffort === "heavy";
+  }
+
+  return false;
+}
+
+function compactSelectionMatchesRequestedInSnapshot(snapshot, selection, compactSelection, { weak = false } = {}) {
+  if (!compactSelectionMatchesRequested(selection, compactSelection)) return false;
+  if (selection.modelFamily !== "instant") return true;
+
+  const autoSwitchState = autoSwitchToThinkingSelectionVisible(snapshot);
+  if (autoSwitchState === undefined) return true;
+  if (weak) return selection.autoSwitchToThinking ? autoSwitchState !== false : autoSwitchState !== true;
+  return selection.autoSwitchToThinking ? autoSwitchState === true : autoSwitchState !== true;
+}
+
+function detectCompactIntelligenceSelection(entries) {
+  if (hasRemovableComposerModelChip(entries)) return undefined;
+  if (hasLegacyEffortCombobox(entries)) return undefined;
+
+  for (const entry of entries) {
+    if (entry.kind !== "menuitemradio" || checkedState(entry) !== true) continue;
+    const compactSelection = compactSelectionFromEntry(entry, entries, { allowClosedButtons: false });
+    if (compactSelection) return compactSelection;
+  }
+
+  if (hasCompactIntelligenceMenuContext(entries)) return undefined;
+
+  for (const entry of entries) {
+    if (entry.kind !== "button") continue;
+    const compactSelection = compactSelectionFromEntry(entry, entries);
+    if (!compactSelection) continue;
+    return compactSelection;
+  }
+  return undefined;
+}
+
+export function matchesRequestedModelControlLabel(label, selection) {
+  const compactSelection = parseCompactIntelligenceSelection(label);
+  if (compactSelection) return compactSelectionMatchesRequested(selection, compactSelection);
+  return matchesModelFamilyLabel(label, selection.modelFamily);
+}
+
+export function matchesCompactIntelligenceOpenerLabel(label) {
+  return COMPACT_INTELLIGENCE_OPENER_PATTERN.test(normalizeChipLabel(label));
+}
+
 function detectComposerChipSelection(entries) {
   for (const entry of entries) {
     if (entry.disabled || entry.kind !== "button") continue;
+    if (/\bexpanded=true\b/.test(String(entry.line || "")) && !/click to remove/i.test(String(entry.label || ""))) continue;
     const selection = parseComposerChipSelection(entry.label);
     if (selection) return selection;
   }
@@ -168,6 +297,9 @@ function checkedState(entry) {
 }
 
 function detectSelectedModelFamily(entries) {
+  const compactSelection = detectCompactIntelligenceSelection(entries);
+  if (compactSelection) return compactSelection.modelFamily;
+
   for (const entry of entries) {
     if (entry.disabled || !MODEL_FAMILY_CONTROL_KINDS.has(entry.kind || "") || checkedState(entry) !== true) continue;
     for (const family of /** @type {OracleUiModelFamily[]} */ (["instant", "thinking", "pro"])) {
@@ -213,8 +345,15 @@ export function effortSelectionVisible(snapshot, effortLabel) {
   /** @type {SnapshotEntry[]} */
   const entries = parseSnapshotEntries(snapshot);
   const normalizedEffort = effortLabel.toLowerCase();
+  const compactClosedButtonsAllowed = !hasRemovableComposerModelChip(entries) && !hasLegacyEffortCombobox(entries) && !hasCompactIntelligenceMenuContext(entries);
   return entries.some((entry) => {
     if (entry.disabled) return false;
+    const compactSelection = compactSelectionFromEntry(entry, entries, { allowClosedButtons: compactClosedButtonsAllowed });
+    if (compactSelection && entry.kind === "menuitemradio" && checkedState(entry) !== true) return false;
+    if (compactSelection?.modelFamily === "thinking") {
+      return compactSelectionMatchesRequested({ modelFamily: "thinking", effort: /** @type {import("./chatgpt-ui-helpers.d.mts").OracleUiEffort} */ (normalizedEffort), autoSwitchToThinking: false }, compactSelection);
+    }
+    if (compactSelection?.modelFamily === "pro") return true;
     if (entry.kind === "combobox" && normalizeText(entry.value).toLowerCase() === normalizedEffort) return true;
     const chipSelection = entry.kind === "button" ? parseComposerChipSelection(entry.label) : undefined;
     if (chipSelection?.effort === normalizedEffort) return true;
@@ -255,12 +394,18 @@ export function snapshotHasModelConfigurationUi(snapshot) {
           .filter((family) => matchesModelFamilyLabel(entry.label, family)),
       ),
   );
+  const visibleCompactControls = entries.filter(
+    (entry) => !entry.disabled && entry.kind === "menuitemradio" && /\d/.test(String(entry.label || "")) && parseCompactIntelligenceSelection(entry.label),
+  );
+  const hasCompactIntelligenceMenu = entries.some(
+    (entry) => !entry.disabled && entry.kind === "menu" && COMPACT_INTELLIGENCE_MENU_PATTERN.test(normalizeText(entry.label)),
+  );
   const hasCloseButton = entries.some((entry) => entry.kind === "button" && entry.label === "Close" && !entry.disabled);
   const hasIntelligenceHeading = entries.some((entry) => entry.kind === "heading" && normalizeText(entry.label) === "Intelligence" && !entry.disabled);
   const hasEffortCombobox = entries.some(
     (entry) => entry.kind === "combobox" && EFFORT_LABELS.has(entry.value || "") && !entry.disabled,
   );
-  return visibleFamilies.size >= 2 || visibleRadioFamilies.size >= 2 || hasCloseButton || hasIntelligenceHeading || hasEffortCombobox;
+  return visibleFamilies.size >= 2 || visibleRadioFamilies.size >= 2 || visibleCompactControls.length >= 2 || hasCompactIntelligenceMenu || hasCloseButton || hasIntelligenceHeading || hasEffortCombobox;
 }
 
 /**
@@ -287,6 +432,7 @@ export function snapshotHasModelOpener(snapshot) {
     const label = normalizeChipLabel(entry.label);
     return label === "Model"
       || label === "Model selector"
+      || COMPACT_INTELLIGENCE_OPENER_PATTERN.test(label)
       || EFFORT_LABELS.has(label)
       || ["instant", "thinking", "pro"].some((family) => matchesModelFamilyLabel(label, /** @type {OracleUiModelFamily} */ (family)))
       || THINKING_CHIP_PATTERN.test(label)
@@ -325,6 +471,10 @@ export function autoSwitchToThinkingSelectionVisible(snapshot) {
  */
 export function snapshotCanSafelySkipModelConfiguration(snapshot, selection) {
   if (!snapshotStronglyMatchesRequestedModel(snapshot, selection)) return false;
+  const hasBareProPill = selection.modelFamily === "pro" && parseSnapshotEntries(snapshot).some(
+    (entry) => entry.kind === "button" && !entry.disabled && normalizeChipLabel(entry.label) === "Pro",
+  );
+  if (hasBareProPill && !snapshotHasModelConfigurationUi(snapshot)) return false;
   if (selection.modelFamily === "instant" && selection.autoSwitchToThinking) {
     return autoSwitchToThinkingSelectionVisible(snapshot) === true;
   }
@@ -339,6 +489,9 @@ export function snapshotCanSafelySkipModelConfiguration(snapshot, selection) {
 export function snapshotStronglyMatchesRequestedModel(snapshot, selection) {
   /** @type {SnapshotEntry[]} */
   const entries = parseSnapshotEntries(snapshot);
+  const compactSelection = detectCompactIntelligenceSelection(entries);
+  if (compactSelection) return compactSelectionMatchesRequestedInSnapshot(snapshot, selection, compactSelection);
+
   const chipSelection = detectComposerChipSelection(entries);
   if (chipSelection) return selectionMatchesChipSelection(selection, chipSelection);
 
@@ -366,6 +519,9 @@ export function snapshotStronglyMatchesRequestedModel(snapshot, selection) {
 export function snapshotWeaklyMatchesRequestedModel(snapshot, selection) {
   /** @type {SnapshotEntry[]} */
   const entries = parseSnapshotEntries(snapshot);
+  const compactSelection = detectCompactIntelligenceSelection(entries);
+  if (compactSelection) return compactSelectionMatchesRequestedInSnapshot(snapshot, selection, compactSelection, { weak: true });
+
   const chipSelection = detectComposerChipSelection(entries);
   if (chipSelection) return selectionMatchesChipSelection(selection, chipSelection);
 

package/extensions/oracle/worker/chromium-cookie-source.mjs

@@ -4,6 +4,7 @@
 // Usage: auth-bootstrap.mjs uses this when auth.chromiumKeychain is configured alongside auth.chromeCookiePath.
 // Invariants/Assumptions: The configured cookie path points at a Chromium Cookies DB and the configured Keychain item is the browser's safe-storage secret.
 import { spawn } from "node:child_process";
+import { sweetCookieSafeStoragePasswordScrubbedEnv } from "../shared/browser-profile-helpers.mjs";
 import { createDecipheriv, pbkdf2Sync } from "node:crypto";
 import { copyFileSync, existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -16,7 +17,7 @@ const MACOS_CHROMIUM_KEY_ITERATIONS = 1003;
 
 function spawnCapture(command, args, options = {}) {
   return new Promise((resolve) => {
-    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn(command, args, { env: sweetCookieSafeStoragePasswordScrubbedEnv(), stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
     let stdout = "";
     let stderr = "";
     const timeoutMs = options.timeoutMs ?? 5_000;