@youdie006/prodex 0.16.5 → 0.16.7

package/dist/chatgpt-browser.js

@@ -476,6 +476,12 @@ async function readSettledChatGptPageStatus(page) {
     // "not ready". Escape dismisses such dialogs; try it (bounded) only when the
     // composer is actually blocked and a dialog is open.
     for (let attempt = 0; attempt < 2 && !status.hasComposer && (status.openDialogText ?? "").length > 0; attempt += 1) {
+        // Never Escape a dialog that IS the evidence of a real blocker (usage
+        // limit, verification, captcha): dismissing it would destroy the precise
+        // diagnosis and let the send proceed into a generic failure. The blocker
+        // scan sample includes the dialog text, so detection sees it.
+        if (detectChatGptPageBlocker(status))
+            break;
         await dismissOpenDialogViaEscape(page);
         await sleep(500);
         status = await evaluateOnPage(page, statusExpression());
@@ -483,17 +489,20 @@ async function readSettledChatGptPageStatus(page) {
     return status;
 }
 async function dismissOpenDialogViaEscape(page) {
-    const cdp = await connectCdp(page.webSocketDebuggerUrl);
+    // Best effort throughout - including the connect itself: a browser that quit
+    // between the status read and this dismiss must not abort the settle loop
+    // with a raw websocket error (the loop just reports the not-ready state).
+    let cdp;
     try {
+        cdp = await connectCdp(page.webSocketDebuggerUrl);
         await cdp.send("Runtime.enable");
         await dispatchEscapeKey(cdp);
     }
     catch {
-        // Best effort: if the Escape cannot be delivered the settle loop simply
-        // reports the original not-ready state.
+        // reported by the settle loop as the original not-ready state
     }
     finally {
-        cdp.close();
+        cdp?.close();
     }
 }
 async function ensureVisibleChatGptPage(port, page, status) {
@@ -541,13 +550,24 @@ function chatGptPageMissingBlocker() {
         next_step: "Open https://chatgpt.com/ in the dedicated Chrome profile, or run `prodex pro browser login` to reopen it."
     };
 }
-export function assertChatGptReadyForPrompt(loggedInLikely, hasComposer) {
+export function assertChatGptReadyForPrompt(loggedInLikely, hasComposer, openDialogText) {
     if (loggedInLikely && hasComposer)
         return;
     const missing = [
         loggedInLikely ? undefined : "a clear logged-in ChatGPT session",
         hasComposer ? undefined : "a visible prompt composer"
     ].filter(Boolean);
+    // A dialog that survived the Escape auto-dismiss is the actual cause - name
+    // it so the user closes the modal instead of chasing the login advice.
+    const dialogHead = (openDialogText ?? "").trim().split("\n")[0]?.slice(0, 80);
+    if (!hasComposer && dialogHead) {
+        throw new ChatGptBrowserBlockerError({
+            code: "chatgpt_not_ready",
+            message: `ChatGPT browser is reachable, but an open dialog ("${dialogHead}") is blocking the prompt composer.`,
+            retryable: true,
+            next_step: "Close the dialog in the visible browser (it did not respond to Escape), then retry."
+        });
+    }
     throw new ChatGptBrowserBlockerError({
         code: "chatgpt_not_ready",
         message: `ChatGPT browser is reachable, but it is missing ${missing.join(" and ")}.`,
@@ -910,11 +930,16 @@ async function selectModelReasoning(cdp, options) {
             // Open the Pro sub-mode submenu via the chevron, then pick 기본/확장.
             const expander = await cdp.evaluate(proSubmenuExpanderRectExpression());
             if (!expander.ok || expander.x === undefined || expander.y === undefined) {
-                // The 2026-07 ChatGPT update removed the Pro sub-mode chevron from the
-                // model picker (verified live, including on hover) - Pro is a plain
-                // radio now. Name the change and the working alternative instead of a
-                // bare "expander not found".
-                throw new Error("The ChatGPT model menu no longer offers Pro sub-modes (the 2026-07 update removed the Pro submenu; Pro is a single mode now). Use --model Pro instead of --pro-mode. If ChatGPT restores sub-modes, update prodex (npm i -g @youdie006/prodex@latest).");
+                // Only the expander-specific miss means "the 2026-07 update removed the
+                // submenu"; other reasons (no Pro entry on a Plus plan, menu not open)
+                // must surface verbatim or the guidance sends users to a --model Pro
+                // that fails the same way.
+                if (expander.reason && expander.reason !== "Pro sub-mode expander not found next to Pro") {
+                    throw new Error(expander.reason);
+                }
+                // The saved setup default injects pro_mode into plain asks, so the user
+                // may never have typed --pro-mode - name the clear command too.
+                throw new Error("The ChatGPT model menu no longer offers Pro sub-modes (the 2026-07 update removed the Pro submenu; Pro is a single mode now). Use --model Pro instead of --pro-mode - and if this ask did not pass --pro-mode, a saved default is injecting it: run `prodex setup --clear-pro-mode`. If ChatGPT restores sub-modes, update prodex (npm i -g @youdie006/prodex@latest).");
             }
             await verifiedClickAt(cdp, expander.x, expander.y, "Pro sub-mode expander");
             const subLabels = PRO_MODE_SUBMENU_LABELS[options.proMode];
@@ -953,7 +978,7 @@ async function selectModelReasoning(cdp, options) {
             throw new Error(`ChatGPT model/effort option not found: ${primaryLabel}${primary.available ? ` (available: ${primary.available.join(", ")})` : ""}`);
         }
         if (primary.role === "menuitem" && primary.haspopup === "menu") {
-            throw new Error(`ChatGPT model "${primaryLabel}" opens a submenu of variants instead of committing; selecting it is not supported yet. Supported today: reasoning efforts (--effort) and Pro via --pro-mode.`);
+            throw new Error(`ChatGPT model "${primaryLabel}" opens a submenu of variants instead of committing; selecting it is not supported yet. Supported today: reasoning efforts (--effort) and --model Pro.`);
         }
         await verifiedClickAt(cdp, primary.x, primary.y, primaryLabel);
         await assertSelectionCommitted(cdp, primaryLabel);
@@ -1074,12 +1099,18 @@ async function selectProject(cdp, options) {
     await verifiedClickAt(cdp, hit.x, hit.y, `project ${options.project}`);
     const navigated = await waitForExpressionTrue(cdp, `location.href !== ${JSON.stringify(hrefBefore)}`, PROJECT_NAVIGATION_TIMEOUT_MS);
     if (!navigated) {
-        // The href staying put is fine when the tab was ALREADY on this project's
-        // home: the click landed on the requested row's own navigation control
-        // (hover-verified above), so an unchanged project URL means "already
-        // there", not a failed click.
-        const alreadyInProject = await cdp.evaluate(`/^https:\\/\\/chatgpt\\.com\\/g\\/g-p-/.test(location.href)`);
-        if (!alreadyInProject) {
+        // The href staying put is fine ONLY when the tab was already on THIS
+        // project's home. Requiring the requested project's name in the page title
+        // or heading (both carry it, measured live) prevents a stalled cross-
+        // project navigation from being accepted while still inside the OLD
+        // 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)};
+        if ((document.title || "").includes(name)) return true;
+        return [...document.querySelectorAll('h1,[role="heading"]')].some((h) => (h.innerText || "").includes(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.`);
         }
     }
@@ -1136,7 +1167,7 @@ export async function sendChatGptPrompt(options) {
     if (blocker) {
         throw new ChatGptBrowserBlockerError(blocker);
     }
-    assertChatGptReadyForPrompt(inferChatGptPageLoggedInLikely(status), status.hasComposer);
+    assertChatGptReadyForPrompt(inferChatGptPageLoggedInLikely(status), status.hasComposer, status.openDialogText);
     if (normalizedTargetUrl)
         assertChatGptTargetUrlMatches(status.url, normalizedTargetUrl);
     assertVisibleChatGptTab(status.visibilityState, status.url, normalizedTargetUrl);
@@ -1331,7 +1362,7 @@ export async function listChatGptModelOptions(input = {}) {
     const blocker = detectChatGptPageBlocker(status);
     if (blocker)
         throw new ChatGptBrowserBlockerError(blocker);
-    assertChatGptReadyForPrompt(inferChatGptPageLoggedInLikely(status), status.hasComposer);
+    assertChatGptReadyForPrompt(inferChatGptPageLoggedInLikely(status), status.hasComposer, status.openDialogText);
     assertVisibleChatGptTab(status.visibilityState, status.url, undefined);
     const cdp = await connectCdp(page.webSocketDebuggerUrl);
     try {
@@ -1594,7 +1625,7 @@ export function statusExpression() {
       hasComposer,
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || visibleButtonLabels.some((label) => generatingControlPattern.test(label)),
       modelHints: lines.filter((line) => /GPT|Pro|Thinking|ChatGPT|Extra High|Auto/i.test(line)).slice(0, 30),
-      openDialogText: (document.querySelector('[role="dialog"]')?.innerText || "").trim().slice(0, 200)
+      openDialogText: (([...document.querySelectorAll('[role="dialog"]')].find((d) => d.offsetWidth || d.offsetHeight || d.getClientRects().length)?.innerText) || "").trim().slice(0, 200)
     };
   })()`;
 }
@@ -1742,7 +1773,7 @@ function composerExpressionHelpers() {
     };
   `;
 }
-function answerExpression() {
+export function answerExpression() {
     const excludedTextSelector = JSON.stringify(CHATGPT_RUNTIME_BLOCKER_TEXT_EXCLUDED_ANCESTORS);
     const blockerScanExcludedSelector = JSON.stringify(CHATGPT_BLOCKER_SCAN_EXCLUDED_ANCESTORS);
     const streamingSelector = JSON.stringify(CHATGPT_STREAMING_SELECTOR);

package/dist/cli-pro.js

@@ -297,17 +297,37 @@ export async function runProCommand(rest, io, runCliFn) {
             if (printProBrowserHelpIfRequested(browserArgs, "pro browser models", io, { valueFlags: ["--port", "--timeout-ms", "--source-cli"] }))
                 return 0;
             assertOnlyOptions(browserArgs, "pro browser models", ["--port", "--timeout-ms", "--source-cli"]);
-            const listed = await listChatGptModelOptions({
-                port: readPortFlag(browserArgs, "--port"),
-                timeoutMs: readPositiveIntegerFlag(browserArgs, "--timeout-ms")
-            });
+            const modelsSourceCli = resolveOptionalFileFlag(io.cwd, browserArgs, "--source-cli");
+            // Parse flags OUTSIDE the browser-error adapter: a flag-validation
+            // error is a usage error, not a browser blocker.
+            const modelsPort = readPortFlag(browserArgs, "--port");
+            const modelsTimeoutMs = readPositiveIntegerFlag(browserArgs, "--timeout-ms");
+            // Port-awareness must reflect the RESOLVED port (PRODEX_CDP_PORT env
+            // included), not just the raw --port flag.
+            const modelsResolvedPort = resolveCdpPort(modelsPort);
+            let listed;
+            try {
+                listed = await listChatGptModelOptions({
+                    port: modelsPort,
+                    timeoutMs: modelsTimeoutMs
+                });
+            }
+            catch (error) {
+                // Keep the next step actionable for a custom port: the raw blocker
+                // suggests the default-port login command, which would not fix a
+                // 9444-style setup.
+                const blocker = sourceAwareBrowserBlocker(browserSendBlockerFromError(error), modelsSourceCli, {
+                    ...(modelsResolvedPort !== DEFAULT_CDP_PORT ? { port: modelsResolvedPort } : {})
+                });
+                throw new Error(blocker.next_step ? `${blocker.message} Next: ${blocker.next_step}` : errorMessage(error));
+            }
             io.stdout("Model menu options in the visible ChatGPT tab (read-only; nothing was selected):");
             for (const option of listed.options) {
                 const marker = option.checked ? "*" : " ";
                 const suffix = option.kind === "submenu" ? "  (has sub-variants; not selectable via --model yet)" : "";
                 io.stdout(`${marker} ${option.label}${suffix}`);
             }
-            io.stdout("Use radio entries with `pro browser ask --model/--effort`; Pro sub-modes via --pro-mode 기본|확장.");
+            io.stdout("Use radio entries with `pro browser ask --model/--effort` (e.g. --model Pro).");
             return 0;
         }
         throw unknownSubcommandError("pro browser", browserSubcommand, ["login", "ask", "smoke", "check", "models"]);
@@ -1197,47 +1217,62 @@ export async function printProductCheck(store, io, args, configCwd = io.cwd) {
     catch {
         // config unreadable: already reported by the config line above
     }
-    const browserStatus = await getChatGptBrowserStatus({
-        port: resolveCdpPort(readPortFlag(args, "--port")),
-        timeoutMs: readPositiveIntegerFlag(args, "--timeout-ms") ?? 1500
-    });
+    // Parse flags OUTSIDE the probe guard: an invalid --port / PRODEX_CDP_PORT /
+    // --timeout-ms is a usage or config error, not a browser-check failure.
+    const checkPort = resolveCdpPort(readPortFlag(args, "--port"));
+    const checkTimeoutMs = readPositiveIntegerFlag(args, "--timeout-ms") ?? 1500;
     const browserCommandOptions = {
         cwd: setupHintCwd,
-        port: readPortFlag(args, "--port") ?? undefined
+        port: checkPort !== DEFAULT_CDP_PORT ? checkPort : undefined
     };
-    let chatgptReady = false;
-    const visibilityBlocker = chatGptVisibilityBlocker(browserStatus.visibilityState, browserStatus.url);
-    if (!browserStatus.reachable) {
-        io.stdout(`chatgpt: ${browserStatus.blocker?.code ?? "unreachable"} - ${browserStatus.blocker?.message ?? "browser is not reachable"}`);
-        const nextStep = productCheckBrowserNextStep(browserStatus.blocker?.next_step, sourceCli, browserCommandOptions);
-        if (nextStep)
-            io.stdout(`next: ${nextStep}`);
+    let browserStatus;
+    try {
+        browserStatus = await getChatGptBrowserStatus({ port: checkPort, timeoutMs: checkTimeoutMs });
     }
-    else if (browserStatus.blocker) {
-        const visibilityText = browserStatus.blocker.code === "tab_not_visible" ? ` visibility=${browserStatus.visibilityState ?? "unknown"}` : "";
-        io.stdout(`chatgpt: blocked ${browserStatus.blocker.code}${visibilityText} - ${browserStatus.blocker.message}`);
-        const nextStep = productCheckBrowserNextStep(browserStatus.blocker.next_step, sourceCli, browserCommandOptions);
-        if (nextStep)
-            io.stdout(`next: ${nextStep}`);
+    catch (error) {
+        // A reachable-but-broken page (e.g. a failing in-page evaluate) must show
+        // as a check failure like doctor does, not crash the whole check with an
+        // internal error - and the rest of the check (latest_pro) still runs.
+        io.stdout(`chatgpt: check failed - ${errorMessage(error)}`);
+        const failedNext = productCheckBrowserNextStep("Reload the ChatGPT tab in the dedicated browser (or rerun `prodex pro browser login`), then retry.", sourceCli, browserCommandOptions);
+        if (failedNext)
+            io.stdout(`next: ${failedNext}`);
     }
-    else if (visibilityBlocker) {
-        io.stdout(`chatgpt: blocked ${visibilityBlocker.code} visibility=${browserStatus.visibilityState ?? "unknown"} - ${visibilityBlocker.message}`);
-        const nextStep = productCheckBrowserNextStep(visibilityBlocker.next_step, sourceCli, browserCommandOptions);
-        if (nextStep)
+    let chatgptReady = false;
+    if (browserStatus) {
+        const visibilityBlocker = chatGptVisibilityBlocker(browserStatus.visibilityState, browserStatus.url);
+        if (!browserStatus.reachable) {
+            io.stdout(`chatgpt: ${browserStatus.blocker?.code ?? "unreachable"} - ${browserStatus.blocker?.message ?? "browser is not reachable"}`);
+            const nextStep = productCheckBrowserNextStep(browserStatus.blocker?.next_step, sourceCli, browserCommandOptions);
+            if (nextStep)
+                io.stdout(`next: ${nextStep}`);
+        }
+        else if (browserStatus.blocker) {
+            const visibilityText = browserStatus.blocker.code === "tab_not_visible" ? ` visibility=${browserStatus.visibilityState ?? "unknown"}` : "";
+            io.stdout(`chatgpt: blocked ${browserStatus.blocker.code}${visibilityText} - ${browserStatus.blocker.message}`);
+            const nextStep = productCheckBrowserNextStep(browserStatus.blocker.next_step, sourceCli, browserCommandOptions);
+            if (nextStep)
+                io.stdout(`next: ${nextStep}`);
+        }
+        else if (visibilityBlocker) {
+            io.stdout(`chatgpt: blocked ${visibilityBlocker.code} visibility=${browserStatus.visibilityState ?? "unknown"} - ${visibilityBlocker.message}`);
+            const nextStep = productCheckBrowserNextStep(visibilityBlocker.next_step, sourceCli, browserCommandOptions);
+            if (nextStep)
+                io.stdout(`next: ${nextStep}`);
+        }
+        else if (browserStatus.loggedInLikely && browserStatus.hasComposer) {
+            io.stdout(`chatgpt: ok logged_in=true composer=true${browserStatus.url ? ` url=${browserStatus.url}` : ""}`);
+            chatgptReady = true;
+        }
+        else {
+            io.stdout(`chatgpt: blocked logged_in=${browserStatus.loggedInLikely} composer=${browserStatus.hasComposer}`);
+            const nextStep = productCheckBrowserNextStep(browserReadinessNextStep(browserStatus), sourceCli, browserCommandOptions);
             io.stdout(`next: ${nextStep}`);
+        }
+        const modelHints = formatBrowserModelHints(browserStatus.modelHints);
+        if (modelHints)
+            io.stdout(`model_hints: ${modelHints}`);
     }
-    else if (browserStatus.loggedInLikely && browserStatus.hasComposer) {
-        io.stdout(`chatgpt: ok logged_in=true composer=true${browserStatus.url ? ` url=${browserStatus.url}` : ""}`);
-        chatgptReady = true;
-    }
-    else {
-        io.stdout(`chatgpt: blocked logged_in=${browserStatus.loggedInLikely} composer=${browserStatus.hasComposer}`);
-        const nextStep = productCheckBrowserNextStep(browserReadinessNextStep(browserStatus), sourceCli, browserCommandOptions);
-        io.stdout(`next: ${nextStep}`);
-    }
-    const modelHints = formatBrowserModelHints(browserStatus.modelHints);
-    if (modelHints)
-        io.stdout(`model_hints: ${modelHints}`);
     if (bridgeReady) {
         try {
             const latest = await latestTrustedConsult(store, { readOnly: false });

package/dist/repo-write.js

@@ -77,6 +77,12 @@ export async function applyRepoWriteDryRun(root, store, input) {
     const current = await readWritableExistingFile(root, metadata.path);
     const currentPreimage = sha256(current.content);
     if (currentPreimage !== input.preimage_sha256) {
+        // A retry after a successful apply sees the file already holding the new
+        // content - name that instead of the generic conflict message so the
+        // caller can tell "already done" from "someone else changed the file".
+        if (currentPreimage === metadata.new_sha256) {
+            throw new Error(`Write for ${metadata.path} was already applied (the file already matches the reviewed content). Re-run repo_write_file_dry_run if you need a new change.`);
+        }
         throw new Error(`File preimage changed for ${metadata.path}`);
     }
     const newContent = await readDryRunReplacementContent(store, metadata);

package/package.json

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