npm - @openthink/ui-leaf - Versions diffs - 0.4.0 → 0.6.0 - Mend

@openthink/ui-leaf 0.4.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/README.md +43 -19
package/package.json +14 -17
package/packages/cli/dist/cli.js +986 -0
package/packages/cli/dist/cli.js.map +1 -0
package/{dist → packages/cli/dist}/index.d.ts +88 -57
package/packages/cli/dist/index.js +721 -0
package/packages/cli/dist/index.js.map +1 -0
package/packages/cli/dist/server-3vbR-tuu.d.ts +7 -0
package/{dist → packages/cli/dist}/view.d.ts +1 -1
package/packages/cli/package.json +22 -0
package/dist/cli.js +0 -725
package/dist/cli.js.map +0 -1
package/dist/dev-server-DapOoULX.d.ts +0 -5
package/dist/index.js +0 -556
package/dist/index.js.map +0 -1
/package/{dist → packages/cli/dist}/cli.d.ts +0 -0
/package/{dist → packages/cli/dist}/view.js +0 -0
/package/{dist → packages/cli/dist}/view.js.map +0 -0

package/packages/cli/dist/cli.js ADDED Viewed

@@ -0,0 +1,986 @@
+#!/usr/bin/env node
+// src/cli.ts
+import { createInterface } from "readline";
+// src/index.ts
+import { resolve as resolve2 } from "path";
+// src/server.ts
+import { randomBytes, timingSafeEqual as nodeTimingSafeEqual } from "crypto";
+import open, { apps } from "open";
+// src/compile.ts
+import { createRequire } from "module";
+import { tmpdir } from "os";
+import { join, resolve, sep } from "path";
+import { mkdtemp, rm, stat, writeFile } from "fs/promises";
+// src/internal/html.ts
+function escapeForScriptTag(json) {
+  return json.replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+// src/compile.ts
+var requireFromHere = createRequire(import.meta.url);
+var reactAliasPlugin = {
+  name: "ui-leaf-react-alias",
+  setup(build) {
+    build.onResolve({ filter: /^react($|\/|-dom($|\/))/ }, (args2) => {
+      try {
+        return { path: requireFromHere.resolve(args2.path) };
+      } catch {
+        return {
+          path: args2.path,
+          errors: [{ text: `ui-leaf: failed to resolve ${args2.path}` }]
+        };
+      }
+    });
+  }
+};
+var SHARED_BRIDGE = `
+async function mutate(name: string, args?: unknown): Promise<unknown> {
+  const res = await fetch("/mutate", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(token ? { Authorization: "Bearer " + token } : {}),
+    },
+    body: JSON.stringify({ name, args }),
+  });
+  const text = await res.text().catch(() => "");
+  if (!res.ok) {
+    let detail = text;
+    try {
+      const parsed: unknown = text ? JSON.parse(text) : null;
+      if (parsed !== null && typeof parsed === "object" && "error" in parsed && typeof (parsed as { error: unknown }).error === "string") {
+        detail = (parsed as { error: string }).error;
+      }
+    } catch { /* keep raw text */ }
+    throw new Error("ui-leaf: mutation '" + name + "' failed (" + res.status + "): " + detail);
+  }
+  return text ? JSON.parse(text) : undefined;
+}
+async function heartbeat(): Promise<void> {
+  try {
+    await fetch("/heartbeat", {
+      method: "POST",
+      headers: token ? { Authorization: "Bearer " + token } : {},
+    });
+  } catch { /* server may have shut down; ignore */ }
+}
+setInterval(heartbeat, 5000);
+heartbeat();`;
+async function runBunBuild(entryPath) {
+  let buildOutput;
+  try {
+    buildOutput = await Bun.build({
+      entrypoints: [entryPath],
+      target: "browser",
+      format: "esm",
+      minify: false,
+      sourcemap: "none",
+      plugins: [reactAliasPlugin]
+    });
+  } catch (err) {
+    if (err instanceof AggregateError) {
+      const errors = err.errors.map((e) => ({
+        file: e.position?.file ?? "<unknown>",
+        line: e.position?.line ?? 0,
+        column: e.position?.column ?? 0,
+        message: e.message
+      }));
+      return { errors };
+    }
+    throw err;
+  }
+  const output = buildOutput.outputs[0];
+  if (!output) {
+    return {
+      errors: [{ file: "<unknown>", line: 0, column: 0, message: "ui-leaf: Bun.build produced no output" }]
+    };
+  }
+  return { js: await output.text() };
+}
+function assembleHtml(opts) {
+  const { js, title, csp, data, token, dataLoader } = opts;
+  const safeJs = js.replace(/<\/script>/gi, "<\\/script>");
+  const titleEscaped = title.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const cspMeta = csp ? `    <meta http-equiv="Content-Security-Policy" content="${csp.replace(/&/g, "&amp;").replace(/"/g, "&quot;")}" />
+` : "";
+  const safeToken = token ? escapeForScriptTag(JSON.stringify(token)) : null;
+  const tokenField = safeToken ? `, token: ${safeToken}` : "";
+  const bootstrapValue = dataLoader ? `{ token: ${safeToken ?? '""'} }` : `{ data: JSON.parse(${escapeForScriptTag(JSON.stringify(JSON.stringify(data ?? null)))})${tokenField} }`;
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>${titleEscaped}</title>
+${cspMeta}    <!-- ui-leaf bootstrap -->
+    <script>window.__UI_LEAF__ = ${bootstrapValue};</script>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module">${safeJs}</script>
+  </body>
+</html>`;
+}
+async function compileView(opts) {
+  const {
+    entry,
+    viewsRoot,
+    data,
+    title = "ui-leaf",
+    csp,
+    // allowedHosts has no compile-time effect; accepted for API symmetry.
+    allowedHosts: _allowedHosts,
+    token,
+    dataLoader = false
+  } = opts;
+  const viewsRootAbs = resolve(viewsRoot);
+  const hasExt = /\.[a-z]+$/i.test(entry);
+  const viewAbs = resolve(viewsRootAbs, hasExt ? entry : `${entry}.tsx`);
+  if (!viewAbs.startsWith(viewsRootAbs + sep)) {
+    return {
+      html: "",
+      errors: [
+        {
+          file: "<unknown>",
+          line: 0,
+          column: 0,
+          message: `ui-leaf: view '${entry}' resolves outside viewsRoot`
+        }
+      ]
+    };
+  }
+  try {
+    await stat(viewAbs);
+  } catch {
+    return {
+      html: "",
+      errors: [
+        {
+          file: viewAbs,
+          line: 0,
+          column: 0,
+          message: `ui-leaf: view '${entry}' not found at ${viewAbs}`
+        }
+      ]
+    };
+  }
+  const tempDir = await mkdtemp(join(tmpdir(), "ui-leaf-compile-"));
+  try {
+    const entryPath = join(tempDir, "entry.tsx");
+    const entryContent = dataLoader ? `import { createRoot } from "react-dom/client";
+import View from ${JSON.stringify(viewAbs)};
+const ctx = (globalThis as { __UI_LEAF__?: { token?: string } }).__UI_LEAF__ ?? {};
+const token = ctx.token;
+${SHARED_BRIDGE}
+async function bootstrap(): Promise<void> {
+  const res = await fetch("/api/data", {
+    headers: token ? { Authorization: "Bearer " + token } : {},
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error("ui-leaf: /api/data fetch failed (" + res.status + "): " + text);
+  }
+  const data = await res.json();
+  const el = document.getElementById("root");
+  if (!el) throw new Error("ui-leaf: #root element missing");
+  createRoot(el).render(<View data={data} mutate={mutate} />);
+}
+bootstrap();
+` : `import { createRoot } from "react-dom/client";
+import View from ${JSON.stringify(viewAbs)};
+const ctx = (globalThis as { __UI_LEAF__?: { data?: unknown; token?: string } }).__UI_LEAF__ ?? {};
+const data = ctx.data;
+const token = ctx.token;
+${SHARED_BRIDGE}
+const el = document.getElementById("root");
+if (!el) throw new Error("ui-leaf: #root element missing");
+createRoot(el).render(<View data={data} mutate={mutate} />);
+`;
+    await writeFile(entryPath, entryContent);
+    const buildResult = await runBunBuild(entryPath);
+    if ("errors" in buildResult) return { html: "", errors: buildResult.errors };
+    return {
+      html: assembleHtml({ js: buildResult.js, title, csp, data, token, dataLoader }),
+      errors: []
+    };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+async function compileSource(opts) {
+  const { source, data, title = "ui-leaf", csp, token } = opts;
+  const tempDir = await mkdtemp(join(tmpdir(), "ui-leaf-src-"));
+  try {
+    const viewPath = join(tempDir, "view.tsx");
+    const entryPath = join(tempDir, "entry.tsx");
+    await writeFile(viewPath, source);
+    const entryContent = `import { createRoot } from "react-dom/client";
+import View from ${JSON.stringify(viewPath)};
+const ctx = (globalThis as { __UI_LEAF__?: { data?: unknown; token?: string } }).__UI_LEAF__ ?? {};
+const data = ctx.data;
+const token = ctx.token;
+${SHARED_BRIDGE}
+const el = document.getElementById("root");
+if (!el) throw new Error("ui-leaf: #root element missing");
+createRoot(el).render(<View data={data} mutate={mutate} />);
+`;
+    await writeFile(entryPath, entryContent);
+    const buildResult = await runBunBuild(entryPath);
+    if ("errors" in buildResult) return { html: "", errors: buildResult.errors };
+    return {
+      html: assembleHtml({ js: buildResult.js, title, csp, data, token, dataLoader: false }),
+      errors: []
+    };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+// src/server.ts
+var ORIGINAL_STDOUT_WRITE = process.stdout.write.bind(process.stdout);
+var stdoutRedirectCount = 0;
+function redirectStdoutToStderr() {
+  stdoutRedirectCount++;
+  if (stdoutRedirectCount === 1) {
+    process.stdout.write = ((chunk, enc, cb) => process.stderr.write(chunk, enc, cb));
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    stdoutRedirectCount--;
+    if (stdoutRedirectCount === 0) {
+      process.stdout.write = ORIGINAL_STDOUT_WRITE;
+    }
+  };
+}
+async function openInAppMode(url) {
+  const candidates = [apps.chrome, apps.edge, apps.brave];
+  for (const app of candidates) {
+    try {
+      await open(url, { app: { name: app, arguments: [`--app=${url}`] } });
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+var STRICT_CSP = [
+  "default-src 'self'",
+  "connect-src 'self'",
+  "img-src 'self' data: https:",
+  "font-src 'self' https: data:",
+  "style-src 'self' 'unsafe-inline'",
+  "script-src 'self' 'unsafe-inline'"
+].join("; ");
+function resolveCsp(opt) {
+  if (!opt || opt === "off") return null;
+  if (opt === "strict") return STRICT_CSP;
+  return opt;
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  return nodeTimingSafeEqual(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+}
+var DEFAULT_LOOPBACK_HOSTNAMES = ["127.0.0.1", "localhost", "::1"];
+function parseHostHeader(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+  if (trimmed.startsWith("[")) {
+    const close = trimmed.indexOf("]");
+    if (close === -1) return null;
+    return trimmed.slice(1, close).toLowerCase();
+  }
+  const colon = trimmed.indexOf(":");
+  return (colon === -1 ? trimmed : trimmed.slice(0, colon)).toLowerCase();
+}
+function isAllowedHost(value, allowed) {
+  const host = value === void 0 ? null : parseHostHeader(value);
+  return host !== null && allowed.has(host);
+}
+function isAllowedOrigin(value, allowed) {
+  if (value === void 0 || value === "" || value === "null") return true;
+  try {
+    let hostname = new URL(value).hostname.toLowerCase();
+    if (hostname.startsWith("[") && hostname.endsWith("]")) {
+      hostname = hostname.slice(1, -1);
+    }
+    return allowed.has(hostname);
+  } catch {
+    return false;
+  }
+}
+async function startDevServer(opts) {
+  const {
+    view,
+    data,
+    dataLoader,
+    viewsRoot,
+    mutations = {},
+    title = "ui-leaf",
+    port,
+    openBrowser = true,
+    shell = "tab",
+    heartbeatTimeoutMs = 75e3,
+    startupGraceMs = 3e4,
+    csp,
+    allowedHosts,
+    silent = false,
+    _opener,
+    _heartbeatCheckIntervalMs = 1e3
+  } = opts;
+  const cspHeader = resolveCsp(csp);
+  const allowedHostSet = new Set(DEFAULT_LOOPBACK_HOSTNAMES);
+  for (const h of allowedHosts ?? []) allowedHostSet.add(h.toLowerCase());
+  const allowedHostList = [...allowedHostSet].join(", ");
+  const restoreStdout = silent ? redirectStdoutToStderr() : null;
+  try {
+    let fireEvent2 = function(event) {
+      for (const fn of listeners.get(event)) fn();
+    };
+    var fireEvent = fireEvent2;
+    if (view.includes("/") || view.includes("\\")) {
+      throw new Error(
+        `ui-leaf: view '${view}' must be a bare identifier with no path separators`
+      );
+    }
+    if (data !== void 0 && dataLoader) {
+      throw new Error("ui-leaf: pass data or dataLoader, not both");
+    }
+    const token = randomBytes(32).toString("hex");
+    let loadedData;
+    if (dataLoader) {
+      loadedData = await dataLoader();
+    }
+    const result = await compileView({
+      entry: view,
+      viewsRoot,
+      data: dataLoader ? null : data,
+      title,
+      csp: cspHeader ?? void 0,
+      token,
+      dataLoader: !!dataLoader
+    });
+    if (result.errors.length > 0) {
+      const msg = result.errors.map((e) => e.message).join("; ");
+      throw new Error(`ui-leaf: view compilation failed: ${msg}`);
+    }
+    const viewState = { html: result.html, data: dataLoader ? loadedData : data };
+    const listeners = /* @__PURE__ */ new Map([
+      ["data-updated", /* @__PURE__ */ new Set()],
+      ["view-swapped", /* @__PURE__ */ new Set()],
+      ["disconnected", /* @__PURE__ */ new Set()],
+      ["reconnected", /* @__PURE__ */ new Set()]
+    ]);
+    let lastHeartbeatAt = Date.now();
+    let closeRequested = false;
+    let connectionState = "connecting";
+    let resolveClosed = () => {
+    };
+    const closed = new Promise((r) => {
+      resolveClosed = r;
+    });
+    const bunPort = port === void 0 ? 5810 : port;
+    let actualPort = bunPort;
+    const handler = (req) => {
+      const host = req.headers.get("host") ?? void 0;
+      const origin = req.headers.get("origin") ?? void 0;
+      const hostOk = isAllowedHost(host, allowedHostSet);
+      const originOk = isAllowedOrigin(origin, allowedHostSet);
+      if (!hostOk || !originOk) {
+        const offender = !hostOk ? `Host "${host ?? "(absent)"}"` : `Origin "${origin}"`;
+        return new Response(
+          `ui-leaf: refusing request with ${offender} \u2014 only the following hostnames are accepted to prevent DNS rebinding: ${allowedHostList}. Open the server at http://localhost:${actualPort}/ or http://127.0.0.1:${actualPort}/, or pass { allowedHosts: ["my-alias"] } to mount() to permit a custom alias.
+`,
+          { status: 403, headers: { "Content-Type": "text/plain; charset=utf-8" } }
+        );
+      }
+      const headers = {};
+      if (cspHeader) {
+        headers["Content-Security-Policy"] = cspHeader;
+      }
+      const url2 = new URL(req.url);
+      const path = url2.pathname;
+      const method = req.method;
+      if (method === "GET" && path === "/") {
+        return new Response(viewState.html, {
+          status: 200,
+          headers: { ...headers, "Content-Type": "text/html; charset=utf-8" }
+        });
+      }
+      if (method === "POST" && path === "/heartbeat") {
+        if (!checkAuth(req, token)) {
+          return new Response(JSON.stringify({ error: "unauthorized" }), {
+            status: 401,
+            headers: { ...headers, "Content-Type": "application/json" }
+          });
+        }
+        lastHeartbeatAt = Date.now();
+        if (connectionState === "disconnected") {
+          connectionState = "connected";
+          fireEvent2("reconnected");
+        } else if (connectionState === "connecting") {
+          connectionState = "connected";
+        }
+        return new Response("", { status: 204, headers });
+      }
+      if (method === "POST" && path === "/mutate") {
+        if (!checkAuth(req, token)) {
+          return new Response(JSON.stringify({ error: "unauthorized" }), {
+            status: 401,
+            headers: { ...headers, "Content-Type": "application/json" }
+          });
+        }
+        return handleMutate(req, mutations, headers);
+      }
+      if (method === "GET" && path === "/api/data") {
+        if (!dataLoader) {
+          return new Response(JSON.stringify({ error: "not found" }), {
+            status: 404,
+            headers: { ...headers, "Content-Type": "application/json" }
+          });
+        }
+        if (!checkAuth(req, token)) {
+          return new Response(JSON.stringify({ error: "unauthorized" }), {
+            status: 401,
+            headers: { ...headers, "Content-Type": "application/json" }
+          });
+        }
+        return new Response(JSON.stringify(viewState.data !== void 0 ? viewState.data : null), {
+          status: 200,
+          headers: { ...headers, "Content-Type": "application/json" }
+        });
+      }
+      return new Response(JSON.stringify({ error: "not found" }), {
+        status: 404,
+        headers: { ...headers, "Content-Type": "application/json" }
+      });
+    };
+    let heartbeatWatcher;
+    let bunServer;
+    const cleanup = async (reason) => {
+      if (closeRequested) return;
+      closeRequested = true;
+      if (heartbeatWatcher) clearInterval(heartbeatWatcher);
+      await bunServer.stop(true);
+      if (restoreStdout) restoreStdout();
+      resolveClosed(reason);
+    };
+    const serverErrorHandler = (_err) => {
+      void cleanup("error");
+      return new Response(JSON.stringify({ error: "internal server error" }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    };
+    bunServer = (() => {
+      if (bunPort === 0) {
+        return Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: handler, error: serverErrorHandler });
+      }
+      const MAX_PORT_ATTEMPTS = 10;
+      for (let i = 0; i < MAX_PORT_ATTEMPTS; i++) {
+        try {
+          return Bun.serve({ hostname: "127.0.0.1", port: bunPort + i, fetch: handler, error: serverErrorHandler });
+        } catch (err) {
+          const isAddrinuse = err instanceof Error && err.message.includes("EADDRINUSE");
+          if (!isAddrinuse || i === MAX_PORT_ATTEMPTS - 1) {
+            if (isAddrinuse) {
+              throw new Error(
+                `ui-leaf: ports ${bunPort}\u2013${bunPort + MAX_PORT_ATTEMPTS - 1} are all in use. Pass { port: 0 } to mount() for an OS-assigned port.`
+              );
+            }
+            throw err;
+          }
+        }
+      }
+      throw new Error("unreachable");
+    })();
+    actualPort = bunServer.port ?? bunPort;
+    const url = `http://127.0.0.1:${actualPort}`;
+    const startedAt = Date.now();
+    heartbeatWatcher = setInterval(() => {
+      if (closeRequested) return;
+      const now = Date.now();
+      if (now - startedAt < startupGraceMs) return;
+      if (now - lastHeartbeatAt > heartbeatTimeoutMs) {
+        if (connectionState !== "disconnected") {
+          connectionState = "disconnected";
+          fireEvent2("disconnected");
+        }
+      }
+    }, _heartbeatCheckIntervalMs);
+    const doOpen = _opener ? () => _opener(url) : async () => {
+      if (shell === "app") {
+        const launched = await openInAppMode(url);
+        if (!launched) {
+          process.stderr.write(
+            `ui-leaf: shell:"app" requested but no Chromium browser found; falling back to default browser tab.
+`
+          );
+          await open(url);
+        }
+      } else {
+        await open(url);
+      }
+    };
+    if (openBrowser) {
+      await doOpen();
+    }
+    return {
+      url,
+      port: actualPort,
+      closed,
+      close: (reason = "caller") => cleanup(reason),
+      on(event, listener) {
+        listeners.get(event)?.add(listener);
+      },
+      off(event, listener) {
+        listeners.get(event)?.delete(listener);
+      },
+      update(newData) {
+        viewState.data = newData;
+        fireEvent2("data-updated");
+      },
+      async swapView(source) {
+        const r = await compileSource({
+          source,
+          data: viewState.data,
+          title,
+          csp: cspHeader ?? void 0,
+          token
+        });
+        if (r.errors.length > 0) return r.errors;
+        viewState.html = r.html;
+        fireEvent2("view-swapped");
+        return [];
+      },
+      async patch(newData, source) {
+        const r = await compileSource({
+          source,
+          data: newData,
+          title,
+          csp: cspHeader ?? void 0,
+          token
+        });
+        if (r.errors.length > 0) return r.errors;
+        viewState.data = newData;
+        viewState.html = r.html;
+        fireEvent2("data-updated");
+        fireEvent2("view-swapped");
+        return [];
+      },
+      async reopen() {
+        await doOpen();
+      }
+    };
+  } catch (err) {
+    restoreStdout?.();
+    throw err;
+  }
+}
+function checkAuth(req, token) {
+  const header = req.headers.get("authorization") ?? "";
+  const match = /^Bearer (.+)$/.exec(header);
+  if (!match) return false;
+  return timingSafeEqual(match[1], token);
+}
+async function handleMutate(req, mutations, headers) {
+  const contentLength = req.headers.get("content-length");
+  if (contentLength && Number.parseInt(contentLength, 10) > 1024 * 1024) {
+    return new Response(JSON.stringify({ error: "request body exceeds 1 MiB limit" }), {
+      status: 400,
+      headers: { ...headers, "Content-Type": "application/json" }
+    });
+  }
+  let body;
+  try {
+    const text = await req.text();
+    if (text.length > 1024 * 1024) {
+      return new Response(JSON.stringify({ error: "request body exceeds 1 MiB limit" }), {
+        status: 400,
+        headers: { ...headers, "Content-Type": "application/json" }
+      });
+    }
+    body = text ? JSON.parse(text) : void 0;
+  } catch (err) {
+    return new Response(
+      JSON.stringify({ error: err instanceof Error ? err.message : "bad request" }),
+      { status: 400, headers: { ...headers, "Content-Type": "application/json" } }
+    );
+  }
+  const name = body?.name;
+  if (typeof name !== "string" || name.length === 0) {
+    return new Response(JSON.stringify({ error: "missing mutation name" }), {
+      status: 400,
+      headers: { ...headers, "Content-Type": "application/json" }
+    });
+  }
+  if (!Object.hasOwn(mutations, name)) {
+    return new Response(
+      JSON.stringify({
+        error: `ui-leaf: no mutation handler registered for '${name}'. Add it to the mutations: { } map passed to mount().`
+      }),
+      { status: 404, headers: { ...headers, "Content-Type": "application/json" } }
+    );
+  }
+  const handler = mutations[name];
+  try {
+    const result = await handler(body.args);
+    return new Response(JSON.stringify(result ?? null), {
+      status: 200,
+      headers: { ...headers, "Content-Type": "application/json" }
+    });
+  } catch (err) {
+    return new Response(
+      JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
+      { status: 500, headers: { ...headers, "Content-Type": "application/json" } }
+    );
+  }
+}
+// src/index.ts
+async function mount(opts) {
+  const viewsRoot = opts.viewsRoot ?? resolve2(process.cwd(), "views");
+  const server = await startDevServer({
+    view: opts.view,
+    data: opts.data,
+    dataLoader: opts.dataLoader,
+    viewsRoot,
+    mutations: opts.mutations,
+    title: opts.title,
+    port: opts.port,
+    openBrowser: opts.openBrowser,
+    shell: opts.shell,
+    heartbeatTimeoutMs: opts.heartbeatTimeoutMs,
+    startupGraceMs: opts.startupGraceMs,
+    csp: opts.csp,
+    allowedHosts: opts.allowedHosts,
+    silent: opts.silent,
+    _heartbeatCheckIntervalMs: opts._heartbeatCheckIntervalMs
+  });
+  const onSignal = (signal) => {
+    void (async () => {
+      await server.close("signal");
+      process.kill(process.pid, signal);
+    })();
+  };
+  const sigint = () => onSignal("SIGINT");
+  const sigterm = () => onSignal("SIGTERM");
+  process.once("SIGINT", sigint);
+  process.once("SIGTERM", sigterm);
+  if (opts.signal) {
+    if (opts.signal.aborted) {
+      process.off("SIGINT", sigint);
+      process.off("SIGTERM", sigterm);
+      await server.close();
+      return {
+        url: server.url,
+        port: server.port,
+        closed: Promise.resolve("caller"),
+        close: () => server.close(),
+        update: server.update.bind(server),
+        swapView: (source) => server.swapView(source),
+        patch: (data, source) => server.patch(data, source),
+        reopen: server.reopen.bind(server),
+        on: server.on.bind(server),
+        off: server.off.bind(server)
+      };
+    }
+    opts.signal.addEventListener(
+      "abort",
+      () => void server.close(),
+      { once: true }
+    );
+  }
+  const closed = server.closed.finally(() => {
+    process.off("SIGINT", sigint);
+    process.off("SIGTERM", sigterm);
+  });
+  return {
+    url: server.url,
+    port: server.port,
+    closed,
+    close: () => server.close(),
+    update: server.update.bind(server),
+    swapView: (source) => server.swapView(source),
+    patch: (data, source) => server.patch(data, source),
+    reopen: server.reopen.bind(server),
+    on: server.on.bind(server),
+    off: server.off.bind(server)
+  };
+}
+// src/ipc.ts
+var PROTOCOL_VERSION = "1";
+function emit(event) {
+  const stamped = { version: PROTOCOL_VERSION, ...event };
+  return `${JSON.stringify(stamped)}
+`;
+}
+function parseInbound(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (err) {
+    return {
+      ok: false,
+      kind: "json",
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { ok: false, kind: "missing-version" };
+  }
+  if (!Object.hasOwn(parsed, "version")) {
+    return { ok: false, kind: "missing-version" };
+  }
+  const version = parsed.version;
+  if (version !== PROTOCOL_VERSION) {
+    return { ok: false, kind: "unsupported-version", got: version };
+  }
+  return { ok: true, msg: parsed };
+}
+// src/cli.ts
+var realStdoutWrite = process.stdout.write.bind(process.stdout);
+var args = process.argv.slice(2);
+if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+  process.stdout.write(
+    [
+      "ui-leaf \u2014 Customizable browser views, on demand, for any CLI.",
+      "",
+      "Usage:",
+      "  ui-leaf mount         Read a JSON config from stdin and mount a view.",
+      "                        See https://github.com/OpenThinkAi/ui-leaf for",
+      "                        the full stdio protocol spec.",
+      "",
+      "  ui-leaf --version     Print version.",
+      "  ui-leaf --help        Print this message.",
+      ""
+    ].join("\n")
+  );
+  process.exit(0);
+}
+if (args[0] === "--version" || args[0] === "-v") {
+  const { createRequire: createRequire2 } = await import("module");
+  const require2 = createRequire2(import.meta.url);
+  const pkg = require2("../package.json");
+  process.stdout.write(`${pkg.version}
+`);
+  process.exit(0);
+}
+if (args[0] !== "mount") {
+  process.stderr.write(`ui-leaf: unknown command "${args[0]}"
+`);
+  process.exit(1);
+}
+if (args[1] === "--help" || args[1] === "-h" || process.stdin.isTTY) {
+  process.stdout.write(
+    [
+      "ui-leaf mount \u2014 read a JSON config from stdin and mount a view.",
+      "",
+      "Protocol: line-delimited JSON over stdio.",
+      "  stdin  line 1 = config object",
+      "         lines 2+ = mutation responses {type:result|error,id,...}",
+      "  stdout {type:ready,url,port}, {type:mutate,id,name,args},",
+      "         {type:closed}, {type:error,message}",
+      "",
+      "Full spec: https://github.com/OpenThinkAi/ui-leaf#driving-ui-leaf-from-a-non-node-cli",
+      "",
+      "Example:",
+      `  echo '{"view":"spec","viewsRoot":"/abs/path","data":{}}' | ui-leaf mount`,
+      ""
+    ].join("\n")
+  );
+  process.exit(0);
+}
+try {
+  await runMount();
+} catch (err) {
+  emit2({
+    type: "error",
+    message: err instanceof Error ? err.message : String(err)
+  });
+  process.exit(1);
+}
+function emit2(event) {
+  realStdoutWrite(emit(event));
+}
+function stringifyVersion(got) {
+  if (typeof got === "string") return got;
+  return JSON.stringify(got);
+}
+async function runMount() {
+  const rl = createInterface({ input: process.stdin });
+  let nextId = 0;
+  const pending = /* @__PURE__ */ new Map();
+  let configReceived = false;
+  let configResolve;
+  let configReject;
+  const configPromise = new Promise((res, rej) => {
+    configResolve = res;
+    configReject = rej;
+  });
+  let mountedView = null;
+  let stdinClosed = false;
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    if (!configReceived) {
+      configReceived = true;
+      const outcome2 = parseInbound(trimmed);
+      if (!outcome2.ok) {
+        if (outcome2.kind === "json") {
+          emit2({
+            type: "error",
+            message: `failed to parse config JSON: ${outcome2.reason}`
+          });
+        } else if (outcome2.kind === "missing-version") {
+          emit2({ type: "error", message: "missing version field" });
+        } else {
+          emit2({
+            type: "error",
+            message: `unsupported protocol version: ${stringifyVersion(outcome2.got)}`
+          });
+        }
+        process.exit(1);
+      }
+      configResolve(outcome2.msg);
+      return;
+    }
+    const outcome = parseInbound(trimmed);
+    if (!outcome.ok) {
+      if (outcome.kind === "missing-version") {
+        emit2({ type: "error", message: "missing version field" });
+      } else if (outcome.kind === "unsupported-version") {
+        emit2({
+          type: "error",
+          message: `unsupported protocol version: ${stringifyVersion(outcome.got)}`
+        });
+      }
+      return;
+    }
+    const msg = outcome.msg;
+    if ("id" in msg && typeof msg.id === "number") {
+      const p = pending.get(msg.id);
+      if (!p) return;
+      pending.delete(msg.id);
+      if (msg.type === "result") p.resolve(msg.value);
+      else if (msg.type === "error") p.reject(new Error(msg.message));
+      return;
+    }
+    if (!mountedView) return;
+    if (msg.type === "update") {
+      mountedView.update(msg.data);
+      return;
+    }
+    if (msg.type === "view") {
+      void (async () => {
+        const errors = await mountedView.swapView(msg.source);
+        if (errors.length > 0) {
+          emit2({
+            type: "error",
+            phase: "build",
+            message: errors.map((e) => e.message).join("; ")
+          });
+        }
+      })();
+      return;
+    }
+    if (msg.type === "patch") {
+      void (async () => {
+        const errors = await mountedView.patch(msg.data, msg.view.source);
+        if (errors.length > 0) {
+          emit2({
+            type: "error",
+            phase: "build",
+            message: errors.map((e) => e.message).join("; ")
+          });
+        }
+      })();
+      return;
+    }
+    if (msg.type === "reopen") {
+      void mountedView.reopen().catch((err) => {
+        emit2({ type: "error", message: err instanceof Error ? err.message : String(err) });
+      });
+      return;
+    }
+    if (msg.type === "close") {
+      void mountedView.close();
+      return;
+    }
+    emit2({ type: "error", message: `unknown message type: ${msg.type}` });
+  });
+  rl.on("close", () => {
+    stdinClosed = true;
+    for (const { reject } of pending.values()) {
+      reject(new Error("ui-leaf: stdin closed by parent before mutation responded"));
+    }
+    pending.clear();
+    if (!configReceived) {
+      configReject(new Error("ui-leaf: stdin closed before config received"));
+      return;
+    }
+    if (mountedView) {
+      void mountedView.close();
+    }
+  });
+  const config = await configPromise;
+  const mutations = {};
+  for (const name of config.mutations ?? []) {
+    mutations[name] = (mutationArgs) => {
+      const id = ++nextId;
+      return new Promise((resolve3, reject) => {
+        pending.set(id, { resolve: resolve3, reject });
+        emit2({ type: "mutate", id, name, args: mutationArgs });
+      });
+    };
+  }
+  const mountOpts = {
+    view: config.view,
+    viewsRoot: config.viewsRoot,
+    data: config.data,
+    mutations,
+    title: config.title,
+    port: config.port,
+    openBrowser: config.openBrowser,
+    shell: config.shell,
+    csp: config.csp,
+    heartbeatTimeoutMs: config.heartbeatTimeoutMs,
+    startupGraceMs: config.startupGraceMs,
+    silent: true
+    // bridge owns stdout; bundler / dev-server output must stay silent
+  };
+  try {
+    const view = await mount(mountOpts);
+    mountedView = view;
+    if (stdinClosed) {
+      void view.close();
+    }
+    view.on("disconnected", () => emit2({ type: "disconnected" }));
+    view.on("reconnected", () => emit2({ type: "reconnected" }));
+    emit2({ type: "ready", url: view.url, port: view.port });
+    const closeReason = await view.closed;
+    emit2({ type: "closed", reason: closeReason });
+    process.exit(closeReason === "error" ? 1 : 0);
+  } catch (err) {
+    emit2({
+      type: "error",
+      message: err instanceof Error ? err.message : String(err)
+    });
+    process.exit(1);
+  }
+}
+//# sourceMappingURL=cli.js.map