@mentiko/pty-mgr 1.4.2 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,86 @@
 # Changelog
 
+## 1.5.0 - 2026-07-18
+
+### Added
+
+- `p daemons` lists every running daemon on the machine — one line per daemon
+  with pid, uptime, session counts, and cwd, in the same style as `p list`. The
+  currently-selected daemon (`@name` / `$PTY_DAEMON`) is marked with a leading
+  `*`; a socket that no longer answers is shown as `(stale)` and one with an
+  empty name as `(unnamed)`. It is read-only — unlike `p stop all` it never
+  removes stale sockets. Both commands now share one socket-enumeration helper.
+
+### Fixed
+
+- The installer no longer reports success while an older `pty-mgr` shadows the
+  freshly installed one. `install.sh` used to print `PATH is set.` once
+  `~/.pty-mgr/bin` was on `PATH`, which said nothing about *which* copy answers:
+  a stale binary earlier in `PATH` (e.g. a hand-placed `/usr/local/bin/pty-mgr`,
+  which sits on line 1 of macOS `/etc/paths`) would win silently. The installer
+  now scans every `PATH` entry after installing and prints any other `pty-mgr`
+  or `p` it finds, with an exact `rm` line to remove them.
+
+## 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.5.0";
 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", () => {
@@ -1410,6 +1479,32 @@ function sendCommandTo(sock, req) {
   return requestSocket(sock, req, "daemon not running");
 }
 
+// enumerate every daemon socket: ~/.pty-manager/*.sock plus legacy
+// /tmp/pty-manager-*.sock. returns [{ name, sockFile }]. shared by `stop all`
+// and `daemons` so both see the same set. presence of a .sock file does not
+// prove the daemon is alive -- the caller probes it.
+function listDaemonSockets() {
+  const found = [];
+  const dir = join(homedir(), ".pty-manager");
+  try {
+    for (const f of readdirSync(dir)) {
+      if (f.endsWith(".sock")) {
+        found.push({ name: f.replace(/\.sock$/, ""), sockFile: join(dir, f) });
+      }
+    }
+  } catch { /* dir doesn't exist yet */ }
+  try {
+    const tmp = tmpdir();
+    for (const f of readdirSync(tmp)) {
+      if (f.startsWith("pty-manager-") && f.endsWith(".sock")) {
+        const name = f.replace(/^pty-manager-/, "").replace(/\.sock$/, "");
+        found.push({ name, sockFile: join(tmp, f) });
+      }
+    }
+  } catch { /* tmp unreadable */ }
+  return found;
+}
+
 // send to the daemon selected by @name / --daemon / $PTY_DAEMON.
 function sendCommand(req) {
   return requestSocket(SOCKET_PATH, req, "daemon not running. start with: pty-mgr daemon");
@@ -1437,11 +1532,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 +1584,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 +1612,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 +1637,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();
@@ -1552,6 +1668,7 @@ const USAGE = `pty-mgr - PTY session manager
 usage:
   p daemon                           start daemon (background: &)
   p daemon @myproject                named daemon (isolated sessions)
+  p daemons                          list all running daemons (* = current)
   p status                           daemon info + config
   p config                           show current config
   p config screen 100x50             set default terminal size
@@ -2969,32 +3086,13 @@ async function cli() {
     const target = args[0]; // "all" or undefined (= current daemon)
     if (target === "all") {
       // find all pty-manager sockets and shut them down
-      const dir = join(homedir(), ".pty-manager");
-      let socks = [];
-      try {
-        socks = readdirSync(dir).filter((f) => f.endsWith(".sock"));
-      } catch { /* dir doesn't exist */ }
-      // also check legacy /tmp/ location for old sockets
-      try {
-        const tmp = tmpdir();
-        const legacy = readdirSync(tmp).filter((f) => f.startsWith("pty-manager-") && f.endsWith(".sock"));
-        for (const s of legacy) socks.push("__legacy__/" + s);
-      } catch {}
-      if (socks.length === 0) {
+      const daemons = listDaemonSockets();
+      if (daemons.length === 0) {
         console.log("no daemons running");
         return;
       }
       const stopped = [];
-      for (const sock of socks) {
-        let sockFile, name;
-        if (sock.startsWith("__legacy__/")) {
-          const legacyName = sock.replace("__legacy__/", "");
-          sockFile = join(tmpdir(), legacyName);
-          name = legacyName.replace("pty-manager-", "").replace(".sock", "");
-        } else {
-          sockFile = join(dir, sock);
-          name = sock.replace(".sock", "");
-        }
+      for (const { name, sockFile } of daemons) {
         try {
           const res = await sendCommandTo(sockFile, { cmd: "shutdown" });
           if (res.ok) stopped.push(name);
@@ -3017,6 +3115,36 @@ async function cli() {
     return;
   }
 
+  if (command === "daemons") {
+    // read-only listing of every daemon socket. probes each for live status;
+    // unlike `stop all` it never removes stale sockets. one line per daemon,
+    // matching the `list` house style. current daemon (@name/$PTY_DAEMON) is
+    // marked with a leading '*'.
+    const daemons = listDaemonSockets();
+    if (daemons.length === 0) {
+      console.log("no daemons running");
+      return;
+    }
+    for (const { name, sockFile } of daemons) {
+      const marker = sockFile === SOCKET_PATH ? "*" : " ";
+      let st = null;
+      try {
+        const res = await sendCommandTo(sockFile, { cmd: "status" });
+        if (res.ok) st = res.status;
+      } catch { /* stale: file exists but nothing is listening */ }
+      const label = name || "(unnamed)";
+      if (st) {
+        const s = st.sessions;
+        let line = `${marker} ${label}  pid=${st.pid}  up=${st.uptime}  ${s.alive}/${s.total} sessions`;
+        if (st.cwd) line += `  ${st.cwd}`; // older daemons may not report cwd
+        console.log(line);
+      } else {
+        console.log(`${marker} ${label}  (stale)`);
+      }
+    }
+    return;
+  }
+
   if (command === "attach") {
     const name = args[0];
     if (!name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentiko/pty-mgr",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "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.5.0",
+    "@mentiko/pty-mgr-linux-arm64": "1.5.0",
+    "@mentiko/pty-mgr-darwin-x64": "1.5.0",
+    "@mentiko/pty-mgr-darwin-arm64": "1.5.0"
   },
   "engines": {
     "bun": ">=1.0"