@kitn.ai/cli 0.1.0

package/dist/assets/dev-C27Rnkul.js

@@ -0,0 +1,668 @@
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+import { connect } from "node:net";
+import { createServer } from "node:http";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, writeFileSync, watch, readdirSync, statSync, renameSync } from "node:fs";
+import { join, resolve, basename, dirname, extname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { n as npmInvocation, a as npmArgs, v as validateConstruct, g as generateProject, w as writeProject, b as generationNotices, i as inferTemplateId, t as templateById, c as buildableTemplates } from "../construct-cli.es.js";
+import "zod";
+function workDirFor(name, root) {
+  return join(root, ".kai", name);
+}
+function installKey(files) {
+  const pkg = files.find((f) => f.path === "package.json");
+  return createHash("sha256").update(pkg?.code ?? "").digest("hex");
+}
+function regenerate(raw, sink, dir, opts = {}) {
+  const validated = validateConstruct(raw);
+  if (!validated.ok) return validated;
+  const files = generateProject(validated.construct, opts);
+  sink.write(files, dir);
+  return { ok: true, files, construct: validated.construct };
+}
+function regenTurn(readRaw, sink, dir, opts, io) {
+  try {
+    const raw = readRaw();
+    const out = regenerate(raw, sink, dir, opts);
+    if (!out.ok) {
+      io.error("construct rejected — last good preview stays up:");
+      for (const p of out.problems) io.error(`  ${p.path || "(root)"}: ${p.message}`);
+      return;
+    }
+    io.log("construct changed — regenerated; Vite will hot-update the tab.");
+    for (const n of generationNotices(out.construct)) io.log(n);
+  } catch (err) {
+    io.error(`regen failed (${err instanceof Error ? err.message : String(err)}) — last good preview stays up`);
+  }
+}
+const KEY_FILE = ".kai-install-key";
+async function ensureInstalled(dir, files, io) {
+  const key = installKey(files);
+  const keyPath = join(dir, KEY_FILE);
+  const installed = existsSync(keyPath) && readFileSync(keyPath, "utf8") === key;
+  if (installed) return;
+  io.log(`installing dependencies in ${dir} (first run or deps changed)…`);
+  const npm = npmInvocation();
+  await new Promise((done, fail) => {
+    const child = spawn(npm.command, npmArgs(["install"], npm.shell), { cwd: dir, stdio: "inherit", shell: npm.shell });
+    child.on("exit", (code) => code === 0 ? done() : fail(new Error(`npm install exited ${code}`)));
+    child.on("error", (err) => fail(new Error(`npm install failed to start: ${err.message}`)));
+  });
+  writeFileSync(keyPath, key);
+}
+async function dev(constructPath, opts = {}) {
+  const io = opts.io ?? { log: (s) => console.log(s), error: (s) => console.error(s) };
+  const abs = resolve(constructPath);
+  const readRaw = () => JSON.parse(readFileSync(abs, "utf8"));
+  const first = validateConstruct(readRaw());
+  if (!first.ok) {
+    for (const p of first.problems) io.error(`  ${p.path || "(root)"}: ${p.message}`);
+    process.exit(1);
+  }
+  const dir = workDirFor(first.construct.name, process.cwd());
+  const files = generateProject(first.construct, { uiSpec: opts.uiSpec });
+  writeProject(files, dir);
+  for (const n of generationNotices(first.construct)) io.log(n);
+  await ensureInstalled(dir, files, io);
+  const base = basename(abs);
+  watch(dirname(abs), (_event, filename) => {
+    if (filename !== base) return;
+    regenTurn(readRaw, { write: writeProject }, dir, { uiSpec: opts.uiSpec }, io);
+  });
+  io.log(`previewing <${first.construct.name}> — edit ${abs} and watch the tab.`);
+  const npm = npmInvocation();
+  const vite = spawn(npm.command, npmArgs(["run", "dev"], npm.shell), { cwd: dir, stdio: "inherit", shell: npm.shell });
+  const killVite = () => vite.kill();
+  process.once("exit", killVite);
+  process.once("SIGINT", killVite);
+  process.once("SIGTERM", killVite);
+  return new Promise((_, rejectP) => {
+    vite.on("exit", (code) => {
+      rejectP(new Error(`vite dev exited ${code}`));
+      process.exit(code ?? 0);
+    });
+    vite.on("error", (err) => {
+      io.error(`vite dev failed to start: ${err.message}`);
+      rejectP(new Error(`vite dev failed to start: ${err.message}`));
+      process.exit(1);
+    });
+  });
+}
+function atomicWriteJson(abs, value) {
+  const tmp = `${abs}.tmp-${process.pid}`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`);
+  renameSync(tmp, abs);
+}
+function handleConstructPut(raw, abs) {
+  const out = validateConstruct(raw);
+  if (!out.ok) return out;
+  atomicWriteJson(abs, raw);
+  return { ok: true, construct: out.construct };
+}
+function shapeConstructGetResponse(onDisk) {
+  const checked = validateConstruct(onDisk);
+  return checked.ok ? onDisk : { ...onDisk, problems: checked.problems };
+}
+function createEventHub() {
+  const clients = /* @__PURE__ */ new Set();
+  return {
+    attach(res) {
+      res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        connection: "keep-alive"
+      });
+      res.write(": connected\n\n");
+      clients.add(res);
+      res.on("close", () => clients.delete(res));
+    },
+    broadcast(event, data) {
+      const frame = `event: ${event}
+data: ${JSON.stringify(data ?? {})}
+
+`;
+      for (const res of clients) res.write(frame);
+    }
+  };
+}
+function previewFields(preview) {
+  return {
+    previewUrl: preview.status === "ready" ? preview.url : void 0,
+    previewPending: preview.status === "starting",
+    previewError: preview.status === "error" ? preview.message : void 0
+  };
+}
+function starterFor(body) {
+  const template = buildableTemplates().find((t) => t.id === body.templateId);
+  return body.templateId === "scratch" || !template ? { name: body.name, layout: "fullscreen", provider: { mode: "mock" } } : {
+    ...template.variants?.find((v) => v.id === body.variantId)?.starter ?? template.starter,
+    name: body.name
+  };
+}
+function handleCreate(body, cwd) {
+  const starter = starterFor(body);
+  const validated = validateConstruct(starter);
+  if (!validated.ok) return { ok: false, problems: validated.problems };
+  const target = resolve(cwd, `${validated.construct.name}.construct.json`);
+  if (existsSync(target)) {
+    return {
+      ok: false,
+      problems: [{
+        path: "name",
+        message: `a construct named "${validated.construct.name}" already exists here (${basename(target)}) — open it from the home screen, or pick another name.`
+      }]
+    };
+  }
+  atomicWriteJson(target, starter);
+  return { ok: true, construct: starter, target };
+}
+async function waitUntilListening(probe, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 18e4;
+  const intervalMs = opts.intervalMs ?? 250;
+  const sleep = opts.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+  const now = opts.now ?? Date.now;
+  const started = now();
+  for (; ; ) {
+    const aborted = opts.abort?.();
+    if (aborted) return { ok: false, reason: aborted };
+    if (await probe()) return { ok: true };
+    if (now() - started >= timeoutMs) {
+      return { ok: false, reason: `the preview server did not start within ${Math.round(timeoutMs / 1e3)}s` };
+    }
+    await sleep(intervalMs);
+  }
+}
+function probeHost(port, host) {
+  return new Promise((done) => {
+    const socket = connect({ port, host });
+    let settled = false;
+    const finish = (ok) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      done(ok);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    socket.setTimeout(1e3, () => finish(false));
+  });
+}
+function probePort(port, hosts = ["127.0.0.1", "::1"]) {
+  return Promise.all(hosts.map((host) => probeHost(port, host))).then((answers) => answers.some(Boolean));
+}
+async function announceBoot(boot, hub, io) {
+  try {
+    const url = await boot();
+    hub.broadcast("preview", { previewUrl: url });
+    return { status: "ready", url };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    io.error(`preview failed to start — ${message}`);
+    hub.broadcast("preview-error", { message });
+    return { status: "error", message };
+  }
+}
+function listenLoopbackOnly(server, port, onListening) {
+  server.listen(port, "127.0.0.1", onListening);
+}
+function portInUseNotice(taken, next) {
+  return `port ${taken} is already in use — another \`kai dev --builder\` is probably still running (\`lsof -nP -iTCP:${taken} -sTCP:LISTEN\` names it). Trying ${next} instead.`;
+}
+function portsExhaustedMessage(from, to) {
+  return `every port from ${from} to ${to} is in use. Stop the other \`kai dev --builder\` (\`lsof -nP -iTCP:${from} -sTCP:LISTEN\` names it) and try again.`;
+}
+async function listenWithPortFallback(server, startPort, io, opts = {}) {
+  const attempts = Math.max(1, opts.attempts ?? 10);
+  const isTaken = opts.isTaken ?? ((p) => probePort(p));
+  let port = startPort;
+  for (let tried = 1; ; tried++) {
+    let busy = port !== 0 && await isTaken(port);
+    if (!busy) busy = await tryListenLoopback(server, port) === "taken";
+    if (!busy) {
+      const addr = server.address();
+      return typeof addr === "object" && addr !== null ? addr.port : port;
+    }
+    if (tried >= attempts) throw new Error(portsExhaustedMessage(startPort, port));
+    io.error(portInUseNotice(port, port + 1));
+    port += 1;
+  }
+}
+function tryListenLoopback(server, port) {
+  return new Promise((done, fail) => {
+    let settled = false;
+    const cleanup = () => {
+      server.off("error", onError);
+      server.off("listening", onListening);
+    };
+    const onListening = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      done("ok");
+    };
+    const onError = (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (err.code === "EADDRINUSE") done("taken");
+      else fail(err);
+    };
+    server.on("error", onError);
+    server.on("listening", onListening);
+    listenLoopbackOnly(server, port, () => {
+    });
+  });
+}
+const ASSET_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".map": "application/json",
+  ".json": "application/json"
+};
+function serveBuilderAsset(urlPath, rootDir) {
+  const decoded = decodeURIComponent(urlPath.split("?")[0]);
+  const rel = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
+  const file = resolve(rootDir, rel);
+  if (!file.startsWith(resolve(rootDir) + "/") && file !== resolve(rootDir, "index.html")) return void 0;
+  if (!existsSync(file)) return void 0;
+  return { file, type: ASSET_TYPES[extname(file)] ?? "application/octet-stream" };
+}
+function resolveBuilderPageDir(startDir, dirName = "builder-page") {
+  const tried = [];
+  let dir = startDir;
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, dirName);
+    tried.push(candidate);
+    if (existsSync(join(candidate, "index.html"))) return { dir: candidate };
+    const atPackageRoot = existsSync(join(dir, "package.json"));
+    const parent = dirname(dir);
+    if (atPackageRoot || parent === dir) break;
+    dir = parent;
+  }
+  return { tried };
+}
+function builderPageDir() {
+  const out = resolveBuilderPageDir(dirname(fileURLToPath(import.meta.url)));
+  if ("dir" in out) return out.dir;
+  throw new Error(
+    `Missing build artifact: builder-page/index.html — the builder page ships prebuilt. Tried:
+${out.tried.map((p) => `  ${p}`).join("\n")}
+Run \`nx build cli\` (or npm run build in packages/cli) and try again.`
+  );
+}
+function themeStudioDir() {
+  const out = resolveBuilderPageDir(dirname(fileURLToPath(import.meta.url)), "theme-studio");
+  return "dir" in out ? out.dir : void 0;
+}
+function kitDistRoot() {
+  return join(dirname(createRequire(import.meta.url).resolve("@kitn.ai/ui/package.json")), "dist");
+}
+function themeStudioAsset(sub, studioDir, kitRoot = kitDistRoot()) {
+  if (sub.startsWith("/kit/")) {
+    if (!existsSync(kitRoot)) {
+      return {
+        kind: "problem",
+        status: 500,
+        message: `The kit's built assets are missing: ${kitRoot} does not exist (resolved from @kitn.ai/ui/package.json). Run \`npm run build\` in packages/ui (or \`nx build ui\`) and reload.`
+      };
+    }
+    const hit2 = serveBuilderAsset(sub.slice("/kit".length), kitRoot);
+    if (!hit2) return { kind: "problem", status: 404, message: "not found" };
+    return { kind: "file", file: hit2.file, type: hit2.type };
+  }
+  const hit = serveBuilderAsset(sub, studioDir);
+  if (!hit) return { kind: "problem", status: 404, message: "not found" };
+  return { kind: "file", file: hit.file, type: hit.type };
+}
+function listConstructs(cwd) {
+  let entries;
+  try {
+    entries = readdirSync(cwd);
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const file of entries) {
+    if (!file.endsWith(".construct.json")) continue;
+    const abs = join(cwd, file);
+    let updatedAt = (/* @__PURE__ */ new Date(0)).toISOString();
+    try {
+      updatedAt = statSync(abs).mtime.toISOString();
+    } catch {
+      continue;
+    }
+    const fallbackName = file.slice(0, -".construct.json".length);
+    try {
+      const checked = validateConstruct(JSON.parse(readFileSync(abs, "utf8")));
+      if (checked.ok) {
+        const templateId = inferTemplateId(checked.construct);
+        rows.push({
+          file,
+          name: checked.construct.name,
+          templateId,
+          templateName: templateId ? templateById(templateId)?.name : void 0,
+          updatedAt,
+          valid: true
+        });
+        continue;
+      }
+    } catch {
+    }
+    rows.push({ file, name: fallbackName, updatedAt, valid: false });
+  }
+  return rows.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0);
+}
+function resolveConstructArg(arg, cwd) {
+  const asPath = resolve(cwd, arg);
+  if (existsSync(asPath)) return { ok: true, abs: asPath };
+  if (!arg.includes("/") && !arg.endsWith(".json")) {
+    const asName = resolve(cwd, `${arg}.construct.json`);
+    if (existsSync(asName)) return { ok: true, abs: asName };
+  }
+  const names = listConstructs(cwd).map((c) => c.file.slice(0, -".construct.json".length));
+  const inventory = names.length > 0 ? `this directory has: ${names.join(", ")}` : `no *.construct.json files exist in ${cwd}`;
+  return {
+    ok: false,
+    message: `no construct named "${arg}" — ${inventory}. Run \`kai dev --builder\` with no argument to pick from a list, or pass a path to a .construct.json file.`
+  };
+}
+function handleOpen(body, cwd) {
+  const file = body.file;
+  if (typeof file !== "string" || file !== basename(file) || !file.endsWith(".construct.json")) {
+    return {
+      ok: false,
+      status: 422,
+      problems: [{ path: "file", message: "file must be the basename of a *.construct.json in the project directory" }]
+    };
+  }
+  const abs = resolve(cwd, file);
+  if (!existsSync(abs)) {
+    return {
+      ok: false,
+      status: 404,
+      problems: [{ path: "file", message: `no construct file "${file}" here — the list may be stale; reload the page.` }]
+    };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(abs, "utf8"));
+  } catch (err) {
+    return {
+      ok: false,
+      status: 422,
+      problems: [{ path: "file", message: `${file} is not valid JSON: ${err instanceof Error ? err.message : String(err)}` }]
+    };
+  }
+  const checked = validateConstruct(raw);
+  if (!checked.ok) return { ok: false, status: 422, problems: checked.problems };
+  return { ok: true, abs, construct: raw };
+}
+function crossOriginProblem(headers) {
+  const origin = headers.origin;
+  if (origin === void 0) return void 0;
+  if (headers.host !== void 0 && origin === `http://${headers.host}`) return void 0;
+  return `cross-origin request rejected (origin: ${origin}) — the builder API only accepts requests from its own page`;
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > 1e6) throw new Error("body too large");
+    chunks.push(chunk);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+async function devBuilder(constructPath, opts = {}) {
+  const io = opts.io ?? { log: (s) => console.log(s), error: (s) => console.error(s) };
+  const port = opts.port ?? 4400;
+  let previewPort = opts.previewPort ?? port + 1;
+  let pageDir;
+  try {
+    pageDir = builderPageDir();
+  } catch (err) {
+    io.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const hub = createEventHub();
+  let abs;
+  if (constructPath) {
+    const resolved = resolveConstructArg(constructPath, process.cwd());
+    if (!resolved.ok) {
+      io.error(resolved.message);
+      process.exit(1);
+    }
+    abs = resolved.abs;
+  }
+  let preview = { status: "idle" };
+  let activeVite;
+  let activeWatcher;
+  const killActiveVite = () => {
+    activeVite?.kill();
+  };
+  process.once("exit", killActiveVite);
+  process.once("SIGINT", killActiveVite);
+  process.once("SIGTERM", killActiveVite);
+  let bootGeneration = 0;
+  const boot = async (absPath, gen) => {
+    const superseded = () => gen !== bootGeneration;
+    activeWatcher?.close();
+    activeWatcher = void 0;
+    if (activeVite) {
+      const previous = activeVite;
+      activeVite = void 0;
+      previous.kill();
+      const freed = await waitUntilListening(async () => !await probePort(previewPort), { timeoutMs: 15e3 });
+      if (!freed.ok) {
+        throw new Error(`the previous preview server did not release port ${previewPort} — stop it and reopen`);
+      }
+    }
+    if (superseded()) throw new Error("superseded by a newer open");
+    const readRaw = () => JSON.parse(readFileSync(absPath, "utf8"));
+    const initialText = readFileSync(absPath, "utf8");
+    const first = validateConstruct(JSON.parse(initialText));
+    if (!first.ok) {
+      for (const p of first.problems) io.error(`  ${p.path || "(root)"}: ${p.message}`);
+      throw new Error("construct invalid");
+    }
+    const dir = workDirFor(first.construct.name, process.cwd());
+    const files = generateProject(first.construct, { uiSpec: opts.uiSpec });
+    writeProject(files, dir);
+    await ensureInstalled(dir, files, io);
+    if (superseded()) throw new Error("superseded by a newer open");
+    const base = basename(absPath);
+    activeWatcher = watch(dirname(absPath), (_event, filename) => {
+      if (filename !== base) return;
+      regenTurn(readRaw, { write: writeProject }, dir, { uiSpec: opts.uiSpec }, io);
+      hub.broadcast("construct");
+    });
+    if (readFileSync(absPath, "utf8") !== initialText) {
+      regenTurn(readRaw, { write: writeProject }, dir, { uiSpec: opts.uiSpec }, io);
+    }
+    const npm = npmInvocation();
+    const vite = spawn(npm.command, npmArgs(["run", "dev", "--", "--port", String(previewPort), "--strictPort"], npm.shell), {
+      cwd: dir,
+      stdio: "inherit",
+      shell: npm.shell
+    });
+    activeVite = vite;
+    let viteDied;
+    vite.on("exit", (code) => {
+      viteDied ??= `the preview server exited with code ${code} before it started listening`;
+    });
+    vite.on("error", (err) => {
+      viteDied ??= `the preview server failed to start: ${err.message}`;
+    });
+    const listening = await waitUntilListening(() => probePort(previewPort), { abort: () => viteDied });
+    if (!listening.ok) throw new Error(listening.reason);
+    const url = `http://localhost:${previewPort}/`;
+    io.log(`previewing <${first.construct.name}> at ${url}`);
+    return url;
+  };
+  const bootInBackground = (absPath) => {
+    const gen = ++bootGeneration;
+    preview = { status: "starting" };
+    const gatedHub = {
+      broadcast: (event, data) => {
+        if (gen === bootGeneration) hub.broadcast(event, data);
+      }
+    };
+    void announceBoot(() => boot(absPath, gen), gatedHub, io).then((next) => {
+      if (gen === bootGeneration) preview = next;
+    });
+  };
+  if (abs) {
+    try {
+      const initial = validateConstruct(JSON.parse(readFileSync(abs, "utf8")));
+      if (!initial.ok) {
+        for (const p of initial.problems) io.error(`  ${p.path || "(root)"}: ${p.message}`);
+        process.exit(1);
+      }
+    } catch (err) {
+      io.error(`cannot read ${abs}: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  }
+  const server = createServer(async (req, res) => {
+    const send = (code, body) => {
+      res.writeHead(code, { "content-type": "application/json" });
+      res.end(JSON.stringify(body));
+    };
+    try {
+      const url = req.url ?? "/";
+      if (req.method !== "GET") {
+        const rejected = crossOriginProblem({ origin: req.headers.origin, host: req.headers.host });
+        if (rejected) return send(403, { problems: [{ path: "", message: rejected }] });
+      }
+      if (req.method === "GET" && url === "/api/state") {
+        if (abs) {
+          return send(200, {
+            phase: "panel",
+            constructPath: abs,
+            construct: JSON.parse(readFileSync(abs, "utf8")),
+            ...previewFields(preview)
+          });
+        }
+        const constructs = listConstructs(process.cwd());
+        return send(200, { phase: constructs.length > 0 ? "home" : "start", constructs });
+      }
+      if (req.method === "GET" && url === "/api/constructs") {
+        return send(200, { constructs: listConstructs(process.cwd()) });
+      }
+      if (req.method === "GET" && url === "/api/construct") {
+        if (!abs) return send(404, { problems: [{ path: "", message: "no construct yet" }] });
+        return send(200, shapeConstructGetResponse(JSON.parse(readFileSync(abs, "utf8"))));
+      }
+      if (req.method === "GET" && url === "/api/events") return hub.attach(res);
+      if (req.method === "POST" && url === "/api/construct") {
+        if (!abs) return send(409, { problems: [{ path: "", message: "create a construct first" }] });
+        const out = handleConstructPut(await readJsonBody(req), abs);
+        return out.ok ? send(200, { ok: true }) : send(422, { problems: out.problems });
+      }
+      if (req.method === "POST" && url === "/api/open") {
+        const out = handleOpen(await readJsonBody(req), process.cwd());
+        if (!out.ok) return send(out.status, { problems: out.problems });
+        if (abs === out.abs && (preview.status === "ready" || preview.status === "starting")) {
+          return send(200, { construct: out.construct, constructPath: abs, ...previewFields(preview) });
+        }
+        abs = out.abs;
+        preview = { status: "starting" };
+        send(200, { construct: out.construct, constructPath: abs, ...previewFields(preview) });
+        bootInBackground(out.abs);
+        return;
+      }
+      if (req.method === "POST" && url === "/api/create") {
+        const out = handleCreate(await readJsonBody(req), process.cwd());
+        if (!out.ok) return send(422, { problems: out.problems });
+        abs = out.target;
+        preview = { status: "starting" };
+        send(200, { construct: out.construct, ...previewFields(preview) });
+        bootInBackground(out.target);
+        return;
+      }
+      if (req.method === "GET" && (url === "/theme-studio" || url.startsWith("/theme-studio?"))) {
+        const q = url.indexOf("?");
+        res.writeHead(302, { location: `/theme-studio/${q === -1 ? "" : url.slice(q)}` });
+        return res.end();
+      }
+      if (req.method === "GET" && url.startsWith("/theme-studio/")) {
+        const studioDir = themeStudioDir();
+        if (!studioDir) {
+          return send(404, {
+            problems: [{ path: "", message: "dist/theme-studio is missing — run `npm run build` in packages/cli (or nx build cli) and reload." }]
+          });
+        }
+        const sub = url.slice("/theme-studio".length);
+        const studioAsset = themeStudioAsset(sub, studioDir);
+        if (studioAsset.kind === "problem") {
+          return send(studioAsset.status, { problems: [{ path: "", message: studioAsset.message }] });
+        }
+        res.writeHead(200, { "content-type": studioAsset.type });
+        return res.end(readFileSync(studioAsset.file));
+      }
+      const asset = serveBuilderAsset(url, pageDir);
+      if (asset) {
+        res.writeHead(200, { "content-type": asset.type });
+        return res.end(readFileSync(asset.file));
+      }
+      if (req.method === "GET") {
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        return res.end(readFileSync(join(pageDir, "index.html")));
+      }
+      return send(404, { problems: [{ path: "", message: "not found" }] });
+    } catch (err) {
+      return send(400, { problems: [{ path: "", message: err instanceof Error ? err.message : String(err) }] });
+    }
+  });
+  let bound;
+  try {
+    bound = await listenWithPortFallback(server, port, io);
+  } catch (err) {
+    io.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  if (opts.previewPort === void 0) previewPort = bound + 1;
+  io.log(`kai builder at http://localhost:${bound}/ — the construct file stays yours.`);
+  if (abs) bootInBackground(abs);
+  return new Promise(() => {
+  });
+}
+export {
+  announceBoot,
+  atomicWriteJson,
+  builderPageDir,
+  createEventHub,
+  crossOriginProblem,
+  dev,
+  devBuilder,
+  ensureInstalled,
+  handleConstructPut,
+  handleCreate,
+  handleOpen,
+  installKey,
+  kitDistRoot,
+  listConstructs,
+  listenLoopbackOnly,
+  listenWithPortFallback,
+  portInUseNotice,
+  portsExhaustedMessage,
+  previewFields,
+  probeHost,
+  probePort,
+  regenTurn,
+  regenerate,
+  resolveBuilderPageDir,
+  resolveConstructArg,
+  serveBuilderAsset,
+  shapeConstructGetResponse,
+  starterFor,
+  themeStudioAsset,
+  themeStudioDir,
+  waitUntilListening,
+  workDirFor
+};