termdock 1.4.191 → 1.4.192

package/dist/server/agent/collaborationDeliveryWorker.js

@@ -4,11 +4,14 @@ export class CollaborationDeliveryWorker {
     states = new Map();
     failures = new Map();
     submitted = new Set();
-    /** Sessions whose first delivery was confirmed consumed (or settled) in
-     *  this process. Only first deliveries pass the confirm gate — a write to
-     *  an agent that has been interacting is consumed by definition of pty
-     *  semantics, and every delivery after the first rides that assumption. */
-    confirmedSessions = new Set();
+    /** Sessions whose latest delivery was confirmed rendered in this process,
+     *  mapped to the timestamp until which confirmations are skipped. A recent
+     *  confirmed delivery means the agent is actively consuming input, so
+     *  follow-up messages settle immediately; once the cooldown lapses the
+     *  agent's state is unknown again (it may be mid-turn, or finishing one)
+     *  and the gate re-engages. Settled-but-unconfirmed deliveries never grant
+     *  cooldown — that would re-open the turn-handover hole the gate closes. */
+    confirmedUntil = new Map();
     timer = null;
     ticking = null;
     constructor(options) {
@@ -117,6 +120,28 @@ export class CollaborationDeliveryWorker {
         }
         const message = pending[0];
         const attempts = store.diagnostic(message.id)?.attempt_count ?? 0;
+        // Confirm gate: the route becoming ready only proves the agent process is
+        // up, not that its TUI is consuming — a write landing while the agent
+        // finishes another turn can sit unsubmitted in its input box. When the
+        // route can read terminal history, hold deliveries outside the session's
+        // confirm cooldown until our message appears in the history (the agent
+        // 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;
+        const gateActive = Boolean(route.confirm) && confirmMs > 0
+            && Date.now() >= (this.confirmedUntil.get(id) ?? 0)
+            && attempts + 1 < (this.options.maxUnconfirmedWrites ?? 3);
+        // 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 = '';
+        if (gateActive && route.recoverStuck && !this.submitted.has(message.id) && route.capture) {
+            try {
+                baseline = (await route.capture()) ?? '';
+            }
+            catch {
+                baseline = '';
+            }
+        }
         if (!this.submitted.has(message.id)) {
             store.recordTransport(message.id, {
                 relay_online: null, peer_reachable: true,
@@ -143,18 +168,8 @@ export class CollaborationDeliveryWorker {
                 catch { /* best-effort */ }
             }
         }
-        // First-delivery confirm gate: the route becoming ready only proves the
-        // agent process is up, not that its TUI is reading — a write inside the
-        // boot window can be wiped by the startup clear while the message is
-        // already marked delivered. When the route can read terminal history,
-        // hold the first delivery until our message actually appears there (the
-        // agent rendered it), dismissing any approval dialog blocking the agent
-        // on the way. Unconfirmed writes are re-attempted up to the configured
-        // bound; at-least-once transport is preserved throughout.
-        const confirmMs = this.options.firstDeliveryConfirmMs ?? 1_500;
-        if (route.confirm && confirmMs > 0 && !this.confirmedSessions.has(id)
-            && attempts + 1 < (this.options.maxUnconfirmedWrites ?? 3)) {
-            if (!(await this.confirmConsumed(pending, route, confirmMs))) {
+        if (gateActive) {
+            if (!(await this.confirmConsumed(pending, route, confirmMs, baseline))) {
                 this.submitted.delete(message.id);
                 store.recordTransport(message.id, {
                     relay_online: null, peer_reachable: true,
@@ -164,17 +179,24 @@ export class CollaborationDeliveryWorker {
                 this.failures.delete(id);
                 return;
             }
+            // Confirmed rendered: refresh the exemption window so follow-ups in the
+            // agent's active turn settle immediately.
+            this.confirmedUntil.set(id, Date.now() + (this.options.confirmCooldownMs ?? 30_000));
         }
         // 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);
     }
     /** Wait out the confirm window, then look for the written messages in the
-     *  recipient's terminal history. While the agent is blocked on an approval
-     *  dialog (its first Bash call needs permission) dismiss it once per cycle
-     *  — the delivery itself told the agent to run td collab, and the pane
-     *  must show an actual dialog for the key to be sent. */
-    async confirmConsumed(messages, route, delayMs) {
+     *  recipient's terminal history. A message found there was rendered by the
+     *  agent and counts as consumed. While the agent is blocked on an approval
+     *  dialog (its Bash call needs permission) dismiss it once per cycle, and
+     *  on the first cycle submit a paste that arrived during turn handover and
+     *  is still sitting unsubmitted (differential baseline evidence only, at
+     *  most once per delivery). Each recovery sends Enter on evidence, never
+     *  blind. */
+    async confirmConsumed(messages, route, delayMs, baseline) {
+        let recovered = false;
         for (let attempt = 0; attempt < 3; attempt += 1) {
             await new Promise((resolve) => setTimeout(resolve, attempt === 0 ? delayMs : Math.min(1_200, delayMs)));
             let content = null;
@@ -186,6 +208,12 @@ export class CollaborationDeliveryWorker {
             }
             if (content && messages.some((message) => content.includes(message.id)))
                 return true;
+            if (!recovered && route.recoverStuck && baseline) {
+                try {
+                    recovered = await route.recoverStuck(baseline);
+                }
+                catch { /* a failed submit must not settle delivery */ }
+            }
             if (content && route.approve) {
                 try {
                     await route.approve();
@@ -197,7 +225,6 @@ export class CollaborationDeliveryWorker {
     }
     complete(id, message) {
         const { store } = this.options;
-        this.confirmedSessions.add(id);
         store.markDelivered([message.id]);
         this.submitted.delete(message.id);
         store.recordTransport(message.id, {

package/dist/server/agent/collaborationTmuxDelivery.js

@@ -18,9 +18,26 @@ const APPROVAL_DIALOG_PATTERNS = [
     /\b1\.\s*是\b/,
     /允许.*执行|确认.*执行/i,
 ];
+/** Agent TUIs collapse pasted input in the input box to a marker line like
+ * "[Pasted text #3 +42 lines]". While the paste sits unsubmitted the marker
+ * stays on screen; a submitted paste clears the box and only the transcript
+ * holds the content. Session-unique #N lets us diff screen captures. */
+const PASTE_MARKER_PATTERN = /\[Pasted text #(\d+)/g;
 export function detectApprovalDialog(content) {
     return APPROVAL_DIALOG_PATTERNS.some((pattern) => pattern.test(content));
 }
+/** Paste marker sequence numbers visible in a screen capture. */
+export function extractPasteMarkerNumbers(content) {
+    return new Set([...content.matchAll(PASTE_MARKER_PATTERN)].map((match) => Number(match[1])));
+}
+/** True when `after` shows a paste marker that was not in `before`. Diffing
+ * prevents a recovery Enter from submitting a stale paste that predates this
+ * delivery (or someone else's draft): we only ever submit what we just put
+ * there, at most once per delivery. */
+export function hasNewPasteMarker(after, before) {
+    const beforeNumbers = extractPasteMarkerNumbers(before);
+    return [...extractPasteMarkerNumbers(after)].some((number) => !beforeNumbers.has(number));
+}
 async function assertSamePane(run, pane) {
     const identity = (await run(['display-message', '-p', '-t', pane.paneId,
         '#{pid}:#{session_id}:#{pane_id}:#{pane_pid}'])).trim();
@@ -56,6 +73,19 @@ export async function approveCollaborationDialog(run, pane) {
     await sendTmuxPaneKey(run, pane, 'enter');
     return true;
 }
+/** Submit a paste that arrived while the agent was finishing its previous
+ *  turn and is still sitting unsubmitted in the input box. Only acts on
+ *  differential evidence — a paste marker that appeared after the write —
+ *  never on pre-existing stale markers, and returns whether Enter was sent.
+ *  Committing the whole input buffer is safe: each delivery is written once,
+ *  so each marker's content enters the transcript exactly once. */
+export async function recoverStuckPaste(run, pane, baseline) {
+    const viewport = await captureTmuxPaneText(run, pane);
+    if (!hasNewPasteMarker(viewport, baseline))
+        return false;
+    await sendTmuxPaneKey(run, pane, 'enter');
+    return true;
+}
 /** History-inclusive pane text (scrollback + viewport) used to confirm a
  *  delivery was actually rendered by the agent, not wiped by a boot clear. */
 export async function captureTmuxPaneHistory(run, pane, lines = 800) {

package/dist/server/routes/terminal.js

@@ -45,7 +45,7 @@ import { SessionSearchStore } from '../agent/sessionSearchStore.js';
 import { resolveCollaborationBackend, resolveCollaborationSessionId } from '../agent/sessionBindingRecovery.js';
 import { CollaborationRoutingStore, selectCollaborationPane } from '../agent/collaborationRouting.js';
 import { CollaborationDeliveryWorker } from '../agent/collaborationDeliveryWorker.js';
-import { approveCollaborationDialog, captureTmuxPaneHistory, captureTmuxPaneText, sendTmuxPaneKey, writeCollaborationTmuxPane } from '../agent/collaborationTmuxDelivery.js';
+import { approveCollaborationDialog, captureTmuxPaneHistory, captureTmuxPaneText, recoverStuckPaste, sendTmuxPaneKey, writeCollaborationTmuxPane } from '../agent/collaborationTmuxDelivery.js';
 import { listAllHookAgents, refreshStaleHooksAtLaunch, installHooksForSlug, uninstallHooksForSlug, } from '../agent/installers.js';
 import { loadPlugins, savePlugin, removePlugin, readPluginIcon, validateManifest, } from '../agent/plugins.js';
 import { TmuxLifecycleCoordinator } from '../utils/tmuxLifecycle.js';
@@ -1604,7 +1604,8 @@ async function resolveCollaborationRoute(frontendSessionId) {
                 // First-delivery confirm: history proves the agent rendered our
                 // message (boot sequences clear only the screen, never the history a
                 // live TUI writes into). Terminal-state only — no agent hooks.
-            }, confirm: async () => captureTmuxPaneHistory(runTmux, pinned), approve: async () => approveCollaborationDialog(runTmux, pinned) };
+            }, confirm: async () => captureTmuxPaneHistory(runTmux, pinned), approve: async () => approveCollaborationDialog(runTmux, pinned),
+            recoverStuck: async (baseline) => recoverStuckPaste(runTmux, pinned, baseline) };
     }
     if (!backend || !binding.backendSessionId)
         return { state: 'offline', reason: 'SHELL_BACKEND_NOT_RUNNING' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.191",
+  "version": "1.4.192",
   "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.191",
+  "version": "1.4.192",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-36ZcNv3lgwTbxmDk01fEKtfGW25R0K5dUN3m9bbhPeU=",
+  "serverBundleHash": "sha256-jIRqCSStnF2/E81Q9GtAEeXAsshmnR4UUDtExjgLex0=",
   "clientBundleHash": "sha256-wpGsT/oJup/G4MyJSKqpHBJlzc2Ha3wFIWmtp4vc/Wc=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"