@yolo-labs/yolobridge 0.27.0 → 0.28.0

package/dist/api-client.js

@@ -187,6 +187,32 @@ export async function openStream(cfg, workspaceId, attachmentId) {
     }
     return res;
 }
+/**
+ * Tell the server where this daemon's LOCAL terminal server is listening.
+ *
+ * ⚠️ Uses the daemon's SCOPED token, and the route requires one. It is the
+ * mirror of the input route's rule: only a USER may type, and only the machine
+ * actually running the server may say where it is. A user token here would let
+ * anyone point a tile at an arbitrary address.
+ *
+ * Best-effort by design — returns false rather than throwing. A daemon whose
+ * report fails is still a perfectly good daemon; the tile simply falls back to
+ * the cloud relay, which is slower and works.
+ */
+export async function reportLocalEndpoint(cfg, workspaceId, attachmentId, url, secret) {
+    const fetchImpl = cfg.fetchImpl ?? fetch;
+    try {
+        const res = await fetchImpl(`${base(cfg)}/v1/workspaces/${workspaceId}/yolobridge/attach/${attachmentId}/local-endpoint`, {
+            method: 'POST',
+            headers: { ...authHeaders(cfg), 'Content-Type': 'application/json' },
+            body: JSON.stringify({ url, secret }),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
 export async function postHeartbeat(cfg, workspaceId, attachmentId) {
     const body = await postEvent(cfg, workspaceId, { attachmentId, type: 'heartbeat' });
     return Boolean(body?.recorded);

package/dist/attach-cmd.js

@@ -900,6 +900,20 @@ export async function runAttachDaemon(deps) {
                                             return;
                                         }
                                         await apiClient.postHeartbeat(scopedCfg(), workspaceId, attachmentId);
+                                        // ⚠️ RE-REPORTED ON EVERY BEAT, not once at startup. The
+                                        // server holds this in memory with a TTL, so it is lost
+                                        // on a restart or a failover — and the correct recovery
+                                        // is the daemon simply saying it again a few seconds
+                                        // later, not the server persisting a secret. Best-effort:
+                                        // a failed report costs the tile its fast path, nothing
+                                        // more.
+                                        // Read LAZILY: the shell server starts inside
+                                        // `onAttached`, after these deps were built, so a
+                                        // snapshot taken at construction would always be empty.
+                                        const local = deps.localEndpoint?.();
+                                        if (local) {
+                                            await apiClient.reportLocalEndpoint(scopedCfg(), workspaceId, attachmentId, local.url, local.secret);
+                                        }
                                     }, (err) => {
                                         // The heartbeat hits the SAME boundary as the stream open
                                         // and gets the SAME 403, so it needs the same answer: a
@@ -912,6 +926,19 @@ export async function runAttachDaemon(deps) {
                                             detail: `heartbeat error: ${err instanceof Error ? err.message : String(err)}`,
                                         });
                                     }, undefined, deps.timers);
+                                    // ⚠️ REPORT THE LOCAL ENDPOINT IMMEDIATELY TOO, not only on
+                                    // the interval. Waiting ~10s means a tile opened in that
+                                    // window gets a 404 and silently downgrades to the ~200ms
+                                    // relay, while a perfectly good local server is already
+                                    // listening — and it would stay downgraded for that whole
+                                    // session. Same reasoning as the immediate heartbeat below.
+                                    // (codex P2.)
+                                    {
+                                        const local = deps.localEndpoint?.();
+                                        if (local) {
+                                            apiClient.reportLocalEndpoint(scopedCfg(), workspaceId, attachmentId, local.url, local.secret).catch(() => { });
+                                        }
+                                    }
                                     // Send one immediately so status isn't stale for the first ~10s.
                                     apiClient.postHeartbeat(scopedCfg(), workspaceId, attachmentId).catch((err) => {
                                         if (noteCredentialRejection(err))

package/dist/cli.js

@@ -356,6 +356,12 @@ async function cmdAttach(args) {
     let result;
     try {
         result = await runAttachFromDisk({
+            // Read lazily on each heartbeat — the shell server starts in
+            // `onAttached`, after this object is built, so a value here would
+            // always be undefined.
+            localEndpoint: () => (shellServerHandle
+                ? { url: shellServerHandle.url, secret: shellServerHandle.secret }
+                : undefined),
             workspaceId,
             commonApiBaseUrl: apiUrl(),
             hostLabel: attachHostInfo.hostLabel,

package/dist/local-shell-server.js

@@ -38,16 +38,30 @@
  * why the client must treat "no answer" as a timeout and fall back, never wait
  * forever.
  *
- * ⚠️ KNOWN GAP — RECONNECT FIDELITY FOR TUIs. The backlog is a byte TAIL, cut
- * at a parser-safe boundary. That is enough to resume a shell transcript, and
- * NOT enough to reconstruct a full-screen TUI that painted its layout once and
- * then emitted more than `BACKLOG_CHARS` of cursor-addressed updates: a viewer
- * reconnecting mid-session gets the updates without the screen they address,
- * and sticky modes set before the window are lost. The cloud path already
- * solved this properly — `local-agent.ts` keeps an `@xterm/headless` mirror and
- * serves a serialized screen plus a mode `prologue` — and `@xterm/headless` is
- * already a dependency here. Doing the same for these shells is the next slice;
- * it is called out rather than left to be discovered. (codex P2.)
+ * ⚠️ THE BACKLOG DOES NOT RECONSTRUCT A TUI SCREEN — AND NOTHING CURRENTLY
+ * NEEDS IT TO. Worth stating precisely, because the obvious next step here is
+ * speculative work.
+ *
+ * The backlog is a byte TAIL cut at a parser-safe boundary. It cannot rebuild a
+ * full-screen TUI that painted its layout once and then emitted more than
+ * `BACKLOG_CHARS` of cursor-addressed updates: a viewer joining mid-session
+ * would get the updates without the screen they address. The cloud path solved
+ * that properly — `local-agent.ts` keeps an `@xterm/headless` mirror and serves
+ * a serialized screen plus a mode `prologue` — and that dependency is already
+ * here, so doing the same looks like the natural next slice.
+ *
+ * IT IS NOT, because no client reconnects. `openLocalTerminal` establishes the
+ * stream exactly once; a stream that ends marks the session DEAD rather than
+ * retrying, and the tile never reuses a session id — every mount opens a fresh
+ * shell. So the replay only ever covers output produced between `/open` and
+ * `/stream`, a window of milliseconds inside a single connection, where a byte
+ * tail is exactly right.
+ *
+ * ⚠️ WHAT WOULD MAKE IT MATTER: adding session RESUMPTION — a tile that
+ * reattaches to its shell across a remount, a dropped stream, or a page
+ * refresh. That is a real feature and a reasonable one to want. The headless
+ * mirror is a prerequisite FOR IT, not an improvement on its own; building the
+ * mirror first would be solving the second half of a problem nobody has yet.
  *
  * SECURITY, deliberately narrow because this hands out shells:
  *   · bound to 127.0.0.1 ONLY — never 0.0.0.0, so it is off the local network

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolo-labs/yolobridge",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "YoloBridge \u2014 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",