termdock 1.4.193 → 1.4.195

package/dist/server/agent/collaborationDeliveryWorker.js

@@ -128,9 +128,13 @@ export class CollaborationDeliveryWorker {
         // rendered it). Unconfirmed writes are re-attempted up to the configured
         // bound; at-least-once transport is preserved throughout.
         const confirmMs = this.options.firstDeliveryConfirmMs ?? 1_500;
+        // A delivery that has already spent its confirm budget still has to be
+        // written — the queue must never wedge — but it settles carrying the
+        // unconfirmed reason instead of looking identical to a confirmed one.
+        const boundReachedUnconfirmed = attempts + 1 >= (this.options.maxUnconfirmedWrites ?? 3);
         const gateActive = Boolean(route.confirm) && confirmMs > 0
             && Date.now() >= (this.confirmedUntil.get(id) ?? 0)
-            && attempts + 1 < (this.options.maxUnconfirmedWrites ?? 3);
+            && !boundReachedUnconfirmed;
         // Differential baseline for stuck-paste recovery: captured before the
         // write so a later screen diff can tell our paste apart from stale ones.
         let baseline = '';
@@ -185,7 +189,7 @@ export class CollaborationDeliveryWorker {
         }
         // If persistence fails after writing, the in-process guard avoids a
         // second write on retry. Across a crash, transport is at-least-once.
-        this.complete(id, message);
+        this.complete(id, message, boundReachedUnconfirmed ? 'AGENT_CONSUME_UNCONFIRMED' : null);
     }
     /** Wait out the confirm window, then look for the written messages in the
      *  recipient's terminal history. A message found there was rendered by the
@@ -223,13 +227,18 @@ export class CollaborationDeliveryWorker {
         }
         return false;
     }
-    complete(id, message) {
+    /** Settle a delivery as delivered. `unconfirmedReason`, when set, is a
+     *  diagnosis that survives the settle: the write reached the pty (there is
+     *  nothing more a retry may do) but the recipient never showed it, so the
+     *  sender can still see why. Never re-queues — that is what would wedge the
+     *  queue and duplicate the body. */
+    complete(id, message, unconfirmedReason = null) {
         const { store } = this.options;
         store.markDelivered([message.id]);
         this.submitted.delete(message.id);
         store.recordTransport(message.id, {
             relay_online: null, peer_reachable: true, attempt_count: store.diagnostic(message.id)?.attempt_count ?? 1,
-            next_retry_at: null, last_error: null, checked_at: Date.now(),
+            next_retry_at: null, last_error: unconfirmedReason, checked_at: Date.now(),
         });
         this.failures.delete(id);
     }

package/dist/server/agent/collaborationPrompt.js

@@ -25,8 +25,21 @@ export function sanitizeCollaborationName(name, max = 40) {
         .trim();
     return cleaned.length > max ? `${cleaned.slice(0, max - 1)}…` : cleaned;
 }
+/** The one line of a delivered block that carries `message.id`, chosen by what
+ *  the recipient can actually do with it: an agent-sourced message gets the
+ *  reply command, a user message gets the read-back command (`td collab reply`
+ *  refuses user messages — NO_REPLY_TARGET — so naming it there would be a dead
+ *  command). The delivery-confirm gate searches the recipient terminal for
+ *  `message.id`, so every message must carry it regardless of source: this
+ *  function is the single place that decides how, and the invariant is pinned
+ *  by the "carries its id" test in collaborationPrompt.test.ts. */
+export function collaborationMessageAnchorLine(message) {
+    return message.fromSessionId
+        ? `回复:td collab reply ${message.id} "回复内容" --text`
+        : `详情:td collab message get ${message.id} --json`;
+}
 /** A single delivered message: `来自:X · kind` over a fenced body, with the
- * reply route for agent-sourced messages kept outside the fence. A fan-out
+ * anchor line (reply route / read-back route) kept outside the fence. A fan-out
  * dispatch (message.fanOutIds present) is flagged `· 群发` and names the
  * sibling recipients on their own line, so a broadcast is never mistaken for
  * a one-to-one assignment — raw ids fall back to the sanitized id itself. */
@@ -37,8 +50,7 @@ function formatCollaborationMessage(message, source, fannedNames, fence) {
     lines.push('', fence, message.content, fence);
     if (message.task)
         lines.push('', `任务上报:${JSON.stringify(message.task)}`);
-    if (message.fromSessionId)
-        lines.push('', `回复:td collab reply ${message.id} "回复内容" --text`);
+    lines.push('', collaborationMessageAnchorLine(message));
     return lines.join('\n');
 }
 export function formatCollaborationDelivery(input) {

package/dist/server/agent/collaborationTmuxDelivery.js

@@ -1,4 +1,4 @@
-import { buildBracketedSubmitBytes } from './promptDelivery.js';
+import { normalizePromptForPaste } from './promptDelivery.js';
 const TMUX_KEY_NAMES = {
     enter: 'Enter', escape: 'Escape', space: 'Space', left: 'Left', right: 'Right', up: 'Up', down: 'Down',
 };
@@ -47,20 +47,56 @@ async function assertSamePane(run, pane) {
 /** Unique-per-process buffer name so concurrent deliveries to different panes
  *  never share (or clobber) a buffer. */
 let bufferSequence = 0;
-export async function writeCollaborationTmuxPane(run, pane, prompt) {
+export async function writeCollaborationTmuxPane(run, pane, prompt, 
+/** Sends `input` to the tmux client's stdin. The steps below are one `\;`
+ *  chain (see the comment inside), and a chain is argv, so the body must not
+ *  ride in argv: tmux treats an element that is exactly `;` as a separator
+ *  even after `--`, and its backslash unescaping is version-dependent
+ *  (`\\` survives verbatim while `\;` collapses to `;`). Reading the body
+ *  from stdin sidesteps both — every byte round-trips unchanged. Required,
+ *  not optional: a run() that ignored the payload would load an empty buffer
+ *  and fail the delivery rather than deliver the wrong thing. */
+stdin) {
     await assertSamePane(run, pane);
     // A fixed pane target is independent of the current window, keyboard focus
     // and browser presence. Delivery goes through a named tmux buffer rather
     // than `send-keys -l`: while a pane is in copy-mode, literal bytes are
     // routed to the mode's key table (they scroll or do nothing) and never
     // reach the app, whereas paste-buffer writes into the pty regardless of
-    // mode and leaves the mode and scroll position untouched. paste-buffer
-    // does not bracket on its own, so the payload carries its own
-    // `\x1b[200~ … \x1b[201~` wrapper plus the submitting CR.
+    // mode and leaves the mode and scroll position untouched.
+    //
+    // The bracketed-paste wrapper is left to tmux (-p) instead of riding in the
+    // payload. tmux adds the pair exactly when the application has bracketed
+    // paste on and adds nothing when it does not — so an agent TUI sees one
+    // paste while a plain shell sees clean text — and the marker bytes never
+    // enter the buffer, where tmux 3.7+ would run them through vis(3) and land
+    // a literal `^[` in the pane instead of a control byte. The same vis pass
+    // is why the body must carry no ESC: escape bytes are exactly what it
+    // rewrites, and an ESC-free body makes the pass a byte-for-byte no-op on
+    // every tmux version.
     const buffer = `termdock-collab-${process.pid}-${bufferSequence++}`;
     try {
-        await run(['set-buffer', '-b', buffer, '--', buildBracketedSubmitBytes(prompt)]);
-        await run(['paste-buffer', '-d', '-b', buffer, '-t', pane.paneId]);
+        // The four steps ride one client invocation joined by tmux's `\;`: the
+        // server runs them back to back in a single queue item, so no other
+        // client's paste can interleave between our text and our submit CR
+        // (measured: one contiguous block, 0ms apart, versus two invocations
+        // ~14ms apart). A failing step stops the rest — verified on 3.4 and 3.7 —
+        // which is the safe direction: a failed text paste is never followed by a
+        // bare CR into whatever the input box already held.
+        await stdin([
+            // The body arrives on stdin, not argv: it is user content, and in a
+            // `\;` chain argv is a language where `;` and `\` mean something.
+            'load-buffer', '-b', buffer, '-', ';',
+            // -r keeps LF as LF rather than the separator default of CR. The
+            // normalizer already folded every line break to CR, so no LF is left
+            // for it to rewrite — the flag is insurance, not the mechanism.
+            'paste-buffer', '-p', '-r', '-d', '-b', buffer, '-t', pane.paneId, ';',
+            // The submit key rides outside the paste block: inside it, an editor
+            // inserts a pasted CR as text instead of acting on it. Pasting the bare
+            // CR (no -p) keeps the key in the same mode-proof channel as the text.
+            'set-buffer', '-b', buffer, '--', '\r', ';',
+            'paste-buffer', '-d', '-b', buffer, '-t', pane.paneId,
+        ], normalizePromptForPaste(prompt));
     }
     finally {
         // -d consumed the buffer on the happy path; this sweeps up after a failed

package/dist/server/agent/promptDelivery.js

@@ -1,12 +1,20 @@
+/**
+ * Fold a prompt into the single-channel form both tmux and agent TUIs expect:
+ * every line break becomes one CR (commits a line inside the editor, and is
+ * never a paste-end candidate), and a raw ESC becomes the visible ␛ glyph so
+ * no byte sequence in the body can be mistaken for terminal control — notably
+ * not our own bracketed-paste markers.
+ */
+export function normalizePromptForPaste(prompt) {
+    return prompt.replace(/\r\n|\r|\n/g, '\r').replace(/\x1b/g, '␛');
+}
 /**
  * Encode a prompt as one bracketed-paste block followed by one real Enter.
  * Agent TUIs then keep embedded newlines inside the editor instead of treating
  * each line as a separate submission.
  */
 export function buildBracketedSubmitBytes(prompt) {
-    const normalized = prompt.replace(/\r\n|\r|\n/g, '\r');
-    const escaped = normalized.replace(/\x1b/g, '␛');
-    return `\x1b[200~${escaped}\x1b[201~\r`;
+    return `\x1b[200~${normalizePromptForPaste(prompt)}\x1b[201~\r`;
 }
 /**
  * Process detection and hook events are independent Agent signals. A target is

package/dist/server/routes/terminal.js

@@ -1610,7 +1610,7 @@ async function resolveCollaborationRoute(frontendSessionId) {
         return { state: 'ready', capture: async () => (await captureTmuxPane(pinned.paneId)).content, write: async (messages) => {
                 if (!globalSessionState.sessions.some((candidate) => candidate.sessionId === frontendSessionId))
                     throw new Error('SESSION_REMOVED');
-                await writeCollaborationTmuxPane(runTmux, pinned, formatLocalCollaborationMessages(frontendSessionId, messages));
+                await writeCollaborationTmuxPane(runTmux, pinned, formatLocalCollaborationMessages(frontendSessionId, messages), runTmuxStdin);
                 backend.lastActivity = Date.now();
                 // First-delivery confirm: history proves the agent rendered our
                 // message (boot sequences clear only the screen, never the history a
@@ -1735,6 +1735,32 @@ async function runTmux(args) {
     });
     return stdout;
 }
+/** runTmux with a payload on the client's stdin — how delivery hands user
+ *  content to `load-buffer -`. Kept separate from runTmux so the many callers
+ *  that never pipe anything are untouched. */
+async function runTmuxStdin(args, input) {
+    const child = execFile(getTmuxBinary(), args, {
+        timeout: 5000,
+        maxBuffer: 2 * 1024 * 1024,
+        env: buildInteractiveColorEnvironment(process.env),
+    });
+    // Write then end: tmux reads stdin to EOF for `load-buffer -`.
+    child.stdin?.end(input);
+    const { stdout } = await new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => { stdout += chunk; });
+        child.stderr?.on('data', (chunk) => { stderr += chunk; });
+        child.on('error', reject);
+        child.on('close', (code) => (code === 0
+            ? resolve({ stdout })
+            // Carry tmux's own message: it names the failing step ("no buffer X",
+            // "target pane has exited"), which is what makes a delivery failure
+            // diagnosable from the transport diagnostic alone.
+            : reject(new Error(`tmux exited with ${code}${stderr.trim() ? `: ${stderr.trim()}` : ''}`))));
+    });
+    return stdout;
+}
 // ---- Persistent tmux control-mode connection ----
 // Instead of spawning a new `tmux` process per command (execFile overhead),
 // maintain a single `tmux -C attach` child process per session.  Commands
@@ -5781,7 +5807,7 @@ router.post('/operations/orchestration/drive', async (req, res) => {
                 return res.status(400).json({ error: 'run 文本过长（上限 10000 字符）；需要更多内容请走 td collab send 投递' });
             // Same bracketed-paste write path deliveries use: one line, one submit,
             // embedded newlines stay inside the recipient's editor.
-            await writeCollaborationTmuxPane(runTmux, pane, text);
+            await writeCollaborationTmuxPane(runTmux, pane, text, runTmuxStdin);
             const snapshot = await captureTmuxPaneText(runTmux, pane);
             return res.json({ ok: true, action, sessionId: target, text, snapshot });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.193",
+  "version": "1.4.195",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",

package/runtime-manifest.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.193",
+  "version": "1.4.195",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-grEE01C40LqZFNdPE78QJXxG3gYtDw6ADT1aW+lm58I=",
+  "serverBundleHash": "sha256-T9Yr6kyM0VWWMdS6LFYinasOYunqdstwvkzVg2zQqZE=",
   "clientBundleHash": "sha256-wpGsT/oJup/G4MyJSKqpHBJlzc2Ha3wFIWmtp4vc/Wc=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"