@steipete/oracle 0.20.0 → 0.20.2

package/dist/src/cli/browserTabs.js

@@ -2,6 +2,9 @@ import fs from "node:fs/promises";
 import { createHash } from "node:crypto";
 import chalk from "chalk";
 import { sessionStore } from "../sessionStore.js";
+import { resolveBrowserConfig } from "../browser/config.js";
+import { formatWebSocketHost, readDevToolsActivePortInfo } from "../browser/detect.js";
+import { browserPromptFingerprint } from "../browser/promptFingerprint.js";
 import { collectChatGptTabs, DEFAULT_REMOTE_CHROME_HOST, DEFAULT_REMOTE_CHROME_PORT, formatBrowserTabState, harvestChatGptTab, sessionMatchesTab, } from "../browser/liveTabs.js";
 import { isRecoveredConversationHarvestReady, recoverConversationTab, } from "../browser/recoverConversation.js";
 import { resolveOutputPath } from "./writeOutputPath.js";
@@ -9,6 +12,7 @@ import { persistBrowserHarvest } from "./harvestIntegrity.js";
 import { completeOwnedBrowserHarvest } from "./recoveredBrowserHarvest.js";
 const LIVE_POLL_MS = 2000;
 const DEFAULT_STALL_THRESHOLD_MS = 60_000;
+const HARVEST_FRESHNESS_POLL_MS = 250;
 function isRecoverableMissingTabError(message) {
     return (message.includes("No ChatGPT tab matched") ||
         message.includes("No live ChatGPT tabs found") ||
@@ -31,7 +35,39 @@ function finishRecoveredChrome(recoveredChrome, closeAfterRecover) {
         // best-effort cleanup
     }
 }
-function sessionBrowserEndpoint(meta) {
+function harvestMatchesSessionPrompt(harvested, fingerprint) {
+    const answer = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText;
+    if (harvested.assistantFollowsLatestUser !== true || !answer?.trim())
+        return false;
+    return (fingerprint === undefined ||
+        (typeof harvested.lastUserMessageId === "string" &&
+            harvested.lastUserMessageId.trim().length > 0 &&
+            // ChatGPT can append transient status text outside the user's content after submission.
+            // Keep legacy full-container hashes valid and require an exact match for either form.
+            [harvested.lastUserTextRaw ?? harvested.lastUserText, harvested.lastUserContentText].some((text) => typeof text === "string" &&
+                browserPromptFingerprint(text, harvested.lastUserMessageId) === fingerprint)));
+}
+async function harvestSessionPrompt(meta, options, requireSessionPrompt = true) {
+    const fingerprint = requireSessionPrompt ? meta.browser?.runtime?.submittedPromptHash : undefined;
+    if (fingerprint === null) {
+        throw new Error("This browser session has no confirmed submitted user turn; retry after submission or use --browser-tab to inspect a specific tab.");
+    }
+    if (requireSessionPrompt && fingerprint === undefined) {
+        console.warn("Legacy browser session: submitted-turn identity is unavailable; verifying only latest user/assistant pairing.");
+    }
+    const freshnessTimeoutMs = resolveBrowserConfig(meta.browser?.config).inputTimeoutMs;
+    const deadline = Date.now() + freshnessTimeoutMs;
+    let harvested = await harvestChatGptTab(options);
+    while (!harvestMatchesSessionPrompt(harvested, fingerprint) && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, HARVEST_FRESHNESS_POLL_MS));
+        harvested = await harvestChatGptTab(options);
+    }
+    if (!harvestMatchesSessionPrompt(harvested, fingerprint)) {
+        throw new Error(`Latest ChatGPT turn did not contain an assistant answer paired with this session prompt after ${Math.ceil(freshnessTimeoutMs / 1000)}s; refusing to harvest stale output.`);
+    }
+    return harvested;
+}
+async function sessionBrowserEndpoint(meta) {
     const runtime = meta?.browser?.runtime ?? {};
     const remote = meta?.browser?.config?.remoteChrome ?? {};
     const host = runtime.chromeHost ?? remote.host;
@@ -39,20 +75,65 @@ function sessionBrowserEndpoint(meta) {
     if (!host || !port) {
         return null;
     }
-    return { host, port };
+    let browserWSEndpoint = runtime.chromeBrowserWSEndpoint;
+    let livePort = port;
+    if (browserWSEndpoint) {
+        const active = runtime.chromeProfileRoot
+            ? await readDevToolsActivePortInfo(runtime.chromeProfileRoot, { host }).catch(() => null)
+            : null;
+        if (active) {
+            browserWSEndpoint = active.browserWSEndpoint;
+            livePort = active.port;
+        }
+        else {
+            // A restarted Chrome can keep its port while changing its browser socket ID.
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 1000);
+            try {
+                const response = await fetch(`http://${formatWebSocketHost(host)}:${port}/json/version`, {
+                    signal: controller.signal,
+                });
+                if (response.ok) {
+                    const version = (await response.json());
+                    const advertised = new URL(version.webSocketDebuggerUrl ?? "");
+                    if (advertised.pathname.startsWith("/devtools/browser/")) {
+                        const refreshed = new URL(browserWSEndpoint);
+                        refreshed.pathname = advertised.pathname;
+                        browserWSEndpoint = refreshed.toString();
+                    }
+                }
+            }
+            catch {
+                // Attach-running Chrome may disable HTTP discovery; keep its saved socket.
+            }
+            finally {
+                clearTimeout(timeout);
+                controller.abort();
+            }
+        }
+    }
+    return {
+        host,
+        port: livePort,
+        ...(browserWSEndpoint
+            ? {
+                browserWSEndpoint,
+                approvalWaitMs: resolveBrowserConfig(meta?.browser?.config).approvalWaitMs,
+            }
+            : {}),
+    };
 }
-function collectUniqueEndpoints(metas) {
+async function collectUniqueEndpoints(metas) {
     const entries = new Map();
-    entries.set(`${DEFAULT_REMOTE_CHROME_HOST}:${DEFAULT_REMOTE_CHROME_PORT}`, {
+    entries.set(`${DEFAULT_REMOTE_CHROME_HOST}:${DEFAULT_REMOTE_CHROME_PORT}:http`, {
         host: DEFAULT_REMOTE_CHROME_HOST,
         port: DEFAULT_REMOTE_CHROME_PORT,
     });
-    for (const meta of metas) {
-        const endpoint = sessionBrowserEndpoint(meta);
+    for (const endpoint of await Promise.all(metas.map(sessionBrowserEndpoint))) {
         if (!endpoint) {
             continue;
         }
-        entries.set(`${endpoint.host}:${endpoint.port}`, endpoint);
+        entries.set(`${endpoint.host}:${endpoint.port}:${endpoint.browserWSEndpoint ?? "http"}`, endpoint);
     }
     return Array.from(entries.values());
 }
@@ -119,7 +200,7 @@ async function maybeWriteHarvestOutput(pathInput, cwd, content) {
 }
 export async function showBrowserTabsStatus() {
     const metas = await sessionStore.listSessions().catch(() => []);
-    const endpoints = collectUniqueEndpoints(metas);
+    const endpoints = await collectUniqueEndpoints(metas);
     let printedAny = false;
     for (const endpoint of endpoints) {
         let tabs;
@@ -156,7 +237,7 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
     if (!meta) {
         throw new Error(`No session found with ID ${sessionId}.`);
     }
-    const recordedEndpoint = sessionBrowserEndpoint(meta);
+    const recordedEndpoint = await sessionBrowserEndpoint(meta);
     const initialEndpoint = recordedEndpoint ?? {
         host: DEFAULT_REMOTE_CHROME_HOST,
         port: DEFAULT_REMOTE_CHROME_PORT,
@@ -167,12 +248,11 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
     try {
         let harvested;
         try {
-            harvested = await harvestChatGptTab({
-                host: initialEndpoint.host,
-                port: initialEndpoint.port,
+            harvested = await harvestSessionPrompt(meta, {
+                ...initialEndpoint,
                 ref,
                 stallWindowMs: options.stallWindowMs,
-            });
+            }, !options.browserTabRef);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -184,9 +264,11 @@ export async function harvestSessionBrowserOutput(sessionId, options = {}) {
                 existingEndpoint: recordedEndpoint ?? undefined,
             });
             recoveredChrome = recovered.chrome;
-            harvested = await harvestChatGptTab({
+            harvested = await harvestSessionPrompt(meta, {
                 host: recovered.host,
                 port: recovered.port,
+                browserWSEndpoint: recovered.browserWSEndpoint,
+                approvalWaitMs: recovered.approvalWaitMs,
                 ref: recovered.ref,
                 stallWindowMs: options.stallWindowMs,
             });
@@ -212,7 +294,7 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
     if (!meta) {
         throw new Error(`No session found with ID ${sessionId}.`);
     }
-    const recordedEndpoint = sessionBrowserEndpoint(meta);
+    const recordedEndpoint = await sessionBrowserEndpoint(meta);
     let endpoint = recordedEndpoint ?? {
         host: DEFAULT_REMOTE_CHROME_HOST,
         port: DEFAULT_REMOTE_CHROME_PORT,
@@ -229,8 +311,7 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
         // Probe once to see if the live tab is still alive; recover if not.
         try {
             await harvestChatGptTab({
-                host: endpoint.host,
-                port: endpoint.port,
+                ...endpoint,
                 ref: browserTabRef,
             });
         }
@@ -245,15 +326,19 @@ export async function liveTailSessionBrowserOutput(sessionId, options = {}) {
                 waitForReady: false,
             });
             recoveredChrome = recovered.chrome;
-            endpoint = { host: recovered.host, port: recovered.port };
+            endpoint = {
+                host: recovered.host,
+                port: recovered.port,
+                browserWSEndpoint: recovered.browserWSEndpoint,
+                approvalWaitMs: recovered.approvalWaitMs,
+            };
             browserTabRef = recovered.ref;
             requireRecoveredContent = true;
             recoveredContentDeadlineMs = Date.now() + stallThresholdMs;
         }
         while (true) {
             const harvested = await harvestChatGptTab({
-                host: endpoint.host,
-                port: endpoint.port,
+                ...endpoint,
                 ref: browserTabRef,
             });
             const fullText = harvested.lastAssistantMarkdown ?? harvested.lastAssistantText ?? "";

package/dist/src/cli/detach.js

@@ -1,4 +1,5 @@
 import { isProModel } from "../oracle/modelResolver.js";
+import { isGpt6ProAlias } from "./browserConfig.js";
 export function shouldDetachSession({ 
 // Params kept for policy tweaks.
 engine, model, reasoningMode, waitPreference, disableDetachEnv, }) {
@@ -7,7 +8,7 @@ engine, model, reasoningMode, waitPreference, disableDetachEnv, }) {
     // Keep long local browser Pro work in a separate process even while the CLI
     // stays attached to its session log. If the foreground stream is interrupted,
     // the worker can still finish the browser run and persist the answer.
-    if (engine === "browser" && isProModel(model))
+    if (engine === "browser" && (isProModel(model) || isGpt6ProAlias(model)))
         return true;
     // For API runs, explicit --wait keeps execution in the foreground.
     if (waitPreference)
@@ -17,6 +18,14 @@ engine, model, reasoningMode, waitPreference, disableDetachEnv, }) {
         return true;
     return false;
 }
+export function shouldExitAfterTopLevelSigint(remainingListenerCount) {
+    return remainingListenerCount === 0;
+}
+export function detachedCancellationExitCode(cancelled, finalStatus, currentExitCode) {
+    if (!cancelled)
+        return currentExitCode;
+    return finalStatus === "completed" || finalStatus === "partial" ? 0 : 130;
+}
 export function stopDetachedWorker(workerPid, kill = process.kill) {
     try {
         kill(workerPid, "SIGTERM");

package/dist/src/cli/detachedSession.js

@@ -1,5 +1,41 @@
 import { spawn } from "node:child_process";
+import { access, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
+const CANCELLATION_MARKER = ".cancel-requested";
+export function detachedSessionCancellationPath(sessionDir, workerPid) {
+    return path.join(sessionDir, `${CANCELLATION_MARKER}-${workerPid}`);
+}
+export async function requestDetachedSessionCancellation(markerPath) {
+    await writeFile(markerPath, "cancel\n", "utf8");
+}
+export async function clearDetachedSessionCancellation(markerPath) {
+    await rm(markerPath, { force: true });
+}
+export async function waitForDetachedSessionCancellation({ markerPath, signal, pollIntervalMs = 100, }) {
+    while (!signal.aborted) {
+        try {
+            await access(markerPath);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof Error) || error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        try {
+            await delay(pollIntervalMs, undefined, { signal });
+        }
+        catch (error) {
+            if (signal.aborted && error instanceof Error && error.name === "AbortError") {
+                return false;
+            }
+            throw error;
+        }
+    }
+    return false;
+}
 export function resolveOracleCliEntrypoint(moduleUrl = import.meta.url) {
     const extension = fileURLToPath(moduleUrl).endsWith(".ts") ? "ts" : "js";
     return fileURLToPath(new URL(`../../bin/oracle-cli.${extension}`, moduleUrl));

package/dist/src/cli/errorUtils.js

@@ -1,4 +1,13 @@
 const LOGGED_SYMBOL = Symbol("oracle.alreadyLogged");
+export function formatCliError(error) {
+    const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+    if (message.trim())
+        return message;
+    const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+    if (typeof code === "string" && code.trim())
+        return `Operation failed (${code}).`;
+    return "An unexpected error occurred. Retry with --verbose for more details.";
+}
 export function markErrorLogged(error) {
     if (error instanceof Error) {
         error[LOGGED_SYMBOL] = true;

package/dist/src/cli/sessionDisplay.js

@@ -359,7 +359,10 @@ export async function attachSession(sessionId, options) {
             console.log(dim(`User error: ${userErrorSummary}`));
         }
     }
-    const shouldTrimIntro = initialStatus === "completed" || initialStatus === "partial" || initialStatus === "error";
+    const shouldTrimIntro = initialStatus === "completed" ||
+        initialStatus === "partial" ||
+        initialStatus === "error" ||
+        initialStatus === "cancelled";
     if (options?.renderPrompt !== false) {
         const prompt = await readStoredPrompt(sessionId);
         if (prompt) {
@@ -485,7 +488,10 @@ export async function attachSession(sessionId, options) {
         if (!latest) {
             break;
         }
-        if (latest.status === "completed" || latest.status === "partial" || latest.status === "error") {
+        if (latest.status === "completed" ||
+            latest.status === "partial" ||
+            latest.status === "error" ||
+            latest.status === "cancelled") {
             await printNew();
             flushRemainder();
             if (!options?.suppressMetadata) {
@@ -516,7 +522,9 @@ export async function attachSession(sessionId, options) {
             if (!settled) {
                 break;
             }
-            if (settled.status === "completed" || settled.status === "partial") {
+            if (settled.status === "completed" ||
+                settled.status === "partial" ||
+                settled.status === "cancelled") {
                 continue;
             }
             await printNew();