@thenewlabs/entangle-serve 2.6.2 → 2.8.0

package/dist/host-terminal.js

@@ -1,11 +1,8 @@
-import { OutputHandler } from '@thenewlabs/entangle-utils';
 /** Minimum terminal size that can hold the shell plus a bottom status bar. */
 const MIN_COLS = 20;
 const MIN_ROWS = 6;
 /** Repaint cadence for the status bar: coalesce shell output into ~30ms frames. */
 const FRAME_MS = 30;
-/** Cap on the host's captured-log ring buffer backing the debug tab. */
-const DEBUG_MAX_LINES = 1000;
 /** Host window-management prefix (Ctrl-B), tmux-style. */
 const PREFIX = 0x02;
 /** Status-bar palette (tmux-style blue). */
@@ -13,8 +10,50 @@ const BAR_BG = '\x1b[48;5;25m'; // base blue background
 const BAR_ACTIVE_BG = '\x1b[48;5;33m'; // brighter blue for the active tab
 const BAR_FG = '\x1b[97m'; // bright white text
 const RESET = '\x1b[0m';
+/** SGR mouse reporting: enable/disable click reporting for the status bar. */
+const MOUSE_ENABLE = '\x1b[?1000h\x1b[?1006h';
+const MOUSE_DISABLE = '\x1b[?1000l\x1b[?1006l';
 /**
- * Wire the host's own terminal to the shared workspace.
+ * Try to parse a well-formed SGR mouse sequence at `i` in `d`. Returns null for
+ * anything that isn't a complete `\x1b[<b;x;y(M|m)` so it passes through as
+ * ordinary input (including partial sequences split across chunks).
+ */
+function matchMouse(d, i) {
+    if (d[i] !== 0x1b || d[i + 1] !== 0x5b /* [ */ || d[i + 2] !== 0x3c /* < */)
+        return null;
+    let j = i + 3;
+    const readNum = () => {
+        let n = 0;
+        let any = false;
+        while (j < d.length && d[j] >= 0x30 && d[j] <= 0x39) {
+            n = n * 10 + (d[j] - 0x30);
+            j++;
+            any = true;
+        }
+        return any ? n : null;
+    };
+    const button = readNum();
+    if (button === null)
+        return null;
+    if (d[j] !== 0x3b /* ; */)
+        return null;
+    j++;
+    const col = readNum();
+    if (col === null)
+        return null;
+    if (d[j] !== 0x3b)
+        return null;
+    j++;
+    const row = readNum();
+    if (row === null)
+        return null;
+    const fin = d[j];
+    if (fin !== 0x4d /* M */ && fin !== 0x6d /* m */)
+        return null;
+    return { length: j - i + 1, button, col, row, press: fin === 0x4d };
+}
+/**
+ * Wire the host's own terminal to the {@link HostSession}.
  *
  * On a real, big-enough terminal the host sees their shell rendered RAW at full
  * width, using rows 1..(rows-1), with a blue tmux-style status bar pinned to the
@@ -22,26 +61,34 @@ const RESET = '\x1b[0m';
  * region keeps its scrolling clear of the bar; because output is passed through
  * byte-for-byte (no VtGrid), resizes stay clean. Elsewhere (too small, or not a
  * TTY) it falls back to raw pass-through.
+ *
+ * The session URL is only known once the relay assigns the capability, so the
+ * host subscribes to {@link HostSession.onUrl} and shows a brief "connecting…"
+ * screen until it arrives (index.ts sets it on the session).
  */
-export function attachHostTerminal(shared, output) {
+export function attachHostTerminal(session, output) {
     const stdout = process.stdout;
     const stdin = process.stdin;
     const cols = stdout.columns || 0;
     const rows = stdout.rows || 0;
     const barCapable = !!stdout.isTTY && !!stdin.isTTY && cols >= MIN_COLS && rows >= MIN_ROWS;
-    return barCapable
-        ? attachBarTerminal(shared, output, cols, rows)
-        : attachRawTerminal(shared, output);
+    if (barCapable)
+        attachBarTerminal(session, output, cols, rows);
+    else
+        attachRawTerminal(session, output);
 }
 /**
  * Blue-bottom-bar UI (the normal interactive host experience).
  *
- * Launch sequence: clear + "connecting…" on attach; then on setUrl clear again,
- * print an info banner (brand, share URL, key hint) at the top, set the scroll
- * region, size the shell to rows-1, paint its current screen from the replay,
- * draw the bar, and go live (raw pass-through + status bar).
+ * Launch sequence: clear + "connecting…" on attach; then on the URL arriving
+ * clear again, set the scroll region, size the shell to rows-1, enable SGR mouse
+ * reporting for the clickable bar, and go live on the WELCOME/log view (the
+ * pinned banner header + live event-log tail). The shell keeps running in the
+ * background; the host reaches it by clicking a window tab or Ctrl-B <digit>/n,
+ * which repaints it from the replay. The `⧉ entangle` bar label doubles as the
+ * button back to the welcome/log view.
  */
-function attachBarTerminal(shared, output, initialCols, initialRows) {
+function attachBarTerminal(session, output, initialCols, initialRows) {
     const stdout = process.stdout;
     const stdin = process.stdin;
     const write = (s) => { try {
@@ -55,64 +102,74 @@ function attachBarTerminal(shared, output, initialCols, initialRows) {
     let cols = initialCols;
     let rows = initialRows;
     let live = false; // true once the URL is known and we're in pass-through
-    let viewers = shared.viewerCount();
+    let viewers = session.viewerCount();
     let barDirty = false;
-    // The capability URL, once the relay assigns it. Stored so the debug view's
-    // pinned header can always show it (and refresh on a later setUrl).
-    let url = null;
-    // Which surface fills the shell area (rows 1..rows-1). 'shell' is the normal
-    // raw pass-through; 'debug' shows the captured agent-log tail (Ctrl-B d).
-    let viewMode = 'shell';
-    // Capped ring of captured agent logs. While the host owns stdout, agent logs
-    // are redirected here (via the OutputHandler sink) instead of trampling the
-    // terminal; the debug tab renders the tail of this buffer.
-    const debugBuf = [];
+    // Which surface fills the shell area (rows 1..rows-1). 'shell' is the raw
+    // pass-through; 'debug' is the welcome/log view (pinned banner + event-log
+    // tail). We DEFAULT to 'debug' so the first thing the host sees on go-live is
+    // the welcome screen with the shareable URL; a window tab/Ctrl-B digit or n
+    // reveals the shell.
+    let viewMode = 'debug';
+    // The captured agent logs live in the session's ring buffer (the session owns
+    // the OutputHandler sink); the welcome/log view renders the tail of that
+    // buffer and marks itself dirty when a new line arrives while it's showing.
     let debugDirty = false;
-    const pushLog = (level, message, data) => {
-        let line = `[${level}] ${message}`;
-        if (data !== undefined && data !== null) {
-            let extra;
-            try {
-                extra = typeof data === 'string' ? data : JSON.stringify(data);
-            }
-            catch {
-                extra = String(data);
-            }
-            if (extra)
-                line += ` ${extra}`;
+    // Clickable segments of the bar (rebuilt each buildBar), mapping a 1-based
+    // column span on the bar row to an action (the entangle label → welcome/log
+    // view; each window tab → switch to that window).
+    let clickTargets = [];
+    // Which DEC mouse-tracking modes the SHELL app has enabled, scanned from its
+    // output. When any is on, the app (vim/htop) wants mouse events, so we forward
+    // raw off-bar mouse sequences to it; otherwise we swallow them so bash doesn't
+    // receive click garbage. Mode 1006 is just SGR encoding, not a tracking mode.
+    const appMouseModes = new Set();
+    const appMouseOn = () => appMouseModes.has('1000') || appMouseModes.has('1002') || appMouseModes.has('1003');
+    const MOUSE_MODE_RE = /\x1b\[\?(1000|1002|1003|1006)(h|l)/g;
+    const scanAppMouse = (buf) => {
+        const s = Buffer.from(buf).toString('latin1');
+        MOUSE_MODE_RE.lastIndex = 0;
+        let m;
+        while ((m = MOUSE_MODE_RE.exec(s)) !== null) {
+            if (m[2] === 'h')
+                appMouseModes.add(m[1]);
+            else
+                appMouseModes.delete(m[1]);
         }
-        debugBuf.push(line);
-        if (debugBuf.length > DEBUG_MAX_LINES)
-            debugBuf.splice(0, debugBuf.length - DEBUG_MAX_LINES);
-        if (viewMode === 'debug')
-            debugDirty = true;
     };
-    // Local mirror of the workspace's window set, kept in sync via onWindowState
+    // Local mirror of the session's window set, kept in sync via onWindowState
     // and rendered as the tab row of the bar. Seeded with the current state.
-    const initialState = shared.windowState();
+    const initialState = session.windowState();
     let windows = initialState.windows;
     let activeIndex = initialState.activeIndex;
     /**
-     * Compose the status bar for the bottom row: ` ⧉ entangle ` then 1-based
+     * Compose the status bar for the bottom row: ` ⧉ entangle ` (which doubles as
+     * the welcome/log button — brighter blue while the log view shows) then 1-based
      * window tabs (the active one in brighter blue) and a right-aligned viewer
      * count, all on blue and padded/truncated to exactly `cols` visible columns.
+     * Side effect: records each clickable segment's column span into clickTargets.
      */
     const buildBar = () => {
+        const targets = [];
         const segs = [
-            { text: ' ⧉ entangle ', active: false },
+            // The brand label is the welcome/log button; active while in that view.
+            { text: ' ⧉ entangle ', active: viewMode === 'debug', action: () => enterDebug() },
         ];
         for (let i = 0; i < windows.length; i++) {
             const title = (windows[i].title || '').replace(/[\x00-\x1f\x7f]/g, '');
-            segs.push({ text: ` ${i + 1}:${title} `, active: viewMode === 'shell' && i === activeIndex });
+            const idx = i;
+            segs.push({
+                text: ` ${i + 1}:${title} `,
+                active: viewMode === 'shell' && i === activeIndex,
+                action: () => { enterShell(); session.selectWindow(idx); },
+            });
         }
-        // A distinct debug tab after the window tabs; active while in debug view.
-        segs.push({ text: ' debug ', active: viewMode === 'debug' });
         const viewerSeg = ` ${viewers} viewer${viewers === 1 ? '' : 's'} `;
         // Reserve room on the right for the viewer count when it fits.
         const showViewer = viewerSeg.length + 1 <= cols;
         const leftBudget = showViewer ? cols - viewerSeg.length : cols;
         // Emit the left segments up to leftBudget visible columns, truncating the
         // last one that overflows (each active segment is wrapped in its own bg).
+        // Record the on-screen column span of each clickable segment for hit-testing.
         let left = '';
         let leftVis = 0;
         for (const s of segs) {
@@ -120,11 +177,14 @@ function attachBarTerminal(shared, output, initialCols, initialRows) {
                 break;
             const room = leftBudget - leftVis;
             const text = s.text.length > room ? s.text.slice(0, room) : s.text;
+            if (s.action)
+                targets.push({ start: leftVis + 1, end: leftVis + text.length, action: s.action });
             left += s.active ? `${BAR_ACTIVE_BG}${text}${BAR_BG}` : text;
             leftVis += text.length;
         }
         const fill = ' '.repeat(Math.max(0, cols - leftVis - (showViewer ? viewerSeg.length : 0)));
         const right = showViewer ? viewerSeg : '';
+        clickTargets = targets;
         return `${BAR_BG}${BAR_FG}${left}${fill}${right}${RESET}`;
     };
     // Draw the bar on the bottom row without disturbing the shell: save the cursor
@@ -136,37 +196,41 @@ function attachBarTerminal(shared, output, initialCols, initialRows) {
         barDirty = false;
         write(`\x1b7\x1b[${rows};1H\x1b[2K${buildBar()}\x1b8`);
     };
-    // The info banner lines (brand, share URL, key hint), shared by the launch
-    // banner printed on go-live and the debug view's pinned header so they match
-    // exactly. Shows `connecting…` for the URL until it's known.
+    // The welcome banner lines (brand, intro, share URL, key hint) — the pinned
+    // header of the welcome/log view. Shows `connecting…` for the URL until known.
     const bannerLines = (link) => [
         `${BAR_FG}⧉ entangle${RESET} — live shared session`,
+        `A shared terminal others can join at the URL below.`,
+        ``,
         `Share this live session:`,
         `  ${BAR_FG}${link ?? 'connecting…'}${RESET}`,
-        `Windows: Ctrl-B then c=new  n/p=prev/next  1-9=select  x=close  d=debug`,
+        ``,
+        `Ctrl-B  d=detach  l=logs  c=new  n/p=win  1-9=select  x=close  ·  or click the bar`,
     ];
-    // Render the debug tab: a PINNED HEADER (the info banner: brand, share URL,
-    // key hint) at the top so the URL is always findable, then a blank separator,
-    // then the tail of the log buffer that fits, then repaint the bar. No
-    // scrollback — just the last rows.
+    // Render the welcome/log view: a PINNED HEADER (brand, intro, share URL, key
+    // hint) at the top so the URL is always findable, a "Recent activity:"
+    // separator, then the tail of the event-log buffer that fits (viewer
+    // connect/disconnect lines land here), then repaint the bar. No scrollback —
+    // just the last rows.
     const renderDebug = () => {
         if (!live)
             return;
         debugDirty = false;
         const shellRows = Math.max(1, rows - 1);
-        const header = bannerLines(url);
-        const headerRows = header.length + 1; // banner lines + one blank separator
+        const header = bannerLines(session.getUrl());
+        const sep = `${BAR_FG}Recent activity:${RESET}`;
+        const headerRows = header.length + 1; // banner lines + the separator line
         const tailRows = Math.max(0, shellRows - headerRows);
-        const lines = tailRows > 0 ? debugBuf.slice(-tailRows) : [];
+        const lines = tailRows > 0 ? session.getLogBuffer().slice(-tailRows) : [];
         let out = '';
         let r = 0;
         for (; r < header.length && r < shellRows; r++) {
             out += `\x1b[${r + 1};1H\x1b[2K${header[r]}`; // header lines print as-is
         }
         if (r < shellRows) {
-            out += `\x1b[${r + 1};1H\x1b[2K`;
+            out += `\x1b[${r + 1};1H\x1b[2K${sep}`;
             r++;
-        } // blank separator
+        } // separator
         for (let i = 0; r < shellRows; r++, i++) {
             out += `\x1b[${r + 1};1H\x1b[2K`; // move to row, clear it
             const line = lines[i];
@@ -187,10 +251,13 @@ function attachBarTerminal(shared, output, initialCols, initialRows) {
             out += `\x1b[${r};1H\x1b[2K`;
         out += '\x1b[H';
         write(out);
-        const replay = shared.getReplay();
+        const replay = session.getReplay();
         if (replay.length > 0)
             writeRaw(replay);
         drawBar();
+        // The replay may have re-disabled mouse (e.g. it ends after a full-screen
+        // app quit); re-assert our bar-click reporting so the bar stays clickable.
+        write(MOUSE_ENABLE);
     };
     const enterDebug = () => {
         if (viewMode === 'debug')
@@ -217,87 +284,141 @@ function attachBarTerminal(shared, output, initialCols, initialRows) {
             drawBar();
     }, FRAME_MS);
     timer.unref?.();
-    shared.onHostData((chunk) => {
+    session.onHostData((chunk) => {
         if (!live)
             return; // pre-live output is captured in the replay; painted on go-live
-        if (viewMode === 'debug')
-            return; // still buffered in replay; not shown while in debug
-        writeRaw(chunk);
-        barDirty = true;
+        // Track the shell app's mouse mode even while the welcome/log view is up, so
+        // off-bar mouse passthrough is correct the moment we switch back to the shell.
+        const mouseWasOn = appMouseOn();
+        scanAppMouse(chunk);
+        if (viewMode !== 'debug') { // in the welcome/log view the shell is still buffered in replay
+            writeRaw(chunk);
+            barDirty = true;
+            // A full-screen app quitting turns mouse OFF, which also kills OUR bar-click
+            // reporting; re-assert it after the app's disable bytes have been written.
+            if (mouseWasOn && !appMouseOn())
+                write(MOUSE_ENABLE);
+        }
     });
-    shared.onViewersChange((n) => { viewers = n; drawBar(); });
-    shared.onWindowState((state) => {
+    session.onViewersChange((n) => { viewers = n; drawBar(); });
+    session.onWindowState((state) => {
         windows = state.windows;
         activeIndex = state.activeIndex;
         drawBar();
     });
-    // Redirect all agent text-mode logs into the debug ring buffer instead of
-    // stdout (which this bar UI owns). This both stops the logs from trampling
-    // the terminal / scrolling the banner away and feeds the debug tab.
-    OutputHandler.setLogSink(pushLog);
+    // The session captures agent logs into its ring buffer (it owns the
+    // OutputHandler sink); we only need to know when a new line arrives so the
+    // debug tab repaints its tail while it's the visible surface.
+    session.onLog(() => { if (viewMode === 'debug')
+        debugDirty = true; });
     const wasRaw = !!stdin.isRaw;
     stdin.setRawMode(true);
     stdin.resume();
     // Window-management commands after a Ctrl-B prefix. Unknown keys are swallowed.
-    // `d` opens the debug view; every workspace op returns to (and repaints) the
-    // shell view before running, so acting on a window always shows its output.
+    // `d` detaches (leaving the daemon session running; a no-op for an in-process
+    // session that has no detach), `l` opens the logs view; every workspace op
+    // returns to (and repaints) the shell view before running, so acting on a
+    // window always shows its output.
     const runCommand = (byte) => {
         const ch = String.fromCharCode(byte);
+        // Detach fires the session's onExit path, which runs restore()+exit below;
+        // don't force an exit here that would race it.
         if (ch === 'd') {
+            session.detach?.();
+            return;
+        }
+        if (ch === 'l') {
             enterDebug();
             return;
         }
         if (ch === 'c') {
             enterShell();
-            shared.newWindow();
+            session.newWindow();
         }
         else if (ch === 'n') {
             enterShell();
-            shared.nextWindow();
+            session.nextWindow();
         }
         else if (ch === 'p') {
             enterShell();
-            shared.prevWindow();
+            session.prevWindow();
         }
         else if (ch === 'x') {
             enterShell();
-            shared.closeWindow(activeIndex);
+            session.closeWindow(activeIndex);
         }
         else if (ch >= '0' && ch <= '9') {
             // Tabs are labelled 1-based ("1:shell" = index 0), so digit 1..9 selects
             // window 0..8 and 0 selects window 9 (ignored if out of range).
             enterShell();
             const digit = byte - 0x30;
-            shared.selectWindow(digit === 0 ? 9 : digit - 1);
+            session.selectWindow(digit === 0 ? 9 : digit - 1);
         }
     };
+    // Handle a parsed SGR mouse event. A left-button PRESS on the bar row (rows)
+    // is hit-tested against the recorded clickTargets and its action run — never
+    // forwarded to the shell. Any other event: if the shell app wants mouse, the
+    // ORIGINAL escape bytes are forwarded so vim/htop still get it; otherwise it's
+    // swallowed so bash doesn't receive click garbage.
+    const handleMouse = (m, raw) => {
+        if (m.row >= rows) { // on (or below) the bar row — the bar owns these
+            // button bits: 0/1 = button number, 32 = motion, 64 = wheel, 128 = extra;
+            // modifiers (shift/meta/ctrl, bits 2-4) are ignored. Left press = 0.
+            if (m.press && (m.button & 0xe3) === 0) {
+                for (const t of clickTargets) {
+                    if (m.col >= t.start && m.col <= t.end) {
+                        t.action();
+                        break;
+                    }
+                }
+            }
+            return; // never forward bar-row mouse events to the shell
+        }
+        if (appMouseOn())
+            session.write(new Uint8Array(raw)); // shell wants mouse
+        // else swallow: bash gets no garbage clicks
+    };
     // Ctrl-B prefix state machine: a lone Ctrl-B arms the prefix; the next byte is
-    // a command (Ctrl-B again = a literal Ctrl-B to the active window). All other
-    // bytes forward to the active window, flushed around each prefix boundary so
-    // ordering across a window switch is preserved.
+    // a command (Ctrl-B again = a literal Ctrl-B to the active window). Well-formed
+    // SGR mouse sequences are intercepted (bar click / passthrough / swallow). All
+    // other bytes forward to the active window, flushed around each prefix or mouse
+    // boundary so ordering across a window switch is preserved.
     let pendingPrefix = false;
     const onInput = (d) => {
         let start = 0;
-        for (let i = 0; i < d.length; i++) {
+        for (let i = 0; i < d.length;) {
             const byte = d[i];
             if (pendingPrefix) {
                 pendingPrefix = false;
                 if (byte === PREFIX)
-                    shared.write(new Uint8Array([PREFIX]));
+                    session.write(new Uint8Array([PREFIX]));
                 else
                     runCommand(byte);
-                start = i + 1;
+                i++;
+                start = i;
+                continue;
+            }
+            const mouse = matchMouse(d, i);
+            if (mouse) {
+                if (i > start)
+                    session.write(new Uint8Array(d.subarray(start, i)));
+                handleMouse(mouse, d.subarray(i, i + mouse.length));
+                i += mouse.length;
+                start = i;
                 continue;
             }
             if (byte === PREFIX) {
                 if (i > start)
-                    shared.write(new Uint8Array(d.subarray(start, i)));
+                    session.write(new Uint8Array(d.subarray(start, i)));
                 pendingPrefix = true;
-                start = i + 1;
+                i++;
+                start = i;
+                continue;
             }
+            i++;
         }
         if (d.length > start)
-            shared.write(new Uint8Array(d.subarray(start)));
+            session.write(new Uint8Array(d.subarray(start)));
     };
     stdin.on('data', onInput);
     // Clean resize: drop the scroll region, clear, re-arm the region one row short,
@@ -312,7 +433,7 @@ function attachBarTerminal(shared, output, initialCols, initialRows) {
         write('\x1b[r');
         write('\x1b[2J\x1b[H');
         write(`\x1b[1;${shellRows}r`);
-        shared.resize(cols, shellRows);
+        session.resize(cols, shellRows);
         // In debug view the shell won't redraw itself, so re-render the tail for the
         // new size; in shell view the shell's own SIGWINCH redraw fills the screen.
         if (viewMode === 'debug')
@@ -327,9 +448,10 @@ function attachBarTerminal(shared, output, initialCols, initialRows) {
             return;
         restored = true;
         clearInterval(timer);
-        OutputHandler.setLogSink(null); // let any final logs print to stdout normally
+        session.dispose(); // release the log sink so any final logs print to stdout normally
         stdin.removeListener('data', onInput);
         stdout.removeListener('resize', onResize);
+        write(MOUSE_DISABLE); // stop SGR mouse reporting we enabled for the bar
         write('\x1b[r'); // reset scroll region
         write('\x1b[2J\x1b[H'); // clear screen + home, so no stale bar/shell is left behind
         write('\x1b[?25h'); // show cursor
@@ -341,7 +463,7 @@ function attachBarTerminal(shared, output, initialCols, initialRows) {
         }
         stdin.pause();
     };
-    shared.onExit((code) => {
+    session.onExit((code) => {
         restore();
         write('\n');
         output.info('Shared session ended.');
@@ -349,54 +471,53 @@ function attachBarTerminal(shared, output, initialCols, initialRows) {
     });
     process.on('exit', restore);
     process.on('SIGINT', () => { restore(); process.exit(130); });
-    // Info banner shown at the top when the session goes live. `\r\n` because raw
-    // mode does not translate a bare `\n` into a carriage return. Reuses the same
-    // `bannerLines` the debug view pins so the two always match.
-    const writeBanner = (link) => {
-        write(bannerLines(link).map((l) => `${l}\r\n`).join(''));
-    };
+    // The session URL is stored on the session (its pinned-header/getUrl source);
+    // we react to it arriving. The first URL drives the go-live launch sequence
+    // (which lands on the welcome/log view); a later refresh just marks the
+    // bar/pinned-header dirty.
+    session.onUrl(() => {
+        if (live) { // URL refresh after we're already live
+            barDirty = true;
+            if (viewMode === 'debug')
+                debugDirty = true; // repaint the pinned header
+            return;
+        }
+        cols = stdout.columns || cols;
+        rows = stdout.rows || rows;
+        const shellRows = Math.max(1, rows - 1);
+        write('\x1b[2J\x1b[H');
+        write(`\x1b[1;${shellRows}r`); // reserve the bottom row for the bar
+        session.resize(cols, shellRows); // shell is authoritative-sized to rows-1
+        scanAppMouse(session.getReplay()); // seed app-mouse state from the shell's screen
+        write(MOUSE_ENABLE); // enable SGR mouse reporting for the clickable bar
+        live = true;
+        // Start on the welcome/log view (viewMode defaults to 'debug'): the pinned
+        // banner + event-log tail. The shell keeps running in the background.
+        renderDebug();
+    });
     // Connecting screen until the relay hands us the capability URL.
     write('\x1b[2J\x1b[H');
     write(`${BAR_FG}⧉ entangle — connecting…${RESET}`);
-    return {
-        setUrl(link) {
-            url = link; // stored so the debug view's pinned header can always show it
-            if (live) { // URL refresh after we're already live
-                barDirty = true;
-                if (viewMode === 'debug')
-                    debugDirty = true; // repaint the pinned header
-                return;
-            }
-            cols = stdout.columns || cols;
-            rows = stdout.rows || rows;
-            const shellRows = Math.max(1, rows - 1);
-            write('\x1b[2J\x1b[H');
-            writeBanner(link);
-            write(`\x1b[1;${shellRows}r`); // reserve the bottom row for the bar
-            shared.resize(cols, shellRows); // shell is authoritative-sized to rows-1
-            const replay = shared.getReplay(); // paint the shell's current screen below the banner
-            if (replay.length > 0)
-                writeRaw(replay);
-            live = true;
-            drawBar();
-        },
-    };
 }
 /**
  * Raw pass-through: mirror the shell byte-for-byte and forward keystrokes, with
  * no status bar. Used when the terminal is too small for a bar (or not a TTY).
  */
-function attachRawTerminal(shared, output) {
+function attachRawTerminal(session, output) {
     const stdin = process.stdin;
     const stdout = process.stdout;
-    const initial = shared.getReplay();
+    // No status bar and no debug tab here, so there's nowhere to surface captured
+    // logs — release the session's log sink so agent logs print to stdout as they
+    // did before this UI existed (the bar path keeps the sink for its debug tab).
+    session.dispose();
+    const initial = session.getReplay();
     if (initial.length > 0) {
         try {
             stdout.write(Buffer.from(initial));
         }
         catch { }
     }
-    shared.onHostData((chunk) => { try {
+    session.onHostData((chunk) => { try {
         stdout.write(chunk);
     }
     catch { } });
@@ -404,15 +525,16 @@ function attachRawTerminal(shared, output) {
     if (stdin.isTTY)
         stdin.setRawMode(true);
     stdin.resume();
-    const onInput = (d) => shared.write(new Uint8Array(d));
+    const onInput = (d) => session.write(new Uint8Array(d));
     stdin.on('data', onInput);
-    const onResize = () => shared.resize(stdout.columns || 80, stdout.rows || 24);
+    const onResize = () => session.resize(stdout.columns || 80, stdout.rows || 24);
     stdout.on('resize', onResize);
     let restored = false;
     const restore = () => {
         if (restored)
             return;
         restored = true;
+        session.dispose(); // release the log sink so any final logs print to stdout normally
         stdin.removeListener('data', onInput);
         stdout.removeListener('resize', onResize);
         if (stdin.isTTY) {
@@ -423,16 +545,15 @@ function attachRawTerminal(shared, output) {
         }
         stdin.pause();
     };
-    shared.onExit((code) => {
+    session.onExit((code) => {
         restore();
         output.info(`Shared session ended (code=${code ?? 0}).`);
         process.exit(code ?? 0);
     });
     process.on('exit', restore);
-    return {
-        setUrl(link) {
-            output.info(`⧉ entangle session shared — open to collaborate:\n  ${link}\n`);
-        },
-    };
+    // The relay hands us the capability URL after attach; print it once it arrives.
+    session.onUrl((link) => {
+        output.info(`⧉ entangle session shared — open to collaborate:\n  ${link}\n`);
+    });
 }
 //# sourceMappingURL=host-terminal.js.map