gencow 0.1.137 → 0.1.138

package/bin/gencow.mjs

@@ -12,19 +12,12 @@
  *   gencow db:studio   — open Drizzle Studio (visual DB browser)
  *   gencow dashboard   — open /_admin in browser
  *   gencow backup      — manage database backups (list/create/restore/delete/download)
+ *   gencow templates   — publish/list/download/clone marketplace templates
  *   gencow help        — show this help
  */
 
 import { execSync, spawn } from "child_process";
-import {
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  unlinkSync,
-  cpSync,
-  symlinkSync,
-  copyFileSync,
-} from "fs";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, cpSync, symlinkSync, copyFileSync } from "fs";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 import { createAddCommand } from "../lib/add-command.mjs";
@@ -62,6 +55,7 @@ import { createJobsCommand } from "../lib/jobs-command.mjs";
 import { createLogsCommand } from "../lib/logs-command.mjs";
 import { createStaticDeployRuntime } from "../lib/static-deploy-command.mjs";
 import { createStaticCommand } from "../lib/static-command.mjs";
+import { createTemplateMarketplaceCommand } from "../lib/template-marketplace-command.mjs";
 import {
   getAppUrl,
   getBaseDomain,
@@ -70,7 +64,20 @@ import {
   parseDurationToMinutes,
   validatePlatformUrl,
 } from "../lib/domain-helpers.mjs";
-import { BOLD, CYAN, DIM, GREEN, RED, RESET, YELLOW, error, info, log, success, warn } from "../lib/output.mjs";
+import {
+  BOLD,
+  CYAN,
+  DIM,
+  GREEN,
+  RED,
+  RESET,
+  YELLOW,
+  error,
+  info,
+  log,
+  success,
+  warn,
+} from "../lib/output.mjs";
 import { platformFetch, requireCreds, rpcMutation, rpcQuery } from "../lib/platform-client.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -229,6 +236,7 @@ const runStaticCommand = createStaticCommand({
   requireCredsImpl: requireCreds,
   runStaticDeployRuntimeImpl: runStaticDeployRuntime,
 });
+const runTemplatesCommand = createTemplateMarketplaceCommand();
 
 // ─── Commands ─────────────────────────────────────────────
 
@@ -299,6 +307,10 @@ ${BOLD}Commands (login required):${RESET}
   ${GREEN}static [dir]${RESET}     Deploy static files ${DIM}(dist/, out/, build/)${RESET}
                      ${DIM}--prod          Deploy to production app${RESET}
                      ${DIM}--force, -f     Skip dependency audit${RESET}
+  ${GREEN}templates publish${RESET} Publish current project as a marketplace template
+                     ${DIM}--title, --slug, --price, --private, --unlisted${RESET}
+  ${GREEN}templates list${RESET}    Browse public templates
+  ${GREEN}templates clone <slug>${RESET} Clone a template into a local directory
   ${GREEN}deploy${RESET}           Deploy backend to cloud ${DIM}(dev by default)${RESET}
                      ${DIM}--prod          Deploy to production (Pro+ only)${RESET}
                      ${DIM}--rollback      Rollback to previous deployment${RESET}
@@ -355,6 +367,10 @@ ${BOLD}Examples:${RESET}
 
   ${DIM}# Inspect stale workflows:${RESET}
   gencow jobs workflow cleanup --status terminal --older-than 7d
+
+  ${DIM}# Publish and clone templates:${RESET}
+  gencow templates publish --title "CRM Starter" --price 29
+  gencow templates clone crm-starter
 `);
   },
 
@@ -379,6 +395,7 @@ ${BOLD}Examples:${RESET}
   // ── backup / domain ──────────────────────────────────
   backup: runBackupCommand,
   domain: runDomainCommand,
+  templates: runTemplatesCommand,
 
   async mcp() {
     info(`MCP server is ${BOLD}coming soon${RESET}.`);

package/lib/template-marketplace-command.mjs

@@ -0,0 +1,228 @@
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { basename, resolve } from "path";
+import { BOLD, CYAN, DIM, GREEN, RESET, error, info, log, success } from "./output.mjs";
+import { platformFetch, requireCreds } from "./platform-client.mjs";
+import {
+  buildTemplateTarExcludes,
+  detectStaticTemplateProject,
+  validateStaticOutput,
+} from "./template-marketplace-detection.mjs";
+
+export function parseTemplateArgs(args) {
+  const [subcommand = "list", ...rest] = args;
+  const options = { _: [], price: "0", currency: "USD", visibility: "public" };
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+    if (arg === "--title") options.title = rest[++index];
+    else if (arg === "--summary") options.summary = rest[++index];
+    else if (arg === "--slug") options.slug = rest[++index];
+    else if (arg === "--price") options.price = rest[++index];
+    else if (arg === "--currency") options.currency = rest[++index];
+    else if (arg === "--visibility") options.visibility = rest[++index];
+    else if (arg === "--private") options.visibility = "private";
+    else if (arg === "--unlisted") options.visibility = "unlisted";
+    else if (arg === "--build") options.build = rest[++index];
+    else if (arg === "--out") options.out = rest[++index];
+    else if (arg === "--frontend-root") options.frontendRoot = rest[++index];
+    else if (arg === "--backend-root") options.backendRoot = rest[++index];
+    else if (arg === "--version") options.version = rest[++index];
+    else if (arg === "--out-file") options.outFile = rest[++index];
+    else options._.push(arg);
+  }
+  return { subcommand, options };
+}
+
+function centsFromPrice(value) {
+  const numeric = Number(value || 0);
+  if (!Number.isFinite(numeric) || numeric < 0) throw new Error("Invalid --price");
+  return Math.round(numeric * 100);
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function createSourceBundle({ cwd, staticOutputDir, execSyncImpl = execSync, mkdirSyncImpl = mkdirSync }) {
+  const out = resolve(cwd, ".gencow", "template-source.tar.gz");
+  mkdirSyncImpl(resolve(cwd, ".gencow"), { recursive: true });
+  const excludes = buildTemplateTarExcludes(staticOutputDir)
+    .map((item) => `--exclude=${shellQuote(item)}`)
+    .join(" ");
+  execSyncImpl(`COPYFILE_DISABLE=1 tar ${excludes} -czf ${shellQuote(out)} .`, { cwd });
+  return out;
+}
+
+function createStaticBundle({ cwd, outputDir, execSyncImpl = execSync, mkdirSyncImpl = mkdirSync }) {
+  const out = resolve(cwd, ".gencow", "template-static.tar.gz");
+  mkdirSyncImpl(resolve(cwd, ".gencow"), { recursive: true });
+  execSyncImpl(`COPYFILE_DISABLE=1 tar -czf ${shellQuote(out)} -C ${shellQuote(resolve(cwd, outputDir))} .`, {
+    cwd,
+  });
+  return out;
+}
+
+async function rpc(creds, name, args, platformFetchImpl) {
+  const res = await platformFetchImpl(creds, "/api/query", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ name, args }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || res.statusText);
+  return data.result ?? data;
+}
+
+export function createTemplateMarketplaceCommand({
+  cwdImpl = () => process.cwd(),
+  errorImpl = error,
+  execSyncImpl = execSync,
+  existsSyncImpl = existsSync,
+  exitImpl = (code) => process.exit(code),
+  infoImpl = info,
+  logImpl = log,
+  platformFetchImpl = platformFetch,
+  readFileSyncImpl = readFileSync,
+  requireCredsImpl = requireCreds,
+  resolvePathImpl = resolve,
+  rmSyncImpl = rmSync,
+  successImpl = success,
+  writeFileSyncImpl = writeFileSync,
+} = {}) {
+  async function publish(options) {
+    const cwd = cwdImpl();
+    const detection = detectStaticTemplateProject({
+      cwd,
+      explicit: {
+        frontendRoot: options.frontendRoot,
+        backendRoot: options.backendRoot,
+        buildCommand: options.build,
+        outputDir: options.out,
+      },
+      existsSyncImpl,
+      readFileSyncImpl,
+      resolvePathImpl,
+    });
+    if (!detection.ok) throw new Error(detection.error);
+
+    logImpl(`\n${BOLD}${CYAN}Gencow Template Publish${RESET}\n`);
+    infoImpl(`Framework: ${detection.frontendFramework}`);
+    infoImpl(`Kind:      ${detection.projectKind}`);
+
+    if (detection.buildCommand) {
+      infoImpl(`Build:     ${detection.buildCommand}`);
+      execSyncImpl(detection.buildCommand, {
+        cwd: resolvePathImpl(cwd, detection.buildWorkdir),
+        stdio: "inherit",
+      });
+    }
+    const outputValidation = validateStaticOutput({
+      cwd: resolvePathImpl(cwd, detection.buildWorkdir),
+      outputDir: detection.staticOutputDir,
+      existsSyncImpl,
+      resolvePathImpl,
+    });
+    if (!outputValidation.ok) throw new Error(outputValidation.error);
+
+    const sourceBundle = createSourceBundle({
+      cwd,
+      staticOutputDir: detection.staticOutputDir,
+      execSyncImpl,
+    });
+    const staticBundle = createStaticBundle({
+      cwd: resolvePathImpl(cwd, detection.buildWorkdir),
+      outputDir: detection.staticOutputDir,
+      execSyncImpl,
+    });
+
+    const creds = requireCredsImpl();
+    const priceCents = centsFromPrice(options.price);
+    const form = new FormData();
+    form.append("title", options.title || basename(cwd));
+    form.append("summary", options.summary || "");
+    form.append("slug", options.slug || "");
+    form.append("version", options.version || "1.0.0");
+    form.append("priceType", priceCents > 0 ? "paid" : "free");
+    form.append("priceCents", String(priceCents));
+    form.append("currency", options.currency || "USD");
+    form.append("visibilityIntent", options.visibility || "public");
+    form.append("projectKind", detection.projectKind);
+    form.append("frontendFramework", detection.frontendFramework);
+    form.append("packageManager", detection.packageManager);
+    form.append("frontendRoot", detection.frontendRoot);
+    form.append("backendRoot", detection.backendRoot);
+    form.append("buildWorkdir", detection.buildWorkdir);
+    form.append("buildCommand", detection.buildCommand);
+    form.append("staticOutputDir", detection.staticOutputDir);
+    form.append("bundle", new Blob([readFileSyncImpl(sourceBundle)]), "template-source.tar.gz");
+    form.append("staticBundle", new Blob([readFileSyncImpl(staticBundle)]), "template-static.tar.gz");
+
+    const res = await platformFetchImpl(creds, "/platform/templates/publish", { method: "POST", body: form });
+    const body = await res.json().catch(() => ({}));
+    rmSyncImpl(sourceBundle, { force: true });
+    rmSyncImpl(staticBundle, { force: true });
+    if (!res.ok) throw new Error(body.error || res.statusText);
+    successImpl(`Template submitted: ${body.slug}`);
+    infoImpl(`Status: draft review`);
+    if (body.audit?.errors?.length) infoImpl(`${DIM}Audit errors: ${body.audit.errors.join(", ")}${RESET}`);
+  }
+
+  async function list() {
+    const rows = await rpc(requireCredsImpl(), "templates.listPublic", {}, platformFetchImpl);
+    for (const row of rows)
+      logImpl(
+        `${GREEN}${row.slug}${RESET}  ${row.priceType === "paid" ? `$${(row.priceCents / 100).toFixed(2)}` : "free"}  ${row.title}`,
+      );
+  }
+
+  async function infoCommand(slug) {
+    const data = await rpc(requireCredsImpl(), "templates.getPublic", { slug }, platformFetchImpl);
+    if (!data) throw new Error("Template not found");
+    logImpl(`${BOLD}${data.listing.title}${RESET}`);
+    logImpl(`${DIM}${data.listing.summary || ""}${RESET}`);
+    logImpl(
+      `Price: ${data.listing.priceType === "paid" ? `$${(data.listing.priceCents / 100).toFixed(2)}` : "free"}`,
+    );
+    if (data.release?.previewFrontendUrl) logImpl(`Preview: ${data.release.previewFrontendUrl}`);
+  }
+
+  async function download(slug, options, cloneMode = false) {
+    const creds = requireCredsImpl();
+    const versionQuery = options.version
+      ? `?version=${encodeURIComponent(options.version)}${cloneMode ? "&clone=1" : ""}`
+      : cloneMode
+        ? "?clone=1"
+        : "";
+    const res = await platformFetchImpl(creds, `/platform/templates/${slug}/download${versionQuery}`);
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.error || res.statusText);
+    }
+    const buffer = Buffer.from(await res.arrayBuffer());
+    const out = options.outFile || `${slug}.tar.gz`;
+    writeFileSyncImpl(resolvePathImpl(cwdImpl(), out), buffer);
+    successImpl(`Downloaded: ${out}`);
+    return resolvePathImpl(cwdImpl(), out);
+  }
+
+  return async function runTemplatesCommand(...args) {
+    const { subcommand, options } = parseTemplateArgs(args);
+    if (subcommand === "publish") return publish(options);
+    if (subcommand === "list") return list();
+    if (subcommand === "info") return infoCommand(options._[0]);
+    if (subcommand === "download") return download(options._[0], options);
+    if (subcommand === "clone") {
+      const slug = options._[0];
+      const dir = options._[1] || slug;
+      const archive = await download(slug, { ...options, outFile: ".gencow-template-clone.tar.gz" }, true);
+      execSyncImpl(`mkdir -p ${shellQuote(dir)} && tar -xzf ${shellQuote(archive)} -C ${shellQuote(dir)}`, {
+        cwd: cwdImpl(),
+      });
+      rmSyncImpl(archive, { force: true });
+      successImpl(`Cloned into: ${dir}`);
+      return;
+    }
+    errorImpl("Usage: gencow templates <list|info|publish|download|clone>");
+    exitImpl(1);
+  };
+}

package/lib/template-marketplace-detection.mjs

@@ -0,0 +1,162 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { isAbsolute, resolve } from "path";
+
+const CONFIG_FILES = {
+  vite: ["vite.config.ts", "vite.config.js", "vite.config.mjs"],
+  astro: ["astro.config.ts", "astro.config.mjs", "astro.config.js"],
+  svelte: ["svelte.config.ts", "svelte.config.js"],
+  next: ["next.config.ts", "next.config.js", "next.config.mjs"],
+};
+
+export function detectPackageManager({
+  cwd = process.cwd(),
+  existsSyncImpl = existsSync,
+  resolvePathImpl = resolve,
+} = {}) {
+  if (existsSyncImpl(resolvePathImpl(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSyncImpl(resolvePathImpl(cwd, "bun.lockb"))) return "bun";
+  if (existsSyncImpl(resolvePathImpl(cwd, "yarn.lock"))) return "yarn";
+  if (existsSyncImpl(resolvePathImpl(cwd, "package-lock.json"))) return "npm";
+  return "unknown";
+}
+
+function readPackageJson({ cwd, readFileSyncImpl = readFileSync, resolvePathImpl = resolve }) {
+  try {
+    return JSON.parse(readFileSyncImpl(resolvePathImpl(cwd, "package.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function hasAnyConfig(cwd, files, { existsSyncImpl = existsSync, resolvePathImpl = resolve }) {
+  return files.some((file) => existsSyncImpl(resolvePathImpl(cwd, file)));
+}
+
+function isSafeProjectPath(value, { allowDot = true } = {}) {
+  const normalized = String(value || "")
+    .replace(/\\/g, "/")
+    .replace(/\/+$/, "");
+  if (!normalized) return false;
+  if (normalized === ".") return allowDot;
+  if (isAbsolute(normalized) || normalized.startsWith("~")) return false;
+  return !normalized.split("/").some((part) => part === "" || part === "." || part === "..");
+}
+
+export function detectStaticTemplateProject({
+  cwd = process.cwd(),
+  explicit = {},
+  existsSyncImpl = existsSync,
+  readFileSyncImpl = readFileSync,
+  resolvePathImpl = resolve,
+} = {}) {
+  const pkg = readPackageJson({ cwd, readFileSyncImpl, resolvePathImpl });
+  const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+  const metadata = pkg.gencowTemplate || {};
+
+  const frontendRoot = explicit.frontendRoot || metadata.frontend?.root || ".";
+  const backendRoot = explicit.backendRoot || metadata.backendRoot || "gencow";
+  if (!isSafeProjectPath(frontendRoot) || !isSafeProjectPath(backendRoot)) {
+    return { ok: false, error: "Template frontend/backend roots must be safe relative paths" };
+  }
+  const frontendCwd = resolvePathImpl(cwd, frontendRoot);
+  const frontendPkg =
+    frontendRoot === "." ? pkg : readPackageJson({ cwd: frontendCwd, readFileSyncImpl, resolvePathImpl });
+  const frontendDeps = { ...(frontendPkg.dependencies || {}), ...(frontendPkg.devDependencies || {}) };
+  const allDeps = { ...deps, ...frontendDeps };
+
+  if (hasAnyConfig(frontendCwd, CONFIG_FILES.next, { existsSyncImpl, resolvePathImpl }) || allDeps.next) {
+    return {
+      ok: false,
+      error: "MVP는 Vite/Astro/Svelte static frontend만 지원하며 Next.js/SSR frontend는 지원하지 않는다",
+    };
+  }
+
+  const candidates = [];
+  if (hasAnyConfig(frontendCwd, CONFIG_FILES.vite, { existsSyncImpl, resolvePathImpl }) || allDeps.vite) {
+    candidates.push("vite");
+  }
+  if (hasAnyConfig(frontendCwd, CONFIG_FILES.astro, { existsSyncImpl, resolvePathImpl }) || allDeps.astro) {
+    candidates.push("astro");
+  }
+  if (
+    hasAnyConfig(frontendCwd, CONFIG_FILES.svelte, { existsSyncImpl, resolvePathImpl }) &&
+    allDeps["@sveltejs/adapter-static"]
+  ) {
+    candidates.push("sveltekit_static");
+  }
+
+  if (!explicit.frontendRoot && candidates.length > 1) {
+    return {
+      ok: false,
+      error: "Multiple static frontend candidates found. Pass --frontend-root and --out explicitly.",
+    };
+  }
+
+  const packageManager = detectPackageManager({ cwd, existsSyncImpl, resolvePathImpl });
+  const framework = explicit.framework || metadata.frontend?.framework || candidates[0] || "unknown";
+  const buildCommand =
+    explicit.buildCommand ||
+    metadata.frontend?.buildCommand ||
+    (frontendPkg.scripts?.build ? `${packageManager === "unknown" ? "npm" : packageManager} build` : "");
+  const outputDir =
+    explicit.outputDir || metadata.frontend?.outputDir || (framework === "astro" ? "dist" : "dist");
+  if (!isSafeProjectPath(outputDir, { allowDot: false })) {
+    return { ok: false, error: "Template static output directory must be a safe relative path" };
+  }
+
+  const hasBackend =
+    existsSyncImpl(resolvePathImpl(cwd, backendRoot, "index.ts")) ||
+    existsSyncImpl(resolvePathImpl(cwd, backendRoot, "schema.ts")) ||
+    existsSyncImpl(resolvePathImpl(cwd, "gencow.config.ts"));
+
+  return {
+    ok: true,
+    projectKind: hasBackend ? "full_stack" : "static_only",
+    frontendFramework: framework,
+    packageManager,
+    frontendRoot,
+    backendRoot,
+    buildWorkdir: frontendRoot,
+    buildCommand,
+    staticOutputDir: outputDir,
+  };
+}
+
+export function validateStaticOutput({
+  cwd = process.cwd(),
+  outputDir,
+  existsSyncImpl = existsSync,
+  readdirSyncImpl = readdirSync,
+  statSyncImpl = statSync,
+  resolvePathImpl = resolve,
+}) {
+  if (!isSafeProjectPath(outputDir, { allowDot: false })) {
+    return { ok: false, error: "Static output directory must be a safe relative path" };
+  }
+  const absolute = resolvePathImpl(cwd, outputDir);
+  if (!existsSyncImpl(resolvePathImpl(absolute, "index.html"))) {
+    return { ok: false, error: `Static output missing index.html: ${outputDir}` };
+  }
+  const entries = readdirSyncImpl(absolute);
+  const hasAsset = entries.some((entry) => {
+    const entryPath = resolvePathImpl(absolute, entry);
+    return entry !== "index.html" && statSyncImpl(entryPath).size >= 0;
+  });
+  return hasAsset ? { ok: true } : { ok: false, error: `Static output has no assets: ${outputDir}` };
+}
+
+export function buildTemplateTarExcludes(staticOutputDir) {
+  const excludes = [
+    ".git",
+    ".gencow",
+    ".env",
+    ".env.*",
+    "node_modules",
+    "coverage",
+    ".next",
+    ".svelte-kit",
+    "gencow.json",
+  ];
+  if (staticOutputDir) excludes.push(staticOutputDir.replace(/\/$/, ""));
+  return excludes;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencow",
-  "version": "0.1.137",
+  "version": "0.1.138",
   "description": "Gencow — AI Backend Engine",
   "type": "module",
   "bin": {