termdock 1.4.192 → 1.4.194

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/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

@@ -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',
 };
@@ -44,16 +44,59 @@ async function assertSamePane(run, pane) {
     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.
+    //
+    // 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, '--', normalizePromptForPaste(prompt)]);
+        // -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.
+        await run(['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.
+        await run(['set-buffer', '-b', buffer, '--', '\r']);
+        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. */
@@ -70,6 +113,8 @@ 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;
 }

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

@@ -43,7 +43,7 @@ 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, recoverStuckPaste, sendTmuxPaneKey, writeCollaborationTmuxPane } from '../agent/collaborationTmuxDelivery.js';
 import { listAllHookAgents, refreshStaleHooksAtLaunch, installHooksForSlug, uninstallHooksForSlug, } from '../agent/installers.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 () => {
@@ -5726,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.192",
+  "version": "1.4.194",
   "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.192",
+  "version": "1.4.194",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-K4KyYJuVoQDpZsBM8ZX1Rw3MddOxAzVdp/cPm0iGZz0=",
-  "serverBundleHash": "sha256-jIRqCSStnF2/E81Q9GtAEeXAsshmnR4UUDtExjgLex0=",
+  "serverBundleHash": "sha256-2Y3XSbsDOzYXhEe57Szt3L16aZzGBDb1ZA/6TsYIiOQ=",
   "clientBundleHash": "sha256-wpGsT/oJup/G4MyJSKqpHBJlzc2Ha3wFIWmtp4vc/Wc=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"