glove-foundry 0.0.0

package/dist/cli.js

@@ -0,0 +1,760 @@
+#!/usr/bin/env node
+import {
+  FoundryRuntime,
+  FoundryServer,
+  writeGeneratedTypes
+} from "./chunk-UNHGCCSA.js";
+import {
+  DEFAULT_FOUNDRY_CONFIG
+} from "./chunk-ZFNMFE3T.js";
+import {
+  EMPTY_FOUNDRY_APPLICATION,
+  isFoundryApplication
+} from "./chunk-CRWY7M66.js";
+
+// src/cli.ts
+import { watch } from "node:fs";
+import { access as access2 } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { relative, resolve as resolve2, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import process2 from "node:process";
+
+// src/env.ts
+import { readFile } from "node:fs/promises";
+function unquote(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  const comment = trimmed.indexOf(" #");
+  return comment >= 0 ? trimmed.slice(0, comment).trim() : trimmed;
+}
+async function loadEnvFile(path) {
+  let source;
+  try {
+    source = await readFile(path, "utf8");
+  } catch {
+    return;
+  }
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const normalized = line.startsWith("export ") ? line.slice(7) : line;
+    const equals = normalized.indexOf("=");
+    if (equals <= 0) continue;
+    const name = normalized.slice(0, equals).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) continue;
+    if (process.env[name] === void 0) {
+      process.env[name] = unquote(normalized.slice(equals + 1));
+    }
+  }
+}
+
+// src/scaffold.ts
+import { access, mkdir, readdir, writeFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scaffoldFoundryProject(options) {
+  const rootDir = resolve(options.directory);
+  if (await exists(rootDir)) {
+    const entries = await readdir(rootDir);
+    if (entries.length > 0) {
+      throw new Error(`Cannot scaffold into non-empty directory ${rootDir}.`);
+    }
+  }
+  await mkdir(rootDir, { recursive: true });
+  const projectName = basename(rootDir).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-|-$/g, "") || "glove-foundry-app";
+  const files = /* @__PURE__ */ new Map([
+    [
+      "package.json",
+      `${JSON.stringify(
+        {
+          name: projectName,
+          version: "0.1.0",
+          private: true,
+          type: "module",
+          scripts: {
+            dev: "glove foundry dev",
+            start: "glove foundry start",
+            lint: "eslint .",
+            typecheck: "tsc --noEmit"
+          },
+          dependencies: {
+            effect: "^3.22.1",
+            "glove-core": "^3.5.0",
+            "glove-foundry": "^0.1.0",
+            "glove-js": "^0.3.0",
+            "glove-mcp": "^1.0.1",
+            "glove-memory": "^1.0.2",
+            "glove-working-environment": "^0.5.0",
+            zod: "^4.3.6"
+          },
+          devDependencies: {
+            "@types/node": "^25.2.3",
+            eslint: "^9.39.2",
+            "typescript-eslint": "^8.54.0",
+            typescript: "^5.9.3"
+          }
+        },
+        null,
+        2
+      )}
+`
+    ],
+    [
+      "tsconfig.json",
+      `${JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ES2022",
+            lib: ["ES2022", "DOM"],
+            module: "ESNext",
+            moduleResolution: "Bundler",
+            strict: true,
+            noEmit: true,
+            skipLibCheck: true
+          },
+          include: ["agents", "src", "foundry.application.ts", "foundry.config.ts", ".foundry/routes.d.ts"]
+        },
+        null,
+        2
+      )}
+`
+    ],
+    [
+      "foundry.config.ts",
+      `import { defineConfig } from "glove-foundry/config";
+
+export default defineConfig({
+  server: { port: 4141 },
+  execution: {
+    pollIntervalMs: 100,
+    maxConcurrent: 4,
+  },
+});
+`
+    ],
+    [
+      "agents/assistant/composition.ts",
+      `import { composeAgent } from "glove-foundry";
+import notes from "./apps/notes.app.js";
+import requestContext from "./layers/request-context.layer.js";
+import notion from "./mcp/notion.mcp.js";
+import personalMemory from "./memory/personal.memory.js";
+import usage from "./subscribers/usage.subscriber.js";
+import currentTime from "./tools/current-time.tool.js";
+
+export const components = composeAgent(
+  notes,
+  requestContext,
+  notion,
+  personalMemory,
+  usage,
+  currentTime,
+);
+`
+    ],
+    [
+      "agents/assistant/agent.ts",
+      `import { MemoryStore } from "glove-core";
+import { createAdapter } from "glove-core/models/providers";
+import { defineAgent } from "glove-foundry";
+import { components } from "./composition.js";
+import { loadDefaultInbox } from "./inboxes/default.inbox.js";
+import requestContext from "./layers/request-context.layer.js";
+import personalMemory from "./memory/personal.memory.js";
+import usage from "./subscribers/usage.subscriber.js";
+import { assistantRepl, assistantWorkspace } from "./workbench.js";
+
+export default defineAgent({
+  description: "A general-purpose Glove assistant",
+  components,
+  memory: [personalMemory],
+  inboxes: (_agent, context) => loadDefaultInbox(context),
+  workingEnvironment: assistantWorkspace,
+  repl: (_agent, context) => assistantRepl(context.agentId, context.messageText),
+  store: ({ conversationId }) => new MemoryStore(\`foundry:\${conversationId}\`),
+  model: createAdapter({
+    provider: "openrouter",
+    model: process.env.OPENROUTER_MODEL ?? "openai/gpt-4.1-mini",
+    stream: true,
+  }),
+  systemPrompt: (_agent, { message, history }) =>
+    [
+      "You are a precise, practical assistant.",
+      \`Current request: \${message.text}\`,
+      \`Prior messages: \${history.length}\`,
+    ].join("\\n"),
+  compactionInstructions: () =>
+    "Preserve decisions, open work, and important context.",
+  compactionLimit: (_agent, { messageText }) =>
+    messageText.length > 2_000 ? 80_000 : 40_000,
+  layers: [requestContext],
+  subscribers: [usage],
+});
+`
+    ],
+    [
+      "agents/assistant/workbench.ts",
+      `import { JsSession, defineFn } from "glove-js";
+import { defineRepl, defineWorkingEnvironment } from "glove-foundry";
+import { z } from "zod";
+
+export const assistantWorkspace = defineWorkingEnvironment({
+  options: { limits: { maxVfsBytes: 32 * 1024 * 1024 } },
+});
+
+export function assistantRepl(actor: string, message: string) {
+  const session = JsSession.create({ actor });
+  session.register(defineFn({
+    name: "request__current",
+    description: "Read the current request inside the REPL",
+    input: z.object({}),
+    readOnlyHint: true,
+    handler: () => ({ text: message, length: message.length }),
+  }));
+  return defineRepl({ language: "javascript", session });
+}
+`
+    ],
+    [
+      "agents/assistant/layers/request-context.layer.ts",
+      `import { Effect } from "effect";
+import { defineLayer } from "glove-foundry";
+
+const requestContext = defineLayer({
+  description: "Expose Foundry request identity as a native Glove skill",
+  setup: ({ glove, agentId, runId, message, history }) => Effect.sync(() => {
+    glove.defineSkill({
+      name: "request-context",
+      description: "Read the current Foundry agent and run ids",
+      exposeToAgent: true,
+      async handler() { return \`agent=\${agentId} run=\${runId} message=\${message.text} prior=\${history.length}\`; },
+    });
+  }),
+});
+
+export default requestContext;
+`
+    ],
+    [
+      "agents/assistant/subscribers/usage.subscriber.ts",
+      `import { defineSubscriber } from "glove-foundry";
+
+const usage = defineSubscriber({
+  description: "Observe token consumption without changing the agent",
+  create: {
+    async record(type, data) {
+      if (type === "token_consumption") console.log("[tokens]", data);
+    },
+  },
+});
+
+export default usage;
+`
+    ],
+    [
+      "foundry.application.ts",
+      `import { MemoryFoundryDataAdapter, defineApplication } from "glove-foundry";
+
+export const data = new MemoryFoundryDataAdapter();
+
+export default defineApplication({
+  name: "${projectName}",
+  data,
+  accounts: [],
+  routes: [],
+  bindings: [],
+});
+`
+    ],
+    [
+      "agents/assistant/tools/current-time.tool.ts",
+      `import { defineSharedTool } from "glove-foundry";
+import { z } from "zod";
+
+const currentTime = defineSharedTool({
+  description: "Return the current ISO timestamp",
+  tool: {
+    name: "current_time",
+  description: "Return the current ISO timestamp",
+  inputSchema: z.object({}),
+  async do() {
+    return { status: "success", data: new Date().toISOString() };
+  },
+  },
+});
+
+export default currentTime;
+`
+    ],
+    [
+      "agents/assistant/apps/notes.app.ts",
+      `import { Effect } from "effect";
+import { defineApp } from "glove-foundry";
+import { z } from "zod";
+
+const notes = defineApp({
+  description: "An example application installed only when selected",
+  config: z.object({ namespace: z.string().default("default") }),
+  inbound: [],
+  outbound: [],
+  install: ({ config }) => Effect.sync(() => {
+    return { tools: [{
+      name: "notes_namespace",
+      description: "Return the installed notes namespace",
+      inputSchema: z.object({}),
+      async do() { return { status: "success", data: config.namespace }; },
+    }] };
+  }),
+});
+
+export default notes;
+`
+    ],
+    [
+      "agents/assistant/inboxes/default.inbox.ts",
+      `import type { InboxItem } from "glove-core";
+import type { AgentAssemblyContext } from "glove-foundry";
+
+export async function loadDefaultInbox(
+  context: AgentAssemblyContext,
+): Promise<ReadonlyArray<InboxItem>> {
+  // Load this conversation's inbox from your own adapter or service.
+  void \`\${context.agentId}:\${context.conversationId}\`;
+  return [];
+}
+`
+    ],
+    [
+      "agents/assistant/mcp/notion.mcp.ts",
+      `import { defineMcp } from "glove-foundry";
+
+// This remains disconnected until an agent instance installs it.
+const notion = defineMcp({
+  entry: {
+    name: "Notion",
+    description: "Search and update a Notion workspace",
+    url: "https://mcp.notion.com/mcp",
+    tags: ["notes", "workspace"],
+  },
+});
+
+export default notion;
+`
+    ],
+    [
+      "agents/assistant/memory/personal.memory.ts",
+      `import { Effect } from "effect";
+import { defineMemory } from "glove-foundry";
+import { MemorySchema } from "glove-memory/core";
+import { InMemoryContextAdapter } from "glove-memory/in-memory";
+
+const schema = new MemorySchema();
+const context = new InMemoryContextAdapter({ schema });
+
+const personalMemory = defineMemory({
+  description: "Ambient user context backed by a replaceable memory adapter",
+  context: { adapter: () => Effect.succeed(context) },
+});
+
+export default personalMemory;
+`
+    ],
+    [
+      "src/client.ts",
+      `import { createFoundryClient } from "glove-foundry/client";
+import type { FoundryRoutes } from "../.foundry/routes.js";
+
+export const foundry = createFoundryClient<FoundryRoutes>();
+
+const agent = await foundry.agent("assistant").create({ workspaceId: "default" });
+const conversation = await foundry.createConversation(agent.id);
+const run = await foundry.send(agent.id, conversation.id, "Hello");
+const completed = await run.wait();
+console.log(completed.output);
+`
+    ],
+    [
+      ".foundry/routes.d.ts",
+      `// Generated by Glove Foundry. Do not edit.
+export type FoundryRoutes = {
+  readonly "assistant": typeof import("../agents/assistant/agent.js").default;
+};
+`
+    ],
+    [".env.example", "OPENROUTER_API_KEY=\nOPENROUTER_MODEL=openai/gpt-4.1-mini\n"],
+    [
+      "eslint.config.js",
+      `import tseslint from "typescript-eslint";
+import foundry from "glove-foundry/eslint";
+
+export default [...tseslint.configs.recommended, foundry];
+`
+    ],
+    [".gitignore", "node_modules\n.env.local\n.foundry/manifest.json\n"],
+    [
+      "README.md",
+      `# ${projectName}
+
+A file-routed Glove Foundry application.
+
+1. Copy \`.env.example\` to \`.env.local\` and add your API key.
+2. Install dependencies with \`pnpm install\`.
+3. Run \`pnpm dev\`.
+4. Open http://127.0.0.1:4141.
+
+Add agents under \`agents/<route>/agent.ts\`; the file path is the route. Keep that agent's applications, transmissions, tools, MCPs, memory, inboxes, layers, subscribers, and workbench beside it, then combine reusable capabilities with \`composeAgent\`. Code-authored references use imported definition values; Foundry normalizes them to ids only when instance data is persisted. Applications and MCPs remain inert until an agent instance installs them. The scaffold mounts a sandboxed VFS/script environment and a request-aware JavaScript REPL; change or remove them in \`workbench.ts\`. Agents create future and recurring work only through Foundry's scheduling and sleep tools.
+`
+    ]
+  ]);
+  for (const [relativePath, content] of files) {
+    const path = resolve(rootDir, relativePath);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, { encoding: "utf8", flag: "wx" });
+  }
+  return { rootDir, files: [...files.keys()] };
+}
+
+// src/cli.ts
+var HELP = `Glove Foundry \u2014 a file-routed runtime for agents
+
+Usage:
+  glove foundry [directory]       Create a Foundry application
+  glove foundry dev [options]     Run the development runtime and DevTools
+  glove foundry start [options]   Run without file watching
+  glove-foundry init [directory]  Create a Foundry application
+  glove-foundry dev [options]     Run the development runtime and DevTools
+  glove-foundry start [options]   Run without file watching
+
+Options:
+  --root <directory>              Project root (default: current directory)
+  --port <number>                 Override the configured port
+  --host <address>                Override the configured host
+  --no-watch                      Disable agent/config hot restart
+`;
+function parseArgs(raw) {
+  const args = [...raw];
+  const gloveSyntax = args[0] === "foundry";
+  if (gloveSyntax) args.shift();
+  const command = args[0];
+  const positional = [];
+  const flags = {};
+  for (let index = 1; index < args.length; index++) {
+    const value = args[index];
+    if (value.startsWith("--")) {
+      const name = value.slice(2);
+      const next = args[index + 1];
+      if (next && !next.startsWith("--")) {
+        flags[name] = next;
+        index++;
+      } else {
+        flags[name] = true;
+      }
+    } else {
+      positional.push(value);
+    }
+  }
+  return { command, positional, flags, gloveSyntax };
+}
+async function pathExists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadConfig(rootDir) {
+  const candidates = ["foundry.config.ts", "foundry.config.mts", "foundry.config.js", "foundry.config.mjs"];
+  for (const candidate of candidates) {
+    const path = resolve2(rootDir, candidate);
+    if (!await pathExists(path)) continue;
+    const url = pathToFileURL(path);
+    url.searchParams.set("t", String(Date.now()));
+    const imported = await import(url.href);
+    if (!imported.default) {
+      throw new Error(`${candidate} must have a default export.`);
+    }
+    return imported.default;
+  }
+  return {};
+}
+async function loadApplication(rootDir, config) {
+  const relativePath = config.applicationFile ?? DEFAULT_FOUNDRY_CONFIG.applicationFile;
+  const path = resolve2(rootDir, relativePath);
+  if (!await pathExists(path)) return EMPTY_FOUNDRY_APPLICATION;
+  const url = pathToFileURL(path);
+  url.searchParams.set("t", String(Date.now()));
+  const imported = await import(url.href);
+  if (!isFoundryApplication(imported.default)) {
+    throw new Error(`${relativePath} must default-export defineApplication(...).`);
+  }
+  return imported.default;
+}
+async function runWorker(parsed) {
+  const rootDir = resolve2(
+    typeof parsed.flags.root === "string" ? parsed.flags.root : process2.cwd()
+  );
+  await loadEnvFile(resolve2(rootDir, ".env"));
+  await loadEnvFile(resolve2(rootDir, ".env.local"));
+  const config = await loadConfig(rootDir);
+  const application = await loadApplication(rootDir, config);
+  const applicationFilePath = resolve2(
+    rootDir,
+    config.applicationFile ?? DEFAULT_FOUNDRY_CONFIG.applicationFile
+  );
+  const agentsDir = resolve2(
+    rootDir,
+    config.agentsDir ?? DEFAULT_FOUNDRY_CONFIG.agentsDir
+  );
+  const runtime = await FoundryRuntime.discover({
+    rootDir,
+    agentsDir,
+    application,
+    ...await pathExists(applicationFilePath) ? { applicationFilePath } : {},
+    config
+  });
+  await writeGeneratedTypes({
+    rootDir,
+    agents: runtime.agents,
+    manifest: runtime.manifest
+  });
+  await runtime.start();
+  const server = new FoundryServer(runtime, {
+    host: typeof parsed.flags.host === "string" ? parsed.flags.host : config.server?.host ?? DEFAULT_FOUNDRY_CONFIG.server.host,
+    port: typeof parsed.flags.port === "string" ? Number(parsed.flags.port) : config.server?.port ?? DEFAULT_FOUNDRY_CONFIG.server.port
+  });
+  const listening = await server.listen();
+  await runtime.health();
+  process2.stdout.write(`
+  Glove Foundry
+
+`);
+  process2.stdout.write(`  Local:    ${listening.url}
+`);
+  process2.stdout.write(`  Agents:   ${runtime.agents.length}
+`);
+  process2.stdout.write(`  Runtime:  ready
+`);
+  process2.stdout.write(`  Types:    .foundry/routes.d.ts
+
+`);
+  let closing = false;
+  const close = async () => {
+    if (closing) return;
+    closing = true;
+    await server.close();
+    await runtime.stop();
+  };
+  process2.once("SIGTERM", () => void close());
+  process2.once("SIGINT", () => void close());
+}
+function shouldRestart(rootDir, changed) {
+  if (!changed) return false;
+  const normalized = relative(rootDir, resolve2(rootDir, changed)).split(sep).join("/");
+  return normalized.startsWith("agents/") || normalized === ".env" || normalized === ".env.local" || /^foundry\.application\.(?:ts|mts|js|mjs)$/.test(normalized) || /^foundry\.config\.(?:ts|mts|js|mjs)$/.test(normalized);
+}
+async function superviseDev(parsed) {
+  const rootDir = resolve2(
+    typeof parsed.flags.root === "string" ? parsed.flags.root : process2.cwd()
+  );
+  const cliPath = fileURLToPath(import.meta.url);
+  const tsxImport = import.meta.resolve("tsx");
+  let child = null;
+  const watchers = [];
+  let restarting = false;
+  let stopping = false;
+  let debounce = null;
+  const workerArgs = [
+    "--import",
+    tsxImport,
+    cliPath,
+    "__dev-worker",
+    "--root",
+    rootDir,
+    ...typeof parsed.flags.port === "string" ? ["--port", parsed.flags.port] : [],
+    ...typeof parsed.flags.host === "string" ? ["--host", parsed.flags.host] : []
+  ];
+  const start = () => {
+    child = spawn(process2.execPath, workerArgs, {
+      cwd: rootDir,
+      env: process2.env,
+      stdio: "inherit"
+    });
+    child.once("exit", (code) => {
+      child = null;
+      if (!stopping && !restarting && code !== 0) {
+        process2.stderr.write(`Foundry worker exited with code ${code ?? "unknown"}.
+`);
+      }
+    });
+  };
+  const restart = () => {
+    if (stopping || restarting) return;
+    restarting = true;
+    process2.stdout.write("\n  Change detected \u2014 restarting Foundry\u2026\n");
+    const old = child;
+    if (!old) {
+      restarting = false;
+      start();
+      return;
+    }
+    old.once("exit", () => {
+      restarting = false;
+      if (!stopping) start();
+    });
+    old.kill("SIGTERM");
+  };
+  start();
+  if (!parsed.flags["no-watch"]) {
+    try {
+      const onChange = (filename) => {
+        if (!shouldRestart(rootDir, filename?.toString() ?? null)) return;
+        if (debounce) clearTimeout(debounce);
+        debounce = setTimeout(restart, 120);
+      };
+      watchers.push(
+        watch(
+          rootDir,
+          { recursive: false },
+          (_event, filename) => onChange(filename?.toString() ?? null)
+        )
+      );
+      const defaultAgentsDir = resolve2(rootDir, "agents");
+      if (await pathExists(defaultAgentsDir)) {
+        watchers.push(
+          watch(
+            defaultAgentsDir,
+            { recursive: true },
+            (_event, filename) => onChange(
+              filename ? `agents/${filename.toString()}` : "agents"
+            )
+          )
+        );
+      }
+      for (const directory of [
+        "tools",
+        "applications",
+        "mcp",
+        "memory",
+        "inboxes"
+      ]) {
+        const watched = resolve2(rootDir, directory);
+        if (await pathExists(watched)) {
+          watchers.push(
+            watch(
+              watched,
+              { recursive: true },
+              (_event, filename) => onChange(
+                filename ? `${directory}/${filename.toString()}` : directory
+              )
+            )
+          );
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process2.stderr.write(`Foundry file watching is unavailable: ${message}
+`);
+    }
+  }
+  const stop = () => {
+    if (stopping) return;
+    stopping = true;
+    for (const watcher of watchers) watcher.close();
+    if (debounce) clearTimeout(debounce);
+    child?.kill("SIGTERM");
+  };
+  process2.once("SIGINT", stop);
+  process2.once("SIGTERM", stop);
+}
+async function superviseStart(parsed) {
+  const rootDir = resolve2(
+    typeof parsed.flags.root === "string" ? parsed.flags.root : process2.cwd()
+  );
+  const child = spawn(
+    process2.execPath,
+    [
+      "--import",
+      import.meta.resolve("tsx"),
+      fileURLToPath(import.meta.url),
+      "__start-worker",
+      "--root",
+      rootDir,
+      ...typeof parsed.flags.port === "string" ? ["--port", parsed.flags.port] : [],
+      ...typeof parsed.flags.host === "string" ? ["--host", parsed.flags.host] : []
+    ],
+    {
+      cwd: rootDir,
+      env: process2.env,
+      stdio: "inherit"
+    }
+  );
+  const forwardSignal = (signal) => {
+    if (!child.killed) child.kill(signal);
+  };
+  const interrupt = () => forwardSignal("SIGINT");
+  const terminate = () => forwardSignal("SIGTERM");
+  process2.once("SIGINT", interrupt);
+  process2.once("SIGTERM", terminate);
+  const exitCode = await new Promise((resolveExit, rejectExit) => {
+    child.once("error", rejectExit);
+    child.once("exit", resolveExit);
+  });
+  process2.removeListener("SIGINT", interrupt);
+  process2.removeListener("SIGTERM", terminate);
+  if (exitCode !== 0 && exitCode !== null) {
+    throw new Error(`Foundry worker exited with code ${exitCode}.`);
+  }
+}
+async function main() {
+  const parsed = parseArgs(process2.argv.slice(2));
+  if (parsed.command === "__dev-worker" || parsed.command === "__start-worker") {
+    await runWorker(parsed);
+    return;
+  }
+  if (["help", "--help", "-h"].includes(parsed.command ?? "")) {
+    process2.stdout.write(HELP);
+    return;
+  }
+  const createByGloveSyntax = parsed.gloveSyntax && parsed.command !== "dev" && parsed.command !== "start";
+  if (parsed.command === "init" || createByGloveSyntax || parsed.gloveSyntax && !parsed.command) {
+    const directory = parsed.command === "init" ? parsed.positional[0] ?? "glove-foundry-app" : parsed.command ?? "glove-foundry-app";
+    const result = await scaffoldFoundryProject({ directory });
+    process2.stdout.write(`Created Glove Foundry in ${result.rootDir}
+
+`);
+    process2.stdout.write(`  cd ${relative(process2.cwd(), result.rootDir) || "."}
+`);
+    process2.stdout.write(`  cp .env.example .env.local
+`);
+    process2.stdout.write(`  pnpm install
+`);
+    process2.stdout.write(`  pnpm dev
+`);
+    return;
+  }
+  if (parsed.command === "dev") {
+    await superviseDev(parsed);
+    return;
+  }
+  if (parsed.command === "start") {
+    await superviseStart(parsed);
+    return;
+  }
+  process2.stdout.write(HELP);
+}
+main().catch((error) => {
+  process2.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}
+`);
+  process2.exitCode = 1;
+});