erdraft 0.0.0-stage → 0.0.2

package/dist/cli.js

@@ -0,0 +1,758 @@
+#!/usr/bin/env node
+import {
+  DECISION_SECONDS,
+  TUNNEL_IDS,
+  chooseDatabase,
+  createApi,
+  createServer,
+  currentDatabase,
+  databaseOf,
+  describeDecision,
+  describeDraft,
+  describeTable,
+  describeTables,
+  draftLine,
+  readDraft,
+  readSchema,
+  storeOf,
+  version_default,
+  writtenIn
+} from "./chunk-IQ5YYSCP.js";
+import "./chunk-VSN3XJPO.js";
+
+// bin/erdraft.ts
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+import { join as join7 } from "path";
+import { text } from "stream/consumers";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server/serve-window.ts
+import { createServer as createServer2 } from "http";
+import { readFile, stat } from "fs/promises";
+import { extname, join } from "path";
+var TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+async function fileOf(folder, url) {
+  const { pathname } = new URL(String(url), "http://localhost");
+  const path = join(folder, pathname);
+  const found = await stat(path).catch(() => void 0);
+  return found?.isFile() ? path : join(folder, "index.html");
+}
+function refuse(response, status, message) {
+  response.writeHead(status, { "content-type": "text/plain; charset=utf-8" });
+  response.end(message);
+}
+async function serveWindow(config, folder) {
+  const api = createApi(config);
+  const server = createServer2((request, response) => {
+    api.middleware(request, response, (error) => {
+      if (error) {
+        refuse(response, 500, String(error));
+        return;
+      }
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        refuse(response, 404, "Not found");
+        return;
+      }
+      fileOf(folder, request.url).then(async (path) => {
+        const body = await readFile(path);
+        response.writeHead(200, {
+          "content-type": TYPES[extname(path)] ?? "application/octet-stream"
+        });
+        response.end(body);
+      }).catch((failure) => refuse(response, 500, String(failure)));
+    });
+  });
+  server.on("close", api.close);
+  await new Promise((done, fail) => {
+    server.once("error", (error) => {
+      api.close();
+      fail(
+        error.code === "EADDRINUSE" ? new Error(
+          `Port ${config.port} is taken: stop what holds it, or give the window another "port" in .erdraft.json`
+        ) : error
+      );
+    });
+    server.listen(config.port, "127.0.0.1", done);
+  });
+  return server;
+}
+
+// src/cli/run.ts
+import { readFile as readFile5 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import { parseArgs } from "util";
+import { z as z4 } from "zod";
+
+// src/core/load-config.ts
+import { z } from "zod";
+import { join as join2, resolve, dirname, basename } from "path";
+import { homedir } from "os";
+import { readFile as readFile2 } from "fs/promises";
+import { createHash } from "crypto";
+var CONFIG_FILE = ".erdraft.json";
+var databaseSchema = z.object({
+  // The name the window's menu shows it by
+  name: z.string().min(1),
+  // The module of Drizzle that exports every table and enum (drizzle-kit's `schema`)
+  schema: z.string().min(1)
+});
+var configSchema = z.object({
+  // The project's name; none given, its folder's
+  name: z.string().min(1).optional(),
+  // The project's one database, its module of Drizzle; or its databases, each named, the window switching between
+  schema: z.string().min(1).optional(),
+  databases: z.array(databaseSchema).min(1).optional(),
+  // The folder Erdraft keeps the drafts in, shared by the CLI, the MCP and the window, and by every workspace of
+  // the project on the machine: `~` is the home folder; none given, ~/.erdraft/<the project's name>
+  store: z.string().min(1).optional(),
+  // The window's port
+  port: z.number().int().min(1).max(65535).default(9369),
+  // The window's assistant: the Claude Code it runs headless, and its model (an alias or a model's full name)
+  claude: z.string().min(1).default("claude"),
+  model: z.string().min(1).default("sonnet"),
+  // The provider the window is shared over the internet through (src/share/tunnels.ts)
+  tunnel: z.enum(TUNNEL_IDS).default("ngrok")
+});
+function folderOf(name) {
+  const folder = name.normalize("NFKD").replace(new RegExp("\\p{Diacritic}", "gu"), "").toLocaleLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return folder || createHash("sha256").update(name).digest("hex").slice(0, 12);
+}
+function storeOf2(folder, name, store) {
+  if (store === void 0) {
+    return join2(homedir(), ".erdraft", folderOf(name));
+  }
+  if (store === "~" || store.startsWith("~/")) {
+    return join2(homedir(), store.slice(1));
+  }
+  return resolve(folder, store);
+}
+function parsed(path, text2) {
+  try {
+    return configSchema.parse(JSON.parse(text2));
+  } catch (error) {
+    throw new Error(
+      `${path} is not a config Erdraft reads: ${error instanceof z.ZodError ? z.prettifyError(error) : String(error)}`
+    );
+  }
+}
+async function readIfThere(path) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function loadConfig(from) {
+  let folder = resolve(from);
+  for (; ; ) {
+    const text2 = await readIfThere(join2(folder, CONFIG_FILE));
+    if (text2 !== void 0) {
+      const {
+        schema,
+        databases,
+        name = basename(folder),
+        ...config
+      } = parsed(join2(folder, CONFIG_FILE), text2);
+      const [first, ...rest] = (databases ?? (schema ? [{ name, schema }] : [])).map((database) => ({
+        id: folderOf(database.name),
+        name: database.name,
+        schema: resolve(folder, database.schema)
+      }));
+      if (!first) {
+        throw new Error(`${CONFIG_FILE} names no schema nor databases`);
+      }
+      const ids = new Set([first, ...rest].map((database) => database.id));
+      if (ids.size !== rest.length + 1) {
+        throw new Error(`${CONFIG_FILE} names two databases alike`);
+      }
+      return {
+        ...config,
+        name,
+        databases: [first, ...rest],
+        store: storeOf2(folder, name, config.store),
+        root: folder,
+        workspace: createHash("sha256").update(folder).digest("hex").slice(0, 12)
+      };
+    }
+    const parent = dirname(folder);
+    if (parent === folder) {
+      throw new Error(
+        `No ${CONFIG_FILE} in ${resolve(from)} or above it: erdraft init sets the project up`
+      );
+    }
+    folder = parent;
+  }
+}
+
+// src/core/init-project.ts
+import { z as z3 } from "zod";
+import { join as join6, resolve as resolve3, relative, basename as basename2 } from "path";
+import { existsSync } from "fs";
+import { writeFile as writeFile3 } from "fs/promises";
+
+// src/core/read-if-there.ts
+import { readFile as readFile3 } from "fs/promises";
+async function readIfThere2(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+}
+
+// src/core/find-schema.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
+var DRIZZLE_CONFIGS = [
+  "drizzle.config.ts",
+  "drizzle.config.mts",
+  "drizzle.config.cts",
+  "drizzle.config.js",
+  "drizzle.config.mjs",
+  "drizzle.config.cjs",
+  "drizzle.config.json"
+];
+var USUAL_SCHEMAS = [
+  "src/db/schema.ts",
+  "src/db/schema/index.ts",
+  "src/server/db/schema.ts",
+  "src/lib/db/schema.ts",
+  "src/schema.ts",
+  "db/schema.ts",
+  "lib/db/schema.ts",
+  "drizzle/schema.ts"
+];
+var WORKSPACE_FOLDERS = ["packages", "apps"];
+var SCHEMA_KEY = /(?:^|[\s{,])["']?schema["']?\s*:\s*(["'`])([^"'`*]+)\1/;
+async function moduleAt(path) {
+  const found = await stat2(path).catch(() => void 0);
+  if (found?.isFile()) {
+    return path;
+  }
+  if (found?.isDirectory()) {
+    return moduleAt(join3(path, "index.ts"));
+  }
+  return void 0;
+}
+async function schemaIn(folder) {
+  for (const name of DRIZZLE_CONFIGS) {
+    const text2 = await readIfThere2(join3(folder, name));
+    const path = text2?.match(SCHEMA_KEY)?.[2];
+    const found = path && await moduleAt(resolve2(folder, path));
+    if (found) {
+      return found;
+    }
+  }
+  for (const path of USUAL_SCHEMAS) {
+    const found = await moduleAt(join3(folder, path));
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+async function workspacesOf(root) {
+  const folders = [];
+  for (const parent of WORKSPACE_FOLDERS) {
+    const entries = await readdir(join3(root, parent), {
+      withFileTypes: true
+    }).catch(() => []);
+    const names = entries.filter((each) => each.isDirectory()).map((each) => each.name).sort();
+    for (const name of names) {
+      folders.push(join3(root, parent, name));
+    }
+  }
+  return folders;
+}
+async function findSchema(root) {
+  for (const folder of [root, ...await workspacesOf(root)]) {
+    const found = await schemaIn(folder);
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+
+// src/core/add-mcp-server.ts
+import { z as z2 } from "zod";
+import { join as join4 } from "path";
+import { writeFile } from "fs/promises";
+var MCP_FILE = ".mcp.json";
+var ERDRAFT_SERVER = { command: "npx", args: ["-y", "erdraft", "mcp"] };
+var mcpFile = z2.looseObject({
+  mcpServers: z2.record(z2.string(), z2.unknown()).optional()
+});
+function parsed2(text2) {
+  try {
+    return mcpFile.parse(JSON.parse(text2));
+  } catch (error) {
+    throw new Error(
+      `${MCP_FILE} is not one Erdraft can add to: ${error instanceof z2.ZodError ? z2.prettifyError(error) : String(error)}`
+    );
+  }
+}
+async function addMcpServer(root) {
+  const path = join4(root, MCP_FILE);
+  const text2 = await readIfThere2(path);
+  const file = text2 === void 0 ? {} : parsed2(text2);
+  if (file.mcpServers?.erdraft !== void 0) {
+    return { path, added: false };
+  }
+  const servers = { ...file.mcpServers, erdraft: ERDRAFT_SERVER };
+  await writeFile(
+    path,
+    `${JSON.stringify({ ...file, mcpServers: servers }, null, 2)}
+`
+  );
+  return { path, added: true };
+}
+
+// src/core/install-skill.ts
+import { mkdir, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join5 } from "path";
+var SKILL_PATH = join5(".claude", "skills", "erdraft", "SKILL.md");
+async function installSkill(root, source, force = false) {
+  const path = join5(root, SKILL_PATH);
+  const skill = await readFile4(source, "utf8");
+  const there = await readIfThere2(path);
+  if (there === skill) {
+    return { path, written: false };
+  }
+  if (there !== void 0 && !force) {
+    throw new Error(
+      `${SKILL_PATH} differs from this Erdraft's skill (changed, or of another version): --force writes it over`
+    );
+  }
+  await mkdir(dirname2(path), { recursive: true });
+  await writeFile2(path, skill);
+  return { path, written: true };
+}
+
+// src/core/init-project.ts
+var packageFile = z3.looseObject({
+  name: z3.string().min(1).optional(),
+  dependencies: z3.record(z3.string(), z3.string()).optional(),
+  devDependencies: z3.record(z3.string(), z3.string()).optional()
+});
+var INSTALLS = [
+  ["pnpm-workspace.yaml", "pnpm add -D -w erdraft"],
+  ["pnpm-lock.yaml", "pnpm add -D erdraft"],
+  ["bun.lock", "bun add -d erdraft"],
+  ["bun.lockb", "bun add -d erdraft"],
+  ["yarn.lock", "yarn add -D erdraft"]
+];
+async function packageOf(root) {
+  const text2 = await readIfThere2(join6(root, "package.json")) ?? "{}";
+  try {
+    return packageFile.parse(JSON.parse(text2));
+  } catch {
+    return {};
+  }
+}
+async function schemaOf(root, given) {
+  const path = given === void 0 ? await findSchema(root) : resolve3(root, given);
+  if (path === void 0) {
+    throw new Error(
+      "Found no Drizzle schema here: erdraft init <the module that exports every table>"
+    );
+  }
+  if (!existsSync(path)) {
+    throw new Error(`There is no ${given}`);
+  }
+  return relative(root, path);
+}
+function installOf(root) {
+  const found = INSTALLS.find(([file]) => existsSync(join6(root, file)));
+  return found ? found[1] : "npm install --save-dev erdraft";
+}
+async function initProject(options) {
+  const { root, out } = options;
+  const project = await packageOf(root);
+  if (existsSync(join6(root, CONFIG_FILE)) && !options.force) {
+    out(`Kept ${CONFIG_FILE}, already here (--force writes it again).`);
+  } else {
+    const schema = await schemaOf(root, options.schema);
+    const name = options.name ?? project.name ?? basename2(root);
+    await writeFile3(
+      join6(root, CONFIG_FILE),
+      `${JSON.stringify({ name, schema }, null, 2)}
+`
+    );
+    out(`Wrote ${CONFIG_FILE}: ${name}, its schema ${schema}.`);
+  }
+  const mcp = await addMcpServer(root);
+  out(
+    mcp.added ? `Added Erdraft's MCP to ${MCP_FILE}.` : `${MCP_FILE} has Erdraft's MCP already.`
+  );
+  const skill = await installSkill(root, options.skill, options.force);
+  out(
+    skill.written ? `Wrote Erdraft's skill to ${relative(root, skill.path)}.` : `Erdraft's skill is in ${relative(root, skill.path)} already.`
+  );
+  const config = await loadConfig(root);
+  const [database] = config.databases;
+  const base = await readSchema(config, database, storeOf(config, database));
+  const installed = project.dependencies?.erdraft ?? project.devDependencies?.erdraft;
+  out(
+    `Read ${base.schema.tables.length} tables and ${base.schema.enums.length} enums from ${base.source}.`
+  );
+  const studio = [
+    "npx erdraft studio",
+    `opens the window, at http://localhost:${config.port}`
+  ];
+  const steps = installed ? [studio] : [
+    [
+      installOf(root),
+      "keeps this version in the project, which npx erdraft then runs"
+    ],
+    studio
+  ];
+  const width = Math.max(...steps.map(([command2]) => command2.length));
+  out(
+    [
+      "",
+      "Next:",
+      ...steps.map(([command2, what]) => `  ${command2.padEnd(width)}   ${what}`),
+      '  Then, in a new Claude Code session with its MCP approved, ask for a draft: "propose two ways to tag projects"'
+    ].join("\n")
+  );
+}
+
+// src/cli/run.ts
+var HELP = `erdraft: a project's data model, drafted with an agent while a person watches
+
+Usage: erdraft <command> [options] [--database <id>]
+       erdraft --version
+
+  init [<schema>] [--name <name>] [--force]
+                              Set the project up: .erdraft.json (its Drizzle schema found, or the one given), the MCP
+                              in .mcp.json, the skill for its agents
+  studio                      Open the window (the diagram, live)
+  mcp                         Serve the MCP on stdin and stdout, for an agent
+  read                        Read the schema again from the code
+  tables [--draft <id>]       List the tables
+  table <name> [--draft <id>] Describe a table
+  drafts                      List the drafts
+  draft <id>                  Show a draft and what it changes
+  propose <file|-> --title <title> [--summary <text>] [--group <name>]
+                              Propose a draft from a JSON array of operations
+  revise <id> [<file|->] [--replace] [--title <title>] [--summary <text>] [--group <name>]
+                              Add operations to a draft (or put them in its place)
+  show [<table>] [--related] [--draft <id> | --schema]
+                              Show it in the window: a table in focus, only it and the tables it joins, a draft
+  wait <id> [--seconds <n>]   Wait until the person adopts a draft or sets it aside (30 s at most when not said)
+  adopt <id>                  Adopt a draft (the others of its group are set aside)
+  discard <id>                Set a draft aside
+  delete <id>                 Delete a draft for good
+  databases                   List the project's databases, * the one worked on
+  install-skill [--force]     Write Erdraft's skill into the project (.claude/skills/erdraft), for its agents
+  use <id>                    Work on another database (the window switches too)
+
+A command works on the database chosen last (use), or on the one --database names. The nearest .erdraft.json says
+where the databases' schemas and their drafts are.`;
+var COMMANDS = /* @__PURE__ */ new Set([
+  "init",
+  "studio",
+  "mcp",
+  "read",
+  "tables",
+  "table",
+  "drafts",
+  "draft",
+  "propose",
+  "revise",
+  "show",
+  "wait",
+  "adopt",
+  "discard",
+  "delete",
+  "databases",
+  "install-skill",
+  "use"
+]);
+async function operationsFrom(path, options) {
+  if (path === void 0) {
+    return void 0;
+  }
+  const text2 = path === "-" ? await options.stdin() : await readFile5(resolve4(options.cwd, path), "utf8");
+  return JSON.parse(text2);
+}
+function required(value, what) {
+  if (!value) {
+    throw new Error(`Missing ${what}. Run erdraft --help`);
+  }
+  return value;
+}
+async function command(argv, options) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      draft: { type: "string" },
+      title: { type: "string" },
+      summary: { type: "string" },
+      group: { type: "string" },
+      replace: { type: "boolean" },
+      related: { type: "boolean" },
+      schema: { type: "boolean" },
+      database: { type: "string" },
+      seconds: { type: "string" },
+      force: { type: "boolean" },
+      name: { type: "string" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  const [name, argument] = positionals;
+  if (values.version) {
+    options.out(version_default);
+    return;
+  }
+  if (!name || values.help) {
+    options.out(HELP);
+    return;
+  }
+  if (!COMMANDS.has(name)) {
+    throw new Error(`Unknown command "${name}". Run erdraft --help`);
+  }
+  if (name === "init") {
+    return initProject({
+      root: options.cwd,
+      skill: options.skill,
+      schema: argument,
+      name: values.name,
+      force: values.force,
+      out: options.out
+    });
+  }
+  const config = await loadConfig(options.cwd);
+  const database = values.database ? databaseOf(config, values.database) : await currentDatabase(config);
+  const drafts = storeOf(config, database);
+  async function base() {
+    return await drafts.readBase() ?? readSchema(config, database, drafts);
+  }
+  async function readOf(draft) {
+    return readDraft(
+      (await base()).schema,
+      draft ? (await drafts.draft(draft)).operations : []
+    );
+  }
+  async function schemaOf2(draft) {
+    return (await readOf(draft)).diff;
+  }
+  switch (name) {
+    case "studio":
+      await readSchema(config, database, drafts);
+      return options.startStudio(config);
+    case "mcp":
+      return options.startMcp(config);
+    case "read": {
+      const base2 = await readSchema(config, database, drafts);
+      options.out(
+        `Read ${base2.schema.tables.length} tables and ${base2.schema.enums.length} enums from ${base2.source}.`
+      );
+      return;
+    }
+    case "tables":
+      options.out(describeTables(await schemaOf2(values.draft)));
+      return;
+    case "table": {
+      const tableName = required(argument, "the table\u2019s name");
+      const diff = await schemaOf2(values.draft);
+      const table = diff.tables.find((each) => each.name === tableName);
+      if (!table) {
+        throw new Error(`There is no table "${tableName}"`);
+      }
+      options.out(describeTable(table, diff));
+      return;
+    }
+    case "drafts": {
+      const all = await drafts.readDrafts();
+      options.out(
+        all.length > 0 ? all.map(draftLine).join("\n") : "No drafts yet."
+      );
+      return;
+    }
+    case "draft": {
+      const draft = await drafts.draft(required(argument, "the draft\u2019s id"));
+      const { diff, written } = await readOf(draft.id);
+      options.out(describeDraft(draft, diff, written));
+      return;
+    }
+    case "propose": {
+      await base();
+      const operations = await operationsFrom(
+        required(argument, "the operations\u2019 file"),
+        options
+      );
+      const draft = await drafts.propose({
+        title: required(values.title, "--title"),
+        summary: values.summary,
+        group: values.group,
+        operations
+      });
+      options.out(`Proposed ${draft.id}: ${draft.title}.`);
+      return;
+    }
+    case "revise": {
+      await base();
+      const id = required(argument, "the draft\u2019s id");
+      const operations = await operationsFrom(positionals[2], options);
+      const draft = await drafts.revise(id, {
+        title: values.title,
+        summary: values.summary,
+        group: values.group,
+        mode: values.replace ? "replace" : "append",
+        operations
+      });
+      options.out(`Revised ${draft.id}: ${draft.title}.`);
+      return;
+    }
+    case "show": {
+      const draft = values.schema ? null : values.draft;
+      const diff = await schemaOf2(draft ?? void 0);
+      if (argument && !diff.tables.some((each) => each.name === argument)) {
+        throw new Error(`There is no table "${argument}"`);
+      }
+      await drafts.show({
+        table: argument ?? null,
+        related: values.related === true && argument !== void 0,
+        draft
+      });
+      options.out(`Shown in the window.`);
+      return;
+    }
+    case "wait": {
+      const seconds = Number(values.seconds ?? DECISION_SECONDS);
+      if (!Number.isInteger(seconds) || seconds < 1) {
+        throw new Error("--seconds is a whole number of seconds, 1 or more");
+      }
+      const draft = await drafts.decision(
+        required(argument, "the draft\u2019s id"),
+        seconds * 1e3
+      );
+      options.out(
+        describeDecision(
+          draft,
+          await drafts.readDrafts(),
+          seconds,
+          writtenIn((await base()).schema, draft.operations)
+        )
+      );
+      return;
+    }
+    case "adopt":
+    case "discard": {
+      const draft = await drafts.setStatus(
+        required(argument, "the draft\u2019s id"),
+        name === "adopt" ? "adopted" : "discarded"
+      );
+      options.out(
+        `${name === "adopt" ? "Adopted" : "Discarded"} ${draft.id}: ${draft.title}.`
+      );
+      return;
+    }
+    case "delete": {
+      const draft = await drafts.deleteDraft(
+        required(argument, "the draft\u2019s id")
+      );
+      options.out(`Deleted ${draft.id}: ${draft.title}.`);
+      return;
+    }
+    case "databases":
+      options.out(
+        config.databases.map(
+          (each) => `${each.id === database.id ? "*" : " "} ${each.id}  ${each.name}`
+        ).join("\n")
+      );
+      return;
+    case "install-skill": {
+      const { path, written } = await installSkill(
+        config.root,
+        options.skill,
+        values.force
+      );
+      options.out(
+        written ? `Wrote Erdraft's skill to ${path}.` : `Erdraft's skill is already in ${path}, the same.`
+      );
+      return;
+    }
+    case "use": {
+      const chosen = await chooseDatabase(
+        config,
+        required(argument, "the database\u2019s id")
+      );
+      options.out(`Working on ${chosen.name}.`);
+    }
+  }
+}
+var ERROR_NAME = /^\w*Error(?: \[\w+\])?: /;
+async function run(argv, options) {
+  try {
+    await command(argv, options);
+    return 0;
+  } catch (error) {
+    options.err(
+      error instanceof z4.ZodError ? z4.prettifyError(error) : String(error).replace(ERROR_NAME, "")
+    );
+    return 1;
+  }
+}
+
+// bin/erdraft.ts
+var WINDOW = fileURLToPath(new URL("./window", import.meta.url));
+async function listen(config) {
+  if (existsSync2(join7(WINDOW, "index.html"))) {
+    return serveWindow(config, WINDOW);
+  }
+  const [{ createServer: createServer3 }, { default: studioConfig }] = await Promise.all([
+    import("vite"),
+    import("./studio-config-TCMRAVMR.js")
+  ]);
+  const server = await createServer3(studioConfig(config));
+  await server.listen();
+  return server.httpServer;
+}
+process.stdout.on("error", (error) => {
+  if (error.code !== "EPIPE") {
+    throw error;
+  }
+  process.exit(0);
+});
+var code = await run(process.argv.slice(2), {
+  cwd: process.cwd(),
+  skill: fileURLToPath(new URL("../skill/SKILL.md", import.meta.url)),
+  out: (value) => process.stdout.write(`${value}
+`),
+  err: (value) => process.stderr.write(`${value}
+`),
+  stdin: () => text(process.stdin),
+  startMcp: async (config) => {
+    await createServer({ config }).connect(new StdioServerTransport());
+    await new Promise((done) => process.stdin.on("end", done));
+  },
+  startStudio: async (config) => {
+    const server = await listen(config);
+    process.stdout.write(
+      `Erdraft: ${config.name}'s data model at http://localhost:${config.port}
+`
+    );
+    await new Promise((done) => server?.on("close", done));
+  }
+});
+process.stderr.write(
+  "",
+  () => process.stdout.write("", () => process.exit(code))
+);