truecanvas 0.4.1 → 0.6.0

package/dist/chunk-NAK4DQWO.js

@@ -0,0 +1,1005 @@
+import {
+  EditError,
+  addArgs,
+  detectPm,
+  nodeBin,
+  shellSafe,
+  toolEnv
+} from "./chunk-D565QDII.js";
+
+// src/cli/setup.ts
+import { spawn } from "child_process";
+import { createHash } from "crypto";
+import fs from "fs";
+import os from "os";
+import path 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 path.resolve(path.dirname(cliFile), "..");
+}
+function packageVersion(pkgDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(pkgDir, "package.json"), "utf8")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function isSourceCheckout(pkgDir) {
+  return !pkgDir.split(path.sep).includes("node_modules") && fs.existsSync(path.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 = path.join(os.homedir(), ".cache", "truecanvas");
+  fs.mkdirSync(cacheDir, { recursive: true });
+  const file = path.join(cacheDir, `truecanvas-${version}.tgz`);
+  await exec("npm", ["pack", "--silent", "--pack-destination", cacheDir], pkgDir);
+  const hash = createHash("sha256").update(fs.readFileSync(file)).digest("hex").slice(0, 10);
+  const named = path.join(cacheDir, `truecanvas-${version}-${hash}.tgz`);
+  fs.renameSync(file, named);
+  return named;
+}
+function installedIn(root) {
+  let declared = false;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+    declared = "truecanvas" in { ...pkg.dependencies, ...pkg.devDependencies };
+  } catch {
+  }
+  const file = path.join(root, "node_modules", "truecanvas", "package.json");
+  const installed = fs.existsSync(file);
+  return { declared, installed, version: installed ? packageVersion(path.dirname(file)) : null };
+}
+function readPackage(root) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function depVersion(root, name) {
+  const file = path.join(root, "node_modules", name, "package.json");
+  if (fs.existsSync(file)) return packageVersion(path.dirname(file));
+  const pkg = readPackage(root);
+  return pkg ? { ...pkg.dependencies, ...pkg.devDependencies }[name] ?? null : null;
+}
+function mergeJson(file, update) {
+  let data = {};
+  if (fs.existsSync(file)) {
+    try {
+      data = JSON.parse(fs.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(data);
+  update(data);
+  if (JSON.stringify(data) === before) return "unchanged";
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(data, 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(path.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 || fs.existsSync(path.join(root, ".cursor"))) add(".cursor/mcp.json", (d) => void (servers(d, "mcpServers").truecanvas = { url }));
+  if (opts.vscode || fs.existsSync(path.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(fs.readFileSync(path.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/locate.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+var HUB_PORT = 4800;
+function stateDir() {
+  if (process.platform === "win32") return path2.join(process.env.LOCALAPPDATA ?? path2.join(os2.homedir(), "AppData", "Local"), "truecanvas");
+  if (process.platform === "darwin") return path2.join(os2.homedir(), "Library", "Application Support", "truecanvas");
+  return path2.join(process.env.XDG_STATE_HOME ?? path2.join(os2.homedir(), ".local", "state"), "truecanvas");
+}
+var hubFile = () => path2.join(stateDir(), "hub.json");
+function writeHubFile(port) {
+  try {
+    fs2.mkdirSync(stateDir(), { recursive: true });
+    fs2.writeFileSync(hubFile(), JSON.stringify({ port, pid: process.pid }));
+  } catch {
+  }
+}
+function removeHubFile() {
+  try {
+    const saved = JSON.parse(fs2.readFileSync(hubFile(), "utf8"));
+    if (saved.pid === process.pid) fs2.rmSync(hubFile());
+  } catch {
+  }
+}
+function hubPort() {
+  try {
+    const saved = JSON.parse(fs2.readFileSync(hubFile(), "utf8"));
+    if (saved.port && saved.pid) {
+      process.kill(saved.pid, 0);
+      return saved.port;
+    }
+  } catch {
+  }
+  return HUB_PORT;
+}
+
+// src/hub/server.ts
+import http from "http";
+import fs5 from "fs";
+import os5 from "os";
+import path5 from "path";
+import { randomUUID } from "crypto";
+import { fileURLToPath } from "url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+
+// src/hub/projects.ts
+import fs3 from "fs";
+import os3 from "os";
+import path3 from "path";
+var CONFIG_DIR = path3.join(process.env.XDG_CONFIG_HOME ?? path3.join(os3.homedir(), ".config"), "truecanvas");
+var FILE = path3.join(CONFIG_DIR, "projects.json");
+var ProjectStore = class {
+  list = [];
+  constructor() {
+    try {
+      this.list = JSON.parse(fs3.readFileSync(FILE, "utf8"));
+    } catch {
+      this.list = [];
+    }
+  }
+  save() {
+    fs3.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs3.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 = path3.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 !== path3.resolve(dir));
+    this.save();
+  }
+};
+function readPkg(dir) {
+  try {
+    return JSON.parse(fs3.readFileSync(path3.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 : path3.basename(dir);
+}
+function inspect(dir) {
+  const pkg = readPkg(dir);
+  if (!pkg) return { next: false, ready: false, canvases: 0, exists: fs3.existsSync(dir) };
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  let canvases = 0;
+  for (const d of ["canvas", "src/canvas"]) {
+    try {
+      canvases += fs3.readdirSync(path3.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) => path3.join(home, d)).filter((d) => fs3.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 = fs3.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(path3.join(dir, e.name), depth + 1);
+    }
+  };
+  for (const r of roots) walk(r, 0);
+  return found;
+}
+function listDirs(dir) {
+  const abs = path3.resolve(dir.replace(/^~(?=$|[\\/])/, os3.homedir()));
+  const dirs = fs3.readdirSync(abs, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => ({ name: e.name, next: inspect(path3.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 fs4 from "fs";
+import net from "net";
+import os4 from "os";
+import path4 from "path";
+var NO_NODE = "Node.js wasn't found. Install it (nodejs.org, or your package manager), then restart Truecanvas: your projects run on your own Node.";
+function node() {
+  const bin = nodeBin();
+  if (!bin) throw new Error(NO_NODE);
+  return bin;
+}
+function projectCli(dir, fallback) {
+  const local = path4.join(dir, "node_modules", "truecanvas", "dist", "cli.js");
+  return fs4.existsSync(local) ? local : fallback;
+}
+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, hubUrl) {
+    this.cli = cli;
+    this.onChange = onChange;
+    this.hubUrl = hubUrl;
+  }
+  cli;
+  onChange;
+  hubUrl;
+  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 (!fs4.existsSync(path4.join(dir, "package.json"))) throw new Error(`${dir} isn't there anymore (or has no package.json).`);
+    const bin = node();
+    const [editorPort, appPort] = await this.allocatePorts();
+    const proc = spawn2(bin, [projectCli(dir, this.cli), "dev", "--no-open", "--port", String(editorPort), "--app", `http://localhost:${appPort}`], {
+      cwd: dir,
+      env: toolEnv({ FORCE_COLOR: "0", TRUECANVAS_HUB: "1", ...this.hubUrl ? { TRUECANVAS_HUB_URL: this.hubUrl } : {} }),
+      stdio: ["ignore", "pipe", "pipe"],
+      // its own process group: closing the project also stops the next dev it started
+      detached: process.platform !== "win32"
+    });
+    const run2 = { path: dir, editorPort, appPort, proc, status: "starting", log: [], startedAt: Date.now() };
+    this.running.set(dir, run2);
+    const capture2 = (chunk) => {
+      for (const line of chunk.toString().split("\n")) if (line.trim()) run2.log.push(line.replace(/\x1b\[[0-9;]*m/g, ""));
+      if (run2.log.length > 200) run2.log.splice(0, run2.log.length - 200);
+    };
+    proc.stdout.on("data", capture2);
+    proc.stderr.on("data", capture2);
+    proc.on("error", (err) => {
+      run2.status = "failed";
+      run2.error = err.message;
+      this.onChange();
+    });
+    proc.on("exit", (code) => {
+      if (this.running.get(dir) !== run2) return;
+      if (run2.status === "starting" || code) {
+        run2.status = "failed";
+        run2.error = run2.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 && run2.status === "starting") {
+      try {
+        const res = await fetch(`http://127.0.0.1:${editorPort}/api/state`, { signal: AbortSignal.timeout(1e3) });
+        if (res.ok) {
+          run2.status = "ready";
+          break;
+        }
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, 400));
+    }
+    if (run2.status === "starting") {
+      run2.status = "failed";
+      run2.error = "Truecanvas didn't start within a minute.";
+      killTree(run2.proc, "SIGTERM");
+    }
+    this.onChange();
+    return run2;
+  }
+  /** Stops a project and everything it started; resolves once it has exited (or after 5s). */
+  close(dir) {
+    const run2 = this.running.get(dir);
+    if (!run2) return Promise.resolve();
+    this.running.delete(dir);
+    this.onChange();
+    if (run2.proc.exitCode !== null || run2.proc.signalCode !== null) return Promise.resolve();
+    return new Promise((resolve) => {
+      const force = setTimeout(() => killTree(run2.proc, "SIGKILL"), 4e3);
+      const done = setTimeout(resolve, 5e3);
+      run2.proc.once("exit", () => {
+        clearTimeout(force);
+        clearTimeout(done);
+        resolve();
+      });
+      killTree(run2.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, run2] of this.running) if (run2.proc.pid) outMap[dir] = Math.round(total(run2.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 run(job, cmd, args, cwd);
+  } catch (err) {
+    const ignoredBuilds = job.log.some((l) => l.includes("ERR_PNPM_IGNORED_BUILDS"));
+    const installed = fs4.existsSync(path4.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 run(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 = (c) => {
+      for (const line of c.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"], os4.homedir());
+  return ok ? "pnpm" : "npm";
+}
+function setupJob(dir, pkgDir, cli) {
+  return startJob(`Set up ${path4.basename(dir)}`, async (job) => {
+    const pm = packageManager(dir);
+    const source = await packageSpec(pkgDir, (cmd, args, cwd) => run(job, cmd, args, cwd));
+    await install(job, pm.cmd, [...pm.add, source], dir);
+    await run(job, node(), [projectCli(dir, 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 = path4.resolve(parent.replace(/^~(?=$|[\\/])/, os4.homedir()));
+  const dir = path4.join(parentDir, safe);
+  return startJob(`Create ${safe}`, async (job) => {
+    if (!safe) throw new Error("Pick a project name.");
+    if (fs4.existsSync(dir)) throw new Error(`${dir} already exists.`);
+    fs4.mkdirSync(parentDir, { recursive: true });
+    const pm = await preferredPm();
+    await run(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) => run(job, cmd, args, cwd));
+    await install(job, pm, addArgs(pm, [source], true), dir);
+    await run(job, node(), [projectCli(dir, 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: toolEnv({ 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 = path4.resolve(parent.replace(/^~(?=$|[\\/])/, os4.homedir()));
+  const name = repo.replace(/\.git$/, "").split(/[/:]/).pop() ?? "";
+  const dir = path4.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 (fs4.existsSync(dir)) throw new Error(`${dir} already exists. Open it with Open folder instead.`);
+    fs4.mkdirSync(parentDir, { recursive: true });
+    const url = /^(https?:|git@|ssh:|file:)/.test(repo);
+    if (url) await run(job, "git", ["clone", repo, dir], parentDir);
+    else await run(job, "gh", ["repo", "clone", repo, dir], parentDir);
+    if (!fs4.existsSync(path4.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 (!fs4.existsSync(path4.join(dir, "node_modules"))) throw err;
+    });
+    const pkg = JSON.parse(fs4.readFileSync(path4.join(dir, "package.json"), "utf8"));
+    if (!("truecanvas" in { ...pkg.dependencies, ...pkg.devDependencies })) {
+      const source = await packageSpec(pkgDir, (cmd, args, cwd) => run(job, cmd, args, cwd));
+      await install(job, pm.cmd, [...pm.add, source], dir);
+      await run(job, node(), [projectCli(dir, cli), "init"], dir);
+    } else job.log.push("Truecanvas is already part of this project.");
+    return dir;
+  });
+}
+
+// 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/hub/server.ts
+var MIME = {
+  ".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 = fileURLToPath(new URL("./editor/", import.meta.url));
+  const pkgDir = path5.resolve(path5.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, origin);
+  const idleMs = (opts.idleMinutes ?? Number(process.env.TRUECANVAS_IDLE_MINUTES ?? 30)) * 6e4;
+  const lastUsed = /* @__PURE__ */ new Map();
+  const used = (dir) => {
+    if (dir) lastUsed.set(dir, Date.now());
+  };
+  if (idleMs > 0)
+    setInterval(() => {
+      if (clients.size) used(active);
+      for (const [dir, run2] of runner.running) {
+        if (dir === active && clients.size || run2.status === "starting") continue;
+        if (Date.now() - (lastUsed.get(dir) ?? run2.startedAt) < idleMs) continue;
+        lastUsed.delete(dir);
+        void runner.close(dir);
+      }
+    }, Math.min(6e4, idleMs)).unref();
+  setInterval(() => {
+    for (const res of clients) res.write(": ping\n\n");
+  }, 2e4).unref();
+  let focus = null;
+  async function sessionsOf(dir) {
+    const r = runner.running.get(dir);
+    if (!r || r.status !== "ready") return [];
+    try {
+      const res = await fetch(`http://localhost:${r.editorPort}/api/session`, { signal: AbortSignal.timeout(800) });
+      return res.ok ? (await res.json()).sessions.filter((s) => s.status !== "stopped") : [];
+    } catch {
+      return [];
+    }
+  }
+  async function sessionAction(action, dir = active, canvas) {
+    if (!dir) throw new Error("Open a project first.");
+    const r = runner.running.get(dir);
+    if (!r || r.status !== "ready") throw new Error("Open the project first: its Truecanvas runs the session.");
+    const live = await sessionsOf(dir);
+    const start = action === "start" || action === "toggle" && !live.length;
+    const res = await fetch(`http://localhost:${r.editorPort}/api/session/${start ? "start" : "stop"}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(canvas ? { canvas } : {}),
+      signal: AbortSignal.timeout(3e4)
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(data.error ?? `${res.status} ${res.statusText}`);
+    used(dir);
+    broadcast();
+    return sessionsOf(dir);
+  }
+  async function state() {
+    const memory = await runner.memory();
+    const running = [...runner.running.keys()];
+    const live = await Promise.all(running.map(async (dir) => [dir, await sessionsOf(dir)]));
+    return {
+      origin,
+      active,
+      focus,
+      notice: opts.notice ?? null,
+      liveSession: { available: true, sessions: Object.fromEntries(live.filter(([, s]) => s.length)) },
+      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 Server({ 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((c) => c.close()).catch(() => {
+      });
+    };
+    const upstream = (dir) => {
+      const run2 = runner.running.get(dir);
+      if (!run2 || run2.status !== "ready") return null;
+      const hit = upstreams.get(dir);
+      if (hit && hit.pid === run2.proc.pid) return hit.client;
+      if (hit) drop(dir);
+      const info = server2.getClientVersion();
+      const client = new Client({ name: info?.name ?? "agent", version: info?.version ?? "0.0.0" });
+      const c = client.connect(new StreamableHTTPClientTransport(new URL(`http://127.0.0.1:${run2.editorPort}/mcp`))).then(() => client);
+      c.catch(() => upstreams.delete(dir));
+      upstreams.set(dir, { pid: run2.proc.pid, client: c });
+      return c;
+    };
+    const withUpstream = async (dir, fn) => {
+      used(dir);
+      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(ListToolsRequestSchema, async () => {
+      const dir = target();
+      const projectTools = dir ? (await withUpstream(dir, (c) => c.listTools()).catch(() => null))?.tools ?? [] : [];
+      return { tools: [...hubTools, ...projectTools] };
+    });
+    server2.setRequestHandler(CallToolRequestSchema, 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 || path5.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 run2 = await runner.open(p.path);
+        if (run2.status !== "ready") return text(`Couldn't start ${p.name}: ${run2.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, (c) => c.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" || !isInitializeRequest(body)) return json(res, 400, { jsonrpc: "2.0", error: { code: -32e3, message: "No valid MCP session." }, id: null });
+      const t = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        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 json(res, 200, await state());
+      case "GET /api/hub/discover": {
+        const known = new Set(store.all().map((p) => p.path));
+        return json(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 json(res, 404, { error: "No icon" });
+        res.writeHead(200, { "content-type": ICON_MIME[path5.extname(icon)] ?? "application/octet-stream", "cache-control": "private, max-age=300" });
+        return fs5.createReadStream(icon).on("error", () => res.destroy()).pipe(res);
+      }
+      case "GET /api/hub/ls":
+        return json(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 = path5.resolve(body.path.replace(/^~(?=$|[\\/])/, os5.homedir()));
+        if (!fs5.existsSync(path5.join(dir, "package.json"))) return json(res, 400, { error: "No package.json in that folder. Pick the root of a Next.js or Vite app." });
+        store.touch(dir);
+        broadcast();
+        return json(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;
+        used(body.path);
+        if (body.focus) focus = { path: body.path, at: Date.now() };
+        let run2;
+        try {
+          run2 = await runner.open(body.path);
+        } catch (err) {
+          broadcast();
+          return json(res, 400, { error: err.message });
+        }
+        broadcast();
+        return json(res, 200, { status: run2.status, editor: `http://localhost:${run2.editorPort}`, error: run2.error });
+      }
+      case "POST /api/hub/close":
+        runner.close(body.path);
+        if (active === body.path) active = null;
+        broadcast();
+        return json(res, 200, { ok: true });
+      case "POST /api/hub/active":
+        used(active);
+        active = body.path || null;
+        used(active);
+        broadcast();
+        return json(res, 200, { ok: true });
+      case "POST /api/hub/forget":
+        runner.close(body.path);
+        store.forget(body.path);
+        broadcast();
+        return json(res, 200, { ok: true });
+      case "POST /api/hub/setup":
+        return json(res, 200, setupJob(body.path, pkgDir, opts.cli));
+      case "POST /api/hub/create":
+        return json(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"], os5.homedir());
+        if (!r.ok) return json(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 json(res, 200, { gh: true, repos });
+      }
+      case "POST /api/hub/clone":
+        return json(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 json(res, 200, { error: msg, prs: [] });
+        }
+        return json(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 json(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 json(res, 200, { ok: true });
+      }
+      case "POST /api/hub/notify": {
+        const p = store.all().find((x) => x.path === body.path);
+        if (!p || !body.name || !body.canvas) return json(res, 400, { error: "Unknown project or comment" });
+        opts.onNotice?.({ path: p.path, project: p.name, canvas: String(body.canvas), name: String(body.name).slice(0, 80), text: String(body.text ?? "").slice(0, 300) });
+        return json(res, 200, { ok: true });
+      }
+      case "POST /api/hub/session": {
+        const action = body.action === "start" || body.action === "stop" ? body.action : "toggle";
+        try {
+          const sessions = await sessionAction(action, body.path ? String(body.path) : active, body.canvas ? String(body.canvas) : void 0);
+          return json(res, 200, { sessions });
+        } catch (err) {
+          return json(res, 400, { error: err.message });
+        }
+      }
+      case "POST /api/hub/quit":
+        json(res, 200, { ok: true });
+        if (opts.onQuit) return opts.onQuit();
+        void shutdown().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 ? json(res, 200, j) : json(res, 404, { error: "No such job" });
+    }
+    return json(res, 404, { error: `No route ${route}` });
+  }
+  function serveStatic(res, pathname) {
+    let file = path5.join(editorDir, pathname === "/" ? "hub.html" : pathname);
+    if (!inside(editorDir, file) || !fs5.existsSync(file) || fs5.statSync(file).isDirectory()) file = path5.join(editorDir, "hub.html");
+    if (!fs5.existsSync(file)) {
+      res.writeHead(500, { "content-type": "text/plain" });
+      return res.end("Hub bundle missing. Run `pnpm build`.");
+    }
+    res.writeHead(200, { "content-type": MIME[path5.extname(file)] ?? "application/octet-stream", "cache-control": pathname.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-cache" });
+    fs5.createReadStream(file).on("error", () => res.destroy()).pipe(res);
+  }
+  const server = http.createServer(async (req, res) => {
+    try {
+      if (!allowedHosts.has(req.headers.host ?? "")) return json(res, 403, { error: "Forbidden host" });
+      const reqOrigin = req.headers.origin;
+      if (reqOrigin && reqOrigin !== origin && reqOrigin !== `http://127.0.0.1:${opts.port}`) return json(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);
+      json(res, 405, { error: "Method not allowed" });
+    } catch (err) {
+      if (!res.headersSent) json(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);
+  });
+  writeHubFile(opts.port);
+  const shutdown = () => {
+    server.close();
+    removeHubFile();
+    return runner.closeAll();
+  };
+  if (opts.signals !== false) {
+    const exit = () => void shutdown().finally(() => process.exit(0));
+    process.once("SIGINT", exit);
+    process.once("SIGTERM", exit);
+  }
+  return {
+    origin,
+    shutdown,
+    state,
+    /** shows a project's tab in the window (and a canvas, when given) */
+    focus(dir, canvas) {
+      active = dir;
+      used(dir);
+      focus = { path: dir, at: Date.now(), ...canvas ? { canvas } : {} };
+      broadcast();
+    },
+    /** live sessions: clients follow a project's open canvas live on its share link */
+    liveSession: {
+      available: true,
+      /** the project's running sessions (the active project by default) */
+      sessions: (dir = active) => dir ? sessionsOf(dir) : Promise.resolve([]),
+      /** stops the project's session if one runs, else starts one on the canvas open in its editor */
+      async toggle(dir = active, canvas) {
+        return sessionAction("toggle", dir, canvas);
+      }
+    }
+  };
+}
+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 || !fs5.existsSync(path5.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 = path5.join(dir, root, name);
+      if (fs5.existsSync(file) && fs5.statSync(file).size < 2e6) return file;
+    }
+  }
+  for (const root of ["app", "src/app"]) {
+    let entries = [];
+    try {
+      entries = fs5.readdirSync(path5.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 = path5.join(dir, root, e.name, name);
+        if (fs5.existsSync(file)) return file;
+      }
+    }
+  }
+  return null;
+}
+function json(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function inside(dir, file) {
+  const rel = path5.relative(dir, file);
+  return !!rel && !rel.startsWith("..") && !path5.isAbsolute(rel);
+}
+
+export {
+  readJson,
+  addDevArgs,
+  runScript,
+  execInherit,
+  packageDir,
+  packageVersion,
+  packageSpec,
+  installedIn,
+  readPackage,
+  depVersion,
+  connectAgents,
+  hasAgentConfig,
+  HUB_PORT,
+  hubPort,
+  startHub
+};