@youdie006/prodex 0.40.18 → 0.40.19

package/README.md

@@ -77,7 +77,9 @@ Finish any native browser or OS confirmation before requesting the handoff: Chro
 
 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. For a running headless browser, use `prodex pro browser login --headed --recover-visible` to open that same profile and page visibly. This explicit recovery refuses other tabs, active work, filled inputs, and uncertain browser identity; it never clicks a security check or sends a prompt. A usage limit or missing composer has its own next step instead of a blanket login instruction.
+The login guide explains this separate Chrome choice before the authentication steps. Keep the ChatGPT tab open after making it. If a verified signed-in headed session reaches another authentication or protection blocker immediately after the headless handoff, prodex stops without prescribing another login cycle. Repeating login is not a demonstrated fix for that headless failure; `login: READY` before the handoff is not `background: READY` after it.
+
+"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. Outside the just-verified handoff case above, `prodex pro browser login --headed --recover-visible` is available for explicit visible inspection of a running headless browser's same profile and page. This recovery refuses other tabs, active work, filled inputs, and uncertain browser identity; it never clicks a security check or sends a prompt. 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`).
 

package/dist/cli-pro.js

@@ -392,9 +392,10 @@ export async function runProCommand(rest, io, runCliFn) {
                     port: opened.port,
                     headless,
                     minimized,
+                    // A blocked background handoff must not make a temporary auth window permanent.
                     ...(alreadyRunning && savedLaunchForPort?.resume_headless === true &&
-                        !Object.values(windowModeOptions.flags).some((value) => typeof value === "boolean") &&
-                        !["PRODEX_HEADLESS", "PRODEX_VIRTUAL_DISPLAY", "PRODEX_MINIMIZE_WINDOW"].some((key) => (process.env[key] ?? "").trim() !== "")
+                        (background || (!Object.values(windowModeOptions.flags).some((value) => typeof value === "boolean") &&
+                            !["PRODEX_HEADLESS", "PRODEX_VIRTUAL_DISPLAY", "PRODEX_MINIMIZE_WINDOW"].some((key) => (process.env[key] ?? "").trim() !== "")))
                         ? { resume_headless: true } : {}),
                     ...(virtualDisplay
                         ? { virtual_display: virtualDisplay.displayNumber }
@@ -1544,7 +1545,7 @@ export async function runAskProCommand(rest, io, beforeSend) {
             }
         }
         catch (error) {
-            const blocker = sourceAwareBrowserBlocker(browserSendBlockerFromError(error), sourceCli, browserCommandOptions);
+            const blocker = await withManualStepForWindowMode(sourceAwareBrowserBlocker(browserSendBlockerFromError(error), sourceCli, browserCommandOptions), resolveCdpPort(browserPort), sourceCli, browserCommandOptions);
             const message = blocker.next_step ? `${blocker.message} Next: ${blocker.next_step}` : errorMessage(error);
             // The blocker text can quote the requested/default project name (e.g. a
             // "project not found" error). Local stdout/stderr keep it (useful to the
@@ -2319,6 +2320,7 @@ async function completeBackgroundBrowserLogin(io, options) {
             port: opened.port,
             timeoutMs: options.timeoutMs,
             windowMode: { headless: true, virtualDisplay: false, minimized: false },
+            verifiedHeadedHandoff: true,
             headedLoginCommand: options.headedLoginCommand,
             headlessRecoveryCommand: options.headlessRecoveryCommand
         });
@@ -2387,6 +2389,12 @@ export async function waitForChatGptLoginReady(stderr, options, deps = {}) {
         const blocker = status.blocker;
         const blockerNextStep = blocker?.next_step ? ` Next: ${blocker.next_step}` : "";
         if (!hasInteractiveWindow && blocker && needsVisibleAuthRecovery(blocker.code)) {
+            if (options.verifiedHeadedHandoff) {
+                stderr(`login: blocked - ${blocker.message}`);
+                stderr(`login: NOT READY - ${blocker.code}. Sign-in was verified before the headless handoff, but the same profile is not ready headlessly.`);
+                stderr("login: Another login is not a demonstrated fix. Stop automatic recovery and inspect this headless failure before another login or mode change. No further window will be opened automatically.");
+                return false;
+            }
             const visibleStep = options.windowMode?.headless === true && options.headlessRecoveryCommand
                 ? `run \`${options.headlessRecoveryCommand}\` to handle it visibly.`
                 : `${manualInspection} Handle the reported step visibly.`;
@@ -3040,6 +3048,60 @@ export async function listConsultListEntries(store, options = { readOnly: true }
     }
     return entries;
 }
+/** Blockers whose only remedy is a person acting inside the browser window. */
+const MANUAL_BROWSER_STEP_CODES = new Set(["login_required", "captcha_required", "cloudflare_check"]);
+/**
+ * Rewrite a "do it in the visible browser" next step for a browser that has no
+ * window to do it in.
+ *
+ * Measured with a signed-out profile on a virtual display: `pro browser check`
+ * and every send reported `login_required` with "Log in manually in the
+ * visible browser." - on a browser prodex had itself started with no visible
+ * window. The login command already knew the way out (close that browser, log
+ * in through a headed one), but the blocker a send or a check prints did not.
+ * A session that expires under a no-window setup is exactly this case, and the
+ * advice it got could not be followed.
+ *
+ * Only the manual-step codes are rewritten, and only when the saved launch
+ * belongs to the port in use, so a stale record for another browser cannot
+ * change the advice for this one.
+ */
+export function manualBrowserStepForWindowMode(blocker, launch, port, commands) {
+    if (!MANUAL_BROWSER_STEP_CODES.has(blocker.code))
+        return blocker;
+    if (!launch || launch.port !== port)
+        return blocker;
+    if (launch.headless === true) {
+        return {
+            ...blocker,
+            next_step: `The dedicated browser runs headless, with no window to do this in. Run \`${commands.visibleRecovery}\` ` +
+                "to switch it to a visible window through the guarded path, complete the step there, then retry."
+        };
+    }
+    if (launch.virtual_display !== undefined) {
+        return {
+            ...blocker,
+            next_step: "The dedicated browser runs on a virtual display, with no window to do this in. Close it yourself when no " +
+                `consult is running, then run \`${commands.headedLogin}\` to complete the step in a visible window, and retry.`
+        };
+    }
+    return blocker;
+}
+/** The same rewrite, with the saved launch record and the commands resolved for this call. */
+async function withManualStepForWindowMode(blocker, port, sourceCli, commandOptions) {
+    if (!MANUAL_BROWSER_STEP_CODES.has(blocker.code))
+        return blocker;
+    const launch = await readLastBrowserLoginLaunch().catch(() => undefined);
+    const options = {
+        ...commandOptions,
+        port,
+        ...(launch?.profile_dir ? { profileDir: launch.profile_dir } : {})
+    };
+    return manualBrowserStepForWindowMode(blocker, launch, port, {
+        headedLogin: formatHeadedBrowserLoginCommand(sourceCli, options),
+        visibleRecovery: formatVisibleAuthRecoveryCommand(sourceCli, options)
+    });
+}
 function formatHeadedBrowserLoginCommand(sourceCli, options = {}) {
     return `${formatBrowserLoginCommand(sourceCli, options)} --headed`;
 }
@@ -3100,6 +3162,9 @@ export function printBrowserLoginGuide(stdout, input) {
         return;
     }
     stdout("");
+    stdout("Chrome account connection is separate from ChatGPT sign-in. If Chrome asks, choose whether to connect the browser account yourself.");
+    stdout("'Use Chrome without an account' declines that browser connection, not your ChatGPT login. Keep the ChatGPT tab open after making that choice.");
+    stdout("");
     stdout("Steps:");
     if (windowAvailable) {
         stdout(input.reusedProfile || input.reused === true
@@ -3261,7 +3326,12 @@ export async function printProductCheck(store, io, args, configCwd = io.cwd) {
         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);
+            const modeAware = await withManualStepForWindowMode(browserStatus.blocker, checkPort, sourceCli, browserCommandOptions);
+            // A rewritten step already carries fully formed commands; running it back
+            // through the product-check rewrite would only re-derive them.
+            const nextStep = modeAware === browserStatus.blocker
+                ? productCheckBrowserNextStep(browserStatus.blocker.next_step, sourceCli, browserCommandOptions)
+                : modeAware.next_step;
             if (nextStep)
                 io.stdout(`next: ${nextStep}`);
         }

package/dist/cli-shared.js

@@ -88,10 +88,10 @@ export function sourceAwareBrowserNextStep(nextStep, sourceCli, options = {}) {
         return `\`cd ${cwdPrefix} && ${formatBrowserAskCommandBody(sourceCli)}${storedArgs ?? ""}\``;
     })
         .replace(/`prodex pro browser login([^`]*)?`/g, (_match, storedArgs) => {
-        return `\`${formatBrowserLoginCommand(sourceCli, browserOptionsWithStoredPort(options, storedArgs))}\``;
+        return `\`${formatBrowserLoginCommand(sourceCli, browserOptionsWithStoredPort(options, storedArgs))}${flagsBesidesPort(storedArgs)}\``;
     })
         .replace(/`prodex pro browser smoke([^`]*)?`/g, (_match, storedArgs) => {
-        return `\`${formatBrowserSmokeCommand(sourceCli, browserOptionsWithStoredPort(options, storedArgs))}\``;
+        return `\`${formatBrowserSmokeCommand(sourceCli, browserOptionsWithStoredPort(options, storedArgs))}${flagsBesidesPort(storedArgs)}\``;
     })
         .replace(/`prodex pro browser ask([^`]*)?`/g, (_match, storedArgs) => {
         return `\`${formatBrowserAskCommandBody(sourceCli)}${storedArgs ?? ""}\``;
@@ -131,6 +131,19 @@ export function isUntrustedResultError(error) {
 export function formatCommandInCwd(command, cwd) {
     return cwd ? `cd ${shellQuote(cwd)} && ${command}` : command;
 }
+/**
+ * The flags of a quoted command other than --port, which the rewrite rebuilds
+ * itself. They used to be dropped: a next step saying "run `prodex pro browser
+ * login --background`" came out as a plain `login`, and "--headed" vanished from
+ * the step that exists to get a window - so following the advice relaunched the
+ * browser in the very mode it was telling the caller to leave.
+ */
+export function flagsBesidesPort(storedArgs) {
+    if (!storedArgs)
+        return "";
+    const rest = storedArgs.replace(/(?:^|\s)--port\s+\d{1,5}(?=\s|$)/, " ").replace(/\s+/g, " ").trim();
+    return rest ? ` ${rest}` : "";
+}
 export function browserOptionsWithStoredPort(options, storedArgs) {
     if (options.port || !storedArgs)
         return options;

package/docs/releasing.md

@@ -16,6 +16,28 @@ Release target: `v0.40.13` on `main`. The GitHub Release records the resolved co
 
 The release adds a guarded, opt-in transition and more accurate blocker reporting. It does not claim that headless Pro consultation is verified on either deployment target or that authentication can be retained indefinitely.
 
+## 0.40.2 - 0.40.7 Release Record
+
+Recorded 2026-09-29, after the fact. These versions went around the tag-and-CI path, so none of them has a git tag, a GitHub Release or npm provenance; this section is their durable record. The commit for each published version was matched to the npm publish time and cross-checked by downloading the published package and finding that version's fixes in its `dist`.
+
+**Channel.** Built with `prodex release pack` (normalized tarball) and published by hand with `npm publish <tarball>` from WSL, because a source-tree publish is refused on the WSL mount's file modes. That route bypasses `publish.yml`, so there is no provenance attestation (0.40.1 and 0.40.8 have one; 0.40.2 - 0.40.6 do not), no tag and no Release. Tags were not backfilled: pushing a `v*` tag runs `publish.yml`, which would re-verify old code and then fail at `npm publish` because the version already exists.
+
+| Version | Commit | npm publish (UTC) | Verification before publish | Live check |
+|---|---|---|---|---|
+| 0.40.2 | `003d4d7` | 2026-09-09 17:39 | vitest 1126 pass; `release:verify` ok | Defective: installed from the registry on 2026-09-10 and sent into a real project - refused `project_not_bound`. Every project send fails in this version (see CHANGELOG). |
+| 0.40.3 | `6f36b47` | 2026-09-10 07:27 | vitest 1184 pass; `release:verify` ok | Registry package sent into an existing project, across projects, and with `--project-new`; `destination.verified: true` on the receipt. |
+| 0.40.4 | `2a84bc5` | 2026-09-11 00:21 | vitest 1198 pass; `release:verify` ok | `--continue` with the tab deliberately moved elsewhere, over CLI and over MCP `pro_consult` (`continue_thread`). |
+| 0.40.5 | `a9c629d` | 2026-09-14 00:43 | vitest 1248 pass; `release:verify` ok; tarball `publish --dry-run` ok | create-image and web-search sends; back-to-back sends queued on the lock 3/3. |
+| 0.40.6 | `4550cad` | 2026-09-14 01:52 | vitest 1259 pass; `release:verify` ok; tarball `publish --dry-run` ok | Dedicated browser killed twice; `--auto-login` relaunched it in about 3 s and the receipt carried `browser_recovered`. |
+| 0.40.7 | `678a02e` (tag only) | not published | `publish.yml` run 34816390439 failed at Release verification; logs no longer retrievable | Superseded by 0.40.8. |
+
+**Installation.** Global npm installs, verified with `prodex --version` on each host after install:
+
+- 0.40.3, 0.40.4, 0.40.5, 0.40.6: WSL, M3 and the Mac mini, each upgraded on its publish day (the Mac mini came from 0.37.0 at 0.40.3). M4 was unreachable over SSH every time and was never updated.
+- Running services are separate from the install. After 0.40.3 and 0.40.4 the long-lived stdio MCP servers (13 on WSL, 8 on M3) kept the old code. A freshly spawned server reported `serverInfo.version` 0.40.4 and completed a `continue_thread` consult. On 2026-09-14, before 0.40.5, every prodex MCP server was stopped with SIGTERM (20 on WSL, 7 on M3) with no consult in flight; the servers the clients respawned came up on 0.40.4, the install at that moment, and needed another reconnect after the 0.40.5 and 0.40.6 installs.
+- State on 2026-09-29: WSL 0.40.18, M3 0.40.18, Mac mini still 0.40.6 (not upgraded since), M4 unreachable (its hostname no longer resolves).
+- 2026-09-29: Mac mini upgraded 0.40.6 -> 0.40.18 with `npm i -g @youdie006/prodex@0.40.18`; `prodex --version` reports 0.40.18. No prodex MCP server was running there, so nothing needed a restart; the next one a client starts runs 0.40.18.
+
 ## Publishing
 
 Publishing to npm runs entirely in CI with **no long-lived token** — auth is npm [trusted publishing](https://docs.npmjs.com/trusted-publishers) (OIDC), so nothing needs to store or paste an `NPM_TOKEN`, and every release carries a verifiable `--provenance` attestation.

package/package.json

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