@usegraft/cli 0.1.0

package/dist/chunk-LTFTDG6Z.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-BUPFXTUG.js";
+
+// src/commands/migrate.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { basename, join } from "path";
+import { GraftError } from "@usegraft/contracts";
+import {
+  runContentMigration
+} from "@usegraft/content-migrations";
+import { runDataMigration } from "@usegraft/core";
+import { createJiti } from "jiti";
+async function discoverMigrations(migrationsDir) {
+  if (!existsSync(migrationsDir) || !statSync(migrationsDir).isDirectory()) return [];
+  const files = readdirSync(migrationsDir).filter((name) => /\.(ts|mts|js|mjs)$/.test(name)).sort().map((name) => join(migrationsDir, name));
+  const jiti = createJiti(migrationsDir, { moduleCache: false });
+  const discovered = [];
+  for (const file of files) {
+    const id = basename(file).replace(/\.(ts|mts|js|mjs)$/, "");
+    let mod;
+    try {
+      mod = await jiti.import(file);
+    } catch (error) {
+      throw new GraftError({
+        code: "MIGRATION_FAILED",
+        message: `Migration file ${basename(file)} failed to load: ${error instanceof Error ? error.message : String(error)}`,
+        fix: "Fix the error in the file \u2014 it must be importable and default-export defineContentMigration(\u2026) or defineDataMigration(\u2026).",
+        details: { file }
+      });
+    }
+    const migration = mod.default;
+    if (!migration || migration.kind !== "content" && migration.kind !== "data" || typeof migration.transform !== "function") {
+      throw new GraftError({
+        code: "MIGRATION_FAILED",
+        message: `${basename(file)} does not default-export a migration.`,
+        fix: `Add \`export default defineContentMigration({ \u2026 })\` (from "@usegraft/content-migrations") or \`export default defineDataMigration({ \u2026 })\` (from "@usegraft/core").`,
+        details: { file, exports: Object.keys(mod) }
+      });
+    }
+    discovered.push({ id, file, migration });
+  }
+  return discovered;
+}
+async function migrateCommand(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  const branchId = options.branchId ?? "main";
+  const migrations = await discoverMigrations(config.migrationsDir);
+  if (migrations.length === 0) {
+    console.log(
+      `No migrations found in ${config.migrationsDir}.
+Author one as migrations/0001-<name>.ts default-exporting defineContentMigration or defineDataMigration.`
+    );
+    return { applied: [], pending: [], didApply: false };
+  }
+  const url = requireDatabaseUrl();
+  const [
+    { compile, resolveGitSha },
+    {
+      createDb,
+      listAppliedMigrations,
+      recordAppliedMigration,
+      resolveBranchHandle,
+      scopeWriteBranch
+    }
+  ] = await Promise.all([import("@usegraft/compiler"), import("@usegraft/db")]);
+  const control = createDb(url);
+  const branch = await resolveBranchHandle(control.db, branchId, { databaseUrl: url });
+  const writeBranch = scopeWriteBranch(branch.scope);
+  try {
+    const appliedRows = await listAppliedMigrations(branch.db, writeBranch);
+    const appliedIds = new Set(appliedRows.map((row) => row.migrationId));
+    const applied = migrations.filter((m) => appliedIds.has(m.id)).map((m) => m.id);
+    const pending = migrations.filter((m) => !appliedIds.has(m.id));
+    if (applied.length > 0) {
+      console.log(`Already applied on "${branchId}": ${applied.join(", ")}`);
+    }
+    if (pending.length === 0) {
+      console.log("Nothing pending \u2014 the branch is up to date.");
+      return { applied, pending: [], didApply: false };
+    }
+    const gitSha = resolveGitSha(config.projectDir);
+    const outcomes = [];
+    for (const { id, migration } of pending) {
+      const label = `${id} [${migration.kind}] ${migration.collection.name} \u2014 ${migration.description}`;
+      if (migration.kind === "content") {
+        const report = await runContentMigration({
+          contentDir: config.contentDir,
+          migration,
+          apply: options.apply
+        });
+        if (options.apply) {
+          const compiled = await compile({
+            db: branch.db,
+            contentDir: config.contentDir,
+            collections: config.collections,
+            branchId: writeBranch,
+            gitSha
+          });
+          await recordAppliedMigration(branch.db, {
+            branchId: writeBranch,
+            migrationId: id,
+            kind: "content",
+            collection: migration.collection.name,
+            docCount: report.changed,
+            gitSha
+          });
+          console.log(
+            `applied ${label}
+  ${report.changed} file(s) rewritten, ${report.unchanged} unchanged; compiled: +${compiled.changes.added.length} ~${compiled.changes.changed.length} -${compiled.changes.removed.length}`
+          );
+        } else {
+          console.log(
+            `pending ${label}
+  would rewrite ${report.changed} file(s) (${report.unchanged} unchanged)`
+          );
+        }
+        outcomes.push({
+          id,
+          kind: "content",
+          collection: migration.collection.name,
+          description: migration.description,
+          report
+        });
+      } else {
+        const report = await runDataMigration({
+          db: branch.db,
+          migration,
+          migrationId: id,
+          branchId: writeBranch,
+          gitSha,
+          apply: options.apply
+        });
+        console.log(
+          options.apply ? `applied ${label}
+  ${report.changed} row(s) updated, ${report.unchanged} unchanged` : `pending ${label}
+  would update ${report.changed} of ${report.rows} row(s)`
+        );
+        outcomes.push({
+          id,
+          kind: "data",
+          collection: migration.collection.name,
+          description: migration.description,
+          report
+        });
+      }
+    }
+    if (!options.apply) {
+      console.log(`
+Dry run \u2014 nothing was written. Run \`graft migrate --apply\` to execute.`);
+    } else {
+      console.log(
+        `
+${outcomes.length} migration(s) applied. Commit the changes \u2014 git is the version history.`
+      );
+    }
+    return { applied, pending: outcomes, didApply: options.apply === true };
+  } finally {
+    await branch.close();
+    await control.close();
+  }
+}
+
+export {
+  discoverMigrations,
+  migrateCommand
+};

package/dist/chunk-TUWL7WFD.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-BUPFXTUG.js";
+
+// src/commands/serve.ts
+import { execFileSync } from "child_process";
+import { createServer } from "http";
+import { createActorResolver } from "@usegraft/auth";
+import { GraftError } from "@usegraft/contracts";
+function createServeRouter(routes) {
+  return async (request) => {
+    const { pathname } = new URL(request.url);
+    if (pathname === "/healthz") return routes.health(request);
+    if (pathname === "/api/mcp") return routes.mcp(request);
+    if (pathname === "/api/fn" || pathname.startsWith("/api/fn/")) return routes.fn(request);
+    if (routes.studio && (pathname === "/studio" || pathname.startsWith("/studio/") || pathname.startsWith("/api/studio/"))) {
+      return routes.studio(request);
+    }
+    const studioHint = routes.studio ? ", GET /studio (opt-in Studio)" : " \u2014 or pass --studio / GRAFT_STUDIO=1 for the opt-in Studio UI";
+    const error = new GraftError({
+      code: "ROUTE_NOT_FOUND",
+      message: `Nothing is mounted at ${pathname}.`,
+      fix: `Use POST /api/fn/<name> (typed functions), POST /api/mcp (MCP Streamable HTTP), or GET /healthz${studioHint}.`,
+      details: { pathname }
+    });
+    return new Response(JSON.stringify(error.toJSON()), {
+      status: 404,
+      headers: { "content-type": "application/json" }
+    });
+  };
+}
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "content-length",
+  "upgrade",
+  "proxy-connection"
+]);
+function createNodeListener(handler) {
+  return async (req, res) => {
+    try {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      const body = Buffer.concat(chunks);
+      const headers = new Headers();
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value === void 0 || HOP_BY_HOP.has(key)) continue;
+        if (Array.isArray(value)) for (const v of value) headers.append(key, v);
+        else headers.set(key, value);
+      }
+      const method = req.method ?? "GET";
+      const request = new Request(`http://${req.headers.host ?? "localhost"}${req.url ?? "/"}`, {
+        method,
+        headers,
+        body: method === "GET" || method === "HEAD" || body.length === 0 ? void 0 : body
+      });
+      const response = await handler(request);
+      const outHeaders = {};
+      response.headers.forEach((value, key) => {
+        if (!HOP_BY_HOP.has(key)) outHeaders[key] = value;
+      });
+      res.writeHead(response.status, outHeaders);
+      res.end(Buffer.from(await response.arrayBuffer()));
+    } catch (error) {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "FUNCTION_EXECUTION_FAILED",
+          message: `graft serve failed to relay the request: ${error instanceof Error ? error.message : String(error)}`,
+          fix: "Check the server logs; if this reproduces, file it \u2014 the adapter should never throw."
+        })
+      );
+    }
+  };
+}
+function localGitSha(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function trustedIssuersFromEnv() {
+  return (process.env.GRAFT_TRUSTED_ISSUERS ?? "").split(/[,\s]+/).map((issuer) => issuer.trim()).filter(Boolean).map((issuer) => ({ issuer }));
+}
+async function startServe(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  const url = requireDatabaseUrl();
+  const enableStudio = options.studio === true || process.env.GRAFT_STUDIO === "1";
+  const [
+    { createFunctionsHandler },
+    { createGraftMcpHandler },
+    { createDb, resolveBranchHandle, scopeWriteBranch, sql },
+    studioMod
+  ] = await Promise.all([
+    import("@usegraft/core"),
+    import("@usegraft/mcp"),
+    import("@usegraft/db"),
+    enableStudio ? import("@usegraft/studio") : Promise.resolve(null)
+  ]);
+  const control = createDb(url);
+  const branchName = options.branchId ?? "main";
+  const branch = await resolveBranchHandle(control.db, branchName, { databaseUrl: url });
+  const writeBranch = scopeWriteBranch(branch.scope);
+  const devToken = process.env.GRAFT_DEV_TOKEN;
+  const scopes = (process.env.GRAFT_DEV_SCOPES ?? "").split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+  const issuers = trustedIssuersFromEnv();
+  const resolveActor = createActorResolver({
+    issuers,
+    devTokens: devToken ? { [devToken]: { kind: "agent", id: "graft-serve", scopes } } : void 0
+  });
+  const approvalPolicy = process.env.GRAFT_APPROVAL_POLICY === "human" ? "human" : "none";
+  const requireMcpActor = process.env.GRAFT_MCP_REQUIRE_AUTH === "1";
+  const functions = config.functions ?? {};
+  const gitSha = localGitSha(options.cwd);
+  const fnHandler = createFunctionsHandler({
+    functions,
+    db: branch.db,
+    branch: writeBranch,
+    actor: resolveActor,
+    approvalPolicy,
+    // Backstop; per-function rateLimit overrides it.
+    rateLimit: { limit: 60, windowSeconds: 60 },
+    gitSha
+  });
+  const mcpHandler = createGraftMcpHandler({
+    name: "graft-serve",
+    contentDir: config.contentDir,
+    collections: config.collections,
+    functions,
+    db: branch.db,
+    branchId: writeBranch,
+    scope: branch.scope,
+    actor: resolveActor,
+    requireActor: requireMcpActor
+  });
+  const health = async () => {
+    try {
+      await branch.db.execute(sql`select 1`);
+    } catch (error) {
+      return new Response(
+        JSON.stringify({
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }),
+        { status: 503, headers: { "content-type": "application/json" } }
+      );
+    }
+    return new Response(
+      JSON.stringify({
+        ok: true,
+        branch: branchName,
+        collections: Object.keys(config.collections).length,
+        functions: Object.keys(functions).length,
+        gitSha: gitSha ?? null
+      }),
+      { status: 200, headers: { "content-type": "application/json" } }
+    );
+  };
+  const host = options.host ?? process.env.HOST ?? "127.0.0.1";
+  const requestedPort = options.port ?? Number(process.env.PORT ?? 3903);
+  if (!Number.isInteger(requestedPort) || requestedPort < 0 || requestedPort > 65535) {
+    await branch.close();
+    await control.close();
+    throw new GraftError({
+      code: "INPUT_VALIDATION_FAILED",
+      message: `"${options.port ?? process.env.PORT}" is not a valid port.`,
+      fix: "Pass --port <0-65535> (0 picks a free port) or set PORT."
+    });
+  }
+  const loopback = host === "127.0.0.1" || host === "localhost" || host === "::1";
+  if (!loopback && !requireMcpActor && issuers.length === 0 && !devToken) {
+    console.warn(
+      "[graft serve] WARNING: binding beyond loopback with no identity configured \u2014 set GRAFT_MCP_REQUIRE_AUTH=1 and provide GRAFT_DEV_TOKEN or GRAFT_TRUSTED_ISSUERS before exposing this to a network."
+    );
+  }
+  let studioHandler;
+  if (studioMod) {
+    const authorize = !loopback && (devToken || issuers.length > 0) ? async (request) => {
+      const actor = await resolveActor(request);
+      return actor.kind !== "anonymous";
+    } : !loopback ? () => false : void 0;
+    studioHandler = studioMod.createStudioHandler({
+      db: branch.db,
+      collections: config.collections,
+      contentDir: config.contentDir,
+      defaultBranch: writeBranch,
+      decidedBy: "studio-serve",
+      uiBasePath: "/studio",
+      authorize
+    });
+  }
+  const server = createServer(
+    createNodeListener(
+      createServeRouter({ fn: fnHandler, mcp: mcpHandler, health, studio: studioHandler })
+    )
+  );
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(requestedPort, host, () => resolve());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : requestedPort;
+  return {
+    port,
+    host,
+    branch: branchName,
+    close: async () => {
+      await new Promise((resolve, reject) => {
+        server.close((err) => err ? reject(err) : resolve());
+      });
+      await branch.close();
+      await control.close();
+    }
+  };
+}
+async function serveCommand(options) {
+  const running = await startServe(options);
+  const base = `http://${running.host}:${running.port}`;
+  const studioOn = options.studio === true || process.env.GRAFT_STUDIO === "1";
+  console.log(
+    [
+      `graft serve \u2014 branch "${running.branch}"`,
+      `  functions  POST ${base}/api/fn/<name>`,
+      `  mcp        POST ${base}/api/mcp`,
+      `  health     GET  ${base}/healthz`,
+      ...studioOn ? [
+        `  studio     GET  ${base}/studio`,
+        `  openapi    GET  ${base}/api/studio/v1/openapi.json`
+      ] : []
+    ].join("\n")
+  );
+  await new Promise((resolve) => {
+    const stop = () => resolve();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  await running.close();
+}
+
+export {
+  createServeRouter,
+  createNodeListener,
+  startServe,
+  serveCommand
+};

package/dist/compilations-6P45MPAE.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import {
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-BUPFXTUG.js";
+
+// src/commands/compilations.ts
+async function compilationsListCommand(options) {
+  loadProjectEnv(options.cwd);
+  const url = requireDatabaseUrl();
+  const { createDb, listCompilations } = await import("@usegraft/db");
+  const handle = createDb(url);
+  try {
+    return await listCompilations(handle.db, {
+      branchId: options.branchId,
+      limit: options.limit
+    });
+  } finally {
+    await handle.close();
+  }
+}
+function formatCompilation(row) {
+  const sha = row.gitSha ? row.gitSha.slice(0, 7) : "no-sha";
+  return `${row.createdAt.toISOString()}  ${row.branchId}  ${sha}  docs=${row.docCount}  +${row.added} ~${row.changed} -${row.removed}  ${row.id}`;
+}
+export {
+  compilationsListCommand,
+  formatCompilation
+};

package/dist/compile-AAUC4G7H.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  assertNoStaticBranch,
+  compileCommand
+} from "./chunk-KZ3FDWUK.js";
+import "./chunk-GPA66AP5.js";
+import "./chunk-BUPFXTUG.js";
+export {
+  assertNoStaticBranch,
+  compileCommand
+};

package/dist/content-DY2YI3LT.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-BUPFXTUG.js";
+
+// src/commands/content.ts
+async function contentListCommand(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  const url = requireDatabaseUrl();
+  const { createDb, readContent, resolveBranchScope } = await import("@usegraft/db");
+  const handle = createDb(url);
+  const branch = options.branchId ?? "main";
+  try {
+    const scope = await resolveBranchScope(handle.db, branch);
+    const lines = [];
+    for (const name of Object.keys(config.collections).sort()) {
+      const rows = await readContent(handle.db, scope, { collection: name });
+      for (const row of rows) {
+        const title = typeof row.data.title === "string" ? row.data.title : typeof row.data.name === "string" ? row.data.name : void 0;
+        lines.push({
+          collection: name,
+          slug: row.slug,
+          sourcePath: row.sourcePath,
+          ...title ? { title } : {}
+        });
+      }
+    }
+    return { branch, lines };
+  } finally {
+    await handle.close();
+  }
+}
+function formatContentLine(line) {
+  const label = line.title ? `${line.slug}  (${line.title})` : line.slug;
+  return `${line.collection}/${label}  ${line.sourcePath}`;
+}
+export {
+  contentListCommand,
+  formatContentLine
+};

package/dist/db-VGDWG4QA.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import {
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-BUPFXTUG.js";
+
+// src/commands/db.ts
+import { GraftError } from "@usegraft/contracts";
+async function dbMigrateCommand(options) {
+  loadProjectEnv(options.cwd);
+  const config = await loadConfig(findConfig(options.cwd));
+  if (config.index.driver === "static") {
+    throw new GraftError({
+      code: "NEEDS_DATABASE",
+      message: "This project's content index is static (a SQLite artifact), so there is no database schema to migrate.",
+      fix: 'Static projects need no migrations \u2014 just `graft compile`. To move to the Postgres tier: set `export const index = "postgres"` in graft.config.ts and DATABASE_URL in .env, then re-run `graft db migrate` followed by `graft compile`.',
+      details: { index: config.index.driver }
+    });
+  }
+  const url = requireDatabaseUrl();
+  const { runMigrations } = await import("@usegraft/db");
+  return runMigrations(url, { dryRun: options.dryRun });
+}
+function formatMigrateResult(result) {
+  if (result.dryRun) {
+    return result.pending.length === 0 ? "Schema is up to date \u2014 no migrations pending." : [
+      `${result.pending.length} migration(s) pending:`,
+      ...result.pending.map((tag) => `  ${tag}`),
+      "",
+      "Run `graft db migrate` (without --dry-run) to apply them."
+    ].join("\n");
+  }
+  if (result.applied.length === 0) {
+    return "Schema is up to date \u2014 nothing to apply.";
+  }
+  return [
+    `Applied ${result.applied.length} migration(s):`,
+    ...result.applied.map((tag) => `  ${tag}`),
+    "",
+    "Next: `graft compile` to project your content into the index."
+  ].join("\n");
+}
+export {
+  dbMigrateCommand,
+  formatMigrateResult
+};

package/dist/dev-MX7TQOJ2.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import {
+  assertNoStaticBranch
+} from "./chunk-KZ3FDWUK.js";
+import {
+  formatCompileResult,
+  printGraftError
+} from "./chunk-GPA66AP5.js";
+import {
+  CONFIG_FILENAMES,
+  findConfig,
+  loadConfig,
+  loadProjectEnv,
+  requireDatabaseUrl
+} from "./chunk-BUPFXTUG.js";
+
+// src/commands/dev.ts
+import { existsSync, watch } from "fs";
+import { basename, relative } from "path";
+import { GraftError } from "@usegraft/contracts";
+var DEBOUNCE_MS = 150;
+async function devCommand(options) {
+  loadProjectEnv(options.cwd);
+  const configPath = findConfig(options.cwd);
+  let config = await loadConfig(configPath);
+  if (!existsSync(config.contentDir)) {
+    throw new GraftError({
+      code: "CONTENT_DIR_NOT_FOUND",
+      message: `Content directory ${config.contentDir} does not exist.`,
+      fix: "Create it (documents live at <contentDir>/<collection>/<slug>.mdx) or fix the `contentDir` export in graft.config.ts, then restart `graft dev`."
+    });
+  }
+  const isStatic = config.index.driver === "static";
+  if (isStatic) assertNoStaticBranch(options.branchId);
+  const url = isStatic ? void 0 : requireDatabaseUrl();
+  const [compiler, { createDb, resolveBranchHandle, scopeWriteBranch }] = await Promise.all([
+    import("@usegraft/compiler"),
+    import("@usegraft/db")
+  ]);
+  const { compile, compileStatic } = compiler;
+  const control = url !== void 0 ? createDb(url) : void 0;
+  const branch = control !== void 0 && url !== void 0 ? await resolveBranchHandle(control.db, options.branchId ?? "main", { databaseUrl: url }) : void 0;
+  const writeBranch = branch !== void 0 ? scopeWriteBranch(branch.scope) : "main";
+  let timer;
+  let compiling = false;
+  let dirty = false;
+  let configDirty = false;
+  const runCompile = async () => {
+    if (compiling) {
+      dirty = true;
+      return;
+    }
+    compiling = true;
+    try {
+      if (configDirty) {
+        configDirty = false;
+        config = await loadConfig(configPath);
+        console.log(`reloaded ${basename(configPath)}`);
+      }
+      const result = branch !== void 0 ? await compile({
+        db: branch.db,
+        contentDir: config.contentDir,
+        collections: config.collections,
+        branchId: writeBranch
+      }) : await compileStatic({
+        contentDir: config.contentDir,
+        collections: config.collections,
+        indexPath: config.index.path
+      });
+      console.log(formatCompileResult(result));
+    } catch (error) {
+      if (error instanceof GraftError) printGraftError(error);
+      else console.error(error);
+    } finally {
+      compiling = false;
+      if (dirty) {
+        dirty = false;
+        schedule();
+      }
+    }
+  };
+  const schedule = (configChanged = false) => {
+    if (configChanged) configDirty = true;
+    clearTimeout(timer);
+    timer = setTimeout(() => void runCompile(), DEBOUNCE_MS);
+  };
+  await runCompile();
+  const watchers = [
+    watch(config.contentDir, { recursive: true }, () => schedule()),
+    watch(config.projectDir, (_event, filename) => {
+      if (filename && CONFIG_FILENAMES.includes(filename)) schedule(true);
+    })
+  ];
+  const watchedContent = relative(options.cwd, config.contentDir) || ".";
+  const branchLabel = branch === void 0 ? "static index" : branch.scope.kind === "physical" ? `${branch.name} (neon)` : options.branchId ?? "main";
+  console.log(
+    `Watching ${watchedContent} + ${basename(configPath)} (branch: ${branchLabel}). Ctrl+C to stop.`
+  );
+  await new Promise((resolveStopped) => {
+    const stop = () => {
+      clearTimeout(timer);
+      for (const watcher of watchers) watcher.close();
+      resolveStopped();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  await branch?.close();
+  await control?.close();
+}
+export {
+  devCommand
+};