botmux 2.24.5 → 2.24.6

package/dist/utils/transient-snapshot.js

@@ -0,0 +1,96 @@
+/**
+ * Transient snapshot helper for tmux pipe-pane sessions.
+ *
+ * Instead of accumulating PTY data into a long-lived xterm-headless instance
+ * (the legacy renderer path), we ask tmux for a fresh ANSI snapshot of the
+ * current pane viewport and feed it to a throwaway xterm-headless that gets
+ * disposed immediately after we read it.
+ *
+ * Why: the long-lived buffer accumulates errors over time —
+ *   - drift if the headless cols/rows don't match the real pane (web client
+ *     resize changes the real pane via tmux resize-window, but the headless
+ *     stays at spawn-time dimensions),
+ *   - leftover history from before alt-buffer switches that the long buffer
+ *     never strictly cleared,
+ *   - cursor-positioning sequences emitted by the CLI landing at the wrong
+ *     coordinates when the headless terminal is narrower than the real pane.
+ *
+ * Tmux's own state IS the authoritative current screen — capture-pane returns
+ * what the user actually sees in their terminal. Seeding a fresh xterm-headless
+ * with this snapshot every screenshot/screen-update means there is no
+ * accumulated state to drift.
+ */
+import xtermHeadless from '@xterm/headless';
+const { Terminal } = xtermHeadless;
+import { TmuxPipeBackend } from '../adapters/backend/tmux-pipe-backend.js';
+import { readViewportText } from './terminal-renderer.js';
+import { captureToPng } from './screenshot-renderer.js';
+import { clamp, MIN_RENDER_COLS, MAX_RENDER_COLS, MIN_RENDER_ROWS, MAX_RENDER_ROWS } from './render-dimensions.js';
+/** Attempt to capture a fresh ANSI snapshot from a TmuxPipeBackend. Returns
+ *  null if the backend isn't a pipe backend, the pane has gone away, or
+ *  tmux refuses to answer. Callers should fall back to the legacy renderer
+ *  path on null. */
+export function tryCapturePipeSnapshot(backend, fallbackCols, fallbackRows) {
+    if (!(backend instanceof TmuxPipeBackend))
+        return null;
+    const live = backend.getPaneSize();
+    const cols = clamp(live?.cols ?? fallbackCols, MIN_RENDER_COLS, MAX_RENDER_COLS);
+    const rows = clamp(live?.rows ?? fallbackRows, MIN_RENDER_ROWS, MAX_RENDER_ROWS);
+    // Viewport-only capture: same number of rows as the transient terminal,
+    // so the snapshot never overflows and triggers a normal-buffer scroll.
+    const ansi = backend.captureViewport();
+    if (!ansi)
+        return null;
+    return { cols, rows, ansi };
+}
+/** Feed an ANSI snapshot into a transient xterm-headless and yield the
+ *  terminal once tmux's bytes have been consumed by the parser. Caller MUST
+ *  dispose() the terminal when done. */
+async function buildTransientTerminal(snap) {
+    const terminal = new Terminal({ cols: snap.cols, rows: snap.rows, allowProposedApi: true });
+    // xterm.write() with a callback resolves after the async parser has fully
+    // consumed the chunk. Without awaiting this, reading the buffer can race
+    // and pick up partial state mid-parse.
+    await new Promise(resolve => terminal.write(snap.ansi, () => resolve()));
+    return terminal;
+}
+/** Render a tmux pipe-pane snapshot to a PNG buffer. Returns null when the
+ *  backend can't provide a snapshot — caller falls back to the legacy
+ *  long-lived-renderer path. */
+export async function snapshotToPng(backend, fallbackCols, fallbackRows) {
+    const snap = tryCapturePipeSnapshot(backend, fallbackCols, fallbackRows);
+    if (!snap)
+        return null;
+    const terminal = await buildTransientTerminal(snap);
+    try {
+        // Read the actual viewport — baseY may have shifted if the snapshot
+        // ended with a newline that triggered a normal-buffer scroll. We want
+        // the *current* visible rows, not buffer rows 0..N-1 which may be
+        // stale scrollback after that scroll.
+        const startY = terminal.buffer.active.baseY;
+        const png = captureToPng(terminal, { cols: snap.cols, rows: snap.rows, startY });
+        return { png, ansi: snap.ansi };
+    }
+    finally {
+        terminal.dispose();
+    }
+}
+/** Render a tmux pipe-pane snapshot to filtered text (drops the bare prompt
+ *  + input echo lines, same rules as TerminalRenderer.snapshot()). Returns
+ *  null when the backend can't provide a snapshot. */
+export async function snapshotToText(backend, fallbackCols, fallbackRows, opts) {
+    const snap = tryCapturePipeSnapshot(backend, fallbackCols, fallbackRows);
+    if (!snap)
+        return null;
+    const terminal = await buildTransientTerminal(snap);
+    try {
+        // Read from the actual current viewport (see snapshotToPng comment).
+        const startY = terminal.buffer.active.baseY;
+        const content = readViewportText(terminal, { filter: opts.filter, startY, rows: snap.rows });
+        return { content, ansi: snap.ansi };
+    }
+    finally {
+        terminal.dispose();
+    }
+}
+//# sourceMappingURL=transient-snapshot.js.map

package/dist/utils/transient-snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transient-snapshot.js","sourceRoot":"","sources":["../../src/utils/transient-snapshot.ts"],"names":[],"mappings":"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"}

package/dist/worker.js

@@ -29,13 +29,14 @@ import { TerminalRenderer } from './utils/terminal-renderer.js';
 import { DEFAULT_RENDER_COLS, DEFAULT_RENDER_ROWS, MAX_RENDER_COLS, MAX_RENDER_ROWS, MIN_RENDER_COLS, MIN_RENDER_ROWS, clamp, resolveRenderDimensions, } from './utils/render-dimensions.js';
 import { createCliAdapterSync } from './adapters/cli/registry.js';
 import { claudeJsonlPathForSession, resolveJsonlFromPid, findOpenClaudeSessionIds } from './adapters/cli/claude-code.js';
-import { PtyBackend } from './adapters/backend/pty-backend.js';
 import { TmuxBackend } from './adapters/backend/tmux-backend.js';
 import { TmuxPipeBackend } from './adapters/backend/tmux-pipe-backend.js';
+import { selectSessionBackend } from './adapters/backend/session-backend-selector.js';
 import { tmuxEnv } from './setup/ensure-tmux.js';
 import { IdleDetector } from './utils/idle-detector.js';
 import { ScreenAnalyzer } from './utils/screen-analyzer.js';
 import { captureToPng } from './utils/screenshot-renderer.js';
+import { snapshotToPng, snapshotToText } from './utils/transient-snapshot.js';
 import { uploadImageBuffer } from './utils/lark-upload.js';
 import { config } from './config.js';
 import * as sessionStore from './services/session-store.js';
@@ -1574,6 +1575,10 @@ let renderCols = PTY_COLS;
 let renderRows = PTY_ROWS;
 // ─── Headless Terminal for Screen Capture ────────────────────────────────────
 let renderer = null;
+/** Most recent unfiltered viewport text — kept in sync by the screen_update
+ *  timer for pipe-pane backends so ScreenAnalyzer (which is synchronous) has
+ *  a fresh snapshot to read without needing its own tmux capture-pane call. */
+let lastAnalyzerSnapshot = '';
 let screenUpdateTimer = null;
 const SCREEN_UPDATE_INTERVAL_MS = 2_000;
 // ─── Scrollback Buffer (replay to late-connecting WS clients) ───────────────
@@ -1607,7 +1612,14 @@ function startScreenAnalyzer() {
         extraHeaders: sa.extraHeaders,
         extraBody: sa.extraBody,
     }, {
-        getSnapshot: () => renderer?.rawSnapshot() ?? '',
+        getSnapshot: () => {
+            // ScreenAnalyzer is called every ~5s for TUI-prompt detection. We
+            // can't make this async without overhauling the analyzer, so cache
+            // the last pipe-pane text snapshot here and refresh it eagerly.
+            // For pipe-pane backends, the cache is repopulated by the screen
+            // update timer; for others, fall through to the long-lived renderer.
+            return lastAnalyzerSnapshot || renderer?.rawSnapshot() || '';
+        },
         onAnalyzing: () => { },
         onTuiPrompt: (description, options, multiSelect) => {
             tuiPromptBlocking = true;
@@ -1709,28 +1721,41 @@ async function captureAndUpload() {
         logScreenshotSkip('awaitingFirstPrompt');
         return;
     }
-    if (!renderer) {
-        logScreenshotSkip('renderer=null');
-        return;
-    }
     if (!larkAppIdForUpload || !larkAppSecretForUpload) {
         logScreenshotSkip('lark credentials missing');
         return;
     }
-    const term = renderer.xterm;
-    const startY = term.buffer.active.baseY;
-    // Hash dedup — same content → skip upload. Not logged: this is the expected
-    // "nothing changed" path and would dominate the log signal.
-    const snap = renderer.rawSnapshot();
-    const hash = createHash('md5').update(snap).digest('hex');
-    if (hash === lastShotHash)
-        return;
-    lastShotHash = hash;
     let png;
     try {
-        const shotCols = clamp(term.cols, MIN_RENDER_COLS, MAX_RENDER_COLS);
-        const shotRows = clamp(term.rows, MIN_RENDER_ROWS, MAX_RENDER_ROWS);
-        png = captureToPng(term, { cols: shotCols, rows: shotRows, startY });
+        // Preferred path: pipe-pane backends ask tmux for a fresh viewport
+        // snapshot and render it through a transient xterm-headless. This
+        // avoids the accumulated-buffer drift that produced duplicated /
+        // staircase content under the legacy long-lived renderer.
+        const pipeResult = await snapshotToPng(backend, renderCols, renderRows);
+        if (pipeResult) {
+            if (pipeResult.ansi === lastShotHash)
+                return;
+            lastShotHash = pipeResult.ansi;
+            png = pipeResult.png;
+        }
+        else {
+            // Fallback path: non-pipe backends (PtyBackend, legacy TmuxBackend)
+            // still drive the long-lived renderer.
+            if (!renderer) {
+                logScreenshotSkip('renderer=null');
+                return;
+            }
+            const term = renderer.xterm;
+            const startY = term.buffer.active.baseY;
+            const snap = renderer.rawSnapshot();
+            const hash = createHash('md5').update(snap).digest('hex');
+            if (hash === lastShotHash)
+                return;
+            lastShotHash = hash;
+            const shotCols = clamp(term.cols, MIN_RENDER_COLS, MAX_RENDER_COLS);
+            const shotRows = clamp(term.rows, MIN_RENDER_ROWS, MAX_RENDER_ROWS);
+            png = captureToPng(term, { cols: shotCols, rows: shotRows, startY });
+        }
     }
     catch (err) {
         logError(`Screenshot render failed: ${err?.message ?? err}`);
@@ -2187,18 +2212,46 @@ function startScreenUpdates() {
     // content (the live failure that prompted this fix).
     renderer = new TerminalRenderer(renderCols, renderRows);
     let lastSentStatus;
+    let lastTextSnapshotHash = '';
     screenUpdateTimer = setInterval(() => {
-        if (!renderer || awaitingFirstPrompt)
+        if (awaitingFirstPrompt)
             return;
-        const { content, changed } = renderer.snapshot();
         let status = isPromptReady ? 'idle' : 'working';
         if (screenAnalyzer?.isAnalyzing)
             status = 'analyzing';
-        // Send update when content changed OR status changed (e.g. idle → analyzing)
-        if (changed || status !== lastSentStatus) {
-            lastSentStatus = status;
-            send({ type: 'screen_update', content, status });
-        }
+        void (async () => {
+            let content;
+            let changed;
+            // Preferred path: pipe-pane backends pull a fresh viewport snapshot
+            // from tmux every tick. This eliminates the accumulated-buffer drift
+            // that produced duplicated/staircase text in 'text' display mode.
+            const pipeText = await snapshotToText(backend, renderCols, renderRows, { filter: true });
+            if (pipeText) {
+                content = pipeText.content;
+                const hash = pipeText.ansi;
+                changed = hash !== lastTextSnapshotHash;
+                lastTextSnapshotHash = hash;
+                // Refresh the unfiltered cache that ScreenAnalyzer reads from. Same
+                // tmux call would otherwise need to fire twice per tick.
+                if (changed) {
+                    const rawSnap = await snapshotToText(backend, renderCols, renderRows, { filter: false });
+                    if (rawSnap)
+                        lastAnalyzerSnapshot = rawSnap.content;
+                }
+            }
+            else if (renderer) {
+                const snap = renderer.snapshot();
+                content = snap.content;
+                changed = snap.changed;
+            }
+            else {
+                return;
+            }
+            if (changed || status !== lastSentStatus) {
+                lastSentStatus = status;
+                send({ type: 'screen_update', content, status });
+            }
+        })();
     }, SCREEN_UPDATE_INTERVAL_MS);
 }
 function stopScreenUpdates() {
@@ -2210,6 +2263,7 @@ function stopScreenUpdates() {
         renderer.dispose();
         renderer = null;
     }
+    lastAnalyzerSnapshot = '';
 }
 // ─── PTY Management ──────────────────────────────────────────────────────────
 function spawnCli(cfg) {
@@ -2395,9 +2449,10 @@ function spawnCli(cfg) {
         log('tmux backend requested but functional probe failed — falling back to PTY backend');
         useTmux = false;
     }
-    isTmuxMode = useTmux;
-    const tmuxBe = useTmux ? new TmuxBackend(TmuxBackend.sessionName(cfg.sessionId)) : null;
-    backend = tmuxBe ?? new PtyBackend();
+    const selectedBackend = selectSessionBackend({ sessionId: cfg.sessionId, useTmux });
+    isTmuxMode = selectedBackend.isTmuxMode;
+    isPipeMode = selectedBackend.isPipeMode;
+    backend = selectedBackend.backend;
     // Claude Code appends a line to ~/.claude/projects/<cwd-hash>/<sid>.jsonl each
     // time the user submits. The adapter uses this file to verify paste+Enter
     // actually committed (rather than trusting a fixed sleep), so wire it up now.
@@ -2470,9 +2525,6 @@ function spawnCli(cfg) {
     // On tmux re-attach, keep awaitingFirstPrompt = true so screen updates are
     // suppressed until the idle detector fires markNewTurn() — this prevents the
     // full tmux scrollback history from leaking into the streaming card.
-    if (tmuxBe?.isReattach) {
-        log('Re-attached to existing tmux session');
-    }
     // Bridge fallback: claude-code only. Tail Claude's transcript JSONL so a
     // turn the model finishes WITHOUT calling `botmux send` still gets its
     // assistant text forwarded to Lark (the gate in emitReadyTurns suppresses
@@ -2547,6 +2599,17 @@ function spawnCli(cfg) {
         isPromptReady = false;
         send({ type: 'claude_exit', code, signal });
     });
+    if (isPipeMode && backend instanceof TmuxPipeBackend && backend.isReattach) {
+        log(`Re-attached to existing tmux session via pipe-pane: ${TmuxBackend.sessionName(cfg.sessionId)}`);
+        try {
+            const initial = backend.captureCurrentScreen();
+            if (initial.length > 0)
+                onPtyData(initial);
+        }
+        catch (err) {
+            log(`captureCurrentScreen failed: ${err.message}`);
+        }
+    }
     // Fallback: if the CLI takes too long to show its prompt (e.g. slow
     // plugin init), unblock screen updates so the card doesn't stay at
     // "启动中" forever.  markNewTurn() sets a clean baseline at the current