@yolo-labs/yolobridge 0.15.0 → 0.17.0

package/dist/cli.js

@@ -17,7 +17,8 @@
  * YOLOBRIDGE_AUTH_URL for local dev against a different environment.
  */
 import { fileURLToPath } from 'node:url';
-import { realpathSync } from 'node:fs';
+import path from 'node:path';
+import { realpathSync, existsSync, readFileSync } from 'node:fs';
 import { hostname } from 'node:os';
 import { runLogin } from './login-cmd.js';
 import { runAttachFromDisk, pickWorkspaceFromDisk } from './attach-cmd.js';
@@ -99,6 +100,7 @@ function printHelp() {
         '                         that check entirely.',
         '  detach                 Detach the current workspace attachment.',
         '  status                 Print local login/attach state.',
+        '  version                Print the installed yolo-bridge version (also --version, -v).',
         '  --help                 Print this help.',
         '',
         `API base:   ${apiUrl()} (override: YOLOBRIDGE_API_URL)`,
@@ -559,6 +561,35 @@ async function cmdWorkspaces() {
     process.stdout.write(`${formatWorkspacesTable(result.workspaces)}\n`);
     return 0;
 }
+/**
+ * This package's own version, read from the package.json that ships beside
+ * `dist/`.
+ *
+ * Resolved from `import.meta.url`, NOT `process.argv[1]`: the global install
+ * puts a symlink on PATH, and argv[1] is that symlink's unresolved path, so
+ * walking up from it lands outside the package. Same reasoning as
+ * `isMainModule` below.
+ *
+ * Returns `'unknown'` rather than throwing — a version probe must never be the
+ * thing that stops the CLI from starting.
+ */
+export function readOwnVersion() {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        // dist/cli.js -> package root. Walk up a couple of levels so this holds
+        // whether it is run from `dist/` or from a ts-node-style layout.
+        for (const rel of ['..', '../..']) {
+            const candidate = path.join(here, rel, 'package.json');
+            if (!existsSync(candidate))
+                continue;
+            const parsed = JSON.parse(readFileSync(candidate, 'utf-8'));
+            if (parsed.name === '@yolo-labs/yolobridge' && typeof parsed.version === 'string')
+                return parsed.version;
+        }
+    }
+    catch { /* fall through */ }
+    return 'unknown';
+}
 async function main() {
     const [, , cmd, ...rest] = process.argv;
     switch (cmd) {
@@ -572,6 +603,11 @@ async function main() {
             return cmdDetach();
         case 'status':
             return cmdStatus();
+        case 'version':
+        case '--version':
+        case '-v':
+            process.stdout.write(`${readOwnVersion()}\n`);
+            return 0;
         case '--help':
         case '-h':
         case undefined:

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.15.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",