@youdie006/prodex 0.25.0 → 0.26.0

package/dist/chatgpt-browser.js

@@ -363,6 +363,48 @@ export async function ensureVirtualDisplay(options = {}) {
     }
     throw new Error(`No free X display between :${first} and :${first + 9}. Set PRODEX_VIRTUAL_DISPLAY_NUM to a free number.`);
 }
+/**
+ * How should the dedicated browser be opened?
+ *
+ * An explicit flag or environment variable wins; otherwise reopen it the way it
+ * was last opened. Without the saved fallback, `pro browser login` - the exact
+ * command every `browser_unreachable` blocker tells people to run - put a
+ * VISIBLE window back on the desktop of someone who had set up a virtual
+ * display, which is the surprise window they went to that trouble to avoid.
+ *
+ * Choosing a mode explicitly replaces the saved one wholesale rather than
+ * merging with it: asking for headless must not also rejoin an old virtual
+ * display.
+ */
+export function resolveBrowserWindowMode(args) {
+    const env = args.env ?? process.env;
+    const flags = args.flags ?? {};
+    const fromEnv = (name) => {
+        const raw = (env[name] ?? "").trim().toLowerCase();
+        if (raw === "")
+            return undefined;
+        return raw === "1" || raw === "true" || raw === "yes";
+    };
+    const explicit = {
+        headless: flags.headless ?? fromEnv("PRODEX_HEADLESS"),
+        virtualDisplay: flags.virtualDisplay ?? fromEnv("PRODEX_VIRTUAL_DISPLAY"),
+        minimized: flags.minimized ?? fromEnv("PRODEX_MINIMIZE_WINDOW")
+    };
+    const chosen = Object.values(explicit).some((value) => value === true);
+    if (chosen) {
+        return {
+            headless: explicit.headless === true,
+            virtualDisplay: explicit.virtualDisplay === true,
+            minimized: explicit.minimized === true
+        };
+    }
+    const saved = args.lastLogin;
+    return {
+        headless: saved?.headless === true,
+        virtualDisplay: saved?.virtual_display !== undefined,
+        minimized: saved?.minimized === true
+    };
+}
 export function resolveHeadlessPreference(explicit, env = process.env) {
     if (typeof explicit === "boolean")
         return explicit;
@@ -416,6 +458,11 @@ export function isUsableChatGptAnswer(answer) {
         if (toolPanelOnly)
             return false;
     }
+    // ChatGPT's own interruption notice, which is what a thread shows after the
+    // browser dies mid-stream. Measured: recover saved "Pro thinking / Connection
+    // interrupted. Waiting for the complete answer" as a recovered answer.
+    if (/connection interrupted|연결이\s*중단/i.test(normalized) && normalized.length < 200)
+        return false;
     return true;
 }
 /**
@@ -439,6 +486,26 @@ export function classifyTranscriptRead(state, sentPrompt) {
         ? "pending"
         : "unavailable";
 }
+/**
+ * Should prodex drag the tab back to the thread it pinned?
+ *
+ * Only when the pin is a real conversation, and only when the page is the only
+ * way left to read the answer. Pinning a project or new-chat page (the url a
+ * send starts on, before ChatGPT rewrites it to /c/<id>) made prodex treat its
+ * OWN conversation as a stray tab and navigate away from the answer it was
+ * waiting for. And while the transcript can answer, moving someone else's tab
+ * back buys nothing.
+ */
+export function shouldRecoverThreadNavigation(args) {
+    const { pinnedThreadUrl, currentUrl, lastTranscriptClassification } = args;
+    if (!pinnedThreadUrl || !currentUrl)
+        return false;
+    if (!conversationIdFromThreadUrl(pinnedThreadUrl))
+        return false;
+    if (lastTranscriptClassification === "pending" || lastTranscriptClassification === "answer")
+        return false;
+    return !chatGptUrlsReferToSameTarget(currentUrl, pinnedThreadUrl);
+}
 export function hasFreshChatGptAnswer(previousAssistantMessageCount, state) {
     return state.assistantMessageCount > previousAssistantMessageCount && isUsableChatGptAnswer(state.answer) && !state.generating;
 }
@@ -1725,6 +1792,26 @@ export async function recoverChatGptAnswerFromThread(options) {
                         warnings: []
                     };
                 }
+                // Not a research thread: read the ordinary answer from the transcript
+                // too. Recover used to be page-only, so it inherited everything the
+                // page loses - flattened markdown, dropped citation urls - and it once
+                // saved ChatGPT's "Connection interrupted" notice as the answer.
+                const transcript = await evaluateOnPage(page.page, transcriptAnswerExpression(conversationId), {
+                    timeoutMs: 60_000
+                });
+                if (transcript.ok && transcript.text.trim().length > 0) {
+                    const recovered = resolveTranscriptCitations(transcript.text, transcript.references).trim();
+                    if (recovered.length > 0) {
+                        return {
+                            url,
+                            title: "",
+                            answer: recovered,
+                            modelHints: [],
+                            ...(transcript.modelSlug ? { modelSlug: transcript.modelSlug } : {}),
+                            warnings: []
+                        };
+                    }
+                }
             }
             catch {
                 // Not a research thread, or the transcript API is unavailable: fall
@@ -2108,12 +2195,21 @@ export async function sendChatGptPrompt(options) {
         if (!conversationId)
             throw new ChatGptBrowserBlockerError(deepResearchUnreadableBlocker(pinnedThreadUrl ?? "https://chatgpt.com/"));
         let lastState;
+        let consecutiveResearchReadFailures = 0;
         while (Date.now() - started < timeoutMs) {
             try {
                 lastState = await evaluateOnPage(page, deepResearchReportExpression(conversationId), { timeoutMs: 60_000 });
+                consecutiveResearchReadFailures = 0;
             }
             catch {
-                // Transient CDP/network failure: keep polling until the budget runs out.
+                // A few failures in a row mean the browser is gone, not busy. Waiting
+                // out a 30-minute budget on a dead browser helps nobody: the research
+                // finishes on ChatGPT's side anyway, so hand back the thread and let
+                // recover collect the report.
+                consecutiveResearchReadFailures += 1;
+                if (consecutiveResearchReadFailures >= CONSECUTIVE_READ_FAILURES_BEFORE_GIVING_UP) {
+                    throw new ChatGptBrowserBlockerError(browserLostMidWaitBlocker(pinnedThreadUrl));
+                }
                 await sleep(5_000);
                 continue;
             }
@@ -2143,11 +2239,14 @@ export async function sendChatGptPrompt(options) {
         });
     }
     let recoveredNavigations = 0;
+    let lastTranscriptClassification;
+    let consecutiveReadFailures = 0;
     const answerIsStable = createChatGptAnswerStabilityTracker();
     while (Date.now() - started < timeoutMs) {
         await sleep(1000);
         try {
             finalState = await evaluateOnPage(page, answerExpression());
+            consecutiveReadFailures = 0;
             // First conversation id wins. Re-deriving it every poll would let a tab
             // that wandered to another thread redirect the read to a stranger's
             // conversation - and the prompt check below is the second line of defence,
@@ -2159,12 +2258,11 @@ export async function sendChatGptPrompt(options) {
             // instead of caret heuristics, and the model that actually answered.
             if (transcriptConversationId && !finalState.generating) {
                 const transcript = await readTranscriptAnswer(page, transcriptConversationId, options.prompt);
+                lastTranscriptClassification = transcript.classification;
                 if (transcript.answer)
                     return transcriptResult(transcript.answer);
             }
-            // Only the DOM reader depends on which thread the tab is showing; once the
-            // conversation id is known, a wandering tab is harmless.
-            if (!transcriptConversationId && pinnedThreadUrl && finalState?.url && !chatGptUrlsReferToSameTarget(finalState.url, pinnedThreadUrl)) {
+            if (shouldRecoverThreadNavigation({ pinnedThreadUrl, currentUrl: finalState?.url, lastTranscriptClassification })) {
                 if (recoveredNavigations >= 2) {
                     throw new ChatGptBrowserBlockerError({
                         code: "thread_navigated_away",
@@ -2186,7 +2284,13 @@ export async function sendChatGptPrompt(options) {
                 throw error;
             // Transient CDP failure while the answer is streaming: retry. A throw here
             // would discard an already-streamed partial answer and skip the salvage
-            // path below, so keep the last good state and poll again until timeout.
+            // path below, so keep the last good state and poll again. But a run of
+            // failures is a browser that went away rather than a busy one, and
+            // sitting out the whole budget on it only delays the recovery.
+            consecutiveReadFailures += 1;
+            if (consecutiveReadFailures >= CONSECUTIVE_READ_FAILURES_BEFORE_GIVING_UP) {
+                throw new ChatGptBrowserBlockerError(browserLostMidWaitBlocker(finalState?.url ?? pinnedThreadUrl));
+            }
             continue;
         }
         const runtimeBlocker = chatGptBlockerFromAnswerState(finalState);
@@ -2205,6 +2309,7 @@ export async function sendChatGptPrompt(options) {
             // code that innerText flattens) and the model that actually answered.
             if (transcriptConversationId) {
                 const transcript = await readTranscriptAnswer(page, transcriptConversationId, options.prompt);
+                lastTranscriptClassification = transcript.classification;
                 if (transcript.answer)
                     return transcriptResult(transcript.answer);
                 // The transcript can read this conversation and says it is not done:
@@ -3052,6 +3157,32 @@ export function chunkComposerText(text, size = COMPOSER_INSERT_CHUNK_CHARS) {
  * so hand the run back rather than waiting on a page that never renders it -
  * deep research draws into a widget iframe, leaving the thread DOM empty.
  */
+/**
+ * The dedicated browser died while a send was waiting for its answer.
+ *
+ * Observed live: Chrome went away mid deep-research run, every poll threw, the
+ * loop swallowed each failure, and the send sat silent for the rest of a
+ * 30-minute budget - while the research finished on ChatGPT's side. Nothing is
+ * lost except the ability to read it, so fail fast and hand back the thread.
+ */
+// Reading the page can fail for a moment (a navigation, a busy renderer). Five
+// failures in a row is not a moment - it is a browser that went away.
+const CONSECUTIVE_READ_FAILURES_BEFORE_GIVING_UP = 5;
+export function browserLostMidWaitBlocker(threadUrl) {
+    // Killing the browser aborts a streaming answer too, so promise nothing
+    // about the answer itself - only say where to look. Deep research is the one
+    // case that genuinely keeps going without us.
+    const where = threadUrl ? ` The consult landed in ${threadUrl}` : "";
+    return {
+        code: "browser_unreachable",
+        message: `The dedicated ChatGPT browser stopped responding while this consult was waiting for its answer.${where}`,
+        retryable: true,
+        next_step: threadUrl
+            ? `Run \`prodex pro browser login\` to reopen the browser, then collect the answer with \`prodex pro browser recover --target-url ${threadUrl}\` (MCP: pro_recover with thread ${threadUrl}).`
+            : "Run `prodex pro browser login` to reopen the browser, then retry.",
+        ...(threadUrl ? { thread: threadUrl } : {})
+    };
+}
 export function deepResearchUnreadableBlocker(threadUrl) {
     return {
         code: "deep_research_not_readable",
@@ -3135,7 +3266,14 @@ const NORMALIZED_PROMPT_MATCH_CHARS = 120;
  * tool prefixes it ("@Deep research ...") and attachments append to it.
  */
 export function transcriptMatchesSentPrompt(userText, sentPrompt) {
-    const normalize = (value) => value.replace(/\s+/g, " ").trim();
+    // The composer escapes markdown when it stores what was typed ("## File" is
+    // kept as "\\## File", fences as escaped backticks), so undo that before
+    // comparing - otherwise every prompt carrying markdown, which is every
+    // --file send, looks like a different conversation.
+    const normalize = (value) => value
+        .replace(/\\([\\`*_{}[\]()#+\-.!>~|])/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim();
     const seen = normalize(userText);
     const sent = normalize(sentPrompt);
     if (seen.length === 0 || sent.length === 0)
@@ -3370,17 +3508,11 @@ export function answerExpression() {
     });
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     const userMessages = messages.filter((message) => message.role === "user");
-    // Deep research renders no assistant-role node at all: the thread is
-    // conversation-turn sections, the prompt in the first and the report in a
-    // later one (measured live - roles were ["user"] only while a research ran).
-    // Fall back to the last turn that is NOT the user's, so such an answer is
-    // readable instead of looking like "no answer" forever.
-    const turnAnswers = assistantMessages.length > 0 ? [] : [...document.querySelectorAll('[data-testid^="conversation-turn"]')]
-      .filter((turn) => !turn.querySelector('[data-message-author-role="user"]'))
-      .map((turn) => ({ role: "assistant", text: (turn.innerText || "").trim(), modelSlug: undefined }))
-      .filter((turn) => turn.text.length > 0);
-    const effectiveAssistants = assistantMessages.length > 0 ? assistantMessages : turnAnswers;
-    const assistant = effectiveAssistants.at(-1);
+    // A turn without an assistant message is NOT an answer. Treating one as an
+    // answer (a 0.21.3 fallback for deep research, which is read from the
+    // transcript now) turned a tool's progress panel into a 28-character
+    // "answer" that a consult returned as its result.
+    const assistant = assistantMessages.at(-1);
     const buttons = [...document.querySelectorAll('button,[role="button"]')]
       .filter((node) => !!(node.offsetWidth || node.offsetHeight || node.getClientRects().length))
       .filter((node) => !node.closest(excludedTextSelector))
@@ -3393,13 +3525,16 @@ export function answerExpression() {
     return {
       title: document.title,
       url: location.href,
-      answer: assistant ? answer : text.slice(-4000),
+      // No assistant message means no answer. This used to hand back the last
+      // 4000 characters of the page, which reads as sidebar and navigation text
+      // dressed up as a reply.
+      answer,
       textSample: text.slice(0, 12000),
       blockerTextSample: visibleTextOutsideMessages(excludedTextSelector).slice(0, 12000),
       blockerScanTextSample: visibleTextOutsideMessages(blockerScanExcludedSelector).slice(0, 12000),
       visibleButtonLabels: buttons,
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || buttons.some((label) => generatingControlPattern.test(label)),
-      assistantMessageCount: effectiveAssistants.length,
+      assistantMessageCount: assistantMessages.length,
       userMessageCount: userMessages.length,
       // ChatGPT tags each assistant message with the model that produced it -
       // the only ground truth for "did the Pro selection actually take".

package/dist/cli-pro.js

@@ -2,7 +2,7 @@ import { existsSync, statSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { buildDryRunBundle } from "./bundle.js";
-import { DEFAULT_CDP_PORT, resolveCdpPort, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, listChatGptModelOptions, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveVirtualDisplayPreference, resolveHeadlessPreference, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt } from "./chatgpt-browser.js";
+import { DEFAULT_CDP_PORT, resolveCdpPort, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, listChatGptModelOptions, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveVirtualDisplayPreference, resolveBrowserWindowMode, resolveHeadlessPreference, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt } from "./chatgpt-browser.js";
 import { ASK_PRO_BOOLEAN_FLAGS, ASK_PRO_PREVIEW_VALUE_FLAGS, ASK_PRO_VALUE_FLAGS, assertHelpRequestArgs, assertNoExtraArgs, assertOnlyOptions, findHelpFlagIndexBeforePromptDelimiter, formatCliCommand, hasAskProDryRunMode, hasAskProMode, hasAskProSendMode, isHelpSubcommand, parseAskProArgs, printHelpIfRequested, readFlag, readPortFlag, readPositionalsWithOptions, readNonNegativeIntegerFlag, readPositiveIntegerFlag, readRepeatedFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError } from "./cli-args.js";
 import { printProBrowserHelp, printProHelp } from "./cli-help.js";
 import { listRawResultsForInspection, listTasksForInspection } from "./cli-ledger.js";
@@ -222,14 +222,30 @@ export async function runProCommand(rest, io, runCliFn) {
             // again: Chrome's singleton would just open ANOTHER window (the recurring
             // "extra windows" problem, which then blocks sends as
             // ambiguous_chatgpt_tabs). Reuse the running instance instead.
-            const headless = resolveHeadlessPreference(browserArgs.includes("--headless") ? true : undefined);
-            // A real browser on a virtual X display: no window anywhere, and
-            // Cloudflare sees an ordinary headed Chrome (headless it rejects).
-            const wantsVirtualDisplay = resolveVirtualDisplayPreference(browserArgs.includes("--virtual-display") ? true : undefined);
-            if (wantsVirtualDisplay && headless) {
+            if (browserArgs.includes("--virtual-display") && browserArgs.includes("--headless")) {
                 throw new Error("pro browser login cannot combine --headless and --virtual-display (a virtual display already hides the window).");
             }
-            const virtualDisplay = wantsVirtualDisplay ? await ensureVirtualDisplay() : undefined;
+            // Reopen the browser the way it was last opened unless a flag or the
+            // environment says otherwise. A virtual-display user who follows the
+            // `browser_unreachable` advice used to get a visible window back.
+            const savedLaunch = await readLastBrowserLoginLaunch();
+            const windowMode = resolveBrowserWindowMode({
+                flags: {
+                    ...(browserArgs.includes("--headless") ? { headless: true } : {}),
+                    ...(browserArgs.includes("--virtual-display") ? { virtualDisplay: true } : {}),
+                    ...(browserArgs.includes("--minimized") ? { minimized: true } : {})
+                },
+                ...(savedLaunch ? { lastLogin: savedLaunch } : {})
+            });
+            const headless = windowMode.headless;
+            // A real browser on a virtual X display: no window anywhere, and
+            // Cloudflare sees an ordinary headed Chrome (headless it rejects).
+            const wantsVirtualDisplay = windowMode.virtualDisplay;
+            const virtualDisplay = wantsVirtualDisplay
+                ? await ensureVirtualDisplay(savedLaunch?.virtual_display !== undefined && !browserArgs.includes("--virtual-display")
+                    ? { displayNumber: savedLaunch.virtual_display }
+                    : {})
+                : undefined;
             const alreadyRunning = (await getChatGptBrowserStatus({ port })).reachable;
             if (alreadyRunning) {
                 // One Chrome profile cannot serve a headed and a headless instance at

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",