@yolo-labs/yolobridge 0.16.0 → 0.17.0

package/dist/local-agent.js

@@ -412,10 +412,16 @@ export function computeUsedRows(term) {
     }
     return used;
 }
-/** The PTY's grid, which the tile must render at EXACTLY (it cannot be
- *  resized — the human at the keyboard is watching the same PTY), plus how
+/** The PTY's CURRENT grid, which the tile must render at EXACTLY, plus how
  *  much of that grid is in USE.
  *
+ *  The viewer must not resize this grid — the human at the keyboard is
+ *  watching the same PTY, so a cloud-side resize would reach over and reflow
+ *  their real screen. But the human themselves CAN resize it, and when they
+ *  do the ring restarts under a fresh epoch (see `handleLocalResize`), so a
+ *  viewer holding the old geometry re-seeds rather than replaying old bytes
+ *  against a grid that no longer exists.
+ *
  *  ⚠️ `usedRows` IS NOT A SECOND GEOMETRY. It never changes `cols`/`rows` and
  *  the viewer never resizes its terminal to it: a viewer's terminal that is
  *  not exactly `cols`×`rows` cannot replay the daemon's bytes (relative cursor
@@ -679,6 +685,12 @@ export function startLocalAgent(opts = {}) {
     // explicitly to disable stdin piping entirely, distinct from omitting the
     // field (which defaults to wiring up the real `process.stdin`).
     const inStream = 'stdin' in opts ? opts.stdin : process.stdin;
+    // Same defaulting rule as `resolveCols`/`resolveRows`: only reach for the real
+    // `process.stdout` when nothing was injected, so a test with a fake sink does
+    // not silently pick up the CI runner's terminal.
+    const resizeSource = 'resizeSource' in opts
+        ? opts.resizeSource
+        : (opts.stdout === undefined ? process.stdout : undefined);
     const ptyProcess = spawnImpl(agentBin, agentArgs, {
         name: 'xterm-256color',
         cols,
@@ -706,8 +718,14 @@ export function startLocalAgent(opts = {}) {
         writeChain: Promise.resolve(),
         stdin: inStream,
         rawModeEnabled: false,
+        resizeSource,
     };
     current = state;
+    if (resizeSource && typeof resizeSource.on === 'function') {
+        const resizeListener = () => handleLocalResize(state);
+        state.resizeListener = resizeListener;
+        resizeSource.on('resize', resizeListener);
+    }
     ptyProcess.onData((data) => {
         state.lastOutputAt = Date.now();
         outStream.write(data);
@@ -756,7 +774,53 @@ export function startLocalAgent(opts = {}) {
  * exit code 124. With `stdin.pause()` added below, the same repro exits
  * cleanly on its own well under a second — no timeout/kill needed.
  */
+/**
+ * The human at the keyboard resized their terminal window.
+ *
+ * WHY THIS EXISTS: the PTY size used to be treated as fixed at spawn, on the
+ * reasoning that "nothing resizes this PTY, least of all the cloud". The cloud
+ * half of that is right and still enforced — a viewer must never reach over and
+ * reflow the operator's real screen. The other half was simply wrong: the human
+ * watching this PTY through `process.stdout` can drag their window, Node raises
+ * `'resize'` on SIGWINCH, and we ignored it. The child kept rendering to the old
+ * grid, so the operator's own terminal garbled and the tile kept reporting a
+ * geometry that no longer matched anything.
+ *
+ * Everything retained in the ring was captured against a grid that no longer
+ * exists — relative cursor moves and the scroll region are defined against the
+ * REAL grid, so replaying those bytes at the new size garbles rather than
+ * degrades. A fresh epoch is the honest answer: the viewer re-seeds from the
+ * current buffer instead of splicing two geometries together.
+ */
+function handleLocalResize(state) {
+    const src = state.resizeSource;
+    if (!src)
+        return;
+    const cols = src.columns ?? 0;
+    const rows = src.rows ?? 0;
+    // A stdout that has stopped being a TTY (piped, or the window is gone)
+    // reports 0/undefined. Resizing a PTY to zero wedges the child.
+    if (cols < 1 || rows < 1)
+        return;
+    // SIGWINCH also fires for changes that are not a size change. Resizing to the
+    // size we already have would burn an epoch and force a pointless re-seed.
+    if (cols === state.cols && rows === state.rows)
+        return;
+    state.cols = cols;
+    state.rows = rows;
+    state.term.resize(cols, rows);
+    rawRing = newRawRing(rows);
+    try {
+        state.ptyProcess.resize(cols, rows);
+    }
+    catch {
+        // The child is already gone; onExit will clear `current`.
+    }
+}
 function teardownStdio(state) {
+    if (state.resizeSource && state.resizeListener && typeof state.resizeSource.removeListener === 'function') {
+        state.resizeSource.removeListener('resize', state.resizeListener);
+    }
     const { stdin, stdinListener } = state;
     if (stdin && stdinListener && typeof stdin.removeListener === 'function') {
         stdin.removeListener('data', stdinListener);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolo-labs/yolobridge",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "YoloBridge — local coding-agent daemon that attaches a user's own Claude Code/Codex session to a YOLO Studio workspace as a first-class tile (docs/YOLOBRIDGE_PLAN.md, build-order Phase 5).",
   "license": "MIT",
   "type": "module",