lakebed 0.0.1

package/src/cli.js

@@ -0,0 +1,1066 @@
+#!/usr/bin/env node
+import { createServer } from "node:http";
+import { existsSync, realpathSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import * as esbuild from "esbuild";
+import { WebSocketServer } from "ws";
+import {
+  ANONYMOUS_ARTIFACT_MEDIA_TYPE,
+  AnonymousCompilerError,
+  createAnonymousArtifact,
+  parseTtlSeconds,
+  stableStringify
+} from "./anonymous.js";
+import { startAnonymousServer } from "./anonymous-server.js";
+import { LogBuffer, StateCell } from "./runtime.js";
+import { createMemorySourceStoreFromDirectory, sourcePathDirname, sourcePathJoin } from "./source-store.js";
+
+const root = process.cwd();
+const packageDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const packageNodeModules = resolve(packageDir, "node_modules");
+const sourceNamespace = "lakebed-source";
+
+function usage() {
+  console.log(`lakebed
+
+Usage:
+  lakebed new <name> [--template todo]
+  lakebed dev <capsule-dir> [--port 3000]
+  lakebed build <capsule-dir> --target anonymous [--out .lakebed/artifacts/app.json] [--json]
+  lakebed deploy <capsule-dir> [--ttl 7d] [--api <url>] [--json]
+  lakebed anonymous-server [--port 8787] [--public-root-url <url>]
+  lakebed inspect <deploy-id-or-url> [--api <url>] [--json]
+  lakebed run-many <capsule-dir> [--count 20] [--base-port 4000]
+  lakebed auth as <name>
+  lakebed auth reset
+  lakebed db list [deploy-id-or-url] [--port 3000]
+  lakebed db dump [deploy-id-or-url] [--port 3000]
+  lakebed logs [deploy-id-or-url] [--port 3000]
+`);
+}
+
+function readArg(args, name, fallback) {
+  const index = args.indexOf(name);
+  if (index === -1) {
+    return fallback;
+  }
+
+  return args[index + 1] ?? fallback;
+}
+
+function positionals(args) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (value.startsWith("--")) {
+      index += 1;
+      continue;
+    }
+
+    values.push(value);
+  }
+
+  return values;
+}
+
+function readNumberArg(args, name, fallback) {
+  const value = Number(readArg(args, name, String(fallback)));
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer.`);
+  }
+
+  return value;
+}
+
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+function resolveCapsuleDir(value) {
+  if (!value) {
+    return resolve(root, "examples/todo");
+  }
+
+  return isAbsolute(value) ? value : resolve(root, value);
+}
+
+function authFile() {
+  return resolve(root, ".lakebed/auth.json");
+}
+
+function toGuestName(name) {
+  return String(name ?? "local")
+    .replace(/^guest:/, "")
+    .trim()
+    .replace(/[^a-zA-Z0-9_.-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase() || "local";
+}
+
+function toDisplayName(name) {
+  return toGuestName(name)
+    .split(/[-_\s.]+/)
+    .filter(Boolean)
+    .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+    .join(" ");
+}
+
+function createGuestAuth(name) {
+  const guestName = toGuestName(name);
+  return {
+    userId: `guest:${guestName}`,
+    displayName: toDisplayName(guestName)
+  };
+}
+
+async function readAuth() {
+  try {
+    return JSON.parse(await readFile(authFile(), "utf8"));
+  } catch {
+    return createGuestAuth("local");
+  }
+}
+
+async function writeAuth(auth) {
+  await mkdir(dirname(authFile()), { recursive: true });
+  await writeFile(authFile(), `${JSON.stringify(auth, null, 2)}\n`);
+}
+
+function authFromUrl(url, defaultAuth) {
+  const guestName = url.searchParams.get("lakebed_guest") ?? url.searchParams.get("guest");
+  return guestName ? createGuestAuth(guestName) : defaultAuth;
+}
+
+function isBareSpecifier(path) {
+  return !path.startsWith(".") && !path.startsWith("/") && !/^[a-zA-Z]:/.test(path);
+}
+
+async function resolveSourceFile(sourceStore, requestedPath) {
+  const normalized = sourcePathJoin(requestedPath);
+  const candidates = [
+    normalized,
+    `${normalized}.ts`,
+    `${normalized}.tsx`,
+    `${normalized}.js`,
+    `${normalized}.jsx`,
+    `${normalized}.json`,
+    sourcePathJoin(normalized, "index.ts"),
+    sourcePathJoin(normalized, "index.tsx"),
+    sourcePathJoin(normalized, "index.js"),
+    sourcePathJoin(normalized, "index.jsx")
+  ];
+
+  for (const candidate of candidates) {
+    if (sourceStore.hasFile(candidate)) {
+      return candidate;
+    }
+  }
+
+  throw new Error(`Unable to resolve source import: ${requestedPath}`);
+}
+
+function loaderForPath(path) {
+  if (path.endsWith(".tsx")) {
+    return "tsx";
+  }
+  if (path.endsWith(".ts")) {
+    return "ts";
+  }
+  if (path.endsWith(".jsx")) {
+    return "jsx";
+  }
+  if (path.endsWith(".json")) {
+    return "json";
+  }
+  return "js";
+}
+
+function createSourcePlugin(sourceStore, target) {
+  const allowedBare = new Set(
+    target === "server"
+      ? ["lakebed/server"]
+      : ["lakebed/client", "preact", "preact/hooks", "preact/jsx-runtime", "preact/jsx-dev-runtime"]
+  );
+
+  return {
+    name: "lakebed-source-store",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, async (args) => {
+        if (args.kind === "entry-point") {
+          return {
+            path: await resolveSourceFile(sourceStore, args.path),
+            namespace: sourceNamespace
+          };
+        }
+
+        if (args.namespace !== sourceNamespace) {
+          return;
+        }
+
+        if (args.path.startsWith("node:")) {
+          return {
+            errors: [{ text: `Node built-ins are not available inside Lakebed ${target} modules: ${args.path}` }]
+          };
+        }
+
+        if (isBareSpecifier(args.path)) {
+          if (allowedBare.has(args.path) || (target === "client" && args.path.startsWith("preact/"))) {
+            if (target === "server" && args.path === "lakebed/server") {
+              return { path: join(packageDir, "src/server.js") };
+            }
+
+            if (target === "server") {
+              return { path: args.path, external: true };
+            }
+
+            return build.resolve(args.path, {
+              kind: args.kind,
+              resolveDir: packageDir
+            });
+          }
+
+          return {
+            errors: [
+              {
+                text: `External packages are not supported in Lakebed v0: ${args.path}. Use relative files or Lakebed built-ins.`
+              }
+            ]
+          };
+        }
+
+        const basePath = args.path.startsWith("/") ? "" : sourcePathDirname(args.importer);
+        return {
+          path: await resolveSourceFile(sourceStore, sourcePathJoin(basePath, args.path)),
+          namespace: sourceNamespace
+        };
+      });
+
+      build.onLoad({ filter: /.*/, namespace: sourceNamespace }, async (args) => ({
+        contents: await sourceStore.readFile(args.path),
+        loader: loaderForPath(args.path),
+        resolveDir: sourcePathDirname(args.path)
+      }));
+    }
+  };
+}
+
+async function readServerEnv(sourceStore) {
+  const env = { ...process.env };
+  if (!sourceStore.hasFile(".env.lakebed.server")) {
+    return env;
+  }
+
+  const contents = await sourceStore.readFile(".env.lakebed.server");
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) {
+      continue;
+    }
+
+    const [, key, rawValue] = match;
+    env[key] = rawValue.replace(/^['"]|['"]$/g, "");
+  }
+
+  return env;
+}
+
+export async function buildCapsule({ capsuleDir, sourceStore, capsuleId = "dev" } = {}) {
+  const resolvedCapsuleDir = resolveCapsuleDir(capsuleDir);
+  const originalStore = sourceStore ?? (await createMemorySourceStoreFromDirectory(resolvedCapsuleDir));
+  const workingStore = originalStore.clone();
+  const buildDir = resolve(root, ".lakebed/build", capsuleId);
+
+  await rm(buildDir, { recursive: true, force: true });
+  await mkdir(buildDir, { recursive: true });
+
+  if (!workingStore.hasFile("server/index.ts")) {
+    throw new Error("Missing capsule entry: server/index.ts");
+  }
+
+  if (!workingStore.hasFile("client/index.tsx")) {
+    throw new Error("Missing client entry: client/index.tsx");
+  }
+
+  const serverOut = join(buildDir, "server.mjs");
+  const clientOut = join(buildDir, "client.js");
+
+  await workingStore.writeFile(
+    "__lakebed/client-entry.tsx",
+    `import { h, render } from "preact";\nimport { App } from "../client/index.tsx";\n\nrender(h(App, {}), document.getElementById("app"));\n`
+  );
+
+  await esbuild.build({
+    entryPoints: ["server/index.ts"],
+    outfile: serverOut,
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    sourcemap: "inline",
+    jsx: "automatic",
+    jsxImportSource: "preact",
+    plugins: [createSourcePlugin(workingStore, "server")]
+  });
+
+  await esbuild.build({
+    entryPoints: ["__lakebed/client-entry.tsx"],
+    outfile: clientOut,
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    sourcemap: "inline",
+    jsx: "automatic",
+    jsxImportSource: "preact",
+    nodePaths: [packageNodeModules],
+    plugins: [createSourcePlugin(workingStore, "client")]
+  });
+
+  const capsuleModule = await import(`${pathToFileURL(serverOut).href}?t=${Date.now()}-${Math.random()}`);
+  return {
+    app: capsuleModule.default,
+    buildDir,
+    clientOut,
+    env: await readServerEnv(workingStore),
+    sourceStore: workingStore
+  };
+}
+
+function html(title) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${title}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/client.js"></script>
+    <script>
+      const tailwind = document.createElement("script");
+      tailwind.src = "https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4";
+      tailwind.async = true;
+      document.head.appendChild(tailwind);
+    </script>
+  </body>
+</html>`;
+}
+
+function sendJson(ws, message) {
+  ws.send(JSON.stringify(message));
+}
+
+function createContext({ stateCell, auth, logs, env }) {
+  return {
+    auth,
+    db: stateCell.createDb(),
+    env,
+    log: logs.createLogger()
+  };
+}
+
+async function runQuery({ app, stateCell, auth, logs, env, name }) {
+  const handler = app.queries?.[name];
+  if (!handler) {
+    throw new Error(`Unknown query: ${name}`);
+  }
+
+  return handler(createContext({ stateCell, auth, logs, env }));
+}
+
+async function runMutation({ app, stateCell, auth, logs, env, name, args }) {
+  const handler = app.mutations?.[name];
+  if (!handler) {
+    throw new Error(`Unknown mutation: ${name}`);
+  }
+
+  return stateCell.transaction((db) =>
+    handler(
+      {
+        auth,
+        db,
+        env,
+        log: logs.createLogger()
+      },
+      ...args
+    )
+  );
+}
+
+export async function startDevServer({ capsuleDir, sourceStore, port = 3000, capsuleId = "dev", quiet = false } = {}) {
+  const resolvedCapsuleDir = resolveCapsuleDir(capsuleDir);
+  const built = await buildCapsule({ capsuleDir: resolvedCapsuleDir, sourceStore, capsuleId });
+  const defaultAuth = await readAuth();
+  const stateCell = new StateCell(built.app.schema);
+  const logs = new LogBuffer();
+  const subscriptions = new Map();
+
+  const server = createServer(async (req, res) => {
+    try {
+      const requestUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+
+      if (requestUrl.pathname === "/" || requestUrl.pathname === "/index.html") {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(html(built.app.name ?? "Lakebed Capsule"));
+        return;
+      }
+
+      if (requestUrl.pathname === "/client.js") {
+        res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8" });
+        res.end(await readFile(built.clientOut, "utf8"));
+        return;
+      }
+
+      if (requestUrl.pathname === "/__lakebed/logs") {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify(logs.entries, null, 2));
+        return;
+      }
+
+      if (requestUrl.pathname === "/__lakebed/db/tables") {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify(stateCell.listTables(), null, 2));
+        return;
+      }
+
+      if (requestUrl.pathname === "/__lakebed/db") {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify(stateCell.dump(), null, 2));
+        return;
+      }
+
+      res.writeHead(404);
+      res.end("Not found");
+    } catch (error) {
+      res.writeHead(500);
+      res.end(error instanceof Error ? error.stack : String(error));
+    }
+  });
+
+  const wss = new WebSocketServer({ noServer: true });
+
+  async function publishAll() {
+    for (const [ws, subscription] of subscriptions) {
+      for (const name of subscription.queries) {
+        try {
+          const data = await runQuery({
+            app: built.app,
+            stateCell,
+            auth: subscription.auth,
+            logs,
+            env: built.env,
+            name
+          });
+          sendJson(ws, { op: "query.result", name, data });
+        } catch (error) {
+          sendJson(ws, { op: "query.error", name, error: error instanceof Error ? error.message : String(error) });
+        }
+      }
+    }
+  }
+
+  wss.on("connection", (ws, _req, auth) => {
+    subscriptions.set(ws, { auth, queries: new Set() });
+    sendJson(ws, { op: "auth.result", auth });
+
+    ws.on("message", async (raw) => {
+      const message = JSON.parse(String(raw));
+      const subscription = subscriptions.get(ws);
+
+      try {
+        if (!subscription) {
+          throw new Error("Lakebed connection closed.");
+        }
+
+        if (message.op === "auth.get") {
+          sendJson(ws, { id: message.id, op: "auth.result", ok: true, auth: subscription.auth });
+          return;
+        }
+
+        if (message.op === "query.subscribe") {
+          subscription.queries.add(message.name);
+          const data = await runQuery({
+            app: built.app,
+            stateCell,
+            auth: subscription.auth,
+            logs,
+            env: built.env,
+            name: message.name
+          });
+          sendJson(ws, { id: message.id, op: "query.result", ok: true, name: message.name, data });
+          return;
+        }
+
+        if (message.op === "mutation.run") {
+          const { result } = await runMutation({
+            app: built.app,
+            stateCell,
+            auth: subscription.auth,
+            logs,
+            env: built.env,
+            name: message.name,
+            args: message.args ?? []
+          });
+          sendJson(ws, { id: message.id, op: "mutation.result", ok: true, result });
+          await publishAll();
+          return;
+        }
+
+        throw new Error(`Unknown operation: ${message.op}`);
+      } catch (error) {
+        sendJson(ws, {
+          id: message.id,
+          op: "error",
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+
+    ws.on("close", () => {
+      subscriptions.delete(ws);
+    });
+  });
+
+  server.on("upgrade", (req, socket, head) => {
+    const requestUrl = new URL(req.url ?? "/", "http://lakebed.local");
+    if (requestUrl.pathname !== "/__lakebed/ws") {
+      socket.destroy();
+      return;
+    }
+
+    const auth = authFromUrl(requestUrl, defaultAuth);
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req, auth);
+    });
+  });
+
+  await new Promise((resolveListen, rejectListen) => {
+    server.once("error", rejectListen);
+    server.listen(port, () => {
+      server.off("error", rejectListen);
+      resolveListen();
+    });
+  });
+
+  if (!quiet) {
+    console.log(`Lakebed capsule running at http://localhost:${port}`);
+    console.log(`Capsule: ${resolvedCapsuleDir}`);
+    console.log(`Auth: ${defaultAuth.userId}`);
+  }
+
+  return {
+    app: built.app,
+    buildDir: built.buildDir,
+    capsuleDir: resolvedCapsuleDir,
+    logs,
+    port,
+    stateCell,
+    url: `http://localhost:${port}`,
+    async close() {
+      for (const client of wss.clients) {
+        client.close();
+      }
+
+      await new Promise((resolveClose) => {
+        wss.close(() => {
+          server.close(() => resolveClose());
+        });
+      });
+    }
+  };
+}
+
+async function dev(args) {
+  const [capsuleArg] = positionals(args);
+  const port = readNumberArg(args, "--port", 3000);
+  await startDevServer({
+    capsuleDir: resolveCapsuleDir(capsuleArg),
+    port,
+    capsuleId: `dev-${port}`
+  });
+}
+
+async function buildAnonymousEnvelope(capsuleArg) {
+  const capsuleDir = resolveCapsuleDir(capsuleArg);
+  const sourceStore = await createMemorySourceStoreFromDirectory(capsuleDir);
+  const built = await buildCapsule({
+    capsuleDir,
+    capsuleId: `anonymous-${Date.now()}`,
+    sourceStore
+  });
+  const artifact = await createAnonymousArtifact({
+    app: built.app,
+    clientOut: built.clientOut,
+    sourceStore
+  });
+
+  return {
+    artifact: artifact.artifact,
+    artifactHash: artifact.artifactHash,
+    clientBundle: artifact.clientBundle,
+    clientBundleHash: artifact.clientBundleHash,
+    mediaType: ANONYMOUS_ARTIFACT_MEDIA_TYPE
+  };
+}
+
+function defaultArtifactPath(capsuleDir) {
+  return resolve(root, ".lakebed/artifacts", `${basename(capsuleDir)}.anonymous.json`);
+}
+
+async function buildCommand(args) {
+  const [capsuleArg] = positionals(args);
+  const target = readArg(args, "--target", "anonymous");
+  if (target !== "anonymous") {
+    throw new Error(`Unsupported build target: ${target}. The only explicit build target today is anonymous.`);
+  }
+
+  const capsuleDir = resolveCapsuleDir(capsuleArg);
+  const out = readArg(args, "--out", defaultArtifactPath(capsuleDir));
+  const envelope = await buildAnonymousEnvelope(capsuleArg);
+  await mkdir(dirname(out), { recursive: true });
+  await writeFile(out, `${stableStringify(envelope)}\n`);
+
+  if (hasFlag(args, "--json")) {
+    console.log(
+      JSON.stringify(
+        {
+          artifactHash: envelope.artifactHash,
+          artifactPath: out,
+          clientBundleHash: envelope.clientBundleHash,
+          format: envelope.artifact.format
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  console.log(`Anonymous artifact written to ${out}`);
+  console.log(`Artifact: ${envelope.artifactHash}`);
+  console.log(`Client:   ${envelope.clientBundleHash}`);
+}
+
+function deployApiUrl(args) {
+  return String(readArg(args, "--api", process.env.LAKEBED_DEPLOY_API ?? process.env.SPAN_DEPLOY_API ?? "http://localhost:8787")).replace(
+    /\/+$/g,
+    ""
+  );
+}
+
+async function readResponseJson(response) {
+  const body = await response.text();
+  if (!response.ok) {
+    throw new Error(body || `Request failed with ${response.status}`);
+  }
+  return JSON.parse(body);
+}
+
+async function deployCommand(args) {
+  const [capsuleArg] = positionals(args);
+  const envelope = await buildAnonymousEnvelope(capsuleArg);
+  const ttl = parseTtlSeconds(readArg(args, "--ttl", "7d"));
+  const api = deployApiUrl(args);
+  const response = await fetch(`${api}/v1/anonymous-deploys`, {
+    body: JSON.stringify({
+      artifact: envelope.artifact,
+      clientBundle: envelope.clientBundle,
+      clientVersion: "0.0.1",
+      requestedTtlSeconds: ttl
+    }),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST"
+  });
+  const deployed = await readResponseJson(response);
+
+  if (hasFlag(args, "--json")) {
+    console.log(JSON.stringify(deployed, null, 2));
+    return;
+  }
+
+  console.log("Deploying anonymous preview...\n");
+  console.log(`App:        ${deployed.url}`);
+  console.log(`Expires:    ${deployed.expiresAt}`);
+  console.log(`Claim:      ${deployed.claimUrl}`);
+  console.log(`Inspect:    lakebed inspect ${deployed.deployId}`);
+  console.log("\nLimits:");
+  console.log(`  source/artifact: ${deployed.limits.artifactBytes} bytes`);
+  console.log(`  state:           ${deployed.limits.stateBytes} bytes`);
+  console.log(`  requests:        ${deployed.limits.requestsPerDay} / day`);
+  console.log(`  mutations:       ${deployed.limits.mutationsPerDay} / day`);
+  console.log("  outbound fetch:  disabled");
+}
+
+async function anonymousServerCommand(args) {
+  const port = readNumberArg(args, "--port", Number(process.env.PORT ?? 8787));
+  await startAnonymousServer({
+    appBaseDomain: readArg(args, "--app-base-domain", process.env.LAKEBED_APP_BASE_DOMAIN ?? ""),
+    port,
+    publicRootUrl: readArg(args, "--public-root-url", process.env.PUBLIC_ROOT_URL ?? `http://localhost:${port}`)
+  });
+  await new Promise(() => {});
+}
+
+async function resolveDeployUrl(target, args) {
+  if (!target) {
+    throw new Error("Expected a deploy ID or URL.");
+  }
+
+  try {
+    const url = new URL(target);
+    return url.href.replace(/\/+$/g, "");
+  } catch {
+    const api = deployApiUrl(args);
+    const response = await fetch(`${api}/v1/deploys/${encodeURIComponent(target)}`);
+    const deploy = await readResponseJson(response);
+    return deploy.url.replace(/\/+$/g, "");
+  }
+}
+
+async function hostedJson(target, path, args) {
+  const url = await resolveDeployUrl(target, args);
+  const response = await fetch(`${url}${path}`);
+  return readResponseJson(response);
+}
+
+async function inspectCommand(args) {
+  const [target] = positionals(args);
+  const manifest = await hostedJson(target, "/__lakebed/manifest", args);
+
+  if (hasFlag(args, "--json")) {
+    console.log(JSON.stringify(manifest, null, 2));
+    return;
+  }
+
+  console.log(`Deploy:   ${manifest.deployId}`);
+  console.log(`URL:      ${manifest.url}`);
+  console.log(`Expires:  ${manifest.expiresAt}`);
+  console.log(`Artifact: ${manifest.artifactHash}`);
+  console.log(`Queries:  ${manifest.queries.join(", ") || "(none)"}`);
+  console.log(`Mutations: ${manifest.mutations.join(", ") || "(none)"}`);
+}
+
+async function authCommand(args) {
+  if (args[0] === "as" && args[1]) {
+    const auth = createGuestAuth(args[1]);
+    await writeAuth(auth);
+    console.log(`Lakebed auth set to ${auth.userId}`);
+    return;
+  }
+
+  if (args[0] === "reset") {
+    await writeAuth(createGuestAuth("local"));
+    console.log("Lakebed auth reset to guest:local");
+    return;
+  }
+
+  usage();
+}
+
+async function fetchLakebedJson(port, path) {
+  const response = await fetch(`http://localhost:${port}${path}`);
+  if (!response.ok) {
+    throw new Error(`Unable to read ${path} from port ${port}: ${response.status}`);
+  }
+
+  return response.text();
+}
+
+async function logsCommand(args) {
+  const [target] = positionals(args);
+  if (target) {
+    console.log(JSON.stringify(await hostedJson(target, "/__lakebed/logs", args), null, 2));
+    return;
+  }
+
+  const port = readNumberArg(args, "--port", 3000);
+  console.log(await fetchLakebedJson(port, "/__lakebed/logs"));
+}
+
+async function dbCommand(args) {
+  const [subcommand, target] = positionals(args);
+  const port = readNumberArg(args, "--port", 3000);
+
+  if (subcommand === "list") {
+    if (target) {
+      console.log(JSON.stringify(await hostedJson(target, "/__lakebed/db/tables", args), null, 2));
+      return;
+    }
+
+    console.log(await fetchLakebedJson(port, "/__lakebed/db/tables"));
+    return;
+  }
+
+  if (subcommand === "dump") {
+    if (target) {
+      console.log(JSON.stringify(await hostedJson(target, "/__lakebed/db", args), null, 2));
+      return;
+    }
+
+    console.log(await fetchLakebedJson(port, "/__lakebed/db"));
+    return;
+  }
+
+  usage();
+}
+
+function todoTemplate(name) {
+  const title = basename(name);
+  return {
+    "server/index.ts": `import { boolean, capsule, mutation, query, string, table } from "lakebed/server";
+import { cleanTodoText } from "../shared/todo";
+
+export default capsule({
+  schema: {
+    todos: table({
+      text: string(),
+      done: boolean().default(false),
+      ownerId: string()
+    })
+  },
+
+  queries: {
+    todos: query((ctx) =>
+      ctx.db.todos
+        .where("ownerId", ctx.auth.userId)
+        .orderBy("createdAt", "desc")
+        .all()
+    )
+  },
+
+  mutations: {
+    addTodo: mutation((ctx, text: string) => {
+      const cleanText = cleanTodoText(text);
+      if (!cleanText) {
+        return;
+      }
+
+      ctx.db.todos.insert({ text: cleanText, ownerId: ctx.auth.userId });
+    })
+  }
+});
+`,
+    "client/index.tsx": `import { useAuth, useMutation, useQuery } from "lakebed/client";
+import { cleanTodoText, type Todo } from "../shared/todo";
+
+export function App() {
+  const auth = useAuth();
+  const todos = useQuery<Todo[]>("todos");
+  const addTodo = useMutation<[text: string], void>("addTodo");
+
+  async function onSubmit(event: SubmitEvent) {
+    event.preventDefault();
+    const form = event.currentTarget as HTMLFormElement;
+    const data = new FormData(form);
+    const text = cleanTodoText(String(data.get("text") ?? ""));
+    if (!text) {
+      return;
+    }
+
+    await addTodo(text);
+    form.reset();
+  }
+
+  return (
+    <main className="min-h-screen bg-black px-6 py-10 text-white">
+      <section className="mx-auto max-w-2xl">
+        <p className="mb-3 font-mono text-sm text-neutral-500">signed in as {auth.userId}</p>
+        <h1 className="mb-8 text-5xl font-bold tracking-tight">${title}</h1>
+        <form className="mb-8 flex gap-3" onSubmit={(event) => void onSubmit(event)}>
+          <input className="min-w-0 flex-1 border border-neutral-700 bg-black px-3 py-2 text-white outline-none focus:border-white" name="text" placeholder="Add a todo" />
+          <button className="border border-white px-4 py-2 font-medium" type="submit">Add</button>
+        </form>
+        <ul className="divide-y divide-neutral-800 border-y border-neutral-800">
+          {todos.map((todo) => (
+            <li className="py-3" key={todo.id}>{todo.text}</li>
+          ))}
+        </ul>
+      </section>
+    </main>
+  );
+}
+`,
+    "shared/todo.ts": `export type Todo = {
+  id: string;
+  text: string;
+  done: boolean;
+  ownerId: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export function cleanTodoText(value: string): string {
+  return value.trim().slice(0, 160);
+}
+`,
+    "README.md": `# ${title}
+
+Run this Lakebed capsule:
+
+\`\`\`sh
+pnpm lakebed dev ${name}
+\`\`\`
+`
+  };
+}
+
+async function newCommand(args) {
+  const [name] = positionals(args);
+  const template = readArg(args, "--template", "todo");
+
+  if (!name) {
+    usage();
+    return;
+  }
+
+  if (template !== "todo") {
+    throw new Error(`Unknown template: ${template}`);
+  }
+
+  const targetDir = resolveCapsuleDir(name);
+  if (existsSync(targetDir)) {
+    throw new Error(`Target already exists: ${targetDir}`);
+  }
+
+  const files = todoTemplate(name);
+  for (const [path, contents] of Object.entries(files)) {
+    const absolutePath = join(targetDir, path);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, contents);
+  }
+
+  console.log(`Created Lakebed capsule at ${targetDir}`);
+}
+
+async function runMany(args) {
+  const [capsuleArg] = positionals(args);
+  const capsuleDir = resolveCapsuleDir(capsuleArg);
+  const count = readNumberArg(args, "--count", 20);
+  const basePort = readNumberArg(args, "--base-port", 4000);
+  const handles = [];
+
+  try {
+    for (let index = 0; index < count; index += 1) {
+      handles.push(
+        await startDevServer({
+          capsuleDir,
+          port: basePort + index,
+          capsuleId: `run-many-${basePort + index}`,
+          quiet: true
+        })
+      );
+    }
+  } catch (error) {
+    await Promise.allSettled(handles.map((handle) => handle.close()));
+    throw error;
+  }
+
+  console.log(`Started ${handles.length} Lakebed capsules:`);
+  for (const handle of handles) {
+    console.log(handle.url);
+  }
+
+  async function stop() {
+    await Promise.allSettled(handles.map((handle) => handle.close()));
+  }
+
+  process.once("SIGINT", async () => {
+    await stop();
+    process.exit(0);
+  });
+  process.once("SIGTERM", async () => {
+    await stop();
+    process.exit(0);
+  });
+
+  await new Promise(() => {});
+}
+
+async function main() {
+  const [command, ...args] = process.argv.slice(2);
+
+  if (command === "new") {
+    await newCommand(args);
+    return;
+  }
+
+  if (command === "dev") {
+    await dev(args);
+    return;
+  }
+
+  if (command === "build") {
+    await buildCommand(args);
+    return;
+  }
+
+  if (command === "deploy") {
+    await deployCommand(args);
+    return;
+  }
+
+  if (command === "anonymous-server") {
+    await anonymousServerCommand(args);
+    return;
+  }
+
+  if (command === "inspect") {
+    await inspectCommand(args);
+    return;
+  }
+
+  if (command === "run-many") {
+    await runMany(args);
+    return;
+  }
+
+  if (command === "auth") {
+    await authCommand(args);
+    return;
+  }
+
+  if (command === "db") {
+    await dbCommand(args);
+    return;
+  }
+
+  if (command === "logs") {
+    await logsCommand(args);
+    return;
+  }
+
+  usage();
+}
+
+function isMainModule() {
+  try {
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1]);
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  main().catch((error) => {
+    if (error instanceof AnonymousCompilerError) {
+      console.error("Anonymous build failed:");
+      for (const diagnostic of error.diagnostics) {
+        console.error(`- ${diagnostic.file}: ${diagnostic.message}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+
+    console.error(error);
+    process.exitCode = 1;
+  });
+}