@youdie006/prodex 0.40.25 → 0.40.27

package/dist/chatgpt-browser.js

@@ -191,13 +191,52 @@ export const CHATGPT_BLOCKER_SCAN_EXCLUDED_ANCESTORS = `${'[data-message-author-
  * sat in the thread for ten minutes while prodex waited for it. The model slug
  * attribute went with it; where it is absent the model is simply not known.
  */
-const CHATGPT_MESSAGE_NODES_JS = `
+/**
+ * A message's text with its source pills spelled out.
+ *
+ * Measured 2026-10-06: ChatGPT renders each source as an inline pill
+ * ([data-chatgpt-copy-reference]) and innerText puts its label on a line of
+ * its own, so a page-read answer came back as "walnut-9" plus a line
+ * "cont-att", or ended in a bare "blog.rust-lang.org" that read as part of
+ * the answer. A web source becomes " [label](url)", as the transcript reader
+ * writes it; a file source has no link and becomes " [label]". The label is
+ * looked for on its own line first, so the same words earlier in the prose
+ * are left alone.
+ */
+export const CHATGPT_RENDERED_MESSAGE_TEXT_JS = `
+    const renderedMessageText = (root) => {
+      let text = root.innerText || "";
+      const newline = String.fromCharCode(10);
+      const isSpace = (ch) => ch === " " || ch === newline || ch === String.fromCharCode(9) || ch === String.fromCharCode(13);
+      let cursor = 0;
+      for (const pill of [...root.querySelectorAll('[data-chatgpt-copy-reference]')]) {
+        const label = (pill.innerText || "").trim();
+        if (!label) continue;
+        const onOwnLine = text.indexOf(newline + label, cursor);
+        const at = onOwnLine >= 0 ? onOwnLine + 1 : text.indexOf(label, cursor);
+        if (at < 0) continue;
+        let start = at;
+        while (start > cursor && isSpace(text[start - 1])) start -= 1;
+        const link = pill.querySelector('a[href^="http"]');
+        const rendered = link ? " [" + label + "](" + link.getAttribute("href") + ")" : " [" + label + "]";
+        text = text.slice(0, start) + rendered + text.slice(at + label.length);
+        cursor = start + rendered.length;
+      }
+      return text;
+    };`;
+const CHATGPT_MESSAGE_NODES_JS = `${CHATGPT_RENDERED_MESSAGE_TEXT_JS}
+    // ChatGPT keeps a previously opened conversation mounted but hidden
+    // (measured 2026-10-06: two turns without a box on a project home), and
+    // counting them made a fresh chat look like an existing conversation.
+    // A display:contents node has no box of its own, so its children decide.
+    const isRenderedMessageNode = (node) =>
+      node.getClientRects().length > 0 || [...(node.children || [])].some((child) => child.getClientRects().length > 0);
     const chatMessageNodes = () => {
-      const legacy = [...document.querySelectorAll('[data-message-author-role]')];
+      const legacy = [...document.querySelectorAll('[data-message-author-role]')].filter(isRenderedMessageNode);
       if (legacy.length > 0) {
         return legacy.map((node) => ({ role: node.getAttribute('data-message-author-role'), node, textNode: node }));
       }
-      const units = [...document.querySelectorAll('[data-chatgpt-search-unit-key]')];
+      const units = [...document.querySelectorAll('[data-chatgpt-search-unit-key]')].filter(isRenderedMessageNode);
       return units
         .filter((unit) => !units.some((other) => other !== unit && unit.contains(other)))
         .map((unit) => {
@@ -3431,6 +3470,14 @@ export async function recoverChatGptAnswerFromThread(options) {
                 lastAnswer = "";
                 continue;
             }
+            // A thread that is still loading already has the target URL but no
+            // turns (measured 2026-10-06), and judging the request on it refused a
+            // recovery of the very request it was asked for.
+            if (state.userMessageCount === 0) {
+                stableRuns = 0;
+                lastAnswer = "";
+                continue;
+            }
             if (options.requestId && !chatGptRequestMarkerMatches(state.lastUserText ?? "", options.requestId)) {
                 throw new ChatGptBrowserBlockerError({
                     code: "request_mismatch",
@@ -5109,6 +5156,29 @@ export function insertComposerTextInPageExpression(text) {
 export function composerFileInputSelector() {
     return 'input[type="file"]:not([accept*="image"])';
 }
+const COMPOSER_FILE_INPUT_TIMEOUT_MS = 15_000;
+const COMPOSER_TOOLS_MENU_ATTEMPTS = 3;
+export const PRODEX_ATTACH_INPUT_ATTRIBUTE = "data-prodex-attach-input";
+/**
+ * Tags the general file input of the form that holds the VISIBLE composer, so
+ * DOM.querySelector can resolve exactly that node. A project home also keeps
+ * a hidden copy of an earlier page mounted with its own complete composer
+ * form (measured 2026-10-06: two editor forms, the hidden one first), and a
+ * structural selector cannot tell the two apart. Returns false when no
+ * visible composer form carries a general file input.
+ */
+export function markComposerFileInputExpression() {
+    const attribute = JSON.stringify(PRODEX_ATTACH_INPUT_ATTRIBUTE);
+    return `(() => {${composerExpressionHelpers()}
+    document.querySelectorAll('[' + ${attribute} + ']').forEach((node) => node.removeAttribute(${attribute}));
+    const editor = findChatGptComposerCandidate();
+    const form = editor && editor.closest('form');
+    const input = form && form.querySelector(${JSON.stringify(composerFileInputSelector())});
+    if (!input) return false;
+    input.setAttribute(${attribute}, "1");
+    return true;
+  })()`;
+}
 /**
  * Lookup order for the attachment input. A conversation page also renders a
  * second form without the prompt editor, earlier in the document and with its
@@ -5140,7 +5210,8 @@ export function attachmentStateExpression(fileNames) {
       .join(String.fromCharCode(10));
     const haystack = text + String.fromCharCode(10) + labels;
     // Uploading a name that was used before makes ChatGPT show it as
-    // "stem(3).ext", so that spelling counts as the same file.
+    // "stem(3).ext", and since 2026-10 as "stem(20261006-012426).ext", so
+    // either spelling counts as the same file.
     const shownAsRenamed = (name) => {
       const dot = name.lastIndexOf(".");
       const stem = dot > 0 ? name.slice(0, dot) : name;
@@ -5149,7 +5220,7 @@ export function attachmentStateExpression(fileNames) {
       while ((from = haystack.indexOf(stem + "(", from)) !== -1) {
         let i = from + stem.length + 1;
         const digitsStart = i;
-        while (i < haystack.length && haystack[i] >= "0" && haystack[i] <= "9") i += 1;
+        while (i < haystack.length && ((haystack[i] >= "0" && haystack[i] <= "9") || (i > digitsStart && haystack[i] === "-"))) i += 1;
         if (i > digitsStart && haystack.startsWith(")" + ext, i)) return true;
         from += 1;
       }
@@ -5167,9 +5238,14 @@ export function attachmentStateExpression(fileNames) {
 /** How many attachments are already sitting in the composer (read-only). */
 export function attachmentPresenceExpression() {
     return `(() => {
-    const buttons = [...document.querySelectorAll('button[aria-label]')].filter((b) =>
-      /remove file|파일 제거|첨부 제거/i.test(b.getAttribute("aria-label") || "")
-    );
+    // The chip's remove button was "Remove file 1: name" and became
+    // "Remove name" (measured 2026-10-06); a tool pill's "Remove Search" is
+    // not a file. Chips on a hidden, still-mounted page have no box.
+    const buttons = [...document.querySelectorAll('button[aria-label]')].filter((b) => {
+      const label = b.getAttribute("aria-label") || "";
+      if (!(/remove file|파일 제거|첨부 제거/i.test(label) || /^remove\\s+\\S.*\\.[A-Za-z0-9]{1,8}$/i.test(label))) return false;
+      return b.getClientRects().length > 0;
+    });
     return { ok: true, removed: buttons.length };
   })()`;
 }
@@ -5197,24 +5273,43 @@ export async function attachFilesToComposer(cdp, absolutePaths, options = {}) {
     // every later attach in that tab silently does nothing. A reload is the only
     // reliable reset, and it costs a few seconds only when there is something to
     // clear.
-    const stale = await cdp.evaluate(attachmentPresenceExpression());
-    if ((stale?.removed ?? 0) > 0) {
-        await cdp.evaluate("location.reload()");
-        await sleep(6_000);
-        const settleDeadline = Date.now() + 15_000;
+    // "complete" is not "usable": the server-rendered editor is there before
+    // the app attaches its file inputs (measured: complete at 3.3 s, inputs at
+    // 5.1 s after a new-chat navigation), and every navigation path reaches
+    // this point in that window sometimes. Wait for the input itself, before
+    // the chip check (chips render with it) and before reading the DOM tree.
+    const waitForComposerFileInput = async () => {
+        const inputDeadline = Date.now() + COMPOSER_FILE_INPUT_TIMEOUT_MS;
         for (;;) {
-            const ready = await cdp.evaluate(composerTextStateExpression());
-            if (ready?.ok || Date.now() >= settleDeadline)
-                break;
+            try {
+                if (await cdp.evaluate(markComposerFileInputExpression()) === true)
+                    return true;
+            }
+            catch (error) {
+                if (cdpCommandTimedOut(error))
+                    throw error;
+            }
+            if (Date.now() >= inputDeadline)
+                return false;
             await sleep(500);
         }
+    };
+    let marked = await waitForComposerFileInput();
+    const stale = await cdp.evaluate(attachmentPresenceExpression());
+    if ((stale?.removed ?? 0) > 0) {
+        // A fixed sleep and a composer check could both pass on the document being
+        // left (a reload takes 5-8 s here), and the file then went into a page that
+        // was replaced under it. The marked reload waits for the new document.
+        await reloadAndAwaitComposer(cdp, 20_000);
+        marked = await waitForComposerFileInput();
     }
     const document = await cdp.send("DOM.getDocument", { depth: -1, pierce: true });
     const rootNodeId = document.result?.root?.nodeId;
     if (rootNodeId === undefined)
         throw new Error("Could not read the ChatGPT page DOM to attach files.");
+    const selectors = marked ? [`[${PRODEX_ATTACH_INPUT_ATTRIBUTE}]`, ...composerFileInputSelectors()] : composerFileInputSelectors();
     let inputNodeId;
-    for (const selector of composerFileInputSelectors()) {
+    for (const selector of selectors) {
         const input = await cdp.send("DOM.querySelector", { nodeId: rootNodeId, selector });
         inputNodeId = input.result?.nodeId || undefined;
         if (inputNodeId)
@@ -5406,20 +5501,41 @@ export async function enableComposerTools(cdp, labels) {
             enabled.push(label);
             continue;
         }
-        const button = await cdp.evaluate(composerToolsButtonRectExpression());
+        // The server-rendered editor shows before the app attaches the composer's
+        // controls (measured 2026-10-06), so a first miss is usually just early.
+        let button = await cdp.evaluate(composerToolsButtonRectExpression());
+        const buttonDeadline = Date.now() + COMPOSER_FILE_INPUT_TIMEOUT_MS;
+        while ((!button.ok || button.x === undefined || button.y === undefined) && Date.now() < buttonDeadline) {
+            await sleep(500);
+            button = await cdp.evaluate(composerToolsButtonRectExpression());
+        }
         if (!button.ok || button.x === undefined || button.y === undefined) {
             throw new Error(button.reason ?? "Could not open the ChatGPT composer tools menu");
         }
-        await dispatchMouseClickAt(cdp, button.x, button.y);
+        // A click that lands before the app has wired the button opens nothing
+        // (measured 2026-10-06), which looked exactly like a menu without the
+        // tool. The button is clicked again, freshly located, before concluding
+        // the tool is missing.
         let entry = { ok: false };
-        const menuDeadline = Date.now() + 6_000;
-        for (;;) {
-            entry = await cdp.evaluate(composerToolEntryRectExpression(label));
+        for (let attempt = 0; attempt < COMPOSER_TOOLS_MENU_ATTEMPTS; attempt += 1) {
+            if (attempt > 0) {
+                await dispatchEscapeKey(cdp);
+                const again = await cdp.evaluate(composerToolsButtonRectExpression());
+                if (again.ok && again.x !== undefined && again.y !== undefined)
+                    button = again;
+            }
+            await dispatchMouseClickAt(cdp, button.x, button.y);
+            const menuDeadline = Date.now() + 4_000;
+            for (;;) {
+                entry = await cdp.evaluate(composerToolEntryRectExpression(label));
+                if (entry.ok && entry.x !== undefined && entry.y !== undefined)
+                    break;
+                if (Date.now() >= menuDeadline)
+                    break;
+                await sleep(250);
+            }
             if (entry.ok && entry.x !== undefined && entry.y !== undefined)
                 break;
-            if (Date.now() >= menuDeadline)
-                break;
-            await sleep(250);
         }
         if (!entry.ok || entry.x === undefined || entry.y === undefined) {
             await dispatchEscapeKey(cdp);
@@ -5944,7 +6060,7 @@ export function answerExpression() {
         const tagged = node.closest('[data-message-model-slug]');
         if (tagged) modelSlug = tagged.getAttribute('data-message-model-slug') || undefined;
       }
-      return { role, node, text: textNode.innerText || "", modelSlug };
+      return { role, node, text: renderedMessageText(textNode), modelSlug };
     });
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     const userMessages = messages.filter((message) => message.role === "user");

package/docs/releasing.md

@@ -16,6 +16,79 @@ 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.26 Release Record
+
+Release commit `b413c24` on `main` (cut after PR #16, merge `af5cf20`); tag `v0.40.26`.
+
+**Publishing**
+- `publish.yml` run 37405732176 passed all six platforms on the first attempt, then npm publish with SLSA v1 provenance and the GitHub Release (2026-10-06 03:07 UTC).
+- PR #16's own CI needed one rerun on macOS Intel for an unrelated 30 s timeout in `tests/mcp-consult.test.ts`.
+- `npm run release:verify` passed on the release commit after a build.
+
+**What it fixes**
+- The ChatGPT page measured on 2026-10-06 broke several flows:
+  - Every project send was refused because a hidden, still-mounted conversation was counted.
+  - Attachments did not recognize timestamp-renamed uploads, picked a hidden composer form, and ran before the file input existed.
+  - Leftover chips were no longer detected.
+  - Composer tools were looked up or clicked before they worked.
+- Found by a live matrix against the installed 0.40.25, where `--project` sends, project attachments, new-chat attachments after a repeat upload and `--tool create-image` failed.
+
+**Installation on 2026-10-06**
+- Global npm, each verified with `prodex --version` = 0.40.26.
+- WSL, M3, Mac mini: installed. Running services were not restarted: 11 stdio MCP servers on WSL and 6 on M3 keep older code until their clients reconnect. The Mac mini had none running.
+- M4: not reachable (hostname does not resolve); not updated.
+
+**Live check after install (installed 0.40.26, shared WSL browser)**
+All eight answered:
+- `--project` plain and with `--attach`
+- `--tool create-image`
+- `--new-chat --attach`
+- `--continue --attach`
+- `--tool web-search --attach`
+- `--temporary --attach`
+- plain `--continue`
+
+**Browser container, same day**
+- Before the rebuild, the container build failed the same way: a project send was refused and a new-chat attachment timed out. Its tab then stopped answering CDP.
+- The same fixes were adapted to the branch code, where the transcript reader and the hover-verified tools click differ. The image `sha256:8e5734ee733c` was rebuilt from `b5eac7d` with all patches so far. These are still uncommitted, and nothing was pushed to `feat/headless-browser-compatibility`.
+- Branch suite: 1998 passed. The swap was gated on the send lock being free.
+- Verified in the container, all seven answered:
+  - a project send
+  - a new-chat attachment
+  - an attachment on a continued thread
+  - a project attachment
+  - create-image
+  - web search with an attachment
+  - a temporary chat with an attachment
+- An MCP client reconnect was needed after the swap.
+
+## 0.40.25 Release Record
+
+Release commit `3c66da3` on `main` (cut after PR #15, merge `9bd908c`); tag `v0.40.25`.
+
+**Publishing**
+- `publish.yml` run 37394019059 passed all six platforms on the first attempt, then npm publish with SLSA v1 provenance and the GitHub Release (2026-10-06 00:48 UTC).
+- `npm run release:verify` passed on the release commit after a build.
+
+**What it fixes**
+- A send into an existing conversation from a tab on another one now waits for that page to finish loading.
+
+**Installation on 2026-10-06**
+- Global npm, each verified with `prodex --version` = 0.40.25.
+- WSL, M3, Mac mini: installed. Running services were not restarted: 19 stdio MCP servers on WSL and 7 on M3 keep older code until their clients reconnect. The Mac mini had none running.
+- M4: not reachable (hostname does not resolve); not updated.
+- The browser container already carries the same fix (2026-10-02 rebuild, see 0.40.24). An MCP consult through it answered on 2026-10-06 after the client reconnected.
+
+**Live check after install (installed 0.40.25, shared WSL browser)**
+- The tab was first moved to a new chat.
+- `--continue --attach` answered, with a baseline of 5 earlier user messages.
+- `--new-chat --attach` answered.
+- A plain `--continue` recalled the word set at the start of the thread.
+
+**Real use since 0.40.24 (2026-10-02 to 2026-10-06)**
+- `prodex pro blockers`: 3 of 18 host consults were blocked, all three the probes that reproduced the bugs fixed in 0.40.24 and 0.40.25.
+- 0 of 5 container consults were blocked.
+
 ## 0.40.24 Release Record
 
 Release commit `e927eee` on `main` (cut after PR #14, merge `393f720`); tag `v0.40.24`.

package/package.json

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