@youdie006/prodex 0.40.24 → 0.40.26

package/dist/chatgpt-browser.js

@@ -192,12 +192,18 @@ export const CHATGPT_BLOCKER_SCAN_EXCLUDED_ANCESTORS = `${'[data-message-author-
  * attribute went with it; where it is absent the model is simply not known.
  */
 const CHATGPT_MESSAGE_NODES_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) => {
@@ -1942,6 +1948,10 @@ export function chatGptThreadReadyExpression(conversationId) {
     const current = new URL(location.href);
     const match = /\\/c\\/([0-9a-f-]{16,})\\/?$/i.exec(current.pathname);
     if (current.origin !== "https://chatgpt.com" || match?.[1].toLowerCase() !== ${JSON.stringify(conversationId.toLowerCase())}) return false;
+    // A thread document that is still loading already has its URL and the
+    // server-rendered editor, but no file inputs or messages yet (measured:
+    // 0.6 s after navigating, complete at 6.7 s).
+    if (document.readyState !== "complete") return false;
     return Boolean(findChatGptComposerCandidate());
   })()`;
 }
@@ -5105,6 +5115,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
@@ -5136,7 +5169,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;
@@ -5145,7 +5179,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;
       }
@@ -5163,9 +5197,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 };
   })()`;
 }
@@ -5193,24 +5232,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)
@@ -5402,20 +5460,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);

package/docs/releasing.md

@@ -16,6 +16,59 @@ 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.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`.
+
+**Publishing**
+- `publish.yml` run 36975443077 passed all six platforms on the first attempt, then npm publish with SLSA v1 provenance and the GitHub Release (2026-10-02 07:10 UTC).
+- `npm run release:verify` passed on the release commit after a build.
+
+**What it fixes**
+- Attachments into an existing conversation used a second form on the page that has no prompt editor.
+
+**Installation on 2026-10-02**
+- Global npm, each verified with `prodex --version` = 0.40.24.
+- WSL, M3, Mac mini: installed. Running services were not restarted: 5 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.
+
+**Live check after install (installed 0.40.24, shared WSL browser)**
+- `--new-chat --attach` answered.
+- `--continue --attach` failed with "composer has no file input" when the tab started on another conversation. When the tab was already on the target thread it had passed.
+- Cause: the conversation page was used before it finished loading. Fixed in the next change.
+
+**Browser container, same day**
+- Image `sha256:2a2091354d90`, rebuilt from `b5eac7d` with the earlier uncommitted patches plus two more: the composer-form file input lookup and the loaded-document requirement for thread readiness.
+- Full suite 1989 passed on the patched tree. The swap was gated on the send lock being free.
+- Verified in the container: `--continue --attach` from another thread answered, and so did `--new-chat --attach`.
+
 ## 0.40.23 Release Record
 
 Release commit `1c905e3` on `main` (cut after PR #13, merge `92c26ce`); tag `v0.40.23`.

package/package.json

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