@mentiko/pty-mgr 1.4.2 → 1.4.3

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## 1.4.3 - 2026-07-07
+
+### Fixed
+
+- `p attach` now sizes the session to the attaching client's terminal instead of
+  resizing the client to the session. The old app-driven CSI-8 resize is ignored
+  inside tmux/iTerm panes (or resizes the whole window), so a session viewed in a
+  smaller pane kept its default winsize — which made a full-frame TUI (e.g. Claude
+  Code) flicker its status line and pushed its bottom row off-screen. The client
+  now sends its size in the attach request and the daemon resizes the session
+  (SIGWINCHing the child) to match.
+
+### Added
+
+- Live-resize while attached: when the client's terminal changes size, the
+  session (and its child) resize to follow. The client sends an out-of-band APC
+  control frame that the daemon strips from the raw input stream, so it never
+  reaches the pty as keystrokes.
+
+## 1.4.2 - 2026-07-07
+
+### Changed
+
+- Internal refactor of `lib/pty-manager.mjs`: the two near-identical socket
+  clients collapse into one `requestSocket`, and the terminal-size clamps,
+  `--log` wiring, telegram send, capture-stability check, and transcript
+  listing move to shared helpers. No behavior or public API change.
+
+### Fixed
+
+- Hardened error handling on three paths that could take the daemon down: the
+  socket client now turns a malformed or truncated reply into a rejection
+  instead of an uncaught throw in its data handler; the log write stream gets an
+  `error` listener (a disk-full / permission error drops logging instead of
+  crashing); and attach-mode input is guarded so a keystroke sent to a
+  just-exited session no longer throws in the socket handler.
+
+## 1.4.1 - 2026-07-07
+
+### Fixed
+
+- `p attach` replays the session's full terminal state via the xterm
+  serialize-addon (scrollback, colors, cursor, modes). Normal-buffer sessions
+  (a shell, Claude Code, …) are no longer forced into the alternate screen —
+  which had discarded scrollback — so history stays scrollable in the client.
+  Alt-screen TUIs still get the alt-screen switch, and the client pops back to
+  its normal screen on detach.
+
+## 1.4.0 - 2026-07-07
+
+### Added
+
+- `p attach` replays full scrollback history on connect, not just the visible
+  screen.
+- Layered flow config resolution: flows merge from the packaged defaults, the
+  XDG user config, and a project `pty-mgr.config.json` (project overrides user
+  overrides default). `p flow list` tags each flow with its source layer,
+  `p flow new [--global]` scaffolds a project (or user) flow, and `p open
+  config` opens the config directory.
+
 ## 1.3.1 - 2026-07-02
 
 ### Fixed

package/lib/pty-manager.mjs

@@ -42,7 +42,7 @@ import { fileURLToPath } from "node:url";
 import { spawn as spawnChild } from "node:child_process";
 
 // kept in sync by scripts/version-sync.cjs (rewrites this literal on release)
-export const VERSION = "1.4.2";
+export const VERSION = "1.4.3";
 import xterm from "@xterm/headless";
 import { SerializeAddon } from "@xterm/addon-serialize";
 
@@ -700,6 +700,54 @@ function socketPath(name) {
 const { daemon: DAEMON_NAME, args: CLI_ARGS } = splitDaemonArgs(process.argv.slice(2));
 const SOCKET_PATH = socketPath(DAEMON_NAME);
 
+// ── attach input: out-of-band resize control frames ──────────────────
+// While attached, the socket carries raw keystrokes. A client signals a live
+// terminal resize with an APC control frame the daemon pulls out of the stream
+// instead of forwarding to the pty:  ESC _ ptymgr:resize:<cols>:<rows> ESC \
+// APC (ESC _) is ignored by terminals and is never produced by a keyboard, so
+// it cannot collide with real input.
+const RESIZE_PREFIX = Buffer.from("\x1b_ptymgr:resize:");
+const RESIZE_ST = Buffer.from("\x1b\\");
+
+// longest k (>=1) where buf's last k bytes equal prefix's first k bytes.
+function suffixPrefixOverlap(buf, prefix) {
+  for (let k = Math.min(buf.length, prefix.length - 1); k > 0; k--) {
+    if (buf.subarray(buf.length - k).equals(prefix.subarray(0, k))) return k;
+  }
+  return 0;
+}
+
+// Split raw attach input into pty keystrokes and resize frames. Returns
+// { forward: Buffer for the pty, resizes: [{cols,rows}], rest: Buffer to
+// prepend to the next chunk }. `rest` holds an incomplete frame, or a trailing
+// "ESC _…" that may begin one, so a frame split across reads reassembles. A
+// lone trailing ESC is NOT held (that's the Escape key or a CSI start) so it
+// forwards immediately.
+export function parseAttachInput(buf) {
+  const forward = [];
+  const resizes = [];
+  let i = 0;
+  while (i < buf.length) {
+    const start = buf.indexOf(RESIZE_PREFIX, i);
+    if (start === -1) break;
+    if (start > i) forward.push(buf.subarray(i, start));
+    const st = buf.indexOf(RESIZE_ST, start + RESIZE_PREFIX.length);
+    if (st === -1) {
+      // incomplete frame: forward what precedes it, hold the rest
+      return { forward: Buffer.concat(forward), resizes, rest: buf.subarray(start) };
+    }
+    const body = buf.subarray(start + RESIZE_PREFIX.length, st).toString("latin1");
+    const m = body.match(/^(\d+):(\d+)$/);
+    if (m) resizes.push({ cols: Number(m[1]), rows: Number(m[2]) });
+    i = st + RESIZE_ST.length;
+  }
+  const tail = buf.subarray(i);
+  let keep = suffixPrefixOverlap(tail, RESIZE_PREFIX);
+  if (keep < 2) keep = 0; // never hold a lone ESC (Escape key / CSI start)
+  if (tail.length > keep) forward.push(tail.subarray(0, tail.length - keep));
+  return { forward: Buffer.concat(forward), resizes, rest: tail.subarray(tail.length - keep) };
+}
+
 /**
  * daemon: long-running process that holds all sessions.
  * clients connect via unix socket, send JSON commands, get JSON responses.
@@ -746,6 +794,7 @@ function startDaemon() {
     const server = createServer((conn) => {
       let buf = "";
       let attached = false; // true when in attach streaming mode
+      let attachInBuf = Buffer.alloc(0); // carries a split resize frame across reads
 
       // suppress connection errors (client disconnect, etc.)
       conn.on("error", () => {});
@@ -756,11 +805,21 @@ function startDaemon() {
       });
 
       conn.on("data", async (data) => {
-        // in attach mode, forward raw input to the pty. the session can exit
-        // between attach and this write (write() throws once exited); swallow
-        // so a late keystroke can't crash the daemon's data handler.
+        // in attach mode: pull out any resize control frames (applied to the
+        // session), forward the rest as raw keystrokes to the pty. the session
+        // can exit between attach and this write (write() throws once exited);
+        // swallow so a late keystroke can't crash the daemon's data handler.
         if (attached) {
-          try { attached.write(data.toString()); } catch {}
+          const { forward, resizes, rest } = parseAttachInput(
+            attachInBuf.length ? Buffer.concat([attachInBuf, data]) : data
+          );
+          attachInBuf = rest;
+          for (const { cols, rows } of resizes) {
+            try { attached.resize(cols, rows); } catch {}
+          }
+          if (forward.length) {
+            try { attached.write(forward.toString()); } catch {}
+          }
           return;
         }
 
@@ -781,6 +840,15 @@ function startDaemon() {
             // attach is special: switches to streaming mode
             if (req.cmd === "attach") {
               const session = mgr.get(req.name);
+              // size the session to the attaching client's terminal so the
+              // child's winsize matches what the user actually sees. A pane
+              // (tmux/iTerm split) ignores an app's own CSI-8 window resize --
+              // and honoring it would resize the user's whole window -- so we
+              // resize the session TO the client, the way tmux/ssh do. resize()
+              // SIGWINCHes the child, which repaints at the new size; a mismatch
+              // here is what makes a full-frame TUI's status line flicker and
+              // pushes its bottom row off-screen. No size sent => leave as-is.
+              if (req.cols && req.rows) session.resize(req.cols, req.rows);
               const cols = session.terminal.cols;
               const rows = session.terminal.rows;
               const alt = session.terminal.buffer.active.type === "alternate";
@@ -819,6 +887,7 @@ function startDaemon() {
 
               // forward client input to pty
               attached = session;
+              attachInBuf = Buffer.alloc(0);
 
               // cleanup on disconnect
               conn.on("close", () => {
@@ -1437,11 +1506,19 @@ function attachToSession(name) {
     });
 
     conn.on("connect", () => {
-      // send attach request
-      conn.write(JSON.stringify({ cmd: "attach", name }) + "\n");
+      // send attach request with our real terminal size so the daemon can size
+      // the session (and its child) to us. undefined when stdout isn't a TTY;
+      // the daemon then leaves the session size unchanged.
+      conn.write(JSON.stringify({
+        cmd: "attach",
+        name,
+        cols: process.stdout.columns,
+        rows: process.stdout.rows,
+      }) + "\n");
 
       let gotAck = false;
       let headerBuf = "";
+      let onStdoutResize = null;
 
       // last-seen alt-screen state: detach pops the client back to its
       // normal screen only if the session left it in the alternate buffer
@@ -1481,11 +1558,11 @@ function attachToSession(name) {
           gotAck = true;
           altActive = !!ack.alt;
 
-          // resize client terminal to match session
-          if (ack.cols && ack.rows) {
-            // CSI 8 ; rows ; cols t  = resize terminal window
-            process.stdout.write(`\x1b[8;${ack.rows};${ack.cols}t`);
-          }
+          // NOTE: we do NOT resize our own terminal to the session. The daemon
+          // has already sized the session to us (we sent our size in the attach
+          // request). An app-driven CSI-8 window resize is ignored inside
+          // tmux/iTerm panes and, where honored, resizes the user's entire
+          // window -- which is what caused the flicker and the missing bottom row.
 
           // put terminal in raw mode
           process.stdin.setRawMode(true);
@@ -1509,6 +1586,15 @@ function attachToSession(name) {
             conn.write(key);
           });
 
+          // live-resize: when our terminal changes size, tell the daemon so it
+          // resizes the session (and its child's winsize) to match. Sent as an
+          // out-of-band APC frame the daemon strips from the input stream.
+          onStdoutResize = () => {
+            const c = process.stdout.columns, r = process.stdout.rows;
+            if (c && r) { try { conn.write(`\x1b_ptymgr:resize:${c}:${r}\x1b\\`); } catch {} }
+          };
+          process.stdout.on("resize", onStdoutResize);
+
           return;
         }
 
@@ -1525,6 +1611,10 @@ function attachToSession(name) {
       function detach() {
         if (detached || failed) return;
         detached = true;
+        if (onStdoutResize) {
+          process.stdout.removeListener("resize", onStdoutResize);
+          onStdoutResize = null;
+        }
         if (process.stdin.isRaw) {
           process.stdin.setRawMode(false);
           process.stdin.pause();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentiko/pty-mgr",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "PTY session manager with terminal emulation for programmatic session control.",
   "type": "module",
   "main": "lib/pty-manager.mjs",
@@ -26,10 +26,10 @@
     "@xterm/headless": "^6.0.0"
   },
   "optionalDependencies": {
-    "@mentiko/pty-mgr-linux-x64": "1.4.2",
-    "@mentiko/pty-mgr-linux-arm64": "1.4.2",
-    "@mentiko/pty-mgr-darwin-x64": "1.4.2",
-    "@mentiko/pty-mgr-darwin-arm64": "1.4.2"
+    "@mentiko/pty-mgr-linux-x64": "1.4.3",
+    "@mentiko/pty-mgr-linux-arm64": "1.4.3",
+    "@mentiko/pty-mgr-darwin-x64": "1.4.3",
+    "@mentiko/pty-mgr-darwin-arm64": "1.4.3"
   },
   "engines": {
     "bun": ">=1.0"