termdock 1.4.191 → 1.4.193

package/dist/server/agent/collaborationCli.js

@@ -39,8 +39,11 @@ export const COLLAB_HELP = `td collab — durable messages; no agent-specific ho
     operations are shell operations: approve dismisses an interactive approval
     dialog and refuses unless one is actually showing; named keys inject one
     key; capture reads the current screen back; run submits one line and
-    returns the screen. Cannot target your own session. Treat every drive as
-    strong control: the member's shell executes what you send.)
+    returns the screen. Works on plain shell members too (no agent needed) for
+    run/capture; key actions (approve/enter/…) require an agent pane, and are
+    refused while the user has the pane scrolled into copy-mode. Cannot target
+    your own session. Treat every drive as strong control: the member's shell
+    executes what you send.)
   cleanup <session-id>… 移除协作会话并终止其 tmux/进程（仅限与你同组的会话；
     不能清理当前会话自身，也不能通过清理解散你所在的组）
     风险操作：默认只打印清理计划并拒绝执行（exit 1）——这是不可恢复的删除。

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/collaborationRouting.js

@@ -92,3 +92,19 @@ export function selectCollaborationPane(binding, panes) {
     return matches.length > 1 ? { state: 'ambiguous', reason: 'MULTIPLE_AGENT_PANES' }
         : { state: 'agent-exited', reason: 'AGENT_NOT_RUNNING_OR_IDENTITY_CHANGED' };
 }
+/** Drive-side pane resolution. Message delivery needs an Agent (only a TUI
+ *  consumes the formatted prompt, and the confirm gate searches its
+ *  transcript), but driving is a terminal operation — `run` submits one line
+ *  and `capture` reads the screen, both of which a plain shell answers. So an
+ *  Agent pane wins when one is selectable, and the session's own pane is the
+ *  fallback when there is nothing but a shell. The caller still re-asserts
+ *  pane identity on every write. */
+export function selectDrivePane(binding, panes, activePaneId) {
+    const agent = selectCollaborationPane(binding, panes);
+    if (agent.state === 'ready' && agent.pane?.agentSlug)
+        return agent;
+    const plain = panes.find((pane) => pane.paneId === activePaneId) ?? panes[0];
+    if (!plain)
+        return agent;
+    return { state: 'ready', pane: plain };
+}

package/dist/server/agent/collaborationTmuxDelivery.js

@@ -18,25 +18,69 @@ 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();
     if (identity !== `${pane.serverPid}:${pane.sessionId}:${pane.paneId}:${pane.panePid}`)
         throw new Error('TMUX_PANE_CHANGED');
 }
+/** 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) {
     await assertSamePane(run, pane);
     // A fixed pane target is independent of the current window, keyboard focus
-    // and browser presence. One invocation preserves the bracketed submit bytes.
-    await run(['send-keys', '-t', pane.paneId, '-l', '--', buildBracketedSubmitBytes(prompt)]);
+    // 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.
+    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]);
+    }
+    finally {
+        // -d consumed the buffer on the happy path; this sweeps up after a failed
+        // paste so no stray buffer is left on the server.
+        await run(['delete-buffer', '-b', buffer]).catch(() => undefined);
+    }
+}
+/** True while the pane is in any tmux mode (copy-mode, choose-tree, …), i.e.
+ *  keys sent to it are consumed by the mode handler instead of the app. */
+export async function paneInMode(run, pane) {
+    return (await run(['display-message', '-p', '-t', pane.paneId, '#{pane_in_mode}'])).trim() === '1';
 }
 /** Inject a named key into a member pane after proving the pane identity
- *  unchanged. Named keys only — no freeform keystroke passthrough. */
+ *  unchanged. Named keys only — no freeform keystroke passthrough. Refuses
+ *  while the pane is in a mode: there the key would be taken by the mode
+ *  handler (Enter in copy-mode exits the user's scroll) rather than the app. */
 export async function sendTmuxPaneKey(run, pane, key) {
     await assertSamePane(run, pane);
+    if (await paneInMode(run, pane))
+        throw new Error('TMUX_PANE_IN_MODE');
     await run(['send-keys', '-t', pane.paneId, TMUX_KEY_NAMES[key]]);
 }
 /** Current pane screen text (viewport), identity-checked. */
@@ -53,6 +97,21 @@ export async function approveCollaborationDialog(run, pane) {
     const content = await captureTmuxPaneText(run, pane);
     if (!detectApprovalDialog(content))
         return false;
+    // sendTmuxPaneKey refuses in-mode panes, so a dialog-looking screen behind a
+    // user's scroll never turns Enter into copy-mode navigation.
+    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;
 }

package/dist/server/routes/terminal.js

@@ -43,9 +43,9 @@ import { COLLAB_NAME_FORBIDDEN, formatCollaborationDelivery } from '../agent/col
 import { buildCollaborationSpawnCommand, resolveCollaborationSpawnMode } from '../agent/collaborationSpawn.js';
 import { SessionSearchStore } from '../agent/sessionSearchStore.js';
 import { resolveCollaborationBackend, resolveCollaborationSessionId } from '../agent/sessionBindingRecovery.js';
-import { CollaborationRoutingStore, selectCollaborationPane } from '../agent/collaborationRouting.js';
+import { CollaborationRoutingStore, selectCollaborationPane, selectDrivePane } 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';
@@ -1478,7 +1478,12 @@ function formatLocalCollaborationMessages(frontendSessionId, messages) {
         showRoutingHelp,
     });
 }
-async function inspectCollaborationTmux(binding, requestedPane) {
+/** `allowPlainPane` widens the candidate set from "an Agent owns the pane" to
+ *  "the session's pane exists": a plain shell member has no agentSlug, so the
+ *  agent-keyed selector can never reach it. Delivery still needs an agent (the
+ *  confirm gate and prompt formatting assume a TUI); driving a terminal —
+ *  run/capture — is a shell operation and works on any pane. */
+async function inspectCollaborationTmux(binding, requestedPane, allowPlainPane = false) {
     if (!binding.tmuxSessionName)
         return { state: 'offline', reason: 'TMUX_BINDING_MISSING' };
     const name = `=${binding.tmuxSessionName}`;
@@ -1504,7 +1509,13 @@ async function inspectCollaborationTmux(binding, requestedPane) {
         return { serverPid, sessionId: layout.sessionId, paneId: pane.id, panePid: pane.pid,
             agentSlug: agent?.slug ?? '', nativeSessionId, cwd: pane.currentPath };
     }));
-    return selectCollaborationPane(binding, requestedPane ? panes.filter((pane) => pane.paneId === requestedPane) : panes);
+    const candidates = requestedPane ? panes.filter((pane) => pane.paneId === requestedPane) : panes;
+    if (allowPlainPane && !binding.pane) {
+        // No pinned pane: prefer an Agent pane, fall back to the session's own
+        // pane so a plain shell member is drivable (run/capture are shell ops).
+        return selectDrivePane(binding, candidates, layout.activePaneId);
+    }
+    return selectCollaborationPane(binding, candidates);
 }
 async function rebindCollaborationRoute(frontendSessionId, paneId) {
     await collaborationDeliveryWorker.reconfigure(frontendSessionId, async () => {
@@ -1604,7 +1615,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' };
@@ -5725,9 +5737,31 @@ router.post('/operations/orchestration/drive', async (req, res) => {
         return res.status(409).json({ error: '目标会话不是 tmux 会话，无法从 CLI 驱动（模式：' + (record.mode ?? 'unknown') + '）' });
     }
     const binding = collaborationRouting.get(target);
-    const pane = binding?.pane ?? null;
-    if (!pane)
-        return res.status(409).json({ error: '目标会话还没有可驱动的已固定终端面板（agent 可能尚未启动或已离线）' });
+    let pane = binding?.pane ?? null;
+    if (!pane) {
+        // No pinned Agent pane: resolve the session's pane directly so a plain
+        // shell member is drivable. The actions below are terminal operations —
+        // run and capture are exactly what a general terminal offers.
+        try {
+            const inspected = await inspectCollaborationTmux(binding ?? { sessionId: target, backendSessionId: null, mode: record.mode,
+                tmuxSessionName: record.tmuxSessionName, agentSlug: null, nativeSessionId: null, pane: null }, null, true);
+            pane = inspected.pane ?? null;
+        }
+        catch (error) {
+            return res.status(409).json({ ok: false, code: 'DRIVE_FAILED', error: getErrorMessage(error) });
+        }
+        if (!pane)
+            return res.status(409).json({ error: '目标会话还没有可驱动的终端面板（tmux 会话可能已退出）' });
+        // Deliberately not written back to the routing store: that store drives
+        // message delivery, where a plain pane has no agent to consume anything.
+        // Each drive re-resolves and assertSamePane still guards the write.
+    }
+    // Keys are for Agents: `run` submits its own line, while a bare Enter would
+    // commit whatever draft the user has typed into a plain shell. Approving a
+    // dialog only makes sense where dialogs appear, too.
+    if (!pane.agentSlug && (action === 'approve' || DRIVE_KEYS.has(action))) {
+        return res.status(409).json({ ok: false, code: 'DRIVE_REQUIRES_AGENT', error: '目标面板是纯终端（无 agent），只支持 run/capture；按键类动作需要 agent 面板' });
+    }
     try {
         if (action === 'approve') {
             const approved = await approveCollaborationDialog(runTmux, pane);

package/package.json

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