easy-cms 0.1.0 → 0.2.0

package/bin/easy-cms.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// Committed entry point, so package managers can link the `easy-cms` command at install time,
+// before `dist/` is built (fresh clones of the monorepo).
+import '../dist/bin.js'

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   run
-} from "./chunk-3JYUADKB.js";
+} from "./chunk-AAFZW525.js";
 
 // src/bin.ts
 process.exitCode = await run(process.argv.slice(2));

package/dist/chunk-AAFZW525.js

@@ -0,0 +1,419 @@
+// src/index.ts
+import { existsSync } from "fs";
+import { writeFile } from "fs/promises";
+import { isAbsolute, join, resolve } from "path";
+import { createInterface } from "readline/promises";
+import { parseArgs } from "util";
+import {
+  ConfigError,
+  createEasyCMS as createEasyCMS2,
+  EasyCMSError,
+  generateTypes,
+  loadConfig,
+  ValidationError
+} from "@easy-cms/core";
+
+// src/serve.ts
+import { watch } from "fs";
+import { createServer } from "http";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { createAdminHandler } from "@easy-cms/admin";
+import {
+  createEasyCMS,
+  createRestHandler
+} from "@easy-cms/core";
+function createStandaloneHandler(cms) {
+  const config = cms.config;
+  const adminPath = `/${config.admin.path.replace(/^\/+|\/+$/g, "")}`;
+  const clientIps = /* @__PURE__ */ new WeakMap();
+  const api = createRestHandler(cms, { getClientIp: (request) => clientIps.get(request) });
+  const admin = createAdminHandler({
+    basePath: adminPath,
+    apiPath: config.routes.api,
+    locale: config.admin.locale
+  });
+  const under = (path, base) => path === base || path.startsWith(`${base}/`);
+  return async (request, clientIp) => {
+    const { pathname } = new URL(request.url);
+    if (under(pathname, config.routes.api)) {
+      clientIps.set(request, clientIp);
+      return api(request);
+    }
+    if (under(pathname, adminPath)) return admin(request);
+    if (pathname === "/healthz")
+      return new Response("ok", { headers: { "cache-control": "no-store" } });
+    if (pathname === "/")
+      return new Response(null, { status: 302, headers: { location: `${adminPath}/` } });
+    return Response.json({ message: "Not found" }, { status: 404 });
+  };
+}
+function toWebRequest(req, trustProxy) {
+  const forwardedProto = trustProxy ? header(req, "x-forwarded-proto")?.split(",")[0]?.trim() : void 0;
+  const encrypted = req.socket.encrypted === true;
+  const protocol = forwardedProto ?? (encrypted ? "https" : "http");
+  const url = new URL(req.url ?? "/", `${protocol}://${header(req, "host") ?? "localhost"}`);
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+    else if (value !== void 0) headers.set(name, value);
+  }
+  const method = req.method ?? "GET";
+  const hasBody = method !== "GET" && method !== "HEAD";
+  return new Request(url, {
+    method,
+    headers,
+    ...hasBody ? { body: Readable.toWeb(req), duplex: "half" } : {}
+  });
+}
+async function sendWebResponse(res, response) {
+  res.statusCode = response.status;
+  const cookies = response.headers.getSetCookie();
+  response.headers.forEach((value, name) => {
+    if (name !== "set-cookie") res.setHeader(name, value);
+  });
+  if (cookies.length > 0) res.setHeader("set-cookie", cookies);
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  await pipeline(Readable.fromWeb(response.body), res);
+}
+function header(req, name) {
+  const value = req.headers[name];
+  return Array.isArray(value) ? value[0] : value;
+}
+function clientIpOf(req, trustProxy) {
+  if (trustProxy) {
+    const forwarded = header(req, "x-forwarded-for")?.split(",")[0]?.trim();
+    if (forwarded) return forwarded;
+  }
+  return req.socket.remoteAddress;
+}
+var WATCHED = /\.(?:[cm]?[jt]s)$/;
+var IGNORED = /(?:^|[/\\])(?:node_modules|\.git|dist|\.output|\.next|uploads)(?:[/\\]|$)/;
+async function startServer(options) {
+  const { logger, cwd } = options;
+  const trustProxy = options.trustProxy ?? false;
+  let cms = await createEasyCMS(await options.loadConfig(), { cwd, logger });
+  let handler = createStandaloneHandler(cms);
+  const server = createServer(async (req, res) => {
+    try {
+      await sendWebResponse(
+        res,
+        await handler(toWebRequest(req, trustProxy), clientIpOf(req, trustProxy))
+      );
+    } catch (error) {
+      logger.error(`Request failed: ${error.message}`);
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader("content-type", "application/json; charset=utf-8");
+      }
+      res.end(res.headersSent ? void 0 : JSON.stringify({ message: "Internal server error" }));
+    }
+  });
+  let watcher;
+  if (options.watch) {
+    let timer;
+    let reloading = Promise.resolve();
+    const reload = () => {
+      reloading = reloading.then(async () => {
+        try {
+          const next = await createEasyCMS(await options.loadConfig(), { cwd, logger });
+          const previous = cms;
+          cms = next;
+          handler = createStandaloneHandler(next);
+          await previous.destroy();
+          logger.info("Config reloaded.");
+        } catch (error) {
+          logger.error(
+            `Reload failed, still serving the previous config:
+${error.message}`
+          );
+        }
+      });
+    };
+    watcher = watch(cwd, { recursive: true }, (_event, file) => {
+      if (!file || !WATCHED.test(file) || IGNORED.test(file)) return;
+      clearTimeout(timer);
+      timer = setTimeout(reload, 150);
+    });
+  }
+  await new Promise((resolveListen, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, options.host, () => resolveListen());
+  });
+  const address = server.address();
+  const host = !options.host || options.host === "0.0.0.0" || options.host === "::" ? "localhost" : options.host;
+  const url = `http://${host.includes(":") ? `[${host}]` : host}:${address.port}`;
+  return {
+    server,
+    url,
+    async close() {
+      watcher?.close();
+      const closed = new Promise((done) => server.close(() => done()));
+      server.closeAllConnections();
+      await closed;
+      await cms.destroy();
+    }
+  };
+}
+
+// src/index.ts
+async function ask(question, options = {}) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  if (options.hidden) {
+    const output = rl;
+    let asked = false;
+    output._writeToOutput = (text) => {
+      if (!asked) {
+        process.stdout.write(text);
+        asked = true;
+      }
+    };
+  }
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    if (options.hidden) process.stdout.write("\n");
+    rl.close();
+  }
+}
+var defaultIO = {
+  out: (line) => console.log(line),
+  err: (line) => console.error(line),
+  interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+  prompt: ask
+};
+var HELP = `Usage: easy-cms <command> [options]
+
+Commands:
+  migrate                 Apply pending migrations
+  migrate:create <name>   Create a migration from config changes
+  migrate:status          List migrations and whether they are applied
+  generate:types          Write TypeScript types for your collections and globals
+  create-admin            Create an admin user
+  serve                   Run the CMS as its own server (admin + REST API)
+
+Options:
+  --config <file>         Config file (default: easy-cms.config.ts)
+  --cwd <dir>             Project root (default: current directory); its .env is loaded
+  -h, --help              Show help
+`;
+var COMMAND_HELP = {
+  migrate: `Usage: easy-cms migrate [options]
+
+Applies every migration in easy-cms/migrations that the database has not run yet.
+Each migration runs in its own transaction; a failure rolls it back and stops.
+`,
+  "migrate:create": `Usage: easy-cms migrate:create <name> [options]
+
+Compares the config with the latest migration and writes a new migration
+(easy-cms/migrations/<timestamp>_<name>.sql) if anything changed.
+In a terminal you are asked whether changed fields were renamed.
+`,
+  "migrate:status": `Usage: easy-cms migrate:status [options]
+
+Lists migration files and whether each has been applied.
+`,
+  "generate:types": `Usage: easy-cms generate:types [--out <file>] [options]
+
+Writes interfaces for every collection and global (default: easy-cms-types.ts).
+The file has no imports, so a frontend in another repository can copy it.
+`,
+  "create-admin": `Usage: easy-cms create-admin [--email <email>] [--name <name>] [--role <role>] [options]
+
+Creates a user (role "admin" unless --role is given). The password is asked for in the
+terminal, or read from EASY_CMS_ADMIN_PASSWORD when there is no terminal.
+`,
+  serve: `Usage: easy-cms serve [--port <n>] [--host <host>] [--watch] [--trust-proxy] [options]
+
+Runs Easy CMS without Nuxt or Next.js: the admin at /admin, the REST API at /api/cms and
+/healthz for load balancers. Frontends on other origins need \`cors\` in the config.
+
+  --port <n>       Port (default: PORT, then 4000)
+  --host <host>    Interface to listen on (default: HOST, then all interfaces)
+  --watch          Reload when the config or files it imports change (development)
+  --trust-proxy    Trust X-Forwarded-For / X-Forwarded-Proto from your reverse proxy
+
+In production (NODE_ENV=production) pending migrations stop the server from starting.
+`
+};
+async function run(argv, io = defaultIO) {
+  let parsed;
+  try {
+    parsed = parse(argv);
+  } catch (error) {
+    io.err(error.message);
+    io.err(HELP);
+    return 1;
+  }
+  const { values, positionals } = parsed;
+  const [command, ...rest] = positionals;
+  if (!command) {
+    ;
+    (values.help ? io.out : io.err)(HELP);
+    return values.help ? 0 : 1;
+  }
+  if (!(command in COMMAND_HELP)) {
+    io.err(`Unknown command "${command}".
+`);
+    io.err(HELP);
+    return 1;
+  }
+  if (values.help) {
+    io.out(COMMAND_HELP[command]);
+    return 0;
+  }
+  const cwd = values.cwd ?? process.cwd();
+  loadDotEnv(cwd);
+  const logger = { info: io.out, warn: (m) => io.err(`warning: ${m}`), error: io.err };
+  try {
+    const load = () => loadConfig({ cwd, ...values.config ? { configFile: values.config } : {} });
+    if (command === "serve") return await serve(values, cwd, logger, load, io);
+    const config = await load();
+    if (command === "generate:types") {
+      const out = values.out ?? "easy-cms-types.ts";
+      const file = isAbsolute(out) ? out : resolve(cwd, out);
+      await writeFile(file, generateTypes(config));
+      io.out(`Wrote ${file}`);
+      return 0;
+    }
+    const schema = command === "create-admin" && process.env.NODE_ENV !== "production" ? "push" : "skip";
+    const cms = await createEasyCMS2(config, { cwd, schema, logger, interactive: io.interactive });
+    try {
+      switch (command) {
+        case "migrate": {
+          const applied = await cms.db.migrate();
+          io.out(
+            applied.length === 0 ? "No pending migrations." : `Applied ${applied.length} migration(s).`
+          );
+          return 0;
+        }
+        case "migrate:create": {
+          const name = rest.join(" ").trim();
+          if (!name) {
+            io.err("Missing migration name.\n");
+            io.err(COMMAND_HELP["migrate:create"]);
+            return 1;
+          }
+          const created = await cms.db.createMigration({ name });
+          if (!created) {
+            io.out("No changes; nothing to migrate.");
+          } else {
+            io.out(`Created ${created.file} (${created.statements.length} statements).`);
+            io.out("Review it, commit it, then run `easy-cms migrate` where you deploy.");
+          }
+          return 0;
+        }
+        case "create-admin": {
+          const email = values.email ?? (io.interactive && io.prompt ? await io.prompt("Email: ") : "");
+          if (!email) {
+            io.err("Missing --email.\n");
+            io.err(COMMAND_HELP["create-admin"]);
+            return 1;
+          }
+          const password = process.env.EASY_CMS_ADMIN_PASSWORD ?? (io.interactive && io.prompt ? await io.prompt("Password (8+ characters): ", { hidden: true }) : "");
+          if (!password) {
+            io.err("Missing password: run in a terminal or set EASY_CMS_ADMIN_PASSWORD.");
+            return 1;
+          }
+          try {
+            const user = await cms.create("users", {
+              email,
+              password,
+              role: values.role ?? "admin",
+              ...values.name ? { name: values.name } : {}
+            });
+            io.out(`Created ${user.role} ${user.email}. Log in at ${cms.config.admin.path}`);
+            return 0;
+          } catch (error) {
+            if (error instanceof ValidationError) {
+              for (const e of error.errors) io.err(`${e.field}: ${e.message}`);
+              return 1;
+            }
+            throw error;
+          }
+        }
+        case "migrate:status": {
+          const list = await cms.db.migrationStatus();
+          if (list.length === 0)
+            io.out("No migrations yet. Create one with `easy-cms migrate:create init`.");
+          for (const m of list) io.out(`${m.applied ? "\u2713 applied" : "\u2022 pending"}  ${m.name}`);
+          return 0;
+        }
+      }
+      return 1;
+    } finally {
+      await cms.destroy();
+    }
+  } catch (error) {
+    const known = error instanceof ConfigError || error instanceof EasyCMSError;
+    if (error instanceof Error)
+      io.err(!known && process.env.DEBUG ? error.stack ?? error.message : error.message);
+    else io.err(String(error));
+    return 1;
+  }
+}
+function parse(argv) {
+  return parseArgs({
+    args: [...argv],
+    allowPositionals: true,
+    options: {
+      config: { type: "string" },
+      cwd: { type: "string" },
+      out: { type: "string" },
+      email: { type: "string" },
+      name: { type: "string" },
+      role: { type: "string" },
+      port: { type: "string" },
+      host: { type: "string" },
+      watch: { type: "boolean" },
+      "trust-proxy": { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+}
+async function serve(values, cwd, logger, load, io) {
+  const port = Number(values.port ?? process.env.PORT ?? 4e3);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    io.err(`Invalid port "${values.port ?? process.env.PORT}".`);
+    return 1;
+  }
+  const host = values.host ?? process.env.HOST;
+  const server = await startServer({
+    port,
+    ...host ? { host } : {},
+    cwd,
+    logger,
+    loadConfig: load,
+    watch: values.watch ?? false,
+    trustProxy: values["trust-proxy"] ?? false
+  });
+  const config = await load();
+  io.out(`Easy CMS running at ${server.url}`);
+  io.out(`  admin  ${server.url}/${config.admin.path.replace(/^\/+|\/+$/g, "")}`);
+  io.out(`  API    ${server.url}${config.routes.api}`);
+  if (values.watch) io.out("  watching for changes");
+  await new Promise((resolveStop) => {
+    const stop = (signal) => {
+      io.out(`
+${signal} received, shutting down\u2026`);
+      resolveStop();
+    };
+    process.once("SIGINT", () => stop("SIGINT"));
+    process.once("SIGTERM", () => stop("SIGTERM"));
+  });
+  await server.close();
+  return 0;
+}
+function loadDotEnv(cwd) {
+  const file = join(cwd, ".env");
+  if (existsSync(file)) process.loadEnvFile(file);
+}
+
+export {
+  createStandaloneHandler,
+  startServer,
+  run
+};

package/dist/index.d.ts

@@ -1,3 +1,35 @@
+import { Server } from 'node:http';
+import { Logger, ResolvedConfig, Config, EasyCMS } from '@easy-cms/core';
+
+interface StandaloneOptions {
+    /** Use `X-Forwarded-For` / `X-Forwarded-Proto` from a reverse proxy you control. */
+    readonly trustProxy?: boolean;
+}
+type Handler = (request: Request, clientIp?: string) => Promise<Response>;
+/**
+ * One Web-standard handler for the whole standalone server: the REST API at `routes.api`, the
+ * admin at `admin.path`, and `/healthz` for load balancers. `/` redirects to the admin.
+ */
+declare function createStandaloneHandler<C extends Config>(cms: EasyCMS<C>): Handler;
+interface StartOptions extends StandaloneOptions {
+    readonly port: number;
+    readonly host?: string;
+    readonly cwd: string;
+    readonly logger: Logger;
+    /** Loads (or reloads) the resolved config. */
+    readonly loadConfig: () => Promise<ResolvedConfig>;
+    /** Reload when files in `cwd` change (development). */
+    readonly watch?: boolean;
+}
+interface RunningServer {
+    readonly server: Server;
+    readonly url: string;
+    /** Stops accepting connections, then closes the database. */
+    close(): Promise<void>;
+}
+/** Starts the standalone HTTP server. */
+declare function startServer(options: StartOptions): Promise<RunningServer>;
+
 interface IO {
     readonly out: (line: string) => void;
     readonly err: (line: string) => void;
@@ -10,4 +42,4 @@ interface IO {
 /** Runs the CLI and returns the exit code. */
 declare function run(argv: readonly string[], io?: IO): Promise<number>;
 
-export { type IO, run };
+export { type IO, type RunningServer, type StartOptions, createStandaloneHandler, run, startServer };

package/dist/index.js

@@ -1,6 +1,10 @@
 import {
-  run
-} from "./chunk-3JYUADKB.js";
+  createStandaloneHandler,
+  run,
+  startServer
+} from "./chunk-AAFZW525.js";
 export {
-  run
+  createStandaloneHandler,
+  run,
+  startServer
 };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "easy-cms",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Command line tool for Easy CMS",
   "license": "MIT",
   "type": "module",
   "bin": {
-    "easy-cms": "./dist/bin.js"
+    "easy-cms": "./bin/easy-cms.js"
   },
   "exports": {
     ".": {
@@ -14,16 +14,18 @@
     }
   },
   "files": [
+    "bin",
     "dist"
   ],
   "engines": {
     "node": ">=22.12"
   },
   "dependencies": {
-    "@easy-cms/core": "^0.1.0"
+    "@easy-cms/core": "^0.2.0",
+    "@easy-cms/admin": "^0.2.0"
   },
   "devDependencies": {
-    "@easy-cms/db-sqlite": "^0.1.0"
+    "@easy-cms/db-sqlite": "^0.2.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/chunk-3JYUADKB.js

@@ -1,220 +0,0 @@
-// src/index.ts
-import { existsSync } from "fs";
-import { writeFile } from "fs/promises";
-import { isAbsolute, join, resolve } from "path";
-import { createInterface } from "readline/promises";
-import { parseArgs } from "util";
-import {
-  ConfigError,
-  createEasyCMS,
-  EasyCMSError,
-  generateTypes,
-  loadConfig,
-  ValidationError
-} from "@easy-cms/core";
-async function ask(question, options = {}) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-  if (options.hidden) {
-    const output = rl;
-    let asked = false;
-    output._writeToOutput = (text) => {
-      if (!asked) {
-        process.stdout.write(text);
-        asked = true;
-      }
-    };
-  }
-  try {
-    return (await rl.question(question)).trim();
-  } finally {
-    if (options.hidden) process.stdout.write("\n");
-    rl.close();
-  }
-}
-var defaultIO = {
-  out: (line) => console.log(line),
-  err: (line) => console.error(line),
-  interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
-  prompt: ask
-};
-var HELP = `Usage: easy-cms <command> [options]
-
-Commands:
-  migrate                 Apply pending migrations
-  migrate:create <name>   Create a migration from config changes
-  migrate:status          List migrations and whether they are applied
-  generate:types          Write TypeScript types for your collections and globals
-  create-admin            Create an admin user
-
-Options:
-  --config <file>         Config file (default: easy-cms.config.ts)
-  --cwd <dir>             Project root (default: current directory); its .env is loaded
-  -h, --help              Show help
-`;
-var COMMAND_HELP = {
-  migrate: `Usage: easy-cms migrate [options]
-
-Applies every migration in easy-cms/migrations that the database has not run yet.
-Each migration runs in its own transaction; a failure rolls it back and stops.
-`,
-  "migrate:create": `Usage: easy-cms migrate:create <name> [options]
-
-Compares the config with the latest migration and writes a new migration
-(easy-cms/migrations/<timestamp>_<name>.sql) if anything changed.
-In a terminal you are asked whether changed fields were renamed.
-`,
-  "migrate:status": `Usage: easy-cms migrate:status [options]
-
-Lists migration files and whether each has been applied.
-`,
-  "generate:types": `Usage: easy-cms generate:types [--out <file>] [options]
-
-Writes interfaces for every collection and global (default: easy-cms-types.ts).
-The file has no imports, so a frontend in another repository can copy it.
-`,
-  "create-admin": `Usage: easy-cms create-admin [--email <email>] [--name <name>] [--role <role>] [options]
-
-Creates a user (role "admin" unless --role is given). The password is asked for in the
-terminal, or read from EASY_CMS_ADMIN_PASSWORD when there is no terminal.
-`
-};
-async function run(argv, io = defaultIO) {
-  let parsed;
-  try {
-    parsed = parse(argv);
-  } catch (error) {
-    io.err(error.message);
-    io.err(HELP);
-    return 1;
-  }
-  const { values, positionals } = parsed;
-  const [command, ...rest] = positionals;
-  if (!command) {
-    ;
-    (values.help ? io.out : io.err)(HELP);
-    return values.help ? 0 : 1;
-  }
-  if (!(command in COMMAND_HELP)) {
-    io.err(`Unknown command "${command}".
-`);
-    io.err(HELP);
-    return 1;
-  }
-  if (values.help) {
-    io.out(COMMAND_HELP[command]);
-    return 0;
-  }
-  const cwd = values.cwd ?? process.cwd();
-  loadDotEnv(cwd);
-  const logger = { info: io.out, warn: (m) => io.err(`warning: ${m}`), error: io.err };
-  try {
-    const config = await loadConfig({
-      cwd,
-      ...values.config ? { configFile: values.config } : {}
-    });
-    if (command === "generate:types") {
-      const out = values.out ?? "easy-cms-types.ts";
-      const file = isAbsolute(out) ? out : resolve(cwd, out);
-      await writeFile(file, generateTypes(config));
-      io.out(`Wrote ${file}`);
-      return 0;
-    }
-    const schema = command === "create-admin" && process.env.NODE_ENV !== "production" ? "push" : "skip";
-    const cms = await createEasyCMS(config, { cwd, schema, logger, interactive: io.interactive });
-    try {
-      switch (command) {
-        case "migrate": {
-          const applied = await cms.db.migrate();
-          io.out(
-            applied.length === 0 ? "No pending migrations." : `Applied ${applied.length} migration(s).`
-          );
-          return 0;
-        }
-        case "migrate:create": {
-          const name = rest.join(" ").trim();
-          if (!name) {
-            io.err("Missing migration name.\n");
-            io.err(COMMAND_HELP["migrate:create"]);
-            return 1;
-          }
-          const created = await cms.db.createMigration({ name });
-          if (!created) {
-            io.out("No changes; nothing to migrate.");
-          } else {
-            io.out(`Created ${created.file} (${created.statements.length} statements).`);
-            io.out("Review it, commit it, then run `easy-cms migrate` where you deploy.");
-          }
-          return 0;
-        }
-        case "create-admin": {
-          const email = values.email ?? (io.interactive && io.prompt ? await io.prompt("Email: ") : "");
-          if (!email) {
-            io.err("Missing --email.\n");
-            io.err(COMMAND_HELP["create-admin"]);
-            return 1;
-          }
-          const password = process.env.EASY_CMS_ADMIN_PASSWORD ?? (io.interactive && io.prompt ? await io.prompt("Password (8+ characters): ", { hidden: true }) : "");
-          if (!password) {
-            io.err("Missing password: run in a terminal or set EASY_CMS_ADMIN_PASSWORD.");
-            return 1;
-          }
-          try {
-            const user = await cms.create("users", {
-              email,
-              password,
-              role: values.role ?? "admin",
-              ...values.name ? { name: values.name } : {}
-            });
-            io.out(`Created ${user.role} ${user.email}. Log in at ${cms.config.admin.path}`);
-            return 0;
-          } catch (error) {
-            if (error instanceof ValidationError) {
-              for (const e of error.errors) io.err(`${e.field}: ${e.message}`);
-              return 1;
-            }
-            throw error;
-          }
-        }
-        case "migrate:status": {
-          const list = await cms.db.migrationStatus();
-          if (list.length === 0)
-            io.out("No migrations yet. Create one with `easy-cms migrate:create init`.");
-          for (const m of list) io.out(`${m.applied ? "\u2713 applied" : "\u2022 pending"}  ${m.name}`);
-          return 0;
-        }
-      }
-      return 1;
-    } finally {
-      await cms.destroy();
-    }
-  } catch (error) {
-    const known = error instanceof ConfigError || error instanceof EasyCMSError;
-    if (error instanceof Error)
-      io.err(!known && process.env.DEBUG ? error.stack ?? error.message : error.message);
-    else io.err(String(error));
-    return 1;
-  }
-}
-function parse(argv) {
-  return parseArgs({
-    args: [...argv],
-    allowPositionals: true,
-    options: {
-      config: { type: "string" },
-      cwd: { type: "string" },
-      out: { type: "string" },
-      email: { type: "string" },
-      name: { type: "string" },
-      role: { type: "string" },
-      help: { type: "boolean", short: "h" }
-    }
-  });
-}
-function loadDotEnv(cwd) {
-  const file = join(cwd, ".env");
-  if (existsSync(file)) process.loadEnvFile(file);
-}
-
-export {
-  run
-};