roforge-cli 0.3.2 → 0.3.4

package/bin/roforge.js

@@ -9,7 +9,7 @@ import { Session } from "../src/session.js";
 import { BridgeServer } from "../src/bridge/server.js";
 import { probeMcp } from "../src/mcp.js";
 import { TUI } from "../src/tui/tui.js";
-import { bold, dim, red, green, cyan, yellow, gray } from "../src/tui/ansi.js";
+import { bold, dim, red, green, cyan, yellow, gray, magenta } from "../src/tui/ansi.js";
 
 const argv = process.argv.slice(2);
 const command = argv[0] || "tui";
@@ -262,6 +262,66 @@ async function main() {
       return;
     }
 
+    case "install-plugin": {
+      const { PLUGINS, findPluginSource, installPlugin, pluginsDir } = await import("../src/install.js");
+      const which = (flags._pos && flags._pos[0]) || "bridge";
+      if (flags.list || flags.l) {
+        console.log(bold("Roblox Studio plugins folder:") + ` ${pluginsDir()}`);
+        return;
+      }
+      if (!PLUGINS[which]) {
+        console.error(red(`unknown plugin: ${which} (expected: ${Object.keys(PLUGINS).join(" | ")})`));
+        process.exit(1);
+      }
+      const src = findPluginSource(which);
+      if (!src) {
+        console.error(red("no built plugin found in this install."));
+        console.error(dim("  from a git clone: rojo build -o studio-bridge/dist/RoForgeBridge.rbxm studio-bridge/default.project.json"));
+        process.exit(1);
+      }
+      const { dest } = installPlugin(which);
+      console.log(bold("RoForge plugin installed") + dim(" — " + PLUGINS[which].desc + "\n"));
+      console.log(`  ${green("✓")} ${src}\n  →  ${dest}\n`);
+      console.log(bold("Next:"));
+      console.log("  1. start (or restart) Roblox Studio");
+      console.log("  2. File → Plugins → Manage Plugins — " + which + " is now listed");
+      console.log("  3. run `roforge studio` (or the TUI) and paste the printed token into the plugin dock");
+      return;
+    }
+
+    case "pro": {
+      const { queryProStatus, renderProStatus, probeBridge, startOwnBridge } = await import("../src/pro.js");
+      const port = flags.port ? Number(flags.port) : cfg.bridge.port;
+      const host = cfg.bridge.host;
+      const token = cfg.bridge.token;
+      const base = `http://${host}:${port}`;
+      console.log(bold("RoForge Pro") + dim(" — license status\n"));
+      // Attach to an already-running bridge (e.g. `roforge studio`);
+      // otherwise start a throwaway one for the plugin to connect to.
+      const health = await probeBridge(base);
+      if (health) {
+        const res = await queryProStatus(null, { port, token, baseUrl: base });
+        console.log(renderProStatus(res, { bold, dim, red, green, magenta, yellow }) + "\n");
+        return;
+      }
+      const bridge = startOwnBridge({ port, host, token });
+      try {
+        await bridge.start();
+      } catch (e) {
+        console.error(red(`bridge could not start on port ${port}: ${e.message}`));
+        process.exit(1);
+      }
+      // The plugin pings every ~1s; give it a moment to show up if it's up.
+      const deadline = Date.now() + 6000;
+      while (!bridge.connected && Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 250));
+      }
+      const res = await queryProStatus(bridge, { port, token });
+      console.log(renderProStatus(res, { bold, dim, red, green, magenta, yellow }) + "\n");
+      bridge.stop();
+      return;
+    }
+
     case "help":
     case "--help":
     case "-h": {
@@ -375,6 +435,8 @@ ${bold("Usage")}
   roforge tools               list all tools
   roforge login --provider <p> store a key (gemini|groq|openrouter|anthropic|openai)
   roforge providers           list providers, keys, and auto-routing order
+  roforge install-plugin      install the RoForge Bridge plugin into Studio
+  roforge pro                 show RoForge Pro license status (needs Studio bridge)
   roforge analyze <file...>   run the official Luau analyzer on files
   roforge config [set k v]    show / set configuration
   roforge version
@@ -382,14 +444,15 @@ ${bold("Usage")}
 ${bold("How it connects to Studio")}
   1. Built-in MCP (recommended): Studio → File → Studio Settings → Beta Features →
      ${bold("MCP Server")} — roforge talks to it at http://localhost:3004/mcp automatically.
-  2. RoForge Bridge plugin: install studio-bridge/dist/RoForgeBridge.rbxm into Studio,
-     paste the bridge token (shown by ${bold("roforge studio")}) into the plugin.
+  2. RoForge Bridge plugin (not in the Roblox Toolbox — install from here):
+     ${bold("roforge install-plugin")}  →  Studio: File → Plugins (it's now listed)
+     then paste the bridge token (shown by ${bold("roforge studio")}) into the plugin dock.
 
 ${bold("Model providers (BYOK, zero backend)")}
   auto (default): first configured key wins, free tiers first:
   gemini → groq → openrouter → anthropic → openai
   free tiers: Gemini 2.5 Flash (~1,500 req/day), Groq Llama 3.3 70B (~1,000 req/day),
-  OpenRouter ":free" models (e.g. qwen/qwen3-coder:free)
+  OpenRouter ":free" models (e.g. nvidia/nemotron-3-super-120b-a12b:free)
   pin: --provider <p> or --model <provider>:<model> · ROFORGE_FREE_FIRST=0
 
 ${bold("Config & keys")}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roforge-cli",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "RoForge \u2014 Claude-Code-style local AI agent for Roblox Studio. BYOK, zero backend, zero dependencies.",
   "type": "module",
   "bin": {
@@ -30,6 +30,7 @@
   "files": [
     "bin",
     "src",
+    "dist",
     "demo",
     "README.md"
   ],

package/src/bridge/server.js

@@ -10,11 +10,12 @@ import http from "node:http";
 import { json } from "./wire.js";
 
 export class BridgeServer {
-  constructor({ port, host = "127.0.0.1", token, jobTimeoutMs = 60000 }) {
+  constructor({ port, host = "127.0.0.1", token, jobTimeoutMs = 60000, completedTtlMs = 30000 }) {
     this.port = port;
     this.host = host;
     this.token = token;
     this.jobTimeoutMs = jobTimeoutMs;
+    this.completedTtlMs = completedTtlMs;
     this.jobs = new Map(); // id → {id, tool, args, status, resolve, timer}
     this.lastPingAt = null;
     this.lastSeenAt = null;
@@ -45,7 +46,7 @@ export class BridgeServer {
   stop() {
     for (const job of this.jobs.values()) {
       clearTimeout(job.timer);
-      job.resolve({ ok: false, error: "bridge shut down" });
+      if (typeof job.resolve === "function") job.resolve({ ok: false, error: "bridge shut down" });
     }
     this.jobs.clear();
     if (this.server) {
@@ -114,20 +115,91 @@ export class BridgeServer {
           }
           clearTimeout(job.timer);
           const out = body.error ? { ok: false, error: body.error } : { ok: true, result: body.result ?? "" };
-          this.jobs.delete(job.id);
-          job.resolve(out);
+          job.status = "done";
+          job.out = out;
+          if (typeof job.resolve === "function") job.resolve(out);
+          this._retire(job);
           emit("job_done", { id: job.id, ...out });
           json(res, 200, { ok: true });
         });
         return;
       }
 
+      // Enqueue a job from an authenticated client (used by `roforge pro`
+      // attaching to an already-running bridge). The plugin still discovers
+      // it via the normal GET /jobs claim path.
+      if (req.method === "POST" && path === "/v1/bridge/jobs/enqueue") {
+        let body = {};
+        const chunks = [];
+        let size = 0;
+        req.on("data", (c) => {
+          size += c.length;
+          if (size < 1024 * 1024) chunks.push(c);
+        });
+        req.on("end", () => {
+          try {
+            body = chunks.length ? JSON.parse(Buffer.concat(chunks).toString("utf8")) : {};
+          } catch {
+            body = {};
+          }
+          if (typeof body.tool !== "string" || !body.tool) {
+            return json(res, 400, { error: "missing tool", code: "BAD_REQUEST" });
+          }
+          const id = this.enqueueRemote(body.tool, body.args ?? {});
+          json(res, 200, { ok: true, id });
+        });
+        return;
+      }
+
+      // Poll a (possibly completed) job's status — read by an attaching client.
+      const gs = /^\/v1\/bridge\/jobs\/(\w+)$/.exec(path);
+      if (req.method === "GET" && gs) {
+        const st = this.jobStatus(gs[1]);
+        if (!st) return json(res, 404, { error: "unknown job", code: "JOB_NOT_FOUND" });
+        return json(res, 200, { ok: true, ...st });
+      }
+
       return json(res, 404, { error: `no route: ${req.method} ${path}`, code: "NOT_FOUND" });
     } catch (e) {
       json(res, 500, { error: e.message, code: "INTERNAL" });
     }
   }
 
+  // Keep a finished job readable for a short window (so an attaching client
+  // can poll its result), then drop it. Unref'd: housekeeping must not keep
+  // the CLI process (or test runner) alive.
+  _retire(job) {
+    const t = setTimeout(() => {
+      if (this.jobs.get(job.id) === job) this.jobs.delete(job.id);
+    }, this.completedTtlMs);
+    if (typeof t.unref === "function") t.unref();
+  }
+
+  // Enqueue a job on behalf of a remote (attaching) client. Returns the id to
+  // poll. The plugin claims it through the normal GET /jobs path.
+  enqueueRemote(tool, args, { timeoutMs = this.jobTimeoutMs } = {}) {
+    const id = `job_${this.nextJobId++}`;
+    const job = { id, tool, args, status: "pending", remote: true, out: null, resolve: null, claimedAt: null, timer: null };
+    job.timer = setTimeout(() => {
+      if (this.jobs.get(id) === job && job.status !== "done") {
+        job.status = "timeout";
+        job.out = { ok: false, error: `studio job timed out after ${Math.round(timeoutMs / 1000)}s` };
+        this._retire(job);
+      }
+    }, timeoutMs);
+    this.jobs.set(id, job);
+    return id;
+  }
+
+  // Current status of a job for a poller: {id, status} while in flight, or
+  // {id, status:"done"|"timeout", ...out} once finished. null if unknown.
+  jobStatus(id) {
+    const job = this.jobs.get(id);
+    if (!job) return null;
+    if (job.status === "pending" || job.status === "claimed") return { id, status: job.status };
+    return { id, status: job.status, ...(job.out || {}) };
+  }
+
   // Submit a tool job and wait for the plugin's result. Resolves to
   // {ok:true, result:string} or {ok:false, error:string}.
   submit(tool, args, { timeoutMs = this.jobTimeoutMs } = {}) {

package/src/config.js

@@ -188,6 +188,7 @@ export function resolveConfig() {
   if (process.env.ROFORGE_PROVIDER) cfg.provider = process.env.ROFORGE_PROVIDER;
   if (process.env.ROFORGE_MCP_URL) cfg.mcpUrl = process.env.ROFORGE_MCP_URL;
   if (process.env.ROFORGE_BRIDGE_PORT) cfg.bridge.port = Number(process.env.ROFORGE_BRIDGE_PORT);
+  if (process.env.ROFORGE_BRIDGE_TOKEN) cfg.bridge.token = process.env.ROFORGE_BRIDGE_TOKEN;
   if (process.env.ROFORGE_STUDIO_MODE) cfg.studioMode = process.env.ROFORGE_STUDIO_MODE;
   if (process.env.ROFORGE_MAX_ITERATIONS) cfg.maxIterations = Number(process.env.ROFORGE_MAX_ITERATIONS);
   if (process.env.ROFORGE_FREE_FIRST === "0" || process.env.ROFORGE_FREE_FIRST === "false") cfg.freeFirst = false;

package/src/install.js

@@ -0,0 +1,72 @@
+// Plugin installation: copy a built .rbxm into the OS Roblox Studio plugins
+// folder so it appears under Studio's plugin page.
+//
+// Sources are resolved in this order:
+//   1. the npm package's bundled copy (cli/dist/<name>.rbxm) — works when
+//      installed via `npm i -g roforge-cli`
+//   2. the repo layout (<repoRoot>/studio-bridge/dist or <repoRoot>/client/dist)
+//      — works when running from a git clone
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url)); // cli/src
+
+export const PLUGINS = {
+  bridge: {
+    dest: "RoForgeBridge.rbxm",
+    desc: "RoForge Bridge (loopback bridge driven by the roforge CLI — tools, vision, Pro status)",
+    repoRel: path.join("..", "..", "studio-bridge", "dist"),
+  },
+  client: {
+    dest: "RoForge.rbxm",
+    desc: "RoForge (in-Studio chat dock; standalone mode)",
+    repoRel: path.join("..", "..", "client", "dist"),
+  },
+};
+
+// Studio scans these folders for plugins.
+export function pluginsDir(env = process.env, platform = process.platform, home = os.homedir()) {
+  switch (platform) {
+    case "win32":
+      return path.join(env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "Roblox", "Plugins");
+    case "darwin":
+      return path.join(home, "Documents", "Roblox", "Plugins");
+    default:
+      return path.join(env.XDG_DATA_HOME || path.join(home, ".local", "share"), "Roblox", "Plugins");
+  }
+}
+
+// Find the built .rbxm for `name`. Returns an absolute path or null.
+export function findPluginSource(name, { packageDir = path.join(here, "..") } = {}) {
+  const meta = PLUGINS[name];
+  if (!meta) return null;
+  const candidates = [
+    path.join(packageDir, "dist", meta.dest), // npm bundle
+    path.join(here, meta.repoRel, meta.dest), // git clone
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+// Copy the plugin into the plugins folder. `destDir` overrides the target
+// (tests). Returns { src, dest }.
+export function installPlugin(name, { destDir } = {}) {
+  const meta = PLUGINS[name];
+  if (!meta) throw new Error(`unknown plugin: ${name} (expected: ${Object.keys(PLUGINS).join(" | ")})`);
+  const src = findPluginSource(name);
+  if (!src) {
+    throw new Error(
+      `no built plugin found (${meta.dest}). From a git clone run: ` +
+        `rojo build -o studio-bridge/dist/RoForgeBridge.rbxm studio-bridge/default.project.json`
+    );
+  }
+  const dir = destDir || pluginsDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const dest = path.join(dir, meta.dest);
+  fs.copyFileSync(src, dest);
+  return { src, dest };
+}

package/src/pro.js

@@ -0,0 +1,126 @@
+// RoForge Pro — CLI-side status plumbing.
+//
+// The entitlement itself is checked inside Studio by the bridge plugin
+// (MarketplaceService only exists there). This module reaches the connected
+// Studio and renders its `forge_pro` report for `roforge pro`.
+//
+// Two ways to reach Studio, tried in order:
+//   1. ATTACH — if a bridge is already running on the configured port (e.g.
+//      `roforge studio` is up and the plugin is bound to it), enqueue the
+//      forge_pro job on that bridge and poll for the result. This is the
+//      normal case: you check Pro while your Studio session is live.
+//   2. OWN — otherwise start a throwaway bridge on the configured port, wait
+//      for the plugin (bound to the same port + token) to connect, submit,
+//      and stop. This lets `roforge pro` work standalone too.
+
+import { BridgeServer } from "./bridge/server.js";
+
+const HEALTH_PATH = "/health";
+
+// Probe for an already-running bridge on baseUrl. Returns the /health body
+// ({ok, service, connected, port}) or null when nothing is listening.
+export async function probeBridge(baseUrl, { timeoutMs = 1200 } = {}) {
+  try {
+    const r = await fetch(`${baseUrl}${HEALTH_PATH}`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!r.ok) return null;
+    const j = await r.json();
+    return j && j.service === "roforge-bridge" ? j : null;
+  } catch {
+    return null;
+  }
+}
+
+// Enqueue `tool` on a running bridge and poll for the result. Resolves to
+// {ok, result?/error}. `connected` lets the caller fail fast when the plugin
+// isn't actually bound to this bridge.
+export async function remoteSubmit(baseUrl, token, tool, args, { timeoutMs = 20000, pollMs = 150 } = {}) {
+  const auth = { authorization: `Bearer ${token}`, "content-type": "application/json" };
+  const enq = await fetch(`${baseUrl}/v1/bridge/jobs/enqueue`, {
+    method: "POST",
+    headers: auth,
+    body: JSON.stringify({ tool, args }),
+  });
+  if (!enq.ok) {
+    let msg = `HTTP ${enq.status}`;
+    try { msg = (await enq.json()).error || msg; } catch { /* keep status */ }
+    return { ok: false, error: msg };
+  }
+  const { id } = await enq.json();
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const st = await (await fetch(`${baseUrl}/v1/bridge/jobs/${id}`, { headers: { authorization: `Bearer ${token}` } })).json();
+    if (st.status === "done") {
+      return st.error ? { ok: false, error: st.error } : { ok: true, result: st.result ?? "" };
+    }
+    if (st.status === "timeout") return { ok: false, error: st.error || "studio job timed out" };
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return { ok: false, error: "timed out waiting for Studio" };
+}
+
+// Query Pro status, attaching to a running bridge when present. Returns
+// { text } on success, { error } otherwise. `bridge` may be null to force the
+// "own bridge" path (used by tests).
+export async function queryProStatus(bridge, { port, token, baseUrl, timeoutMs = 20000 } = {}) {
+  const base = baseUrl || `http://127.0.0.1:${port}`;
+
+  // Path 1: attach to a running bridge.
+  if (!bridge) {
+    const health = await probeBridge(base);
+    if (health) {
+      if (!health.connected) {
+        return {
+          error:
+            "A bridge is running but Studio is not connected. Open Roblox Studio with the " +
+            "RoForge Bridge plugin active and paste the bridge token into it.",
+        };
+      }
+      const out = await remoteSubmit(base, token, "forge_pro", {}, { timeoutMs });
+      if (!out.ok) return { error: out.error };
+      return { text: String(out.result ?? "") };
+    }
+  }
+
+  // Path 2: own bridge (already started by the caller).
+  if (!bridge || !bridge.connected) {
+    return {
+      error:
+        "No Studio bridge connection. Pro status is checked inside Studio (MarketplaceService), " +
+        "so this needs the RoForge Bridge plugin running and connected.",
+    };
+  }
+  const out = await bridge.submit("forge_pro", {}, { timeoutMs });
+  if (!out.ok) return { error: out.error };
+  return { text: String(out.result ?? "") };
+}
+
+// Start a throwaway bridge for the "own bridge" path. Returns the started
+// BridgeServer or throws on EADDRINUSE.
+export function startOwnBridge({ port, host = "127.0.0.1", token }) {
+  const bridge = new BridgeServer({ port, host, token });
+  return bridge;
+}
+
+// Render the forge_pro report (plain text from the plugin) with minimal
+// styling: the tier header gets color, the rest stays as-is.
+export function renderProStatus(res, { bold, dim, red, green, magenta, yellow } = {}) {
+  const id = (fn, s) => (fn ? fn(s) : String(s));
+  if (res && res.error) {
+    return (
+      id(red, res.error) +
+      "\n" +
+      id(dim, "  1. open Roblox Studio with the RoForge Bridge plugin\n") +
+      id(dim, "  2. run `roforge studio` here and paste the token it prints into the plugin\n") +
+      id(dim, "  3. re-run `roforge pro` while both are running")
+    );
+  }
+  const lines = String(res?.text ?? "").split("\n");
+  const out = [];
+  for (const line of lines) {
+    if (line.startsWith("RoForge Pro: PRO")) out.push(id(green, line));
+    else if (line.startsWith("RoForge Pro: FREE")) out.push(id(yellow, line));
+    else if (line.startsWith("Unlock Pro:")) out.push(id(magenta, line));
+    else out.push(line);
+  }
+  return out.join("\n");
+}

package/src/session.js

@@ -60,7 +60,18 @@ export class Session {
     if (this.studioInfo.bridge) studio.push("The RoForge Bridge plugin is available (forge_* tools) — it connects when Studio is open and the bridge plugin is active.");
     const caps = (this.studioInfo.mcpCapture || []).map((n) => `studio_${n}`).join(", ");
     if (caps) studio.push(`Studio's MCP exposes vision tools (${caps}) — they return an image you can SEE; prefer them for visual checks.`);
-    if (!studio.length) studio.push("No Studio connection yet — forge_* tools will error until Studio is open with the RoForge Bridge plugin (or enable Studio's built-in MCP beta).");
+    if (!studio.length) {
+      studio.push(
+        "No Studio connection yet — forge_* tools will error until Studio is connected. " +
+          "If the user asks how to connect, give EXACTLY these steps (do not invent others — the RoForge " +
+          "Bridge plugin is NOT in the Roblox Toolbox): (1) run `roforge install-plugin` to install the " +
+          "bundled plugin into Studio's plugins folder, or in Studio use File → Plugins → Manage Plugins → " +
+          "Install File… with studio-bridge/dist/RoForgeBridge.rbxm from https://github.com/hacvilke/roforge; " +
+          "(2) open the RoForge Bridge dock and paste the bridge token shown by `roforge studio` (or in this " +
+          "TUI's /studio output); (3) the status turns green when connected. Alternative: enable Studio's " +
+          "built-in MCP (File → Studio Settings → Beta Features → MCP Server) — no plugin needed."
+      );
+    }
 
     return `You are RoForge, a local AI agent for Roblox development, running on the user's machine (Claude-Code-style). You work on two surfaces:
 

package/src/tools/studio.js

@@ -28,6 +28,7 @@ const BRIDGE_TOOL_NAMES = [
   "forge_diff",
   "forge_export",
   "forge_import",
+  "forge_pro",
 ];
 
 const BRIDGE_DESCRIPTIONS = {
@@ -53,8 +54,9 @@ const BRIDGE_DESCRIPTIONS = {
   forge_bulk_create: "Create many instances in one call (paste-style): items[] of {path: parent path, class_name, name?, properties?}. Destructive.",
   forge_snapshot: "Capture the current instance tree under a name, so forge_diff can show what changed later. Keeps the last 10.",
   forge_diff: "Compare a snapshot to the current instance tree: added (+) and removed (-) instances. Omit name to diff the most recent snapshot.",
-  forge_export: "Export a DataModel subtree as JSON (properties, script sources truncated, attributes). Defaults to workspace, depth 3 (max 6).",
-  forge_import: "Apply a forge_export JSON back into Studio: recreates the instance tree (properties, sources, attributes) under a parent. dry_run=true only reports. Destructive; max 500 nodes.",
+  forge_export: "Export a DataModel subtree as JSON (properties, script sources truncated, attributes). Defaults to workspace, depth 3 (max 6; 10 with RoForge Pro).",
+  forge_import: "Apply a forge_export JSON back into Studio: recreates the instance tree (properties, sources, attributes) under a parent. dry_run=true only reports. Destructive; max 500 nodes (2500 with RoForge Pro).",
+  forge_pro: "Report the current RoForge Pro entitlement: Free or Pro, which pass/product the Studio user owns, and the active limits + Pro features. Call it to know whether the user has Pro.",
 };
 
 const BRIDGE_SCHEMAS = {
@@ -213,6 +215,7 @@ const BRIDGE_SCHEMAS = {
     },
     additionalProperties: false,
   },
+  forge_pro: { type: "object", properties: {}, additionalProperties: false },
 };
 
 // Tools that modify the DataModel — gated by the approval prompt.

package/src/tui/tui.js

@@ -303,11 +303,14 @@ export class TUI {
     else lines.push(`${red("○")} studio MCP (built-in): not reachable @ ${this.session.cfg.mcpUrl}` + dim(" (File → Studio Settings → Beta Features → MCP Server)"));
     if (this.session.bridgeServer) {
       const b = this.session.bridgeServer;
-      lines.push(
-        b.connected
-          ? `${green("●")} bridge plugin: connected (http://${b.host}:${b.port})`
-          : `${yellow("○")} bridge plugin: waiting for Studio (http://${b.host}:${b.port})`
-      );
+      if (b.connected) {
+        lines.push(`${green("●")} bridge plugin: connected (http://${b.host}:${b.port})`);
+      } else {
+        lines.push(
+          `${yellow("○")} bridge plugin: waiting for Studio (http://${b.host}:${b.port})` +
+            dim(` — run \`roforge install-plugin\` if not installed; token to paste in the plugin dock: ${b.token}`)
+        );
+      }
     }
     return lines.join("\n");
   }