@steipete/oracle 0.16.0 → 0.17.0

package/dist/src/browser/cdpLiveness.js

@@ -0,0 +1,78 @@
+import { listRemoteChromeTargets } from "./chromeLifecycle.js";
+import { verifyDevToolsReachable } from "./profileState.js";
+/**
+ * Probe whether Chrome's DevTools endpoint (and optionally a specific target)
+ * is still reachable after a CDP client WebSocket disconnect.
+ */
+export async function probeChromeTargetLiveness(options) {
+    const host = options.host || "127.0.0.1";
+    const port = options.port;
+    if (!Number.isFinite(port) || port <= 0) {
+        return { endpointReachable: false, targetFound: null, error: "missing debug port" };
+    }
+    const verifyEndpoint = options.verifyEndpoint ?? verifyDevToolsReachable;
+    const endpoint = await verifyEndpoint({ host, port, attempts: 2, timeoutMs: 1500 });
+    if (!endpoint.ok) {
+        return {
+            endpointReachable: false,
+            targetFound: null,
+            error: endpoint.error,
+        };
+    }
+    const targetId = options.targetId?.trim();
+    if (!targetId) {
+        return { endpointReachable: true, targetFound: null };
+    }
+    try {
+        const listTargets = options.listTargets ?? listRemoteChromeTargets;
+        const targets = await listTargets({
+            host,
+            port,
+            browserWSEndpoint: options.browserWSEndpoint,
+        });
+        const match = targets.find((target) => {
+            const id = target.targetId ?? target.id;
+            return id === targetId;
+        });
+        if (!match) {
+            return { endpointReachable: true, targetFound: false };
+        }
+        return {
+            endpointReachable: true,
+            targetFound: true,
+            matchedUrl: typeof match.url === "string" ? match.url : undefined,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // Endpoint answered /json/version; treat list failures as still recoverable.
+        return { endpointReachable: true, targetFound: null, error: message };
+    }
+}
+export function isRecoverableChromeDisconnect(liveness) {
+    if (!liveness.endpointReachable) {
+        return false;
+    }
+    // Confirmed live target → recoverable.
+    if (liveness.targetFound === true) {
+        return true;
+    }
+    // Confirmed missing target → not recoverable.
+    if (liveness.targetFound === false) {
+        return false;
+    }
+    // targetFound === null:
+    // - no target id was provided (endpoint-only check) → recoverable
+    // - target list failed after a specific id was requested (error set) → fail closed
+    return !liveness.error;
+}
+export function connectionLostUserMessage(options) {
+    if (options.recoverable) {
+        return options.remote
+            ? "Remote Chrome DevTools client disconnected before oracle finished; the browser target appears still alive."
+            : "Chrome DevTools client disconnected before oracle finished; the browser target appears still alive.";
+    }
+    return options.remote
+        ? "Remote Chrome connection lost before Oracle finished."
+        : "Chrome window closed before oracle finished. Please keep it open until completion.";
+}

package/dist/src/browser/chromeLifecycle.js

@@ -1,17 +1,14 @@
 import { rm } from "node:fs/promises";
-import { readFileSync } from "node:fs";
-import os from "node:os";
 import net from "node:net";
 import CDP from "chrome-remote-interface";
 import { launch, Launcher } from "chrome-launcher";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
+import { isWsl, resolveWslChromeLaunchRoute } from "./wslHost.js";
 export async function launchChrome(config, userDataDir, logger) {
-    const connectHost = resolveRemoteDebugHost();
-    const debugBindAddress = connectHost && connectHost !== "127.0.0.1" ? "0.0.0.0" : connectHost;
+    const { connectHost, debugBindAddress, usePatchedLauncher } = resolveWslChromeLaunchRoute();
     const debugPort = config.debugPort ?? parseDebugPortEnv();
     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):
     // strip the keychain-mocking flags from both chrome-launcher's defaults and
@@ -406,13 +403,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));
@@ -425,10 +488,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 {
@@ -487,6 +560,11 @@ function buildChromeFlags(headless, debugBindAddress, hideWindow = false) {
         // 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) {
@@ -514,38 +592,6 @@ function parseDebugPortEnv() {
     }
     return value;
 }
-function resolveRemoteDebugHost() {
-    const override = process.env.ORACLE_BROWSER_REMOTE_DEBUG_HOST?.trim() || process.env.WSL_HOST_IP?.trim();
-    if (override) {
-        return override;
-    }
-    if (!isWsl()) {
-        return null;
-    }
-    try {
-        const resolv = readFileSync("/etc/resolv.conf", "utf8");
-        for (const line of resolv.split("\n")) {
-            const match = line.match(/^nameserver\s+([0-9.]+)/);
-            if (match?.[1]) {
-                return match[1];
-            }
-        }
-    }
-    catch {
-        // ignore; fall back to localhost
-    }
-    return null;
-}
-function isWsl() {
-    if (process.platform !== "linux") {
-        return false;
-    }
-    if (process.env.WSL_DISTRO_NAME) {
-        return true;
-    }
-    const release = os.release();
-    return release.toLowerCase().includes("microsoft");
-}
 async function launchWithCustomHost({ chromeFlags, chromePath, userDataDir, host, requestedPort, ignoreDefaultFlags, }) {
     const launcher = new Launcher({
         chromePath: chromePath ?? undefined,

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);