@youdie006/prodex 0.16.29 → 0.16.31

package/dist/chatgpt-browser.js

@@ -1246,13 +1246,15 @@ async function selectProject(cdp, options) {
         // project - which would silently send the prompt into the wrong project.
         const alreadyInRequestedProject = await cdp.evaluate(`(() => {
         if (!/^https:\\/\\/chatgpt\\.com\\/g\\/g-p-/.test(location.href)) return false;
-        const name = ${JSON.stringify(options.project)};
-        // Equality, not substring: a stalled cross-project navigation must not
-        // be accepted just because the current project's name CONTAINS the
-        // requested one (e.g. sitting on "Research Lab" while "Research" was
-        // requested), which would silently send into the wrong project.
-        if ((document.title || "").trim() === name) return true;
-        return [...document.querySelectorAll('h1,[role="heading"]')].some((h) => (h.innerText || "").trim() === name);
+        const name = ${JSON.stringify(options.project)}.toLowerCase();
+        // Case-insensitive EQUALITY (not substring): matches the case-insensitive
+        // sidebar-row lookup (so "codex" is accepted while sitting on "Codex"),
+        // but a stalled cross-project navigation must NOT be accepted just because
+        // the current project's name CONTAINS the requested one (e.g. "Research
+        // Lab" while "Research" was requested) - that would send into the wrong
+        // project.
+        if ((document.title || "").trim().toLowerCase() === name) return true;
+        return [...document.querySelectorAll('h1,[role="heading"]')].some((h) => (h.innerText || "").trim().toLowerCase() === name);
       })()`);
         if (!alreadyInRequestedProject) {
             throw new Error(`Clicking project "${options.project}" did not navigate the visible tab. If the tab is already inside this project, omit --project and retry.`);
@@ -1277,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;
@@ -1379,11 +1462,27 @@ export async function sendChatGptPrompt(options) {
     };
     let beforeSubmit;
     let submitButtonFound = false;
+    const sendWarnings = [];
     const cdp = await connectCdp(page.webSocketDebuggerUrl);
     try {
         await cdp.send("Runtime.enable");
         await selectProject(cdp, options);
-        await selectModelReasoning(cdp, options);
+        try {
+            await selectModelReasoning(cdp, options);
+        }
+        catch (modelError) {
+            // Pro sub-mode isn't exposed in this UI yet (staged rollout). Pro itself is
+            // already selected by this point, so degrade to plain Pro with a warning
+            // instead of failing the whole consult - an agent's --pro-mode 확장 becomes
+            // a successful plain-Pro send rather than a hard block it has to retry past.
+            const modelMsg = modelError instanceof Error ? modelError.message : String(modelError);
+            if (options.proMode && /does not expose Pro sub-modes/.test(modelMsg)) {
+                sendWarnings.push("pro_mode_unavailable: this ChatGPT UI does not expose Pro sub-modes yet, so the consult was sent as plain Pro. Drop --pro-mode (or run `prodex setup --clear-pro-mode`).");
+            }
+            else {
+                throw modelError;
+            }
+        }
         // Capture the answer baseline AFTER any project navigation or model switch
         // so assistant-message counts compare within the thread we actually send
         // into; a --project/--project-new hop lands on a page with its own counts.
@@ -1520,7 +1619,7 @@ export async function sendChatGptPrompt(options) {
             title: completed.title,
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
-            warnings: []
+            warnings: [...sendWarnings]
         };
     }
     // Timed out while the answer was still streaming: salvage the partial text
@@ -1534,6 +1633,7 @@ export async function sendChatGptPrompt(options) {
             answer: completed.answer.trim(),
             modelHints: completed.modelHints,
             warnings: [
+                ...sendWarnings,
                 `answer_incomplete: ChatGPT was still generating after ${formatDurationMs(timeoutMs)} (${timeoutMs}ms), so the answer below may be truncated. Raise --timeout-ms and retry for the full response.`
             ]
         };

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.`);
@@ -545,7 +602,19 @@ export async function runAskProCommand(rest, io) {
     }
     const targetCwd = resolveCwdFlag(io.cwd, parsedAskPro.optionArgs);
     const targetStore = new BridgeStore(targetCwd);
-    const files = readRepeatedFlag(parsedAskPro.optionArgs, "--file");
+    const files = readRepeatedFlag(parsedAskPro.optionArgs, "--file").map((file) => {
+        if (!path.isAbsolute(file))
+            return file;
+        // Accept an absolute --file that points INSIDE the repo by converting it to
+        // the repo-relative path the reader requires (agents naturally pass absolute
+        // paths); reject one that escapes the repo so a file outside the project
+        // (secrets, ~/.ssh, ...) is not attached to a consult by mistake.
+        const rel = path.relative(targetCwd, path.resolve(file));
+        if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) {
+            throw new Error(`--file "${file}" is outside the repo root (${targetCwd}). Pass a path inside the repo (absolute or relative), or point --cwd at that repo.`);
+        }
+        return rel;
+    });
     const targetUrl = readFlag(parsedAskPro.optionArgs, "--target-url");
     const normalizedTargetUrl = targetUrl ? normalizeChatGptTargetUrl(targetUrl) : undefined;
     if (!normalizedTargetUrl && parsedAskPro.optionArgs.includes("--confirm-target")) {
@@ -559,12 +628,15 @@ export async function runAskProCommand(rest, io) {
         throw new Error("--json applies to the visible-browser send output; the dry-run preview does not support it.");
     }
     const prompt = parsedAskPro.promptParts.join(" ").trim();
-    if (!prompt) {
+    const usingStdin = parsedAskPro.optionArgs.includes("--stdin");
+    // A prompt is required UNLESS --stdin supplies one: `git diff | prodex ask
+    // --stdin` (piped text is the whole prompt) is as valid as `... --stdin
+    // "review this"` (positional instruction + piped data below it).
+    if (!prompt && !usingStdin) {
         throw new Error('ask-pro requires a prompt. Example: prodex ask "Explain this stack trace" (or pipe input: git diff | prodex ask --stdin "review this diff").');
     }
     let promptText = prompt;
-    if (parsedAskPro.optionArgs.includes("--stdin")) {
-        // Unix ergonomics: `git diff | prodex ask --stdin "review this"`.
+    if (usingStdin) {
         const piped = ((await io.readStdin?.()) ?? "").trim();
         if (!piped) {
             throw new Error("--stdin was set but no piped input was received on stdin (pipe something in, e.g. `git diff | prodex ask --stdin \"review\"`).");
@@ -573,7 +645,7 @@ export async function runAskProCommand(rest, io) {
         if (piped.length > MAX_STDIN_CHARS) {
             throw new Error(`--stdin input is too large (${piped.length} chars > ${MAX_STDIN_CHARS}); attach a file with --file instead.`);
         }
-        promptText = `${prompt}\n\n--- piped input (stdin) ---\n${piped}`;
+        promptText = prompt ? `${prompt}\n\n--- piped input (stdin) ---\n${piped}` : piped;
     }
     const browserDefaults = await loadBrowserDefaults(targetCwd);
     const explicitProject = readFlag(parsedAskPro.optionArgs, "--project");

package/package.json

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