@yolo-labs/yolobridge 0.7.1 → 0.9.0

package/dist/attach-cmd.js

@@ -419,54 +419,72 @@ export async function runAttachDaemon(deps) {
             return { ok: true };
         }
     }
-    // Cover the case where the daemon is (re)started against a token that's
-    // already within the refresh buffer of expiry (e.g. `attach` run right
-    // after a long-down period) — refresh before the very first network
-    // call, not just before subsequent reconnects.
-    const initialRefresh = await ensureFreshToken();
     /**
      * RESUME an existing attachment from its persisted scoped credential
-     * (card 08), instead of creating a new one.
+     * (card 08), instead of creating a second one.
      *
-     * Deliberately reached ONLY when the account credential cannot do a fresh
-     * attach. A healthy account token takes the ordinary path, byte for byte as
-     * before — resuming is a recovery route, not a new default, so it cannot
-     * change what a normal `yolo-bridge attach` does.
+     * **LIVENESS decides, not the account token's health** (D7). Card 08 gated
+     * this on the account refresh having failed, which meant a daemon restarting
+     * with a healthy account token ignored a perfectly good stored attachment and
+     * called `attach` again — a SECOND server-side attachment and a second tile.
+     * The first stops heartbeating and is reaped, but the operator is left
+     * looking at a duplicate. Account-token health says nothing about whether the
+     * attachment is still alive, so it was never the right question.
      *
-     * The case it exists for is the one this card creates: a daemon that has run
-     * for days renewing its scoped credential, whose account access token expired
-     * on day one and whose refresh token is deliberately no longer on disk. Its
-     * restart has no account credential at all — but it does still hold a
-     * workspace-scoped one, which is precisely the credential the attachment's
-     * own routes want. Without this the operator is sent back to
-     * `yolo-bridge login` for a session that never actually lost anything.
+     * The probe is card 07's own renewal route
+     * (`POST .../yolobridge/attach/:attachmentId/refresh`). That route re-reads
+     * live attachment state on every call and 403s a detached one, so it is
+     * simultaneously the liveness check AND the source of a fresh credential —
+     * there is deliberately no second probe to drift out of agreement with it.
      *
-     * No window check here on purpose: the SERVER is the authority on whether a
-     * credential is still renewable (card 07's grace-window comment), and the
-     * renewal that runs before the stream opens asks it. If the answer is no, the
-     * daemon stops with card 07's own re-attach remedy rather than inventing a
-     * second, possibly-drifted opinion about the window here.
+     * A failure of ANY kind (403 detached, 401 past the renewal window, a
+     * network error) is not fatal here: it just means there is nothing to
+     * resume, and the ordinary attach path below runs. The server, not this
+     * binary's copy of the window, is the authority on which it was.
      */
     let resumed = false;
-    if (!initialRefresh.ok) {
+    if (!deps.fresh) {
         const stored = loadAttachment(env, io);
         if (stored &&
             stored.workspaceId === workspaceId &&
             stored.scopedToken !== undefined &&
             stored.scopedTokenExpiresAtMs !== undefined) {
-            attachmentId = stored.attachmentId;
-            tileId = stored.tileId;
-            attachedAt = stored.attachedAt;
-            rememberScopedCredential(stored.scopedToken, stored.scopedTokenExpiresAtMs);
-            resumed = true;
+            try {
+                // A one-off config rather than `scopedCfg()`: the stored token is not
+                // adopted as THE credential until the server has confirmed it is
+                // still good, so a failed probe leaves the daemon's own state
+                // untouched and the fall-through is a clean ordinary attach.
+                const renewed = await apiClient.refreshScopedToken({ commonApiBaseUrl, accessToken: stored.scopedToken, fetchImpl }, workspaceId, stored.attachmentId);
+                attachmentId = stored.attachmentId;
+                tileId = stored.tileId;
+                attachedAt = stored.attachedAt;
+                rememberScopedCredential(renewed.scopedToken, renewed.scopedTokenExpiresAt);
+                resumed = true;
+            }
+            catch (err) {
+                // Pre-spawn, so `log` is safe here (nothing owns the terminal yet) —
+                // and worth saying out loud: the operator is about to get a NEW tile
+                // where they may have expected the old one back.
+                const message = err instanceof Error ? err.message : String(err);
+                log(`Stored attachment is no longer resumable (${message}) — attaching fresh.`);
+            }
         }
-        else {
+    }
+    if (!resumed) {
+        // ONLY the attach path needs the account credential — attach is the call
+        // that creates the scope, and nothing after it presents an account token.
+        // Keeping this refresh inside the branch is the ordering win D7 exists
+        // for: a daemon whose account token expired days ago, but whose
+        // attachment is still live, resumes above and never reaches this line.
+        // (It also still covers the original reason it existed: an `attach` run
+        // right after a long-down period, against a token already inside the
+        // refresh buffer, rotates before the very first network call.)
+        const initialRefresh = await ensureFreshToken();
+        if (!initialRefresh.ok) {
             log(`Token refresh failed: ${initialRefresh.message}`);
             log('Run `yolo-bridge login` again.');
             return { ok: false, reason: 'refresh-failed', message: initialRefresh.message };
         }
-    }
-    if (!resumed) {
         try {
             const result = await apiClient.attach(accountCfg, workspaceId, hostLabel, remoteHost);
             attachmentId = result.attachmentId;

package/dist/cli.js

@@ -94,6 +94,10 @@ function printHelp() {
         '    [--agent-id <id>]    Registry identity for local MCP access, if different from --agent',
         '                         (e.g. a raw executable path, or an agent whose binary name differs',
         '                         from its registry id like qwen-code/qwen). Defaults to --agent.',
+        '    [--fresh]            Always create a NEW attachment and tile. By default an attach that',
+        '                         finds a still-live attachment for this workspace on this machine',
+        '                         RESUMES it (same tile) instead of adding a duplicate; --fresh skips',
+        '                         that check entirely.',
         '  detach                 Detach the current workspace attachment.',
         '  status                 Print local login/attach state.',
         '  --help                 Print this help.',
@@ -139,8 +143,16 @@ export function parseAttachArgs(args) {
     let hostLabel;
     let agentBin;
     let agentId;
+    let fresh = false;
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
+        // Boolean — handled before the value-taking flags so it never swallows
+        // the following argument (`attach --fresh w1` must still see `w1` as the
+        // positional workspace id).
+        if (a === '--fresh') {
+            fresh = true;
+            continue;
+        }
         if (a === '--label' || a === '--agent' || a === '--agent-id') {
             const value = args[i + 1];
             if (value === undefined || value.startsWith('--')) {
@@ -162,7 +174,7 @@ export function parseAttachArgs(args) {
             workspaceId = a;
         }
     }
-    return { workspaceId, hostLabel, agentBin, agentId };
+    return { workspaceId, hostLabel, agentBin, agentId, fresh };
 }
 /**
  * Everything the attach handshake tells the workspace about this machine,
@@ -210,7 +222,7 @@ async function cmdAttach(args) {
     const parsed = parseAttachArgs(args);
     if ('error' in parsed) {
         process.stderr.write(`yolo-bridge attach: ${parsed.error}\n`);
-        process.stderr.write('Usage: yolo-bridge attach [workspaceId] [--label <name>] [--agent <binary>] [--agent-id <registryId>]\n');
+        process.stderr.write('Usage: yolo-bridge attach [workspaceId] [--label <name>] [--agent <binary>] [--agent-id <registryId>] [--fresh]\n');
         return 64;
     }
     let workspaceId = parsed.workspaceId;
@@ -222,6 +234,7 @@ async function cmdAttach(args) {
     // match, which is every built-in agent this daemon has been used with so
     // far (claude, codex).
     const resolvedAgentId = parsed.agentId ?? agentBin ?? DEFAULT_AGENT_BIN;
+    const fresh = parsed.fresh === true;
     if (workspaceId) {
         const resolved = await resolveWorkspaceIdOrName(workspaceId, { commonApiBaseUrl: apiUrl() });
         if (!resolved.ok) {
@@ -250,7 +263,7 @@ async function cmdAttach(args) {
                     process.stderr.write(`yolo-bridge attach: ${pick.message}\n`);
                     break;
             }
-            process.stderr.write('Usage: yolo-bridge attach [workspaceId] [--label <name>] [--agent <binary>] [--agent-id <registryId>]\n');
+            process.stderr.write('Usage: yolo-bridge attach [workspaceId] [--label <name>] [--agent <binary>] [--agent-id <registryId>] [--fresh]\n');
             return 64;
         }
         workspaceId = pick.workspaceId;
@@ -286,6 +299,7 @@ async function cmdAttach(args) {
             commonApiBaseUrl: apiUrl(),
             hostLabel: attachHostInfo.hostLabel,
             remoteHost: attachHostInfo.remoteHost,
+            fresh,
             shouldStop: () => stopRequested,
             // Fires once the real tileId exists (docs/YOLOBRIDGE_PLAN.md's "Local
             // MCP access" section) — starts the local MCP proxy and writes

package/dist/local-agent.js

@@ -124,22 +124,177 @@ function resolveRows(opts) {
         return DEFAULT_ROWS;
     return process.stdout.rows || DEFAULT_ROWS;
 }
+const DEFAULT_ATTRS = {
+    bold: false,
+    dim: false,
+    italic: false,
+    underline: false,
+    inverse: false,
+    strikethrough: false,
+    fgMode: 'default',
+    fgColor: 0,
+    bgMode: 'default',
+    bgColor: 0,
+};
+function attrsAreDefault(a) {
+    return (!a.bold &&
+        !a.dim &&
+        !a.italic &&
+        !a.underline &&
+        !a.inverse &&
+        !a.strikethrough &&
+        a.fgMode === 'default' &&
+        a.bgMode === 'default');
+}
+/** `38;…` / `48;…` (or the compact 30-37/90-97/40-47/100-107 forms). */
+function colorCodes(mode, color, fg) {
+    if (mode === 'default')
+        return [fg ? '39' : '49'];
+    if (mode === 'rgb') {
+        // Typings: RGB mode packs the colour as 0xRRGGBB.
+        const r = (color >> 16) & 0xff;
+        const g = (color >> 8) & 0xff;
+        const b = color & 0xff;
+        return [`${fg ? 38 : 48};2;${r};${g};${b}`];
+    }
+    // Palette: 0-255. 0-7 and 8-15 have compact single-code forms; the rest
+    // need the indexed form.
+    if (color < 8)
+        return [String((fg ? 30 : 40) + color)];
+    if (color < 16)
+        return [String((fg ? 90 : 100) + (color - 8))];
+    return [`${fg ? 38 : 48};5;${color}`];
+}
+/**
+ * The SGR parameters that move `prev` to `next` — EMPTY when nothing
+ * changed, which is what keeps the payload small (see
+ * `serializeTerminalBuffer`).
+ */
+function sgrDiff(prev, next) {
+    const codes = [];
+    // Bold and dim share one "off" code (22), so turning either off means
+    // re-asserting whichever of the two survives.
+    if ((prev.bold && !next.bold) || (prev.dim && !next.dim)) {
+        codes.push('22');
+        if (next.bold)
+            codes.push('1');
+        if (next.dim)
+            codes.push('2');
+    }
+    else {
+        if (!prev.bold && next.bold)
+            codes.push('1');
+        if (!prev.dim && next.dim)
+            codes.push('2');
+    }
+    if (prev.italic !== next.italic)
+        codes.push(next.italic ? '3' : '23');
+    if (prev.underline !== next.underline)
+        codes.push(next.underline ? '4' : '24');
+    if (prev.inverse !== next.inverse)
+        codes.push(next.inverse ? '7' : '27');
+    if (prev.strikethrough !== next.strikethrough)
+        codes.push(next.strikethrough ? '9' : '29');
+    if (prev.fgMode !== next.fgMode || prev.fgColor !== next.fgColor) {
+        codes.push(...colorCodes(next.fgMode, next.fgColor, true));
+    }
+    if (prev.bgMode !== next.bgMode || prev.bgColor !== next.bgColor) {
+        codes.push(...colorCodes(next.bgMode, next.bgColor, false));
+    }
+    return codes;
+}
 /**
- * Serializes the terminal's current buffer (scrollback + viewport) to
- * plain text — no ANSI/SGR escape codes. Deliberately not using
- * `@xterm/addon-serialize`: that addon's `serialize()` reconstructs a
- * VT100-replayable stream (colors, cursor moves included) for re-feeding
- * into another terminal, which is the wrong shape for `read_tile_output`
- * — the consumer on the other end (an orchestrator tile, possibly an
- * LLM) wants clean text, not escape sequences. Walking `buffer.active`
- * directly and calling `translateToString` per line gives exactly that.
+ * Serializes the terminal's current buffer (scrollback + viewport) to text
+ * that keeps the agent's COLOUR and text styling, as SGR escapes only.
+ *
+ * Still deliberately not `@xterm/addon-serialize`: that addon reconstructs
+ * a fully VT100-replayable stream — cursor moves, scroll regions, mode
+ * switches — for re-feeding into another terminal, which is the wrong
+ * shape for `read_tile_output`. Its consumers (the browser tile, and an
+ * orchestrator/LLM reading the same capture) want the SCREEN as lines,
+ * with the styling that makes an agent's output readable, and nothing
+ * that repositions a cursor. So we walk `buffer.active` cell by cell and
+ * re-emit just the SGR state.
+ *
+ * Payload discipline is the reason this walks cells rather than emitting
+ * per cell: an escape is written ONLY where the attribute state actually
+ * changes, so a screen of unstyled text emits ZERO escapes and is
+ * byte-identical to what the old `translateToString(true)` produced. That
+ * matters — this capture is polled on an interval and crosses the
+ * network on every poll.
+ *
+ * Each line is self-contained: any line that ends with non-default
+ * attributes is closed with a reset, so state cannot bleed into the next
+ * line (the webapp splits this on `\n` and renders lines independently).
+ *
+ * NOT preserved, by design: cursor position, the alternate-screen flag,
+ * scroll regions, hyperlinks (OSC 8), and blink/invisible/overline — none
+ * of them survive into a static, line-split view.
  */
 export function serializeTerminalBuffer(term) {
     const buffer = term.buffer.active;
     const lines = [];
     for (let i = 0; i < buffer.length; i++) {
         const line = buffer.getLine(i);
-        lines.push(line ? line.translateToString(true) : '');
+        if (!line) {
+            lines.push('');
+            continue;
+        }
+        // Collect first, so trailing blanks can be trimmed before any escape
+        // is emitted for them (matching the old `translateToString(true)`).
+        const cells = [];
+        for (let x = 0; x < line.length; x++) {
+            const cell = line.getCell(x);
+            if (!cell)
+                continue;
+            // Width 0 = the right half of a wide (CJK/emoji) glyph; its content
+            // already came out of the width-2 cell before it. Emitting it too
+            // would duplicate the character.
+            if (cell.getWidth() === 0)
+                continue;
+            // An untouched cell has no content at all; it renders as a space.
+            const chars = cell.getChars();
+            cells.push({
+                text: chars === '' ? ' ' : chars,
+                attrs: {
+                    bold: !!cell.isBold(),
+                    dim: !!cell.isDim(),
+                    italic: !!cell.isItalic(),
+                    underline: !!cell.isUnderline(),
+                    inverse: !!cell.isInverse(),
+                    strikethrough: !!cell.isStrikethrough(),
+                    fgMode: cell.isFgRGB() ? 'rgb' : cell.isFgPalette() ? 'palette' : 'default',
+                    // In default mode the colour NUMBER is meaningless (the typings
+                    // say "should be 0"; the runtime actually reports -1). Normalise
+                    // it so two default cells compare equal and emit no escape.
+                    fgColor: cell.isFgDefault() ? 0 : cell.getFgColor(),
+                    bgMode: cell.isBgRGB() ? 'rgb' : cell.isBgPalette() ? 'palette' : 'default',
+                    bgColor: cell.isBgDefault() ? 0 : cell.getBgColor(),
+                },
+            });
+        }
+        // Right-trim, as before — but only cells that are blank AND unstyled.
+        // A run of spaces carrying a background colour is real, visible output
+        // (a status bar, a selection); dropping it would lose the paint.
+        while (cells.length > 0) {
+            const last = cells[cells.length - 1];
+            if (last.text === ' ' && attrsAreDefault(last.attrs))
+                cells.pop();
+            else
+                break;
+        }
+        let out = '';
+        let state = DEFAULT_ATTRS;
+        for (const cell of cells) {
+            const codes = sgrDiff(state, cell.attrs);
+            if (codes.length > 0)
+                out += `\x1b[${codes.join(';')}m`;
+            out += cell.text;
+            state = cell.attrs;
+        }
+        if (!attrsAreDefault(state))
+            out += '\x1b[0m';
+        lines.push(out);
     }
     while (lines.length > 0 && lines[lines.length - 1] === '')
         lines.pop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolo-labs/yolobridge",
-  "version": "0.7.1",
+  "version": "0.9.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",