@yolo-labs/yolobridge 0.25.0 → 0.27.0

package/dist/api-client.js

@@ -324,100 +324,3 @@ export async function deliverShare(cfg, workspaceId, attachmentId, assetId, targ
     }
     return (await res.json());
 }
-/**
- * Send raw console keystrokes toward a daemon.
- *
- * ⚠️ Authenticates as the USER, not as a daemon. The console runs on a machine
- * the operator is sitting at; the daemon's workspace-scoped token belongs to the
- * machine being typed INTO and never leaves it. The route enforces the same
- * thing from the other side by refusing a scoped token outright.
- *
- * Returns the server's delivery verdict rather than a bare boolean, because the
- * distinction is real: 'written' means a replica put the frame on the daemon's
- * own stream, 'relayed' means it was handed off and nobody has confirmed it.
- */
-export async function sendConsoleInput(cfg, workspaceId, attachmentId, data) {
-    const fetchImpl = cfg.fetchImpl ?? fetch;
-    const res = await fetchImpl(`${base(cfg)}/v1/workspaces/${workspaceId}/yolobridge/attach/${attachmentId}/input`, {
-        method: 'POST',
-        headers: { ...authHeaders(cfg), 'Content-Type': 'application/json' },
-        body: JSON.stringify({ data }),
-    });
-    if (!res.ok) {
-        const { message, code } = await parseErrorBody(res);
-        throw new YoloBridgeApiError(message, res.status, code);
-    }
-    const body = (await res.json().catch(() => ({})));
-    return body.delivery === 'written' ? 'written' : 'relayed';
-}
-/** Register as an output viewer, which is what makes the daemon stream at all. */
-export async function subscribeOutput(cfg, workspaceId, tileId, subscriptionId) {
-    const fetchImpl = cfg.fetchImpl ?? fetch;
-    const res = await fetchImpl(`${base(cfg)}/v1/workspaces/${workspaceId}/yolobridge/tiles/${tileId}/output/subscribe`, {
-        method: 'POST',
-        headers: { ...authHeaders(cfg), 'Content-Type': 'application/json' },
-        body: JSON.stringify({ subscriptionId }),
-    });
-    if (!res.ok) {
-        const { message, code } = await parseErrorBody(res);
-        throw new YoloBridgeApiError(`could not subscribe to output: ${message}`, res.status, code);
-    }
-    return (await res.json().catch(() => ({})));
-}
-export async function unsubscribeOutput(cfg, workspaceId, tileId, subscriptionId) {
-    const fetchImpl = cfg.fetchImpl ?? fetch;
-    await fetchImpl(`${base(cfg)}/v1/workspaces/${workspaceId}/yolobridge/tiles/${tileId}/output/unsubscribe`, {
-        method: 'POST',
-        headers: { ...authHeaders(cfg), 'Content-Type': 'application/json' },
-        body: JSON.stringify({ subscriptionId }),
-    }).catch(() => { });
-}
-/** The workspace event stream, where relayed PTY output arrives. */
-export async function openWorkspaceEventStream(cfg, workspaceId) {
-    const fetchImpl = cfg.fetchImpl ?? fetch;
-    // ⚠️ THE TOKEN GOES IN THE QUERY STRING, not the Authorization header.
-    // `routes/events.ts` reads `req.query.token` exclusively — because browsers'
-    // EventSource cannot send custom headers — and when it is absent the route
-    // answers HTTP 200 with an SSE `error` frame saying "Token required". So a
-    // header-only client is ACCEPTED by fetch and then shows nothing, forever,
-    // with no failure anywhere to notice. (codex P1.)
-    const url = `${base(cfg)}/v1/events/stream`
-        + `?workspaceId=${encodeURIComponent(workspaceId)}`
-        + `&token=${encodeURIComponent(cfg.accessToken)}`;
-    const res = await fetchImpl(url, { headers: { ...authHeaders(cfg), Accept: 'text/event-stream' } });
-    if (!res.ok || !res.body) {
-        const { message, code } = await parseErrorBody(res);
-        throw new YoloBridgeApiError(`event stream failed: ${message}`, res.status, code);
-    }
-    return res;
-}
-/**
- * Fetch the RAW replay seed for a tile — the tail of the daemon's PTY byte
- * stream plus the absolute offsets that say where it ends.
- *
- * ⚠️ `mode=raw`, not the default. The default returns a SERIALIZED SCREEN, which
- * is a rendering, not a byte stream: writing it into a terminal and then
- * appending live chunks puts the cursor somewhere the daemon never put it. Only
- * the raw form can be continued from.
- *
- * Returns undefined rather than throwing when the seed is unavailable — a
- * detached or briefly unreachable daemon answers 409, and a console that can
- * still stream live output should start blank rather than refuse to run.
- */
-export async function readRawOutputSeed(cfg, workspaceId, tileId) {
-    const fetchImpl = cfg.fetchImpl ?? fetch;
-    const res = await fetchImpl(`${base(cfg)}/v1/workspaces/${workspaceId}/yolobridge/tiles/${tileId}/output?mode=raw`, { headers: authHeaders(cfg) });
-    if (!res.ok)
-        return undefined;
-    const body = (await res.json().catch(() => undefined));
-    return body && typeof body.raw === 'string' ? body : undefined;
-}
-export async function resolveAttachmentTile(cfg, workspaceId, attachmentId) {
-    const fetchImpl = cfg.fetchImpl ?? fetch;
-    const res = await fetchImpl(`${base(cfg)}/v1/workspaces/${workspaceId}`, { headers: authHeaders(cfg) });
-    if (!res.ok)
-        return undefined;
-    const body = (await res.json().catch(() => ({})));
-    const tiles = body.tiles ?? body.workspace?.tiles ?? [];
-    return tiles.find((t) => t?.yoloBridge?.attachmentId === attachmentId)?.id;
-}

package/dist/cli.js

@@ -3,13 +3,22 @@
  * `yolo-bridge` — YoloBridge local daemon CLI (docs/YOLOBRIDGE_PLAN.md,
  * Implementation Plan → build-order step 5).
  *
- * Subcommands:
+ * Subcommands (keep in step with `printHelp` — this list is what a reader of
+ * the file sees first, and it silently fell five commands behind before):
  *   yolo-bridge login                 — device-authorization flow (login-cmd.ts)
  *   yolo-bridge workspaces            — list selectable workspaces (workspaces-cmd.ts)
  *   yolo-bridge attach [workspaceId]  — attach + hold the SSE stream (attach-cmd.ts)
  *                                        (omit the id for an interactive picker)
  *   yolo-bridge detach                — DELETE the current attachment (detach-cmd.ts)
+ *   yolo-bridge console               — REMOVED in 0.26.0; prints where to go instead
+ *   yolo-bridge allow <path>          — approve a path the attached agent may
+ *                                        send files from (approved-paths.ts)
+ *   yolo-bridge share <path>          — push a local file to the workspace,
+ *                                        optionally into a tile (share-cmd.ts)
+ *   yolo-bridge deliver <assetId>     — write an ALREADY-shared file into a
+ *                                        tile's session (share-cmd.ts)
  *   yolo-bridge status                — print local login/attach state (status-cmd.ts)
+ *   yolo-bridge version               — print the installed version (also --version, -v)
  *
  * Base URLs default to this repo's real hostnames (CLAUDE.md → Project
  * Overview): common-api `https://api.yolo.studio`, auth-service
@@ -23,16 +32,27 @@ import { hostname } from 'node:os';
 import { runLogin } from './login-cmd.js';
 import { runAttachFromDisk, pickWorkspaceFromDisk } from './attach-cmd.js';
 import { runShare, runDeliver } from './share-cmd.js';
-import { runConsole } from './console-cmd.js';
 import { runAllow } from './approved-paths.js';
 import { runDetach } from './detach-cmd.js';
 import { getStatus, formatStatus } from './status-cmd.js';
 import { startLocalAgent, stopLocalAgent, DEFAULT_AGENT_BIN } from './local-agent.js';
 import { runListWorkspaces, formatWorkspacesTable } from './workspaces-cmd.js';
 import { startMcpProxy, mcpUrl, SECRET_ENV_VAR } from './mcp-proxy.js';
+import { startLocalShellServer } from './local-shell-server.js';
 import { buildAgentMcpArgs } from './agent-mcp-args.js';
 const DEFAULT_API_URL = 'https://api.yolo.studio';
+const DEFAULT_WEBAPP_ORIGIN = 'https://yolo.studio';
 const DEFAULT_AUTH_URL = 'https://auth.yololabs.ai';
+/**
+ * The ONE browser origin allowed to reach the local terminal server.
+ *
+ * ⚠️ Never a wildcard: this authorises reaching a shell on the operator's
+ * machine, so it is a single exact origin. Overridable only for local
+ * development against a different webapp host.
+ */
+function webappOrigin() {
+    return process.env.YOLOBRIDGE_WEBAPP_ORIGIN || DEFAULT_WEBAPP_ORIGIN;
+}
 function apiUrl() {
     return process.env.YOLOBRIDGE_API_URL || DEFAULT_API_URL;
 }
@@ -105,10 +125,8 @@ function printHelp() {
         '  allow <path>           Let the ATTACHED AGENT send files from this path. You type',
         '                         this; nothing in the cloud can. Also --list and --remove <path>.',
         '                         The daemon\'s own working directory is always allowed.',
-        '  console [workspaceId]  Attach a REAL TERMINAL to a bridged session on another',
-        '    [--attachment <id>]  machine. Ctrl+C goes to the agent; Ctrl-P Ctrl-Q leaves,',
-        '                         and the agent keeps running. Defaults to this machine\'s',
-        '                         own attachment when run with no arguments.',
+        '  console                REMOVED in 0.26.0. Use the YoloBridge tile\'s "open terminal"',
+        '                         control, which spawns a terminal tile wired to the session.',
         '  share <path>           Share a local file with the attached workspace, so a cloud',
         '                         agent can see it. Push only — nothing reads your disk remotely.',
         '    [--to <tileId>]      Also write it into that tile\'s session, so its agent can open it.',
@@ -320,6 +338,14 @@ async function cmdAttach(args) {
         cliVersion: readOwnVersion(),
     });
     let mcpProxyHandle;
+    /**
+     * Serves terminals on 127.0.0.1 for the tile's "open terminal".
+     *
+     * ⚠️ SEPARATE FROM THE AGENT PTY. `startLocalAgent` owns the one agent
+     * session; this owns any shells the operator opens from the workspace. They
+     * share a lifetime — both die with the attach — and nothing else.
+     */
+    let shellServerHandle;
     // argv fragment pointing the spawned agent at the local MCP proxy, or
     // `[]` when MCP isn't wired in — see `agent-mcp-args.ts`. Nothing else is
     // tracked for cleanup any more: as of 2026-08-26 `attach` writes NOTHING
@@ -356,6 +382,22 @@ async function cmdAttach(args) {
                 // prompt. MCP access is an enhancement on a tile that already works
                 // without it; the local agent spawning is not optional.
                 try {
+                    // The local terminal server. Started BEFORE the agent, like the MCP
+                    // proxy, so the endpoint exists by the time the tile could ask for
+                    // it. A failure here must not stop the attach: the agent and its
+                    // tile are the point, a local terminal is an extra.
+                    try {
+                        shellServerHandle = await startLocalShellServer({ allowedOrigin: webappOrigin() });
+                        // ⚠️ THE URL, NEVER THE SECRET. This line lands in the operator's
+                        // scrollback, which is exactly where things get copied into bug
+                        // reports and pasted into chats. The secret authorises spawning a
+                        // shell on this machine; it reaches the tile over the authenticated
+                        // workspace channel and is printed nowhere.
+                        process.stdout.write(`yolo-bridge: local terminals ready at ${shellServerHandle.url} (127.0.0.1 only)\n`);
+                    }
+                    catch (err) {
+                        process.stdout.write(`yolo-bridge: local terminals unavailable (${err instanceof Error ? err.message : String(err)}) — the attach continues without them.\n`);
+                    }
                     mcpProxyHandle = await startMcpProxy({
                         apiUrl: apiUrl(),
                         getAccessToken,
@@ -531,6 +573,17 @@ async function cmdAttach(args) {
         // or a reboot, and every skipped run left a file that broke the
         // operator's own standalone `claude` in that directory. Nothing written
         // is nothing to clean up.
+        // Same "nothing left running detached" rule as the MCP proxy: a shell the
+        // operator opened from the workspace must not outlive the attach that
+        // served it. `close()` kills every session it owns.
+        if (shellServerHandle) {
+            try {
+                await shellServerHandle.close();
+            }
+            catch (err) {
+                process.stdout.write(`yolo-bridge: local terminal shutdown failed (${err instanceof Error ? err.message : String(err)}).\n`);
+            }
+        }
         if (mcpProxyHandle) {
             try {
                 await mcpProxyHandle.stop();
@@ -596,26 +649,29 @@ function cmdStatus() {
     process.stdout.write(`${formatStatus(getStatus())}\n`);
     return 0;
 }
-async function cmdConsole(args) {
-    const attIdx = args.indexOf('--attachment');
-    const attachmentId = attIdx >= 0 ? args[attIdx + 1] : undefined;
-    if (attIdx >= 0 && (!attachmentId || attachmentId.startsWith('-'))) {
-        process.stderr.write('yolo-bridge console: `--attachment` needs an id.\n');
-        return 64;
-    }
-    const workspaceId = args.find((a, i) => !a.startsWith('-') && i !== attIdx + 1);
-    const result = await runConsole({ commonApiBaseUrl: apiUrl(), workspaceId, attachmentId });
-    if (!result.ok) {
-        process.stderr.write(`yolo-bridge console: ${result.message}\n`);
-        return 1;
-    }
-    if (result.reason === 'stream-ended') {
-        // Distinguished from a deliberate detach: the operator did not ask to
-        // leave, so say why the session ended rather than exiting silently.
-        process.stderr.write('yolo-bridge console: the connection ended.\n');
-        return 1;
-    }
-    return 0;
+/**
+ * REMOVED in 0.26.0 — kept as an explicit notice rather than falling through to
+ * "unknown command".
+ *
+ * A command that vanishes without explanation is worse than one that says why:
+ * anyone with it in muscle memory or a shell script gets a dead end and no
+ * pointer. This costs a few lines and answers the question.
+ */
+function cmdConsoleRemoved() {
+    process.stderr.write([
+        'yolo-bridge console was removed in 0.26.0.',
+        '',
+        'Open a terminal from the workspace instead: the YoloBridge tile has an',
+        '"open terminal" control that spawns a terminal tile wired to this session.',
+        '',
+        'It was built for reaching a session from a DIFFERENT machine\'s terminal,',
+        'which turned out not to be a use case anyone had. Nothing replaced it',
+        'because the tile does the job from the machine you are already on.',
+        '',
+        'Need it back? `npm i -g @yolo-labs/yolobridge@0.25.0` still has it.',
+        '',
+    ].join('\n'));
+    return 64;
 }
 async function cmdDeliver(args) {
     const assetId = args.find((a) => !a.startsWith('-') && a !== args[args.indexOf('--to') + 1]);
@@ -723,7 +779,7 @@ async function main() {
         case 'allow':
             return cmdAllow(rest);
         case 'console':
-            return cmdConsole(rest);
+            return cmdConsoleRemoved();
         case 'deliver':
             return cmdDeliver(rest);
         case 'share':