@steipete/oracle 0.6.0 → 0.6.1

package/dist/src/browser/actions/assistantResponse.js

@@ -183,7 +183,9 @@ async function pollAssistantCompletion(Runtime, timeoutMs) {
                 isStopButtonVisible(Runtime),
                 isCompletionVisible(Runtime),
             ]);
-            if (completionVisible || (!stopVisible && stableCycles >= requiredStableCycles)) {
+            // Require at least 2 stable cycles even when completion buttons are visible
+            // to ensure DOM text has fully rendered (buttons can appear before text settles)
+            if ((completionVisible && stableCycles >= 2) || (!stopVisible && stableCycles >= requiredStableCycles)) {
                 return normalized;
             }
         }
@@ -211,10 +213,36 @@ async function isCompletionVisible(Runtime) {
     try {
         const { result } = await Runtime.evaluate({
             expression: `(() => {
-        if (document.querySelector('${FINISHED_ACTIONS_SELECTOR}')) {
+        // Find the LAST assistant turn to check completion status
+        // Must match the same logic as buildAssistantExtractor for consistency
+        const ASSISTANT_SELECTOR = '${ASSISTANT_ROLE_SELECTOR}';
+        const isAssistantTurn = (node) => {
+          if (!(node instanceof HTMLElement)) return false;
+          const role = (node.getAttribute('data-message-author-role') || node.dataset?.messageAuthorRole || '').toLowerCase();
+          if (role === 'assistant') return true;
+          const testId = (node.getAttribute('data-testid') || '').toLowerCase();
+          if (testId.includes('assistant')) return true;
+          return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
+        };
+
+        const turns = Array.from(document.querySelectorAll('${CONVERSATION_TURN_SELECTOR}'));
+        let lastAssistantTurn = null;
+        for (let i = turns.length - 1; i >= 0; i--) {
+          if (isAssistantTurn(turns[i])) {
+            lastAssistantTurn = turns[i];
+            break;
+          }
+        }
+        if (!lastAssistantTurn) {
+          return false;
+        }
+        // Check if the last assistant turn has finished action buttons (copy, thumbs up/down, share)
+        if (lastAssistantTurn.querySelector('${FINISHED_ACTIONS_SELECTOR}')) {
           return true;
         }
-        return Array.from(document.querySelectorAll('.markdown')).some((n) => (n.textContent || '').trim() === 'Done');
+        // Also check for "Done" text in the last assistant turn's markdown
+        const markdowns = lastAssistantTurn.querySelectorAll('.markdown');
+        return Array.from(markdowns).some((n) => (n.textContent || '').trim() === 'Done');
       })()`,
             returnByValue: true,
         });
@@ -257,12 +285,27 @@ function buildAssistantSnapshotExpression() {
 }
 function buildResponseObserverExpression(timeoutMs) {
     const selectorsLiteral = JSON.stringify(ANSWER_SELECTORS);
+    const conversationLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
+    const assistantLiteral = JSON.stringify(ASSISTANT_ROLE_SELECTOR);
     return `(() => {
     ${buildClickDispatcher()}
     const SELECTORS = ${selectorsLiteral};
     const STOP_SELECTOR = '${STOP_BUTTON_SELECTOR}';
     const FINISHED_SELECTOR = '${FINISHED_ACTIONS_SELECTOR}';
+    const CONVERSATION_SELECTOR = ${conversationLiteral};
+    const ASSISTANT_SELECTOR = ${assistantLiteral};
     const settleDelayMs = 800;
+
+    // Helper to detect assistant turns - matches buildAssistantExtractor logic
+    const isAssistantTurn = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const role = (node.getAttribute('data-message-author-role') || node.dataset?.messageAuthorRole || '').toLowerCase();
+      if (role === 'assistant') return true;
+      const testId = (node.getAttribute('data-testid') || '').toLowerCase();
+      if (testId.includes('assistant')) return true;
+      return Boolean(node.querySelector(ASSISTANT_SELECTOR) || node.querySelector('[data-testid*="assistant"]'));
+    };
+
     ${buildAssistantExtractor('extractFromTurns')}
 
     const captureViaObserver = () =>
@@ -307,6 +350,24 @@ function buildResponseObserverExpression(timeoutMs) {
         }, ${timeoutMs});
       });
 
+    // Check if the last assistant turn has finished (scoped to avoid detecting old turns)
+    const isLastAssistantTurnFinished = () => {
+      const turns = Array.from(document.querySelectorAll(CONVERSATION_SELECTOR));
+      let lastAssistantTurn = null;
+      for (let i = turns.length - 1; i >= 0; i--) {
+        if (isAssistantTurn(turns[i])) {
+          lastAssistantTurn = turns[i];
+          break;
+        }
+      }
+      if (!lastAssistantTurn) return false;
+      // Check for action buttons in this specific turn
+      if (lastAssistantTurn.querySelector(FINISHED_SELECTOR)) return true;
+      // Check for "Done" text in this turn's markdown
+      const markdowns = lastAssistantTurn.querySelectorAll('.markdown');
+      return Array.from(markdowns).some((n) => (n.textContent || '').trim() === 'Done');
+    };
+
     const waitForSettle = async (snapshot) => {
       const settleWindowMs = 5000;
       const settleIntervalMs = 400;
@@ -321,9 +382,7 @@ function buildResponseObserverExpression(timeoutMs) {
           lastLength = refreshed.text?.length ?? lastLength;
         }
         const stopVisible = Boolean(document.querySelector(STOP_SELECTOR));
-        const finishedVisible =
-          Boolean(document.querySelector(FINISHED_SELECTOR)) ||
-          Array.from(document.querySelectorAll('.markdown')).some((n) => (n.textContent || '').trim() === 'Done');
+        const finishedVisible = isLastAssistantTurnFinished();
 
         if (!stopVisible || finishedVisible) {
           break;

package/dist/src/browser/constants.js

@@ -1,5 +1,5 @@
 export const CHATGPT_URL = 'https://chatgpt.com/';
-export const DEFAULT_MODEL_TARGET = 'ChatGPT 5.1';
+export const DEFAULT_MODEL_TARGET = 'ChatGPT 5.2';
 export const COOKIE_URLS = ['https://chatgpt.com', 'https://chat.openai.com', 'https://atlas.openai.com'];
 export const INPUT_SELECTORS = [
     'textarea[data-id="prompt-textarea"]',

package/dist/src/browser/index.js

@@ -1,4 +1,4 @@
-import { mkdtemp, rm, mkdir, readFile } from 'node:fs/promises';
+import { mkdtemp, rm, mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import net from 'node:net';
@@ -12,6 +12,7 @@ import { estimateTokenCount, withRetries, delay } from './utils.js';
 import { formatElapsed } from '../oracle/format.js';
 import { CHATGPT_URL } from './constants.js';
 import { BrowserAutomationError } from '../oracle/errors.js';
+import { cleanupStaleProfileState, readChromePid, readDevToolsPort, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from './profileState.js';
 export { CHATGPT_URL, DEFAULT_MODEL_TARGET } from './constants.js';
 export { parseDuration, delay, normalizeChatgptUrl } from './utils.js';
 export async function runBrowserMode(options) {
@@ -98,6 +99,13 @@ export async function runBrowserMode(options) {
             remoteChrome: config.remoteChrome,
         }, userDataDir, logger));
     const chromeHost = chrome.host ?? '127.0.0.1';
+    // Persist profile state so future manual-login runs can reuse this Chrome.
+    if (manualLogin && chrome.port) {
+        await writeDevToolsActivePort(userDataDir, chrome.port);
+        if (!reusedChrome && chrome.pid) {
+            await writeChromePid(userDataDir, chrome.pid);
+        }
+    }
     let removeTerminationHooks = null;
     try {
         removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, effectiveKeepBrowser, logger, {
@@ -533,57 +541,21 @@ async function maybeReuseRunningChrome(userDataDir, logger) {
     const port = await readDevToolsPort(userDataDir);
     if (!port)
         return null;
-    const versionUrl = `http://127.0.0.1:${port}/json/version`;
-    try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 1500);
-        const response = await fetch(versionUrl, { signal: controller.signal });
-        clearTimeout(timeout);
-        if (!response.ok)
-            throw new Error(`HTTP ${response.status}`);
-        const pidPath = path.join(userDataDir, 'chrome.pid');
-        let pid;
-        try {
-            const rawPid = (await readFile(pidPath, 'utf8')).trim();
-            pid = Number.parseInt(rawPid, 10);
-            if (Number.isNaN(pid))
-                pid = undefined;
-        }
-        catch {
-            pid = undefined;
-        }
-        logger(`Found running Chrome for ${userDataDir}; reusing (DevTools port ${port}${pid ? `, pid ${pid}` : ''})`);
-        return {
-            port,
-            pid,
-            kill: async () => { },
-            process: undefined,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger(`DevToolsActivePort found for ${userDataDir} but unreachable (${message}); launching new Chrome.`);
+    const probe = await verifyDevToolsReachable({ port });
+    if (!probe.ok) {
+        logger(`DevToolsActivePort found for ${userDataDir} but unreachable (${probe.error}); launching new Chrome.`);
+        // Safe cleanup: remove stale DevToolsActivePort; only remove lock files if this was an Oracle-owned pid that died.
+        await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: 'if_oracle_pid_dead' });
         return null;
     }
-}
-async function readDevToolsPort(userDataDir) {
-    const candidates = [
-        path.join(userDataDir, 'DevToolsActivePort'),
-        path.join(userDataDir, 'Default', 'DevToolsActivePort'),
-    ];
-    for (const candidate of candidates) {
-        try {
-            const raw = await readFile(candidate, 'utf8');
-            const firstLine = raw.split(/\r?\n/u)[0]?.trim();
-            const port = Number.parseInt(firstLine ?? '', 10);
-            if (Number.isFinite(port)) {
-                return port;
-            }
-        }
-        catch {
-        }
-    }
-    return null;
+    const pid = await readChromePid(userDataDir);
+    logger(`Found running Chrome for ${userDataDir}; reusing (DevTools port ${port}${pid ? `, pid ${pid}` : ''})`);
+    return {
+        port,
+        pid: pid ?? undefined,
+        kill: async () => { },
+        process: undefined,
+    };
 }
 async function runRemoteBrowserMode(promptText, attachments, config, logger, options) {
     const remoteChromeConfig = config.remoteChrome;

package/dist/src/browser/profileState.js

@@ -0,0 +1,171 @@
+import path from 'node:path';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const DEVTOOLS_ACTIVE_PORT_FILENAME = 'DevToolsActivePort';
+const DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS = [
+    DEVTOOLS_ACTIVE_PORT_FILENAME,
+    path.join('Default', DEVTOOLS_ACTIVE_PORT_FILENAME),
+];
+const CHROME_PID_FILENAME = 'chrome.pid';
+const execFileAsync = promisify(execFile);
+export function getDevToolsActivePortPaths(userDataDir) {
+    return DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS.map((relative) => path.join(userDataDir, relative));
+}
+export async function readDevToolsPort(userDataDir) {
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            const raw = await readFile(candidate, 'utf8');
+            const firstLine = raw.split(/\r?\n/u)[0]?.trim();
+            const port = Number.parseInt(firstLine ?? '', 10);
+            if (Number.isFinite(port)) {
+                return port;
+            }
+        }
+        catch {
+            // ignore missing/unreadable candidates
+        }
+    }
+    return null;
+}
+export async function writeDevToolsActivePort(userDataDir, port) {
+    const contents = `${port}\n/devtools/browser`;
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            await mkdir(path.dirname(candidate), { recursive: true });
+            await writeFile(candidate, contents, 'utf8');
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+export async function readChromePid(userDataDir) {
+    const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
+    try {
+        const raw = (await readFile(pidPath, 'utf8')).trim();
+        const pid = Number.parseInt(raw, 10);
+        if (!Number.isFinite(pid) || pid <= 0) {
+            return null;
+        }
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeChromePid(userDataDir, pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return;
+    const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
+    try {
+        await mkdir(path.dirname(pidPath), { recursive: true });
+        await writeFile(pidPath, `${Math.trunc(pid)}\n`, 'utf8');
+    }
+    catch {
+        // best effort
+    }
+}
+export function isProcessAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM means "exists but no permission"; treat as alive.
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+export async function verifyDevToolsReachable({ port, host = '127.0.0.1', attempts = 3, timeoutMs = 3000, }) {
+    const versionUrl = `http://${host}:${port}/json/version`;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            const response = await fetch(versionUrl, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            if (attempt < attempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    return { ok: false, error: 'unreachable' };
+}
+export async function cleanupStaleProfileState(userDataDir, logger, options = {}) {
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            await rm(candidate, { force: true });
+            logger?.(`Removed stale DevToolsActivePort: ${candidate}`);
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+    const lockRemovalMode = options.lockRemovalMode ?? 'never';
+    if (lockRemovalMode === 'never') {
+        return;
+    }
+    const pid = await readChromePid(userDataDir);
+    if (!pid) {
+        return;
+    }
+    if (isProcessAlive(pid)) {
+        logger?.(`Chrome pid ${pid} still alive; skipping profile lock cleanup`);
+        return;
+    }
+    // Extra safety: if Chrome is running with this profile (but with a different PID, e.g. user relaunched
+    // without remote debugging), never delete lock files.
+    if (await isChromeUsingUserDataDir(userDataDir)) {
+        logger?.('Detected running Chrome using this profile; skipping profile lock cleanup');
+        return;
+    }
+    const lockFiles = [
+        path.join(userDataDir, 'lockfile'),
+        path.join(userDataDir, 'SingletonLock'),
+        path.join(userDataDir, 'SingletonSocket'),
+        path.join(userDataDir, 'SingletonCookie'),
+    ];
+    for (const lock of lockFiles) {
+        await rm(lock, { force: true }).catch(() => undefined);
+    }
+    logger?.('Cleaned up stale Chrome profile locks');
+}
+async function isChromeUsingUserDataDir(userDataDir) {
+    if (process.platform === 'win32') {
+        // On Windows, lockfiles are typically held open and removal should fail anyway; avoid expensive process scans.
+        return false;
+    }
+    try {
+        const { stdout } = await execFileAsync('ps', ['-ax', '-o', 'command='], { maxBuffer: 10 * 1024 * 1024 });
+        const lines = String(stdout ?? '').split('\n');
+        const needle = userDataDir;
+        for (const line of lines) {
+            if (!line)
+                continue;
+            const lower = line.toLowerCase();
+            if (!lower.includes('chrome') && !lower.includes('chromium'))
+                continue;
+            if (line.includes(needle) && lower.includes('user-data-dir')) {
+                return true;
+            }
+        }
+    }
+    catch {
+        // best effort
+    }
+    return false;
+}

package/dist/src/cli/sessionDisplay.js

@@ -18,7 +18,14 @@ function isProcessAlive(pid) {
         return true;
     }
     catch (error) {
-        return !(error instanceof Error && error.code === 'ESRCH');
+        const code = error instanceof Error ? error.code : undefined;
+        if (code === 'ESRCH' || code === 'EINVAL') {
+            return false;
+        }
+        if (code === 'EPERM') {
+            return true;
+        }
+        return true;
     }
 }
 const CLEANUP_TIP = 'Tip: Run "oracle session --clear --hours 24" to prune cached runs (add --all to wipe everything).';

package/dist/src/cli/sessionRunner.js

@@ -360,11 +360,6 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 }
                 : undefined,
         });
-        if (mode === 'browser') {
-            log(dim('Next steps (browser fallback):')); // guides users when automation breaks
-            log(dim('- Rerun with --engine api to bypass Chrome entirely.'));
-            log(dim('- Or rerun with --engine api --render-markdown [--file …] to generate a single markdown bundle you can paste into ChatGPT manually (add --browser-bundle-files if you still want attachments).'));
-        }
         if (modelForStatus) {
             await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                 status: 'error',

package/dist/src/remote/server.js

@@ -4,12 +4,12 @@ import path from 'node:path';
 import net from 'node:net';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
 import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
 import chalk from 'chalk';
 import { runBrowserMode } from '../browserMode.js';
 import { loadChromeCookies } from '../browser/chromeCookies.js';
 import { CHATGPT_URL } from '../browser/constants.js';
+import { cleanupStaleProfileState, readDevToolsPort, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from '../browser/profileState.js';
 import { normalizeChatgptUrl } from '../browser/utils.js';
 async function findAvailablePort() {
     return await new Promise((resolve, reject) => {
@@ -209,10 +209,17 @@ export async function serveRemote(options = {}) {
         if (preferManualLogin) {
             await mkdir(manualProfileDir, { recursive: true });
             console.log(`Cookie extraction is unavailable on this platform. Using manual-login Chrome profile at ${manualProfileDir}. Remote runs will reuse this profile; sign in once when the browser opens.`);
-            const devtoolsPortFile = path.join(manualProfileDir, 'DevToolsActivePort');
-            const alreadyRunning = existsSync(devtoolsPortFile);
-            if (alreadyRunning) {
-                console.log('Detected an existing automation Chrome session; will reuse it for manual login.');
+            const existingPort = await readDevToolsPort(manualProfileDir);
+            if (existingPort) {
+                const reachable = await verifyDevToolsReachable({ port: existingPort });
+                if (reachable.ok) {
+                    console.log('Detected an existing automation Chrome session; will reuse it for manual login.');
+                }
+                else {
+                    console.log(`Found stale DevToolsActivePort (port ${existingPort}, ${reachable.error}); launching a fresh manual-login Chrome.`);
+                    await cleanupStaleProfileState(manualProfileDir, console.log, { lockRemovalMode: 'never' });
+                    void launchManualLoginChrome(manualProfileDir, CHATGPT_URL, console.log);
+                }
             }
             else {
                 void launchManualLoginChrome(manualProfileDir, CHATGPT_URL, console.log);
@@ -459,12 +466,11 @@ async function launchManualLoginChrome(profileDir, url, logger) {
         });
         const chosenPort = chrome?.port ?? debugPort ?? null;
         if (chosenPort) {
-            // Write DevToolsActivePort eagerly so maybeReuseRunningChrome can attach on the next run
-            const devtoolsFile = path.join(profileDir, 'DevToolsActivePort');
-            const devtoolsFileDefault = path.join(profileDir, 'Default', 'DevToolsActivePort');
-            const contents = `${chosenPort}\n/devtools/browser`;
-            await writeFile(devtoolsFile, contents).catch(() => undefined);
-            await writeFile(devtoolsFileDefault, contents).catch(() => undefined);
+            // Persist DevToolsActivePort eagerly so future runs can attach/reuse this Chrome.
+            await writeDevToolsActivePort(profileDir, chosenPort);
+            if (chrome?.pid) {
+                await writeChromePid(profileDir, chrome.pid);
+            }
             logger(`Manual-login Chrome DevTools port: ${chosenPort}`);
             logger(`If needed, DevTools JSON at http://127.0.0.1:${chosenPort}/json/version`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.2 Pro (via gpt-5.1-pro alias), GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "type": "module",
   "main": "dist/bin/oracle-cli.js",