@steipete/oracle 0.17.3 → 0.19.0

package/dist/src/browser/modelDisplay.js

@@ -65,3 +65,12 @@ export function formatBrowserModelSelectionEvidence(evidence, model) {
     const verified = evidence.verified ? "yes" : "no";
     return `requestedKey=${requestedKey}; target=${target}; resolvedLabel=${resolvedLabel}; status=${evidence.status}; strategy=${strategy}; verified=${verified}; source=${evidence.source}; capturedAt=${evidence.capturedAt}`;
 }
+/** Renders the observed effort selection independently of the model picker. */
+export function formatBrowserThinkingSelectionEvidence(evidence) {
+    const resolvedLabel = cleanLabel(evidence.resolvedLabel) ?? "(none)";
+    const verified = evidence.verified ? "yes" : "no";
+    const failClosed = evidence.strictFailClosed ? "yes" : "no";
+    const targetKind = evidence.targetModelKind ?? "(none)";
+    const observedKind = evidence.observedModelKind ?? "(none)";
+    return `requestedLevel=${evidence.requestedLevel}; status=${evidence.status}; resolvedLabel=${resolvedLabel}; verified=${verified}; failClosed=${failClosed}; targetModelKind=${targetKind}; observedModelKind=${observedKind}; source=${evidence.source}; capturedAt=${evidence.capturedAt}`;
+}

package/dist/src/browser/pageActions.js

@@ -1,5 +1,5 @@
 export { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, ensureChatMode, waitForResumedConversationHydration, installJavaScriptDialogAutoDismissal, } from "./actions/navigation.js";
 export { ensureModelSelection } from "./actions/modelSelection.js";
 export { submitPrompt, clearPromptComposer } from "./actions/promptComposer.js";
-export { clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, buildUserTurnAttachmentExpressionForTest, } from "./actions/attachments.js";
-export { waitForAssistantResponse, readAssistantSnapshot, captureAssistantMarkdown, buildAssistantExtractorForTest, buildAssistantSnapshotExpressionForTest, buildConversationDebugExpressionForTest, buildMarkdownFallbackExtractorForTest, buildCopyExpressionForTest, } from "./actions/assistantResponse.js";
+export { assertComposerPlusStayedInPlace, captureComposerNavigationUrl, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, buildUserTurnAttachmentExpressionForTest, } from "./actions/attachments.js";
+export { waitForAssistantResponse, readAssistantSnapshot, captureAssistantMarkdown, buildAssistantExtractorForTest, buildAssistantSnapshotExpressionForTest, buildConversationDebugExpressionForTest, buildMarkdownFallbackExtractorForTest, buildCopyExpressionForTest, isRetryAssistantUiErrorText, } from "./actions/assistantResponse.js";

package/dist/src/browser/policies.js

@@ -24,6 +24,7 @@ export function buildAttachmentPlan(sections, { inlineFiles, bundleRequested, ma
         shouldBundle,
     };
 }
+export const CHROME_COOKIE_SYNC_WARNING = "Warning: copying cookies from a live Chrome profile can invalidate that browser's ChatGPT session when tokens rotate. Prefer --browser-manual-login or inline cookies when possible.";
 export function shouldSyncBrowserCookies(config, { manualLogin, profileIsPreSigned = manualLogin, }) {
     const explicitManualLoginSync = manualLogin && config.manualLoginCookieSync === true;
     return config.cookieSync && (!profileIsPreSigned || explicitManualLoginSync);
@@ -36,8 +37,11 @@ export function buildCookiePlan(config) {
             description: `Cookies: inline payload (${config.inlineCookies.length}) via ${source}.`,
         };
     }
-    if (config?.cookieSync === false) {
-        return { type: "disabled", description: "Cookies: sync disabled (--browser-no-cookie-sync)." };
+    if (config?.cookieSync !== true) {
+        return {
+            type: "disabled",
+            description: "Cookies: Chrome copy disabled (use --browser-manual-login, inline cookies, or --browser-cookie-sync).",
+        };
     }
     const allowlist = config?.cookieNames && config.cookieNames.length > 0
         ? config.cookieNames.join(", ")

package/dist/src/browser/profileState.js

@@ -12,6 +12,7 @@ const DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS = [
 const CHROME_PID_FILENAME = "chrome.pid";
 const ORACLE_PROFILE_LOCK_FILENAME = "oracle-automation.lock";
 const execFileAsync = promisify(execFile);
+let ownProcessStartTime;
 export function getDevToolsActivePortPaths(userDataDir) {
     return DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS.map((relative) => path.join(userDataDir, relative));
 }
@@ -95,7 +96,7 @@ function findChromeDebugTargetForProfileFromProcessList(processList, userDataDir
             continue;
         if (!lower.includes("chrome") && !lower.includes("chromium"))
             continue;
-        if (!lower.includes("user-data-dir") || !command.includes(userDataDir))
+        if (!isChromeCommandForUserDataDir(command, userDataDir))
             continue;
         const portMatch = command.match(/--remote-debugging-port(?:=|\s+)(\d+)/);
         const port = Number.parseInt(portMatch?.[1] ?? "", 10);
@@ -119,11 +120,31 @@ export async function terminateRecordedChromeForProfile(userDataDir, logger) {
         return false;
     }
     try {
-        process.kill(pid, "SIGTERM");
+        if (process.platform === "win32") {
+            await execFileAsync("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+                maxBuffer: 1024 * 1024,
+                windowsHide: true,
+                timeout: 5000,
+            });
+        }
+        else {
+            process.kill(pid, "SIGTERM");
+        }
+        for (let attempt = 0; attempt < 30 && isProcessAlive(pid); attempt += 1) {
+            await delay(100);
+        }
+        if (isProcessAlive(pid)) {
+            logger?.(`Shared manual-login Chrome pid ${pid} remained alive after termination.`);
+            return false;
+        }
         logger?.(`Terminated shared manual-login Chrome pid ${pid}`);
         return true;
     }
     catch (error) {
+        if (!isProcessAlive(pid)) {
+            logger?.(`Terminated shared manual-login Chrome pid ${pid}`);
+            return true;
+        }
         const message = error instanceof Error ? error.message : String(error);
         logger?.(`Failed to terminate shared manual-login Chrome pid ${pid}: ${message}`);
         return false;
@@ -132,10 +153,49 @@ export async function terminateRecordedChromeForProfile(userDataDir, logger) {
 function isChromeCommandForUserDataDir(command, userDataDir) {
     if (!command)
         return false;
-    const lower = command.toLowerCase();
-    return ((lower.includes("chrome") || lower.includes("chromium")) &&
-        lower.includes("user-data-dir") &&
-        command.includes(userDataDir));
+    // ps flattens POSIX argv: an unquoted profile may contain spaces, so its
+    // boundary is the next Chrome switch/startup URL or the end, not the first whitespace.
+    const matches = [
+        ...command.matchAll(/(?:^|\s)(?:"--user-data-dir=([^"]*)"|--user-data-dir(?:=|\s+)(?:"([^"]*)"|'([^']*)'|([^\r\n]+?)(?=\s+(?:"?--|about:blank(?:\s|$))|\s*$)))/giu),
+    ];
+    if (matches.length !== 1)
+        return false;
+    const match = matches[0];
+    const commandProfile = match[1] ?? match[2] ?? match[3] ?? match[4];
+    if (!commandProfile || !startsWithChromeExecutable(command))
+        return false;
+    return (normalizeProfilePathForComparison(commandProfile) ===
+        normalizeProfilePathForComparison(userDataDir));
+}
+function startsWithChromeExecutable(command) {
+    const names = /^(?:google chrome(?: canary| beta| dev| for testing)?|google-chrome(?:-stable|-beta|-dev|-unstable)?|chrome|chromium|chromium-browser|chrome-headless-shell)(?:\.exe)?$/iu;
+    const trimmed = command.trimStart();
+    const quoted = trimmed.match(/^(?:"([^"]+)"|'([^']+)')(?=\s|$)/u);
+    let executable;
+    if (quoted) {
+        executable = quoted[1] ?? quoted[2];
+    }
+    else {
+        const optionsStart = trimmed.search(/\s+"?--/u);
+        executable = optionsStart < 0 ? trimmed : trimmed.slice(0, optionsStart);
+        // macOS ps leaves the standard Google Chrome bundle path unquoted. Other
+        // whitespace is ambiguous with argv entries; never mistake a later argument
+        // named chrome for the executable that owns this PID.
+        if (/\s/u.test(executable.replace(/google chrome(?: canary| beta| dev| for testing)?(?:\.app)?/giu, "chrome")))
+            return false;
+    }
+    return names.test(executable.split(/[\\/]/u).at(-1) ?? "");
+}
+function normalizeProfilePathForComparison(value) {
+    let normalized = path.normalize(path.resolve(value));
+    if (process.platform === "win32") {
+        normalized = normalized.replace(/^\\\\\?\\/u, "").toLowerCase();
+    }
+    const root = path.parse(normalized).root;
+    while (normalized.length > root.length && /[\\/]$/u.test(normalized)) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
 }
 export function isChromeCommandForUserDataDirForTest(command, userDataDir) {
     return isChromeCommandForUserDataDir(command, userDataDir);
@@ -158,6 +218,39 @@ export function isProcessAlive(pid) {
         return false;
     }
 }
+export async function readProcessStartTimeMs(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return null;
+    if (Math.trunc(pid) === process.pid) {
+        // Use the same OS identity as peer controllers, not wall time minus uptime.
+        // Cache our own PID only: it cannot be reused during this process's lifetime.
+        return (ownProcessStartTime ??= queryProcessStartTimeMs(process.pid));
+    }
+    return queryProcessStartTimeMs(pid);
+}
+async function queryProcessStartTimeMs(pid) {
+    try {
+        const executable = process.platform === "win32" ? "powershell.exe" : "ps";
+        const args = process.platform === "win32"
+            ? [
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                `$process = Get-Process -Id ${Math.trunc(pid)} -ErrorAction Stop; $process.StartTime.ToUniversalTime().ToString('o')`,
+            ]
+            : ["-p", String(Math.trunc(pid)), "-o", "lstart="];
+        const { stdout } = await execFileAsync(executable, args, {
+            maxBuffer: 1024 * 1024,
+            windowsHide: true,
+            timeout: 5000,
+        });
+        const startedAt = Date.parse(String(stdout ?? "").trim());
+        return Number.isFinite(startedAt) ? startedAt : null;
+    }
+    catch {
+        return null;
+    }
+}
 function parseProfileRunLock(payload) {
     if (!payload)
         return null;
@@ -186,6 +279,7 @@ export async function acquireProfileRunLock(userDataDir, options) {
     const startedAt = Date.now();
     let warned = false;
     for (;;) {
+        options.signal?.throwIfAborted();
         try {
             const payload = {
                 pid: process.pid,
@@ -210,7 +304,7 @@ export async function acquireProfileRunLock(userDataDir, options) {
             let existing = parseProfileRunLock(await readFile(lockPath, "utf8").catch(() => null));
             if (!existing) {
                 // Likely partial write / corruption; re-read once, then delete (user preference: delete unreadable lockfiles).
-                await delay(200);
+                await delay(200, options.signal);
                 existing = parseProfileRunLock(await readFile(lockPath, "utf8").catch(() => null));
                 if (!existing) {
                     options.logger?.("Oracle profile lock unreadable; deleting lockfile.");
@@ -231,7 +325,7 @@ export async function acquireProfileRunLock(userDataDir, options) {
             if (elapsed >= timeoutMs) {
                 throw new Error(`Oracle profile lock still held by pid ${existing.pid} after ${Math.round(elapsed / 1000)}s`);
             }
-            await delay(Math.min(pollMs, timeoutMs - elapsed));
+            await delay(Math.min(pollMs, timeoutMs - elapsed), options.signal);
         }
     }
 }
@@ -353,8 +447,19 @@ async function isChromeUsingUserDataDir(userDataDir) {
 }
 async function readProcessCommand(pid) {
     try {
-        const { stdout } = await execFileAsync("ps", ["-p", String(Math.trunc(pid)), "-o", "command="], {
+        const executable = process.platform === "win32" ? "powershell.exe" : "ps";
+        const args = process.platform === "win32"
+            ? [
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                `(Get-CimInstance Win32_Process -Filter 'ProcessId = ${Math.trunc(pid)}').CommandLine`,
+            ]
+            : ["-p", String(Math.trunc(pid)), "-o", "command="];
+        const { stdout } = await execFileAsync(executable, args, {
             maxBuffer: 1024 * 1024,
+            windowsHide: true,
+            timeout: 5000,
         });
         const command = String(stdout ?? "").trim();
         return command || null;

package/dist/src/browser/projectSourcesRunner.js

@@ -1,19 +1,72 @@
 import { mkdtemp, mkdir, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { closeTab, connectWithNewTab, launchChrome, positionChromeWindowOffscreen, registerTerminationHooks, } from "./chromeLifecycle.js";
+import { closeTab, connectWithNewTab, launchChrome, positionChromeWindowOffscreen, positionChromeWindowOnscreen, registerTerminationHooks, } from "./chromeLifecycle.js";
 import { resolveBrowserConfig } from "./config.js";
 import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
 import { installJavaScriptDialogAutoDismissal, navigateToChatGPT, ensureLoggedIn, } from "./pageActions.js";
-import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLeaseRegistry.js";
-import { acquireProfileRunLock, cleanupStaleProfileState, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
+import { acquireBrowserTabLease } from "./tabLeaseRegistry.js";
+import { acquireProfileRunLock, cleanupStaleProfileState, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, terminateRecordedChromeForProfile, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
 import { CHATGPT_URL } from "./constants.js";
 import { delay } from "./utils.js";
 import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, formatManualLoginSetupCommand, resolveManualLoginWaitMs, } from "./manualLoginProfile.js";
 import { openProjectSourcesTab, uploadProjectSources, waitForProjectSourcesReady, waitForProjectSourcesListSettled, } from "./actions/projectSources.js";
 import { normalizeProjectSourcesUrl } from "../projectSources/url.js";
 import { buildProjectSourcesUploadPlan, diffAddedProjectSources } from "../projectSources/plan.js";
-import { shouldSyncBrowserCookies } from "./policies.js";
+import { CHROME_COOKIE_SYNC_WARNING, shouldSyncBrowserCookies } from "./policies.js";
+async function releaseProjectSourcesBrowserTabLease(options) {
+    let decisionObserved = false;
+    let keepBrowserOpen = false;
+    let terminationHandled = false;
+    let otherLeasesRemain = false;
+    let releaseError;
+    try {
+        await options.lease.release({
+            onRelease: async ({ isLastLease }) => {
+                decisionObserved = true;
+                if (!isLastLease) {
+                    keepBrowserOpen = true;
+                    otherLeasesRemain = true;
+                    return;
+                }
+                if (!options.terminateSharedChrome)
+                    return;
+                options.logger(`[browser] ChatGPT browser slot ${options.lease.id.slice(0, 8)} is final; ` +
+                    `terminating shared Chrome (session=project-sources; controllerPid=${process.pid}; ` +
+                    `chromePid=${options.chromePid ?? "unknown"}; chromePort=${options.chromePort ?? "unknown"}).`);
+                const terminated = await options.terminateSharedChrome().catch(() => false);
+                if (terminated) {
+                    terminationHandled = true;
+                }
+                else {
+                    keepBrowserOpen = true;
+                    options.logger("[browser] Could not verify shared Chrome termination; leaving it available for reuse.");
+                }
+            },
+        });
+    }
+    catch (error) {
+        releaseError = error instanceof Error ? error : new Error(String(error));
+        if (!terminationHandled)
+            keepBrowserOpen = true;
+        options.logger(`[browser] Failed to release the ChatGPT browser slot registry lock; restart Oracle/Codex MCP before another browser run: ${releaseError.message}`);
+    }
+    if (!decisionObserved) {
+        keepBrowserOpen = true;
+        options.logger("[browser] Could not verify final ChatGPT tab lease; leaving shared Chrome running.");
+    }
+    else if (otherLeasesRemain) {
+        options.logger(`[browser] Other ChatGPT tab leases still active; leaving shared Chrome running; ` +
+            `browser slot ${options.lease.id.slice(0, 8)} is non-final ` +
+            `(session=project-sources; controllerPid=${process.pid}; ` +
+            `chromePid=${options.chromePid ?? "unknown"}; chromePort=${options.chromePort ?? "unknown"}).`);
+    }
+    return {
+        keepBrowserOpen,
+        terminationHandled,
+        ...(releaseError ? { releaseError } : {}),
+    };
+}
 export async function runBrowserProjectSources(request) {
     const startedAt = Date.now();
     const logger = ((message) => request.log?.(message));
@@ -96,6 +149,7 @@ export async function runBrowserProjectSources(request) {
         removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, effectiveKeepBrowser, logger, {
             isInFlight: () => !completed,
             preserveUserDataDir: manualLogin,
+            preserveSharedChromeOnSignal: manualLogin,
         });
         const strictTabIsolation = Boolean(manualLogin && reusedChrome);
         const devtoolsRetries = manualLogin ? 6 : 0;
@@ -128,7 +182,10 @@ export async function runBrowserProjectSources(request) {
         }
         await Promise.all(domainEnablers);
         if (!config.headless && config.hideWindow) {
-            await positionChromeWindowOffscreen(client, logger);
+            await positionChromeWindowOffscreen(client, userDataDir, logger);
+        }
+        else if (!config.headless) {
+            await positionChromeWindowOnscreen(client, userDataDir, logger);
         }
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
         if (!manualLogin) {
@@ -189,7 +246,8 @@ export async function runBrowserProjectSources(request) {
         }
         let keepBrowserOpen = effectiveKeepBrowser;
         let cleanupProfileLock = null;
-        let terminatedRecordedChrome = false;
+        let browserTerminationHandledByLease = false;
+        let tabLeaseReleaseError;
         if (!keepBrowserOpen && manualLogin && tabLease) {
             const cleanupLockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
             if (cleanupLockTimeoutMs > 0) {
@@ -199,24 +257,29 @@ export async function runBrowserProjectSources(request) {
                     sessionId: "project-sources",
                 }).catch(() => null);
             }
-            keepBrowserOpen = await hasOtherActiveBrowserTabLeases(userDataDir, tabLease.id).catch(() => false);
-            if (keepBrowserOpen) {
-                logger("[browser] Other ChatGPT tab leases still active; leaving shared Chrome running.");
-            }
-            else if (reusedChrome && !connectionClosedUnexpectedly) {
-                keepBrowserOpen = true;
-                logger("[browser] Reused shared Chrome; leaving browser process running.");
-            }
         }
         if (tabLease) {
             const handle = tabLease;
             tabLease = null;
-            await handle.release().catch(() => undefined);
+            const chromeHandle = chrome;
+            const terminateSharedChrome = !keepBrowserOpen && manualLogin && chromeHandle && !connectionClosedUnexpectedly
+                ? async () => terminateRecordedChromeForProfile(userDataDir, logger).catch(() => false)
+                : undefined;
+            const releaseResult = await releaseProjectSourcesBrowserTabLease({
+                lease: handle,
+                terminateSharedChrome,
+                chromePid: chromeHandle?.pid,
+                chromePort: chromeHandle?.port,
+                logger,
+            });
+            keepBrowserOpen ||= releaseResult.keepBrowserOpen;
+            browserTerminationHandledByLease = releaseResult.terminationHandled;
+            tabLeaseReleaseError = releaseResult.releaseError;
         }
         if (!keepBrowserOpen && chrome) {
             if (!connectionClosedUnexpectedly) {
                 try {
-                    if (!terminatedRecordedChrome) {
+                    if (!browserTerminationHandledByLease) {
                         await chrome.kill();
                     }
                 }
@@ -246,6 +309,10 @@ export async function runBrowserProjectSources(request) {
         if (cleanupProfileLock) {
             await cleanupProfileLock.release().catch(() => undefined);
         }
+        if (tabLeaseReleaseError) {
+            // oxlint-disable-next-line eslint/no-unsafe-finally -- This cleanup failure must override a successful Project Sources result or a live MCP owner can remain locked.
+            throw new Error("Failed to release the ChatGPT browser slot registry lock; restart Oracle/Codex MCP before another browser run.", { cause: tabLeaseReleaseError });
+        }
     }
 }
 async function applyProjectSourcesCookies({ config, network, manualLogin, logger, }) {
@@ -253,9 +320,12 @@ async function applyProjectSourcesCookies({ config, network, manualLogin, logger
     if (!cookieSyncEnabled) {
         logger(manualLogin
             ? "Skipping Chrome cookie sync (--browser-manual-login enabled); reuse the opened profile after signing in."
-            : "Skipping Chrome cookie sync (--browser-no-cookie-sync)");
+            : "Skipping Chrome cookie copy (disabled by default; use --browser-cookie-sync to opt in).");
         return 0;
     }
+    if (!config.inlineCookies) {
+        logger(CHROME_COOKIE_SYNC_WARNING);
+    }
     const cookieCount = await syncCookies(network, config.url, config.chromeProfile, logger, {
         allowErrors: config.allowCookieErrors ?? false,
         filterNames: config.cookieNames ?? undefined,
@@ -389,3 +459,4 @@ async function maybeReuseProjectSourcesChrome(userDataDir, logger, options = {})
 export async function maybeReuseProjectSourcesChromeForTest(userDataDir, logger, options = {}) {
     return maybeReuseProjectSourcesChrome(userDataDir, logger, options);
 }
+export const releaseProjectSourcesBrowserTabLeaseForTest = releaseProjectSourcesBrowserTabLease;