@steipete/oracle 0.15.2 → 0.16.1

package/dist/src/browser/chromeLifecycle.js

@@ -2,18 +2,15 @@ import { rm } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import os from "node:os";
 import net from "node:net";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import CDP from "chrome-remote-interface";
 import { launch, Launcher } from "chrome-launcher";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
-const execFileAsync = promisify(execFile);
 export async function launchChrome(config, userDataDir, logger) {
     const connectHost = resolveRemoteDebugHost();
     const debugBindAddress = connectHost && connectHost !== "127.0.0.1" ? "0.0.0.0" : connectHost;
     const debugPort = config.debugPort ?? parseDebugPortEnv();
-    const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress);
+    const chromeFlags = buildChromeFlags(config.headless ?? false, debugBindAddress, config.hideWindow ?? false);
     const usePatchedLauncher = Boolean(connectHost && connectHost !== "127.0.0.1");
     // copy-profile reuses a copied signed-in profile whose cookies are
     // Keychain-encrypted, so it must launch with the real Keychain (not mocked):
@@ -46,6 +43,24 @@ export async function launchChrome(config, userDataDir, logger) {
     logger(`Launched Chrome${pidLabel} on port ${launcher.port}${hostLabel}`);
     return Object.assign(launcher, { host: connectHost ?? "127.0.0.1" });
 }
+export async function positionChromeWindowOffscreen(client, logger) {
+    if (process.platform !== "darwin") {
+        logger("Window hiding is only supported on macOS");
+        return;
+    }
+    try {
+        const { windowId } = await client.Browser.getWindowForTarget();
+        await client.Browser.setWindowBounds({
+            windowId,
+            bounds: { left: -32_000, top: -32_000, windowState: "normal" },
+        });
+        logger("Chrome window positioned off-screen");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to position Chrome window off-screen: ${message}`);
+    }
+}
 export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logger, opts) {
     const signals = ["SIGINT", "SIGTERM", "SIGQUIT"];
     let handling;
@@ -110,29 +125,6 @@ export function registerTerminationHooks(chrome, userDataDir, keepBrowser, logge
         }
     };
 }
-export async function hideChromeWindow(chrome, logger) {
-    if (process.platform !== "darwin") {
-        logger("Window hiding is only supported on macOS");
-        return;
-    }
-    if (!chrome.pid) {
-        logger("Unable to hide window: missing Chrome PID");
-        return;
-    }
-    const script = `tell application "System Events"
-    try
-      set visible of (first process whose unix id is ${chrome.pid}) to false
-    end try
-  end tell`;
-    try {
-        await execFileAsync("osascript", ["-e", script]);
-        logger("Chrome window hidden (Cmd-H)");
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger(`Failed to hide Chrome window: ${message}`);
-    }
-}
 export async function connectToChrome(port, logger, host) {
     const client = await CDP({ port, host });
     logger("Connected to Chrome DevTools protocol");
@@ -414,13 +406,79 @@ export async function closeTab(port, targetId, logger, host) {
     const effectiveHost = host ?? "127.0.0.1";
     try {
         await CDP.Close({ host: effectiveHost, port, id: targetId });
-        logger(`Closed isolated browser tab (target=${targetId})`);
+        for (let attempt = 0; attempt < 40; attempt += 1) {
+            await delay(25);
+            let targets;
+            try {
+                targets = (await CDP.List({ host: effectiveHost, port }));
+            }
+            catch {
+                continue;
+            }
+            if (!targets.some((target) => (target.targetId ?? target.id) === targetId)) {
+                logger(`Closed isolated browser tab (target=${targetId})`);
+                return true;
+            }
+        }
+        logger(`Browser tab close was not confirmed (target=${targetId})`);
+        return false;
     }
     catch (error) {
+        try {
+            const targets = (await CDP.List({ host: effectiveHost, port }));
+            if (!targets.some((target) => (target.targetId ?? target.id) === targetId)) {
+                logger(`Closed isolated browser tab (target=${targetId})`);
+                return true;
+            }
+        }
+        catch {
+            // Preserve the original close error below.
+        }
         const message = error instanceof Error ? error.message : String(error);
         logger(`Failed to close browser tab ${targetId}: ${message}`);
+        return false;
     }
 }
+export async function createChromePageTarget(port, logger, host) {
+    const effectiveHost = host ?? "127.0.0.1";
+    try {
+        const created = (await CDP.New({
+            host: effectiveHost,
+            port,
+            url: "about:blank",
+        }));
+        const createdTargetId = created.targetId ?? created.id;
+        if (!createdTargetId) {
+            logger("Failed to create a replacement Chrome tab.");
+            return undefined;
+        }
+        logger(`Opened replacement Chrome tab (target=${createdTargetId})`);
+        return createdTargetId;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to create a replacement Chrome tab: ${message}`);
+        return undefined;
+    }
+}
+export async function ensureChromePageTargetAfterClose(port, closingTargetId, logger, host) {
+    const effectiveHost = host ?? "127.0.0.1";
+    try {
+        const targets = (await CDP.List({ host: effectiveHost, port }));
+        const existingPageTargetId = targets
+            .filter((target) => target.type === "page")
+            .map((target) => target.targetId ?? target.id)
+            .find((targetId) => Boolean(targetId) && targetId !== closingTargetId);
+        if (existingPageTargetId) {
+            return existingPageTargetId;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Failed to inspect Chrome tabs before closing ${closingTargetId}: ${message}`);
+    }
+    return await createChromePageTarget(port, logger, host);
+}
 export async function closeBlankChromeTabs(port, logger, host, options) {
     const effectiveHost = host ?? "127.0.0.1";
     const excluded = new Set([...(options?.excludeTargetIds ?? [])].filter((targetId) => typeof targetId === "string" && targetId.length > 0));
@@ -433,10 +491,20 @@ export async function closeBlankChromeTabs(port, logger, host, options) {
         logger(`Failed to inspect blank Chrome tabs: ${message}`);
         return;
     }
+    const preservedBlankTargetId = options?.preserveOneBlank
+        ? targets
+            .filter(isBlankPageTarget)
+            .map((target) => target.targetId ?? target.id)
+            .filter((targetId) => Boolean(targetId))
+            .sort()[0]
+        : undefined;
     let closed = 0;
     for (const target of targets) {
         const targetId = target.targetId ?? target.id;
-        if (!targetId || excluded.has(targetId) || !isBlankPageTarget(target)) {
+        if (!targetId ||
+            targetId === preservedBlankTargetId ||
+            excluded.has(targetId) ||
+            !isBlankPageTarget(target)) {
             continue;
         }
         try {
@@ -459,7 +527,7 @@ function isBlankPageTarget(target) {
     const url = (target.url ?? "").trim().toLowerCase();
     return url === "about:blank" || url === "chrome://newtab/" || url === "chrome://new-tab-page/";
 }
-function buildChromeFlags(headless, debugBindAddress) {
+function buildChromeFlags(headless, debugBindAddress, hideWindow = false) {
     const flags = [
         "--disable-background-networking",
         "--disable-background-timer-throttling",
@@ -489,8 +557,22 @@ function buildChromeFlags(headless, debugBindAddress) {
     if (headless) {
         flags.push("--headless=new");
     }
+    else if (hideWindow && process.platform === "darwin") {
+        // Cmd-H stops macOS Chrome from compositing the page, which can swallow
+        // trusted CDP clicks and retain the prompt as a draft. Keeping the window
+        // off-screen avoids desktop disruption while preserving normal rendering.
+        flags.push("--window-position=-32000,-32000");
+    }
+    // Opt-in only: container/CI Chromium often cannot use the sandbox. Callers must
+    // set ORACLE_CHROME_NO_SANDBOX=1 explicitly (never default this on).
+    if (process.env.ORACLE_CHROME_NO_SANDBOX === "1") {
+        flags.push("--no-sandbox", "--disable-dev-shm-usage");
+    }
     return flags;
 }
+export function buildChromeFlagsForTest(headless, debugBindAddress, hideWindow = false) {
+    return buildChromeFlags(headless, debugBindAddress, hideWindow);
+}
 function resolveChromeLaunchOptions(chromeFlags, usingCopiedProfile) {
     if (!usingCopiedProfile) {
         return { chromeFlags, ignoreDefaultFlags: false };

package/dist/src/browser/config.js

@@ -61,6 +61,7 @@ export function resolveBrowserConfig(config) {
     const debugPortEnv = parseDebugPort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT);
     const envAllowCookieErrors = (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? "").trim().toLowerCase() === "true" ||
         (process.env.ORACLE_BROWSER_ALLOW_COOKIE_ERRORS ?? "").trim() === "1";
+    const envMaxConcurrentTabs = parseMaxConcurrentTabs(process.env.ORACLE_BROWSER_MAX_CONCURRENT_TABS);
     const rawUrl = config?.chatgptUrl ?? config?.url ?? DEFAULT_BROWSER_CONFIG.url;
     const normalizedUrl = normalizeChatgptUrl(rawUrl ?? DEFAULT_BROWSER_CONFIG.url, DEFAULT_BROWSER_CONFIG.url);
     const desiredModel = config?.desiredModel ?? DEFAULT_BROWSER_CONFIG.desiredModel ?? DEFAULT_MODEL_TARGET;
@@ -87,7 +88,7 @@ export function resolveBrowserConfig(config) {
         assistantRecheckTimeoutMs: config?.assistantRecheckTimeoutMs ?? DEFAULT_BROWSER_CONFIG.assistantRecheckTimeoutMs,
         reuseChromeWaitMs: config?.reuseChromeWaitMs ?? DEFAULT_BROWSER_CONFIG.reuseChromeWaitMs,
         profileLockTimeoutMs: config?.profileLockTimeoutMs ?? DEFAULT_BROWSER_CONFIG.profileLockTimeoutMs,
-        maxConcurrentTabs: normalizeMaxConcurrentTabs(config?.maxConcurrentTabs ?? DEFAULT_BROWSER_CONFIG.maxConcurrentTabs),
+        maxConcurrentTabs: normalizeMaxConcurrentTabs(config?.maxConcurrentTabs ?? envMaxConcurrentTabs ?? DEFAULT_BROWSER_CONFIG.maxConcurrentTabs),
         autoReattachDelayMs: config?.autoReattachDelayMs ?? DEFAULT_BROWSER_CONFIG.autoReattachDelayMs,
         autoReattachIntervalMs: config?.autoReattachIntervalMs ?? DEFAULT_BROWSER_CONFIG.autoReattachIntervalMs,
         autoReattachTimeoutMs: config?.autoReattachTimeoutMs ?? DEFAULT_BROWSER_CONFIG.autoReattachTimeoutMs,
@@ -134,6 +135,18 @@ function parseDebugPort(raw) {
     }
     return value;
 }
+function parseMaxConcurrentTabs(raw) {
+    if (!raw)
+        return null;
+    const trimmed = raw.trim();
+    if (!/^\d+$/.test(trimmed))
+        return null;
+    const value = Number(trimmed);
+    if (!Number.isInteger(value) || value <= 0) {
+        return null;
+    }
+    return value;
+}
 function resolveManualLoginProfileDir(...candidates) {
     for (const candidate of candidates) {
         const profileDir = candidate?.trim();

package/dist/src/browser/constants.js

@@ -64,10 +64,14 @@ export const UPLOAD_STATUS_SELECTORS = [
     '[aria-live="assertive"]',
 ];
 export const STOP_BUTTON_SELECTOR = '[data-testid="stop-button"]';
+// The aria-label fallback exists for data-testid drift, but a document-wide match makes ANY
+// visible "stop" control (read-aloud, voice/dictation) read as "still generating", which blocks
+// completion until the response timeout. Scope it to the composer form and exclude the known
+// non-generation stop controls that legitimately live there.
 export const STOP_BUTTON_SELECTORS = [
     STOP_BUTTON_SELECTOR,
     '[data-testid="composer-stop-button"]',
-    'button[aria-label*="stop" i]',
+    'form button[aria-label*="stop" i]:not([aria-label*="dictat" i]):not([aria-label*="voice" i]):not([aria-label*="read" i])',
 ];
 export const SEND_BUTTON_SELECTORS = [
     'button[data-testid="send-button"]',

package/dist/src/browser/controlPlan.js

@@ -45,13 +45,13 @@ export function describeBrowserControlPlan(config = {}) {
         };
     }
     if (config.hideWindow) {
-        guidance.push("Chrome may briefly focus while launching before Oracle hides it.");
+        guidance.push("On macOS, Oracle launches Chrome off-screen while keeping the page rendered.");
         guidance.push("For the calmest shared-desktop flow, prefer --browser-attach-running or --remote-chrome.");
         return {
             mode: "hidden-window",
             launchesChrome: true,
             mayFocusWindow: true,
-            summary: "launch Chrome and hide the window after startup",
+            summary: "launch Chrome in hidden-window mode",
             guidance,
         };
     }

package/dist/src/browser/conversationUrl.js

@@ -0,0 +1,16 @@
+const CONVERSATION_ID_PATH = /\/c\/([a-zA-Z0-9-]+)(?=[/?#]|$)/;
+/**
+ * Extract a durable ChatGPT conversation id from a URL.
+ *
+ * ChatGPT can briefly expose client-created routes such as `/c/WEB:<request-id>`
+ * before replacing them with the persisted conversation URL. Those transient
+ * routes must not be used to scope assistant-response capture or reattachment.
+ */
+export function extractStableConversationIdFromUrl(url) {
+    if (!url)
+        return undefined;
+    return url.match(CONVERSATION_ID_PATH)?.[1];
+}
+export function isStableConversationUrl(url) {
+    return extractStableConversationIdFromUrl(url) !== undefined;
+}

package/dist/src/browser/conversationUrlMonitor.js

@@ -1,4 +1,5 @@
 import { delay } from "./utils.js";
+import { isStableConversationUrl } from "./conversationUrl.js";
 export function createConversationUrlMonitor(options) {
     const pollIntervalMs = options.pollIntervalMs ?? 250;
     const wait = options.wait ?? delay;
@@ -14,7 +15,7 @@ export function createConversationUrlMonitor(options) {
                 if (stopped) {
                     return false;
                 }
-                if (url && isConversationUrl(url)) {
+                if (url && isStableConversationUrl(url)) {
                     options.logger(`[browser] conversation url (${label}) = ${url}`);
                     const persist = options.persistUrl(url);
                     activePersists.add(persist);
@@ -59,6 +60,3 @@ export function createConversationUrlMonitor(options) {
         },
     };
 }
-function isConversationUrl(url) {
-    return /\/c\/[a-z0-9-]+/i.test(url);
-}

package/dist/src/browser/cookies.js

@@ -244,12 +244,14 @@ function normalizeExpiration(expires) {
     if (value <= 0) {
         return undefined;
     }
-    if (value > 1_000_000_000_000) {
-        // Learned: Chrome may store WebKit microseconds since 1601; convert to Unix seconds.
+    // Units by magnitude (do not treat Unix seconds ~1.7e9 as milliseconds):
+    // - >= 1e15: Chrome/WebKit FILETIME microseconds since 1601
+    // - >= 1e12: Unix milliseconds
+    // - else: Unix seconds (sweet-cookie / Chromium Cookie.expires)
+    if (value >= 1_000_000_000_000_000) {
         return Math.round(value / 1_000_000 - 11644473600);
     }
-    if (value > 1_000_000_000) {
-        // Likely milliseconds; normalize to seconds for CDP.
+    if (value >= 1_000_000_000_000) {
         return Math.round(value / 1000);
     }
     return Math.round(value);