create-kide-app 0.0.8 → 0.0.9

package/index.js

@@ -2,7 +2,7 @@
 
 import * as p from "@clack/prompts";
 import { execSync } from "node:child_process";
-import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -13,9 +13,6 @@ const TEMPLATES_DIR = path.join(__dirname, "templates");
 
 const pm = { name: "pnpm", exec: "pnpm dlx", run: "pnpm", install: "pnpm install" };
 
-// --- Template repo URL ---
-const REPO_URL = "https://github.com/mhernesniemi/kide-cms/archive/refs/heads/main.tar.gz";
-
 // --- Main ---
 
 async function main() {
@@ -74,36 +71,15 @@ async function main() {
 
   const s = p.spinner();
 
-  // --- Scaffold ---
+  // --- Scaffold from base template ---
 
   s.start(`Scaffolding project (using ${pm.name})`);
 
-  mkdirSync(projectDir, { recursive: true });
-  const tmpArchive = path.join(projectDir, "_template.tar.gz");
-
-  try {
-    execSync(`curl -sL "${REPO_URL}" -o "${tmpArchive}"`, { stdio: "pipe" });
-    execSync(`tar -xzf "${tmpArchive}" -C "${projectDir}" --strip-components=1`, { stdio: "pipe" });
-    rmSync(tmpArchive, { force: true });
-  } catch {
-    s.message("Archive download failed, trying git clone...");
-    rmSync(projectDir, { recursive: true, force: true });
-    try {
-      execSync(`git clone --depth 1 https://github.com/mhernesniemi/kide-cms.git "${projectDir}"`, {
-        stdio: "pipe",
-      });
-      rmSync(path.join(projectDir, ".git"), { recursive: true, force: true });
-    } catch {
-      s.stop("Failed to download template.");
-      p.cancel("Check your network connection.");
-      process.exit(1);
-    }
-  }
+  cpSync(path.join(TEMPLATES_DIR, "base"), projectDir, { recursive: true });
 
-  // Remove files that shouldn't be in the scaffold
-  for (const remove of ["docs", "packages", "CLAUDE.md", ".claude", "data", ".cms-data", "dist", ".astro", ".env"]) {
-    const fp = path.join(projectDir, remove);
-    if (existsSync(fp)) rmSync(fp, { recursive: true, force: true });
+  // Apply demo schema and seed data if selected
+  if (seedDemo) {
+    cpSync(path.join(TEMPLATES_DIR, "demo"), projectDir, { recursive: true });
   }
 
   s.stop("Project scaffolded");
@@ -115,11 +91,11 @@ async function main() {
   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/core/db.ts"));
+  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/core/storage.ts"));
+    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"));
@@ -130,6 +106,10 @@ async function main() {
 
   pkg.name = projectName;
 
+  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";
@@ -216,6 +196,119 @@ async function main() {
     );
   }
 
+  // --- Cloudflare resource setup ---
+
+  const cf = { d1Created: false, r2Created: false, migrationsApplied: false };
+  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 {
+            s.stop("Migration generation failed");
+          }
+
+          s.start("Applying migrations to remote D1");
+          try {
+            execSync(`${pm.exec} wrangler d1 migrations apply ${projectName}-db --remote`, {
+              cwd: projectDir,
+              stdio: "pipe",
+            });
+            cf.migrationsApplied = true;
+            s.stop("Migrations applied");
+          } catch {
+            s.stop("Migration apply failed — run manually with: wrangler d1 migrations apply --remote");
+          }
+        }
+      }
+    }
+  }
+
   // --- Done ---
 
   if (target === "local") {
@@ -227,26 +320,25 @@ async function main() {
       console.log(`  To start again:   cd ${projectName} && pnpm dev\n`);
     }
   } else {
-    p.note(
-      [
-        `cd ${projectName}`,
-        "",
-        "Set up Cloudflare resources:",
+    const lines = [`cd ${projectName}`];
+    const remaining = [];
+    if (!cf.d1Created) {
+      remaining.push(
         `  ${pm.exec} wrangler d1 create ${projectName}-db`,
         "  # Copy the database_id to wrangler.toml",
-        `  ${pm.exec} wrangler r2 bucket create ${projectName}-assets`,
-        "",
-        "Push database schema:",
-        `  ${pm.exec} wrangler d1 migrations apply ${projectName}-db --remote`,
-        "",
-        "Local development:",
-        `  ${pm.run} dev`,
-        "",
-        "Deploy:",
-        "  pnpm run deploy",
-      ].join("\n"),
-      "Next steps",
-    );
+      );
+    }
+    if (!cf.r2Created) {
+      remaining.push(`  ${pm.exec} wrangler r2 bucket create ${projectName}-assets`);
+    }
+    if (!cf.migrationsApplied) {
+      remaining.push(`  ${pm.exec} wrangler d1 migrations apply ${projectName}-db --remote`);
+    }
+    if (remaining.length > 0) {
+      lines.push("", "Remaining setup:", ...remaining);
+    }
+    lines.push("", "Local development:", `  ${pm.run} dev`, "", "Deploy:", "  pnpm run deploy");
+    p.note(lines.join("\n"), "Next steps");
     p.outro("Project created!");
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-kide-app",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Scaffold a new Kide CMS project",
   "author": "Matti Hernesniemi",
   "license": "MIT",

package/templates/base/.env.example

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

package/templates/base/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "private": true,
+  "type": "module",
+  "version": "0.0.1",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "scripts": {
+    "dev": "astro dev",
+    "build": "astro build",
+    "preview": "astro preview",
+    "check": "astro check",
+    "cms:generate": "node --import tsx src/cms/internals/generator.ts",
+    "cms:admin": "node --import tsx src/cms/internals/create-admin.ts"
+  },
+  "dependencies": {
+    "@kidecms/core": "latest",
+    "@astrojs/node": "^10.0.1",
+    "@astrojs/react": "^5.0.0",
+    "@tailwindcss/typography": "^0.5.19",
+    "@tailwindcss/vite": "^4.2.1",
+    "astro": "^6.0.4",
+    "better-sqlite3": "^12.6.2",
+    "drizzle-orm": "^0.45.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "tailwindcss": "^4.2.1"
+  },
+  "devDependencies": {
+    "@astrojs/check": "^0.9.7",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "drizzle-kit": "^0.31.9",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/templates/base/src/cms/adapters/db.ts

@@ -0,0 +1,49 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+
+let dbInstance: ReturnType<typeof drizzle> | null = null;
+let sqliteInstance: InstanceType<typeof Database> | null = null;
+let migrated = false;
+
+const getDbPath = () => {
+  const url = process.env.CMS_DATABASE_URL;
+  if (url) return url;
+  return path.join(process.cwd(), "data", "cms.db");
+};
+
+export const getDb = async () => {
+  if (dbInstance) return dbInstance;
+
+  const dbPath = getDbPath();
+  mkdirSync(path.dirname(dbPath), { recursive: true });
+
+  sqliteInstance = new Database(dbPath);
+  sqliteInstance.pragma("journal_mode = WAL");
+  sqliteInstance.pragma("foreign_keys = ON");
+
+  dbInstance = drizzle(sqliteInstance);
+
+  if (!migrated) {
+    const migrationsFolder = path.join(process.cwd(), "src/cms/migrations");
+    try {
+      migrate(dbInstance, { migrationsFolder });
+    } catch {
+      // Ignore migration errors. In dev, tables may already exist via drizzle-kit push.
+    }
+    migrated = true;
+  }
+
+  return dbInstance;
+};
+
+export const closeDb = () => {
+  if (sqliteInstance) {
+    sqliteInstance.close();
+    sqliteInstance = null;
+    dbInstance = null;
+    migrated = false;
+  }
+};

package/templates/base/src/cms/adapters/email.ts

@@ -0,0 +1,34 @@
+export const sendInviteEmail = async (to: string, inviteUrl: string): Promise<boolean> => {
+  const apiKey = import.meta.env.RESEND_API_KEY;
+  if (!apiKey) return false;
+
+  const from = import.meta.env.RESEND_FROM_EMAIL ?? "Kide CMS <noreply@example.com>";
+
+  try {
+    const response = await fetch("https://api.resend.com/emails", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        from,
+        to,
+        subject: "You've been invited to Kide CMS",
+        html: `
+          <div style="font-family: sans-serif; max-width: 480px; margin: 0 auto;">
+            <h2 style="font-size: 20px;">You've been invited</h2>
+            <p>You've been invited to manage content on Kide CMS. Click the link below to set up your account:</p>
+            <p><a href="${inviteUrl}" style="display: inline-block; padding: 10px 20px; background: #0d9488; color: white; text-decoration: none; border-radius: 6px;">Accept invitation</a></p>
+            <p style="color: #666; font-size: 13px;">This link expires in 7 days. If you didn't expect this invitation, you can safely ignore it.</p>
+          </div>
+        `,
+      }),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+};
+
+export const isEmailConfigured = (): boolean => !!import.meta.env.RESEND_API_KEY;

package/templates/base/src/cms/adapters/storage.ts

@@ -0,0 +1,29 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+const publicDir = path.join(process.cwd(), "public");
+
+export async function putFile(storagePath: string, data: ArrayBuffer | Uint8Array): Promise<void> {
+  const filePath = path.join(publicDir, storagePath);
+  const dir = path.dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const buffer = data instanceof Uint8Array ? data : new Uint8Array(data);
+  await writeFile(filePath, buffer);
+}
+
+export async function getFile(storagePath: string): Promise<ArrayBuffer | null> {
+  const filePath = path.join(publicDir, storagePath);
+  if (!existsSync(filePath)) return null;
+  const buffer = await readFile(filePath);
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+}
+
+export async function deleteFile(storagePath: string): Promise<void> {
+  const filePath = path.join(publicDir, storagePath);
+  try {
+    await unlink(filePath);
+  } catch {
+    // File may already be deleted.
+  }
+}

package/templates/base/src/cms/cms.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "@kidecms/core";
+import users from "./collections/users";
+
+export default defineConfig({
+  database: { dialect: "sqlite" },
+  collections: [users],
+});

package/templates/base/src/cms/collections/users.ts

@@ -0,0 +1,20 @@
+import { defineCollection, fields } from "@kidecms/core";
+
+export default defineCollection({
+  slug: "users",
+  labels: { singular: "User", plural: "Users" },
+  auth: true,
+  timestamps: true,
+  views: {
+    list: { columns: ["name", "email", "role", "_updatedAt"] },
+  },
+  fields: {
+    name: fields.text({ required: true }),
+    email: fields.email({ required: true, unique: true }),
+    role: fields.select({
+      options: ["admin", "editor", "viewer"],
+      defaultValue: "editor",
+    }),
+    password: fields.text({ admin: { hidden: true } }),
+  },
+});

package/templates/base/src/cms/internals/create-admin.ts

@@ -0,0 +1,40 @@
+import { createInterface } from "node:readline";
+import { createAdminUser } from "@kidecms/core";
+
+import "./runtime";
+import { closeDb } from "../adapters/db";
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+const ask = (question: string): Promise<string> =>
+  new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim())));
+
+async function main() {
+  const name = await ask("Name: ");
+  if (!name) {
+    console.error("Name is required.");
+    process.exit(1);
+  }
+
+  const email = await ask("Email: ");
+  if (!email) {
+    console.error("Email is required.");
+    process.exit(1);
+  }
+
+  const password = await ask("Password: ");
+  if (!password || password.length < 4) {
+    console.error("Password must be at least 4 characters.");
+    process.exit(1);
+  }
+
+  rl.close();
+
+  await createAdminUser({ name, email, password });
+  console.log(`Admin user "${name}" created.`);
+  closeDb();
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/templates/base/src/cms/internals/generator.ts

@@ -0,0 +1,10 @@
+import path from "node:path";
+import { generate } from "@kidecms/core";
+
+import config from "../cms.config";
+
+await generate(config, {
+  outputDir: path.join(process.cwd(), "src/cms/.generated"),
+  runtimeImportPath: "../internals/runtime",
+  configImportPath: "../cms.config",
+});

package/templates/base/src/cms/internals/runtime.ts

@@ -0,0 +1,76 @@
+import {
+  configureCmsRuntime,
+  initSchema,
+  createCms,
+  assets,
+  folders,
+  hashPassword,
+  verifyPassword,
+  createSession,
+  validateSession,
+  destroySession,
+  getSessionUser,
+  createInvite,
+  validateInvite,
+  consumeInvite,
+  SESSION_COOKIE_NAME,
+  setSessionCookie,
+  clearSessionCookie,
+  acquireLock,
+  releaseLock,
+  isAiEnabled,
+  getAiModel,
+  streamAltText,
+  streamSeoDescription,
+  streamTranslation,
+} from "@kidecms/core";
+
+import * as schema from "../.generated/schema";
+import { closeDb, getDb } from "../adapters/db";
+import { deleteFile, getFile, putFile } from "../adapters/storage";
+import { isEmailConfigured, sendInviteEmail } from "../adapters/email";
+
+let initialized = false;
+
+export const initCmsRuntime = () => {
+  if (initialized) return;
+
+  initSchema(schema);
+  configureCmsRuntime({
+    getDb,
+    closeDb,
+    storage: { putFile, getFile, deleteFile },
+    email: { sendInviteEmail, isEmailConfigured },
+    env: (key) =>
+      (import.meta as ImportMeta & { env?: Record<string, string | undefined> }).env?.[key] ?? process.env[key],
+  });
+
+  initialized = true;
+};
+
+initCmsRuntime();
+
+export {
+  createCms,
+  assets,
+  folders,
+  hashPassword,
+  verifyPassword,
+  createSession,
+  validateSession,
+  destroySession,
+  getSessionUser,
+  createInvite,
+  validateInvite,
+  consumeInvite,
+  SESSION_COOKIE_NAME,
+  setSessionCookie,
+  clearSessionCookie,
+  acquireLock,
+  releaseLock,
+  isAiEnabled,
+  getAiModel,
+  streamAltText,
+  streamSeoDescription,
+  streamTranslation,
+};

package/templates/base/src/env.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="astro/client" />
+
+declare namespace App {
+  interface Locals {
+    user?: {
+      id: string;
+      email: string;
+      name: string;
+      role: string;
+    } | null;
+  }
+}

package/templates/base/src/pages/index.astro

@@ -0,0 +1,11 @@
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width" />
+    <title>My Site</title>
+  </head>
+  <body>
+    <h1>Welcome</h1>
+    <p><a href="/admin">Open Admin</a></p>
+  </body>
+</html>