@youdie006/prodex 0.40.38 → 0.40.39

package/dist/browser-send-lock.js

@@ -15,9 +15,10 @@ function lockPath() {
 /**
  * Serialize visible-browser sends across processes. Waits up to waitMs for a
  * live holder to finish (0 = fail fast); a lock whose holder process is dead
- * is reaped immediately.
+ * is reaped immediately. budgetFlag is the option that sets waitMs for the
+ * command that is waiting, named when the wait runs out.
  */
-export async function withBrowserSendLock(waitMs, onWait, fn) {
+export async function withBrowserSendLock(waitMs, onWait, fn, budgetFlag = "--timeout-ms") {
     const file = lockPath();
     const reapClaim = path.join(path.dirname(file), `.${path.basename(file)}.reap`);
     return withCrossProcessFileLock(file, {
@@ -25,7 +26,7 @@ export async function withBrowserSendLock(waitMs, onWait, fn) {
         retryMs: 2_000,
         privateParent: true,
         onWait: (holder) => onWait(`another prodex send holds the browser (pid ${holder.pid ?? "unknown"}); waiting`),
-        busyError: (holder) => new Error(`Another prodex browser send is in progress (pid ${holder.pid ?? "unknown"}) and did not finish within the wait budget. Retry once it finishes, or raise --timeout-ms (which is also the queue budget).`),
+        busyError: (holder) => new Error(`Another prodex browser send is in progress (pid ${holder.pid ?? "unknown"}) and did not finish within the wait budget. Retry once it finishes, or raise ${budgetFlag} (which is also the queue budget).`),
         unavailableError: () => new Error(`A prodex browser send lock at ${file} is held by nothing and could not be removed, so no send can start. Stop all prodex senders and verify no request is active before deleting that file and the abandoned reaper claim at ${reapClaim}, then retry.`)
     }, fn);
 }

package/dist/chatgpt-browser.js

@@ -252,9 +252,31 @@ export const CHATGPT_RENDERED_MESSAGE_TEXT_JS = `
       // Inline math carries data-math-display="false" (measured), so the value counts, not its presence.
       const isDisplayMath = (node) => attr(node, "data-math-display") === "true" || hasClass(node, "katex-display");
       const isCodeBlock = (node) => attr(node, "data-markdown-copy") === "code-block" || tagOf(node) === "pre";
+      // A mermaid block is drawn as an SVG preview whose only text is the
+      // toolbar and node labels (measured 2026-10-21); its source is in the
+      // React props of the preview's fiber ancestors, as CodeMirror's is in
+      // its editor state.
+      const isMermaidPreview = (node) => attr(node, "data-chatgpt-mermaid-preview") !== null;
+      const mermaidBlock = (node) => {
+        let source = null;
+        try {
+          const fiberKey = Object.keys(node).find((key) => key.startsWith("__reactFiber"));
+          let fiber = fiberKey ? node[fiberKey] : null;
+          for (let depth = 0; fiber && depth < 12 && source === null; depth += 1, fiber = fiber.return) {
+            const content = fiber.memoizedProps && fiber.memoizedProps.content;
+            if (typeof content === "string" && content.trim()) source = trimEnd(content);
+          }
+        } catch (error) {
+          source = null;
+        }
+        if (source === null) return "[mermaid diagram - open the thread to see its source]";
+        const longestRun = (source.match(new RegExp(BT + "+", "g")) || []).reduce((most, run) => Math.max(most, run.length), 0);
+        const fence = BT.repeat(Math.max(3, longestRun + 1));
+        return fence + "mermaid" + NL + source + NL + fence;
+      };
       const BLOCK_TAGS = ["p", "div", "section", "article", "figure", "ul", "ol", "li", "table", "blockquote", "pre", "hr", "h1", "h2", "h3", "h4", "h5", "h6"];
       const isBlock = (node) => node.nodeType === 1 && !skipped(node) &&
-        (BLOCK_TAGS.includes(tagOf(node)) || isCodeBlock(node) || (isMath(node) && isDisplayMath(node)) ||
+        (BLOCK_TAGS.includes(tagOf(node)) || isCodeBlock(node) || isMermaidPreview(node) || (isMath(node) && isDisplayMath(node)) ||
           (tagOf(node) === "span" && findAll(node, (n) => BLOCK_TAGS.includes(tagOf(n))).length > 0));
       // The renderer web-search answers use since 2026-10-10 marks a source as a
       // badge inside a popover trigger; its urls only exist once it is opened.
@@ -362,6 +384,7 @@ export const CHATGPT_RENDERED_MESSAGE_TEXT_JS = `
         const tag = tagOf(node);
         if (isMath(node)) return isDisplayMath(node) ? "$$" + NL + mathSource(node) + NL + "$$" : "$" + mathSource(node) + "$";
         if (isCodeBlock(node)) return codeBlock(node);
+        if (isMermaidPreview(node)) return mermaidBlock(node);
         if (tag === "table") return table(node);
         if (/^h[1-6]$/.test(tag)) return "#".repeat(Number(tag[1])) + " " + inline(node).trim();
         if (tag === "ul" || tag === "ol") return list(node, depth);

package/dist/cli-args.js

@@ -72,6 +72,12 @@ export function unknownTopLevelCommandError(command) {
     return new Error(`Unknown command: ${command}.${suggestionText} Run \`prodex help\`.`);
 }
 export function unknownOptionError(option, command, candidates) {
+    // A prompt that starts with a dash ("-5 + 3, what is it?") lands here.
+    // Anything that cannot be a flag gets the way to send it instead of a guess.
+    if (!/^--?[A-Za-z][\w-]*(=.*)?$/.test(option)) {
+        const context = command ? ` for ${command}` : "";
+        return new Error(`Unknown option${context}: ${option}. If this is the prompt, put \`--\` before it: prodex ask -- ${JSON.stringify(option)}`);
+    }
     const suggestion = closestSuggestion(option, candidates);
     const suggestionText = suggestion ? `. Did you mean \`${suggestion}\`?` : "";
     const context = command ? ` for ${command}` : "";

package/dist/cli-pro.js

@@ -2305,7 +2305,7 @@ async function recoverBrowserUnderSendLock(stderr, options) {
     }
 }
 async function completeVisibleAuthRecovery(io, options) {
-    return withBrowserSendLock(5_000, (detail) => io.stderr(`recovery: ${detail}`), async () => {
+    return withBrowserSendLock(options.timeoutMs, (detail) => io.stderr(`recovery: ${detail}`), async () => {
         const { closeBlockedHeadlessBrowserForVisibleAuth, getDedicatedBrowserHeadlessMode } = await import("./browser-handoff.js");
         io.stderr("recovery: verifying the blocked headless browser before graceful visible handoff...");
         let url;
@@ -2342,10 +2342,26 @@ async function completeVisibleAuthRecovery(io, options) {
             headedLoginCommand: formatHeadedBrowserLoginCommand(options.sourceCli, { ...options.commandOptions, profileDir: opened.profileDir, port: opened.port })
         });
         return ready ? 0 : 1;
-    });
+    }, "--wait-timeout-ms");
+}
+/**
+ * Why a headless handoff sat on Cloudflare's check, and the way out. Measured
+ * 2026-10-20 on M3: headless Chrome reported "HeadlessChrome/155.0.0.0" and an
+ * 800x600 screen and stayed on "Just a moment", right after a visible sign-in.
+ * WSL works because its browser is ordinary Chrome on a virtual display.
+ */
+export function headlessCloudflareHint(code, platform) {
+    if (code !== "cloudflare_check")
+        return undefined;
+    const cause = "Cloudflare keeps headless Chrome on its check (it identifies itself as HeadlessChrome), so another login or handoff will not get past it.";
+    return platform === "darwin"
+        ? `${cause} macOS has no virtual display for Chrome; run the dedicated browser in the browser container instead (docs/container-browser.md), or keep a visible window open behind your other windows.`
+        : `${cause} Run it on a virtual display instead, with no window on screen: \`prodex pro browser login --virtual-display\`.`;
 }
 async function completeBackgroundBrowserLogin(io, options) {
-    return withBrowserSendLock(5_000, (detail) => io.stderr(`background: ${detail}`), async () => {
+    // An agent sending consults back to back left no 5 s gap (measured
+    // 2026-10-20 on M3), so the handoff queues for its turn like a send does.
+    return withBrowserSendLock(options.timeoutMs, (detail) => io.stderr(`background: ${detail}`), async () => {
         const { closeIdleChatGptBrowserForHandoff, getDedicatedBrowserHeadlessMode } = await import("./browser-handoff.js");
         io.stderr("background: checking the dedicated browser before graceful handoff...");
         const { url } = await closeIdleChatGptBrowserForHandoff({ port: options.port, profileDir: options.profileDir });
@@ -2367,13 +2383,16 @@ async function completeBackgroundBrowserLogin(io, options) {
         if (!ready) {
             const status = await getChatGptBrowserStatus({ port: opened.port, timeoutMs: 5_000 }).catch(() => undefined);
             io.stderr(`background: NOT READY (${status?.blocker?.code ?? "not_ready"}). The same profile was kept; this is not proof that your saved login was lost. No prompt was sent.`);
+            const hint = headlessCloudflareHint(status?.blocker?.code, process.platform);
+            if (hint)
+                io.stderr(`background: ${hint}`);
             return 1;
         }
         if (!getDedicatedBrowserHeadlessMode({ port: opened.port, profileDir: opened.profileDir }))
             throw new Error("The replacement browser is not actually headless; background readiness was not confirmed.");
         io.stdout("background: READY - the saved login works headless, with no visible window. You may close this terminal; later consults reuse this mode.");
         return 0;
-    });
+    }, "--wait-timeout-ms");
 }
 function needsVisibleAuthRecovery(code) {
     return code !== undefined && ["login_required", "cloudflare_check", "captcha_required", "permission_required"].includes(code);

package/dist/repo.js

@@ -70,7 +70,8 @@ export async function readRepoFile(root, repoPath, options = {}) {
     const resolved = resolveRepoPath(root, repoPath);
     await assertResolvedRepoPathAllowed(root, resolved, repoPath);
     const text = await readVerifiedUtf8File(resolved, () => assertResolvedRepoPathAllowed(root, resolved, repoPath), {
-        maxBytes: MAX_REPO_READ_BYTES
+        maxBytes: MAX_REPO_READ_BYTES,
+        decodeUtf16Bom: true
     }).catch((error) => {
         if (error instanceof Error && /too large/.test(error.message)) {
             throw new Error(`Path ${repoPath} is too large to read through repo tools`);

package/dist/safe-file.js

@@ -71,7 +71,7 @@ export async function readVerifiedUtf8File(filePath, validate, options = {}) {
         if (options.maxBytes !== undefined && stat.size > options.maxBytes) {
             throw new Error(`Target file is too large (${stat.size} bytes)`);
         }
-        const content = await readHandleUtf8(handle, filePath, options.maxBytes);
+        const content = await readHandleUtf8(handle, filePath, options.maxBytes, options.decodeUtf16Bom === true);
         if (options.mode !== undefined) {
             await testHooks.beforeChmod?.(filePath, "read");
             await assertSafeOpenFile(handle, filePath, "read");
@@ -185,7 +185,7 @@ async function replaceByVerifiedTempFile(filePath, content, validate, options =
         throw error;
     }
 }
-async function readHandleUtf8(handle, filePath, maxBytes) {
+async function readHandleUtf8(handle, filePath, maxBytes, decodeUtf16Bom = false) {
     await assertOpenFileMatchesPath(handle, filePath, "read");
     const stat = await handle.stat();
     if (!stat.isFile()) {
@@ -206,7 +206,24 @@ async function readHandleUtf8(handle, filePath, maxBytes) {
             throw new Error(`Target file is too large (${offset} bytes)`);
         }
     }
-    return buffer.subarray(0, offset).toString("utf8");
+    return decodeFileText(buffer.subarray(0, offset), decodeUtf16Bom);
+}
+/**
+ * UTF-8, or UTF-16 when asked and the file starts with its BOM. Windows
+ * Notepad's "Unicode" saves UTF-16 LE with a BOM, and reading that as UTF-8
+ * turned every other byte into a NUL (measured 2026-10-20: --file refused it
+ * as "not a text file"). Only readers opt in, so nothing is re-encoded on write.
+ */
+export function decodeFileText(bytes, decodeUtf16Bom = false) {
+    if (decodeUtf16Bom && bytes.length >= 2) {
+        if (bytes[0] === 0xff && bytes[1] === 0xfe)
+            return bytes.subarray(2).toString("utf16le");
+        if (bytes[0] === 0xfe && bytes[1] === 0xff) {
+            const body = Buffer.from(bytes.subarray(2, 2 + ((bytes.length - 2) & ~1)));
+            return body.swap16().toString("utf16le");
+        }
+    }
+    return bytes.toString("utf8");
 }
 async function writeHandleUtf8(handle, filePath, content) {
     const replacement = Buffer.from(content, "utf8");

package/docs/releasing.md

@@ -16,6 +16,44 @@ 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.
 
+## Browser Incident 2026-10-20: M3 headless browser behind Cloudflare
+
+**What happened**
+- A read-only `prodex pro browser check` on M3 (0.40.38) reported `cloudflare_check`: the dedicated browser had run headless since 2026-09-16 and its ChatGPT tab sat on Cloudflare's human-verification page. Consults from M3's stdio MCP servers could not send.
+- `login --headed --recover-visible` could not take it over (`Chrome DevTools command timed out: Runtime.enable` on the stuck tab), and `reset` declined because the browser itself still answered.
+
+**Recovery**
+- The dedicated browser was closed with CDP `Browser.close` (send lock idle), then started with a window. Cloudflare passed. `--minimized` was not kept: this macOS desktop reports a minimized window as hidden, so prodex restored it.
+- The profile's ChatGPT login had expired; the maintainer signed in on the Mac. `pro browser check` then reported `ok logged_in=true composer=true`, and `pro browser smoke` answered `PRODEX_PRO_SMOKE_OK`.
+
+**Headless handoff, then the cause (same day)**
+- `login --background` handed the signed-in profile to headless (after PR #35's lock-wait problem was worked around by retrying), and the headless tab was immediately back on Cloudflare's "Just a moment" page (`NOT READY - cloudflare_check ... not ready headlessly`).
+- Read over CDP: the headless browser reports `HeadlessChrome/155.0.0.0` in its user agent and an 800x600 screen. WSL never runs headless - its dedicated browser is ordinary Chrome on the Xvfb display - which is why the same account works there. macOS has no Xvfb. Faking the user agent was not done: the container design excludes stealth settings.
+- M3's Claude and Codex MCP configs already use the browser container (`container-client.mjs --context colima-prodex-check mcp`), which runs ordinary Chromium on Xvfb and was logged in and ready. Three long-running sessions (two Claude, started via cmux with `--resume`, and a Codex running since 2026-09-15) still held host `prodex mcp` connections; they reach the container after a `/mcp` reconnect.
+- M3's container was rebuilt from `container/redesign-patches` `a870b0c` (image `feb5a47aae06`, restart `unless-stopped`) under the container's send-lock check. Its login was kept, the ChatGPT tab opened by itself, `pro browser check` was ok and the smoke answered `PRODEX_PRO_SMOKE_OK`. The container's `prodex --version` still prints 0.40.18 because that branch never bumped its version.
+
+**Open**
+- A long-running headless browser ends up behind Cloudflare's check (also noted on WSL, where the Xvfb display is used instead). On macOS there is no virtual display, and a minimized window counts as hidden, so the remaining no-headless option there is a window kept behind others. Changing the headless preference is a design decision that was not made here.
+
+## 0.40.38 Release Record
+
+Release commit `9541727` on `main` (cut after PR #32, merge `2c049b5`); tag `v0.40.38`.
+
+**Publishing**
+- `publish.yml` run 39362699716 passed all six platforms on the first attempt, then npm publish with SLSA v1 provenance and the GitHub Release (2026-10-20 03:08 UTC).
+- `npm run release:verify` passed on the release commit after a build.
+
+**Installed**
+- WSL, M3, Mac mini: `prodex --version` reports 0.40.38. Running services were not restarted: 9 stdio MCP servers on WSL and 3 on M3 keep older code until their clients reconnect. The Mac mini had none running.
+- The maintainer watchdog checkout was pulled to `9541727` and rebuilt.
+
+**Verified live**
+- Over a fresh stdio MCP server on installed 0.40.38: a `pro_consult` with a 15 s timeout returned `status: "blocked"` (`send_timeout`) with `recover`, and `pro_recover` with `recover.arguments` returned `status: "done"`. On 0.40.37 the same consult returned only error text naming a CLI command.
+- Earlier the same day over MCP: `files`, `continue_thread`, and refusals for a path outside the repo, `.env`, a missing attachment, `new_chat` with `continue_thread`, and `deep-research` all behaved as documented.
+
+**Browser container**
+- `container/redesign-patches` `9c8a3d9` ports PR #32. Image `7486d2054a82`; branch suite 2049 passed, 3 skipped. Swapped under the send lock check. Live over MCP in the container: the same timeout returned `recover`, and `pro_recover` returned `done`.
+
 ## 0.40.37 Release Record
 
 Release commit `437590d` on `main` (cut after PR #31, merge `fd0ef2e`); tag `v0.40.37`.

package/package.json

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