@youdie006/prodex 0.35.0 → 0.36.0

package/dist/chatgpt-browser.js

@@ -596,8 +596,46 @@ export function modelSelectionWarning(requestedModel, modelSlug) {
         return undefined;
     return `model_mismatch: you asked for ${requestedModel}, but the answer came from "${modelSlug}". Check the model picker in the browser; the selection did not take.`;
 }
-export function chatGptBusyBlocker(generating) {
-    if (!generating)
+/**
+ * The panel ChatGPT raises to ask which of two answers you prefer.
+ *
+ * Recognized by its testids rather than its wording, so a UI in any language
+ * still matches. Read off the live page: the title is `paragen-feedback-title`
+ * and both choices are `paragen-prefer-response-button`.
+ */
+export const CHATGPT_RESPONSE_CHOICE_SELECTOR = '[data-testid="paragen-feedback-title"],[data-testid="paragen-prefer-response-button"]';
+/**
+ * A thread parked on that question, which no amount of waiting will clear.
+ *
+ * Measured live: both candidate answers had finished, the page had not changed
+ * in twenty seconds, and the composer's submit control was still
+ * `data-testid="stop-button"` - which prodex read as "generating". Every send
+ * afterwards waited out its whole budget and then advised waiting some more.
+ */
+export function chatGptResponseChoiceBlocker(awaitingResponseChoice) {
+    if (!awaitingResponseChoice)
+        return undefined;
+    return {
+        code: "response_choice_pending",
+        message: "ChatGPT is asking which of two answers you prefer, and this thread stays locked until one is picked.",
+        retryable: true,
+        next_step: "Pick one in the browser (the two \"I prefer this response\" buttons), " +
+            "or leave the thread alone and send into a new chat (`--new-chat`)."
+    };
+}
+/**
+ * Whether that question stands in the way of THIS send. A send that navigates
+ * away - a fresh chat, or a project home - never touches the parked thread.
+ */
+export function responseChoiceBlocksThisSend(input) {
+    if (!input.awaitingResponseChoice)
+        return false;
+    return !input.newChat && input.project === undefined && input.projectNew === undefined;
+}
+export function chatGptBusyBlocker(state) {
+    // Waiting for a choice is not generating. Conflating them turned a click
+    // away from ready into a full send budget spent on "still generating".
+    if (!state.generating || state.awaitingResponseChoice === true)
         return undefined;
     return {
         code: "response_in_progress",
@@ -608,6 +646,39 @@ export function chatGptBusyBlocker(generating) {
             "A new topic can go to a new chat instead."
     };
 }
+/**
+ * The busy verdict, re-decided against the transcript.
+ *
+ * Measured on the real page: an ordinary conversation whose answer was complete
+ * kept `data-testid="stop-button"` (aria-label "Stop answering") unchanged over
+ * thirty seconds, while the transcript for that same conversation reported
+ * finished_successfully with end_turn set. The page control is decoration once
+ * the turn is over; the transcript is the record. Only a transcript that can be
+ * read AND says the turn finished clears the blocker - an unreadable one is no
+ * evidence of anything, and typing into a live generation corrupts the thread.
+ */
+export function busyBlockerAfterTranscriptCheck(busyBlocker, transcript) {
+    if (!busyBlocker)
+        return undefined;
+    return transcript?.ok === true && transcript.isComplete === true ? undefined : busyBlocker;
+}
+/**
+ * Ask the transcript whether the conversation the tab is showing has finished.
+ * Undefined when there is nothing to ask about (a fresh chat or project home
+ * carries no conversation id) or the read fails.
+ */
+async function readTranscriptCompletion(page, url) {
+    const conversationId = conversationIdFromThreadUrl(url);
+    if (!conversationId)
+        return undefined;
+    try {
+        const state = await evaluateOnPage(page, transcriptAnswerExpression(conversationId));
+        return { ok: state.ok === true, ...(state.isComplete !== undefined ? { isComplete: state.isComplete } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
 export function isLikelyChatGptSubmitButton(label, dataTestId) {
     const normalized = label.trim().toLowerCase();
     return dataTestId === "send-button" || /\b(send|submit)\b|보내기|전송/.test(normalized);
@@ -878,8 +949,12 @@ function chatGptPageMissingBlocker() {
 // readiness assert - otherwise it is misreported as "missing a visible prompt
 // composer" (measured live: continue-by-default consults landing on a thread
 // still generating the previous prodex answer).
-export function assertChatGptIdleAndReadyForPrompt(status) {
-    const busyBlocker = chatGptBusyBlocker(status.generating);
+export function assertChatGptIdleAndReadyForPrompt(status, 
+// The caller may have already weighed the page against the transcript and
+// found the stop control stale. Re-deriving the verdict from the DOM here
+// threw away that answer and failed the send the queue had just cleared.
+decidedBusyBlocker, busyVerdictDecided = false) {
+    const busyBlocker = busyVerdictDecided ? decidedBusyBlocker : chatGptBusyBlocker(status);
     if (busyBlocker)
         throw new ChatGptBrowserBlockerError(busyBlocker);
     assertChatGptReadyForPrompt(inferChatGptPageLoggedInLikely(status), status.hasComposer, status.openDialogText);
@@ -1054,7 +1129,13 @@ export async function getChatGptBrowserStatus(options = {}) {
         ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {})
     });
     const loggedInLikely = inferChatGptPageLoggedInLikely(state);
-    const blocker = chatGptVisibilityBlocker(state.visibilityState, state.url) ?? detectChatGptPageBlocker(state) ?? chatGptBusyBlocker(state.generating);
+    // The busy verdict is checked against the transcript here too, so `check`
+    // does not report a finished conversation as one still being written.
+    const busyBlocker = chatGptBusyBlocker(state);
+    const blocker = chatGptVisibilityBlocker(state.visibilityState, state.url) ??
+        detectChatGptPageBlocker(state) ??
+        chatGptResponseChoiceBlocker(state.awaitingResponseChoice === true) ??
+        (busyBlocker ? busyBlockerAfterTranscriptCheck(busyBlocker, await readTranscriptCompletion(page.page, state.url)) : undefined);
     return {
         reachable: true,
         loggedInLikely,
@@ -2009,7 +2090,7 @@ export async function sendChatGptPrompt(options) {
     // timeout: consults continue threads by default, so landing on a thread
     // whose previous (often timed-out Pro) answer is still streaming is a when,
     // not an if - queueing behind it beats failing.
-    let busyBlocker = chatGptBusyBlocker(status.generating);
+    let busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
     const busyWaitBudgetMs = options.busyWaitMs ?? timeoutMs;
     if (busyBlocker && busyWaitBudgetMs > 0) {
         // Queue behind the in-flight response instead of failing: shared-tab
@@ -2023,17 +2104,32 @@ export async function sendChatGptPrompt(options) {
             const midBlocker = detectChatGptPageBlocker(status);
             if (midBlocker)
                 throw new ChatGptBrowserBlockerError(midBlocker);
-            busyBlocker = chatGptBusyBlocker(status.generating);
+            busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
             if (busyBlocker)
                 emitProgress("waiting", "tab busy with another response; waiting");
         }
         if (!busyBlocker) {
             // The composer takes a moment to unlock after generation ends; settle
-            // again so the readiness assert below sees the reopened composer.
+            // again so the readiness assert below sees the reopened composer, and
+            // weigh that fresh reading the same way - a generation that started in
+            // the meantime must still hold the send back.
             status = await readSettledChatGptPageStatus(page);
+            busyBlocker = busyBlockerAfterTranscriptCheck(chatGptBusyBlocker(status), await readTranscriptCompletion(page, status.url));
         }
     }
-    assertChatGptIdleAndReadyForPrompt(status);
+    // A thread ChatGPT has parked on "which response do you prefer?" will not
+    // unpark on its own. Sends that navigate away - a fresh chat, a project home
+    // - never touch it; a send that means to continue THAT thread has to say so
+    // now, rather than type into a composer that will not post.
+    if (responseChoiceBlocksThisSend({
+        awaitingResponseChoice: status.awaitingResponseChoice === true,
+        ...(options.newChat !== undefined ? { newChat: options.newChat } : {}),
+        ...(options.project !== undefined ? { project: options.project } : {}),
+        ...(options.projectNew !== undefined ? { projectNew: options.projectNew } : {})
+    })) {
+        throw new ChatGptBrowserBlockerError(chatGptResponseChoiceBlocker(true));
+    }
+    assertChatGptIdleAndReadyForPrompt(status, busyBlocker, true);
     if (normalizedTargetUrl)
         assertChatGptTargetUrlMatches(status.url, normalizedTargetUrl);
     assertVisibleChatGptTab(status.visibilityState, status.url, normalizedTargetUrl);
@@ -2580,7 +2676,15 @@ export function findLaunchedBrowserProcesses(psOutput, input) {
     // made a check against an unused port report a healthy Chrome as wedged.
     if (mains.length === 0)
         return [];
-    const helpers = input.profileDir.length > 0 ? lines.filter((line) => line.includes(input.profileDir) && !mains.includes(line)) : [];
+    // Which profile the helpers belong to is the browser's answer, not the
+    // caller's: `check` has only a port, and matching against the profile it
+    // assumed both missed this browser's renderers and collected a stranger's.
+    // Read it off the process that answered to the port; fall back to what the
+    // caller passed only when the command line does not say.
+    // Stop at the next flag, so a profile path containing spaces survives.
+    const profileOf = (line) => /--user-data-dir=(.*?)(?=\s+-{1,2}\w|\s*$)/.exec(line)?.[1];
+    const profileDir = profileOf(mains[0]) ?? input.profileDir;
+    const helpers = profileDir.length > 0 ? lines.filter((line) => profileOf(line) === profileDir && !mains.includes(line)) : [];
     return [...mains, ...helpers].map(pidOf).filter((pid) => pid !== undefined);
 }
 /**
@@ -3074,6 +3178,7 @@ export function statusExpression() {
     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);
+    const responseChoiceSelector = JSON.stringify(CHATGPT_RESPONSE_CHOICE_SELECTOR);
     const generatingControlPattern = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.source);
     const generatingControlFlags = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.flags);
     return `(() => {
@@ -3127,6 +3232,7 @@ export function statusExpression() {
       visibleButtonLabels,
       hasComposer,
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || visibleButtonLabels.some((label) => generatingControlPattern.test(label)),
+      awaitingResponseChoice: Boolean(document.querySelector(${responseChoiceSelector})),
       modelHints: lines.filter((line) => /GPT|Pro|Thinking|ChatGPT|Extra High|Auto/i.test(line)).slice(0, 30),
       openDialogText: (([...document.querySelectorAll('[role="dialog"]')].find((d) => d.offsetWidth || d.offsetHeight || d.getClientRects().length)?.innerText) || "").trim().slice(0, 200)
     };
@@ -3961,6 +4067,7 @@ 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);
+    const responseChoiceSelector = JSON.stringify(CHATGPT_RESPONSE_CHOICE_SELECTOR);
     const generatingControlPattern = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.source);
     const generatingControlFlags = JSON.stringify(CHATGPT_GENERATING_CONTROL_PATTERN.flags);
     return `(() => {
@@ -4025,6 +4132,7 @@ export function answerExpression() {
       blockerScanTextSample: visibleTextOutsideMessages(blockerScanExcludedSelector).slice(0, 12000),
       visibleButtonLabels: buttons,
       generating: placeholder || Boolean(document.querySelector(${streamingSelector})) || buttons.some((label) => generatingControlPattern.test(label)),
+      awaitingResponseChoice: Boolean(document.querySelector(${responseChoiceSelector})),
       assistantMessageCount: assistantMessages.length,
       userMessageCount: userMessages.length,
       // ChatGPT tags each assistant message with the model that produced it -

package/dist/cli-pro.js

@@ -1473,7 +1473,16 @@ export async function attemptBrowserAutoRecovery(stderr, options) {
     // a second Chrome on the same profile joins the wedged one rather than
     // replacing it, and the wedged one keeps burning CPU while nobody looks. This
     // runs unattended for agents, so it is the path that let four days pass.
-    const wedged = findWedgedBrowser({ ...(options.port !== undefined ? { port: options.port } : {}) });
+    // The same record the relaunch below reads, read once and used for both: the
+    // scan matches the main process by port but its helpers by profile, so
+    // scanning the DEFAULT profile for a custom-profile user put a second,
+    // healthy browser's renderers on the list this function kills.
+    const lastLogin = await readLastBrowserLoginLaunch().catch(() => undefined);
+    const scanFor = {
+        ...(options.port !== undefined ? { port: options.port } : {}),
+        ...(lastLogin?.profile_dir ? { profileDir: lastLogin.profile_dir } : {})
+    };
+    const wedged = findWedgedBrowser(scanFor);
     if (wedged.length > 0) {
         // Confirm the silence before ending anything: one missed poll is a busy
         // browser, several in a row is a dead one.
@@ -1496,7 +1505,7 @@ export async function attemptBrowserAutoRecovery(stderr, options) {
         // delay: the replacement launch fails outright if the old process still
         // holds it, which is how the first self-heal attempt ended.
         for (let attempt = 0; attempt < 10; attempt += 1) {
-            if (findWedgedBrowser({ ...(options.port !== undefined ? { port: options.port } : {}) }).length === 0)
+            if (findWedgedBrowser(scanFor).length === 0)
                 break;
             await sleep(1_000);
         }
@@ -1506,7 +1515,6 @@ export async function attemptBrowserAutoRecovery(stderr, options) {
         // Reuse the profile the user last logged in with; launching the default
         // profile for a custom-profile user would wait on the wrong (logged-out)
         // profile or, worse, silently send to a different account.
-        const lastLogin = await readLastBrowserLoginLaunch();
         // Relaunch in the SAME window mode the user chose: silently reopening a
         // visible window for someone running headless would be exactly the
         // surprise window they turned headless to avoid.
@@ -1556,15 +1564,23 @@ export async function waitForChatGptLoginReady(stderr, options, deps = {}) {
     const startedAt = now();
     stderr("login: waiting for a logged-in ChatGPT tab (finish login in the dedicated Chrome window; Ctrl+C stops waiting)...");
     let lastState = "";
-    let openedMissingTab = false;
+    let openMissingTabAttempts = 0;
     while (now() - startedAt < timeoutMs) {
         const status = await statusFn({ port: options.port, timeoutMs: 1_500 });
         // A running Chrome with no chatgpt.com tab leaves the user nothing to log
-        // into. Open the tab once rather than waiting for one to appear.
-        if (status.reachable && status.blocker?.code === "chatgpt_page_missing" && !openedMissingTab) {
-            openedMissingTab = true;
-            stderr("login: the running Chrome had no ChatGPT tab - opening a ChatGPT tab in it...");
-            await openTabFn(options.port);
+        // 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
+        // a real machine sat for a minute reporting the missing tab and ended
+        // not-ready with nothing to go on.
+        if (status.reachable && status.blocker?.code === "chatgpt_page_missing") {
+            const attempt = openMissingTabAttempts + 1;
+            openMissingTabAttempts = attempt;
+            stderr(attempt === 1
+                ? "login: the running Chrome had no ChatGPT tab - opening a ChatGPT tab in it..."
+                : `login: still no ChatGPT tab - opening one again (attempt ${attempt})...`);
+            const opened = await openTabFn(options.port);
+            if (opened === false)
+                stderr("login: could not open a ChatGPT tab through the debug port; open https://chatgpt.com/ in that window.");
             await sleepFn(pollMs);
             continue;
         }

package/dist/cli.js

@@ -116,7 +116,10 @@ export async function runCli(args, io = defaultIo()) {
     // A person typing `prodex` used to get the agent-facing command wall and no
     // way in. On a terminal, walk them through a consult instead; piped or
     // scripted callers still get the banner and the command list they parse.
-    if (!command && io.isInteractive === true)
+    // A keyboard as well as a screen: with stdin redirected there is nothing to
+    // answer the picker's questions with, and `prodex` alone should still print
+    // the command list rather than refuse.
+    if (!command && io.isInteractive === true && process.stdin.isTTY === true)
         return runInteractiveUi(io);
     if (!command || command === "help" || command === "--help" || command === "-h") {
         if (shouldColorize())

package/dist/tui-run.js

@@ -136,6 +136,17 @@ async function askLine(io, question) {
  * Returns the process exit code.
  */
 export async function runInteractiveConsult(io, deps) {
+    // Every question here is answered with a keystroke, so a stdin that cannot
+    // deliver one has to be turned away at the door. Measured with stdin
+    // redirected: the picker painted the alternate screen, hid the cursor, and
+    // waited forever for a key that could not arrive - and never returning meant
+    // the screen was never restored either, leaving a terminal that needed
+    // `reset`.
+    if (io.input.isTTY !== true) {
+        io.write("The picker reads single keystrokes, so it needs a terminal on stdin.\n");
+        io.write('Send without one: prodex pro browser ask "your prompt"\n');
+        return 1;
+    }
     const now = deps.now ?? Date.now;
     readline.emitKeypressEvents(io.input);
     io.input.setRawMode?.(true);
@@ -278,6 +289,12 @@ export async function runInteractiveConsult(io, deps) {
         // Leave the alternate screen before the send: the answer, the receipt id
         // and any blocker belong in the scrollback the user keeps.
         io.write(ALT_SCREEN_OFF + SHOW_CURSOR);
+        // Hand the terminal back too. Raw mode is what let the pickers read single
+        // keys, and it also turns off the terminal's own ctrl-c: the key arrives as
+        // a keypress nothing is waiting for. The progress bar promises "ctrl-c to
+        // stop", and under raw mode that promise was false for the whole ten
+        // minutes a deep research send runs. No key is read from here on.
+        io.input.setRawMode?.(false);
         // --target-url confirms which conversation a send means; it deliberately
         // does not navigate. Picking one from a list IS a request to go there, so
         // move the tab first and let the flag confirm it landed.

package/package.json

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