baysecms-cli 1.0.0

package/README.md

@@ -0,0 +1,16 @@
+# BayseCMS CLI
+
+CLI for BayseCMS schema push and frontend helper generation.
+
+## Commands
+
+- `baysecms schema push`
+- `baysecms codegen`
+
+## Example
+
+```bash
+BAYSECMS_API_URL="https://api.example.com" \
+BAYSECMS_API_KEY="<api-key>" \
+baysecms codegen --out src/lib/baysecms
+```

package/cli.mjs

@@ -0,0 +1,590 @@
+#!/usr/bin/env node
+/**
+ * BayseCMS CLI — schema-as-code → cloud tenant.
+ * Usage: baysecms schema push [--config path] [--file path] [--review] [--publish]
+ */
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { cwd } from "node:process";
+
+const DEFAULT_CONFIG = "baysecms.config.json";
+
+function parseArgs(argv) {
+  const args = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const next = argv[i + 1];
+      if (!next || next.startsWith("--")) {
+        args.flags[key] = true;
+      } else {
+        args.flags[key] = next;
+        i++;
+      }
+    } else {
+      args._.push(a);
+    }
+  }
+  return args;
+}
+
+async function loadConfig(configPath) {
+  const raw = await readFile(configPath, "utf-8");
+  return JSON.parse(raw);
+}
+
+function headersFromConfig(cfg) {
+  const h = { "content-type": "application/json" };
+  const apiKey = process.env.BAYSECMS_API_KEY || cfg.apiKey;
+  if (apiKey) {
+    h["x-api-key"] = apiKey;
+    return h;
+  }
+  const token = process.env.BAYSECMS_TOKEN || cfg.token;
+  if (!token) {
+    console.error("Missing auth: set BAYSECMS_API_KEY or BAYSECMS_TOKEN (or apiKey/token in config).");
+    process.exit(1);
+  }
+  h.authorization = `Bearer ${token}`;
+  const tenantId = process.env.BAYSECMS_TENANT_ID || cfg.tenantId;
+  const workspaceId = process.env.BAYSECMS_WORKSPACE_ID || cfg.workspaceId;
+  if (tenantId) h["x-tenant-id"] = tenantId;
+  if (workspaceId) h["x-workspace-id"] = workspaceId;
+  return h;
+}
+
+const toPascalCase = (value) =>
+  String(value)
+    .replace(/[^a-zA-Z0-9]+/g, " ")
+    .split(" ")
+    .filter(Boolean)
+    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .join("");
+
+const toCamelCase = (value) => {
+  const parts = String(value)
+    .replace(/[^a-zA-Z0-9]+/g, " ")
+    .trim()
+    .split(" ")
+    .filter(Boolean);
+  if (!parts.length) return "field";
+  return parts
+    .map((part, index) => {
+      const normalized = part.toLowerCase();
+      if (index === 0) return normalized;
+      return normalized[0].toUpperCase() + normalized.slice(1);
+    })
+    .join("");
+};
+
+const toSafeIdentifier = (value) => {
+  const camel = toCamelCase(value).replace(/[^a-zA-Z0-9_$]/g, "");
+  if (!camel) return "field";
+  if (/^[0-9]/.test(camel)) return `field${camel}`;
+  return camel;
+};
+
+const fieldToTypeScript = (field) => {
+  switch (field.type) {
+    case "string":
+    case "text":
+    case "slug":
+    case "email":
+    case "url":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "image":
+      return "{ url: string; alt?: string | null }";
+    case "richText":
+      return "Array<{ text: string }>";
+    case "tags":
+      return "string[]";
+    case "object": {
+      const nested = (field.fields ?? [])
+        .map((f) => `${toSafeIdentifier(f.key)}${f.required ? "" : "?"}: ${fieldToTypeScript(f)};`)
+        .join(" ");
+      return `{ ${nested} }`;
+    }
+    case "array": {
+      const item = field.items ?? { type: "string", key: "item" };
+      return `${fieldToTypeScript(item)}[]`;
+    }
+    default:
+      return "unknown";
+  }
+};
+
+function buildGeneratedTypes(collections) {
+  const lines = [
+    "/** Auto-generated by `baysecms codegen`. Do not edit manually. */",
+    ""
+  ];
+  for (const collection of collections) {
+    const typeName = `${toPascalCase(collection.slug)}Item`;
+    lines.push(`export type ${typeName} = {`);
+    lines.push("  id: string;");
+    lines.push("  slug: string | null;");
+    lines.push("  createdAt: string;");
+    lines.push("  updatedAt: string;");
+    lines.push("  data: {");
+    for (const field of collection.fields ?? []) {
+      const tsType = fieldToTypeScript(field);
+      lines.push(`    ${toSafeIdentifier(field.key)}${field.required ? "" : "?"}: ${tsType};`);
+    }
+    lines.push("  };");
+    lines.push("};");
+    lines.push("");
+  }
+  return `${lines.join("\n").trim()}\n`;
+}
+
+function buildGeneratedData(collections) {
+  const lines = [
+    "/** Auto-generated by `baysecms codegen`. Do not edit manually. */",
+    'import { createBayseCMSClient } from "baysecms/client";',
+    'import type {',
+    ...collections.map((c) => `  ${toPascalCase(c.slug)}Item,`),
+    '} from "./types";',
+    "",
+    "const readEnv = (key: string): string => {",
+    "  if (typeof process !== \"undefined\" && process?.env?.[key]) return String(process.env[key]);",
+    "  const maybeRuntime = globalThis as { __BAYSECMS_RUNTIME__?: Record<string, string | undefined>; __VITE_ENV__?: Record<string, string | undefined> };",
+    "  if (maybeRuntime.__BAYSECMS_RUNTIME__?.[key]) return String(maybeRuntime.__BAYSECMS_RUNTIME__[key]);",
+    "  if (key === \"BAYSECMS_API_URL\" && maybeRuntime.__VITE_ENV__?.VITE_BAYSECMS_API_URL) return String(maybeRuntime.__VITE_ENV__.VITE_BAYSECMS_API_URL);",
+    "  if (key === \"BAYSECMS_API_KEY\" && maybeRuntime.__VITE_ENV__?.VITE_BAYSECMS_API_KEY) return String(maybeRuntime.__VITE_ENV__.VITE_BAYSECMS_API_KEY);",
+    "  return \"\";",
+    "};",
+    "",
+    "function getApiClient() {",
+    "  const apiUrl = readEnv(\"BAYSECMS_API_URL\") || \"http://localhost:4000\";",
+    "  const apiKey = readEnv(\"BAYSECMS_API_KEY\") || \"\";",
+    "  return createBayseCMSClient({",
+    "    baseUrl: apiUrl,",
+    "    apiKey: apiKey || undefined",
+    "  });",
+    "}",
+    "",
+    "const toCamelCase = (value: string): string => {",
+    "  const parts = String(value)",
+    "    .replace(/[^a-zA-Z0-9]+/g, \" \")",
+    "    .trim()",
+    "    .split(\" \")",
+    "    .filter(Boolean);",
+    "  if (!parts.length) return \"field\";",
+    "  return parts",
+    "    .map((part, index) => {",
+    "      const normalized = part.toLowerCase();",
+    "      return index === 0 ? normalized : normalized[0].toUpperCase() + normalized.slice(1);",
+    "    })",
+    "    .join(\"\");",
+    "};",
+    "",
+    "const normalizeKeys = (value: unknown): unknown => {",
+    "  if (Array.isArray(value)) return value.map(normalizeKeys);",
+    "  if (!value || typeof value !== \"object\") return value;",
+    "  const output: Record<string, unknown> = {};",
+    "  for (const [key, nested] of Object.entries(value as Record<string, unknown>)) {",
+    "    output[toCamelCase(key)] = normalizeKeys(nested);",
+    "  }",
+    "  return output;",
+    "};",
+    "",
+    "const mapItem = <T extends { data?: unknown }>(item: T): T => ({",
+    "  ...item,",
+    "  data: normalizeKeys(item.data)",
+    "});",
+    ""
+  ];
+  for (const collection of collections) {
+    const pascal = toPascalCase(collection.slug);
+    if (collection.isSingleton) {
+      lines.push(`export async function get${pascal}(): Promise<${pascal}Item> {`);
+      lines.push("  const client = getApiClient();");
+      lines.push(`  const res = await client.get<{ item: ${pascal}Item }>(\"/v2/content/${collection.slug}/singleton\");`);
+      lines.push(`  return mapItem(res.item as ${pascal}Item);`);
+      lines.push("}");
+      lines.push("");
+    } else {
+      lines.push(`export async function get${pascal}Items(): Promise<${pascal}Item[]> {`);
+      lines.push("  const client = getApiClient();");
+      lines.push(`  const res = await client.getContent({ schema: "${collection.slug}", status: "published" });`);
+      lines.push(`  return (res.items as ${pascal}Item[]).map((item) => mapItem(item));`);
+      lines.push("}");
+      lines.push("");
+      lines.push(`export async function get${pascal}ItemBySlug(slug: string): Promise<${pascal}Item | null> {`);
+      lines.push("  try {");
+      lines.push("    const client = getApiClient();");
+      lines.push(`    const item = await client.getContentBySlug("${collection.slug}", slug);`);
+      lines.push(`    return mapItem(item as ${pascal}Item);`);
+      lines.push("  } catch {");
+      lines.push("    return null;");
+      lines.push("  }");
+      lines.push("}");
+      lines.push("");
+    }
+  }
+  return `${lines.join("\n").trim()}\n`;
+}
+
+function buildGeneratedHooks(collections) {
+  const lines = [
+    "/** Auto-generated by `baysecms codegen`. Do not edit manually. */",
+    'import { useEffect, useMemo, useState } from "react";',
+    'import { createBayseCMSClient } from "baysecms/client";',
+    'import type {',
+    ...collections.map((c) => `  ${toPascalCase(c.slug)}Item,`),
+    '} from "./types";',
+    "",
+    "type QueryState<T> = {",
+    "  data: T | null;",
+    "  isLoading: boolean;",
+    "  error: Error | null;",
+    "  isStale: boolean;",
+    "};",
+    "",
+    "const queryCache = new Map<string, { data: unknown; timestamp: number }>();",
+    "const cacheGcTimers = new Map<string, ReturnType<typeof setTimeout>>();",
+    "",
+    "const readEnv = (key: string): string => {",
+    "  if (typeof process !== \"undefined\" && process?.env?.[key]) return String(process.env[key]);",
+    "  const maybeRuntime = globalThis as { __BAYSECMS_RUNTIME__?: Record<string, string | undefined>; __VITE_ENV__?: Record<string, string | undefined> };",
+    "  if (maybeRuntime.__BAYSECMS_RUNTIME__?.[key]) return String(maybeRuntime.__BAYSECMS_RUNTIME__[key]);",
+    "  if (key === \"BAYSECMS_API_URL\" && maybeRuntime.__VITE_ENV__?.VITE_BAYSECMS_API_URL) return String(maybeRuntime.__VITE_ENV__.VITE_BAYSECMS_API_URL);",
+    "  if (key === \"BAYSECMS_API_KEY\" && maybeRuntime.__VITE_ENV__?.VITE_BAYSECMS_API_KEY) return String(maybeRuntime.__VITE_ENV__.VITE_BAYSECMS_API_KEY);",
+    "  return \"\";",
+    "};",
+    "function getApiClient() {",
+    "  const apiUrl = readEnv(\"BAYSECMS_API_URL\") || \"http://localhost:4000\";",
+    "  const apiKey = readEnv(\"BAYSECMS_API_KEY\") || \"\";",
+    "  return createBayseCMSClient({",
+    "    baseUrl: apiUrl,",
+    "    apiKey: apiKey || undefined",
+    "  });",
+    "}",
+    "",
+    "export function useQuery<T>(config: {",
+    "  queryKey: Array<string | null | number>;",
+    "  queryFn: () => Promise<T>;",
+    "  staleTime?: number;",
+    "  gcTime?: number;",
+    "}): QueryState<T> {",
+    "  const cacheKey = useMemo(() => JSON.stringify(config.queryKey), [config.queryKey]);",
+    "  const staleTime = config.staleTime ?? 5 * 60 * 1000;",
+    "  const gcTime = config.gcTime ?? 30 * 60 * 1000;",
+    "  const cached = queryCache.get(cacheKey);",
+    "  const stale = !cached || Date.now() - cached.timestamp > staleTime;",
+    "",
+    "  const [state, setState] = useState<QueryState<T>>({",
+    "    data: cached ? (cached.data as T) : null,",
+    "    isLoading: stale,",
+    "    error: null,",
+    "    isStale: stale",
+    "  });",
+    "",
+    "  useEffect(() => {",
+    "    if (!stale && cached) {",
+    "      setState({",
+    "        data: cached.data as T,",
+    "        isLoading: false,",
+    "        error: null,",
+    "        isStale: false",
+    "      });",
+    "      return;",
+    "    }",
+    "",
+    "    let isMounted = true;",
+    "    setState((prev) => ({ ...prev, isLoading: true, error: null, isStale: true }));",
+    "",
+    "    config",
+    "      .queryFn()",
+    "      .then((data) => {",
+    "        if (!isMounted) return;",
+    "        queryCache.set(cacheKey, { data, timestamp: Date.now() });",
+    "        const prevTimer = cacheGcTimers.get(cacheKey);",
+    "        if (prevTimer) clearTimeout(prevTimer);",
+    "        cacheGcTimers.set(",
+    "          cacheKey,",
+    "          setTimeout(() => {",
+    "            queryCache.delete(cacheKey);",
+    "            cacheGcTimers.delete(cacheKey);",
+    "          }, gcTime)",
+    "        );",
+    "        setState({ data, isLoading: false, error: null, isStale: false });",
+    "      })",
+    "      .catch((error) => {",
+    "        if (!isMounted) return;",
+    "        setState((prev) => ({",
+    "          ...prev,",
+    "          isLoading: false,",
+    "          error: error instanceof Error ? error : new Error(String(error))",
+    "        }));",
+    "      });",
+    "",
+    "    return () => {",
+    "      isMounted = false;",
+    "    };",
+    "  }, [cacheKey, stale, gcTime]);",
+    "",
+    "  return state;",
+    "}",
+    ""
+  ];
+
+  for (const collection of collections) {
+    const pascal = toPascalCase(collection.slug);
+    const camel = toSafeIdentifier(collection.slug);
+    if (collection.isSingleton) {
+      lines.push(`export const ${camel}Queries = {`);
+      lines.push(`  all: () => ["${collection.slug}"] as const,`);
+      lines.push(`  singleton: () => [...${camel}Queries.all(), "singleton"] as const`);
+      lines.push("};");
+      lines.push("");
+      lines.push(`export function use${pascal}() {`);
+      lines.push(`  return useQuery<${pascal}Item>({`);
+      lines.push(`    queryKey: ${camel}Queries.singleton(),`);
+      lines.push("    queryFn: async () => {");
+      lines.push("      const client = getApiClient();");
+      lines.push(`      const res = await client.get<{ item: ${pascal}Item }>(\"/v2/content/${collection.slug}/singleton\");`);
+      lines.push(`      return res.item as ${pascal}Item;`);
+      lines.push("    },");
+      lines.push("    staleTime: 60 * 60 * 1000");
+      lines.push("  });");
+      lines.push("}");
+      lines.push("");
+    } else {
+      lines.push(`export const ${camel}Queries = {`);
+      lines.push(`  all: () => ["${collection.slug}"] as const,`);
+      lines.push(`  list: () => [...${camel}Queries.all(), "list"] as const,`);
+      lines.push(`  bySlug: (slug: string) => [...${camel}Queries.all(), "slug", slug] as const`);
+      lines.push("};");
+      lines.push("");
+      lines.push(`export function use${pascal}Items() {`);
+      lines.push(`  return useQuery<${pascal}Item[]>({`);
+      lines.push(`    queryKey: ${camel}Queries.list(),`);
+      lines.push("    queryFn: async () => {");
+      lines.push("      const client = getApiClient();");
+      lines.push(
+        `      const res = await client.getContent({ schema: "${collection.slug}", status: "published" });`
+      );
+      lines.push(`      return (res.items as ${pascal}Item[]) ?? [];`);
+      lines.push("    },");
+      lines.push("    staleTime: 5 * 60 * 1000");
+      lines.push("  });");
+      lines.push("}");
+      lines.push("");
+      lines.push(`export function use${pascal}ItemBySlug(slug: string | null) {`);
+      lines.push(`  return useQuery<${pascal}Item>({`);
+      lines.push(`    queryKey: ${camel}Queries.bySlug(slug ?? ""),`);
+      lines.push("    queryFn: async () => {");
+      lines.push('      if (!slug) throw new Error("Slug required");');
+      lines.push("      const client = getApiClient();");
+      lines.push(
+        `      return (await client.getContentBySlug("${collection.slug}", slug)) as ${pascal}Item;`
+      );
+      lines.push("    }");
+      lines.push("  });");
+      lines.push("}");
+      lines.push("");
+    }
+  }
+
+  return `${lines.join("\n").trim()}\n`;
+}
+
+function buildGeneratedIndex(collections) {
+  const exports = collections.flatMap((c) => {
+    const pascal = toPascalCase(c.slug);
+    if (c.isSingleton) return [`get${pascal}`];
+    return [`get${pascal}Items`, `get${pascal}ItemBySlug`];
+  });
+  const hookExports = collections.flatMap((c) => {
+    const pascal = toPascalCase(c.slug);
+    const camel = toSafeIdentifier(c.slug);
+    if (c.isSingleton) return [`${camel}Queries`, `use${pascal}`];
+    return [`${camel}Queries`, `use${pascal}Items`, `use${pascal}ItemBySlug`];
+  });
+  return `/** Auto-generated by \`baysecms codegen\`. */\nexport * from "./types";\nexport { ${exports.join(", ")} } from "./data";\nexport { useQuery, ${hookExports.join(", ")} } from "./hooks";\n`;
+}
+
+async function fetchPublishedCollections(apiUrl, hdrs, schemaFilter) {
+  const payload = await request(apiUrl, "/schemas", "GET", undefined, hdrs);
+  const rawItems = Array.isArray(payload?.items) ? payload.items : [];
+  const latestPublishedBySchema = new Map();
+  for (const item of rawItems) {
+    if (item?.status !== "published" || !item?.schemaId || typeof item?.version !== "number") continue;
+    const current = latestPublishedBySchema.get(item.schemaId);
+    if (!current || item.version > current.version) {
+      latestPublishedBySchema.set(item.schemaId, item);
+    }
+  }
+
+  const collections = [];
+  for (const schema of latestPublishedBySchema.values()) {
+    for (const collection of schema.collections ?? []) {
+      if (!collection?.slug) continue;
+      if (schemaFilter && collection.slug !== schemaFilter) continue;
+      collections.push({
+        schemaId: schema.schemaId,
+        slug: collection.slug,
+        name: collection.name || collection.slug,
+        fields: Array.isArray(collection.fields) ? collection.fields : [],
+        isSingleton: Boolean(collection.isSingleton)
+      });
+    }
+  }
+  return collections;
+}
+
+async function runCodegen(apiUrl, hdrs, outDir, schemaFilter) {
+  const collections = await fetchPublishedCollections(apiUrl, hdrs, schemaFilter);
+  if (!collections.length) {
+    console.error("No published collections found for codegen.");
+    process.exit(1);
+  }
+  await mkdir(outDir, { recursive: true });
+  await writeFile(join(outDir, "types.ts"), buildGeneratedTypes(collections), "utf-8");
+  await writeFile(join(outDir, "data.ts"), buildGeneratedData(collections), "utf-8");
+  await writeFile(join(outDir, "hooks.ts"), buildGeneratedHooks(collections), "utf-8");
+  await writeFile(join(outDir, "index.ts"), buildGeneratedIndex(collections), "utf-8");
+  console.log(`Generated ${collections.length} collection helper(s) in ${outDir}`);
+}
+
+async function request(apiUrl, path, method, body, hdrs) {
+  const url = `${apiUrl.replace(/\/$/, "")}${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: hdrs,
+    body: body ? JSON.stringify(body) : undefined
+  });
+  const text = await res.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = text;
+  }
+  if (!res.ok) {
+    console.error(`HTTP ${res.status}`, data);
+    process.exit(1);
+  }
+  return data;
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (
+    argv.length === 0 ||
+    argv[0] === "--help" ||
+    argv[0] === "-h" ||
+    argv.includes("--help") ||
+    argv.includes("-h")
+  ) {
+    console.log(`
+BayseCMS CLI
+
+  baysecms schema push [options]
+  baysecms codegen [options]
+
+Options:
+  --config <path>   Default: ./baysecms.config.json
+  --file <path>     Schema JSON file (overrides config.schemaFile)
+  --review          After draft, POST .../review
+  --publish         After review, POST .../publish (implies --review)
+  --out <path>      For codegen. Default: ./src/lib/baysecms
+  --schema <slug>   For codegen. Generate only one collection slug
+  --no-codegen      With schema push --publish, skip auto helper generation
+
+Env:
+  BAYSECMS_API_URL     Override config.apiUrl
+  BAYSECMS_API_KEY     API key auth (recommended for codegen)
+  BAYSECMS_TOKEN       Bearer JWT alternative
+  BAYSECMS_TENANT_ID   Optional; Cognito custom claim usually covers this
+  BAYSECMS_WORKSPACE_ID
+`);
+    process.exit(0);
+  }
+
+  const parsed = parseArgs(argv);
+  const [cmd, sub] = parsed._;
+
+  const configPath = resolve(cwd(), parsed.flags.config || DEFAULT_CONFIG);
+  let cfg;
+  try {
+    cfg = await loadConfig(configPath);
+  } catch (e) {
+    console.error(`Cannot read config: ${configPath}`, e.message);
+    process.exit(1);
+  }
+
+  const apiUrl = process.env.BAYSECMS_API_URL || cfg.apiUrl;
+  if (!apiUrl) {
+    console.error("Missing apiUrl in config or BAYSECMS_API_URL");
+    process.exit(1);
+  }
+
+  const hdrs = headersFromConfig(cfg);
+
+  if (cmd === "schema" && sub === "push") {
+    const schemaPath = resolve(cwd(), parsed.flags.file || cfg.schemaFile || "baysecms.schema.json");
+    let schemaBody;
+    try {
+      schemaBody = JSON.parse(await readFile(schemaPath, "utf-8"));
+    } catch (e) {
+      console.error(`Cannot read schema file: ${schemaPath}`, e.message);
+      process.exit(1);
+    }
+
+    console.log(`Pushing schema draft to ${apiUrl} ...`);
+    await request(apiUrl, "/schemas/draft", "POST", schemaBody, hdrs);
+    console.log("OK: draft created");
+
+    const schemaId = schemaBody.schemaId;
+    const version = schemaBody.version;
+    if (!schemaId || !version) {
+      console.log("Done (no schemaId/version in file for follow-up steps).");
+      return;
+    }
+
+    if (parsed.flags.publish) {
+      parsed.flags.review = true;
+    }
+
+    if (parsed.flags.review) {
+      console.log(`Submitting review: ${schemaId} v${version} ...`);
+      await request(apiUrl, `/schemas/${encodeURIComponent(schemaId)}/${version}/review`, "POST", undefined, hdrs);
+      console.log("OK: in review");
+    }
+
+    if (parsed.flags.publish) {
+      console.log(`Publishing: ${schemaId} v${version} ...`);
+      await request(apiUrl, `/schemas/${encodeURIComponent(schemaId)}/${version}/publish`, "POST", undefined, hdrs);
+      console.log("OK: published");
+      if (!parsed.flags["no-codegen"]) {
+        const outDir = resolve(cwd(), parsed.flags.out || cfg.codegenOut || "src/lib/baysecms");
+        console.log(`Running codegen to ${outDir} ...`);
+        await runCodegen(apiUrl, hdrs, outDir, undefined);
+      }
+    }
+    return;
+  }
+
+  if (cmd === "codegen") {
+    const outDir = resolve(cwd(), parsed.flags.out || "src/lib/baysecms");
+    const schemaFilter = typeof parsed.flags.schema === "string" ? parsed.flags.schema.trim() : "";
+    await runCodegen(apiUrl, hdrs, outDir, schemaFilter);
+    return;
+  }
+
+  console.error("Unknown command. Use: baysecms schema push OR baysecms codegen");
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "baysecms-cli",
+  "version": "1.0.0",
+  "description": "CLI for BayseCMS schema push and code generation workflows",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "baysecms": "./cli.mjs"
+  },
+  "files": [
+    "cli.mjs",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}