@youdie006/prodex 0.16.30 → 0.16.31

package/dist/chatgpt-browser.js

@@ -1279,6 +1279,87 @@ async function selectProject(cdp, options) {
         throw new Error(`ChatGPT composer did not appear after entering project "${options.project}"`);
     }
 }
+// Read the finished answer from an existing ChatGPT thread WITHOUT sending a new
+// prompt. Recovers a consult whose send timed out but whose answer ChatGPT
+// completed afterwards: the durable receipt is "blocked", yet the full answer
+// sits in the thread the operator can see. Navigates the visible tab to the
+// thread and waits for a stable, non-generating answer.
+export async function recoverChatGptAnswerFromThread(options) {
+    const port = resolveCdpPort(options.port);
+    const timeoutMs = Math.max(1_000, options.timeoutMs ?? 60_000);
+    const url = normalizeChatGptTargetUrl(options.targetUrl);
+    const page = await findChatGptPage(port, 3_000);
+    if (!page.ok || !page.page) {
+        throw new ChatGptBrowserBlockerError(page.blocker ?? {
+            code: "browser_unreachable",
+            message: `No Chrome DevTools endpoint is reachable on 127.0.0.1:${port}.`,
+            retryable: true,
+            next_step: "Run `prodex pro browser login`, log in, then retry."
+        });
+    }
+    const cdp = await connectCdp(page.page.webSocketDebuggerUrl);
+    let state;
+    let generating = false;
+    let stableRuns = 0;
+    let lastAnswer = "";
+    try {
+        await cdp.send("Runtime.enable");
+        // In-tab navigation (location.assign, not Page.navigate which has crashed the
+        // instance) so we read the requested thread, not whatever was open.
+        await cdp.evaluate(`location.assign(${JSON.stringify(url)})`);
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            await sleep(500);
+            try {
+                state = await evaluateOnPage(page.page, answerExpression());
+            }
+            catch {
+                continue;
+            }
+            generating = state.generating;
+            const runtimeBlocker = chatGptBlockerFromAnswerState(state);
+            if (runtimeBlocker)
+                throw new ChatGptBrowserBlockerError(runtimeBlocker);
+            // Require a REAL assistant message, not answerExpression's page-chrome
+            // fallback (empty assistant returns sidebar/nav text): the thread's
+            // conversation loads asynchronously after navigation, so keep polling.
+            if (state.assistantMessageCount > 0 && isUsableChatGptAnswer(state.answer) && !state.generating) {
+                // Two identical settled reads: a just-finished streaming caret artifact
+                // must not sneak into the recovered text.
+                stableRuns = state.answer === lastAnswer ? stableRuns + 1 : 0;
+                lastAnswer = state.answer;
+                if (stableRuns >= 1)
+                    break;
+            }
+            else {
+                stableRuns = 0;
+                lastAnswer = "";
+            }
+        }
+    }
+    finally {
+        cdp.close();
+    }
+    if (!state || state.assistantMessageCount < 1 || !isUsableChatGptAnswer(state.answer)) {
+        throw new ChatGptBrowserBlockerError({
+            code: generating ? "still_generating" : "no_recoverable_answer",
+            message: generating
+                ? "That thread is still generating - the answer is not complete yet."
+                : "No finished assistant answer loaded from that thread (the conversation may not have rendered, or the URL is not the consult thread).",
+            retryable: true,
+            next_step: generating
+                ? "Wait for ChatGPT to finish, then rerun `prodex pro browser recover --target-url <url>`."
+                : "Confirm the URL is the consult thread that shows a finished answer, raise --timeout-ms if the page loads slowly, or send a fresh consult."
+        });
+    }
+    return {
+        url: state.url,
+        title: state.title,
+        answer: state.answer.trim(),
+        modelHints: state.modelHints,
+        warnings: []
+    };
+}
 export async function sendChatGptPrompt(options) {
     const port = resolveCdpPort(options.port);
     const timeoutMs = options.timeoutMs ?? 90_000;

package/dist/cli-help.js

@@ -25,6 +25,7 @@ Ask / consult commands:
   prodex pro browser smoke [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000]
   prodex pro browser models [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of model menu options
   prodex pro browser projects [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--timeout-ms 15000]  # read-only list of sidebar project names (for --project)
+  prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # recover a finished answer from a thread whose send timed out
   prodex pro browser ask [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] [--timeout-ms 90000] [--busy-wait-ms 600000] [--target-url url --confirm-target] [--new-chat] [--stdin] [--json] [--auto-login|--no-auto-login] [--file path] [--model Pro] [--pro-mode 기본|확장] [--effort 즉시|중간|높음|"매우 높음"] [--project "name" | --project-new "name"] "prompt"  # explicit visible-browser send
   prodex pro latest [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo]
   prodex pro list [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--json]

package/dist/cli-pro.js

@@ -1,7 +1,7 @@
 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, readLastBrowserLoginLaunch, recordBrowserLoginLaunch, sendChatGptPrompt } from "./chatgpt-browser.js";
+import { DEFAULT_CDP_PORT, resolveCdpPort, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, listChatGptModelOptions, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, parseProMode, parseReasoningEffort, readLastBrowserLoginLaunch, 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, readPositiveIntegerFlag, readRepeatedFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError } from "./cli-args.js";
 import { printProBrowserHelp, printProHelp } from "./cli-help.js";
 import { listRawResultsForInspection, listTasksForInspection } from "./cli-ledger.js";
@@ -366,7 +366,64 @@ export async function runProCommand(rest, io, runCliFn) {
             io.stdout("Use with `pro browser ask --project \"<name>\"` or pin one with `prodex setup --project \"<name>\"`.");
             return 0;
         }
-        throw unknownSubcommandError("pro browser", browserSubcommand, ["login", "ask", "smoke", "check", "models", "projects"]);
+        if (browserSubcommand === "recover") {
+            if (printProBrowserHelpIfRequested(browserArgs, "pro browser recover", io, { valueFlags: ["--cwd", "--port", "--timeout-ms", "--target-url", "--source-cli"] }))
+                return 0;
+            assertOnlyOptions(browserArgs, "pro browser recover", ["--cwd", "--port", "--timeout-ms", "--target-url", "--source-cli"]);
+            const recoverCwd = resolveCwdFlag(io.cwd, browserArgs);
+            const recoverSourceCli = resolveOptionalFileFlag(io.cwd, browserArgs, "--source-cli");
+            const targetUrl = readFlag(browserArgs, "--target-url");
+            if (!targetUrl) {
+                throw new Error("pro browser recover requires --target-url <thread-url> - the ChatGPT conversation URL whose finished answer to recover (e.g. the thread from a send_timeout blocker).");
+            }
+            const recoverPort = readPortFlag(browserArgs, "--port");
+            const recoverTimeoutMs = readPositiveIntegerFlag(browserArgs, "--timeout-ms");
+            const recoverResolvedPort = resolveCdpPort(recoverPort);
+            let consult;
+            try {
+                consult = await recoverChatGptAnswerFromThread({ port: recoverPort, targetUrl, timeoutMs: recoverTimeoutMs });
+            }
+            catch (error) {
+                const blocker = sourceAwareBrowserBlocker(browserSendBlockerFromError(error), recoverSourceCli, {
+                    ...(recoverResolvedPort !== DEFAULT_CDP_PORT ? { port: recoverResolvedPort } : {})
+                });
+                throw new Error(blocker.next_step ? `${blocker.message} Next: ${blocker.next_step}` : errorMessage(error));
+            }
+            // Record the recovered answer as a done consult so `pro latest` re-prints it.
+            const recoverStore = new BridgeStore(recoverCwd);
+            const recoveredTask = await recoverStore.createTask({
+                source: "codex",
+                title: "GPT Pro consult (recovered)",
+                prompt: `Recovered answer from ${consult.url}`,
+                repo_id: "default",
+                files: [],
+                provenance: { adapter: "chatgpt-control", thread: consult.url, warnings: [] }
+            });
+            const recoveredArtifactText = formatProConsultArtifact(consult);
+            let recoveredArtifactPath;
+            try {
+                recoveredArtifactPath = await recoverStore.writeArtifactText(`.bridge/artifacts/pro-consults/${recoveredTask.id}.md`, recoveredArtifactText);
+            }
+            catch (error) {
+                io.stderr(`answer_artifact_warning: ${errorMessage(error)}`);
+            }
+            await recoverStore.completeTask(recoveredTask.id, {
+                status: "done",
+                summary: consult.answer,
+                artifacts: recoveredArtifactPath
+                    ? [{ path: recoveredArtifactPath, role: "result", bytes: Buffer.byteLength(recoveredArtifactText, "utf8") }]
+                    : [],
+                commands: ["recovered ChatGPT answer from thread"],
+                warnings: [],
+                provenance: { thread: consult.url, warnings: [] }
+            });
+            io.stdout(`${recoveredTask.id}\tdone\t${consult.url}`);
+            io.stdout("");
+            io.stdout(consult.answer);
+            io.stderr(`recovered: answer saved to .bridge; re-print with \`prodex pro latest --cwd ${recoverCwd}\``);
+            return 0;
+        }
+        throw unknownSubcommandError("pro browser", browserSubcommand, ["login", "ask", "smoke", "check", "models", "projects", "recover"]);
     }
     if (subcommand === "open" || subcommand === "status" || subcommand === "smoke" || subcommand === "check" || subcommand === "doctor") {
         throw new Error(`Use \`prodex pro browser ${subcommand === "doctor" ? "check" : subcommand}\` for explicit browser automation.`);

package/package.json

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