@yolo-labs/yolobridge 0.7.1 → 0.8.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/package.json

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