create-kide-app 0.0.36 → 0.1.2

package/README.md

@@ -5,27 +5,28 @@ Scaffold a new [Kide CMS](https://github.com/mhernesniemi/kide-cms) project.
 ## Usage
 
 ```bash
-npm create kide-app my-project
-# or
 pnpm create kide-app my-project
 # or
-bunx create-kide-app my-project
+npm create kide-app my-project
 ```
 
-The CLI will guide you through:
+The CLI asks for:
 
 1. **Project name** — directory to create
-2. **Deploy target** — Local/Node.js or Cloudflare
-3. **Demo content** — optionally seed the database
+2. **Deploy target** — Node.js (default) or Cloudflare
 
 ## What it does
 
-- Downloads the latest Kide CMS template from GitHub
-- Applies platform-specific configuration (Node.js adapter, Cloudflare D1/R2, etc.)
-- Installs dependencies
-- Generates the CMS schema
-- Optionally seeds demo content
+1. Clones the latest `kide-cms` from GitHub (shallow).
+2. Removes the embedded `.git` and renames the project in `package.json`.
+3. If Cloudflare is selected, overlays the files from `adapters/cloudflare/` and patches `package.json` (swaps `@astrojs/node` → `@astrojs/cloudflare`, adds `wrangler`, removes `sharp`, etc.).
+4. Removes the `adapters/` scaffolding directory.
+5. Runs `pnpm install`.
+
+For Cloudflare projects, the CLI prints the remaining manual steps (create D1/R2, apply migrations).
 
 ## Requirements
 
 - Node.js >= 22.12.0
+- `git` on PATH
+- `pnpm`

package/index.js

@@ -1,51 +1,43 @@
 #!/usr/bin/env node
 
 import * as p from "@clack/prompts";
-import { execSync, spawn } from "node:child_process";
-import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { cpSync, existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TEMPLATES_DIR = path.join(__dirname, "templates");
+const REPO = "https://github.com/mhernesniemi/kide-cms.git";
 
-// Async spawn wrapper so long-running commands don't block clack spinners
-const runAsync = (cmd, cwd) =>
-  new Promise((resolve, reject) => {
-    const child = spawn(cmd, { cwd, shell: true });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (d) => (stdout += d.toString()));
-    child.stderr.on("data", (d) => (stderr += d.toString()));
-    child.on("close", (code) => {
-      if (code === 0) resolve(stdout);
-      else {
-        const err = new Error(`Command failed: ${cmd}`);
-        err.stderr = stderr;
-        err.stdout = stdout;
-        reject(err);
-      }
-    });
-  });
-
-// --- Package manager detection ---
-
-const pm = { name: "pnpm", exec: "pnpm exec", dlx: "pnpm dlx", run: "pnpm", install: "pnpm install" };
-
-// --- Main ---
+function applyPackagePatch(pkg, patch) {
+  for (const [k, v] of Object.entries(patch.dependencies?.add ?? {})) {
+    pkg.dependencies[k] = v;
+  }
+  for (const k of patch.dependencies?.remove ?? []) {
+    delete pkg.dependencies[k];
+  }
+  pkg.devDependencies ??= {};
+  for (const [k, v] of Object.entries(patch.devDependencies?.add ?? {})) {
+    pkg.devDependencies[k] = v;
+  }
+  for (const k of patch.devDependencies?.moveFromDependencies ?? []) {
+    if (pkg.dependencies[k]) {
+      pkg.devDependencies[k] = pkg.dependencies[k];
+      delete pkg.dependencies[k];
+    }
+  }
+  for (const [k, v] of Object.entries(patch.scripts ?? {})) {
+    pkg.scripts[k] = v;
+  }
+}
 
 async function main() {
-  p.intro("🪐 Create Kide CMS Project");
+  p.intro("Create Kide CMS Project");
 
-  // 1. Project name
   const projectName =
     process.argv[2] ||
     (await p.text({
       message: "Project name",
       placeholder: "my-cms-app",
-      validate: (value) => {
-        if (!value) return "Project name is required";
-      },
+      validate: (value) => (value ? undefined : "Project name is required"),
     }));
 
   if (p.isCancel(projectName)) {
@@ -59,28 +51,22 @@ async function main() {
     process.exit(1);
   }
 
-  // 2. Deploy target
-  const target = await p.select({
-    message: "Where will you deploy?",
-    options: [
-      { label: "Local / Node.js", value: "local" },
-      { label: "Cloudflare", value: "cloudflare" },
-    ],
+  const cloudflare = await p.confirm({
+    message: "Deploy to Cloudflare? (otherwise Node.js)",
+    initialValue: false,
   });
 
-  if (p.isCancel(target)) {
+  if (p.isCancel(cloudflare)) {
     p.cancel("Setup cancelled.");
     process.exit(0);
   }
 
-  // 3. Demo content (local only — Cloudflare uses remote D1)
   let seedDemo = false;
-  if (target === "local") {
+  if (!cloudflare) {
     const seed = await p.confirm({
       message: "Seed database with demo content?",
       initialValue: false,
     });
-
     if (p.isCancel(seed)) {
       p.cancel("Setup cancelled.");
       process.exit(0);
@@ -90,417 +76,106 @@ async function main() {
 
   const s = p.spinner();
 
-  // --- Scaffold from base template ---
-
-  s.start(`Scaffolding project (using ${pm.name})`);
-
-  cpSync(path.join(TEMPLATES_DIR, "base"), projectDir, { recursive: true });
-
-  // Rename gitignore → .gitignore (npm strips dotfiles from published tarballs)
-  const gitignoreSrc = path.join(projectDir, "gitignore");
-  if (existsSync(gitignoreSrc)) {
-    cpSync(gitignoreSrc, path.join(projectDir, ".gitignore"));
-    rmSync(gitignoreSrc);
-  }
-
-  // Apply demo schema and seed data if selected
-  if (seedDemo) {
-    cpSync(path.join(TEMPLATES_DIR, "demo"), projectDir, { recursive: true });
-  }
-
-  s.stop("Project scaffolded");
-
-  // --- Apply target-specific files ---
-
-  s.start(`Applying ${target} configuration`);
-
-  const targetDir = path.join(TEMPLATES_DIR, target);
-
-  cpSync(path.join(targetDir, "astro.config.mjs"), path.join(projectDir, "astro.config.mjs"));
-  cpSync(path.join(targetDir, "db.ts"), path.join(projectDir, "src/cms/adapters/db.ts"));
-  cpSync(path.join(targetDir, "drizzle.config.ts"), path.join(projectDir, "drizzle.config.ts"));
-
-  if (target === "cloudflare") {
-    cpSync(path.join(targetDir, "storage.ts"), path.join(projectDir, "src/cms/adapters/storage.ts"));
-    const uploadsRouteDir = path.join(projectDir, "src/pages/uploads");
-    mkdirSync(uploadsRouteDir, { recursive: true });
-    cpSync(path.join(targetDir, "uploads-route.ts"), path.join(uploadsRouteDir, "[...path].ts"));
-  }
+  s.start("Cloning kide-cms");
+  execSync(`git clone --depth 1 ${REPO} "${projectDir}"`, { stdio: "pipe" });
+  rmSync(path.join(projectDir, ".git"), { recursive: true, force: true });
+  s.stop("Cloned");
 
   const pkgPath = path.join(projectDir, "package.json");
   const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-
   pkg.name = projectName;
+  pkg.version = "0.0.1";
+
+  const adaptersDir = path.join(projectDir, "adapters");
+
+  if (cloudflare) {
+    s.start("Applying Cloudflare adapter");
+    const cfDir = path.join(adaptersDir, "cloudflare");
+
+    const overlayFiles = [
+      "astro.config.mjs",
+      "drizzle.config.ts",
+      "src/cms/adapters/db.ts",
+      "src/cms/adapters/storage.ts",
+      "src/pages/uploads/[...path].ts",
+    ];
+    for (const f of overlayFiles) {
+      cpSync(path.join(cfDir, f), path.join(projectDir, f));
+    }
 
-  if (seedDemo) {
-    pkg.scripts["cms:seed"] = "node --import tsx src/cms/internals/seed.ts";
-  }
-
-  if (target === "cloudflare") {
-    delete pkg.dependencies["@astrojs/node"];
-    pkg.dependencies["@astrojs/cloudflare"] = "^13.0.0";
-    // libsql is for local target only; Cloudflare uses D1 directly
-    delete pkg.dependencies["@libsql/client"];
-    delete pkg.dependencies["sharp"];
-
-    let wranglerContent = readFileSync(path.join(targetDir, "wrangler.toml"), "utf-8");
-    wranglerContent = wranglerContent.replaceAll("{{PROJECT_NAME}}", projectName);
-    writeFileSync(path.join(projectDir, "wrangler.toml"), wranglerContent);
+    const wrangler = readFileSync(path.join(cfDir, "wrangler.toml"), "utf-8").replaceAll(
+      "{{PROJECT_NAME}}",
+      projectName,
+    );
+    writeFileSync(path.join(projectDir, "wrangler.toml"), wrangler);
 
-    pkg.devDependencies.wrangler = "^4.0.0";
+    const patch = JSON.parse(readFileSync(path.join(cfDir, "package.patch.json"), "utf-8"));
+    applyPackagePatch(pkg, patch);
 
-    pkg.scripts.dev = "astro dev";
-    pkg.scripts.build = "astro build";
-    pkg.scripts.preview = "astro build && wrangler dev --config dist/server/wrangler.json";
-    pkg.scripts.deploy = "astro build && wrangler deploy --config dist/server/wrangler.json";
+    s.stop("Cloudflare adapter applied");
   }
 
+  rmSync(adaptersDir, { recursive: true, force: true });
   writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
 
-  if (target === "cloudflare") {
-    const gitignorePath = path.join(projectDir, ".gitignore");
-    const gitignore = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
-    writeFileSync(gitignorePath, gitignore + "\n# Cloudflare\n.wrangler/\n");
-  }
-
-  s.stop("Configuration applied");
-
-  // --- Install dependencies ---
-
   s.start("Installing dependencies");
   try {
-    await runAsync(pm.install, projectDir);
+    execSync("pnpm install", { cwd: projectDir, stdio: "pipe" });
     s.stop("Dependencies installed");
   } catch {
-    s.stop(`${pm.install} failed — run it manually`);
+    s.stop("pnpm install failed — run it manually");
   }
 
-  // --- Initialize git repository ---
-
-  let gitInitialized = false;
-  try {
-    execSync("git init -q && git add . && git commit -q -m 'Initial commit from create-kide-app'", {
-      cwd: projectDir,
-      stdio: "pipe",
-    });
-    gitInitialized = true;
-  } catch {
-    // git not available — silently skip
-  }
-
-  // --- Optional: create GitHub repository ---
-
-  if (gitInitialized) {
-    let ghAvailable = false;
+  if (seedDemo) {
+    s.start("Generating CMS schema");
     try {
-      execSync("gh --version", { stdio: "pipe" });
-      execSync("gh auth status", { stdio: "pipe" });
-      ghAvailable = true;
+      execSync("pnpm cms:generate", { cwd: projectDir, stdio: "pipe" });
+      s.stop("Schema generated");
     } catch {
-      // gh not installed or not authenticated — skip the prompt
+      s.stop("Schema generation failed — run `pnpm cms:generate` manually");
     }
 
-    if (ghAvailable) {
-      const createRepo = await p.confirm({
-        message: "Create a GitHub repository for this project?",
-        initialValue: false,
-      });
-      if (!p.isCancel(createRepo) && createRepo) {
-        // Get the GitHub username so we can check repo availability
-        let ghUser = "";
-        try {
-          ghUser = execSync("gh api user --jq .login", { stdio: "pipe" }).toString().trim();
-        } catch {}
-
-        // Prompt for repo name, validate it doesn't already exist
-        let repoName = null;
-        while (true) {
-          const input = await p.text({
-            message: "Repository name",
-            initialValue: projectName,
-            validate: (value) => {
-              if (!value) return "Repository name is required";
-              if (!/^[a-zA-Z0-9._-]+$/.test(value)) return "Only letters, numbers, dots, hyphens, and underscores";
-            },
-          });
-          if (p.isCancel(input)) break;
-
-          // Check if repo already exists under the user's account
-          if (ghUser) {
-            try {
-              execSync(`gh repo view ${ghUser}/${input}`, { stdio: "pipe" });
-              p.note(`A repository named "${input}" already exists. Pick a different name.`, "Name taken");
-              continue;
-            } catch {
-              // Repo doesn't exist — name is free
-            }
-          }
-          repoName = input;
-          break;
-        }
-
-        if (repoName) {
-          const visibility = await p.select({
-            message: "Repository visibility",
-            options: [
-              { label: "Private", value: "--private" },
-              { label: "Public", value: "--public" },
-            ],
-          });
-          if (!p.isCancel(visibility)) {
-            s.start("Creating GitHub repository");
-            try {
-              execSync(`gh repo create ${repoName} ${visibility} --source=. --push`, {
-                cwd: projectDir,
-                stdio: "pipe",
-              });
-              s.stop("GitHub repository created and pushed");
-            } catch (err) {
-              s.stop("GitHub repository creation failed");
-              if (err.stderr) console.error(err.stderr.toString().slice(-500));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // --- Generate schema ---
-
-  s.start("Generating CMS schema");
-  try {
-    execSync(`${pm.run} cms:generate`, { cwd: projectDir, stdio: "pipe" });
-    s.stop("Schema generated");
-  } catch {
-    s.stop("Schema generation failed — run `cms:generate` manually");
-  }
-
-  // --- Seed demo content ---
-
-  if (seedDemo && target === "local") {
     s.start("Pushing schema to database");
-    // Ensure data/ directory exists — drizzle-kit push silently exits 0 if it can't open the file
-    mkdirSync(path.join(projectDir, "data"), { recursive: true });
-    let pushOk = false;
     try {
-      const out = execSync(`${pm.exec} drizzle-kit push --force`, {
-        cwd: projectDir,
-        stdio: "pipe",
-      }).toString();
-      // drizzle-kit exits 0 even on connection errors, so verify by checking output
-      pushOk = !out.includes("Error:") && out.includes("Changes applied");
-      s.stop(pushOk ? "Schema pushed" : "Schema push failed — run `pnpm exec drizzle-kit push` manually");
+      execSync("pnpm exec drizzle-kit push --force", { cwd: projectDir, stdio: "pipe" });
+      s.stop("Schema pushed");
     } catch {
-      s.stop("Schema will be set up on first dev start");
+      s.stop("Schema push failed — will be set up on first dev start");
     }
+
     s.start("Seeding demo content");
     try {
-      execSync(`${pm.run} cms:seed`, { cwd: projectDir, stdio: "pipe" });
+      execSync("pnpm cms:seed", { cwd: projectDir, stdio: "pipe" });
       s.stop("Demo content seeded");
-    } catch (err) {
+    } catch {
       s.stop("Seeding failed — run `pnpm cms:seed` manually");
-      if (err.stderr) console.error(err.stderr.toString());
-      if (err.stdout) console.error(err.stdout.toString());
     }
-  } else if (seedDemo && target === "cloudflare") {
+  }
+
+  if (cloudflare) {
     p.note(
       [
-        "Seeding for Cloudflare requires a D1 database.",
+        `cd ${projectName}`,
+        "",
+        "1. Create Cloudflare resources:",
+        `   pnpm wrangler d1 create ${projectName}-db`,
+        "   # Paste the database_id into wrangler.toml",
+        `   pnpm wrangler r2 bucket create ${projectName}-assets`,
         "",
-        `  ${pm.dlx} wrangler d1 create ${projectName}-db`,
-        "  # Add the database_id to wrangler.toml",
-        `  ${pm.dlx} wrangler d1 migrations apply ${projectName}-db --local`,
-        `  ${pm.run} cms:seed`,
+        "2. Generate and apply migrations:",
+        "   pnpm cms:generate && pnpm exec drizzle-kit generate",
+        `   pnpm wrangler d1 migrations apply ${projectName}-db --remote`,
+        "",
+        "3. Run locally or deploy:",
+        "   pnpm dev",
+        "   pnpm deploy",
       ].join("\n"),
-      "Seed manually",
+      "Next steps",
     );
-  }
-
-  // --- Cloudflare resource setup ---
-
-  const cf = { d1Created: false, r2Created: false, migrationsApplied: false, deployed: false, url: null };
-  if (target === "cloudflare") {
-    const setupNow = await p.confirm({
-      message: "Set up Cloudflare resources now? (creates D1 database and R2 bucket)",
-      initialValue: true,
-    });
-
-    if (!p.isCancel(setupNow) && setupNow) {
-      // Check wrangler authentication
-      let authenticated = false;
-      try {
-        execSync(`${pm.exec} wrangler whoami`, { cwd: projectDir, stdio: "pipe" });
-        authenticated = true;
-      } catch {
-        p.note("You need to log in to Cloudflare first.", "Wrangler login required");
-        const doLogin = await p.confirm({ message: "Open browser to log in?", initialValue: true });
-        if (!p.isCancel(doLogin) && doLogin) {
-          try {
-            execSync(`${pm.exec} wrangler login`, { cwd: projectDir, stdio: "inherit" });
-            authenticated = true;
-          } catch {
-            s.stop("Login failed");
-          }
-        }
-      }
-
-      if (authenticated) {
-        // Create D1 database
-        let databaseId = null;
-        s.start("Creating D1 database");
-        try {
-          const output = execSync(`${pm.exec} wrangler d1 create ${projectName}-db`, {
-            cwd: projectDir,
-            stdio: "pipe",
-          }).toString();
-          // Parse database_id from output (looks for UUID-like string)
-          const match = output.match(/database_id\s*=\s*"([^"]+)"/);
-          if (match) databaseId = match[1];
-          cf.d1Created = true;
-          s.stop("D1 database created");
-        } catch (err) {
-          // Already exists — look it up
-          try {
-            const listOutput = execSync(`${pm.exec} wrangler d1 list`, { cwd: projectDir, stdio: "pipe" }).toString();
-            const lines = listOutput.split("\n");
-            const dbLine = lines.find((l) => l.includes(`${projectName}-db`));
-            if (dbLine) {
-              const idMatch = dbLine.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
-              if (idMatch) databaseId = idMatch[0];
-            }
-            if (databaseId) {
-              cf.d1Created = true;
-              s.stop("D1 database already exists — using existing");
-            } else {
-              s.stop("D1 setup failed");
-              if (err.stderr) console.error(err.stderr.toString());
-            }
-          } catch {
-            s.stop("D1 setup failed");
-          }
-        }
-
-        // Update wrangler.toml with database_id
-        if (databaseId) {
-          const wranglerPath = path.join(projectDir, "wrangler.toml");
-          let wranglerContent = readFileSync(wranglerPath, "utf-8");
-          wranglerContent = wranglerContent.replace(/database_id = "" #[^\n]*/, `database_id = "${databaseId}"`);
-          writeFileSync(wranglerPath, wranglerContent);
-        }
-
-        // Create R2 bucket
-        s.start("Creating R2 bucket");
-        try {
-          execSync(`${pm.exec} wrangler r2 bucket create ${projectName}-assets`, { cwd: projectDir, stdio: "pipe" });
-          cf.r2Created = true;
-          s.stop("R2 bucket created");
-        } catch {
-          // Already exists is fine — assume it's there
-          cf.r2Created = true;
-          s.stop("R2 bucket already exists");
-        }
-
-        // Generate migrations and apply to remote D1
-        if (databaseId) {
-          s.start("Generating database migrations");
-          try {
-            execSync(`${pm.exec} drizzle-kit generate`, { cwd: projectDir, stdio: "pipe" });
-            s.stop("Migrations generated");
-          } catch (err) {
-            s.stop("Migration generation failed");
-            if (err.stderr) console.error(err.stderr.toString().slice(-800));
-            if (err.stdout) console.error(err.stdout.toString().slice(-800));
-          }
-
-          s.start("Applying migrations to remote D1");
-          try {
-            execSync(`${pm.exec} wrangler d1 migrations apply ${projectName}-db --remote`, {
-              cwd: projectDir,
-              stdio: "pipe",
-              input: "y\n",
-            });
-            cf.migrationsApplied = true;
-            s.stop("Migrations applied");
-          } catch {
-            s.stop("Migration apply failed — run manually with: wrangler d1 migrations apply --remote");
-          }
-        }
-
-        // Deploy to Cloudflare
-        if (cf.migrationsApplied) {
-          const doDeploy = await p.confirm({
-            message: "Deploy to Cloudflare now?",
-            initialValue: true,
-          });
-          if (!p.isCancel(doDeploy) && doDeploy) {
-            s.start("Building and deploying to Cloudflare");
-            try {
-              const deployOutput = await runAsync(`${pm.run} run deploy`, projectDir);
-              const urlMatch = deployOutput.match(/https:\/\/[^\s]+\.workers\.dev/);
-              if (urlMatch) cf.url = urlMatch[0];
-              cf.deployed = true;
-              s.stop("Deployed to Cloudflare");
-            } catch (err) {
-              s.stop("Deploy failed — run manually with: pnpm run deploy");
-              if (err.stderr) console.error(err.stderr.slice(-1500));
-              if (err.stdout) console.error(err.stdout.slice(-1500));
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // --- Done ---
-
-  if (target === "local") {
-    p.outro("Starting dev server...");
-    try {
-      execSync(`${pm.run} dev`, { cwd: projectDir, stdio: "inherit" });
-    } catch {
-      console.log(`\n  Project directory: ${projectDir}`);
-      console.log(`  To start again:   cd ${projectName} && pnpm dev\n`);
-    }
+    p.outro("Project created!");
   } else {
-    if (cf.deployed && cf.url) {
-      p.note(
-        [
-          `Live at: ${cf.url}`,
-          `Admin:   ${cf.url}/admin`,
-          "",
-          `cd ${projectName}`,
-          "",
-          "Local development:",
-          `  ${pm.run} dev`,
-          "",
-          "Redeploy:",
-          "  pnpm run deploy",
-        ].join("\n"),
-        "🎉 Your Kide CMS is live",
-      );
-      p.outro("Project created!");
-    } else {
-      const lines = [`cd ${projectName}`];
-      const remaining = [];
-      if (!cf.d1Created) {
-        remaining.push(`  ${pm.dlx} wrangler d1 create ${projectName}-db`, "  # Copy the database_id to wrangler.toml");
-      }
-      if (!cf.r2Created) {
-        remaining.push(`  ${pm.dlx} wrangler r2 bucket create ${projectName}-assets`);
-      }
-      if (!cf.migrationsApplied) {
-        remaining.push(`  ${pm.dlx} wrangler d1 migrations apply ${projectName}-db --remote`);
-      }
-      if (!cf.deployed) {
-        remaining.push(`  ${pm.run} run deploy`);
-      }
-      if (remaining.length > 0) {
-        lines.push("", "Remaining setup:", ...remaining);
-      }
-      lines.push("", "Local development:", `  ${pm.run} dev`);
-      p.note(lines.join("\n"), "Next steps");
-      p.outro("Project created!");
-    }
+    p.note([`cd ${projectName}`, "pnpm dev"].join("\n"), "Next steps");
+    p.outro("Project created!");
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-kide-app",
-  "version": "0.0.36",
+  "version": "0.1.2",
   "description": "Scaffold a new Kide CMS project",
   "author": "Matti Hernesniemi",
   "license": "MIT",
@@ -9,8 +9,7 @@
     "create-kide-app": "./index.js"
   },
   "files": [
-    "index.js",
-    "templates"
+    "index.js"
   ],
   "repository": {
     "type": "git",

package/templates/base/.env.example

@@ -1,2 +0,0 @@
-# Optional: Enable AI features
-# OPENAI_API_KEY=sk-...