create-katajs 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yaseer A. Okino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# create-katajs
+
+Scaffolding CLI for [katajs](https://github.com/ookino/katajs) projects.
+
+```bash
+pnpm create katajs my-app
+# or
+npm create katajs@latest my-app
+# or
+yarn create katajs my-app
+```
+
+## Flags
+
+```bash
+pnpm create katajs my-app [options]
+
+Options:
+  --auth                  Add Better Auth scaffolding
+  --pm <pm>               Package manager (pnpm | npm | yarn | bun)
+  --no-install            Skip install step
+  --no-git                Skip git init
+  -h, --help              Show help
+```
+
+If you omit a name or skip flags, the CLI prompts interactively.
+
+## What you get
+
+A single-API Cloudflare Workers project with:
+
+- `@katajs/core` runtime + `@katajs/drizzle` adapter wired up
+- One example `posts` module (schema, repository, service, routes, errors)
+- Drizzle config + migration setup
+- `wrangler.jsonc` with Hyperdrive binding placeholder
+- `.dev.vars.example`
+- `.github/workflows/deploy.yml` stub
+- README with next-step instructions
+
+With `--auth`, you also get a `src/modules/auth/` integrating [Better Auth](https://better-auth.com), Better Auth tables added to your Drizzle schema, and a protected route on the example module.
+
+## After scaffolding
+
+```bash
+cd my-app
+
+# 1. Configure your Hyperdrive binding in wrangler.jsonc
+#    (see https://developers.cloudflare.com/hyperdrive/ to create one)
+
+# 2. Generate migrations from the schema
+pnpm db:generate
+
+# 3. Run dev server
+pnpm dev
+```
+
+## License
+
+[MIT](./LICENSE) © Yaseer A. Okino

package/dist/index.js

@@ -0,0 +1,568 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { cac } from "cac";
+import * as p from "@clack/prompts";
+import { cyan, dim, green, red, yellow } from "kolorist";
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { resolve as pathResolve } from "path";
+
+// src/scaffold.ts
+import { spawnSync } from "child_process";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, relative, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/codemod.ts
+var AnchorMissingError = class extends Error {
+  constructor(anchor) {
+    super(`Anchor "// katajs:${anchor}" not found`);
+    this.anchor = anchor;
+    this.name = "AnchorMissingError";
+  }
+  anchor;
+};
+function insertBeforeAnchor(content, anchor, lines) {
+  const anchorMatch = new RegExp(`^(\\s*)// katajs:${escapeRe(anchor)}\\s*$`, "m");
+  const m = content.match(anchorMatch);
+  if (!m) throw new AnchorMissingError(anchor);
+  const indent = m[1] ?? "";
+  const toInsert = (Array.isArray(lines) ? lines : [lines]).map((l) => indent + l).join("\n");
+  const allPresent = (Array.isArray(lines) ? lines : [lines]).every(
+    (l) => content.includes(l.trim())
+  );
+  if (allPresent) return content;
+  return content.replace(anchorMatch, `${toInsert}
+${m[0]}`);
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function appendRouteToChain(content, moduleVar) {
+  const newCallSig = `.route(${moduleVar}.prefix, ${moduleVar}.routes)`;
+  if (content.includes(newCallSig)) return content;
+  const lines = content.split("\n");
+  const anchorIdx = lines.findIndex(
+    (l) => /^\s*\/\/ katajs:routes\s*$/.test(l)
+  );
+  if (anchorIdx === -1) throw new AnchorMissingError("routes");
+  let lastChainIdx = -1;
+  const chainLineRe = /^\s*\.route\(\w+\.prefix,\s*\w+\.routes\)/;
+  for (let i = anchorIdx - 1; i >= Math.max(0, anchorIdx - 25); i--) {
+    if (chainLineRe.test(lines[i] ?? "")) {
+      lastChainIdx = i;
+      break;
+    }
+  }
+  if (lastChainIdx === -1) {
+    throw new Error(
+      "appendRouteToChain: could not locate a `.route(<X>.prefix, <X>.routes)` line above // katajs:routes"
+    );
+  }
+  const lastLine = lines[lastChainIdx];
+  const indent = lastLine.match(/^(\s*)/)?.[1] ?? "      ";
+  lines[lastChainIdx] = lastLine.replace(/,(\s*)$/, "$1");
+  lines.splice(
+    lastChainIdx + 1,
+    0,
+    `${indent}.route(${moduleVar}.prefix, ${moduleVar}.routes),`
+  );
+  return lines.join("\n");
+}
+
+// src/scaffold.ts
+var PROJECT_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".cjs",
+  ".mjs",
+  ".json",
+  ".jsonc",
+  ".md",
+  ".yml",
+  ".yaml",
+  ".example",
+  ".toml",
+  ""
+]);
+async function runScaffold(opts) {
+  const workerName = opts.workerName ?? "worker";
+  if (opts.worker && !opts.monorepo) {
+    throw new Error(
+      `--worker requires --monorepo. apps/${workerName} only makes sense in a monorepo layout.`
+    );
+  }
+  if (opts.worker && !PROJECT_NAME_RE.test(workerName)) {
+    throw new Error(
+      `Invalid worker name '${workerName}'. Use lowercase letters, digits, and hyphens (must start with a letter or digit).`
+    );
+  }
+  const templateName = opts.monorepo ? "monorepo" : "api";
+  const templateRoot = resolve(getTemplatesDir(), templateName);
+  if (!existsSync(templateRoot)) {
+    throw new Error(`Template directory not found: ${templateRoot}`);
+  }
+  ensureDir(opts.targetDir);
+  const tokens = {
+    PROJECT_NAME: opts.projectName,
+    TODAY_ISO: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    WORKER_NAME: workerName
+  };
+  copyTemplate(templateRoot, opts.targetDir, tokens);
+  if (opts.worker) {
+    const workerRoot = resolve(getTemplatesDir(), "monorepo-worker");
+    if (!existsSync(workerRoot)) {
+      throw new Error(`Worker template not found: ${workerRoot}`);
+    }
+    copyTemplate(workerRoot, opts.targetDir, tokens);
+    if (workerName !== "worker") {
+      const oldDir = join(opts.targetDir, "apps", "worker");
+      const newDir = join(opts.targetDir, "apps", workerName);
+      if (existsSync(oldDir)) {
+        renameSync(oldDir, newDir);
+      }
+    }
+    augmentForWorker(opts.targetDir, tokens);
+  }
+  renameUnderscorePrefixed(opts.targetDir);
+  if (opts.auth) {
+    const authVariant = opts.monorepo ? "monorepo" : "api";
+    const authRoot = resolve(getTemplatesDir(), "auth-snippets", authVariant);
+    if (!existsSync(authRoot)) {
+      throw new Error(`Auth snippet template not found: ${authRoot}`);
+    }
+    copyTemplate(authRoot, opts.targetDir, tokens);
+    if (opts.monorepo) {
+      augmentForAuthMonorepo(opts.targetDir, tokens);
+    } else {
+      augmentForAuth(opts.targetDir, tokens);
+    }
+  }
+  if (opts.install) {
+    runCommand(opts.packageManager, ["install"], opts.targetDir);
+  }
+  if (opts.initGit) {
+    runCommand("git", ["init", "-q"], opts.targetDir);
+    runCommand("git", ["add", "."], opts.targetDir);
+    runCommand(
+      "git",
+      ["commit", "-q", "-m", "Initial commit from create-katajs"],
+      opts.targetDir,
+      true
+    );
+  }
+}
+function renameUnderscorePrefixed(root) {
+  const renamableNames = /* @__PURE__ */ new Map([
+    ["_gitignore", ".gitignore"],
+    ["_dev.vars.example", ".dev.vars.example"]
+  ]);
+  const stack = [root];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry);
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        if (entry === "node_modules") continue;
+        stack.push(full);
+      } else if (st.isFile()) {
+        const target = renamableNames.get(entry);
+        if (target) {
+          renameSync(full, join(dir, target));
+        }
+      }
+    }
+  }
+}
+function getTemplatesDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [join(here, "templates"), join(here, "..", "src", "templates")];
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  return candidates[0];
+}
+function copyTemplate(srcRoot, dstRoot, tokens) {
+  const stack = [
+    { from: srcRoot, to: dstRoot }
+  ];
+  while (stack.length) {
+    const { from, to } = stack.pop();
+    ensureDir(to);
+    for (const entry of readdirSync(from)) {
+      const fromPath = join(from, entry);
+      const toPath = join(to, entry);
+      const st = statSync(fromPath);
+      if (st.isDirectory()) {
+        stack.push({ from: fromPath, to: toPath });
+      } else if (st.isFile()) {
+        copyFileWithTokens(fromPath, toPath, tokens);
+      }
+    }
+  }
+}
+function copyFileWithTokens(from, to, tokens) {
+  const ext = extOf(from);
+  if (TEXT_EXTENSIONS.has(ext)) {
+    const content = readFileSync(from, "utf8");
+    const replaced = applyTokens(content, tokens);
+    writeFileSync(to, replaced);
+  } else {
+    cpSync(from, to);
+  }
+}
+function applyTokens(content, tokens) {
+  return content.replace(/\{\{(\w+)\}\}/g, (_, key) => tokens[key] ?? `{{${key}}}`);
+}
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+function extOf(path) {
+  const base = path.split("/").pop() ?? "";
+  const idx = base.lastIndexOf(".");
+  if (idx <= 0) return "";
+  return base.slice(idx);
+}
+function runCommand(cmd, args, cwd, allowFailure = false) {
+  const res = spawnSync(cmd, args, { cwd, stdio: "inherit", shell: process.platform === "win32" });
+  if (res.status !== 0 && !allowFailure) {
+    throw new Error(`Command failed: ${cmd} ${args.join(" ")} (in ${relative(process.cwd(), cwd) || "."})`);
+  }
+}
+function augmentForAuth(targetDir, _tokens) {
+  const appPath = join(targetDir, "src", "app.ts");
+  if (existsSync(appPath)) {
+    let app = readFileSync(appPath, "utf8");
+    if (!app.includes("from './modules/auth/index'")) {
+      app = insertBeforeAnchor(
+        app,
+        "module-imports",
+        "import { authModule } from './modules/auth/index';"
+      );
+      app = insertBeforeAnchor(app, "modules", "authModule,");
+      app = appendRouteToChain(app, "authModule");
+      writeFileSync(appPath, app);
+    }
+  }
+  const typesPath = join(targetDir, "src", "types.d.ts");
+  if (existsSync(typesPath)) {
+    let types = readFileSync(typesPath, "utf8");
+    if (!types.includes("'./modules/auth/index'")) {
+      types = insertBeforeAnchor(
+        types,
+        "registry-imports",
+        "import type { AuthRegistry } from './modules/auth/index';"
+      );
+      types = insertBeforeAnchor(types, "registry", ", AuthRegistry");
+      writeFileSync(typesPath, types);
+    }
+  }
+  const modulesScript = join(targetDir, "scripts", "modules.ts");
+  if (existsSync(modulesScript)) {
+    let g = readFileSync(modulesScript, "utf8");
+    if (!g.includes("'../src/modules/auth/index'")) {
+      g = insertBeforeAnchor(
+        g,
+        "graph-imports",
+        "import { authModule } from '../src/modules/auth/index';"
+      );
+      g = insertBeforeAnchor(g, "graph-modules", "authModule,");
+      writeFileSync(modulesScript, g);
+    }
+  }
+  const schemaPath = join(targetDir, "src", "db", "schema.ts");
+  const authSchemaPath = join(targetDir, "src", "db", "auth-schema.ts");
+  if (existsSync(authSchemaPath) && existsSync(schemaPath)) {
+    const schemaContent = readFileSync(schemaPath, "utf8");
+    if (!schemaContent.includes("export * from './auth-schema';")) {
+      writeFileSync(
+        schemaPath,
+        schemaContent + "\nexport * from './auth-schema';\n"
+      );
+    }
+  }
+  const pkgPath = join(targetDir, "package.json");
+  if (existsSync(pkgPath)) {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    pkg.dependencies = { ...pkg.dependencies, "better-auth": "^1.0.0" };
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  }
+  const dvPath = join(targetDir, ".dev.vars.example");
+  if (existsSync(dvPath)) {
+    const content = readFileSync(dvPath, "utf8");
+    if (!content.includes("BETTER_AUTH_SECRET")) {
+      writeFileSync(
+        dvPath,
+        content.trimEnd() + '\nBETTER_AUTH_SECRET="replace-me-with-a-32-byte-secret"\nBETTER_AUTH_URL="http://localhost:8787"\n'
+      );
+    }
+  }
+}
+function augmentForAuthMonorepo(targetDir, tokens) {
+  const projectName = tokens.PROJECT_NAME ?? "";
+  const appPath = join(targetDir, "apps", "api", "src", "app.ts");
+  if (existsSync(appPath)) {
+    let app = readFileSync(appPath, "utf8");
+    if (!app.includes("from './modules/auth/index'")) {
+      app = insertBeforeAnchor(
+        app,
+        "module-imports",
+        "import { authModule } from './modules/auth/index';"
+      );
+      app = insertBeforeAnchor(app, "modules", "authModule,");
+      app = appendRouteToChain(app, "authModule");
+      writeFileSync(appPath, app);
+    }
+  }
+  const typesPath = join(targetDir, "apps", "api", "src", "types.d.ts");
+  if (existsSync(typesPath)) {
+    let types = readFileSync(typesPath, "utf8");
+    if (!types.includes("'./modules/auth/index'")) {
+      types = insertBeforeAnchor(
+        types,
+        "registry-imports",
+        "import type { AuthRegistry } from './modules/auth/index';"
+      );
+      types = insertBeforeAnchor(types, "registry", ", AuthRegistry");
+      writeFileSync(typesPath, types);
+    }
+  }
+  const modulesScript = join(targetDir, "apps", "api", "scripts", "modules.ts");
+  if (existsSync(modulesScript)) {
+    let g = readFileSync(modulesScript, "utf8");
+    if (!g.includes("'../src/modules/auth/index'")) {
+      g = insertBeforeAnchor(
+        g,
+        "graph-imports",
+        "import { authModule } from '../src/modules/auth/index';"
+      );
+      g = insertBeforeAnchor(g, "graph-modules", "authModule,");
+      writeFileSync(modulesScript, g);
+    }
+  }
+  const dbIndexPath = join(targetDir, "packages", "db", "src", "index.ts");
+  if (existsSync(dbIndexPath)) {
+    const dbIndex = readFileSync(dbIndexPath, "utf8");
+    if (!dbIndex.includes("export * from './auth-schema';")) {
+      writeFileSync(
+        dbIndexPath,
+        dbIndex.trimEnd() + "\nexport * from './auth-schema';\n"
+      );
+    }
+  }
+  const apiPkgPath = join(targetDir, "apps", "api", "package.json");
+  if (existsSync(apiPkgPath)) {
+    const pkg = JSON.parse(readFileSync(apiPkgPath, "utf8"));
+    pkg.dependencies = {
+      ...pkg.dependencies,
+      [`@${projectName}/auth`]: "workspace:*",
+      "better-auth": "^1.0.0"
+    };
+    writeFileSync(apiPkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  }
+  const dvPath = join(targetDir, "apps", "api", ".dev.vars.example");
+  if (existsSync(dvPath)) {
+    const content = readFileSync(dvPath, "utf8");
+    if (!content.includes("BETTER_AUTH_SECRET")) {
+      writeFileSync(
+        dvPath,
+        content.trimEnd() + '\nBETTER_AUTH_SECRET="replace-me-with-a-32-byte-secret"\nBETTER_AUTH_URL="http://localhost:8787"\n'
+      );
+    }
+  }
+}
+function augmentForWorker(targetDir, tokens) {
+  const projectName = tokens.PROJECT_NAME ?? "";
+  const workerName = tokens.WORKER_NAME ?? "worker";
+  const rootPkgPath = join(targetDir, "package.json");
+  if (!existsSync(rootPkgPath)) return;
+  const pkg = JSON.parse(readFileSync(rootPkgPath, "utf8"));
+  pkg.scripts = {
+    ...pkg.scripts,
+    deploy: `pnpm --filter @${projectName}/api deploy && pnpm --filter @${projectName}/${workerName} deploy`,
+    "deploy:api": `pnpm --filter @${projectName}/api deploy`,
+    [`deploy:${workerName}`]: `pnpm --filter @${projectName}/${workerName} deploy`
+  };
+  writeFileSync(rootPkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+
+// src/prompts.ts
+function detectPackageManager() {
+  const ua = process.env.npm_config_user_agent;
+  if (!ua) return void 0;
+  if (ua.startsWith("pnpm/")) return "pnpm";
+  if (ua.startsWith("bun/")) return "bun";
+  if (ua.startsWith("npm/")) return "npm";
+  return void 0;
+}
+
+// src/index.ts
+var PROJECT_NAME_RE2 = /^[a-z0-9][a-z0-9-]*$/;
+async function main() {
+  const cli = cac("create-katajs");
+  cli.command("[name]", "Scaffold a katajs project").option("--auth", "Include Better Auth").option("--monorepo", "Scaffold as a pnpm + Turbo monorepo (apps/api + packages/db + packages/api-client)").option("--worker [name]", 'Add a queue-consumer Worker app. Optional name (e.g. "payout-worker"); defaults to "worker". Requires --monorepo.').option("--no-install", "Skip pnpm/npm/bun install").option("--pm <pm>", "Force package manager (pnpm | npm | bun)").option("--no-git", "Skip git init + initial commit").action(async (name, flags) => {
+    try {
+      await run(name, flags);
+    } catch (err) {
+      p.log.error(red(err.message));
+      process.exit(1);
+    }
+  });
+  cli.help();
+  cli.version("0.1.0");
+  cli.parse();
+}
+async function run(rawName, flags) {
+  p.intro(cyan("create-katajs"));
+  const projectName = await resolveProjectName(rawName);
+  if (p.isCancel(projectName)) return p.cancel("Aborted.");
+  const targetDir = pathResolve(process.cwd(), projectName);
+  if (existsSync2(targetDir) && readdirSync2(targetDir).length > 0) {
+    throw new Error(`Target directory '${projectName}' is not empty.`);
+  }
+  const interactive = process.stdin.isTTY === true;
+  const monorepo = flags.monorepo ?? (interactive ? await askYesNo("Scaffold as a monorepo (apps/api + shared packages)?", false) : false);
+  if (p.isCancel(monorepo)) return p.cancel("Aborted.");
+  let worker = flags.worker !== void 0 && flags.worker !== false;
+  let workerName;
+  if (typeof flags.worker === "string" && flags.worker.length > 0) {
+    workerName = flags.worker;
+  } else if (worker) {
+    workerName = "worker";
+  } else {
+    workerName = "worker";
+  }
+  if (monorepo && flags.worker === void 0 && interactive) {
+    const answer = await askYesNo("Include a queue worker app?", false);
+    if (p.isCancel(answer)) return p.cancel("Aborted.");
+    worker = !!answer;
+    if (worker) {
+      const nameAnswer = await p.text({
+        message: "Worker name?",
+        placeholder: "worker",
+        initialValue: "worker",
+        validate: (v) => {
+          if (!v) return "Required";
+          if (!PROJECT_NAME_RE2.test(v))
+            return "Use lowercase letters, digits, and hyphens.";
+          return void 0;
+        }
+      });
+      if (p.isCancel(nameAnswer)) return p.cancel("Aborted.");
+      workerName = nameAnswer;
+    }
+  }
+  if (worker && !monorepo) {
+    throw new Error(
+      "--worker requires --monorepo. A worker app only makes sense in a monorepo layout."
+    );
+  }
+  if (worker && !PROJECT_NAME_RE2.test(workerName)) {
+    throw new Error(
+      `Invalid worker name '${workerName}'. Use lowercase letters, digits, and hyphens.`
+    );
+  }
+  const auth = flags.auth ?? (interactive ? await askYesNo("Include Better Auth?", false) : false);
+  if (p.isCancel(auth)) return p.cancel("Aborted.");
+  const detectedPm = detectPackageManager();
+  const pm = flags.pm ?? detectedPm ?? (interactive ? await askPm() : "pnpm");
+  if (p.isCancel(pm)) return p.cancel("Aborted.");
+  if (pm !== "pnpm" && pm !== "npm" && pm !== "bun") {
+    throw new Error(`Unsupported package manager '${pm}'. Use one of: pnpm, npm, bun.`);
+  }
+  const install = flags.install !== false;
+  const initGit = flags.git !== false;
+  p.log.step(
+    `Scaffolding ${green(projectName)} (${monorepo ? "monorepo" : "single-api"}, worker=${worker ? workerName : "no"}, auth=${auth ? "yes" : "no"}, pm=${pm}, install=${install ? "yes" : "no"}, git=${initGit ? "yes" : "no"})`
+  );
+  const opts = {
+    targetDir,
+    projectName,
+    auth: !!auth,
+    monorepo: !!monorepo,
+    worker,
+    workerName,
+    packageManager: pm,
+    install,
+    initGit
+  };
+  await runScaffold(opts);
+  p.outro(green(`\u2713 Created ${projectName} in ./${projectName}`));
+  console.log();
+  console.log("Next steps:");
+  console.log(`  ${cyan("cd")} ${projectName}`);
+  if (!install) console.log(`  ${cyan(pm)} install`);
+  console.log(`  ${cyan(pm)} dev`);
+  console.log();
+  console.log(dim("Resources:"));
+  console.log(dim("  Docs: https://github.com/<owner>/katajs"));
+  console.log(dim("  Hono: https://hono.dev"));
+  console.log(dim("  Hyperdrive: https://developers.cloudflare.com/hyperdrive"));
+}
+async function resolveProjectName(raw) {
+  if (raw) {
+    if (!PROJECT_NAME_RE2.test(raw)) {
+      throw new Error(
+        `Invalid project name '${raw}'. Use lowercase letters, digits, and hyphens (must start with a letter or digit).`
+      );
+    }
+    return raw;
+  }
+  if (process.stdin.isTTY !== true) {
+    throw new Error(
+      "Project name is required when running non-interactively. Pass it as the first positional argument."
+    );
+  }
+  const answer = await p.text({
+    message: "Project name?",
+    placeholder: "my-api",
+    validate: (v) => {
+      if (!v) return "Required";
+      if (!PROJECT_NAME_RE2.test(v)) return "Use lowercase letters, digits, and hyphens.";
+      return void 0;
+    }
+  });
+  return answer;
+}
+async function askYesNo(message, initial) {
+  return p.confirm({ message, initialValue: initial });
+}
+async function askPm() {
+  return p.select({
+    message: "Package manager?",
+    initialValue: "pnpm",
+    options: [
+      { value: "pnpm", label: "pnpm" },
+      { value: "npm", label: "npm" },
+      { value: "bun", label: "bun" }
+    ]
+  });
+}
+void main().catch((err) => {
+  console.error(yellow("Unexpected error:"));
+  console.error(err);
+  process.exit(1);
+});

package/dist/templates/api/.github/workflows/deploy.yml

@@ -0,0 +1,26 @@
+name: Deploy
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 9
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm typecheck
+      - uses: cloudflare/wrangler-action@v3
+        with:
+          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}