truecanvas 0.4.1 → 0.6.0

package/dist/cli.js

@@ -1,41 +1,64 @@
 #!/usr/bin/env node
 import {
+  addDevArgs,
+  connectAgents,
+  depVersion,
+  execInherit,
+  hasAgentConfig,
+  hubPort,
+  installedIn,
+  packageDir,
+  packageSpec,
+  packageVersion,
+  readJson,
+  readPackage,
+  runScript,
+  startHub
+} from "./chunk-NAK4DQWO.js";
+import {
+  CHUNK,
+  decodeFrame,
+  encodeFrame,
+  responseHeaders,
+  safePath,
   viewerHtml
-} from "./chunk-M7B3W7EP.js";
+} from "./chunk-OPKROZI2.js";
 import {
   DEVICES,
-  EditError,
   Workspace,
-  addArgs,
   assertCanvasName,
   clearCompare,
   componentsDir,
   configStatus,
   describeComponent,
-  detectPm,
-  findByPath,
   findDevice,
-  findNode,
   frameChanges,
   initProject,
   layoutFiles,
   listRoutes,
   outlineDoc,
-  parseCanvas,
   readDesignTokens,
   readTokenData,
-  run,
   shadcnAdd,
   shadcnRegistry,
   shadcnStatus,
-  shellSafe,
   syncComponentRegistry,
-  toolEnv,
   writeCompare
-} from "./chunk-A4QIAVTG.js";
+} from "./chunk-QJ5M3G4E.js";
+import {
+  EditError,
+  addArgs,
+  detectPm,
+  findByPath,
+  findNode,
+  parseCanvas,
+  run,
+  toolEnv
+} from "./chunk-D565QDII.js";
 import {
   loadConfig
-} from "./chunk-PBKX3SBC.js";
+} from "./chunk-OZOV4Y6C.js";
+import "./chunk-LKFOLM3L.js";
 import "./chunk-2IIAMOFH.js";
 import {
   ICON_LIBRARIES,
@@ -46,15 +69,15 @@ import {
 } from "./chunk-C4SATRZT.js";
 
 // src/cli/index.ts
-import { spawn as spawn3 } from "child_process";
-import fs13 from "fs";
-import path14 from "path";
+import { spawn } from "child_process";
+import fs9 from "fs";
+import path11 from "path";
 import { parseArgs } from "util";
 
 // src/server/http.ts
 import http from "http";
 import fs6 from "fs";
-import path7 from "path";
+import path8 from "path";
 import { randomUUID } from "crypto";
 import { fileURLToPath } from "url";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -62,6 +85,7 @@ import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import launchEditor from "launch-editor";
 
 // src/server/mcp.ts
+import path3 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 
@@ -281,9 +305,33 @@ async function connectReviewSite(url, token) {
   fs2.writeFileSync(file, JSON.stringify(site, null, 2), { mode: 384 });
   return res;
 }
+var ACCESS_MODES = ["invited", "password", "public"];
+async function siteFeatures(site) {
+  const res = await request(site, "GET", "/api/shares");
+  return res.features ?? [];
+}
+var NO_SIGN_IN = "This review site doesn't have sign-in yet. Update it (packages/review-worker) and set BETTER_AUTH_SECRET, STUDIO_EMAILS and STUDIO_EMAIL_FROM to invite people by email.";
 var MAX_FILE = 4.4 * 1024 * 1024;
 async function publishSnapshot(site, dir, manifest, opts = {}) {
-  const share = await request(site, "POST", "/api/shares", { project: manifest.project, canvas: manifest.canvas, title: opts.title ?? manifest.canvas });
+  const can = await siteFeatures(site);
+  const signIn = can.includes("access") && can.includes("invites");
+  if ((opts.access || opts.invite?.length) && !signIn) throw new Error(NO_SIGN_IN);
+  if (opts.access === "password" && !opts.password) throw new Error("Pass the password to protect the link with: --password <p>");
+  if (opts.live) {
+    const needed = "url" in opts.live ? "live-url" : "live-files";
+    if (!can.includes(needed))
+      throw new Error(
+        "url" in opts.live ? "This review site doesn't support live sites yet. Update it (packages/review-worker) to share a live URL." : "This review site doesn't host live sites. Deploy packages/review-worker with LIVE_HOST_SUFFIX set, or pass the URL where the site runs instead."
+      );
+    if ("dir" in opts.live && !fs2.statSync(opts.live.dir, { throwIfNoEntry: false })?.isDirectory()) throw new Error(`No build folder at ${opts.live.dir}`);
+  }
+  const firstAccess = signIn ? opts.access ?? (opts.password ? "password" : "invited") : void 0;
+  const share = await request(site, "POST", "/api/shares", {
+    project: manifest.project,
+    canvas: manifest.canvas,
+    title: opts.title ?? manifest.canvas,
+    ...firstAccess ? { access: firstAccess === "invited" ? "invited" : "public" } : {}
+  });
   const base = `/api/shares/${share.slug}`;
   const known = new Set((await request(site, "GET", `${base}/assets`)).assets);
   const files = [];
@@ -305,10 +353,64 @@ async function publishSnapshot(site, dir, manifest, opts = {}) {
   };
   await Promise.all(Array.from({ length: 4 }, worker));
   if (skipped.some((s) => s.endsWith(".html"))) throw new Error(`A frame is too large to upload (over 4.4 MB): ${skipped.filter((s) => s.endsWith(".html")).join(", ")}`);
-  const change = { ...opts.password !== void 0 ? { password: opts.password } : {}, ...opts.title ? { title: opts.title } : {} };
-  if (Object.keys(change).length) await request(site, "PATCH", base, change);
-  const done = await request(site, "POST", `${base}/versions`, { id: manifest.id, createdAt: manifest.createdAt, frames: manifest.frames });
-  return { url: done.url, version: manifest.id, versions: done.versions, uploaded, skipped, password: opts.password === void 0 ? share.password : !!opts.password };
+  if (opts.live && "dir" in opts.live) {
+    const liveDir = opts.live.dir;
+    const liveFiles = walk(liveDir);
+    const pending = [...liveFiles];
+    const liveWorker = async () => {
+      for (let rel = pending.shift(); rel; rel = pending.shift()) {
+        const body = fs2.readFileSync(path2.join(liveDir, rel));
+        if (body.length > MAX_FILE) {
+          skipped.push(`live/${rel}`);
+          continue;
+        }
+        await request(site, "PUT", `${base}/live/files?version=${manifest.id}`, body, { "x-path": rel, "content-type": contentType(rel) });
+        uploaded++;
+      }
+    };
+    await Promise.all(Array.from({ length: 6 }, liveWorker));
+  }
+  const change = {
+    ...opts.password !== void 0 ? { password: opts.password } : {},
+    ...opts.title ? { title: opts.title } : {},
+    ...opts.access ? { access: opts.access } : {}
+  };
+  let password = share.password;
+  let access = share.access ?? null;
+  if (Object.keys(change).length) {
+    const after = await request(site, "PATCH", base, change);
+    password = after.password;
+    access = after.access ?? access;
+  }
+  const live = opts.live ? "url" in opts.live ? { url: opts.live.url } : { files: true } : void 0;
+  const done = await request(site, "POST", `${base}/versions`, { id: manifest.id, createdAt: manifest.createdAt, frames: manifest.frames, live });
+  const invited = opts.invite?.length ? await inviteTo(site, share.slug, opts.invite) : [];
+  return { url: done.url, version: manifest.id, versions: done.versions, uploaded, skipped, password, live: done.live ?? null, access, invited };
+}
+async function inviteTo(site, slug, emails) {
+  const res = await request(site, "POST", `/api/shares/${slug}/invites`, { emails });
+  return res.invited;
+}
+function parseEmails(values) {
+  const all = (Array.isArray(values) ? values : values ? [values] : []).flatMap((v) => v.split(/[\s,;]+/));
+  const emails = [...new Set(all.map((e) => e.trim().toLowerCase()).filter(Boolean))];
+  const bad = emails.filter((e) => !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(e));
+  if (bad.length) throw new Error(`Not an email: ${bad.join(", ")}`);
+  return emails;
+}
+async function updateAccess(site, project, canvas, change) {
+  const can = await siteFeatures(site);
+  if (!can.includes("access") || !can.includes("invites")) throw new Error(NO_SIGN_IN);
+  const found = await request(site, "GET", `/api/shares?project=${encodeURIComponent(project)}&canvas=${encodeURIComponent(canvas)}`);
+  if (!found.slug) throw new Error(`${canvas} has no link yet. Share it first: npx truecanvas share ${canvas}`);
+  let access = null;
+  if (change.access || change.password) {
+    const after = await request(site, "PATCH", `/api/shares/${found.slug}`, { ...change.access ? { access: change.access } : {}, ...change.password ? { password: change.password } : {} });
+    access = after.access ?? null;
+  }
+  const invited = change.invite?.length ? await inviteTo(site, found.slug, change.invite) : [];
+  const share = await request(site, "GET", `/api/shares/${found.slug}`);
+  return { url: `${site.url}/s/${found.slug}`, access: access ?? share.access ?? null, invited };
 }
 async function deleteShare(site, project, canvas) {
   const found = await request(site, "GET", `/api/shares?project=${encodeURIComponent(project)}&canvas=${encodeURIComponent(canvas)}`);
@@ -339,12 +441,33 @@ async function request(site, method, route, body, headers = {}) {
   if (!res.ok) throw new Error(`Review site: ${data2.error ?? `${res.status} ${res.statusText}`}`);
   return data2;
 }
+function walk(root, rel = "") {
+  const out = [];
+  for (const entry of fs2.readdirSync(path2.join(root, rel), { withFileTypes: true })) {
+    if (entry.name.startsWith(".")) continue;
+    const child = rel ? `${rel}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) out.push(...walk(root, child));
+    else if (entry.isFile()) out.push(child);
+  }
+  return out;
+}
 function contentType(file) {
   const ext = path2.extname(file).slice(1).toLowerCase();
   const types = {
     html: "text/html; charset=utf-8",
+    css: "text/css; charset=utf-8",
+    js: "text/javascript; charset=utf-8",
+    mjs: "text/javascript; charset=utf-8",
+    json: "application/json",
+    map: "application/json",
+    txt: "text/plain; charset=utf-8",
+    xml: "application/xml",
+    webmanifest: "application/manifest+json",
+    wasm: "application/wasm",
+    pdf: "application/pdf",
     png: "image/png",
     jpg: "image/jpeg",
+    jpeg: "image/jpeg",
     webp: "image/webp",
     avif: "image/avif",
     gif: "image/gif",
@@ -375,7 +498,7 @@ Workflow:
 5. focus to show the user what you changed. Everything is undoable by the user.`;
 var literal = z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(z.union([z.string(), z.number(), z.boolean()]))]);
 var deviceIds = DEVICES.map((d) => d.id);
-function createMcpServer(ws, shots, session) {
+function createMcpServer(ws, shots, session, sessions) {
   const server = new McpServer({ name: "truecanvas", version: "0.1.0" }, { instructions: INSTRUCTIONS });
   const actor = () => {
     const name = server.server.getClientVersion()?.name ?? "agent";
@@ -985,10 +1108,14 @@ ${msgs}`;
       inputSchema: {
         ...canvasArg,
         frames: z.array(z.string()).optional().describe("Frame names to share; omit for all."),
-        title: z.string().optional().describe('Title the client sees, e.g. "Homepage, round 2".')
+        title: z.string().optional().describe('Title the client sees, e.g. "Homepage, round 2".'),
+        live: z.string().optional().describe('A live version clients open with "View live": the https URL where the app runs, or a static build folder (Next `out/`, Vite `dist/`, relative to the project) that the review site hosts.'),
+        invite: z.array(z.string()).optional().describe("Emails of people to invite (the client). Each gets an email with a link that signs them in and opens the design. Only invite addresses the user gave you."),
+        access: z.enum(["invited", "password", "public"]).optional().describe("Who can open the link: invited people (the default for new links on review sites with sign-in), a password (the user gives it to you), or anyone with the link. Existing links keep theirs unless this is set."),
+        password: z.string().optional().describe(`The link's password, with access "password".`)
       }
     },
-    async ({ canvas, frames, title }) => {
+    async ({ canvas, frames, title, live, invite, access, password }) => {
       try {
         const c2 = resolveCanvas(canvas);
         presence(c2, "looking", "Preparing a share link");
@@ -1000,8 +1127,55 @@ ${msgs}`;
         ].filter(Boolean);
         const site = reviewSite();
         if (!site) return text([`\u2713 Snapshot ready (${manifest.frames.length} frames). No review site is set up, so this is a local preview: ${preview}`, "To get client links, the user runs `npx truecanvas share setup`.", ...notes].join("\n"));
-        const published = await publishSnapshot(site, dir, manifest, { title });
-        return text([`\u2713 Shared ${manifest.frames.length} frame(s): ${published.url}`, `Version ${published.versions} of this link${published.password ? ", password protected" : ""}.`, ...notes].join("\n"));
+        const liveSite = live ? /^https?:\/\//.test(live) ? { url: live } : { dir: path3.resolve(ws.config.root, live) } : void 0;
+        const published = await publishSnapshot(site, dir, manifest, { title, live: liveSite, access, password, invite: invite?.length ? parseEmails(invite) : void 0 });
+        const who = published.access === "invited" ? ", invited people only" : published.access === "public" ? ", anyone with the link" : published.password ? ", password protected" : "";
+        return text(
+          [
+            `\u2713 Shared ${manifest.frames.length} frame(s): ${published.url}`,
+            `Version ${published.versions} of this link${who}.`,
+            published.live ? `Live version: ${published.live}` : "",
+            ...published.invited.map((i) => i.error ? `Couldn't email ${i.email}: ${i.error}` : `Invited ${i.email} (emailed a sign-in link).`),
+            published.access === "invited" && !published.invited.length ? "Only invited people and the studio can open it: share again with `invite` to invite the client." : "",
+            ...notes
+          ].filter(Boolean).join("\n")
+        );
+      } catch (e) {
+        return fail(e);
+      }
+    }
+  );
+  server.registerTool(
+    "start_session",
+    {
+      title: "Start a live session",
+      description: "Start a live session on a canvas's share link: while it runs, people with access to the link see the real frames from the app (not the frozen snapshot), they update as the canvas is edited, everyone sees each other's cursors, and comments arrive instantly. The canvas must have been shared once (share_canvas). It runs until stop_session or until Truecanvas stops. Only start one when the user asks.",
+      inputSchema: { ...canvasArg }
+    },
+    async ({ canvas }) => {
+      try {
+        if (!sessions) throw new Error("Live sessions run from the Truecanvas server (npx truecanvas).");
+        const c2 = resolveCanvas(canvas);
+        const s = await sessions.start(c2);
+        return text(`\u2713 Live session started on ${c2}: ${s.url}
+People with access to the link now see the frames live. Stop it with stop_session.`);
+      } catch (e) {
+        return fail(e);
+      }
+    }
+  );
+  server.registerTool(
+    "stop_session",
+    {
+      title: "Stop a live session",
+      description: "Stop a canvas's live session: the link goes back to its latest published version.",
+      inputSchema: { ...canvasArg }
+    },
+    async ({ canvas }) => {
+      try {
+        if (!sessions) throw new Error("Live sessions run from the Truecanvas server (npx truecanvas).");
+        const c2 = resolveCanvas(canvas);
+        return text(sessions.stop(c2) ? `\u2713 Stopped the live session on ${c2}.` : `${c2} has no live session.`);
       } catch (e) {
         return fail(e);
       }
@@ -1179,12 +1353,12 @@ ${out.out.slice(-1500)}`));
 // src/server/thumbnails.ts
 import crypto2 from "crypto";
 import fs3 from "fs";
-import path3 from "path";
+import path4 from "path";
 var Thumbnails = class _Thumbnails {
   constructor(ws, shots) {
     this.ws = ws;
     this.shots = shots;
-    this.dir = path3.join(ws.config.root, "node_modules", ".cache", "truecanvas", "thumbs");
+    this.dir = path4.join(ws.config.root, "node_modules", ".cache", "truecanvas", "thumbs");
   }
   ws;
   shots;
@@ -1210,7 +1384,7 @@ var Thumbnails = class _Thumbnails {
   key(spec, props) {
     let stamp = "";
     try {
-      const file = spec.library ? path3.join(this.ws.config.root, "node_modules", spec.library, "package.json") : path3.join(this.ws.config.root, spec.file);
+      const file = spec.library ? path4.join(this.ws.config.root, "node_modules", spec.library, "package.json") : path4.join(this.ws.config.root, spec.file);
       stamp = String(fs3.statSync(file).mtimeMs);
     } catch {
       stamp = "0";
@@ -1222,7 +1396,7 @@ var Thumbnails = class _Thumbnails {
     const spec = this.ws.catalog.get(name);
     if (!spec) throw new Error(`Unknown component ${name}`);
     const props = _Thumbnails.previewProps(spec, preset);
-    const file = path3.join(this.dir, `${name}-${this.key(spec, props)}.png`);
+    const file = path4.join(this.dir, `${name}-${this.key(spec, props)}.png`);
     if (fs3.existsSync(file)) return fs3.readFileSync(file);
     const job = this.queue.then(async () => {
       if (fs3.existsSync(file)) return fs3.readFileSync(file);
@@ -1240,10 +1414,10 @@ var Thumbnails = class _Thumbnails {
 // src/server/screenshot.ts
 import fs4 from "fs";
 import os2 from "os";
-import path4 from "path";
+import path5 from "path";
 function findChromium() {
   if (process.env.TRUECANVAS_CHROME) return process.env.TRUECANVAS_CHROME;
-  const cache2 = process.env.PLAYWRIGHT_BROWSERS_PATH || (process.platform === "win32" ? path4.join(process.env.LOCALAPPDATA ?? path4.join(os2.homedir(), "AppData", "Local"), "ms-playwright") : process.platform === "darwin" ? path4.join(os2.homedir(), "Library", "Caches", "ms-playwright") : path4.join(os2.homedir(), ".cache", "ms-playwright"));
+  const cache2 = process.env.PLAYWRIGHT_BROWSERS_PATH || (process.platform === "win32" ? path5.join(process.env.LOCALAPPDATA ?? path5.join(os2.homedir(), "AppData", "Local"), "ms-playwright") : process.platform === "darwin" ? path5.join(os2.homedir(), "Library", "Caches", "ms-playwright") : path5.join(os2.homedir(), ".cache", "ms-playwright"));
   if (fs4.existsSync(cache2)) {
     const shells = fs4.readdirSync(cache2).filter((d) => d.startsWith("chromium_headless_shell-")).sort().reverse();
     for (const d of shells) {
@@ -1255,14 +1429,14 @@ function findChromium() {
         "chrome-headless-shell-win64/chrome-headless-shell.exe",
         "chrome-win/headless_shell.exe"
       ]) {
-        const p = path4.join(cache2, d, sub);
+        const p = path5.join(cache2, d, sub);
         if (fs4.existsSync(p)) return p;
       }
     }
   }
   const programFiles = [process.env.PROGRAMFILES, process.env["PROGRAMFILES(X86)"], process.env.LOCALAPPDATA].filter(Boolean);
   for (const p of [
-    ...programFiles.flatMap((dir) => [path4.join(dir, "Google", "Chrome", "Application", "chrome.exe"), path4.join(dir, "Microsoft", "Edge", "Application", "msedge.exe")]),
+    ...programFiles.flatMap((dir) => [path5.join(dir, "Google", "Chrome", "Application", "chrome.exe"), path5.join(dir, "Microsoft", "Edge", "Application", "msedge.exe")]),
     "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
     "/usr/bin/chromium-browser",
     "/usr/bin/chromium",
@@ -1487,7 +1661,7 @@ ${root.outerHTML}`, css, canvases, height };
 
 // src/server/review.ts
 import fs5 from "fs";
-import path5 from "path";
+import path6 from "path";
 import { createHash } from "crypto";
 var actorName = (e) => e.actor.kind === "agent" ? e.actor.name : e.actor.kind === "file" ? "code editor" : "you";
 async function versionAt(ws, canvas, ref) {
@@ -1504,7 +1678,7 @@ async function versionAt(ws, canvas, ref) {
 }
 var readNow = (ws, file) => {
   try {
-    return fs5.readFileSync(path5.join(ws.config.root, file), "utf8");
+    return fs5.readFileSync(path6.join(ws.config.root, file), "utf8");
   } catch {
     return null;
   }
@@ -1631,33 +1805,17 @@ function prDesignSection(pages, images) {
   return lines.join("\n");
 }
 
-// src/server/body.ts
-async function readJson(req, limit = 8 * 1024 * 1024) {
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of req) {
-    size += chunk.length;
-    if (size > limit) throw new EditError("Request too large.");
-    chunks.push(chunk);
-  }
-  const raw = Buffer.concat(chunks).toString("utf8");
-  if (!raw) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    throw new EditError("The request body isn't valid JSON.");
-  }
-}
-
 // src/share/sync.ts
-import path6 from "path";
+import path7 from "path";
 var EVERY = 2e4;
 var LOOKUP_EVERY = 5 * 6e4;
 var CommentSync = class {
-  constructor(ws) {
+  constructor(ws, onClientMessage) {
     this.ws = ws;
+    this.onClientMessage = onClientMessage;
   }
   ws;
+  onClientMessage;
   links = /* @__PURE__ */ new Map();
   remote = /* @__PURE__ */ new Map();
   timer = null;
@@ -1700,7 +1858,7 @@ var CommentSync = class {
   async slugOf(site, canvas) {
     const known = this.links.get(canvas);
     if (known && (known.slug || Date.now() - known.at < LOOKUP_EVERY)) return known.slug;
-    const project = path6.basename(this.ws.config.root);
+    const project = path7.basename(this.ws.config.root);
     const res = await call(site, "GET", `/api/shares?project=${encodeURIComponent(project)}&canvas=${encodeURIComponent(canvas)}`);
     this.links.set(canvas, { slug: res.slug, at: Date.now() });
     return res.slug;
@@ -1714,6 +1872,10 @@ var CommentSync = class {
     this.remote.set(slug, { updated: res.updated, threads: remote });
     const byId = new Map(remote.map((t) => [t.id, t]));
     const dismissed = this.ws.comments.dismissed(canvas);
+    const arrived = [];
+    const fromClient = (m) => {
+      if (m.author.kind === "client") arrived.push({ canvas, name: m.author.name, text: m.text });
+    };
     this.ws.comments.merge(canvas, (local) => {
       let changed = false;
       for (const r of remote) {
@@ -1721,6 +1883,7 @@ var CommentSync = class {
         const l = local.find((t) => t.id === r.id);
         if (!l) {
           local.push(fromRemote(r, slug));
+          r.messages.forEach(fromClient);
           changed = true;
           continue;
         }
@@ -1729,6 +1892,7 @@ var CommentSync = class {
         for (const m of r.messages) {
           if (have.has(m.id)) continue;
           l.messages.push(message(m));
+          fromClient(m);
           changed = true;
         }
         if (changed) l.messages.sort((a, b) => a.at - b.at);
@@ -1741,6 +1905,7 @@ var CommentSync = class {
       }
       return changed;
     });
+    if (this.onClientMessage) for (const e of arrived) this.onClientMessage(e);
     let pushed = false;
     for (const l of this.ws.comments.list(canvas)) {
       if (l.share?.link !== slug) continue;
@@ -1793,6 +1958,349 @@ async function call(site, method, route, body) {
   return res.json();
 }
 
+// src/share/session.ts
+var BUFFER_LIMIT = 4 * 1024 * 1024;
+var MAX_REQUEST_BODY = 10 * 1024 * 1024;
+var LiveSession = class {
+  constructor(site, slug, canvas, appUrl, opts) {
+    this.site = site;
+    this.slug = slug;
+    this.opts = opts;
+    this.app = new URL(appUrl);
+    this.state = { canvas, status: "connecting", url: `${site.url}/s/${slug}`, error: null, people: [], you: null };
+  }
+  site;
+  slug;
+  opts;
+  socket = null;
+  stopped = false;
+  retry = null;
+  backoff = 1e3;
+  inflight = /* @__PURE__ */ new Map();
+  relays = /* @__PURE__ */ new Map();
+  cursorTimer = null;
+  cursorLast = 0;
+  cursorNext = null;
+  app;
+  state;
+  start() {
+    this.stopped = false;
+    this.connect();
+    return this;
+  }
+  stop() {
+    this.stopped = true;
+    if (this.retry) clearTimeout(this.retry);
+    this.socket?.close(1e3, "The studio ended the session");
+    this.socket = null;
+    this.cleanup();
+    this.setState({ status: "stopped", people: [] });
+  }
+  /** The studio's cursor on the canvas (canvas coordinates), or null when it left. Throttled. */
+  cursor(x, y) {
+    this.cursorNext = { x, y };
+    const wait = 50 - (Date.now() - this.cursorLast);
+    if (this.cursorTimer) return;
+    const send = () => {
+      this.cursorTimer = null;
+      if (!this.cursorNext) return;
+      this.cursorLast = Date.now();
+      this.sendText({ t: "cursor", ...this.cursorNext });
+      this.cursorNext = null;
+    };
+    if (wait <= 0) send();
+    else this.cursorTimer = setTimeout(send, wait);
+  }
+  setState(change) {
+    this.state = { ...this.state, ...change };
+    this.opts.onState?.(this.state);
+  }
+  connect() {
+    if (this.stopped) return;
+    const url = new URL(`${this.site.url}/api/shares/${encodeURIComponent(this.slug)}/room`);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.searchParams.set("host", "1");
+    url.searchParams.set("name", this.opts.name);
+    url.searchParams.set("route", this.opts.route);
+    const socket = new WebSocket(url, { headers: { authorization: `Bearer ${this.site.token}` } });
+    socket.binaryType = "arraybuffer";
+    this.socket = socket;
+    let opened = false;
+    const keepAlive = setInterval(() => socket.readyState === WebSocket.OPEN && socket.send("ping"), 3e4);
+    keepAlive.unref?.();
+    socket.onopen = () => {
+      opened = true;
+      this.backoff = 1e3;
+      this.setState({ status: "live", error: null });
+    };
+    socket.onmessage = (m) => {
+      if (typeof m.data === "string") this.onText(m.data);
+      else void this.onFrame(m.data);
+    };
+    socket.onclose = (e) => {
+      clearInterval(keepAlive);
+      if (this.socket !== socket) return;
+      this.socket = null;
+      this.cleanup();
+      if (this.stopped) return;
+      if (e.code === 4e3) {
+        this.stopped = true;
+        this.setState({ status: "stopped", error: "Another Truecanvas started a session on this link.", people: [] });
+        return;
+      }
+      this.setState({ status: "reconnecting", error: opened ? null : "Couldn't reach the review site.", people: [] });
+      this.retry = setTimeout(() => this.connect(), this.backoff);
+      this.backoff = Math.min(this.backoff * 2, 15e3);
+    };
+    socket.onerror = () => {
+    };
+  }
+  cleanup() {
+    for (const f of this.inflight.values()) f.controller.abort();
+    this.inflight.clear();
+    for (const r of this.relays.values()) r.socket?.close();
+    this.relays.clear();
+  }
+  sendText(msg) {
+    if (this.socket?.readyState === WebSocket.OPEN) this.socket.send(JSON.stringify(msg));
+  }
+  send(header, payload) {
+    if (this.socket?.readyState === WebSocket.OPEN) this.socket.send(encodeFrame(header, payload));
+  }
+  /** Don't pile megabytes on a slow link: wait until the socket drains. */
+  async drained() {
+    while (this.socket && this.socket.readyState === WebSocket.OPEN && this.socket.bufferedAmount > BUFFER_LIMIT) await new Promise((r) => setTimeout(r, 15));
+  }
+  onText(data2) {
+    if (data2 === "pong") return;
+    let e;
+    try {
+      e = JSON.parse(data2);
+    } catch {
+      return;
+    }
+    if (e.t === "hello") this.setState({ people: e.people, you: e.you.id });
+    else if (e.t === "join") this.setState({ people: [...this.state.people.filter((p) => p.id !== e.person.id), e.person] });
+    else if (e.t === "leave") this.setState({ people: this.state.people.filter((p) => p.id !== e.id) });
+    this.opts.onEvent?.(e);
+  }
+  // ---------- the tunnel ----------
+  /** The app URL for a tunneled path, or null if it would leave the app. */
+  target(path12, ws = false) {
+    const safe = safePath(path12);
+    if (!safe) return null;
+    const url = new URL(safe, this.app);
+    if (url.origin !== this.app.origin) return null;
+    if (ws) url.protocol = this.app.protocol === "https:" ? "wss:" : "ws:";
+    return url;
+  }
+  async onFrame(data2) {
+    let frame;
+    try {
+      frame = decodeFrame(data2);
+    } catch {
+      return;
+    }
+    const h = frame.header;
+    switch (h.t) {
+      case "req":
+        return this.request(h);
+      case "req-body": {
+        const f = this.inflight.get(h.id);
+        if (!f?.body) return;
+        f.size += frame.payload.length;
+        if (f.size > MAX_REQUEST_BODY) {
+          f.controller.abort();
+          return;
+        }
+        f.body.enqueue(frame.payload.slice());
+        return;
+      }
+      case "req-end": {
+        const f = this.inflight.get(h.id);
+        try {
+          f?.body?.close();
+        } catch {
+        }
+        return;
+      }
+      case "req-abort":
+        this.inflight.get(h.id)?.controller.abort();
+        this.inflight.delete(h.id);
+        return;
+      case "ws-open":
+        return this.openRelay(h.id, h.path, h.protocols);
+      case "ws-msg": {
+        const r = this.relays.get(h.id);
+        if (!r) return;
+        const data3 = h.text ? new TextDecoder().decode(frame.payload) : frame.payload.slice();
+        if (r.socket?.readyState === WebSocket.OPEN) r.socket.send(data3);
+        else r.queue.push({ data: data3 });
+        return;
+      }
+      case "ws-close": {
+        const r = this.relays.get(h.id);
+        this.relays.delete(h.id);
+        r?.socket?.close();
+        return;
+      }
+    }
+  }
+  async request(h) {
+    const target = this.target(h.path);
+    if (!target || !["GET", "HEAD", "POST"].includes(h.method)) {
+      this.send({ t: "res", id: h.id, status: 403, headers: [["content-type", "text/plain; charset=utf-8"]] });
+      this.send({ t: "res-body", id: h.id }, new TextEncoder().encode("Not part of the app."));
+      this.send({ t: "res-end", id: h.id });
+      return;
+    }
+    const controller = new AbortController();
+    const entry = { controller, body: null, size: 0 };
+    let body;
+    if (h.body) body = new ReadableStream({ start: (c2) => void (entry.body = c2) });
+    this.inflight.set(h.id, entry);
+    try {
+      const headers = new Headers();
+      for (const [k, v] of h.headers) {
+        try {
+          headers.append(k, v);
+        } catch {
+        }
+      }
+      const res = await fetch(target, {
+        method: h.method,
+        headers,
+        body,
+        redirect: "manual",
+        signal: controller.signal,
+        ...body ? { duplex: "half" } : {}
+      });
+      this.send({ t: "res", id: h.id, status: res.status, headers: this.answerHeaders(res.headers) });
+      if (res.body && h.method !== "HEAD") {
+        const reader = res.body.getReader();
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          for (let i = 0; i < value.length; i += CHUNK) {
+            await this.drained();
+            if (!this.inflight.has(h.id)) {
+              await reader.cancel().catch(() => {
+              });
+              return;
+            }
+            this.send({ t: "res-body", id: h.id }, value.subarray(i, i + CHUNK));
+          }
+        }
+      }
+      this.send({ t: "res-end", id: h.id });
+    } catch (err) {
+      if (!controller.signal.aborted) this.send({ t: "res-error", id: h.id, message: err.message || "request failed" });
+    } finally {
+      this.inflight.delete(h.id);
+    }
+  }
+  /** The app's answer headers, with redirects to itself made relative (they'd point at localhost otherwise). */
+  answerHeaders(headers) {
+    const out = responseHeaders(headers);
+    return out.map(([k, v]) => {
+      if (k !== "location") return [k, v];
+      try {
+        const to = new URL(v, this.app);
+        return [k, to.origin === this.app.origin ? to.pathname + to.search + to.hash : v];
+      } catch {
+        return [k, v];
+      }
+    });
+  }
+  openRelay(id, path12, protocols) {
+    const target = this.target(path12, true);
+    if (!target) {
+      this.send({ t: "ws-close", id, code: 1008, reason: "Not part of the app" });
+      return;
+    }
+    const relay = { socket: null, queue: [] };
+    this.relays.set(id, relay);
+    let socket;
+    try {
+      socket = new WebSocket(target, protocols);
+    } catch (err) {
+      this.relays.delete(id);
+      this.send({ t: "ws-close", id, code: 1011, reason: err.message.slice(0, 100) });
+      return;
+    }
+    socket.binaryType = "arraybuffer";
+    relay.socket = socket;
+    socket.onopen = () => {
+      this.send({ t: "ws-ready", id, protocol: socket.protocol });
+      for (const m of relay.queue) socket.send(m.data);
+      relay.queue = [];
+    };
+    socket.onmessage = (m) => {
+      const text = typeof m.data === "string";
+      this.send({ t: "ws-msg", id, text }, text ? new TextEncoder().encode(m.data) : new Uint8Array(m.data));
+    };
+    socket.onclose = (e) => {
+      if (!this.relays.has(id)) return;
+      this.relays.delete(id);
+      this.send({ t: "ws-close", id, code: e.code, reason: e.reason });
+    };
+    socket.onerror = () => {
+    };
+  }
+};
+var Sessions = class {
+  constructor(project, appUrl, events = {}) {
+    this.project = project;
+    this.appUrl = appUrl;
+    this.events = events;
+  }
+  project;
+  appUrl;
+  events;
+  sessions = /* @__PURE__ */ new Map();
+  list() {
+    return [...this.sessions.values()].map((s) => s.state);
+  }
+  get(canvas) {
+    return this.sessions.get(canvas) ?? null;
+  }
+  /** Starts (or returns) the canvas's session. The canvas needs a link: share it first. */
+  async start(canvas, opts = {}) {
+    const running = this.sessions.get(canvas);
+    if (running && running.state.status !== "stopped") return running.state;
+    const site = reviewSite();
+    if (!site) throw new Error("No review site yet: connect one with `npx truecanvas share setup`, share the canvas, then start a session.");
+    const features = await siteFeatures(site);
+    if (!features.includes("session")) throw new Error("This review site doesn't support live sessions yet: deploy the latest review site (packages/review-worker) with LIVE_HOST_SUFFIX set.");
+    const res = await fetch(`${site.url}/api/shares?project=${encodeURIComponent(this.project)}&canvas=${encodeURIComponent(canvas)}`, {
+      headers: { authorization: `Bearer ${site.token}` },
+      signal: AbortSignal.timeout(2e4)
+    });
+    if (!res.ok) throw new Error(`Review site: ${res.status} ${res.statusText}`);
+    const { slug } = await res.json();
+    if (!slug) throw new Error(`${canvas} has no link yet. Share it once (Share, or \`npx truecanvas share ${canvas}\`), then start a session.`);
+    const session = new LiveSession(site, slug, canvas, this.appUrl, {
+      name: opts.name ?? "Studio",
+      route: "/truecanvas/",
+      onEvent: (e) => this.events.onEvent?.(canvas, e),
+      onState: (s) => this.events.onState?.(s)
+    });
+    this.sessions.set(canvas, session);
+    session.start();
+    return session.state;
+  }
+  stop(canvas) {
+    const s = this.sessions.get(canvas);
+    if (!s) return false;
+    s.stop();
+    this.sessions.delete(canvas);
+    return true;
+  }
+  stopAll() {
+    for (const canvas of [...this.sessions.keys()]) this.stop(canvas);
+  }
+};
+
 // src/server/http.ts
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -1816,7 +2324,12 @@ async function startServer(ws) {
   const shots = new Screenshotter(config.appUrl);
   let prCache = null;
   const thumbs = new Thumbnails(ws, shots);
-  const commentSync = new CommentSync(ws);
+  const hub = process.env.TRUECANVAS_HUB_URL;
+  const commentSync = new CommentSync(
+    ws,
+    hub ? (e) => void fetch(`${hub}/api/hub/notify`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ path: config.root, ...e }), signal: AbortSignal.timeout(5e3) }).catch(() => {
+    }) : void 0
+  );
   commentSync.start();
   const syncRegistry = () => ws.catalog.load().then((list) => syncComponentRegistry(config, list)).catch(() => {
   });
@@ -1832,6 +2345,19 @@ async function startServer(ws) {
     for (const res of clients) res.write(data2);
   };
   ws.on(broadcast);
+  const sendRaw = (e) => {
+    const data2 = `data: ${JSON.stringify(e)}
+
+`;
+    for (const res of clients) res.write(data2);
+  };
+  const sessions = new Sessions(path8.basename(config.root), config.appUrl, {
+    onEvent: (canvas, e) => {
+      if (e.t === "comments") void commentSync.syncAll();
+      else sendRaw({ type: "room", canvas, event: e });
+    },
+    onState: (s) => sendRaw({ type: "session", session: s })
+  });
   setInterval(() => {
     for (const res of clients) res.write(": ping\n\n");
     ws.pruneAgents();
@@ -1870,7 +2396,7 @@ async function startServer(ws) {
           ws.dropAgent(sid);
         }
       };
-      const server2 = createMcpServer(ws, shots, () => sid);
+      const server2 = createMcpServer(ws, shots, () => sid, sessions);
       await server2.connect(t);
       transport = t;
     }
@@ -1885,7 +2411,7 @@ async function startServer(ws) {
           appUrl: config.appUrl,
           framework: config.framework,
           root: config.root,
-          projectName: path7.basename(config.root),
+          projectName: path8.basename(config.root),
           canvases: ws.canvases(),
           darkMode: config.darkMode,
           agents: [...ws.agents.values()],
@@ -2035,7 +2561,7 @@ async function startServer(ws) {
           for (const file of [f.page, ...layoutFiles(config, f.page)]) {
             const old = await ws.git.show(ref, file);
             if (old === null) continue;
-            const now = fs6.existsSync(path7.join(config.root, file)) ? fs6.readFileSync(path7.join(config.root, file), "utf8") : null;
+            const now = fs6.existsSync(path8.join(config.root, file)) ? fs6.readFileSync(path8.join(config.root, file), "utf8") : null;
             if (old !== now) {
               files[file] = old;
               touched.add(f.frameName);
@@ -2165,26 +2691,50 @@ async function startServer(ws) {
       }
       case "POST /api/open-file": {
         const { file } = await readJson(req);
-        const abs = path7.resolve(config.root, file);
-        const rel = path7.relative(config.root, abs);
-        if (rel.startsWith("..") || path7.isAbsolute(rel)) return json(res, 400, { error: "Outside project." });
+        const abs = path8.resolve(config.root, file);
+        const rel = path8.relative(config.root, abs);
+        if (rel.startsWith("..") || path8.isAbsolute(rel)) return json(res, 400, { error: "Outside project." });
         launchEditor(abs, config.editor);
         return json(res, 200, { ok: true });
       }
       case "GET /api/share/status": {
         const site = reviewSite();
-        return json(res, 200, { site: site ? site.url : null });
+        const features = site ? await siteFeatures(site).catch(() => []) : [];
+        return json(res, 200, { site: site ? site.url : null, features });
       }
       case "POST /api/share/snapshot": {
-        const { canvas, frames, local, title, password } = await readJson(req);
+        const { canvas, frames, local, title, password, live, access, invite } = await readJson(req);
         assertCanvasName(canvas);
         const { dir, manifest } = await createSnapshot(ws, shots, canvas, { frames });
         const preview = `${origin}/share/${encodeURIComponent(canvas)}/${manifest.id}/`;
         const site = local ? null : reviewSite();
-        const published = site ? await publishSnapshot(site, dir, manifest, { title, password }) : null;
+        const published = site ? await publishSnapshot(site, dir, manifest, { title, password, live, access, invite: invite?.length ? parseEmails(invite) : void 0 }) : null;
         if (published) commentSync.forget(canvas);
         return json(res, 200, { manifest, preview, published });
       }
+      // live sessions: clients follow the canvas live on its link (editor button, CLI, MCP, desktop tray)
+      case "GET /api/session":
+        return json(res, 200, { sessions: sessions.list() });
+      case "POST /api/session/start": {
+        const body = await readJson(req);
+        const canvas = body.canvas ?? ws.selection.canvas ?? ws.canvases()[0];
+        if (!canvas) return json(res, 400, { error: "No canvas to share live yet." });
+        assertCanvasName(canvas);
+        return json(res, 200, { session: await sessions.start(canvas, { name: body.name }) });
+      }
+      case "POST /api/session/stop": {
+        const { canvas } = await readJson(req);
+        if (canvas) return json(res, 200, { stopped: sessions.stop(canvas) });
+        const any = sessions.list().length > 0;
+        sessions.stopAll();
+        return json(res, 200, { stopped: any });
+      }
+      case "POST /api/session/cursor": {
+        const { canvas, x, y } = await readJson(req);
+        const on = typeof x === "number" && typeof y === "number" && Number.isFinite(x) && Number.isFinite(y);
+        sessions.get(canvas)?.cursor(on ? x : null, on ? y : null);
+        return json(res, 200, { ok: true });
+      }
       case "POST /api/source": {
         const { canvas, id } = await readJson(req);
         const hit = ws.nodeSource(canvas, id);
@@ -2195,23 +2745,23 @@ async function startServer(ws) {
     return json(res, 404, { error: `No route ${route}` });
   }
   function serveStatic(res, pathname) {
-    let file = path7.join(editorDir, pathname === "/" ? "index.html" : pathname);
-    if (!inside(editorDir, file) || !fs6.existsSync(file) || fs6.statSync(file).isDirectory()) file = path7.join(editorDir, "index.html");
+    let file = path8.join(editorDir, pathname === "/" ? "index.html" : pathname);
+    if (!inside(editorDir, file) || !fs6.existsSync(file) || fs6.statSync(file).isDirectory()) file = path8.join(editorDir, "index.html");
     if (!fs6.existsSync(file)) {
       res.writeHead(500, { "content-type": "text/plain" });
       return res.end("Editor bundle missing. Run `pnpm build` in packages/truecanvas.");
     }
-    const ext = path7.extname(file);
+    const ext = path8.extname(file);
     const immutable = pathname.startsWith("/assets/");
     res.writeHead(200, { "content-type": MIME[ext] ?? "application/octet-stream", "cache-control": immutable ? "public, max-age=31536000, immutable" : "no-cache" });
     fs6.createReadStream(file).on("error", () => res.destroy()).pipe(res);
   }
   function serveShare(res, rest) {
     const root = sharesDir(config.root);
-    let file = path7.join(root, decodeURIComponent(rest));
-    if (rest.endsWith("/")) file = path7.join(file, "index.html");
+    let file = path8.join(root, decodeURIComponent(rest));
+    if (rest.endsWith("/")) file = path8.join(file, "index.html");
     if (!inside(root, file) || !fs6.existsSync(file) || fs6.statSync(file).isDirectory()) return json(res, 404, { error: "Not found" });
-    res.writeHead(200, { "content-type": MIME[path7.extname(file)] ?? "application/octet-stream", "cache-control": "no-cache", "x-content-type-options": "nosniff", "access-control-allow-origin": "*" });
+    res.writeHead(200, { "content-type": MIME[path8.extname(file)] ?? "application/octet-stream", "cache-control": "no-cache", "x-content-type-options": "nosniff", "access-control-allow-origin": "*" });
     fs6.createReadStream(file).on("error", () => res.destroy()).pipe(res);
   }
   const server = http.createServer(async (req, res) => {
@@ -2232,7 +2782,7 @@ async function startServer(ws) {
       else res.end();
     }
   });
-  const canvasDir = path7.join(config.root, config.canvasDir);
+  const canvasDir = path8.join(config.root, config.canvasDir);
   fs6.mkdirSync(canvasDir, { recursive: true });
   const pending = /* @__PURE__ */ new Map();
   const onCanvasFile = (filename) => {
@@ -2276,12 +2826,12 @@ async function startServer(ws) {
   };
   watchCanvasDir();
   setInterval(watchCanvasDir, 2e3).unref();
-  const appDirAbs = path7.join(config.root, config.appDir);
+  const appDirAbs = path8.join(config.root, config.appDir);
   if (config.framework === "next" && fs6.existsSync(appDirAbs)) {
     const appPending = /* @__PURE__ */ new Map();
     const appWatcher = fs6.watch(appDirAbs, { recursive: true }, (_event, filename) => {
       if (!filename || !/(^|[\\/])(page|layout)\.[jt]sx$/.test(filename) || /^truecanvas[\\/]/.test(filename)) return;
-      const rel = path7.join(config.appDir, filename).split(path7.sep).join("/");
+      const rel = path8.join(config.appDir, filename).split(path8.sep).join("/");
       clearTimeout(appPending.get(rel));
       appPending.set(
         rel,
@@ -2298,7 +2848,7 @@ async function startServer(ws) {
   }
   let catalogTimer;
   for (const dir of componentRoots(config.components)) {
-    const abs = path7.join(config.root, dir);
+    const abs = path8.join(config.root, dir);
     if (!fs6.existsSync(abs)) continue;
     const componentWatcher = fs6.watch(abs, { recursive: true }, () => {
       clearTimeout(catalogTimer);
@@ -2315,6 +2865,7 @@ async function startServer(ws) {
     server.listen(config.port, "127.0.0.1", resolve);
   });
   const shutdown = async () => {
+    sessions.stopAll();
     commentSync.stop();
     await shots.close();
     for (const t of transports.values()) await t.close().catch(() => {
@@ -2335,8 +2886,8 @@ function dedent(code, col) {
   return code.split("\n").map((l, i) => i > 0 && l.startsWith(pad) ? l.slice(col) : l).join("\n");
 }
 function inside(dir, file) {
-  const rel = path7.relative(dir, file);
-  return !!rel && !rel.startsWith("..") && !path7.isAbsolute(rel);
+  const rel = path8.relative(dir, file);
+  return !!rel && !rel.startsWith("..") && !path8.isAbsolute(rel);
 }
 
 // src/server/stdio.ts
@@ -2377,831 +2928,10 @@ async function runStdioBridge(mcpUrl) {
 // src/cli/index.ts
 import { createRequire } from "module";
 
-// src/hub/server.ts
-import http2 from "http";
-import fs10 from "fs";
-import os6 from "os";
-import path11 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { Server as Server2 } from "@modelcontextprotocol/sdk/server/index.js";
-import { StreamableHTTPServerTransport as StreamableHTTPServerTransport2 } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport as StreamableHTTPClientTransport2 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { CallToolRequestSchema as CallToolRequestSchema2, ListToolsRequestSchema as ListToolsRequestSchema2, isInitializeRequest as isInitializeRequest2 } from "@modelcontextprotocol/sdk/types.js";
-
-// src/hub/projects.ts
+// src/hub/desktop.ts
 import fs7 from "fs";
 import os3 from "os";
-import path8 from "path";
-var CONFIG_DIR = path8.join(process.env.XDG_CONFIG_HOME ?? path8.join(os3.homedir(), ".config"), "truecanvas");
-var FILE = path8.join(CONFIG_DIR, "projects.json");
-var ProjectStore = class {
-  list = [];
-  constructor() {
-    try {
-      this.list = JSON.parse(fs7.readFileSync(FILE, "utf8"));
-    } catch {
-      this.list = [];
-    }
-  }
-  save() {
-    fs7.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs7.writeFileSync(FILE, JSON.stringify(this.list, null, 2));
-  }
-  all() {
-    return [...this.list].sort((a, b) => b.lastOpened - a.lastOpened).map((p) => ({ ...p, ...inspect(p.path) }));
-  }
-  touch(dir) {
-    const abs = path8.resolve(dir);
-    const existing = this.list.find((p) => p.path === abs);
-    if (existing) existing.lastOpened = Date.now();
-    else this.list.push({ path: abs, name: projectName(abs), lastOpened: Date.now() });
-    this.save();
-  }
-  forget(dir) {
-    this.list = this.list.filter((p) => p.path !== path8.resolve(dir));
-    this.save();
-  }
-};
-function readPkg(dir) {
-  try {
-    return JSON.parse(fs7.readFileSync(path8.join(dir, "package.json"), "utf8"));
-  } catch {
-    return null;
-  }
-}
-function projectName(dir) {
-  const pkg = readPkg(dir);
-  const name = typeof pkg?.name === "string" ? pkg.name : "";
-  return name && !name.startsWith("@") ? name : path8.basename(dir);
-}
-function inspect(dir) {
-  const pkg = readPkg(dir);
-  if (!pkg) return { next: false, ready: false, canvases: 0, exists: fs7.existsSync(dir) };
-  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-  let canvases = 0;
-  for (const d of ["canvas", "src/canvas"]) {
-    try {
-      canvases += fs7.readdirSync(path8.join(dir, d)).filter((f) => f.endsWith(".canvas.tsx")).length;
-    } catch {
-    }
-  }
-  return { next: "next" in deps || "vite" in deps && "react" in deps, ready: "truecanvas" in deps, canvases, exists: true };
-}
-function discover() {
-  const home = os3.homedir();
-  const roots = ["Github", "GitHub", "github", "Projects", "projects", "code", "Code", "dev", "src", "Developer", "Documents", "work"].map((d) => path8.join(home, d)).filter((d) => fs7.existsSync(d));
-  const found = [];
-  let visited = 0;
-  const walk = (dir, depth) => {
-    if (depth > 3 || visited > 3e3 || found.length > 60) return;
-    visited++;
-    let entries;
-    try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    if (entries.some((e) => e.name === "package.json")) {
-      const info = inspect(dir);
-      if (info.next) found.push({ path: dir, name: projectName(dir), ready: info.ready });
-    }
-    for (const e of entries) {
-      if (!e.isDirectory() || e.name.startsWith(".") || e.name === "node_modules" || e.name === "dist" || e.name === "build") continue;
-      walk(path8.join(dir, e.name), depth + 1);
-    }
-  };
-  for (const r of roots) walk(r, 0);
-  return found;
-}
-function listDirs(dir) {
-  const abs = path8.resolve(dir.replace(/^~(?=$|[\\/])/, os3.homedir()));
-  const dirs = fs7.readdirSync(abs, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => ({ name: e.name, next: inspect(path8.join(abs, e.name)).next })).sort((a, b) => Number(b.next) - Number(a.next) || a.name.localeCompare(b.name));
-  return { path: abs, dirs };
-}
-
-// src/hub/runner.ts
-import { execFile, spawn as spawn2 } from "child_process";
-import fs9 from "fs";
-import net from "net";
-import os5 from "os";
-import path10 from "path";
-
-// src/cli/setup.ts
-import { spawn } from "child_process";
-import { createHash as createHash2 } from "crypto";
-import fs8 from "fs";
-import os4 from "os";
 import path9 from "path";
-function addDevArgs(pm, spec) {
-  return addArgs(pm, [spec], true);
-}
-function runScript(pm, script) {
-  return pm === "npm" ? `npm run ${script}` : `${pm} ${script}`;
-}
-var execInherit = (cmd, args, cwd) => new Promise((resolve, reject) => {
-  const safe = shellSafe(cmd, args);
-  const p = spawn(safe.cmd, safe.args, { cwd, stdio: "inherit", env: toolEnv(), shell: safe.shell });
-  p.on("error", reject);
-  p.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`${cmd} ${args.join(" ")} exited with ${code}`)));
-});
-function packageDir(cliFile) {
-  return path9.resolve(path9.dirname(cliFile), "..");
-}
-function packageVersion(pkgDir) {
-  try {
-    return JSON.parse(fs8.readFileSync(path9.join(pkgDir, "package.json"), "utf8")).version;
-  } catch {
-    return "0.0.0";
-  }
-}
-function isSourceCheckout(pkgDir) {
-  return !pkgDir.split(path9.sep).includes("node_modules") && fs8.existsSync(path9.join(pkgDir, "src", "cli"));
-}
-async function packageSpec(pkgDir, exec) {
-  if (process.env.TRUECANVAS_PACKAGE) return process.env.TRUECANVAS_PACKAGE;
-  const version = packageVersion(pkgDir);
-  if (!isSourceCheckout(pkgDir)) return `truecanvas@${version}`;
-  const cacheDir = path9.join(os4.homedir(), ".cache", "truecanvas");
-  fs8.mkdirSync(cacheDir, { recursive: true });
-  const file = path9.join(cacheDir, `truecanvas-${version}.tgz`);
-  await exec("npm", ["pack", "--silent", "--pack-destination", cacheDir], pkgDir);
-  const hash = createHash2("sha256").update(fs8.readFileSync(file)).digest("hex").slice(0, 10);
-  const named = path9.join(cacheDir, `truecanvas-${version}-${hash}.tgz`);
-  fs8.renameSync(file, named);
-  return named;
-}
-function installedIn(root) {
-  let declared = false;
-  try {
-    const pkg = JSON.parse(fs8.readFileSync(path9.join(root, "package.json"), "utf8"));
-    declared = "truecanvas" in { ...pkg.dependencies, ...pkg.devDependencies };
-  } catch {
-  }
-  const file = path9.join(root, "node_modules", "truecanvas", "package.json");
-  const installed = fs8.existsSync(file);
-  return { declared, installed, version: installed ? packageVersion(path9.dirname(file)) : null };
-}
-function readPackage(root) {
-  try {
-    return JSON.parse(fs8.readFileSync(path9.join(root, "package.json"), "utf8"));
-  } catch {
-    return null;
-  }
-}
-function depVersion(root, name) {
-  const file = path9.join(root, "node_modules", name, "package.json");
-  if (fs8.existsSync(file)) return packageVersion(path9.dirname(file));
-  const pkg = readPackage(root);
-  return pkg ? { ...pkg.dependencies, ...pkg.devDependencies }[name] ?? null : null;
-}
-function mergeJson(file, update) {
-  let data2 = {};
-  if (fs8.existsSync(file)) {
-    try {
-      data2 = JSON.parse(fs8.readFileSync(file, "utf8"));
-    } catch {
-      throw new Error(`${file} isn't valid JSON; fix it or remove it, then run connect again.`);
-    }
-  }
-  const before = JSON.stringify(data2);
-  update(data2);
-  if (JSON.stringify(data2) === before) return "unchanged";
-  fs8.mkdirSync(path9.dirname(file), { recursive: true });
-  fs8.writeFileSync(file, `${JSON.stringify(data2, null, 2)}
-`);
-  return "written";
-}
-function connectAgents(root, port, opts = {}) {
-  const url = `http://localhost:${port}/mcp`;
-  const out = { written: [], unchanged: [] };
-  const add = (rel, update) => out[mergeJson(path9.join(root, rel), update)].push(rel);
-  const servers = (d, key) => d[key] ??= {};
-  add(".mcp.json", (d) => void (servers(d, "mcpServers").truecanvas = { type: "http", url }));
-  if (opts.cursor || fs8.existsSync(path9.join(root, ".cursor"))) add(".cursor/mcp.json", (d) => void (servers(d, "mcpServers").truecanvas = { url }));
-  if (opts.vscode || fs8.existsSync(path9.join(root, ".vscode"))) add(".vscode/mcp.json", (d) => void (servers(d, "servers").truecanvas = { type: "http", url }));
-  return out;
-}
-function hasAgentConfig(root, port) {
-  try {
-    const d = JSON.parse(fs8.readFileSync(path9.join(root, ".mcp.json"), "utf8"));
-    const url = d?.mcpServers?.truecanvas?.url;
-    return typeof url === "string" && (port === void 0 || url.includes(`:${port}/`));
-  } catch {
-    return false;
-  }
-}
-
-// src/hub/runner.ts
-function portFree(port) {
-  return new Promise((resolve) => {
-    const srv = net.createServer();
-    srv.once("error", () => resolve(false));
-    srv.listen(port, "127.0.0.1", () => srv.close(() => resolve(true)));
-  });
-}
-async function freePort(from, taken) {
-  for (let p = from; p < from + 200; p++) if (!taken.has(p) && await portFree(p)) return p;
-  throw new Error("No free port");
-}
-var Runner = class {
-  constructor(cli, onChange) {
-    this.cli = cli;
-    this.onChange = onChange;
-  }
-  cli;
-  onChange;
-  running = /* @__PURE__ */ new Map();
-  opening = /* @__PURE__ */ new Map();
-  ports = Promise.resolve();
-  /** Opens a project; concurrent calls for the same folder share one start. */
-  open(dir) {
-    const existing = this.running.get(dir);
-    if (existing && existing.status !== "failed") return Promise.resolve(existing);
-    const pending = this.opening.get(dir);
-    if (pending) return pending;
-    const job = this.start(dir).finally(() => this.opening.delete(dir));
-    this.opening.set(dir, job);
-    return job;
-  }
-  /** Two ports, picked one project at a time so parallel opens never collide. */
-  allocatePorts() {
-    const next = this.ports.then(async () => {
-      const taken = new Set([...this.running.values()].flatMap((r) => [r.editorPort, r.appPort]));
-      const editorPort = await freePort(4810, taken);
-      taken.add(editorPort);
-      return [editorPort, await freePort(3010, taken)];
-    });
-    this.ports = next.catch(() => {
-    });
-    return next;
-  }
-  async start(dir) {
-    if (!fs9.existsSync(path10.join(dir, "package.json"))) throw new Error(`${dir} isn't there anymore (or has no package.json).`);
-    const [editorPort, appPort] = await this.allocatePorts();
-    const proc = spawn2(process.execPath, [this.cli, "dev", "--no-open", "--port", String(editorPort), "--app", `http://localhost:${appPort}`], {
-      cwd: dir,
-      env: toolEnv({ FORCE_COLOR: "0", TRUECANVAS_HUB: "1" }),
-      stdio: ["ignore", "pipe", "pipe"],
-      // its own process group: closing the project also stops the next dev it started
-      detached: process.platform !== "win32"
-    });
-    const run3 = { path: dir, editorPort, appPort, proc, status: "starting", log: [], startedAt: Date.now() };
-    this.running.set(dir, run3);
-    const capture2 = (chunk) => {
-      for (const line of chunk.toString().split("\n")) if (line.trim()) run3.log.push(line.replace(/\x1b\[[0-9;]*m/g, ""));
-      if (run3.log.length > 200) run3.log.splice(0, run3.log.length - 200);
-    };
-    proc.stdout.on("data", capture2);
-    proc.stderr.on("data", capture2);
-    proc.on("error", (err) => {
-      run3.status = "failed";
-      run3.error = err.message;
-      this.onChange();
-    });
-    proc.on("exit", (code) => {
-      if (this.running.get(dir) !== run3) return;
-      if (run3.status === "starting" || code) {
-        run3.status = "failed";
-        run3.error = run3.log.slice(-6).join("\n") || `exited with ${code}`;
-      } else this.running.delete(dir);
-      this.onChange();
-    });
-    this.onChange();
-    const until = Date.now() + 6e4;
-    while (Date.now() < until && run3.status === "starting") {
-      try {
-        const res = await fetch(`http://127.0.0.1:${editorPort}/api/state`, { signal: AbortSignal.timeout(1e3) });
-        if (res.ok) {
-          run3.status = "ready";
-          break;
-        }
-      } catch {
-      }
-      await new Promise((r) => setTimeout(r, 400));
-    }
-    if (run3.status === "starting") {
-      run3.status = "failed";
-      run3.error = "Truecanvas didn't start within a minute.";
-      killTree(run3.proc, "SIGTERM");
-    }
-    this.onChange();
-    return run3;
-  }
-  /** Stops a project and everything it started; resolves once it has exited (or after 5s). */
-  close(dir) {
-    const run3 = this.running.get(dir);
-    if (!run3) return Promise.resolve();
-    this.running.delete(dir);
-    this.onChange();
-    if (run3.proc.exitCode !== null || run3.proc.signalCode !== null) return Promise.resolve();
-    return new Promise((resolve) => {
-      const force = setTimeout(() => killTree(run3.proc, "SIGKILL"), 4e3);
-      const done = setTimeout(resolve, 5e3);
-      run3.proc.once("exit", () => {
-        clearTimeout(force);
-        clearTimeout(done);
-        resolve();
-      });
-      killTree(run3.proc, "SIGTERM");
-    });
-  }
-  closeAll() {
-    return Promise.all([...this.running.keys()].map((dir) => this.close(dir))).then(() => {
-    });
-  }
-  /** Resident memory (MB) of each project's process tree. */
-  memory() {
-    return new Promise((resolve) => {
-      execFile("ps", ["-eo", "pid=,ppid=,rss="], (err, out) => {
-        if (err) return resolve({});
-        const rows = out.trim().split("\n").map((l) => l.trim().split(/\s+/).map(Number));
-        const kids = /* @__PURE__ */ new Map();
-        const rss = /* @__PURE__ */ new Map();
-        for (const [pid, ppid, kb] of rows) {
-          rss.set(pid, kb);
-          kids.set(ppid, [...kids.get(ppid) ?? [], pid]);
-        }
-        const total = (pid) => (rss.get(pid) ?? 0) + (kids.get(pid) ?? []).reduce((s, k) => s + total(k), 0);
-        const outMap = {};
-        for (const [dir, run3] of this.running) if (run3.proc.pid) outMap[dir] = Math.round(total(run3.proc.pid) / 1024);
-        resolve(outMap);
-      });
-    });
-  }
-};
-function killTree(proc, signal) {
-  try {
-    if (process.platform === "win32" && proc.pid) spawn2("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { stdio: "ignore" }).on("error", () => proc.kill());
-    else if (proc.pid) process.kill(-proc.pid, signal);
-    else proc.kill(signal);
-  } catch {
-    proc.kill(signal);
-  }
-}
-var jobs = /* @__PURE__ */ new Map();
-var jobSeq = 0;
-function getJob(id) {
-  return jobs.get(id);
-}
-async function install(job, cmd, args, cwd) {
-  try {
-    await run2(job, cmd, args, cwd);
-  } catch (err) {
-    const ignoredBuilds = job.log.some((l) => l.includes("ERR_PNPM_IGNORED_BUILDS"));
-    const installed = fs9.existsSync(path10.join(cwd, "node_modules", "truecanvas", "package.json"));
-    if (!(ignoredBuilds && installed)) throw err;
-    job.log.push("(pnpm only complained about other packages' build scripts; Truecanvas is installed, continuing)");
-  }
-}
-function run2(job, cmd, args, cwd) {
-  job.log.push(`$ ${cmd} ${args.join(" ")}`);
-  return new Promise((resolve, reject) => {
-    const safe = shellSafe(cmd, args);
-    const p = spawn2(safe.cmd, safe.args, { cwd, env: toolEnv({ CI: "1", FORCE_COLOR: "0" }), stdio: ["ignore", "pipe", "pipe"], shell: safe.shell });
-    const capture2 = (c2) => {
-      for (const line of c2.toString().split(/\r?\n/)) if (line.trim()) job.log.push(line.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, ""));
-      if (job.log.length > 300) job.log.splice(0, job.log.length - 300);
-    };
-    p.stdout.on("data", capture2);
-    p.stderr.on("data", capture2);
-    p.on("error", reject);
-    p.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`${cmd} exited with ${code}`)));
-  });
-}
-function startJob(title, work) {
-  const job = { id: String(++jobSeq), title, status: "running", log: [] };
-  jobs.set(job.id, job);
-  work(job).then((result) => {
-    job.status = "done";
-    if (result) job.result = result;
-  }).catch((err) => {
-    job.status = "failed";
-    job.log.push(`\u2717 ${err.message}`);
-  });
-  return job;
-}
-function packageManager(dir) {
-  const pm = detectPm(dir);
-  return { cmd: pm, add: addArgs(pm, [], true) };
-}
-async function preferredPm() {
-  const { ok } = await capture("pnpm", ["--version"], os5.homedir());
-  return ok ? "pnpm" : "npm";
-}
-function setupJob(dir, pkgDir, cli) {
-  return startJob(`Set up ${path10.basename(dir)}`, async (job) => {
-    const pm = packageManager(dir);
-    const source = await packageSpec(pkgDir, (cmd, args, cwd) => run2(job, cmd, args, cwd));
-    await install(job, pm.cmd, [...pm.add, source], dir);
-    await run2(job, process.execPath, [cli, "init"], dir);
-    return dir;
-  });
-}
-function createJob(name, parent, pkgDir, cli) {
-  const safe = name.trim().toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/^-+|-+$/g, "");
-  const parentDir = path10.resolve(parent.replace(/^~(?=$|[\\/])/, os5.homedir()));
-  const dir = path10.join(parentDir, safe);
-  return startJob(`Create ${safe}`, async (job) => {
-    if (!safe) throw new Error("Pick a project name.");
-    if (fs9.existsSync(dir)) throw new Error(`${dir} already exists.`);
-    fs9.mkdirSync(parentDir, { recursive: true });
-    const pm = await preferredPm();
-    await run2(job, "npx", ["--yes", "create-next-app@latest", safe, "--ts", "--tailwind", "--app", "--eslint", "--no-src-dir", "--import-alias", "@/*", `--use-${pm}`, "--turbopack", "--yes"], parentDir);
-    const source = await packageSpec(pkgDir, (cmd, args, cwd) => run2(job, cmd, args, cwd));
-    await install(job, pm, addArgs(pm, [source], true), dir);
-    await run2(job, process.execPath, [cli, "init"], dir);
-    return dir;
-  });
-}
-function capture(cmd, args, cwd) {
-  return new Promise((resolve) => {
-    const safe = shellSafe(cmd, args);
-    execFile(
-      safe.cmd,
-      safe.args,
-      { shell: safe.shell, cwd, timeout: 6e4, maxBuffer: 8 * 1024 * 1024, env: { ...process.env, GH_PROMPT_DISABLED: "1", GIT_TERMINAL_PROMPT: "0" } },
-      (err, stdout, stderr) => resolve({ ok: !err, out: err ? (stderr || err.message).trim() : stdout })
-    );
-  });
-}
-function cloneJob(repo, parent, pkgDir, cli) {
-  const parentDir = path10.resolve(parent.replace(/^~(?=$|[\\/])/, os5.homedir()));
-  const name = repo.replace(/\.git$/, "").split(/[/:]/).pop() ?? "";
-  const dir = path10.join(parentDir, name);
-  return startJob(`Clone ${name}`, async (job) => {
-    if (!name || !/^[\w.-]+$/.test(name)) throw new Error("Pick a repository (owner/name or a git URL).");
-    if (fs9.existsSync(dir)) throw new Error(`${dir} already exists. Open it with Open folder instead.`);
-    fs9.mkdirSync(parentDir, { recursive: true });
-    const url = /^(https?:|git@|ssh:|file:)/.test(repo);
-    if (url) await run2(job, "git", ["clone", repo, dir], parentDir);
-    else await run2(job, "gh", ["repo", "clone", repo, dir], parentDir);
-    if (!fs9.existsSync(path10.join(dir, "package.json"))) throw new Error("Cloned, but there's no package.json at the root: Truecanvas needs a Next.js or Vite app.");
-    const pm = packageManager(dir);
-    await install(job, pm.cmd, ["install"], dir).catch(async (err) => {
-      if (!fs9.existsSync(path10.join(dir, "node_modules"))) throw err;
-    });
-    const pkg = JSON.parse(fs9.readFileSync(path10.join(dir, "package.json"), "utf8"));
-    if (!("truecanvas" in { ...pkg.dependencies, ...pkg.devDependencies })) {
-      const source = await packageSpec(pkgDir, (cmd, args, cwd) => run2(job, cmd, args, cwd));
-      await install(job, pm.cmd, [...pm.add, source], dir);
-      await run2(job, process.execPath, [cli, "init"], dir);
-    } else job.log.push("Truecanvas is already part of this project.");
-    return dir;
-  });
-}
-
-// src/hub/server.ts
-var MIME2 = {
-  ".html": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".woff2": "font/woff2",
-  ".png": "image/png"
-};
-var HUB_INSTRUCTIONS = `Truecanvas hub: several projects, each a Next.js or Vite + React app with canvases of real React components.
-Your tools act on the current project (the active tab in the Truecanvas window, unless you pick one with open_project).
-Use list_projects to see them. All other tools are the regular Truecanvas canvas tools for that project.`;
-async function startHub(opts) {
-  const store = new ProjectStore();
-  const editorDir = fileURLToPath2(new URL("./editor/", import.meta.url));
-  const pkgDir = path11.resolve(path11.dirname(opts.cli), "..");
-  const origin = `http://localhost:${opts.port}`;
-  const allowedHosts = /* @__PURE__ */ new Set([`localhost:${opts.port}`, `127.0.0.1:${opts.port}`]);
-  const clients = /* @__PURE__ */ new Set();
-  let active = null;
-  const broadcast = () => {
-    for (const res of clients) res.write(`data: {"type":"state"}
-
-`);
-    for (const fn of toolListeners) fn();
-  };
-  const runner = new Runner(opts.cli, broadcast);
-  setInterval(() => {
-    for (const res of clients) res.write(": ping\n\n");
-  }, 2e4).unref();
-  let focus = null;
-  async function state() {
-    const memory = await runner.memory();
-    return {
-      origin,
-      active,
-      focus,
-      projects: store.all().map((p) => {
-        const r = runner.running.get(p.path);
-        return { ...p, running: r ? { status: r.status, editor: `http://localhost:${r.editorPort}`, app: `http://localhost:${r.appPort}`, error: r.error, memory: memory[p.path] ?? null } : null };
-      })
-    };
-  }
-  const toolListeners = /* @__PURE__ */ new Set();
-  const transports = /* @__PURE__ */ new Map();
-  const lastUse = /* @__PURE__ */ new Map();
-  setInterval(() => {
-    for (const [id, at] of lastUse) {
-      if (Date.now() - at < 60 * 6e4) continue;
-      lastUse.delete(id);
-      void transports.get(id)?.close();
-    }
-  }, 5 * 6e4).unref();
-  function createProxy() {
-    const server2 = new Server2({ name: "truecanvas", version: "0.1.0" }, { capabilities: { tools: { listChanged: true } }, instructions: HUB_INSTRUCTIONS });
-    let current = null;
-    const upstreams = /* @__PURE__ */ new Map();
-    const target = () => current ?? active;
-    const drop = (dir) => {
-      const hit = upstreams.get(dir);
-      upstreams.delete(dir);
-      void hit?.client.then((c2) => c2.close()).catch(() => {
-      });
-    };
-    const upstream = (dir) => {
-      const run3 = runner.running.get(dir);
-      if (!run3 || run3.status !== "ready") return null;
-      const hit = upstreams.get(dir);
-      if (hit && hit.pid === run3.proc.pid) return hit.client;
-      if (hit) drop(dir);
-      const info = server2.getClientVersion();
-      const client = new Client2({ name: info?.name ?? "agent", version: info?.version ?? "0.0.0" });
-      const c2 = client.connect(new StreamableHTTPClientTransport2(new URL(`http://127.0.0.1:${run3.editorPort}/mcp`))).then(() => client);
-      c2.catch(() => upstreams.delete(dir));
-      upstreams.set(dir, { pid: run3.proc.pid, client: c2 });
-      return c2;
-    };
-    const withUpstream = async (dir, fn) => {
-      for (let attempt = 0; attempt < 2; attempt++) {
-        const up = upstream(dir);
-        if (!up) return null;
-        try {
-          return await fn(await up);
-        } catch (err) {
-          drop(dir);
-          const lost = /session|not connected|ECONNREFUSED|ECONNRESET|fetch failed|404/i.test(err.message ?? "");
-          if (attempt === 1 || !lost) throw err;
-        }
-      }
-      return null;
-    };
-    const notify = () => void server2.sendToolListChanged().catch(() => {
-    });
-    toolListeners.add(notify);
-    server2.onclose = () => {
-      toolListeners.delete(notify);
-      for (const dir of [...upstreams.keys()]) drop(dir);
-    };
-    const hubTools = [
-      { name: "list_projects", description: "Projects known to the Truecanvas hub, which are open, and which one your tools act on.", inputSchema: { type: "object", properties: {} } },
-      {
-        name: "open_project",
-        description: "Open a project (starts its app if needed) and make it the target of your tools.",
-        inputSchema: { type: "object", properties: { project: { type: "string", description: "Project name or path." } }, required: ["project"] }
-      }
-    ];
-    server2.setRequestHandler(ListToolsRequestSchema2, async () => {
-      const dir = target();
-      const projectTools = dir ? (await withUpstream(dir, (c2) => c2.listTools()).catch(() => null))?.tools ?? [] : [];
-      return { tools: [...hubTools, ...projectTools] };
-    });
-    server2.setRequestHandler(CallToolRequestSchema2, async (req) => {
-      const text = (t, isError = false) => ({ content: [{ type: "text", text: t }], isError });
-      if (req.params.name === "list_projects") {
-        const s = await state();
-        const lines = s.projects.map((p) => `${p.path === target() ? "\u2192 " : "  "}${p.name} (${p.path})${p.running ? ` [${p.running.status}]` : ""}${p.ready ? "" : " (Truecanvas not set up)"}`);
-        return text(lines.join("\n") || "No projects yet. The user can add some from the Dashboard.");
-      }
-      if (req.params.name === "open_project") {
-        const q = String(req.params.arguments?.project ?? "").toLowerCase();
-        const p = store.all().find((x) => x.name.toLowerCase() === q || x.path.toLowerCase() === q || path11.basename(x.path).toLowerCase() === q);
-        if (!p) return text(`No project "${q}". Use list_projects.`, true);
-        if (!p.ready) return text(`${p.name} isn't set up for Truecanvas yet. Ask the user to click "Set up" on the Dashboard.`, true);
-        store.touch(p.path);
-        const run3 = await runner.open(p.path);
-        if (run3.status !== "ready") return text(`Couldn't start ${p.name}: ${run3.error}`, true);
-        current = p.path;
-        notify();
-        return text(`\u2713 ${p.name} is open. Your tools now act on it.`);
-      }
-      const dir = target();
-      const out = dir ? await withUpstream(dir, (c2) => c2.callTool(req.params, void 0, { timeout: 18e4 })) : null;
-      if (!out) return text("No project is open. Use list_projects and open_project, or open one in the Truecanvas window.", true);
-      return out;
-    });
-    return server2;
-  }
-  async function handleMcp(req, res) {
-    const sessionId = req.headers["mcp-session-id"];
-    const body = req.method === "POST" ? await readJson(req) : void 0;
-    let transport = sessionId ? transports.get(sessionId) : void 0;
-    if (sessionId && transport) lastUse.set(sessionId, Date.now());
-    if (!transport) {
-      if (req.method !== "POST" || !isInitializeRequest2(body)) return json2(res, 400, { jsonrpc: "2.0", error: { code: -32e3, message: "No valid MCP session." }, id: null });
-      const t = new StreamableHTTPServerTransport2({
-        sessionIdGenerator: () => randomUUID2(),
-        onsessioninitialized: (id) => {
-          transports.set(id, t);
-          lastUse.set(id, Date.now());
-        }
-      });
-      t.onclose = () => {
-        if (t.sessionId) {
-          transports.delete(t.sessionId);
-          lastUse.delete(t.sessionId);
-        }
-      };
-      await createProxy().connect(t);
-      transport = t;
-    }
-    await transport.handleRequest(req, res, body);
-  }
-  async function api(req, res, url) {
-    const route = `${req.method} ${url.pathname}`;
-    const body = req.method === "POST" ? await readJson(req) : {};
-    switch (route) {
-      case "GET /api/hub/state":
-        return json2(res, 200, await state());
-      case "GET /api/hub/discover": {
-        const known = new Set(store.all().map((p) => p.path));
-        return json2(res, 200, { found: discover().filter((f) => !known.has(f.path)) });
-      }
-      case "GET /api/hub/icon": {
-        const icon = findIcon(url.searchParams.get("path") ?? "");
-        if (!icon) return json2(res, 404, { error: "No icon" });
-        res.writeHead(200, { "content-type": ICON_MIME[path11.extname(icon)] ?? "application/octet-stream", "cache-control": "private, max-age=300" });
-        return fs10.createReadStream(icon).on("error", () => res.destroy()).pipe(res);
-      }
-      case "GET /api/hub/ls":
-        return json2(res, 200, listDirs(url.searchParams.get("path") || "~"));
-      case "GET /api/hub/events":
-        res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
-        res.write(": connected\n\n");
-        clients.add(res);
-        req.on("close", () => clients.delete(res));
-        return;
-      case "POST /api/hub/add": {
-        const dir = path11.resolve(body.path.replace(/^~(?=$|[\\/])/, os6.homedir()));
-        if (!fs10.existsSync(path11.join(dir, "package.json"))) return json2(res, 400, { error: "No package.json in that folder. Pick the root of a Next.js or Vite app." });
-        store.touch(dir);
-        broadcast();
-        return json2(res, 200, { path: dir, ready: store.all().find((p) => p.path === dir)?.ready ?? false });
-      }
-      case "POST /api/hub/open": {
-        store.touch(body.path);
-        active = body.path;
-        if (body.focus) focus = { path: body.path, at: Date.now() };
-        let run3;
-        try {
-          run3 = await runner.open(body.path);
-        } catch (err) {
-          broadcast();
-          return json2(res, 400, { error: err.message });
-        }
-        broadcast();
-        return json2(res, 200, { status: run3.status, editor: `http://localhost:${run3.editorPort}`, error: run3.error });
-      }
-      case "POST /api/hub/close":
-        runner.close(body.path);
-        if (active === body.path) active = null;
-        broadcast();
-        return json2(res, 200, { ok: true });
-      case "POST /api/hub/active":
-        active = body.path || null;
-        broadcast();
-        return json2(res, 200, { ok: true });
-      case "POST /api/hub/forget":
-        runner.close(body.path);
-        store.forget(body.path);
-        broadcast();
-        return json2(res, 200, { ok: true });
-      case "POST /api/hub/setup":
-        return json2(res, 200, setupJob(body.path, pkgDir, opts.cli));
-      case "POST /api/hub/create":
-        return json2(res, 200, createJob(body.name, body.parent, pkgDir, opts.cli));
-      // ---------- GitHub ----------
-      case "GET /api/hub/github/repos": {
-        const r = await capture("gh", ["repo", "list", "--limit", "100", "--json", "nameWithOwner,description,updatedAt,isPrivate"], os6.homedir());
-        if (!r.ok) return json2(res, 200, { gh: false, error: r.out.split("\n")[0], repos: [] });
-        const repos = JSON.parse(r.out).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-        return json2(res, 200, { gh: true, repos });
-      }
-      case "POST /api/hub/clone":
-        return json2(res, 200, cloneJob(body.repo, body.parent || "~", pkgDir, opts.cli));
-      case "GET /api/hub/prs": {
-        const dir = url.searchParams.get("path") ?? "";
-        const r = await capture("gh", ["pr", "list", "--limit", "30", "--json", "number,title,headRefName,author,updatedAt,isDraft,url"], dir);
-        if (!r.ok) {
-          const msg = /no git remotes|not a git repository|none of the git remotes/i.test(r.out) ? "This project isn't on GitHub yet. Publish it from the Git panel (branch pill) first." : /gh auth login|not logged/i.test(r.out) ? "Sign in to GitHub first: run gh auth login in a terminal." : r.out.split("\n")[0];
-          return json2(res, 200, { error: msg, prs: [] });
-        }
-        return json2(res, 200, { prs: JSON.parse(r.out) });
-      }
-      case "POST /api/hub/pr-checkout": {
-        const r = await capture("gh", ["pr", "checkout", String(Number(body.number))], body.path);
-        if (!r.ok) {
-          const dirty = /local changes|would be overwritten|uncommitted/i.test(r.out);
-          return json2(res, 400, { error: dirty ? "This project has uncommitted changes. Commit them (Git panel) before opening another pull request." : r.out.split("\n").slice(-2).join(" ") });
-        }
-        store.touch(body.path);
-        active = body.path;
-        await runner.open(body.path);
-        broadcast();
-        return json2(res, 200, { ok: true });
-      }
-      case "POST /api/hub/quit":
-        json2(res, 200, { ok: true });
-        void runner.closeAll().finally(() => process.exit(0));
-        return;
-    }
-    const job = /^GET \/api\/hub\/jobs\/(\d+)$/.exec(route);
-    if (job) {
-      const j = getJob(job[1]);
-      if (j?.status === "done" && j.result) {
-        store.touch(j.result);
-        broadcast();
-      }
-      return j ? json2(res, 200, j) : json2(res, 404, { error: "No such job" });
-    }
-    return json2(res, 404, { error: `No route ${route}` });
-  }
-  function serveStatic(res, pathname) {
-    let file = path11.join(editorDir, pathname === "/" ? "hub.html" : pathname);
-    if (!inside2(editorDir, file) || !fs10.existsSync(file) || fs10.statSync(file).isDirectory()) file = path11.join(editorDir, "hub.html");
-    if (!fs10.existsSync(file)) {
-      res.writeHead(500, { "content-type": "text/plain" });
-      return res.end("Hub bundle missing. Run `pnpm build`.");
-    }
-    res.writeHead(200, { "content-type": MIME2[path11.extname(file)] ?? "application/octet-stream", "cache-control": pathname.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-cache" });
-    fs10.createReadStream(file).on("error", () => res.destroy()).pipe(res);
-  }
-  const server = http2.createServer(async (req, res) => {
-    try {
-      if (!allowedHosts.has(req.headers.host ?? "")) return json2(res, 403, { error: "Forbidden host" });
-      const reqOrigin = req.headers.origin;
-      if (reqOrigin && reqOrigin !== origin && reqOrigin !== `http://127.0.0.1:${opts.port}`) return json2(res, 403, { error: "Forbidden origin" });
-      const url = new URL(req.url ?? "/", origin);
-      if (url.pathname === "/mcp") return await handleMcp(req, res);
-      if (url.pathname.startsWith("/api/")) return await api(req, res, url);
-      if (req.method === "GET") return serveStatic(res, url.pathname);
-      json2(res, 405, { error: "Method not allowed" });
-    } catch (err) {
-      if (!res.headersSent) json2(res, err instanceof EditError ? 400 : 500, { error: err.message });
-      else res.end();
-    }
-  });
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(opts.port, "127.0.0.1", resolve);
-  });
-  const shutdown = () => {
-    server.close();
-    return runner.closeAll();
-  };
-  const exit = () => void shutdown().finally(() => process.exit(0));
-  process.once("SIGINT", exit);
-  process.once("SIGTERM", exit);
-  return { origin, shutdown };
-}
-var ICON_MIME = { ".ico": "image/x-icon", ".svg": "image/svg+xml", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp" };
-function findIcon(dir) {
-  if (!dir || !fs10.existsSync(path11.join(dir, "package.json"))) return null;
-  const names = ["icon.svg", "icon.png", "favicon.svg", "favicon.ico", "icon.ico", "apple-icon.png", "favicon.png", "logo.svg", "icon.jpg"];
-  const roots = ["app", "src/app", "public", "static", "assets"];
-  for (const root of roots) {
-    for (const name of names) {
-      const file = path11.join(dir, root, name);
-      if (fs10.existsSync(file) && fs10.statSync(file).size < 2e6) return file;
-    }
-  }
-  for (const root of ["app", "src/app"]) {
-    let entries = [];
-    try {
-      entries = fs10.readdirSync(path11.join(dir, root), { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const e of entries) {
-      if (!e.isDirectory()) continue;
-      for (const name of names.slice(0, 4)) {
-        const file = path11.join(dir, root, e.name, name);
-        if (fs10.existsSync(file)) return file;
-      }
-    }
-  }
-  return null;
-}
-function json2(res, status, body) {
-  res.writeHead(status, { "content-type": "application/json" });
-  res.end(JSON.stringify(body));
-}
-function inside2(dir, file) {
-  const rel = path11.relative(dir, file);
-  return !!rel && !rel.startsWith("..") && !path11.isAbsolute(rel);
-}
-
-// src/hub/desktop.ts
-import fs11 from "fs";
-import os7 from "os";
-import path12 from "path";
 var ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024">
   <defs>
     <linearGradient id="bg" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#ff9466"/><stop offset="1" stop-color="#ea6a3c"/></linearGradient>
@@ -3215,15 +2945,15 @@ var ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024">
   <path fill="#f6f5f1" fill-rule="evenodd" d="M236 236h552v168H236z M428 316h168v472H428z"/>
 </svg>
 `;
-var data = () => process.env.XDG_DATA_HOME ?? path12.join(os7.homedir(), ".local", "share");
+var data = () => process.env.XDG_DATA_HOME ?? path9.join(os3.homedir(), ".local", "share");
 function installDesktop(cli, port) {
-  const dir = path12.join(data(), "truecanvas");
-  fs11.mkdirSync(dir, { recursive: true });
-  const icon = path12.join(dir, "icon.svg");
-  fs11.writeFileSync(icon, ICON);
-  const launcher = path12.join(dir, "launch.sh");
+  const dir = path9.join(data(), "truecanvas");
+  fs7.mkdirSync(dir, { recursive: true });
+  const icon = path9.join(dir, "icon.svg");
+  fs7.writeFileSync(icon, ICON);
+  const launcher = path9.join(dir, "launch.sh");
   const url = `http://localhost:${port}`;
-  fs11.writeFileSync(
+  fs7.writeFileSync(
     launcher,
     `#!/bin/sh
 # Truecanvas launcher: start the hub if needed, then open its window.
@@ -3232,7 +2962,7 @@ CLI=${JSON.stringify(cli)}
 URL=${JSON.stringify(url)}
 LOG="\${XDG_STATE_HOME:-$HOME/.local/state}/truecanvas-hub.log"
 # apps started from the desktop don't get your shell's PATH: next, pnpm and npx need it
-export PATH=${JSON.stringify([path12.dirname(process.execPath), ...(process.env.PATH ?? "").split(path12.delimiter)].filter((p, i, a) => p && a.indexOf(p) === i).join(path12.delimiter))}
+export PATH=${JSON.stringify([path9.dirname(process.execPath), ...(process.env.PATH ?? "").split(path9.delimiter)].filter((p, i, a) => p && a.indexOf(p) === i).join(path9.delimiter))}
 mkdir -p "$(dirname "$LOG")"
 
 if ! curl -sf "$URL/api/hub/state" >/dev/null 2>&1; then
@@ -3241,7 +2971,7 @@ if ! curl -sf "$URL/api/hub/state" >/dev/null 2>&1; then
   while [ $i -lt 60 ] && ! curl -sf "$URL/api/hub/state" >/dev/null 2>&1; do sleep 0.25; i=$((i+1)); done
 fi
 
-PROFILE=${JSON.stringify(path12.join(dir, "window"))}
+PROFILE=${JSON.stringify(path9.join(dir, "window"))}
 for b in google-chrome google-chrome-stable chromium-browser chromium brave-browser microsoft-edge; do
   if command -v "$b" >/dev/null 2>&1; then
     exec "$b" --app="$URL" --class=Truecanvas --user-data-dir="$PROFILE" --no-first-run --no-default-browser-check
@@ -3251,10 +2981,10 @@ exec xdg-open "$URL"
 `,
     { mode: 493 }
   );
-  const apps = path12.join(data(), "applications");
-  fs11.mkdirSync(apps, { recursive: true });
-  const desktop = path12.join(apps, "truecanvas.desktop");
-  fs11.writeFileSync(
+  const apps = path9.join(data(), "applications");
+  fs7.mkdirSync(apps, { recursive: true });
+  const desktop = path9.join(apps, "truecanvas.desktop");
+  fs7.writeFileSync(
     desktop,
     `[Desktop Entry]
 Type=Application
@@ -3270,11 +3000,11 @@ StartupWMClass=Truecanvas
 StartupNotify=true
 `
   );
-  let command = path12.join(os7.homedir(), ".local", "bin", "truecanvas");
-  const ours = !fs11.existsSync(command) || fs11.readFileSync(command, "utf8").includes("# truecanvas wrapper");
+  let command = path9.join(os3.homedir(), ".local", "bin", "truecanvas");
+  const ours = !fs7.existsSync(command) || fs7.readFileSync(command, "utf8").includes("# truecanvas wrapper");
   if (ours) {
-    fs11.mkdirSync(path12.dirname(command), { recursive: true });
-    fs11.writeFileSync(command, `#!/bin/sh
+    fs7.mkdirSync(path9.dirname(command), { recursive: true });
+    fs7.writeFileSync(command, `#!/bin/sh
 # truecanvas wrapper (installed by \`truecanvas desktop\`)
 exec ${JSON.stringify(process.execPath)} ${JSON.stringify(cli)} "$@"
 `, { mode: 493 });
@@ -3282,19 +3012,19 @@ exec ${JSON.stringify(process.execPath)} ${JSON.stringify(cli)} "$@"
   return { desktop, launcher, icon, command };
 }
 function launcherPath() {
-  const p = path12.join(data(), "truecanvas", "launch.sh");
-  return fs11.existsSync(p) ? p : null;
+  const p = path9.join(data(), "truecanvas", "launch.sh");
+  return fs7.existsSync(p) ? p : null;
 }
 function uninstallDesktop() {
   const removed = [];
-  const cmd = path12.join(os7.homedir(), ".local", "bin", "truecanvas");
-  if (fs11.existsSync(cmd) && fs11.readFileSync(cmd, "utf8").includes("# truecanvas wrapper")) {
-    fs11.rmSync(cmd);
+  const cmd = path9.join(os3.homedir(), ".local", "bin", "truecanvas");
+  if (fs7.existsSync(cmd) && fs7.readFileSync(cmd, "utf8").includes("# truecanvas wrapper")) {
+    fs7.rmSync(cmd);
     removed.push(cmd);
   }
-  for (const f of [path12.join(data(), "applications", "truecanvas.desktop"), path12.join(data(), "truecanvas")]) {
-    if (fs11.existsSync(f)) {
-      fs11.rmSync(f, { recursive: true, force: true });
+  for (const f of [path9.join(data(), "applications", "truecanvas.desktop"), path9.join(data(), "truecanvas")]) {
+    if (fs7.existsSync(f)) {
+      fs7.rmSync(f, { recursive: true, force: true });
       removed.push(f);
     }
   }
@@ -3302,16 +3032,16 @@ function uninstallDesktop() {
 }
 
 // src/cli/index.ts
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { createInterface } from "readline/promises";
 
 // src/cli/doctor.ts
-import { execFile as execFile2 } from "child_process";
-import fs12 from "fs";
-import path13 from "path";
+import { execFile } from "child_process";
+import fs8 from "fs";
+import path10 from "path";
 var major = (v) => v ? Number(/(\d+)(?:\.(\d+))?/.exec(v)?.[1] ?? 0) : 0;
 function has(cmd, args, cwd) {
-  return new Promise((resolve) => execFile2(cmd, args, { cwd, timeout: 8e3 }, (err, stdout, stderr) => resolve(err ? null : `${stdout}${stderr}`)));
+  return new Promise((resolve) => execFile(cmd, args, { cwd, timeout: 8e3 }, (err, stdout, stderr) => resolve(err ? null : `${stdout}${stderr}`)));
 }
 async function doctor(root, cliVersion) {
   const checks = [];
@@ -3335,7 +3065,7 @@ async function doctor(root, cliVersion) {
   const tw = depVersion(root, "tailwindcss");
   add(tw ? { label: "Tailwind CSS", status: "ok", detail: tw } : { label: "Tailwind CSS", status: "warn", detail: "not installed", fix: "Optional, but the layout and style controls write Tailwind classes" });
   const config = loadConfig(root);
-  if (config.framework === "next") add(fs12.existsSync(path13.join(root, config.appDir)) ? { label: "App Router", status: "ok", detail: config.appDir } : { label: "App Router", status: "fail", detail: `no ${config.appDir}/`, fix: "Truecanvas renders through the App Router (app/ or src/app/)" });
+  if (config.framework === "next") add(fs8.existsSync(path10.join(root, config.appDir)) ? { label: "App Router", status: "ok", detail: config.appDir } : { label: "App Router", status: "fail", detail: `no ${config.appDir}/`, fix: "Truecanvas renders through the App Router (app/ or src/app/)" });
   const tc = installedIn(root);
   if (!tc.declared) add({ label: "Truecanvas in the project", status: "fail", detail: "not a dependency", fix: "npx truecanvas  (sets it up)" });
   else if (!tc.installed) add({ label: "Truecanvas in the project", status: "fail", detail: "declared but not installed", fix: `${pm} install` });
@@ -3344,15 +3074,15 @@ async function doctor(root, cliVersion) {
   const wrapped = configStatus(root, config.framework);
   const configLabel = config.framework === "vite" ? "vite.config" : "next.config";
   const uses = config.framework === "vite" ? "has the truecanvas() plugin" : "uses withTruecanvas()";
-  add(wrapped.wrapped ? { label: configLabel, status: "ok", detail: `${path13.basename(wrapped.file)} ${uses}` } : { label: configLabel, status: "fail", detail: wrapped.file ? "Truecanvas not enabled" : "missing", fix: "npx truecanvas init" });
+  add(wrapped.wrapped ? { label: configLabel, status: "ok", detail: `${path10.basename(wrapped.file)} ${uses}` } : { label: configLabel, status: "fail", detail: wrapped.file ? "Truecanvas not enabled" : "missing", fix: "npx truecanvas init" });
   const scripts = pkg.scripts ?? {};
   const script = Object.entries(scripts).find(([, v]) => v.includes("truecanvas"));
   add(script ? { label: "Start script", status: "ok", detail: runScript(pm, script[0]) } : { label: "Start script", status: "warn", detail: "none", fix: 'npx truecanvas init  (adds "canvas": "truecanvas dev")' });
-  const ignore = fs12.existsSync(path13.join(root, ".gitignore")) ? fs12.readFileSync(path13.join(root, ".gitignore"), "utf8") : "";
+  const ignore = fs8.existsSync(path10.join(root, ".gitignore")) ? fs8.readFileSync(path10.join(root, ".gitignore"), "utf8") : "";
   add(ignore.includes(config.routeDir) ? { label: "Generated route ignored", status: "ok" } : { label: "Generated route ignored", status: "warn", detail: `${config.routeDir}/ isn't in .gitignore`, fix: "npx truecanvas init" });
   add(hasAgentConfig(root) ? { label: "Agents", status: "ok", detail: ".mcp.json lists Truecanvas" } : { label: "Agents", status: "warn", detail: "not connected for this project", fix: "npx truecanvas connect  (then commit .mcp.json)" });
   const chrome = findChromium();
-  add(chrome ? { label: "Screenshots", status: "ok", detail: path13.basename(chrome) } : { label: "Screenshots", status: "warn", detail: "no Chromium found", fix: "npx playwright install chromium-headless-shell  (or install Chrome)" });
+  add(chrome ? { label: "Screenshots", status: "ok", detail: path10.basename(chrome) } : { label: "Screenshots", status: "warn", detail: "no Chromium found", fix: "npx playwright install chromium-headless-shell  (or install Chrome)" });
   const git = await has("git", ["rev-parse", "--is-inside-work-tree"], root);
   add(git ? { label: "Git", status: "ok" } : { label: "Git", status: "warn", detail: "not a repository", fix: "git init  (branches, history, comments and compare use git)" });
   const gh = await has("gh", ["auth", "status"], root);
@@ -3378,7 +3108,13 @@ Usage
   truecanvas quit      Quit the window and every app it started
   truecanvas desktop   Add Truecanvas to your app launcher (Linux); "desktop remove" undoes it
   truecanvas share [canvas]  Share a canvas as a link for clients (needs truecanvas running).
-                       --password <p>, --no-password, --revoke, --restore, --delete, --title <t>, --local (preview only)
+                       --password <p>, --no-password, --revoke, --restore, --delete, --title <t>, --local (preview only),
+                       --live <url|dir>: a live version clients open with "View live" (where the app runs, or a static build)
+                       --invite <emails>: invite people by email (they sign in with a link; new links are invited-only)
+                       --access invited|password|public: who can open the link
+                       --link-only: with --invite or --access, change the link without a new version
+                       --session: a live session (until Ctrl+C): the link shows the canvas live from your app,
+                         with everyone's cursors and comments in real time
   truecanvas share setup     Connect your studio's review site (URL + REVIEW_TOKEN)
   truecanvas mcp       stdio MCP server for agents without HTTP support
 
@@ -3401,6 +3137,55 @@ var c = {
   yellow: paint("33", "39"),
   red: paint("31", "39")
 };
+var accessLabel = (access) => access === "invited" ? "invited people only" : access === "password" ? "password protected" : access === "public" ? "anyone with the link" : "";
+async function liveSession(base, canvas) {
+  const call2 = async (route, body) => {
+    const res = await fetch(`${base}${route}`, body === void 0 ? void 0 : { method: "POST", headers: { "content-type": "application/json", origin: base }, body: JSON.stringify(body) });
+    const data2 = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(data2.error ?? `${res.status} ${res.statusText}`);
+    return data2;
+  };
+  let session;
+  try {
+    session = (await call2("/api/session/start", { canvas })).session;
+  } catch (err) {
+    console.error(`  ${c.red("\u2717")} ${err.message}`);
+    process.exit(1);
+  }
+  console.log(`  ${c.green("\u25CF")} Live session on ${c.bold(canvas)}: ${c.bold(session.url)}`);
+  console.log(`  ${c.dim("People with access to the link see the canvas live from your app. Ctrl+C ends the session.")}`);
+  let last = "";
+  const tick = async () => {
+    const all = (await call2("/api/session").catch(() => ({ sessions: [] }))).sessions;
+    const s = all.find((x) => x.canvas === canvas);
+    if (!s || s.status === "stopped") {
+      console.log(`  ${c.yellow("!")} The session ended${s?.error ? `: ${s.error}` : "."}`);
+      process.exit(s?.error ? 1 : 0);
+    }
+    const here = s.people.filter((p) => p.id !== s.you).map((p) => p.name);
+    const line = `${s.status}${here.length ? ` \xB7 here: ${here.join(", ")}` : ""}`;
+    if (line !== last) console.log(`  ${s.status === "live" ? c.green("\u25CF") : c.yellow("\u25CB")} ${line}`);
+    last = line;
+  };
+  const timer = setInterval(() => void tick(), 2e3);
+  const end = async () => {
+    clearInterval(timer);
+    await call2("/api/session/stop", { canvas }).catch(() => {
+    });
+    console.log(`  ${c.dim("Session ended: the link shows the latest published version again.")}`);
+    process.exit(0);
+  };
+  process.once("SIGINT", () => void end());
+  process.once("SIGTERM", () => void end());
+  await new Promise(() => {
+  });
+}
+function printInvited(invited) {
+  for (const i of invited) {
+    if (i.error) console.log(`  ${c.yellow("!")} Couldn't email ${i.email}: ${i.error}`);
+    else console.log(`  ${c.green("\u2713")} Invited ${i.email}${i.link ? c.dim(` (local review site: ${i.link})`) : ""}`);
+  }
+}
 async function main() {
   const { positionals, values } = parseArgs({
     allowPositionals: true,
@@ -3423,10 +3208,15 @@ async function main() {
       revoke: { type: "boolean" },
       restore: { type: "boolean" },
       delete: { type: "boolean" },
-      token: { type: "string" }
+      token: { type: "string" },
+      live: { type: "string" },
+      invite: { type: "string", multiple: true },
+      access: { type: "string" },
+      "link-only": { type: "boolean" },
+      session: { type: "boolean" }
     }
   });
-  const cli = fileURLToPath3(import.meta.url);
+  const cli = fileURLToPath2(import.meta.url);
   const pkgDir = packageDir(cli);
   const version = packageVersion(pkgDir);
   const command = positionals[0] ?? "start";
@@ -3440,13 +3230,13 @@ async function main() {
     const root2 = process.cwd();
     const deps = { ...readPackage(root2)?.dependencies, ...readPackage(root2)?.devDependencies };
     if (!("next" in deps) && !("vite" in deps && "react" in deps)) {
-      return openWindow(cli, values.port ? Number(values.port) : 4800);
+      return openWindow(cli, values.port ? Number(values.port) : hubPort());
     }
     if (!await ensureSetup(root2, pkgDir, version, yes)) return;
-    if (await openInWindow(root2, Number(values.port ?? 4800))) return;
-    const local = path14.join(root2, "node_modules", "truecanvas", "dist", "cli.js");
-    if (fs13.existsSync(local) && fs13.realpathSync(local) !== fs13.realpathSync(cli)) {
-      const child = spawn3(process.execPath, [local, "dev", ...process.argv.slice(2).filter((a) => a !== "start" && a !== "-y" && a !== "--yes")], { stdio: "inherit" });
+    if (await openInWindow(root2, values.port ? Number(values.port) : hubPort())) return;
+    const local = path11.join(root2, "node_modules", "truecanvas", "dist", "cli.js");
+    if (fs9.existsSync(local) && fs9.realpathSync(local) !== fs9.realpathSync(cli)) {
+      const child = spawn(process.execPath, [local, "dev", ...process.argv.slice(2).filter((a) => a !== "start" && a !== "-y" && a !== "--yes")], { stdio: "inherit" });
       for (const sig of ["SIGINT", "SIGTERM"]) process.on(sig, () => child.kill(sig));
       child.on("exit", (code) => process.exit(code ?? 0));
       return;
@@ -3503,9 +3293,9 @@ async function main() {
     }
     return;
   }
-  if (command === "open") return openWindow(cli, values.port ? Number(values.port) : 4800);
+  if (command === "open") return openWindow(cli, values.port ? Number(values.port) : hubPort());
   if (command === "quit") {
-    const url = `http://localhost:${values.port ?? 4800}`;
+    const url = `http://localhost:${values.port ?? hubPort()}`;
     const up = await fetch(`${url}/api/hub/state`, { signal: AbortSignal.timeout(1500) }).then((r) => r.ok).catch(() => false);
     if (!up) return console.log("Truecanvas isn't running.");
     await fetch(`${url}/api/hub/quit`, { method: "POST" }).catch(() => {
@@ -3527,7 +3317,7 @@ async function main() {
     return;
   }
   const root = process.cwd();
-  if (!fs13.existsSync(path14.join(root, "package.json"))) {
+  if (!fs9.existsSync(path11.join(root, "package.json"))) {
     console.error("Run truecanvas from your app's root (no package.json here).");
     process.exit(1);
   }
@@ -3537,7 +3327,7 @@ async function main() {
     const report = initProject(config);
     ws.ensureRoute();
     console.log(`
-  ${c.accent("\u25C6")} ${c.bold("Truecanvas")} is set up in ${c.bold(path14.basename(root))}
+  ${c.accent("\u25C6")} ${c.bold("Truecanvas")} is set up in ${c.bold(path11.basename(root))}
 `);
     for (const line of report.done) console.log(`  ${c.green("\u2713")} ${line}`);
     console.log(`  ${c.green("\u2713")} Canvas folder ${c.bold(config.canvasDir)} and dev route ${c.bold(config.routeDir)}`);
@@ -3569,7 +3359,7 @@ async function main() {
         console.error(site ? "Name the canvas: truecanvas share <canvas> --delete" : `No review site yet: ${c.accent("npx truecanvas share setup")}`);
         process.exit(1);
       }
-      const done = await deleteShare(site, path14.basename(root), canvas);
+      const done = await deleteShare(site, path11.basename(root), canvas);
       console.log(done ? `  ${c.green("\u2713")} Deleted the link of ${canvas}, with its versions and comments.` : `  ${canvas} has no link.`);
       return;
     }
@@ -3580,10 +3370,38 @@ async function main() {
         process.exit(1);
       }
       const change = { ...values.revoke ? { revoked: true } : values.restore ? { revoked: false } : {}, ...values["no-password"] ? { password: null } : {} };
-      const url = await updateShare(site, path14.basename(root), canvas, change);
+      const url = await updateShare(site, path11.basename(root), canvas, change);
       console.log(`  ${c.green("\u2713")} ${values.revoke ? "Link revoked" : values.restore ? "Link restored" : "Password removed"}: ${url}`);
       return;
     }
+    let invite = [];
+    try {
+      invite = parseEmails(values.invite);
+    } catch (err) {
+      console.error(`  ${c.red("\u2717")} ${err.message}`);
+      process.exit(1);
+    }
+    const access = values.access;
+    if (access && !ACCESS_MODES.includes(access)) {
+      console.error(`  ${c.red("\u2717")} --access is ${ACCESS_MODES.join(", ")}`);
+      process.exit(1);
+    }
+    if (values["link-only"]) {
+      const site = reviewSite();
+      if (!site || !canvas || !access && !invite.length) {
+        console.error(!site ? `No review site yet: ${c.accent("npx truecanvas share setup")}` : !canvas ? "Name the canvas: truecanvas share <canvas> --invite name@client.com --link-only" : "--link-only goes with --invite or --access");
+        process.exit(1);
+      }
+      try {
+        const done = await updateAccess(site, path11.basename(root), canvas, { access, password: values.password, invite });
+        console.log(`  ${c.green("\u2713")} ${done.url} ${c.dim(`(${accessLabel(done.access)})`)}`);
+        printInvited(done.invited);
+      } catch (err) {
+        console.error(`  ${c.red("\u2717")} ${err.message}`);
+        process.exit(1);
+      }
+      return;
+    }
     if (!state) {
       console.error(`Truecanvas isn't running for this project. Start it first: ${c.accent("npx truecanvas")}`);
       process.exit(1);
@@ -3593,10 +3411,24 @@ async function main() {
   truecanvas share <canvas>`);
       process.exit(1);
     }
+    if (values.session) return liveSession(base, canvas);
     const publish = !values.local && !!reviewSite();
     console.log(`  ${c.dim(`Rendering ${canvas} through your app${publish ? " and publishing it" : ""}\u2026`)}`);
     const password = values.password;
-    const res = await fetch(`${base}/api/share/snapshot`, { method: "POST", headers: { "content-type": "application/json", origin: base }, body: JSON.stringify({ canvas, local: !publish, title: values.title, password }) });
+    const live = values.live ? /^https?:\/\//.test(values.live) ? { url: values.live } : { dir: path11.resolve(values.live) } : void 0;
+    if (live && "dir" in live && !fs9.existsSync(path11.join(live.dir, "index.html"))) {
+      console.error(`  ${c.red("\u2717")} No index.html in ${live.dir}. Pass a static build folder (Next \`out/\`, Vite \`dist/\`) or the URL where the app runs.`);
+      process.exit(1);
+    }
+    if ((live || access || invite.length) && !publish) {
+      console.error(`  ${c.red("\u2717")} ${live ? "--live" : access ? "--access" : "--invite"} needs a review site: ${c.accent("npx truecanvas share setup")}`);
+      process.exit(1);
+    }
+    const res = await fetch(`${base}/api/share/snapshot`, {
+      method: "POST",
+      headers: { "content-type": "application/json", origin: base },
+      body: JSON.stringify({ canvas, local: !publish, title: values.title, password, live, access, invite })
+    });
     const body = await res.json();
     if (!res.ok) {
       console.error(`  ${c.red("\u2717")} ${body.error}`);
@@ -3608,8 +3440,12 @@ async function main() {
     if (manifest.missing.length) console.log(`  ${c.yellow("!")} ${manifest.missing.length} asset${manifest.missing.length === 1 ? "" : "s"} couldn't be fetched.`);
     if (published?.skipped.length) console.log(`  ${c.yellow("!")} Left out (over 4.4 MB): ${published.skipped.join(", ")}`);
     if (published) {
-      console.log(`  ${c.green("\u2713")} Shared: ${c.bold(published.url)} ${c.dim(`(version ${published.versions}${published.password ? ", password protected" : ""})`)}
-`);
+      const who = published.access ? `, ${accessLabel(published.access)}` : published.password ? ", password protected" : "";
+      console.log(`  ${c.green("\u2713")} Shared: ${c.bold(published.url)} ${c.dim(`(version ${published.versions}${who})`)}`);
+      if (published.live) console.log(`  ${c.green("\u2713")} Live: ${published.live} ${c.dim(published.access !== "public" && (published.access || published.password) ? "(opens from the link's View live button)" : "")}`);
+      printInvited(published.invited);
+      if (published.access === "invited" && !published.invited.length) console.log(`  ${c.dim("Only invited people and your studio can open it. Invite someone:")} ${c.accent(`npx truecanvas share ${canvas} --invite name@client.com --link-only`)}`);
+      console.log("");
       if (values.open && !values["no-open"]) openBrowser(published.url);
     } else {
       console.log(`  ${c.dim("Preview")} ${c.bold(body.preview)}`);
@@ -3703,12 +3539,12 @@ async function openWindow(cli, port) {
   const url = `http://localhost:${port}`;
   const launcher = launcherPath();
   if (launcher) {
-    spawn3(launcher, [], { stdio: "ignore", detached: true }).unref();
+    spawn(launcher, [], { stdio: "ignore", detached: true }).unref();
     return console.log(`${c.accent("\u25C6")} Opening Truecanvas\u2026`);
   }
   const up = await fetch(`${url}/api/hub/state`, { signal: AbortSignal.timeout(1500) }).then((r) => r.ok).catch(() => false);
   if (!up) {
-    spawn3(process.execPath, [cli, "hub", "--port", String(port), "--no-open"], { stdio: "ignore", detached: true }).unref();
+    spawn(process.execPath, [cli, "hub", "--port", String(port), "--no-open"], { stdio: "ignore", detached: true }).unref();
     for (let i = 0; i < 40 && !await fetch(`${url}/api/hub/state`).then((r) => r.ok).catch(() => false); i++) await new Promise((r) => setTimeout(r, 250));
   }
   openBrowser(url);
@@ -3721,7 +3557,7 @@ async function openInWindow(root, port) {
   const post = (route, body) => fetch(`${hub}${route}`, { method: "POST", headers: { "content-type": "application/json", origin: hub }, body: JSON.stringify(body) }).catch(() => null);
   await post("/api/hub/add", { path: root });
   await post("/api/hub/open", { path: root, focus: "1" });
-  console.log(`${c.accent("\u25C6")} Opened ${c.bold(path14.basename(root))} in the Truecanvas window ${c.dim(`(${hub})`)}.`);
+  console.log(`${c.accent("\u25C6")} Opened ${c.bold(path11.basename(root))} in the Truecanvas window ${c.dim(`(${hub})`)}.`);
   return true;
 }
 async function prompt(question) {
@@ -3745,7 +3581,7 @@ async function ensureSetup(root, pkgDir, version, yes, force = false) {
   const tc = installedIn(root);
   const wrapped = configStatus(root).wrapped;
   if (tc.declared && tc.installed && wrapped && !force) return true;
-  const name = readPackage(root)?.name ?? path14.basename(root);
+  const name = readPackage(root)?.name ?? path11.basename(root);
   if (!yes) {
     if (!process.stdin.isTTY) {
       console.error(`Truecanvas isn't set up in ${name} yet. Run again with --yes to set it up.`);
@@ -3819,7 +3655,7 @@ function startApp(root, appUrl, framework) {
   const bin = binScript(root, pkg);
   const [cmd, args] = bin ? [process.execPath, [bin, ...devArgs]] : [process.platform === "win32" ? "npx.cmd" : "npx", [pkg, ...devArgs]];
   const label = framework === "vite" ? "vite" : "next";
-  const child = spawn3(cmd, args, { cwd: root, env: toolEnv(process.env.NO_COLOR ? {} : { FORCE_COLOR: "1" }), stdio: ["ignore", "pipe", "pipe"], shell: !bin && process.platform === "win32" });
+  const child = spawn(cmd, args, { cwd: root, env: toolEnv(process.env.NO_COLOR ? {} : { FORCE_COLOR: "1" }), stdio: ["ignore", "pipe", "pipe"], shell: !bin && process.platform === "win32" });
   child.on("error", (err) => console.error(`  ${c.dim(`${label} \u2502`)} couldn't start ${pkg}: ${err.message}`));
   const prefix = c.dim(`${label} \u2502 `);
   for (const stream of [child.stdout, child.stderr]) {
@@ -3836,24 +3672,24 @@ function startApp(root, appUrl, framework) {
 }
 function binScript(root, pkg) {
   try {
-    const req = createRequire(path14.join(root, "package.json"));
+    const req = createRequire(path11.join(root, "package.json"));
     const manifest = req.resolve(`${pkg}/package.json`);
-    const { bin } = JSON.parse(fs13.readFileSync(manifest, "utf8"));
+    const { bin } = JSON.parse(fs9.readFileSync(manifest, "utf8"));
     const rel = typeof bin === "string" ? bin : bin?.[pkg];
-    return rel ? path14.join(path14.dirname(manifest), rel) : null;
+    return rel ? path11.join(path11.dirname(manifest), rel) : null;
   } catch {
     return null;
   }
 }
 function stopTree(child, signal) {
-  if (process.platform === "win32" && child.pid) spawn3("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on("error", () => {
+  if (process.platform === "win32" && child.pid) spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on("error", () => {
   });
   else child.kill(signal);
 }
 function openBrowser(url) {
   const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
   try {
-    spawn3(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" }).on("error", () => {
+    spawn(cmd, [url], { stdio: "ignore", detached: true, shell: process.platform === "win32" }).on("error", () => {
     }).unref();
   } catch {
   }