@youdie006/prodex 0.40.13 → 0.40.14

package/README.md

@@ -73,10 +73,16 @@ For a one-time visible login followed by a verified headless handoff, use `prode
 
 Finish any native browser or OS confirmation before requesting the handoff: Chrome does not expose every native dialog through its page-control interface. The guard detects page targets and rendered dialogs, not every OS prompt. Incognito, guest, and explicitly selected Chrome sub-profiles are refused.
 
+A Chrome account-connection chooser is separate from ChatGPT sign-in. If prodex confirms that chooser is displayed, choose for yourself whether to connect Chrome to the account; "Use Chrome without an account" declines that separate connection. A hidden or unreadable internal target still blocks the handoff but is not proof that a prompt is visible or that ChatGPT is logged out.
+
+"Login readiness is not yet confirmed" does not mean the saved login was lost. Inspect the dedicated browser before signing in again. An explicit `login_required`, `cloudflare_check`, `captcha_required`, or `permission_required` during a headless/virtual-display wait stops promptly: use `prodex pro browser login --headed` to handle the reported step visibly. A usage limit or missing composer has its own next step instead of a blanket login instruction.
+
 While Pro thinks, progress goes to stderr: connecting, prompt sent, elapsed time while generating. A Pro selection raises the send budget to twenty minutes on its own; `--timeout-ms` overrides it. Answers are read from the rendered page, so formatting can differ from the original message. If the dedicated browser is not running, an interactive `ask` starts it, waits for your saved session, and retries once (`--no-auto-login` turns that off; scripts opt in with `--auto-login`).
 
 If the browser stops responding after your question was sent, prodex stops without sending it again. Use the `thread` and `request_id` from the error with `prodex pro browser recover --target-url <thread-url> --request-id <32hex>` (MCP: `pro_recover`). The request ID verifies that the recovered assistant answer follows that exact marked user turn. Legacy recovery without it remains available but returns `request_verified: false` and a warning.
 
+If submission itself is unconfirmed, do not resend or simply increase the timeout: first inspect the original conversation for the `[prodex-request:...]` marker in the error. Missing login signals or text still in the composer do not prove that the question was never submitted.
+
 Useful flags on every send:
 
 | Flag | What it does |

package/dist/browser-handoff.js

@@ -6,7 +6,7 @@ import { ChatGptBrowserBlockerError, attachmentPresenceExpression, composerTextS
 function blocked(message) {
     throw new ChatGptBrowserBlockerError({
         code: "browser_handoff_blocked", message, retryable: false,
-        next_step: "Keep only the intended idle ChatGPT tab open, finish any Chrome account or permission confirmation yourself, and retry `prodex pro browser login --background`. Do not close active work or log in again solely because the handoff stopped."
+        next_step: "Inspect the dedicated browser and keep only the intended idle ChatGPT tab open, then retry `prodex pro browser login --background`. Complete a login or permission step only if it is actually shown. Do not close active work or log in again solely because the handoff stopped."
     });
 }
 function browserIdentity(port, profileDir) {
@@ -62,8 +62,32 @@ async function singlePage(port) {
     if (!Array.isArray(response))
         blocked("The browser page list is invalid.");
     const pages = response.filter((page) => page?.type === "page");
-    if (pages.length !== 1)
-        blocked("The dedicated browser has other tabs or a Chrome confirmation surface; nothing was closed.");
+    if (pages.length !== 1) {
+        const chooser = pages.find((page) => page.url === "chrome://signin-dice-web-intercept.top-chrome/chrome-signin");
+        if (chooser) {
+            let state;
+            try {
+                const socket = localSocket(chooser.webSocketDebuggerUrl, port, "page");
+                const reply = await request(socket, "Runtime.evaluate", {
+                    expression: `(() => { const r = document.body?.getBoundingClientRect(); return { visibilityState: document.visibilityState, width: r?.width, height: r?.height, isChooser: !!document.querySelector('chrome-signin-app') }; })()`,
+                    returnByValue: true
+                });
+                if (!reply.exceptionDetails)
+                    state = reply.result?.value;
+            }
+            catch { /* An unreadable internal target is not proof of a visible prompt. */ }
+            if (state?.visibilityState === "visible" && state.isChooser === true &&
+                typeof state.width === "number" && state.width > 0 && typeof state.height === "number" && state.height > 0) {
+                throw new ChatGptBrowserBlockerError({
+                    code: "browser_account_confirmation", retryable: false,
+                    message: "Chrome is showing its browser-account connection chooser. This is separate from ChatGPT login; no browser was closed.",
+                    next_step: "Choose in the dedicated Chrome window yourself. 'Use Chrome without an account' declines Chrome account connection if you do not want it. Keep the ChatGPT tab open, then retry `prodex pro browser login --background`."
+                });
+            }
+            blocked("Chrome has an internal account target, but its chooser visibility was not confirmed. This does not establish a ChatGPT login problem; nothing was closed.");
+        }
+        blocked("The dedicated browser has additional page targets; nothing was closed.");
+    }
     const page = pages[0];
     const url = new URL(page.url);
     if (url.protocol !== "https:" || url.hostname !== "chatgpt.com" || url.username || url.password || url.port ||

package/dist/chatgpt-browser.js

@@ -702,6 +702,7 @@ export function formatDurationMs(ms) {
 export function acceptanceTimeoutError(ctx) {
     const uiLikelyChanged = ctx.composerStillHasText || !ctx.submitButtonFound;
     const took = `${formatDurationMs(ctx.timeoutMs)} (${ctx.timeoutMs}ms)`;
+    const inspect = `Do not resend automatically: submission was attempted but acceptance is unconfirmed. Inspect the original conversation${ctx.requestId ? ` for [prodex-request:${ctx.requestId}]` : ""} before another request.`;
     if (uiLikelyChanged) {
         const detail = [
             ctx.composerStillHasText ? "the composer still holds the prompt" : undefined,
@@ -709,13 +710,16 @@ export function acceptanceTimeoutError(ctx) {
         ]
             .filter(Boolean)
             .join(" and ");
-        return new Error(`Timed out after ${took} and ChatGPT never registered the prompt (${detail}). ` +
-            "The ChatGPT web UI may have changed, so prodex could not submit. Update prodex " +
-            "(npm i -g @youdie006/prodex@latest); if it persists, report it at " +
-            "https://github.com/youdie006/prodex/issues. You can also paste the prompt manually in the visible browser.");
+        return new ChatGptBrowserBlockerError({
+            code: "send_ui_changed", retryable: false,
+            message: `Timed out after ${took} without confirming prompt acceptance (${detail}). The ChatGPT web UI may have changed.`,
+            next_step: `${inspect} Update prodex (npm i -g @youdie006/prodex@latest); if it persists, report it at https://github.com/youdie006/prodex/issues.`
+        });
     }
-    return new Error(`Timed out after ${took} waiting for ChatGPT to accept the prompt. ` +
-        "Pro reasoning can run many minutes. Raise --timeout-ms and retry.");
+    return new ChatGptBrowserBlockerError({
+        code: "prompt_acceptance_unconfirmed", retryable: false,
+        message: `Timed out after ${took} waiting for ChatGPT to accept the prompt.`, next_step: inspect
+    });
 }
 export function hasPartialChatGptAnswer(previousAssistantMessageCount, state) {
     return state.assistantMessageCount > previousAssistantMessageCount && isUsableChatGptAnswer(state.answer);
@@ -948,7 +952,7 @@ export function detectChatGptBlocker(text, visibleButtonLabels = []) {
             code: "cloudflare_check",
             message: "ChatGPT is showing a Cloudflare or human-verification interstitial.",
             retryable: true,
-            next_step: "Complete the visible browser check manually, then retry."
+            next_step: "Complete the visible browser check manually."
         };
     }
     if (hasLikelyChatGptLoginPrompt(haystack)) {
@@ -956,7 +960,7 @@ export function detectChatGptBlocker(text, visibleButtonLabels = []) {
             code: "login_required",
             message: "ChatGPT is asking you to log in.",
             retryable: true,
-            next_step: "Log in manually in the visible browser, then retry."
+            next_step: "Log in manually in the visible browser."
         };
     }
     // Match real captcha / human-verification phrasing only. Bare words like "robot"/"로봇"/"자동화"
@@ -967,7 +971,7 @@ export function detectChatGptBlocker(text, visibleButtonLabels = []) {
             code: "captcha_required",
             message: "ChatGPT is asking for captcha or human verification.",
             retryable: true,
-            next_step: "Solve it manually in the visible browser, then retry."
+            next_step: "Solve it manually in the visible browser."
         };
     }
     if (/message limit|usage limit|model limit|rate limit|you.?ve reached|try again later|limit resets|사용 한도|메시지 한도|모델 한도|요금 제한|나중에 다시/i.test(haystack)) {
@@ -983,7 +987,7 @@ export function detectChatGptBlocker(text, visibleButtonLabels = []) {
             code: "permission_required",
             message: "ChatGPT requires account verification or permission handling.",
             retryable: true,
-            next_step: "Complete the visible account or permission prompt manually, then retry."
+            next_step: "Complete the visible account or permission prompt manually."
         };
     }
     return undefined;
@@ -992,7 +996,15 @@ export function detectChatGptPageBlocker(state) {
     // Blocker scan uses the nav-excluded sample so a sidebar chat title cannot
     // fake a blocker; fall back to the nav-included sample / full text when the
     // scan sample is absent (older callers).
-    return detectChatGptBlocker(state.blockerScanTextSample ?? state.blockerTextSample ?? state.textSample, state.visibleButtonLabels);
+    const rendered = detectChatGptBlocker(state.blockerScanTextSample ?? state.blockerTextSample ?? state.textSample, state.visibleButtonLabels);
+    if (rendered)
+        return rendered;
+    // The interstitial can have an empty body. Never use a conversation title
+    // alone when the composer exists or its state was not actually checked.
+    if (state.hasComposer === false && /^just a moment\.{0,3}$/i.test(state.title?.trim() ?? "")) {
+        return detectChatGptBlocker("Just a moment", []);
+    }
+    return undefined;
 }
 export function inferChatGptPageLoggedInLikely(state) {
     // The logged-in signals live in the sidebar - "New chat", "Projects", the
@@ -1026,6 +1038,17 @@ export function chatGptBlockerErrorFromAnswerState(state) {
 export function chatGptBlockerFromAnswerState(state) {
     return detectChatGptPageBlocker(state);
 }
+function submittedRequestBlocker(blocker, requestId, thread) {
+    return {
+        ...blocker,
+        retryable: false,
+        ...(thread ? { thread } : {}),
+        next_step: `${blocker.next_step ?? "Inspect the visible browser."} Do not automatically resend. ` +
+            (thread
+                ? `Collect the original answer with \`prodex pro browser recover --target-url ${thread} --request-id ${requestId}\` after resolving the blocker.`
+                : `Submission is unconfirmed; inspect the original conversation for [prodex-request:${requestId}] before another request.`)
+    };
+}
 export function computePromptAcceptanceDeadline(timeoutMs, startedAt) {
     return startedAt + Math.max(1, timeoutMs);
 }
@@ -3508,6 +3531,7 @@ export async function sendChatGptPrompt(options) {
     let beforeSubmit;
     let boundProjectId;
     let submitButtonFound = false;
+    let submissionAttempted = false;
     const sendWarnings = [...preflightWarnings];
     // Anything the page put in front of prodex was answered on the caller's
     // behalf. The note is read at return time - there are several return paths -
@@ -3654,6 +3678,8 @@ export async function sendChatGptPrompt(options) {
       const last = [...document.querySelectorAll('[data-message-author-role="user"]')].at(-1);
       return Boolean(last && (last.innerText || "").includes(${JSON.stringify(`[prodex-request:${requestId}]`)}));
     })()`;
+        // A dispatch can reach Chrome even if its acknowledgement is lost.
+        submissionAttempted = true;
         await cdp.send("Input.dispatchKeyEvent", enterKeyEvent("keyDown"));
         await cdp.send("Input.dispatchKeyEvent", enterKeyEvent("keyUp"));
         let promptPosted = await waitForExpressionTrue(cdp, promptPostedExpression, 1_500);
@@ -3677,6 +3703,13 @@ export async function sendChatGptPrompt(options) {
         await captureOnFailure(`send-${new Date().toISOString().replace(/[:.]/g, "-")}`);
         if (isCrashedTabError(error))
             throw attachSendWarnings(new ChatGptBrowserBlockerError(crashedTabBlocker(undefined, requestId)), sendWarnings);
+        if (submissionAttempted) {
+            const blocker = error instanceof ChatGptBrowserBlockerError ? error.blocker : {
+                code: "prompt_acceptance_unconfirmed", retryable: false,
+                message: `Browser control failed after submission was attempted: ${error instanceof Error ? error.message : String(error)}`
+            };
+            throw attachSendWarnings(new ChatGptBrowserBlockerError(submittedRequestBlocker(blocker, requestId)), sendWarnings);
+        }
         throw attachSendWarnings(error, sendWarnings);
     }
     finally {
@@ -3701,7 +3734,7 @@ export async function sendChatGptPrompt(options) {
         }
         const runtimeBlocker = chatGptBlockerFromAnswerState(finalState);
         if (runtimeBlocker)
-            throw new ChatGptBrowserBlockerError(runtimeBlocker);
+            throw new ChatGptBrowserBlockerError(submittedRequestBlocker(runtimeBlocker, requestId));
         dbgSend(`accept-poll url=${finalState.url} user=${finalState.userMessageCount} assistant=${finalState.assistantMessageCount} generating=${finalState.generating}`);
         if (requestMatches(finalState)) {
             if (normalizedTargetUrl)
@@ -3714,19 +3747,13 @@ export async function sendChatGptPrompt(options) {
         emitProgress("waiting", "prompt posting");
     }
     if (!accepted) {
-        // The session can expire mid-send (logged out during a long Pro wait), which
-        // otherwise surfaces as a cryptic "raise --timeout-ms" failure. Re-check the
-        // login state first and, if the session is gone, say so clearly so the user
-        // re-logs in instead of chasing a timeout.
+        // Missing logged-in signals do not prove session expiry. Only rendered
+        // blockers justify an authentication diagnosis after uncertain submission.
         try {
             const status = await evaluateOnPage(page, statusExpression());
-            if (!inferChatGptPageLoggedInLikely(status)) {
-                throw new ChatGptBrowserBlockerError({
-                    code: "session_expired",
-                    message: "The ChatGPT session is no longer logged in - it likely expired during the send.",
-                    retryable: true,
-                    next_step: "Run `prodex pro browser login`, log in, then retry."
-                });
+            const blocker = detectChatGptPageBlocker(status);
+            if (blocker) {
+                throw new ChatGptBrowserBlockerError(submittedRequestBlocker(blocker, requestId));
             }
         }
         catch (error) {
@@ -3734,8 +3761,7 @@ export async function sendChatGptPrompt(options) {
                 throw error;
             // best effort: a CDP eval failure here falls through to the generic timeout
         }
-        // A successful submit clears the composer, so text still sitting there means
-        // the send control did not register the prompt — the UI-changed signature.
+        // Composer text is only a UI hint, not proof that submission failed.
         let composerStillHasText = false;
         try {
             const composerState = await evaluateOnPage(page, composerTextStateExpression());
@@ -3744,7 +3770,7 @@ export async function sendChatGptPrompt(options) {
         catch {
             // best effort: fall back to submit-button signal only
         }
-        throw acceptanceTimeoutError({ timeoutMs, composerStillHasText, submitButtonFound });
+        throw acceptanceTimeoutError({ timeoutMs, composerStillHasText, submitButtonFound, requestId });
     }
     // Pin the conversation the prompt actually landed in. The browser is shared
     // (other agents, the user, tooling), and a tab that moves mid-wait made
@@ -3807,7 +3833,7 @@ export async function sendChatGptPrompt(options) {
         }
         const runtimeBlocker = chatGptBlockerFromAnswerState(finalState);
         if (runtimeBlocker)
-            throw new ChatGptBrowserBlockerError(runtimeBlocker);
+            throw new ChatGptBrowserBlockerError(submittedRequestBlocker(runtimeBlocker, requestId, pinnedThreadUrl));
         emitProgress("waiting", finalState.generating ? "generating" : "stabilizing");
         if (!hasFreshChatGptAnswer(beforeSubmit.assistantMessageCount, finalState))
             continue;

package/dist/cli-pro.js

@@ -2234,15 +2234,16 @@ export async function waitForChatGptLoginReady(stderr, options, deps = {}) {
     const pollMs = options.pollMs ?? 2_000;
     const hasInteractiveWindow = options.windowMode?.headless !== true && options.windowMode?.virtualDisplay !== true;
     const headedLoginCommand = options.headedLoginCommand ?? "prodex pro browser login --headed";
-    const headedLoginHint = ` No interactive window is available; run \`${headedLoginCommand}\` to complete login, captcha, or human verification visibly.`;
     const startedAt = now();
     stderr(hasInteractiveWindow
-        ? "login: waiting for a logged-in ChatGPT tab (finish login in the dedicated Chrome browser; Ctrl+C stops waiting)..."
-        : `login: waiting for a logged-in ChatGPT tab (no interactive window; use \`${headedLoginCommand}\` if login or verification is required; Ctrl+C stops waiting)...`);
+        ? "login: waiting for ChatGPT readiness in the dedicated Chrome browser (complete any visible step it requests; Ctrl+C stops waiting)..."
+        : `login: waiting for ChatGPT readiness (no interactive window; use \`${headedLoginCommand}\` to inspect any requested browser step visibly; Ctrl+C stops waiting)...`);
     let lastState = "";
+    let lastStatus;
     let openMissingTabAttempts = 0;
     while (now() - startedAt < timeoutMs) {
         const status = await statusFn({ port: options.port, timeoutMs: 1_500 });
+        lastStatus = status;
         // A running Chrome with no chatgpt.com tab leaves the user nothing to log
         // into, so prodex opens one. Keep trying while the tab is still missing:
         // one silent attempt that fails looks exactly like no attempt, which is how
@@ -2263,18 +2264,27 @@ export async function waitForChatGptLoginReady(stderr, options, deps = {}) {
             await sleepFn(pollMs);
             continue;
         }
+        const blocker = status.blocker;
+        const blockerNextStep = blocker?.next_step ? ` Next: ${blocker.next_step}` : "";
+        const needsVisibleAuth = blocker !== undefined &&
+            ["login_required", "cloudflare_check", "captcha_required", "permission_required"].includes(blocker.code);
+        if (!hasInteractiveWindow && needsVisibleAuth) {
+            stderr(`login: blocked - ${blocker.message}${blockerNextStep}`);
+            stderr(`login: NOT READY - ${blocker.code} requires visible manual handling. No interactive window is available; run \`${headedLoginCommand}\` to handle it visibly.`);
+            return false;
+        }
         const state = !status.reachable
             ? "login: browser starting..."
             : status.blocker
-                ? `login: blocked - ${status.blocker.message}${hasInteractiveWindow ? "" : headedLoginHint}`
+                ? `login: blocked - ${status.blocker.message}${blockerNextStep}`
                 : !status.loggedInLikely
                     ? hasInteractiveWindow
-                        ? "login: waiting for ChatGPT login in the dedicated Chrome browser..."
-                        : `login: waiting for a saved ChatGPT login.${headedLoginHint}`
+                        ? "login: ChatGPT is reachable, but login readiness is not yet confirmed; review any visible browser prompt..."
+                        : `login: ChatGPT is reachable, but login readiness is not yet confirmed; inspect it visibly with \`${headedLoginCommand}\` if needed.`
                     : !status.hasComposer
                         ? hasInteractiveWindow
-                            ? "login: logged in; open a chat so the prompt composer is visible..."
-                            : `login: logged in, but no prompt composer is ready.${headedLoginHint}`
+                            ? "login: login looks active; open a chat so the prompt composer is visible..."
+                            : `login: login looks active, but no prompt composer is ready; inspect it visibly with \`${headedLoginCommand}\`.`
                         : "";
         if (state === "") {
             stderr(`login: READY - logged-in ChatGPT tab with composer detected (${Math.round((now() - startedAt) / 1000)}s).`);
@@ -2289,9 +2299,26 @@ export async function waitForChatGptLoginReady(stderr, options, deps = {}) {
             break;
         await sleepFn(Math.min(pollMs, Math.max(1, remainingMs)));
     }
-    stderr(hasInteractiveWindow
-        ? `login: not ready after ${Math.round(timeoutMs / 1000)}s. Finish login in the browser, then verify with \`prodex pro browser check\`.`
-        : `login: not ready after ${Math.round(timeoutMs / 1000)}s. Run \`${headedLoginCommand}\` to complete login, captcha, or human verification visibly, then retry.`);
+    const timeoutPrefix = `login: not ready after ${Math.round(timeoutMs / 1000)}s`;
+    if (lastStatus?.blocker) {
+        const nextStep = lastStatus.blocker.next_step ? ` Next: ${lastStatus.blocker.next_step}` : "";
+        stderr(`${timeoutPrefix}; last blocker ${lastStatus.blocker.code}: ${lastStatus.blocker.message}${nextStep}`);
+    }
+    else if (!lastStatus?.reachable) {
+        stderr(hasInteractiveWindow
+            ? `${timeoutPrefix}; browser startup was not confirmed. Check the dedicated Chrome browser, then verify with \`prodex pro browser check\`.`
+            : `${timeoutPrefix}; browser startup was not confirmed. Inspect it visibly with \`${headedLoginCommand}\`, then retry.`);
+    }
+    else if (lastStatus.loggedInLikely && !lastStatus.hasComposer) {
+        stderr(hasInteractiveWindow
+            ? `${timeoutPrefix}; login looked active, but the prompt composer was not detected. Open a normal ChatGPT chat or Project thread, then verify with \`prodex pro browser check\`.`
+            : `${timeoutPrefix}; login looked active, but the prompt composer was not detected. Inspect it visibly with \`${headedLoginCommand}\`, then retry.`);
+    }
+    else {
+        stderr(hasInteractiveWindow
+            ? `${timeoutPrefix}; ChatGPT was reachable, but login readiness was not yet confirmed. Review the dedicated Chrome browser, then verify with \`prodex pro browser check\`.`
+            : `${timeoutPrefix}; ChatGPT was reachable, but login readiness was not yet confirmed. Inspect it visibly with \`${headedLoginCommand}\`; complete a manual step only if requested.`);
+    }
     return false;
 }
 export async function assertBrowserLaunchStayedAlive(opened, timeoutMs) {
@@ -3150,7 +3177,7 @@ export function assertNoOrphanConsultResults(tasksById, results) {
 }
 export function browserReadinessNextStep(input) {
     if (!input.loggedInLikely) {
-        return "Log in manually in the visible ChatGPT browser, then retry.";
+        return "ChatGPT login readiness is not yet confirmed. Review the visible ChatGPT browser state, then retry.";
     }
     if (!input.hasComposer) {
         return "Open a normal ChatGPT chat or Project thread, select the Pro/Thinking model, and retry.";

package/package.json

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