spfn 0.2.0-beta.46 → 0.2.0-beta.48

package/dist/index.js

@@ -535,8 +535,8 @@ async function setupApiProxy(cwd, includeAuth) {
   const rpcDir = join6(appDir, "api", "rpc", "[routeName]");
   const rpcRoutePath = join6(rpcDir, "route.ts");
   if (existsSync6(rpcRoutePath)) {
-    logger.error(`RPC proxy route already exists: ${rpcRoutePath.replace(cwd + "/", "")}`);
-    process.exit(1);
+    logger.warn(`RPC proxy route already exists, skipping: ${rpcRoutePath.replace(cwd + "/", "")}`);
+    return;
   }
   ensureDirSync3(rpcDir);
   const authImport = includeAuth ? `import '@spfn/auth/nextjs/api';
@@ -573,10 +573,17 @@ var init_api_proxy = __esm({
 });
 
 // src/commands/init/steps/docker.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync2 } from "fs";
 import { join as join7 } from "path";
 import fse4 from "fs-extra";
-async function setupDockerFiles(cwd) {
+function adaptDockerfileForPm(content, pm) {
+  const adaptations = PM_DOCKERFILE_ADAPTATIONS[pm];
+  if (!adaptations) {
+    return content;
+  }
+  return adaptations.reduce((acc, [from, to]) => acc.replace(from, to), content);
+}
+async function setupDockerFiles(cwd, pm = "pnpm") {
   const templatesDir = findTemplatesPath();
   const dockerComposePath = join7(cwd, "docker-compose.yml");
   if (!existsSync7(dockerComposePath)) {
@@ -595,8 +602,9 @@ async function setupDockerFiles(cwd) {
     if (!existsSync7(dockerfilePath)) {
       const dockerfileTemplate = join7(templatesDir, "Dockerfile");
       if (existsSync7(dockerfileTemplate)) {
-        copySync2(dockerfileTemplate, dockerfilePath);
-        logger.success("Created Dockerfile");
+        const content = adaptDockerfileForPm(readFileSync2(dockerfileTemplate, "utf-8"), pm);
+        writeFileSync3(dockerfilePath, content);
+        logger.success(`Created Dockerfile (${pm})`);
       }
     }
     const dockerignorePath = join7(cwd, ".dockerignore");
@@ -619,13 +627,39 @@ async function setupDockerFiles(cwd) {
     logger.warn("Could not copy Docker files (you can create them manually)");
   }
 }
-var copySync2;
+var copySync2, writeFileSync3, PM_DOCKERFILE_ADAPTATIONS;
 var init_docker = __esm({
   "src/commands/init/steps/docker.ts"() {
     "use strict";
     init_logger();
     init_templates();
-    ({ copySync: copySync2 } = fse4);
+    ({ copySync: copySync2, writeFileSync: writeFileSync3 } = fse4);
+    PM_DOCKERFILE_ADAPTATIONS = {
+      npm: [
+        ["# Install pnpm\nRUN corepack enable pnpm\n\n", ""],
+        ["pnpm-lock.yaml*", "package-lock.json*"],
+        ["RUN pnpm install --frozen-lockfile --prod=false", "RUN npm ci --include=dev"],
+        ["RUN pnpm run spfn:build", "RUN npm run spfn:build"],
+        ["RUN pnpm prune --prod", "RUN npm prune --omit=dev"],
+        ['CMD ["pnpm", "run", "spfn:start"]', 'CMD ["npm", "run", "spfn:start"]']
+      ],
+      yarn: [
+        ["RUN corepack enable pnpm", "RUN corepack enable yarn"],
+        ["pnpm-lock.yaml*", "yarn.lock*"],
+        ["RUN pnpm install --frozen-lockfile --prod=false", "RUN yarn install --frozen-lockfile"],
+        ["RUN pnpm run spfn:build", "RUN yarn run spfn:build"],
+        ["# Remove dev dependencies (optional, reduces image size)\nRUN pnpm prune --prod\n\n", ""],
+        ['CMD ["pnpm", "run", "spfn:start"]', 'CMD ["yarn", "run", "spfn:start"]']
+      ],
+      bun: [
+        ["# Install pnpm\nRUN corepack enable pnpm", "# Install bun\nRUN npm install -g bun"],
+        ["pnpm-lock.yaml*", "bun.lockb*"],
+        ["RUN pnpm install --frozen-lockfile --prod=false", "RUN bun install --frozen-lockfile"],
+        ["RUN pnpm run spfn:build", "RUN bun run spfn:build"],
+        ["# Remove dev dependencies (optional, reduces image size)\nRUN pnpm prune --prod\n\n", ""],
+        ['CMD ["pnpm", "run", "spfn:start"]', 'CMD ["bun", "run", "spfn:start"]']
+      ]
+    };
   }
 });
 
@@ -737,25 +771,25 @@ export default {
   }
 }
 `;
-      writeFileSync3(deploymentConfigPath, configContent);
+      writeFileSync4(deploymentConfigPath, configContent);
       logger.success(`Created spfn.config.js (subdomain: ${projectName}.spfn.app)`);
     } catch (error) {
       logger.warn("Could not create spfn.config.js");
     }
   }
 }
-var writeFileSync3;
+var writeFileSync4;
 var init_deployment_config = __esm({
   "src/commands/init/steps/deployment-config.ts"() {
     "use strict";
     init_logger();
-    ({ writeFileSync: writeFileSync3 } = fse5);
+    ({ writeFileSync: writeFileSync4 } = fse5);
   }
 });
 
 // src/utils/version.ts
 function getCliVersion() {
-  return "0.2.0-beta.46";
+  return "0.2.0-beta.48";
 }
 function getTagFromVersion(version) {
   const match = version.match(/-([a-z]+)\./i);
@@ -784,6 +818,8 @@ async function setupPackageJson(cwd, packageJsonPath, packageJson, packageManage
   packageJson.dependencies["@sinclair/typebox"] = "^0.34.0";
   packageJson.dependencies["drizzle-orm"] = "^0.45.0";
   packageJson.dependencies["drizzle-typebox"] = "^0.1.0";
+  packageJson.dependencies["postgres"] = "^3.4.0";
+  packageJson.dependencies["pg"] = "^8.16.3";
   packageJson.dependencies["spfn"] = spfnTag;
   packageJson.dependencies["concurrently"] = "^9.2.1";
   if (includeAuth) {
@@ -806,7 +842,7 @@ async function setupPackageJson(cwd, packageJsonPath, packageJson, packageManage
   packageJson.scripts["spfn:start"] = "spfn start";
   packageJson.scripts["spfn:build"] = "spfn build";
   packageJson.scripts["codegen"] = "spfn codegen run";
-  writeFileSync4(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  writeFileSync5(packageJsonPath, JSON.stringify(packageJson, null, 2));
   spinner.succeed("package.json updated");
   spinner.start("Installing dependencies...");
   try {
@@ -819,18 +855,18 @@ async function setupPackageJson(cwd, packageJsonPath, packageJson, packageManage
     process.exit(1);
   }
 }
-var writeFileSync4;
+var writeFileSync5;
 var init_package = __esm({
   "src/commands/init/steps/package.ts"() {
     "use strict";
     init_logger();
     init_version();
-    ({ writeFileSync: writeFileSync4 } = fse6);
+    ({ writeFileSync: writeFileSync5 } = fse6);
   }
 });
 
 // src/commands/init/steps/config-files.ts
-import { existsSync as existsSync9, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync3 } from "fs";
 import { join as join9 } from "path";
 import fse7 from "fs-extra";
 async function setupConfigFiles(cwd) {
@@ -857,7 +893,7 @@ export default defineConfig({
     ]
 });
 `;
-    writeFileSync5(spfnrcPath, spfnrcContent);
+    writeFileSync6(spfnrcPath, spfnrcContent);
     logger.success("Created .spfnrc.ts (codegen configuration)");
   }
   updateGitignore(cwd);
@@ -892,7 +928,8 @@ CACHE_URL=redis://localhost:6379
 # SPFN App URL (optional, for CORS and redirects)
 # SPFN_APP_URL=http://localhost:3790
 `);
-  writeEnvExample(cwd, ".env.server.example", `# Server-only defaults (committed)
+  writeEnvExample(cwd, ".env.server.example", `# Server-only environment (template)
+# Copy to .env.server (gitignored) and fill in real values.
 # These values are only loaded by the SPFN server, not by Next.js.
 
 # Database pool
@@ -902,9 +939,8 @@ DB_POOL_IDLE_TIMEOUT=30
 # Server timeouts
 SERVER_TIMEOUT=120000
 SHUTDOWN_TIMEOUT=30000
-`);
-  writeEnvExample(cwd, ".env.server.local.example", `# Server secrets (gitignored)
-# Server-only sensitive values. Never commit this file.
+
+# --- Secrets (never commit .env.server) ---
 
 # Database write/read URLs (master-replica pattern, optional)
 # DATABASE_WRITE_URL=postgresql://user:password@master:5432/dbname
@@ -919,7 +955,7 @@ function writeEnvExample(cwd, filename, content) {
   if (existsSync9(filePath)) {
     return;
   }
-  writeFileSync5(filePath, content);
+  writeFileSync6(filePath, content);
   logger.success(`Created ${filename}`);
 }
 function updateGitignore(cwd) {
@@ -928,7 +964,7 @@ function updateGitignore(cwd) {
     return;
   }
   try {
-    const content = readFileSync2(gitignorePath, "utf-8");
+    const content = readFileSync3(gitignorePath, "utf-8");
     let updated = content;
     let changed = false;
     if (!content.includes(".spfn")) {
@@ -943,11 +979,18 @@ function updateGitignore(cwd) {
 # environment secrets (local overrides)
 .env.local
 .env.*.local
+`;
+      changed = true;
+    }
+    if (!content.includes(".env.server")) {
+      updated += `
+# spfn server env (secrets)
+.env.server
 `;
       changed = true;
     }
     if (changed) {
-      writeFileSync5(gitignorePath, updated);
+      writeFileSync6(gitignorePath, updated);
       logger.success("Updated .gitignore with .spfn directory and env patterns");
     }
   } catch (error) {
@@ -960,26 +1003,26 @@ function updateTsconfig(cwd) {
     return;
   }
   try {
-    const tsconfigContent = readFileSync2(tsconfigPath, "utf-8");
+    const tsconfigContent = readFileSync3(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(tsconfigContent);
     if (!tsconfig.exclude) {
       tsconfig.exclude = [];
     }
     if (!tsconfig.exclude.includes("src/server")) {
       tsconfig.exclude.push("src/server");
-      writeFileSync5(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+      writeFileSync6(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
       logger.success("Updated tsconfig.json (excluded src/server for Vercel compatibility)");
     }
   } catch (error) {
     logger.warn('Could not update tsconfig.json (you can add "src/server" to exclude manually)');
   }
 }
-var writeFileSync5;
+var writeFileSync6;
 var init_config_files = __esm({
   "src/commands/init/steps/config-files.ts"() {
     "use strict";
     init_logger();
-    ({ writeFileSync: writeFileSync5 } = fse7);
+    ({ writeFileSync: writeFileSync6 } = fse7);
   }
 });
 
@@ -998,7 +1041,7 @@ async function initializeSpfn(options = {}) {
   logger.step(`Detected package manager: ${pm}`);
   await setupServerStructure(cwd);
   await setupApiProxy(cwd, includeAuth);
-  await setupDockerFiles(cwd);
+  await setupDockerFiles(cwd, pm);
   await setupDeploymentConfig(cwd, packageJson, pm);
   await setupPackageJson(cwd, packageJsonPath, packageJson, pm, includeAuth);
   await setupConfigFiles(cwd);
@@ -1046,7 +1089,7 @@ import chalk12 from "chalk";
 import { join as join15 } from "path";
 import { env as env2 } from "@spfn/core/config";
 import { loadEnv as loadEnv2 } from "@spfn/core/server";
-import { existsSync as existsSync16, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync16, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
 function discoverFunctionMigrations(cwd = process.cwd()) {
   const nodeModulesPath = join15(cwd, "node_modules");
   if (!existsSync16(nodeModulesPath)) {
@@ -1065,7 +1108,7 @@ function discoverFunctionMigrations(cwd = process.cwd()) {
       continue;
     }
     try {
-      const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
       const spfnConfig = packageJson.spfn;
       if (!spfnConfig?.migrations) {
         continue;
@@ -1111,7 +1154,7 @@ async function migrateLegacyTable(db, functionMigrations) {
     if (!existsSync16(journalPath)) {
       continue;
     }
-    const journal = JSON.parse(readFileSync5(journalPath, "utf-8"));
+    const journal = JSON.parse(readFileSync6(journalPath, "utf-8"));
     const entries = journal.entries || [];
     const tableName = `__spfn_fn_${func.packageName.replace("@spfn/", "")}_migrations`;
     await db.execute(
@@ -1137,7 +1180,7 @@ async function migrateLegacyTable(db, functionMigrations) {
       if (!existsSync16(sqlPath)) {
         continue;
       }
-      const sqlContent = readFileSync5(sqlPath, "utf-8");
+      const sqlContent = readFileSync6(sqlPath, "utf-8");
       const hash = createHash("sha256").update(sqlContent).digest("hex");
       const found = legacyRows.find((r) => r.hash === hash);
       if (found) {
@@ -1190,7 +1233,7 @@ var init_function_migrations = __esm({
 });
 
 // src/index.ts
-import { Command as Command13 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/commands/create.ts
 init_logger();
@@ -1366,7 +1409,6 @@ async function createProject(projectName, options) {
   console.log("  " + chalk4.cyan("Or deploy with Docker:"));
   console.log(`    ${chalk4.cyan("docker compose -f docker-compose.production.yml up --build -d")}
 `);
-  console.log(chalk4.dim("  \u{1F4D6} See .guide/deployment.md for complete deployment guide"));
   console.log(chalk4.dim("  \u{1F310} Documentation: https://github.com/spfn/spfn\n"));
 }
 var createCommand = new Command3("create").description("Create a new Next.js project with SPFN").argument("<project-name>", "Name of the project directory").option("--skip-install", "Skip installing dependencies").option("--skip-git", "Skip initializing a git repository").option("--pm <manager>", "Package manager to use (npm, pnpm, yarn, bun)").option("--shadcn", "Setup shadcn/ui (component library)").option("-y, --yes", "Skip prompts and use defaults").action(async (projectName, options) => {
@@ -1380,7 +1422,7 @@ init_init();
 init_logger();
 init_package_manager();
 import { Command as Command4 } from "commander";
-import { existsSync as existsSync11, readFileSync as readFileSync3, writeFileSync as writeFileSync6, mkdirSync, unlinkSync, rmSync, watch } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync4, writeFileSync as writeFileSync7, mkdirSync, unlinkSync, rmSync, watch } from "fs";
 import { join as join11 } from "path";
 import { execa as execa4 } from "execa";
 import chokidar from "chokidar";
@@ -1395,11 +1437,11 @@ function waitForReadyFile(filePath, timeoutMs = 3e4) {
     }, timeoutMs);
     const dir = join11(filePath, "..");
     const fileName = filePath.split("/").pop();
-    const watcher = watch(dir, (event, name) => {
+    const watcher = watch(dir, (_event, name) => {
       if (name === fileName && existsSync11(filePath)) {
         watcher.close();
         clearTimeout(timer);
-        resolve3(readFileSync3(filePath, "utf-8").trim());
+        resolve3(readFileSync4(filePath, "utf-8").trim());
       }
     });
   });
@@ -1419,7 +1461,7 @@ var devCommand = new Command4("dev").description("Start SPFN development server
   const packageJsonPath = join11(cwd, "package.json");
   let hasNext = false;
   if (existsSync11(packageJsonPath)) {
-    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
     hasNext = !!(packageJson.dependencies?.next || packageJson.devDependencies?.next);
   }
   const tempDir = join11(cwd, ".spfn");
@@ -1441,7 +1483,7 @@ var devCommand = new Command4("dev").description("Start SPFN development server
   if (options.routes) configParts.push(`routesPath: '${options.routes}'`);
   configParts.push("debug: true");
   const readyFile = join11(tempDir, "server-ready");
-  writeFileSync6(serverEntry, `
+  writeFileSync7(serverEntry, `
 import { writeFileSync } from 'fs';
 
 // Load environment variables FIRST (before any imports that depend on them)
@@ -1457,7 +1499,7 @@ const instance = await startServer({
 // Signal ready with actual port
 writeFileSync(${JSON.stringify(readyFile)}, String(instance.config.port));
 `);
-  writeFileSync6(watcherEntry, `
+  writeFileSync7(watcherEntry, `
 // Load environment variables
 // const { loadEnvFiles } = await import('@spfn/core/server');
 // loadEnvFiles();
@@ -1730,7 +1772,7 @@ catch (error)
 init_logger();
 init_package_manager();
 import { Command as Command5 } from "commander";
-import { existsSync as existsSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { existsSync as existsSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { join as join12 } from "path";
 import { execa as execa5 } from "execa";
 import ora5 from "ora";
@@ -1846,7 +1888,7 @@ await startServer({
     debug: false
 });
 `;
-      writeFileSync7(prodServerPath, prodServerContent);
+      writeFileSync8(prodServerPath, prodServerContent);
       spinner.succeed(`SPFN server build completed \u2192 .spfn/server`);
       const routesDir = join12(cwd, ".spfn", "server", "routes");
       if (existsSync12(routesDir)) {
@@ -1905,7 +1947,7 @@ var buildCommand = new Command5("build").description("Build SPFN project for pro
 init_logger();
 init_package_manager();
 import { Command as Command6 } from "commander";
-import { existsSync as existsSync13, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync5 } from "fs";
 import { join as join13 } from "path";
 import { execa as execa6 } from "execa";
 import chalk6 from "chalk";
@@ -1917,7 +1959,7 @@ var startCommand = new Command6("start").description("Start SPFN production serv
   const packageJsonPath = join13(cwd, "package.json");
   let hasNext = false;
   if (existsSync13(packageJsonPath)) {
-    const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
     hasNext = !!(packageJson.dependencies?.next || packageJson.devDependencies?.next);
   }
   const builtServerDir = join13(cwd, ".spfn", "server");
@@ -1969,7 +2011,7 @@ var startCommand = new Command6("start").description("Start SPFN production serv
     return;
   }
   const nextCmd = "next start -H 0.0.0.0 -p 3790";
-  const serverCmd = `node ${serverEntry}`;
+  const serverCmd = `node "${serverEntry}"`;
   console.log(chalk6.blue.bold("\n\u{1F680} Starting SPFN production server...\n"));
   logger.info("Next.js: http://0.0.0.0:3790");
   logger.info(`SPFN API: http://${options.host}:${options.port}
@@ -1977,11 +2019,10 @@ var startCommand = new Command6("start").description("Start SPFN production serv
   try {
     await execa6(
       pm === "npm" ? "npx" : pm,
-      pm === "npm" ? ["concurrently", "--raw", "--kill-others", `"${nextCmd}"`, `"${serverCmd}"`] : ["exec", "concurrently", "--raw", "--kill-others", `"${nextCmd}"`, `"${serverCmd}"`],
+      pm === "npm" ? ["concurrently", "--raw", "--kill-others", nextCmd, serverCmd] : ["exec", "concurrently", "--raw", "--kill-others", nextCmd, serverCmd],
       {
         stdio: "inherit",
         cwd,
-        shell: true,
         env: { ...process.env }
       }
     );
@@ -1998,7 +2039,7 @@ var startCommand = new Command6("start").description("Start SPFN production serv
 // src/commands/codegen.ts
 init_logger();
 import { Command as Command7 } from "commander";
-import { existsSync as existsSync14, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync14, writeFileSync as writeFileSync9 } from "fs";
 import { join as join14 } from "path";
 import chalk7 from "chalk";
 async function initCodegen(options) {
@@ -2019,7 +2060,7 @@ async function initCodegen(options) {
       ]
     }
   };
-  writeFileSync8(rcPath, JSON.stringify(config, null, 2) + "\n");
+  writeFileSync9(rcPath, JSON.stringify(config, null, 2) + "\n");
   console.log("\n" + chalk7.green.bold("\u2713 Created .spfnrc.ts\n"));
   console.log("Configuration:");
   console.log(chalk7.gray(JSON.stringify(config, null, 2)));
@@ -2234,7 +2275,7 @@ import { Command as Command9 } from "commander";
 import chalk10 from "chalk";
 
 // src/commands/db/utils/drizzle.ts
-import { existsSync as existsSync15, writeFileSync as writeFileSync9, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync15, writeFileSync as writeFileSync10, unlinkSync as unlinkSync2 } from "fs";
 import { spawn } from "child_process";
 import { pathToFileURL } from "url";
 import chalk9 from "chalk";
@@ -2269,7 +2310,7 @@ async function runDrizzleCommand(command) {
       expandGlobs: true,
       autoDetectSchemas: true
     });
-    writeFileSync9(tempConfigPath, configContent);
+    writeFileSync10(tempConfigPath, configContent);
     console.log(chalk9.dim("Using auto-generated Drizzle config\n"));
   }
   const args = command.split(" ");
@@ -2590,7 +2631,7 @@ async function applyFunctionMigrations() {
 }
 
 // src/commands/db/migrate.ts
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 import { join as join16 } from "path";
 import { existsSync as existsSync18 } from "fs";
 
@@ -2598,11 +2639,13 @@ import { existsSync as existsSync18 } from "fs";
 import { promises as fs3 } from "fs";
 import path3 from "path";
 import { spawn as spawn2 } from "child_process";
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 import ora7 from "ora";
 
 // src/commands/db/utils/database.ts
 import net from "net";
+import chalk14 from "chalk";
+import prompts4 from "prompts";
 function parseDatabaseUrl(dbUrl) {
   try {
     const url = new URL(dbUrl);
@@ -2618,6 +2661,24 @@ function parseDatabaseUrl(dbUrl) {
     throw new Error(`Invalid DATABASE_URL format: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
 }
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
+function isRemoteHost(host) {
+  return !LOCAL_HOSTS.has(host);
+}
+async function confirmDangerousTarget(dbInfo) {
+  if (!isRemoteHost(dbInfo.host) && process.env.NODE_ENV !== "production") {
+    return;
+  }
+  const { typed } = await prompts4({
+    type: "text",
+    name: "typed",
+    message: `Remote/production database detected. Type the database name "${dbInfo.database}" to continue:`
+  });
+  if (typed !== dbInfo.database) {
+    console.log(chalk14.gray("Cancelled (database name mismatch)."));
+    process.exit(0);
+  }
+}
 async function isPortAvailable(port) {
   return new Promise((resolve3) => {
     const server = net.createServer();
@@ -2667,14 +2728,14 @@ function formatTimestamp() {
 import { promises as fs2 } from "fs";
 import { existsSync as existsSync17 } from "fs";
 import path2 from "path";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 
 // src/commands/db/utils/metadata.ts
 import { promises as fs } from "fs";
 import path from "path";
 import { promisify } from "util";
 import { exec } from "child_process";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 var execAsync = promisify(exec);
 async function collectGitInfo() {
   try {
@@ -2737,7 +2798,7 @@ async function collectMigrationInfo(dbUrl) {
       await pool.end();
     }
   } catch (error) {
-    console.log(chalk14.dim("\u26A0\uFE0F  Could not fetch migration info"));
+    console.log(chalk15.dim("\u26A0\uFE0F  Could not fetch migration info"));
     return void 0;
   }
 }
@@ -2745,9 +2806,9 @@ async function saveBackupMetadata(metadata, backupFilename) {
   const metadataPath = backupFilename.replace(/\.(sql|dump)$/, ".meta.json");
   try {
     await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
-    console.log(chalk14.dim(`\u2713 Metadata saved: ${path.basename(metadataPath)}`));
+    console.log(chalk15.dim(`\u2713 Metadata saved: ${path.basename(metadataPath)}`));
   } catch (error) {
-    console.log(chalk14.dim("\u26A0\uFE0F  Could not save metadata"));
+    console.log(chalk15.dim("\u26A0\uFE0F  Could not save metadata"));
   }
 }
 async function loadBackupMetadata(backupFilename) {
@@ -2776,10 +2837,10 @@ async function ensureBackupInGitignore() {
     if (!hasBackupsIgnore) {
       const entry = exists && content && !content.endsWith("\n") ? "\n\n# Database backups\nbackups/\n" : "# Database backups\nbackups/\n";
       await fs2.appendFile(gitignorePath, entry);
-      console.log(chalk15.dim("\u2713 Added backups/ to .gitignore"));
+      console.log(chalk16.dim("\u2713 Added backups/ to .gitignore"));
     }
   } catch (error) {
-    console.log(chalk15.dim("\u26A0\uFE0F  Could not update .gitignore"));
+    console.log(chalk16.dim("\u26A0\uFE0F  Could not update .gitignore"));
   }
 }
 async function ensureBackupDir() {
@@ -2829,12 +2890,12 @@ async function listBackupFiles() {
 import { env as env3 } from "@spfn/core/config";
 import { loadEnv as loadEnv4 } from "@spfn/core/server";
 async function dbBackup(options) {
-  console.log(chalk16.blue("\u{1F4BE} Creating database backup...\n"));
+  console.log(chalk17.blue("\u{1F4BE} Creating database backup...\n"));
   loadEnv4();
   const dbUrl = env3.DATABASE_URL;
   if (!dbUrl) {
-    console.error(chalk16.red("\u274C DATABASE_URL not found in environment"));
-    console.log(chalk16.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    console.error(chalk17.red("\u274C DATABASE_URL not found in environment"));
+    console.log(chalk17.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
     process.exit(1);
   }
   const dbInfo = parseDatabaseUrl(dbUrl);
@@ -2844,7 +2905,7 @@ async function dbBackup(options) {
   const ext = format === "sql" ? "sql" : "dump";
   const filename = options.output || path3.join(backupDir, `${dbInfo.database}_${timestamp}.${ext}`);
   if (options.dataOnly && options.schemaOnly) {
-    console.error(chalk16.red("\u274C Cannot use --data-only and --schema-only together"));
+    console.error(chalk17.red("\u274C Cannot use --data-only and --schema-only together"));
     process.exit(1);
   }
   const args = [
@@ -2890,11 +2951,11 @@ async function dbBackup(options) {
           const stats = await fs3.stat(filename);
           const size = formatBytes(stats.size);
           spinner.succeed("Backup created");
-          console.log(chalk16.green(`
+          console.log(chalk17.green(`
 \u2705 Backup created successfully`));
-          console.log(chalk16.gray(`   File: ${filename}`));
-          console.log(chalk16.gray(`   Size: ${size}`));
-          console.log(chalk16.dim("\n\u{1F4CB} Collecting metadata..."));
+          console.log(chalk17.gray(`   File: ${filename}`));
+          console.log(chalk17.gray(`   Size: ${size}`));
+          console.log(chalk17.dim("\n\u{1F4CB} Collecting metadata..."));
           const [gitInfo, migrationInfo] = await Promise.all([
             collectGitInfo(),
             collectMigrationInfo(dbUrl)
@@ -2934,11 +2995,11 @@ async function dbBackup(options) {
       reject(error);
     });
   }).catch((error) => {
-    console.error(chalk16.red("\n\u274C Failed to create backup"));
+    console.error(chalk17.red("\n\u274C Failed to create backup"));
     if (errorOutput.includes("pg_dump: command not found") || errorOutput.includes("not found")) {
-      console.error(chalk16.yellow("\n\u{1F4A1} pg_dump is not installed. Please install PostgreSQL client tools."));
+      console.error(chalk17.yellow("\n\u{1F4A1} pg_dump is not installed. Please install PostgreSQL client tools."));
     } else {
-      console.error(chalk16.red(error instanceof Error ? error.message : "Unknown error"));
+      console.error(chalk17.red(error instanceof Error ? error.message : "Unknown error"));
     }
     process.exit(1);
   });
@@ -2955,7 +3016,7 @@ async function dbMigrate(options = {}) {
     process.exit(1);
   }
   if (options.withBackup) {
-    console.log(chalk17.blue("\u{1F4E6} Creating pre-migration backup...\n"));
+    console.log(chalk18.blue("\u{1F4E6} Creating pre-migration backup...\n"));
     await dbBackup({
       format: "custom",
       tag: "pre-migration",
@@ -2968,57 +3029,56 @@ async function dbMigrate(options = {}) {
   const postgres = await import("postgres");
   loadEnv5();
   if (!env4.DATABASE_URL) {
-    console.error(chalk17.red("\u274C DATABASE_URL not found in environment"));
+    console.error(chalk18.red("\u274C DATABASE_URL not found in environment"));
     process.exit(1);
   }
   const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
   const functions = discoverFunctionMigrations2(process.cwd());
   if (functions.length > 0) {
-    console.log(chalk17.blue("\u{1F4E6} Applying function package migrations:"));
+    console.log(chalk18.blue("\u{1F4E6} Applying function package migrations:"));
     functions.forEach((func) => {
-      console.log(chalk17.dim(`  - ${func.packageName}`));
+      console.log(chalk18.dim(`  - ${func.packageName}`));
     });
     await executeFunctionMigrations2(functions);
-    console.log(chalk17.green("\u2705 Function migrations applied\n"));
+    console.log(chalk18.green("\u2705 Function migrations applied\n"));
   }
   const projectMigrationsDir = join16(process.cwd(), "src/server/drizzle");
   if (existsSync18(projectMigrationsDir)) {
     const projConn = postgres.default(env4.DATABASE_URL, { max: 1 });
     const projDb = drizzle(projConn);
     try {
-      console.log(chalk17.blue("\u{1F4E6} Running project migrations..."));
+      console.log(chalk18.blue("\u{1F4E6} Running project migrations..."));
       await migrate(projDb, {
         migrationsFolder: projectMigrationsDir,
         migrationsTable: PROJECT_MIGRATIONS_TABLE
       });
-      console.log(chalk17.green("\u2705 Project migrations applied successfully"));
+      console.log(chalk18.green("\u2705 Project migrations applied successfully"));
     } finally {
       await projConn.end();
     }
   } else {
-    console.log(chalk17.dim("No project migrations found (src/server/drizzle)"));
+    console.log(chalk18.dim("No project migrations found (src/server/drizzle)"));
   }
 }
 
 // src/commands/db/studio.ts
-import chalk18 from "chalk";
-import { existsSync as existsSync19, writeFileSync as writeFileSync10, unlinkSync as unlinkSync3 } from "fs";
+import chalk19 from "chalk";
+import { existsSync as existsSync19, writeFileSync as writeFileSync11, unlinkSync as unlinkSync3 } from "fs";
 import { spawn as spawn3 } from "child_process";
 import { env as env5 } from "@spfn/core/config";
-import "@spfn/core/config";
 async function dbStudio(requestedPort) {
-  console.log(chalk18.blue("\u{1F3A8} Opening Drizzle Studio...\n"));
+  console.log(chalk19.blue("\u{1F3A8} Opening Drizzle Studio...\n"));
   const defaultPort = 4983;
   const startPort = requestedPort || defaultPort;
   let port;
   try {
     port = await findAvailablePort(startPort);
     if (port !== startPort) {
-      console.log(chalk18.yellow(`\u26A0\uFE0F  Port ${startPort} is in use, using port ${port} instead
+      console.log(chalk19.yellow(`\u26A0\uFE0F  Port ${startPort} is in use, using port ${port} instead
 `));
     }
   } catch (error) {
-    console.error(chalk18.red(error instanceof Error ? error.message : "Failed to find available port"));
+    console.error(chalk19.red(error instanceof Error ? error.message : "Failed to find available port"));
     process.exit(1);
   }
   const hasUserConfig = existsSync19("./drizzle.config.ts");
@@ -3027,8 +3087,8 @@ async function dbStudio(requestedPort) {
     const configPath = hasUserConfig ? "./drizzle.config.ts" : tempConfigPath;
     if (!hasUserConfig) {
       if (!env5.DATABASE_URL) {
-        console.error(chalk18.red("\u274C DATABASE_URL not found in environment"));
-        console.log(chalk18.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+        console.error(chalk19.red("\u274C DATABASE_URL not found in environment"));
+        console.log(chalk19.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
         process.exit(1);
       }
       const { generateDrizzleConfigFile } = await import("@spfn/core/db");
@@ -3038,8 +3098,8 @@ async function dbStudio(requestedPort) {
         expandGlobs: true
         // Expand glob patterns for Studio compatibility
       });
-      writeFileSync10(tempConfigPath, configContent);
-      console.log(chalk18.dim("Using auto-generated Drizzle config\n"));
+      writeFileSync11(tempConfigPath, configContent);
+      console.log(chalk19.dim("Using auto-generated Drizzle config\n"));
     }
     const studioProcess = spawn3("drizzle-kit", ["studio", `--port=${port}`, `--config=${configPath}`], {
       stdio: "inherit",
@@ -3054,19 +3114,19 @@ async function dbStudio(requestedPort) {
     studioProcess.on("exit", (code) => {
       cleanup();
       if (code !== 0 && code !== null) {
-        console.error(chalk18.red(`
+        console.error(chalk19.red(`
 \u274C Drizzle Studio exited with code ${code}`));
         process.exit(code);
       }
     });
     studioProcess.on("error", (error) => {
       cleanup();
-      console.error(chalk18.red("\u274C Failed to start Drizzle Studio"));
-      console.error(chalk18.red(error.message));
+      console.error(chalk19.red("\u274C Failed to start Drizzle Studio"));
+      console.error(chalk19.red(error.message));
       process.exit(1);
     });
     process.on("SIGINT", () => {
-      console.log(chalk18.yellow("\n\n\u{1F44B} Shutting down Drizzle Studio..."));
+      console.log(chalk19.yellow("\n\n\u{1F44B} Shutting down Drizzle Studio..."));
       studioProcess.kill("SIGTERM");
       cleanup();
       process.exit(0);
@@ -3080,27 +3140,39 @@ async function dbStudio(requestedPort) {
     if (!hasUserConfig && existsSync19(tempConfigPath)) {
       unlinkSync3(tempConfigPath);
     }
-    console.error(chalk18.red("\u274C Failed to start Drizzle Studio"));
-    console.error(chalk18.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk19.red("\u274C Failed to start Drizzle Studio"));
+    console.error(chalk19.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 
 // src/commands/db/drop.ts
-import chalk19 from "chalk";
-import prompts4 from "prompts";
+import chalk20 from "chalk";
+import prompts5 from "prompts";
+import { env as env6 } from "@spfn/core/config";
+import { loadEnv as loadEnv6 } from "@spfn/core/server";
 async function dbDrop() {
-  console.log(chalk19.yellow("\u26A0\uFE0F  WARNING: This will drop all tables in your database!"));
-  const { confirm } = await prompts4({
+  loadEnv6();
+  if (!env6.DATABASE_URL) {
+    console.error(chalk20.red("\u274C DATABASE_URL not found in environment"));
+    console.log(chalk20.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    process.exit(1);
+  }
+  const dbInfo = parseDatabaseUrl(env6.DATABASE_URL);
+  console.log(chalk20.yellow("\u26A0\uFE0F  WARNING: This will drop all tables in your database!"));
+  console.log(chalk20.dim(`   Target: ${dbInfo.database} @ ${dbInfo.host}:${dbInfo.port}
+`));
+  const { confirm } = await prompts5({
     type: "confirm",
     name: "confirm",
     message: "Are you sure you want to drop all tables?",
     initial: false
   });
   if (!confirm) {
-    console.log(chalk19.gray("Cancelled."));
+    console.log(chalk20.gray("Cancelled."));
     process.exit(0);
   }
+  await confirmDangerousTarget(dbInfo);
   await runWithSpinner(
     "Dropping all tables...",
     "drop",
@@ -3110,7 +3182,7 @@ async function dbDrop() {
 }
 
 // src/commands/db/check.ts
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 import ora8 from "ora";
 async function dbCheck() {
   const spinner = ora8("Checking database connection...").start();
@@ -3119,7 +3191,7 @@ async function dbCheck() {
     spinner.succeed("Database connection OK");
   } catch (error) {
     spinner.fail("Database connection failed");
-    console.error(chalk20.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk21.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
@@ -3127,28 +3199,28 @@ async function dbCheck() {
 // src/commands/db/restore.ts
 import path4 from "path";
 import { spawn as spawn4 } from "child_process";
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 import ora9 from "ora";
-import prompts5 from "prompts";
-import { env as env6 } from "@spfn/core/config";
-import { loadEnv as loadEnv6 } from "@spfn/core/server";
+import prompts6 from "prompts";
+import { env as env7 } from "@spfn/core/config";
+import { loadEnv as loadEnv7 } from "@spfn/core/server";
 async function dbRestore(backupFile, options = {}) {
-  console.log(chalk21.blue("\u267B\uFE0F  Restoring database from backup...\n"));
-  loadEnv6();
-  const dbUrl = env6.DATABASE_URL;
+  console.log(chalk22.blue("\u267B\uFE0F  Restoring database from backup...\n"));
+  loadEnv7();
+  const dbUrl = env7.DATABASE_URL;
   if (!dbUrl) {
-    console.error(chalk21.red("\u274C DATABASE_URL not found in environment"));
-    console.log(chalk21.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    console.error(chalk22.red("\u274C DATABASE_URL not found in environment"));
+    console.log(chalk22.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
     process.exit(1);
   }
   let file = backupFile;
   if (!file) {
     const backups = await listBackupFiles();
     if (backups.length === 0) {
-      console.log(chalk21.yellow("No backups found in ./backups directory"));
+      console.log(chalk22.yellow("No backups found in ./backups directory"));
       process.exit(0);
     }
-    const { selected } = await prompts5({
+    const { selected } = await prompts6({
       type: "select",
       name: "selected",
       message: "Select backup to restore:",
@@ -3158,31 +3230,31 @@ async function dbRestore(backupFile, options = {}) {
       }))
     });
     if (!selected) {
-      console.log(chalk21.gray("Cancelled"));
+      console.log(chalk22.gray("Cancelled"));
       process.exit(0);
     }
     file = selected;
   }
   if (!file) {
-    console.error(chalk21.red("\u274C No backup file selected"));
+    console.error(chalk22.red("\u274C No backup file selected"));
     process.exit(1);
   }
   const metadata = await loadBackupMetadata(file);
   if (metadata) {
-    console.log(chalk21.blue("\n\u{1F4CB} Backup Information:\n"));
-    console.log(chalk21.dim(`  Database: ${metadata.database}`));
-    console.log(chalk21.dim(`  Created: ${new Date(metadata.timestamp).toLocaleString()}`));
+    console.log(chalk22.blue("\n\u{1F4CB} Backup Information:\n"));
+    console.log(chalk22.dim(`  Database: ${metadata.database}`));
+    console.log(chalk22.dim(`  Created: ${new Date(metadata.timestamp).toLocaleString()}`));
     if (metadata.environment) {
-      console.log(chalk21.dim(`  Environment: ${metadata.environment}`));
+      console.log(chalk22.dim(`  Environment: ${metadata.environment}`));
     }
     if (metadata.tags && metadata.tags.length > 0) {
-      console.log(chalk21.dim(`  Tags: ${metadata.tags.join(", ")}`));
+      console.log(chalk22.dim(`  Tags: ${metadata.tags.join(", ")}`));
     }
     if (metadata.backup.dataOnly) {
-      console.log(chalk21.yellow("  \u26A0\uFE0F  Data-only backup (no schema)"));
+      console.log(chalk22.yellow("  \u26A0\uFE0F  Data-only backup (no schema)"));
     }
     if (metadata.backup.schemaOnly) {
-      console.log(chalk21.yellow("  \u26A0\uFE0F  Schema-only backup (no data)"));
+      console.log(chalk22.yellow("  \u26A0\uFE0F  Schema-only backup (no data)"));
     }
     const warnings2 = [];
     const [currentGitInfo, currentMigrationInfo] = await Promise.all([
@@ -3205,26 +3277,27 @@ async function dbRestore(backupFile, options = {}) {
       }
     }
     if (warnings2.length > 0) {
-      console.log(chalk21.yellow("\n\u26A0\uFE0F  Version Warnings:\n"));
-      warnings2.forEach((warning) => console.log(chalk21.yellow(`  - ${warning}`)));
+      console.log(chalk22.yellow("\n\u26A0\uFE0F  Version Warnings:\n"));
+      warnings2.forEach((warning) => console.log(chalk22.yellow(`  - ${warning}`)));
       console.log("");
     }
   }
-  const { confirm } = await prompts5({
+  const dbInfo = parseDatabaseUrl(dbUrl);
+  const { confirm } = await prompts6({
     type: "confirm",
     name: "confirm",
-    message: chalk21.yellow("\u26A0\uFE0F  This will replace all data in the database. Continue?"),
+    message: chalk22.yellow(`\u26A0\uFE0F  This will replace all data in "${dbInfo.database}" @ ${dbInfo.host}:${dbInfo.port}. Continue?`),
     initial: false
   });
   if (!confirm) {
-    console.log(chalk21.gray("Cancelled"));
+    console.log(chalk22.gray("Cancelled"));
     process.exit(0);
   }
+  await confirmDangerousTarget(dbInfo);
   if (options.dataOnly && options.schemaOnly) {
-    console.error(chalk21.red("\u274C Cannot use --data-only and --schema-only together"));
+    console.error(chalk22.red("\u274C Cannot use --data-only and --schema-only together"));
     process.exit(1);
   }
-  const dbInfo = parseDatabaseUrl(dbUrl);
   const ext = path4.extname(file);
   const isCustomFormat = ext === ".dump";
   const command = isCustomFormat ? "pg_restore" : "psql";
@@ -3236,7 +3309,7 @@ async function dbRestore(backupFile, options = {}) {
     args.push("-d", dbInfo.database);
     args.push("--verbose");
     if (options.drop) {
-      args.push("--clean");
+      args.push("--clean", "--if-exists");
     }
     if (options.schema) {
       args.push("-n", options.schema);
@@ -3249,9 +3322,12 @@ async function dbRestore(backupFile, options = {}) {
     }
     args.push(file);
   } else {
+    if (options.drop) {
+      console.log(chalk22.yellow("\u26A0\uFE0F  Note: --drop only works with custom format backups (.dump) and was ignored."));
+    }
     if (options.dataOnly || options.schemaOnly) {
-      console.log(chalk21.yellow("\u26A0\uFE0F  Note: --data-only and --schema-only options only work with custom format backups (.dump)"));
-      console.log(chalk21.yellow("    For SQL files, the backup must have been created with the desired option.\n"));
+      console.log(chalk22.yellow("\u26A0\uFE0F  Note: --data-only and --schema-only options only work with custom format backups (.dump)"));
+      console.log(chalk22.yellow("    For SQL files, the backup must have been created with the desired option.\n"));
     }
     args.push("-h", dbInfo.host);
     args.push("-p", dbInfo.port);
@@ -3272,7 +3348,6 @@ async function dbRestore(backupFile, options = {}) {
   const warnings = [];
   const errors = [];
   let objectCount = 0;
-  let lastObject = "";
   restoreProcess.stderr?.on("data", (data) => {
     const lines = data.toString().split("\n").filter((l) => l.trim());
     for (const line of lines) {
@@ -3286,18 +3361,16 @@ async function dbRestore(backupFile, options = {}) {
         objectCount = Number(objectMatch[2]);
         const current = Number(objectMatch[1]);
         const desc = line.replace(/^pg_restore:\s*/, "").trim();
-        lastObject = desc;
         spinner.text = `Restoring backup... [${current}/${objectCount}] ${desc}`;
       } else if (isCustomFormat) {
         const desc = line.replace(/^pg_restore:\s*/, "").trim();
         if (desc && !/warning:|error:/i.test(desc)) {
-          lastObject = desc;
           spinner.text = `Restoring backup... ${desc}`;
         }
       }
       if (verbose) {
         spinner.stop();
-        console.log(chalk21.dim(`  ${line.trim()}`));
+        console.log(chalk22.dim(`  ${line.trim()}`));
         spinner.start();
       }
     }
@@ -3305,7 +3378,7 @@ async function dbRestore(backupFile, options = {}) {
   restoreProcess.stdout?.on("data", (data) => {
     if (verbose) {
       spinner.stop();
-      console.log(chalk21.dim(`  ${data.toString().trim()}`));
+      console.log(chalk22.dim(`  ${data.toString().trim()}`));
       spinner.start();
     }
   });
@@ -3315,31 +3388,31 @@ async function dbRestore(backupFile, options = {}) {
         const summary = objectCount > 0 ? ` (${objectCount} objects)` : "";
         spinner.succeed(`Restore completed${summary}`);
         if (warnings.length > 0) {
-          console.log(chalk21.yellow(`
+          console.log(chalk22.yellow(`
 \u26A0\uFE0F  Warnings during restore (${warnings.length}):
 `));
           for (const w of warnings) {
-            console.log(chalk21.yellow(`  - ${w}`));
+            console.log(chalk22.yellow(`  - ${w}`));
           }
         }
-        console.log(chalk21.green("\n\u2705 Database restored successfully"));
+        console.log(chalk22.green("\n\u2705 Database restored successfully"));
         resolve3();
       } else {
         spinner.fail("Restore failed");
         if (errors.length > 0) {
-          console.error(chalk21.red(`
+          console.error(chalk22.red(`
 \u274C Errors (${errors.length}):
 `));
           for (const e of errors) {
-            console.error(chalk21.red(`  - ${e}`));
+            console.error(chalk22.red(`  - ${e}`));
           }
         }
         if (warnings.length > 0) {
-          console.log(chalk21.yellow(`
+          console.log(chalk22.yellow(`
 \u26A0\uFE0F  Warnings (${warnings.length}):
 `));
           for (const w of warnings) {
-            console.log(chalk21.yellow(`  - ${w}`));
+            console.log(chalk22.yellow(`  - ${w}`));
           }
         }
         const fallback = errors.length === 0 && warnings.length === 0 ? "Restore failed with no output" : "";
@@ -3353,7 +3426,7 @@ async function dbRestore(backupFile, options = {}) {
   }).catch((error) => {
     const msg = error instanceof Error ? error.message : "Unknown error";
     if (msg) {
-      console.error(chalk21.red(`
+      console.error(chalk22.red(`
 \u274C ${msg}`));
     }
     process.exit(1);
@@ -3361,17 +3434,17 @@ async function dbRestore(backupFile, options = {}) {
 }
 
 // src/commands/db/list.ts
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 async function dbBackupList() {
-  console.log(chalk22.blue("\u{1F4CB} Database backups:\n"));
+  console.log(chalk23.blue("\u{1F4CB} Database backups:\n"));
   const backups = await listBackupFiles();
   if (backups.length === 0) {
-    console.log(chalk22.yellow("No backups found in ./backups directory"));
-    console.log(chalk22.gray("\n\u{1F4A1} Create a backup with: pnpm spfn db backup\n"));
+    console.log(chalk23.yellow("No backups found in ./backups directory"));
+    console.log(chalk23.gray("\n\u{1F4A1} Create a backup with: pnpm spfn db backup\n"));
     return;
   }
-  console.log(chalk22.bold("  Date                  Size        File"));
-  console.log(chalk22.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk23.bold("  Date                  Size        File"));
+  console.log(chalk23.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   backups.forEach((backup) => {
     const date = backup.date.toLocaleString("en-US", {
       year: "numeric",
@@ -3382,23 +3455,23 @@ async function dbBackupList() {
       second: "2-digit"
     });
     const sizeStr = backup.size.padEnd(10);
-    console.log(chalk22.white(`  ${date}  ${sizeStr}  ${backup.name}`));
+    console.log(chalk23.white(`  ${date}  ${sizeStr}  ${backup.name}`));
   });
-  console.log(chalk22.gray(`
+  console.log(chalk23.gray(`
   Total: ${backups.length} backup(s)
 `));
 }
 
 // src/commands/db/clean.ts
 import { promises as fs4 } from "fs";
-import chalk23 from "chalk";
+import chalk24 from "chalk";
 import ora10 from "ora";
-import prompts6 from "prompts";
+import prompts7 from "prompts";
 async function dbBackupClean(options) {
-  console.log(chalk23.blue("\u{1F9F9} Cleaning old backups...\n"));
+  console.log(chalk24.blue("\u{1F9F9} Cleaning old backups...\n"));
   const backups = await listBackupFiles();
   if (backups.length === 0) {
-    console.log(chalk23.yellow("No backups found"));
+    console.log(chalk24.yellow("No backups found"));
     return;
   }
   let toDelete = [];
@@ -3415,42 +3488,46 @@ async function dbBackupClean(options) {
     toDelete = backups.slice(defaultKeep);
   }
   if (toDelete.length === 0) {
-    console.log(chalk23.green("\u2705 No backups to clean"));
+    console.log(chalk24.green("\u2705 No backups to clean"));
     return;
   }
-  console.log(chalk23.yellow(`The following ${toDelete.length} backup(s) will be deleted:
+  console.log(chalk24.yellow(`The following ${toDelete.length} backup(s) will be deleted:
 `));
   toDelete.forEach((backup) => {
-    console.log(chalk23.gray(`  - ${backup.name} (${backup.size})`));
+    console.log(chalk24.gray(`  - ${backup.name} (${backup.size})`));
   });
-  const { confirm } = await prompts6({
+  const { confirm } = await prompts7({
     type: "confirm",
     name: "confirm",
     message: "\nProceed with deletion?",
     initial: false
   });
   if (!confirm) {
-    console.log(chalk23.gray("Cancelled"));
+    console.log(chalk24.gray("Cancelled"));
     return;
   }
   const spinner = ora10("Deleting backups...").start();
   try {
-    await Promise.all(toDelete.map((backup) => fs4.unlink(backup.path)));
+    await Promise.all(toDelete.flatMap((backup) => [
+      fs4.unlink(backup.path),
+      // Remove the .meta.json sidecar too (force: ok if it doesn't exist)
+      fs4.rm(backup.path.replace(/\.(sql|dump)$/, ".meta.json"), { force: true })
+    ]));
     spinner.succeed("Backups deleted");
-    console.log(chalk23.green(`
+    console.log(chalk24.green(`
 \u2705 Deleted ${toDelete.length} backup(s)`));
   } catch (error) {
     spinner.fail("Failed to delete backups");
-    console.error(chalk23.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk24.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 
 // src/commands/db/reindex.ts
-import { existsSync as existsSync20, readFileSync as readFileSync6, writeFileSync as writeFileSync11, renameSync, copyFileSync } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync7, writeFileSync as writeFileSync12, renameSync, copyFileSync } from "fs";
 import { join as join17 } from "path";
-import chalk24 from "chalk";
-import { loadEnv as loadEnv7 } from "@spfn/core/server";
+import chalk25 from "chalk";
+import { loadEnv as loadEnv8 } from "@spfn/core/server";
 function isTimestampPrefix(tag) {
   const prefix = tag.split("_")[0];
   return /^\d{5,}$/.test(prefix);
@@ -3466,19 +3543,19 @@ function parseTag(tag) {
   };
 }
 async function dbReindex(options = {}) {
-  loadEnv7();
+  loadEnv8();
   const { getDrizzleConfig } = await import("@spfn/core/db");
   const config = getDrizzleConfig({ disablePackageDiscovery: true });
   const outDir = config.out;
   const journalPath = join17(outDir, "meta", "_journal.json");
   if (!existsSync20(journalPath)) {
-    console.error(chalk24.red("\u274C No _journal.json found at:"), journalPath);
-    console.log(chalk24.yellow("\u{1F4A1} Run `spfn db generate` first to create migrations"));
+    console.error(chalk25.red("\u274C No _journal.json found at:"), journalPath);
+    console.log(chalk25.yellow("\u{1F4A1} Run `spfn db generate` first to create migrations"));
     process.exit(1);
   }
-  const journal = JSON.parse(readFileSync6(journalPath, "utf-8"));
+  const journal = JSON.parse(readFileSync7(journalPath, "utf-8"));
   if (journal.entries.length === 0) {
-    console.log(chalk24.yellow("No migration entries found \u2014 nothing to reindex."));
+    console.log(chalk25.yellow("No migration entries found \u2014 nothing to reindex."));
     return;
   }
   const renames = [];
@@ -3505,33 +3582,33 @@ async function dbReindex(options = {}) {
     tagUpdates.push({ idx: entry.idx, oldTag: entry.tag, newTag });
   }
   if (tagUpdates.length === 0) {
-    console.log(chalk24.green("\u2705 All migrations already use timestamp prefix \u2014 nothing to do."));
+    console.log(chalk25.green("\u2705 All migrations already use timestamp prefix \u2014 nothing to do."));
     if (skipped > 0) {
-      console.log(chalk24.dim(`   (${skipped} entries already timestamp-prefixed)`));
+      console.log(chalk25.dim(`   (${skipped} entries already timestamp-prefixed)`));
     }
     return;
   }
-  console.log(chalk24.bold("\n\u{1F4CB} Reindex plan:\n"));
+  console.log(chalk25.bold("\n\u{1F4CB} Reindex plan:\n"));
   for (const update of tagUpdates) {
     console.log(
-      chalk24.dim(`  [${update.idx}]`),
-      chalk24.red(update.oldTag),
-      chalk24.dim("\u2192"),
-      chalk24.green(update.newTag)
+      chalk25.dim(`  [${update.idx}]`),
+      chalk25.red(update.oldTag),
+      chalk25.dim("\u2192"),
+      chalk25.green(update.newTag)
     );
   }
-  console.log(chalk24.dim(`
+  console.log(chalk25.dim(`
   ${renames.length} file(s) to rename, ${tagUpdates.length} journal tag(s) to update`));
   if (skipped > 0) {
-    console.log(chalk24.dim(`  ${skipped} entry/entries already timestamp-prefixed (skipped)`));
+    console.log(chalk25.dim(`  ${skipped} entry/entries already timestamp-prefixed (skipped)`));
   }
   if (options.dryRun) {
-    console.log(chalk24.yellow("\n\u{1F50D} Dry run \u2014 no changes applied."));
+    console.log(chalk25.yellow("\n\u{1F50D} Dry run \u2014 no changes applied."));
     return;
   }
   const backupPath = journalPath + ".bak";
   copyFileSync(journalPath, backupPath);
-  console.log(chalk24.dim(`
+  console.log(chalk25.dim(`
   Backed up journal \u2192 ${backupPath}`));
   for (const rename of renames) {
     renameSync(rename.from, rename.to);
@@ -3542,8 +3619,8 @@ async function dbReindex(options = {}) {
       entry.tag = update.newTag;
     }
   }
-  writeFileSync11(journalPath, JSON.stringify(journal, null, 2) + "\n");
-  console.log(chalk24.green(`
+  writeFileSync12(journalPath, JSON.stringify(journal, null, 2) + "\n");
+  console.log(chalk25.green(`
 \u2705 Reindex complete \u2014 ${tagUpdates.length} migration(s) converted to timestamp prefix.`));
 }
 
@@ -3562,1415 +3639,96 @@ dbCommand.command("backup:clean").description("Clean old database backups").opti
 dbCommand.command("reindex").description("Convert migration files from sequential to timestamp prefix").option("--dry-run", "Show changes without applying").action((options) => dbReindex(options));
 
 // src/commands/add.ts
+init_package_manager();
 import { Command as Command10 } from "commander";
-import { existsSync as existsSync21, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync8 } from "fs";
 import { join as join18 } from "path";
-import { exec as exec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-import chalk25 from "chalk";
+import { execa as execa7 } from "execa";
+import chalk26 from "chalk";
 import ora11 from "ora";
-var execAsync2 = promisify2(exec2);
 async function addPackage(packageName) {
   if (!packageName.includes("/")) {
-    console.error(chalk25.red("\u274C Please specify full package name"));
-    console.log(chalk25.yellow("\n\u{1F4A1} Examples:"));
-    console.log(chalk25.gray("  pnpm spfn add @spfn/cms"));
-    console.log(chalk25.gray("  pnpm spfn add @mycompany/spfn-analytics"));
+    console.error(chalk26.red("\u274C Please specify full package name"));
+    console.log(chalk26.yellow("\n\u{1F4A1} Examples:"));
+    console.log(chalk26.gray("  pnpm spfn add @spfn/cms"));
+    console.log(chalk26.gray("  pnpm spfn add @mycompany/spfn-analytics"));
     process.exit(1);
   }
-  console.log(chalk25.blue(`
+  console.log(chalk26.blue(`
 \u{1F4E6} Setting up ${packageName}...
 `));
-  try {
-    const pkgPath = join18(process.cwd(), "node_modules", ...packageName.split("/"));
-    const pkgJsonPath = join18(pkgPath, "package.json");
-    if (!existsSync21(pkgJsonPath)) {
-      const installSpinner = ora11("Installing package...").start();
-      try {
-        await execAsync2(`pnpm add ${packageName}`);
-        installSpinner.succeed("Package installed");
-      } catch (error) {
-        installSpinner.fail("Failed to install package");
-        throw error;
-      }
-    } else {
-      console.log(chalk25.gray("\u2713 Package already installed (using local version)\n"));
-    }
-    if (!existsSync21(pkgJsonPath)) {
-      throw new Error(`Package ${packageName} not found after installation`);
+  const pkgPath = join18(process.cwd(), "node_modules", ...packageName.split("/"));
+  const pkgJsonPath = join18(pkgPath, "package.json");
+  if (!existsSync21(pkgJsonPath)) {
+    const pm = detectPackageManager(process.cwd());
+    const installSpinner = ora11("Installing package...").start();
+    try {
+      await execa7(pm, ["add", packageName]);
+      installSpinner.succeed("Package installed");
+    } catch (error) {
+      installSpinner.fail("Failed to install package");
+      console.error(chalk26.red(error instanceof Error ? error.message : "Unknown error"));
+      process.exit(1);
     }
-    const pkgJson = JSON.parse(readFileSync7(pkgJsonPath, "utf-8"));
-    if (pkgJson.spfn?.migrations) {
-      console.log(chalk25.blue(`
+  } else {
+    console.log(chalk26.gray("\u2713 Package already installed (using local version)\n"));
+  }
+  if (!existsSync21(pkgJsonPath)) {
+    console.error(chalk26.red(`\u274C Package ${packageName} not found after installation`));
+    process.exit(1);
+  }
+  const pkgJson = JSON.parse(readFileSync8(pkgJsonPath, "utf-8"));
+  if (pkgJson.spfn?.migrations) {
+    console.log(chalk26.blue(`
 \u{1F5C4}\uFE0F  Setting up database for ${packageName}...
 `));
-      const { env: env7 } = await import("@spfn/core/config");
-      if (!env7.DATABASE_URL) {
-        console.log(chalk25.yellow("\u26A0\uFE0F  DATABASE_URL not found"));
-        console.log(chalk25.gray("Skipping database setup. Run migrations manually when ready:\n"));
-        console.log(chalk25.gray(`  pnpm spfn db push
-`));
-      } else {
-        const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
-        const functions = discoverFunctionMigrations2(process.cwd());
-        const targetFunction = functions.find((f) => f.packageName === packageName);
-        if (targetFunction) {
-          const spinner = ora11("Applying migrations...").start();
-          try {
-            await executeFunctionMigrations2([targetFunction]);
-            spinner.succeed("Migrations applied");
-          } catch (error) {
-            spinner.fail("Failed to apply migrations");
-            throw error;
-          }
-        } else {
-          console.log(chalk25.gray("\u2139\uFE0F  No migrations found for this package"));
+    const { env: env8 } = await import("@spfn/core/config");
+    if (!env8.DATABASE_URL) {
+      console.log(chalk26.yellow("\u26A0\uFE0F  DATABASE_URL not found"));
+      console.log(chalk26.gray("Skipping database setup. Run migrations manually when ready:\n"));
+      console.log(chalk26.gray("  pnpm spfn db push\n"));
+    } else {
+      const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
+      const functions = discoverFunctionMigrations2(process.cwd());
+      const targetFunction = functions.find((f) => f.packageName === packageName);
+      if (targetFunction) {
+        const spinner = ora11("Applying migrations...").start();
+        try {
+          await executeFunctionMigrations2([targetFunction]);
+          spinner.succeed("Migrations applied");
+        } catch (error) {
+          spinner.fail("Failed to apply migrations");
+          console.error(chalk26.red(error instanceof Error ? error.message : "Unknown error"));
+          process.exit(1);
         }
+      } else {
+        console.log(chalk26.gray("\u2139\uFE0F  No migrations found for this package"));
       }
-    } else {
-      console.log(chalk25.gray("\n\u2139\uFE0F  No database migrations to apply"));
     }
-    console.log(chalk25.green(`
+  } else {
+    console.log(chalk26.gray("\n\u2139\uFE0F  No database migrations to apply"));
+  }
+  console.log(chalk26.green(`
 \u2705 ${packageName} installed successfully!
 `));
-    if (pkgJson.spfn?.setupMessage) {
-      console.log(chalk25.cyan("\u{1F4DA} Setup Guide:"));
-      console.log(pkgJson.spfn.setupMessage);
-      console.log();
-    }
-  } catch (error) {
-    console.error(chalk25.red(`
-\u274C Failed to install ${packageName}
-`));
-    console.error(chalk25.red(error instanceof Error ? error.message : "Unknown error"));
-    process.exit(1);
+  if (pkgJson.spfn?.setupMessage) {
+    console.log(chalk26.cyan("\u{1F4DA} Setup Guide:"));
+    console.log(pkgJson.spfn.setupMessage);
+    console.log();
   }
 }
 var addCommand = new Command10("add").description("Install and set up SPFN ecosystem packages").argument("<package>", "Package name (e.g., @spfn/cms, @mycompany/spfn-analytics)").action(addPackage);
 
-// src/commands/generate.ts
-init_logger();
+// src/commands/env.ts
 import { Command as Command11 } from "commander";
-import ora12 from "ora";
-import { join as join27 } from "path";
-import { existsSync as existsSync24 } from "fs";
 import chalk27 from "chalk";
-
-// src/commands/generate/prompts.ts
-init_logger();
-import prompts7 from "prompts";
-import chalk26 from "chalk";
-async function promptScope() {
-  const response = await prompts7({
-    type: "text",
-    name: "scope",
-    message: "NPM scope (e.g., @mycompany, @username):",
-    initial: "@spfn",
-    validate: (value) => {
-      if (!value || value.length === 0) {
-        return "Scope is required";
-      }
-      if (!/^@[a-z0-9-]+$/.test(value)) {
-        return "Scope must start with @ and contain lowercase alphanumeric with hyphens";
-      }
-      return true;
-    }
-  });
-  if (!response.scope) {
-    logger.info("Cancelled");
-    process.exit(0);
-  }
-  return response.scope;
-}
-async function promptFunctionName() {
-  const response = await prompts7({
-    type: "text",
-    name: "fnName",
-    message: "Function name:",
-    validate: (value) => {
-      if (!value || value.length === 0) {
-        return "Function name is required";
-      }
-      if (!/^[a-z][a-z0-9-]*$/.test(value)) {
-        return "Function name must be lowercase alphanumeric with hyphens";
-      }
-      return true;
-    }
-  });
-  if (!response.fnName) {
-    logger.info("Cancelled");
-    process.exit(0);
-  }
-  return response.fnName;
-}
-async function promptDescription(fnName) {
-  const response = await prompts7({
-    type: "text",
-    name: "description",
-    message: "Function description:",
-    initial: "A description of what this module does"
-  });
-  return response.description || "A description of what this module does";
-}
-async function promptEntities() {
-  const response = await prompts7({
-    type: "list",
-    name: "entities",
-    message: "Entity names (comma-separated, press enter to skip):",
-    separator: ",",
-    initial: ""
-  });
-  return response.entities || [];
-}
-async function confirmConfiguration(config) {
-  const { scope, fnName, description, entities, enableCache, enableRoutes } = config;
-  console.log("");
-  logger.info(chalk26.bold("\u26A1 Function Configuration:"));
-  console.log(`  ${chalk26.gray("Package:")}     ${chalk26.cyan(`${scope}/${fnName}`)}`);
-  console.log(`  ${chalk26.gray("Description:")} ${description}`);
-  console.log(`  ${chalk26.gray("Entities:")}    ${entities.length > 0 ? entities.join(", ") : chalk26.gray("none")}`);
-  console.log(`  ${chalk26.gray("Cache:")}       ${enableCache ? chalk26.green("yes") : chalk26.gray("no")}`);
-  console.log(`  ${chalk26.gray("Routes:")}      ${enableRoutes ? chalk26.green("yes") : chalk26.gray("no")}`);
-  console.log("");
-  const { confirmed } = await prompts7({
-    type: "confirm",
-    name: "confirmed",
-    message: "Create function?",
-    initial: true
-  });
-  if (!confirmed) {
-    logger.info("Cancelled");
-    return false;
-  }
-  return true;
-}
-
-// src/commands/generate/generators/structure.ts
-import { join as join26 } from "path";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync18 } from "fs";
-
-// src/commands/generate/generators/config.ts
-import { join as join20 } from "path";
-import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync3 } from "fs";
-
-// src/commands/generate/string-utils.ts
-function toPascalCase(str) {
-  return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-}
-function toKebabCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-}
-function toSnakeCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().replace(/-/g, "_");
-}
-function toCamelCase(str) {
-  return str.split(/[-_]/).map(
-    (word, index) => index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
-  ).join("");
-}
-function toSafeSchemaName(str) {
-  let result = str.toLowerCase().replace(/[@]/g, "").replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
-  if (/^[0-9]/.test(result)) {
-    result = "_" + result;
-  }
-  if (result.length > 63) {
-    result = result.substring(0, 63);
-  }
-  return result;
-}
-
-// src/commands/generate/template-loader.ts
-import { readFileSync as readFileSync8, existsSync as existsSync22 } from "fs";
-import { join as join19, dirname as dirname3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function findTemplatesPath2() {
-  const __filename = fileURLToPath2(import.meta.url);
-  const __dirname2 = dirname3(__filename);
-  const distPath = join19(__dirname2, "commands", "generate", "templates");
-  if (existsSync22(distPath)) {
-    return distPath;
-  }
-  const sameDirPath = join19(__dirname2, "templates");
-  if (existsSync22(sameDirPath)) {
-    return sameDirPath;
-  }
-  const srcPath = join19(__dirname2, "..", "..", "src", "commands", "generate", "templates");
-  if (existsSync22(srcPath)) {
-    return srcPath;
-  }
-  throw new Error(`Templates directory not found. Tried: ${distPath}, ${sameDirPath}, ${srcPath}`);
-}
-function loadTemplate(templateName, variables) {
-  const templatesDir = findTemplatesPath2();
-  const templatePath = join19(templatesDir, `${templateName}.template`);
-  let content = readFileSync8(templatePath, "utf-8");
-  for (const [key, value] of Object.entries(variables)) {
-    const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
-    content = content.replace(regex, value);
-  }
-  return content;
-}
-
-// src/commands/generate/generators/config.ts
-function generatePackageJson(fnDir, scope, fnName, description) {
-  const content = {
-    name: `${scope}/${fnName}`,
-    version: "0.1.0-alpha.1",
-    description,
-    type: "module",
-    main: "./dist/index.js",
-    types: "./dist/index.d.ts",
-    exports: {
-      ".": {
-        types: "./dist/index.d.ts",
-        import: "./dist/index.js",
-        require: "./dist/index.js"
-      },
-      "./server": {
-        types: "./dist/server.d.ts",
-        import: "./dist/server.js",
-        require: "./dist/server.js"
-      },
-      "./client": {
-        types: "./dist/client.d.ts",
-        import: "./dist/client.js",
-        require: "./dist/client.js"
-      }
-    },
-    files: ["dist", "migrations", "README.md"],
-    scripts: {
-      build: "npm run db:generate && tsup",
-      watch: "tsup --watch",
-      dev: "tsup --watch",
-      "type-check": "tsc --noEmit",
-      clean: "rm -rf dist migrations",
-      "db:generate": "drizzle-kit generate",
-      codegen: "spfn codegen run",
-      test: "vitest",
-      "test:watch": "vitest --watch",
-      "test:coverage": "vitest run --coverage",
-      "test:routes": "vitest src/server/routes",
-      "docker:test:up": "docker compose -f docker-compose.test.yml up -d",
-      "docker:test:down": "docker compose -f docker-compose.test.yml down",
-      "docker:test:logs": "docker compose -f docker-compose.test.yml logs -f"
-    },
-    keywords: ["spfn", fnName, "nextjs", "typescript"],
-    author: "SPFN Team",
-    license: "MIT",
-    spfn: {
-      prefix: `/_${fnName}`,
-      schemas: ["./dist/server/entities/*.js"],
-      routes: { dir: "./dist/server/routes" },
-      migrations: { dir: "./migrations" },
-      codegen: {
-        generators: [
-          {
-            name: "@spfn/core:contract",
-            contractsDir: "src/lib/contracts",
-            outputPath: "src/api",
-            runOn: ["build", "manual"]
-          },
-          {
-            name: "${scope}/${fnName}:example",
-            runOn: ["manual"]
-          }
-        ]
-      },
-      setupMessage: `  \u{1F4DA} Next steps:
-    1. Import from '${scope}/${fnName}'
-    2. View data: pnpm spfn db studio
-    3. API at: http://localhost:8790/_${fnName}`
-    },
-    peerDependencies: {
-      "@spfn/core": "workspace:*",
-      "drizzle-orm": "^0.44.0",
-      next: "^15.0.0",
-      react: "^18.0.0 || ^19.0.0"
-    },
-    dependencies: {
-      "@sinclair/typebox": "^0.34.0"
-    },
-    devDependencies: {
-      "@types/node": "^20.11.0",
-      "@types/react": "^19",
-      "@vitest/coverage-v8": "^4.0.6",
-      "drizzle-kit": "^0.31.6",
-      "drizzle-typebox": "^0.1.0",
-      glob: "^11.0.3",
-      postgres: "^3.4.0",
-      spfn: "workspace:*",
-      tsup: "^8.3.5",
-      tsx: "^4.19.2",
-      typescript: "^5",
-      vitest: "^4.0.6"
-    }
-  };
-  writeFileSync12(
-    join20(fnDir, "package.json"),
-    JSON.stringify(content, null, 4) + "\n"
-  );
-}
-function generateTsConfig(fnDir) {
-  const content = {
-    compilerOptions: {
-      target: "ES2022",
-      module: "ESNext",
-      lib: ["ES2022"],
-      moduleResolution: "bundler",
-      esModuleInterop: true,
-      skipLibCheck: true,
-      strict: true,
-      noUncheckedIndexedAccess: true,
-      declaration: true,
-      declarationMap: true,
-      sourceMap: true,
-      outDir: "./dist",
-      rootDir: "./src",
-      composite: false,
-      isolatedModules: true,
-      resolveJsonModule: true,
-      allowSyntheticDefaultImports: true,
-      forceConsistentCasingInFileNames: true,
-      baseUrl: ".",
-      paths: {
-        "@/*": ["./src/*"]
-      }
-    },
-    include: ["src/**/*"],
-    exclude: ["node_modules", "dist", "**/*.test.ts", "**/__tests__/**"]
-  };
-  writeFileSync12(
-    join20(fnDir, "tsconfig.json"),
-    JSON.stringify(content, null, 4) + "\n"
-  );
-}
-function generateTsupConfig(fnDir) {
-  const content = `import { defineConfig } from 'tsup';
-import { glob } from 'glob';
-import * as path from 'path';
-
-// Find all route handler files
-const routeFiles = glob.sync('src/server/routes/**/index.ts');
-const routeEntries = Object.fromEntries(
-    routeFiles.map((file) =>
-    {
-        const key = file
-            .replace('src/', '')
-            .replace('/index.ts', '/index')
-            .replace('.ts', '');
-        return [key, file];
-    })
-);
-
-// Find all entity files
-const entityFiles = glob.sync('src/server/entities/**/*.ts');
-const entityEntries = Object.fromEntries(
-    entityFiles.map((file) =>
-    {
-        const key = file.replace('src/', '').replace('.ts', '');
-        return [key, file];
-    })
-);
-
-// Find all contract files
-const contractFiles = glob.sync('src/lib/contracts/**/*.ts');
-const contractEntries = Object.fromEntries(
-    contractFiles.map((file) =>
-    {
-        const key = file.replace('src/', '').replace('.ts', '');
-        return [key, file];
-    })
-);
-
-export default defineConfig({
-    entry: {
-        index: 'src/index.ts',
-        server: 'src/server.ts',
-        client: 'src/client.ts',
-        ...entityEntries,
-        ...contractEntries,
-        ...routeEntries,
-    },
-    format: ['esm'],
-    dts: true,
-    sourcemap: true,
-    clean: true,
-    splitting: false,
-    esbuildOptions(options)
-    {
-        // Add path alias support
-        options.alias = {
-            '@': path.resolve(__dirname, './src'),
-        };
-    },
-    external: [
-        '@spfn/core',
-        'drizzle-orm',
-        'next',
-        'react',
-        '@sinclair/typebox',
-        'jiti',
-        'zustand',
-        'server-only',
-        'react-dom',
-    ],
-});
-`;
-  writeFileSync12(join20(fnDir, "tsup.config.ts"), content);
-}
-function generateDrizzleConfig(fnDir, scope, fnName) {
-  const schemaName = `spfn_${toSnakeCase(fnName)}`;
-  const content = `import { defineConfig } from 'drizzle-kit';
-
-/**
- * Drizzle Config for ${scope}/${fnName} package
- *
- * This generates migrations for the ${fnName} schema that will be
- * bundled with the package and applied automatically when
- * users run \`spfn db push\` or \`spfn db migrate\`
- */
-export default defineConfig({
-    schema: './src/server/entities/*.ts',
-    out: './migrations',
-    dialect: 'postgresql',
-    schemaFilter: ['${schemaName}'], // Only generate for ${fnName} schema
-});
-`;
-  writeFileSync12(join20(fnDir, "drizzle.config.ts"), content);
-}
-function generateExampleGenerator(fnDir, scope, fnName) {
-  const pascalName = toPascalCase(fnName);
-  const content = `/**
- * Example Custom Generator for ${fnName}
- *
- * This is a template for creating custom code generators.
- * Uncomment and modify to create your own generator.
- */
-
-import type { Generator, GeneratorOptions } from '@spfn/core/codegen';
-import { writeFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Example: Auto-generate index files for types
- */
-export function create${pascalName}ExampleGenerator(): Generator
-{
-    return {
-        name: '${fnName}:example',
-
-        // Define when this generator should run
-        // Options: 'build', 'manual', 'watch', 'start'
-        runOn: ['build', 'manual'],
-
-        // Optional: watch for file changes
-        watchPatterns: [
-            'src/lib/types/**/*.ts',
-        ],
-
-        async generate(options: GeneratorOptions): Promise<void>
-        {
-            const { cwd, debug } = options;
-
-            if (debug)
-            {
-                console.log('Running ${fnName} example generator...');
-            }
-
-            // Your generation logic here
-            const outputDir = join(cwd, 'src/generated');
-            const outputPath = join(outputDir, 'example.ts');
-
-            // Ensure output directory exists
-            mkdirSync(outputDir, { recursive: true });
-
-            // Generate content
-            const content = \`/**
- * Auto-generated file
- *
- * @generated \${new Date().toISOString()}
- */
-
-export const generatedAt = '\${new Date().toISOString()}';
-export const moduleName = '${fnName}';
-\`;
-
-            writeFileSync(outputPath, content, 'utf-8');
-
-            if (debug)
-            {
-                console.log('\u2713 Generated:', outputPath);
-            }
-        },
-    };
-}
-`;
-  const generatorsDir = join20(fnDir, "src/server/generators");
-  mkdirSync3(generatorsDir, { recursive: true });
-  writeFileSync12(
-    join20(generatorsDir, "example-generator.ts"),
-    content
-  );
-  const indexContent = `/**
- * Custom Generators
- *
- * Export your custom generators here.
- *
- * The example generator is already registered in package.json.
- * Comment it out if you don't want to use it.
- */
-
-export { create${pascalName}ExampleGenerator } from './example-generator.js';
-`;
-  writeFileSync12(
-    join20(generatorsDir, "index.ts"),
-    indexContent
-  );
-}
-function generateReadme(fnDir, scope, fnName, description) {
-  const content = `# ${scope}/${fnName}
-
-${description}
-
-## \u{1F4E6} Installation
-
-For users of your module:
-
-\`\`\`bash
-spfn add ${scope}/${fnName}
-\`\`\`
-
-## \u{1F680} Usage
-
-\`\`\`typescript
-// Server-side
-import { /* your entities, repositories */ } from '${scope}/${fnName}/server';
-
-// Client-side
-import { /* your hooks, components */ } from '${scope}/${fnName}/client';
-
-// Generated API client
-import { ${fnName}Api } from '${scope}/${fnName}/api';
-
-// Example: Using the generated API client
-const data = await ${fnName}Api.list();
-\`\`\`
-
-## \u{1F4C1} Project Structure
-
-\`\`\`
-src/
-\u251C\u2500\u2500 lib/
-\u2502   \u251C\u2500\u2500 contracts/         # API contracts (shared types)
-\u2502   \u2514\u2500\u2500 types/            # Shared TypeScript types
-\u251C\u2500\u2500 server/
-\u2502   \u251C\u2500\u2500 entities/         # Drizzle ORM entities
-\u2502   \u251C\u2500\u2500 repositories/     # Data access layer
-\u2502   \u251C\u2500\u2500 routes/           # API route handlers
-\u2502   \u251C\u2500\u2500 helpers/          # Server utilities
-\u2502   \u2514\u2500\u2500 generators/       # Code generators (optional)
-\u251C\u2500\u2500 client/
-\u2502   \u251C\u2500\u2500 hooks/            # React hooks
-\u2502   \u251C\u2500\u2500 store/            # Zustand stores
-\u2502   \u2514\u2500\u2500 components/       # React components
-\u251C\u2500\u2500 api/                  # Auto-generated API client (do not edit manually)
-\u251C\u2500\u2500 index.ts              # Main entry point
-\u251C\u2500\u2500 server.ts             # Server exports
-\u2514\u2500\u2500 client.ts             # Client exports
-\`\`\`
-
-## \u{1F6E0}\uFE0F Development Guide
-
-### Available Scripts
-
-\`\`\`bash
-# Development
-pnpm dev                  # Watch mode - auto rebuild on changes
-pnpm build                # Build for production
-pnpm type-check           # TypeScript type checking
-
-# Database
-pnpm db:generate          # Generate migrations from entities
-pnpm clean                # Clean dist and migrations
-
-# Code Generation
-pnpm codegen              # Generate API client from contracts
-
-# Testing
-pnpm test                 # Run tests
-pnpm test:watch           # Watch mode
-pnpm test:coverage        # Generate coverage report
-pnpm test:routes          # Test only routes
-
-# Docker (for testing)
-pnpm docker:test:up       # Start test database
-pnpm docker:test:down     # Stop test database
-pnpm docker:test:logs     # View database logs
-\`\`\`
-
-### Development Workflow
-
-1. **Define Entities** (\`src/server/entities/\`)
-   \`\`\`typescript
-   // src/server/entities/${fnName}-example.ts
-   import { pgTable, uuid, text, timestamp } from 'drizzle-orm/pg-core';
-
-   export const ${fnName}Examples = pgTable('${fnName}_examples', {
-     id: uuid('id').primaryKey().defaultRandom(),
-     name: text('name').notNull(),
-     createdAt: timestamp('created_at').defaultNow().notNull(),
-   });
-   \`\`\`
-
-2. **Generate Migrations**
-   \`\`\`bash
-   pnpm db:generate
-   \`\`\`
-
-3. **Create Repositories** (\`src/server/repositories/\`)
-   \`\`\`typescript
-   // src/server/repositories/example-repository.ts
-   import { db } from '@spfn/core/db';
-   import { ${fnName}Examples } from '../entities/${fnName}-example';
-
-   export class ExampleRepository {
-     static async findAll() {
-       return db.select().from(${fnName}Examples);
-     }
-   }
-   \`\`\`
-
-4. **Define Contracts** (\`src/lib/contracts/\`)
-   \`\`\`typescript
-   // src/lib/contracts/example.ts
-   import { contract } from '@spfn/core';
-   import { Type as t } from '@sinclair/typebox';
-
-   export const getExamplesContract = contract({
-     method: 'GET',
-     path: '/_${fnName}/examples',
-     responses: {
-       200: t.Array(t.Object({
-         id: t.String(),
-         name: t.String(),
-         createdAt: t.String(),
-       })),
-     },
-   });
-   \`\`\`
-
-5. **Create Routes** (\`src/server/routes/\`)
-   \`\`\`typescript
-   // src/server/routes/examples/index.ts
-   import { route } from '@spfn/core';
-   import { getExamplesContract } from '@/lib/contracts/example';
-   import { ExampleRepository } from '@/server/repositories/example-repository';
-
-   export const GET = route(getExamplesContract, async () => {
-     const examples = await ExampleRepository.findAll();
-     return { status: 200, body: examples };
-   });
-   \`\`\`
-
-6. **Generate API Client**
-   \`\`\`bash
-   pnpm codegen
-   \`\`\`
-
-   This generates type-safe API client in \`src/api/\`:
-   \`\`\`typescript
-   // Auto-generated
-   export const ${fnName}Api = {
-     examples: Examples,
-     // ... other resources
-   };
-   \`\`\`
-
-7. **Write Tests** (\`src/server/routes/__tests__/\`)
-   \`\`\`typescript
-   import { describe, it, expect, beforeAll } from 'vitest';
-   import { GET } from '../examples/index';
-
-   describe('GET /_${fnName}/examples', () => {
-     it('should return all examples', async () => {
-       const response = await GET();
-       expect(response.status).toBe(200);
-       expect(Array.isArray(response.body)).toBe(true);
-     });
-   });
-   \`\`\`
-
-8. **Create Client Hooks** (optional)
-   \`\`\`typescript
-   // src/client/hooks/use-examples.ts
-   'use client';
-   import { useState, useEffect } from 'react';
-   import { ${fnName}Api } from '@/api';
-
-   export function useExamples() {
-     const [examples, setExamples] = useState([]);
-     const [loading, setLoading] = useState(true);
-
-     useEffect(() => {
-       ${fnName}Api.examples.list()
-         .then(setExamples)
-         .finally(() => setLoading(false));
-     }, []);
-
-     return { examples, loading };
-   }
-   \`\`\`
-
-### Configuration
-
-The module is configured via \`package.json\`:
-
-\`\`\`json
-{
-  "spfn": {
-    "prefix": "/_${fnName}",
-    "schemas": ["./dist/server/entities/*.js"],
-    "routes": { "dir": "./dist/server/routes" },
-    "migrations": { "dir": "./migrations" },
-    "codegen": {
-      "generators": [{
-        "name": "@spfn/core:contract",
-        "contractsDir": "src/lib/contracts",
-        "outputPath": "src/api"
-      }]
-    }
-  }
-}
-\`\`\`
-
-#### Configuration Options
-
-| Field | Type | Description |
-|-------|------|-------------|
-| \`prefix\` | \`string\` | API route prefix for this module. Used for namespacing routes and generating API client name. Example: \`"/_${fnName}"\` becomes \`${fnName}Api\` |
-| \`schemas\` | \`string[]\` | Glob patterns for Drizzle entity files. These are used by \`spfn db push\` to apply migrations. |
-| \`routes.dir\` | \`string\` | Directory containing compiled route handlers. Used by \`spfn start\` to load routes. |
-| \`migrations.dir\` | \`string\` | Directory containing database migration files generated by \`drizzle-kit generate\`. |
-| \`codegen.generators\` | \`Generator[]\` | Array of code generators to run. Built-in: \`@spfn/core:contract\` for API client generation. |
-| \`setupMessage\` | \`string\` | (Optional) Message shown after \`spfn add ${scope}/${fnName}\` to guide users. |
-
-#### Built-in Generator: @spfn/core:contract
-
-The contract generator automatically creates type-safe API clients from your route contracts.
-
-\`\`\`json
-{
-  "name": "@spfn/core:contract",
-  "contractsDir": "src/lib/contracts",  // Where to scan for contracts
-  "outputPath": "src/api"                // Where to generate API client
-}
-\`\`\`
-
-**How it works:**
-1. Scans \`contractsDir\` for contract exports
-2. Groups routes by resource (based on file name)
-3. Generates:
-   - Resource files (\`src/api/Examples.ts\`)
-   - Type exports for params, query, body, response
-   - Main index file with \`${fnName}Api\` object
-4. Uses \`prefix\` to generate unique API name (avoids naming conflicts)
-
-**Generated API structure:**
-\`\`\`typescript
-// src/api/index.ts
-export const ${fnName}Api = {
-  examples: Examples,           // Camel case keys
-  exampleById: ExampleById,
-  // ...
-};
-\`\`\`
-
-## \u{1F3A8} Custom Generators
-
-You can create custom code generators for your module. Generators run automatically during development and build.
-
-### Creating a Custom Generator
-
-1. **Create generator file** (\`src/server/generators/\`)
-
-\`\`\`typescript
-// src/server/generators/sync-generator.ts
-import type { Generator, GeneratorOptions } from '@spfn/core/codegen';
-import { writeFileSync } from 'fs';
-import { join } from 'path';
-
-export function createSyncGenerator(): Generator {
-  return {
-    name: '${fnName}-sync',
-
-    // Define when this generator should run
-    runOn: ['build', 'manual'],  // 'build', 'manual', 'watch', 'start'
-
-    // Optional: watch for file changes
-    watchPatterns: [
-      'src/server/entities/**/*.ts',
-      'src/lib/types/**/*.ts',
-    ],
-
-    async generate(options: GeneratorOptions): Promise<void> {
-      const { cwd, debug } = options;
-
-      if (debug) {
-        console.log('Running ${fnName} sync generator...');
-      }
-
-      // Your generation logic here
-      const outputPath = join(cwd, 'src/generated/sync.ts');
-      const content = \`// Auto-generated sync file
-export const generatedAt = '\${new Date().toISOString()}';
-\`;
-
-      writeFileSync(outputPath, content, 'utf-8');
-
-      if (debug) {
-        console.log('\u2713 Generated:', outputPath);
-      }
-    },
-  };
-}
-\`\`\`
-
-2. **Export generator** (\`src/server/generators/index.ts\`)
-
-\`\`\`typescript
-export { createSyncGenerator } from './sync-generator.js';
-\`\`\`
-
-3. **Register in package.json**
-
-\`\`\`json
-{
-  "spfn": {
-    "codegen": {
-      "generators": [
-        {
-          "name": "@spfn/core:contract",
-          "contractsDir": "src/lib/contracts",
-          "outputPath": "src/api"
-        },
-        {
-          "name": "${scope}/${fnName}:sync",  // Custom generator
-          "watchPatterns": ["src/server/entities/**/*.ts"]
-        }
-      ]
-    }
-  }
-}
-\`\`\`
-
-### Generator Options
-
-\`\`\`typescript
-interface Generator {
-  name: string;                    // Generator name
-  runOn?: GeneratorTrigger[];      // When to run: 'build' | 'manual' | 'watch' | 'start'
-  watchPatterns?: string[];        // Glob patterns to watch
-  generate: (options: GeneratorOptions) => Promise<void>;
-}
-
-interface GeneratorOptions {
-  cwd: string;                     // Current working directory
-  debug?: boolean;                 // Debug mode flag
-  trigger?: {                      // Trigger information (for watch mode)
-    type: 'watch' | 'manual' | 'build' | 'start';
-    changedFile?: {
-      path: string;
-      event: 'add' | 'change' | 'unlink';
-    };
-  };
-}
-\`\`\`
-
-### Real-World Example: Type Sync Generator
-
-\`\`\`typescript
-// src/server/generators/type-sync-generator.ts
-import type { Generator, GeneratorOptions } from '@spfn/core/codegen';
-import { readdirSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Generates a type index that auto-exports all types
- */
-export function createTypeSyncGenerator(): Generator {
-  return {
-    name: '${fnName}-type-sync',
-    runOn: ['build', 'watch', 'manual'],
-    watchPatterns: ['src/lib/types/**/*.ts'],
-
-    async generate(options: GeneratorOptions): Promise<void> {
-      const { cwd, debug } = options;
-      const typesDir = join(cwd, 'src/lib/types');
-      const outputFile = join(typesDir, 'index.ts');
-
-      // Read all type files
-      const files = readdirSync(typesDir)
-        .filter(f => f.endsWith('.ts') && f !== 'index.ts')
-        .map(f => f.replace('.ts', ''));
-
-      // Generate exports
-      const content = \`/**
- * Auto-generated type index
- *
- * @generated \${new Date().toISOString()}
- */
-
-\${files.map(f => \`export * from './\${f}.js';\`).join('\\n')}
-\`;
-
-      writeFileSync(outputFile, content, 'utf-8');
-
-      if (debug) {
-        console.log(\`\u2713 Synced \${files.length} type files\`);
-      }
-    },
-  };
-}
-\`\`\`
-
-### Running Generators
-
-\`\`\`bash
-# Run all generators
-pnpm codegen
-
-# Run specific generator
-pnpm spfn codegen run --generator ${scope}/${fnName}:sync
-
-# Watch mode (auto-runs on file changes)
-pnpm spfn codegen watch
-\`\`\`
-
-## \u{1F9EA} Testing
-
-### Setup Test Database
-
-\`\`\`bash
-# Start PostgreSQL in Docker
-pnpm docker:test:up
-
-# Run tests
-pnpm test
-
-# Stop database
-pnpm docker:test:down
-\`\`\`
-
-### Test Structure
-
-\`\`\`
-src/server/routes/
-\u251C\u2500\u2500 examples/
-\u2502   \u251C\u2500\u2500 index.ts
-\u2502   \u2514\u2500\u2500 __tests__/
-\u2502       \u2514\u2500\u2500 index.test.ts
-\`\`\`
-
-## \u{1F4DA} API Documentation
-
-### Entities
-
-Document your database entities here.
-
-### Routes
-
-- \`GET /_${fnName}/...\` - Description
-- \`POST /_${fnName}/...\` - Description
-- \`GET /_${fnName}/.../:id\` - Description
-- \`PATCH /_${fnName}/.../:id\` - Description
-- \`DELETE /_${fnName}/.../:id\` - Description
-
-### Client API
-
-The generated \`${fnName}Api\` provides type-safe methods for all routes.
-
-## \u{1F4E6} Publishing
-
-1. Update version in \`package.json\`
-2. Build the package: \`pnpm build\`
-3. Test in a real project
-4. Publish: \`npm publish\` (or via your CI/CD)
-
-## \u{1F3D7}\uFE0F Architecture
-
-This module follows SPFN's 3-layer architecture:
-
-- **Shared Layer** (\`lib/\`): Contracts and types shared between client and server
-- **Server Layer** (\`server/\`): Database entities, repositories, business logic, API routes
-- **Client Layer** (\`client/\`): React hooks, components, state management
-
-## \u{1F91D} Contributing
-
-Contributions are welcome! Please follow the development workflow above.
-
-## \u{1F4C4} License
-
-MIT
-`;
-  writeFileSync12(join20(fnDir, "README.md"), content);
-}
-
-// src/commands/generate/generators/entity.ts
-import { join as join21 } from "path";
-import { writeFileSync as writeFileSync13, existsSync as existsSync23 } from "fs";
-function generateSchema(fnDir, scope, fnName) {
-  const schemaFilePath = join21(fnDir, "src/server/entities/schema.ts");
-  if (existsSync23(schemaFilePath)) {
-    return;
-  }
-  const packageName = `${scope}/${fnName}`;
-  const fnNamePascal = toPascalCase(fnName);
-  const schemaVarName = `${toCamelCase(fnName)}Schema`;
-  const content = loadTemplate("schema", {
-    FN_NAME_PASCAL: fnNamePascal,
-    PACKAGE_NAME: packageName,
-    SCHEMA_VAR_NAME: schemaVarName
-  });
-  writeFileSync13(schemaFilePath, content);
-}
-function generateEntity(fnDir, scope, fnName, entityName) {
-  const safeScope = toSafeSchemaName(scope);
-  const safeFnName = toSafeSchemaName(fnName);
-  const schemaName = `${safeScope}_${safeFnName}`;
-  const tableName = toKebabCase(entityName);
-  const pascalName = toPascalCase(entityName);
-  const schemaVarName = `${toCamelCase(fnName)}Schema`;
-  const schemaFileName = "schema";
-  const content = loadTemplate("entity", {
-    PASCAL_NAME: pascalName,
-    ENTITY_NAME: entityName,
-    TABLE_NAME: tableName,
-    SCHEMA_NAME: schemaName,
-    FN_NAME: fnName,
-    SCHEMA_VAR_NAME: schemaVarName,
-    SCHEMA_FILE_NAME: schemaFileName
-  });
-  writeFileSync13(
-    join21(fnDir, `src/server/entities/${toKebabCase(entityName)}.ts`),
-    content
-  );
-}
-function generateEntitiesIndex(fnDir, entities) {
-  const schemaExport = `export * from './schema';`;
-  const entityExports = entities.map((entity) => `export * from './${toKebabCase(entity)}';`).join("\n");
-  const content = [schemaExport, entityExports].filter(Boolean).join("\n");
-  writeFileSync13(join21(fnDir, "src/server/entities/index.ts"), content + "\n");
-}
-
-// src/commands/generate/generators/repository.ts
-import { join as join22 } from "path";
-import { writeFileSync as writeFileSync14 } from "fs";
-function generateRepository(fnDir, entityName) {
-  const pascalName = toPascalCase(entityName);
-  const repoName = `${entityName}Repository`;
-  const content = loadTemplate("repository", {
-    PASCAL_NAME: pascalName,
-    ENTITY_NAME: entityName,
-    REPO_NAME: repoName
-  });
-  writeFileSync14(
-    join22(fnDir, `src/server/repositories/${toKebabCase(entityName)}.repository.ts`),
-    content
-  );
-}
-function generateRepositoriesIndex(fnDir, entities) {
-  const exports = entities.map((entity) => `export * from './${toKebabCase(entity)}.repository';`).join("\n");
-  writeFileSync14(join22(fnDir, "src/server/repositories/index.ts"), exports + "\n");
-}
-
-// src/commands/generate/generators/route.ts
-import { join as join23 } from "path";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync15 } from "fs";
-function generateRoute(fnDir, entityName) {
-  const pascalName = toPascalCase(entityName);
-  const repoName = `${entityName}Repository`;
-  const kebabName = toKebabCase(entityName);
-  const content = loadTemplate("route", {
-    PASCAL_NAME: pascalName,
-    ENTITY_NAME: entityName,
-    REPO_NAME: repoName,
-    KEBAB_NAME: kebabName
-  });
-  const routeDir = join23(fnDir, `src/server/routes/${kebabName}`);
-  mkdirSync4(routeDir, { recursive: true });
-  writeFileSync15(join23(routeDir, "index.ts"), content);
-}
-
-// src/commands/generate/generators/contract.ts
-import { join as join24 } from "path";
-import { writeFileSync as writeFileSync16 } from "fs";
-function generateContract(fnDir, entityName) {
-  const pascalName = toPascalCase(entityName);
-  const content = loadTemplate("contract", {
-    PASCAL_NAME: pascalName,
-    ENTITY_NAME: entityName
-  });
-  writeFileSync16(
-    join24(fnDir, `src/lib/contracts/${toKebabCase(entityName)}.ts`),
-    content
-  );
-}
-
-// src/commands/generate/generators/index-files.ts
-import { join as join25 } from "path";
-import { writeFileSync as writeFileSync17 } from "fs";
-function generateMainIndex(fnDir, fnName) {
-  const content = `/**
- * @spfn/${fnName}
- *
- * Common Module (Types, Entities)
- * \uACF5\uD1B5 \uBAA8\uB4C8 (\uD0C0\uC785, \uC5D4\uD2F0\uD2F0)
- *
- * Import structure:
- * - @spfn/${fnName}         - Common (types, entities)
- * - @spfn/${fnName}/server  - Server-side (routes, repositories, helpers)
- * - @spfn/${fnName}/client  - Client-side (hooks, store, components)
- */
-
-// ============================================================================
-// Types
-// ============================================================================
-
-export * from '@/lib/types/index';
-
-// ============================================================================
-// Entities (for type reference)
-// ============================================================================
-
-export * from '@/server/entities/index';
-`;
-  writeFileSync17(join25(fnDir, "src/index.ts"), content);
-}
-function generateServerIndex(fnDir) {
-  const content = `/**
- * @spfn/[name]/server
- *
- * Server-side Only Module
- * \uC11C\uBC84 \uC804\uC6A9 \uBAA8\uB4C8 (\uC11C\uBC84 \uCEF4\uD3EC\uB10C\uD2B8 + \uBC31\uC5D4\uB4DC)
- *
- * Includes:
- * - Routes
- * - Repositories (DB access)
- * - Helpers
- *
- * @note This module should only be imported in server-side code
- */
-
-// ============================================================================
-// Routes
-// ============================================================================
-
-// TODO: Export routes here
-
-// ============================================================================
-// Repositories (DB access)
-// ============================================================================
-
-export * from '@/server/repositories/index';
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-// TODO: Export helpers here
-`;
-  writeFileSync17(join25(fnDir, "src/server.ts"), content);
-}
-function generateClientIndex(fnDir) {
-  const content = `/**
- * @spfn/[name]/client
- *
- * Client Components Only
- * \uD074\uB77C\uC774\uC5B8\uD2B8 \uCEF4\uD3EC\uB10C\uD2B8 \uC804\uC6A9 (\uBE0C\uB77C\uC6B0\uC800\uC5D0\uC11C \uC2E4\uD589)
- *
- * Includes:
- * - Hooks
- * - Store (Zustand)
- * - Components
- */
-
-// ============================================================================
-// Client-side Hooks
-// ============================================================================
-
-export * from './client/hooks';
-
-// ============================================================================
-// Client-side Store
-// ============================================================================
-
-export * from './client/store';
-
-// ============================================================================
-// Client-side Components
-// ============================================================================
-
-export * from './client/components';
-`;
-  writeFileSync17(join25(fnDir, "src/client.ts"), content);
-}
-function generateTypesFile(fnDir, fnName) {
-  const content = `/**
- * @spfn/${fnName} Types
- *
- * @deprecated This file is kept for backwards compatibility.
- * Types are now in src/lib/types/index.ts
- */
-
-export * from '@/lib/types/index';
-`;
-  writeFileSync17(join25(fnDir, "src/types.ts"), content);
-}
-
-// src/commands/generate/generators/structure.ts
-async function generateFunctionStructure(options) {
-  const { fnDir, scope, fnName, description, enableRoutes } = options;
-  const entities = options.entities.filter((e) => e && e.trim().length > 0);
-  const dirs = [
-    // Shared layer
-    "src/lib/contracts",
-    "src/lib/types",
-    // Server layer
-    "src/server/entities",
-    "src/server/routes",
-    "src/server/repositories",
-    "src/server/helpers",
-    "src/server/generators",
-    // Client layer
-    "src/client/hooks",
-    "src/client/store",
-    "src/client/components"
-  ];
-  dirs.forEach((dir) => mkdirSync5(join26(fnDir, dir), { recursive: true }));
-  generatePackageJson(fnDir, scope, fnName, description);
-  generateTsConfig(fnDir);
-  generateTsupConfig(fnDir);
-  generateDrizzleConfig(fnDir, scope, fnName);
-  generateExampleGenerator(fnDir, scope, fnName);
-  generateReadme(fnDir, scope, fnName, description);
-  if (entities.length > 0) {
-    generateSchema(fnDir, scope, fnName);
-    for (const entity of entities) {
-      generateEntity(fnDir, scope, fnName, entity);
-      generateRepository(fnDir, entity);
-      if (enableRoutes) {
-        generateRoute(fnDir, entity);
-        generateContract(fnDir, entity);
-      }
-    }
-    generateEntitiesIndex(fnDir, entities);
-    generateRepositoriesIndex(fnDir, entities);
-  } else {
-    writeFileSync18(join26(fnDir, "src/server/entities/index.ts"), "// Export your entities here\nexport {}\n");
-    writeFileSync18(join26(fnDir, "src/server/repositories/index.ts"), "// Export your repositories here\nexport {}\n");
-  }
-  writeFileSync18(join26(fnDir, "src/client/hooks/index.ts"), "/**\n * Client Hooks\n */\n\n// TODO: Add hooks (e.g., useAuth, useData, etc.)\nexport {}\n");
-  writeFileSync18(join26(fnDir, "src/client/store/index.ts"), "/**\n * Client Store\n */\n\n// TODO: Add Zustand store if needed\nexport {}\n");
-  writeFileSync18(join26(fnDir, "src/client/components/index.ts"), "/**\n * Client Components\n */\n\n// TODO: Add React components\nexport {}\n");
-  writeFileSync18(join26(fnDir, "src/client/index.ts"), "/**\n * Client Module Entry\n */\n\nexport * from './hooks';\nexport * from './store';\nexport * from './components';\n");
-  writeFileSync18(join26(fnDir, "src/lib/types/index.ts"), "/**\n * Shared Type Definitions\n */\n\n// Add your shared types here\nexport {}\n");
-  writeFileSync18(join26(fnDir, "src/lib/contracts/index.ts"), "/**\n * API Contracts\n */\n\n// Export your contracts here\nexport {}\n");
-  generateMainIndex(fnDir, fnName);
-  generateServerIndex(fnDir);
-  generateClientIndex(fnDir);
-  generateTypesFile(fnDir, fnName);
-}
-
-// src/commands/generate.ts
-async function generateFunction(name, options) {
-  const cwd = process.cwd();
-  let scope = options.scope;
-  if (!scope && !options.yes) {
-    scope = await promptScope();
-  } else if (!scope) {
-    scope = "@spfn";
-  }
-  let fnName = name;
-  if (!fnName && !options.yes) {
-    fnName = await promptFunctionName();
-  }
-  if (!fnName) {
-    logger.error("Function name is required");
-    process.exit(1);
-  }
-  const fnDir = join27(cwd, fnName);
-  if (existsSync24(fnDir)) {
-    logger.error(`Directory ${fnName} already exists at ${fnDir}`);
-    process.exit(1);
-  }
-  let description = options.description;
-  if (!description && !options.yes) {
-    description = await promptDescription(fnName);
-  } else if (!description) {
-    description = `SPFN ${fnName} function`;
-  }
-  let entities = [];
-  if (options.entities) {
-    entities = options.entities.split(",").map((e) => e.trim()).filter(Boolean);
-  } else if (!options.yes) {
-    entities = await promptEntities();
-  }
-  const enableCache = !options.skipCache;
-  const enableRoutes = !options.skipRoutes;
-  const config = {
-    scope,
-    fnName,
-    description,
-    entities,
-    enableCache,
-    enableRoutes
-  };
-  if (!options.yes) {
-    const confirmed = await confirmConfiguration(config);
-    if (!confirmed) {
-      process.exit(0);
-    }
-  }
-  const spinner = ora12("Generating function structure...").start();
-  try {
-    await generateFunctionStructure({
-      fnDir,
-      scope,
-      fnName,
-      description,
-      entities,
-      enableCache,
-      enableRoutes
-    });
-    spinner.succeed("Function structure generated");
-    console.log("");
-    logger.success(`\u2728 Package ${chalk27.cyan(`${scope}/${fnName}`)} created successfully!
-`);
-    logger.info(chalk27.bold("\u{1F4DA} Next steps:"));
-    console.log(`  ${chalk27.gray("1.")} cd ${fnName}`);
-    console.log(`  ${chalk27.gray("2.")} pnpm install ${chalk27.dim("(in monorepo root)")}`);
-    console.log(`  ${chalk27.gray("3.")} pnpm build`);
-    console.log(`  ${chalk27.gray("4.")} ${chalk27.dim("Use the package in your app")}`);
-    console.log("");
-  } catch (error) {
-    spinner.fail("Failed to generate function");
-    logger.error(String(error));
-    process.exit(1);
-  }
-}
-var generateCommand = new Command11("generate").alias("g").description("Generate SPFN resources");
-generateCommand.command("fn").description("Generate a new SPFN function module").argument("[name]", "Function name").option("-s, --scope <scope>", "NPM scope (e.g., @spfn, @mycompany)").option("-d, --description <text>", "Function description").option("-e, --entities <list>", "Comma-separated entity names").option("--skip-cache", "Skip cache generation").option("--skip-routes", "Skip route generation").option("-y, --yes", "Skip all prompts").action(generateFunction);
-
-// src/commands/env.ts
-import { Command as Command12 } from "commander";
-import chalk28 from "chalk";
-import { existsSync as existsSync25, readFileSync as readFileSync9, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync9, writeFileSync as writeFileSync13 } from "fs";
 import { resolve as resolve2 } from "path";
 import { parse } from "dotenv";
 var VALID_ENVS = ["local", "development", "staging", "production", "test"];
 var BASE_ENV_FILES = {
   nextjs: [".env", ".env.local"],
-  server: [".env.server", ".env.server.local"]
+  server: [".env.server"]
 };
 function getEnvFilesForEnvironment(nodeEnv) {
   const files = [".env"];
@@ -4984,7 +3742,6 @@ function getEnvFilesForEnvironment(nodeEnv) {
     files.push(`.env.${nodeEnv}.local`);
   }
   files.push(".env.server");
-  files.push(".env.server.local");
   return files;
 }
 function getTargetFile(schema) {
@@ -4992,7 +3749,7 @@ function getTargetFile(schema) {
   if (isNextjs) {
     return schema.sensitive ? ".env.local" : ".env";
   }
-  return schema.sensitive ? ".env.server.local" : ".env.server";
+  return ".env.server";
 }
 async function loadEnvSchema(packageName) {
   try {
@@ -5012,26 +3769,26 @@ async function loadEnvSchema(packageName) {
 }
 function formatType(type) {
   const typeColors = {
-    string: chalk28.green,
-    number: chalk28.blue,
-    boolean: chalk28.yellow,
-    url: chalk28.cyan,
-    enum: chalk28.magenta,
-    json: chalk28.red
+    string: chalk27.green,
+    number: chalk27.blue,
+    boolean: chalk27.yellow,
+    url: chalk27.cyan,
+    enum: chalk27.magenta,
+    json: chalk27.red
   };
-  return (typeColors[type] || chalk28.white)(type);
+  return (typeColors[type] || chalk27.white)(type);
 }
 function formatDefault(value, type) {
   if (value === void 0) {
-    return chalk28.dim("(none)");
+    return chalk27.dim("(none)");
   }
   if (type === "string" || type === "url") {
-    return chalk28.green(`"${value}"`);
+    return chalk27.green(`"${value}"`);
   }
   if (type === "boolean") {
-    return value ? chalk28.green("true") : chalk28.red("false");
+    return value ? chalk27.green("true") : chalk27.red("false");
   }
-  return chalk28.cyan(String(value));
+  return chalk27.cyan(String(value));
 }
 async function listEnvVars(options) {
   const packageName = options.package || "@spfn/core";
@@ -5045,28 +3802,28 @@ async function listEnvVars(options) {
         acc[target].push([key, schema]);
         return acc;
       }, {});
-      console.log(chalk28.blue.bold(`
+      console.log(chalk27.blue.bold(`
 \u{1F4CB} Environment Variables by File (${packageName})
 `));
       for (const [file, vars] of Object.entries(grouped)) {
-        console.log(chalk28.bold.magenta(`
+        console.log(chalk27.bold.magenta(`
 ${file}`));
-        console.log(chalk28.dim("\u2500".repeat(50)));
+        console.log(chalk27.dim("\u2500".repeat(50)));
         for (const [key, schema] of vars) {
           printEnvVar(key, schema);
         }
       }
     } else {
-      console.log(chalk28.blue.bold(`
+      console.log(chalk27.blue.bold(`
 \u{1F4CB} Environment Variables (${packageName})
 `));
       for (const [key, schema] of allVars) {
         printEnvVar(key, schema, true);
       }
     }
-    console.log(chalk28.dim("\n\u{1F4A1} Tip: Use `spfn env init` to generate .env template files\n"));
+    console.log(chalk27.dim("\n\u{1F4A1} Tip: Use `spfn env init` to generate .env template files\n"));
   } catch (error) {
-    console.error(chalk28.red(`
+    console.error(chalk27.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -5074,17 +3831,17 @@ ${file}`));
 }
 function printEnvVar(key, schema, showFile = false) {
   const typeStr = formatType(schema.type);
-  const requiredStr = schema.required || schema.default !== void 0 ? chalk28.red("[required]") : chalk28.dim("[optional]");
-  const sensitiveStr = schema.sensitive ? chalk28.yellow(" [sensitive]") : "";
-  const fileStr = showFile ? chalk28.dim(` \u2192 ${getTargetFile(schema)}`) : "";
-  console.log(`${chalk28.bold.cyan(key)} ${chalk28.dim("(")}${typeStr}${chalk28.dim(")")} ${requiredStr}${sensitiveStr}${fileStr}`);
-  console.log(`  ${chalk28.dim(schema.description)}`);
+  const requiredStr = schema.required || schema.default !== void 0 ? chalk27.red("[required]") : chalk27.dim("[optional]");
+  const sensitiveStr = schema.sensitive ? chalk27.yellow(" [sensitive]") : "";
+  const fileStr = showFile ? chalk27.dim(` \u2192 ${getTargetFile(schema)}`) : "";
+  console.log(`${chalk27.bold.cyan(key)} ${chalk27.dim("(")}${typeStr}${chalk27.dim(")")} ${requiredStr}${sensitiveStr}${fileStr}`);
+  console.log(`  ${chalk27.dim(schema.description)}`);
   if (schema.default !== void 0) {
-    console.log(`  ${chalk28.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
+    console.log(`  ${chalk27.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
   }
   if (schema.examples && schema.examples.length > 0) {
     const exampleStr = schema.examples.map((ex) => formatDefault(ex, schema.type)).join(", ");
-    console.log(`  ${chalk28.dim("Examples:")} ${exampleStr}`);
+    console.log(`  ${chalk27.dim("Examples:")} ${exampleStr}`);
   }
   console.log();
 }
@@ -5092,7 +3849,7 @@ async function showEnvStats(options) {
   const packageName = options.package || "@spfn/core";
   try {
     const envSchema = await loadEnvSchema(packageName);
-    console.log(chalk28.blue.bold(`
+    console.log(chalk27.blue.bold(`
 \u{1F4CA} Environment Variable Statistics (${packageName})
 `));
     const allVars = Object.entries(envSchema);
@@ -5114,24 +3871,24 @@ async function showEnvStats(options) {
       acc[file] = (acc[file] || 0) + 1;
       return acc;
     }, {});
-    console.log(`${chalk28.bold("Total variables:")} ${chalk28.cyan(allVars.length)}`);
-    console.log(`${chalk28.bold("Required:")} ${chalk28.red(required.length)}`);
-    console.log(`${chalk28.bold("Optional:")} ${chalk28.dim(optional.length)}`);
-    console.log(`${chalk28.bold("Sensitive:")} ${chalk28.yellow(sensitive.length)}`);
-    console.log(chalk28.bold("\nBy Target:"));
-    console.log(`  ${chalk28.blue("Next.js accessible:")} ${chalk28.cyan(nextjsVars.length)}`);
-    console.log(`  ${chalk28.magenta("SPFN server only:")} ${chalk28.cyan(serverOnlyVars.length)}`);
-    console.log(chalk28.bold("\nBy File:"));
+    console.log(`${chalk27.bold("Total variables:")} ${chalk27.cyan(allVars.length)}`);
+    console.log(`${chalk27.bold("Required:")} ${chalk27.red(required.length)}`);
+    console.log(`${chalk27.bold("Optional:")} ${chalk27.dim(optional.length)}`);
+    console.log(`${chalk27.bold("Sensitive:")} ${chalk27.yellow(sensitive.length)}`);
+    console.log(chalk27.bold("\nBy Target:"));
+    console.log(`  ${chalk27.blue("Next.js accessible:")} ${chalk27.cyan(nextjsVars.length)}`);
+    console.log(`  ${chalk27.magenta("SPFN server only:")} ${chalk27.cyan(serverOnlyVars.length)}`);
+    console.log(chalk27.bold("\nBy File:"));
     for (const [file, count] of Object.entries(fileCount)) {
-      console.log(`  ${chalk28.dim(file)}: ${chalk28.cyan(count)}`);
+      console.log(`  ${chalk27.dim(file)}: ${chalk27.cyan(count)}`);
     }
-    console.log(chalk28.bold("\nBy Type:"));
+    console.log(chalk27.bold("\nBy Type:"));
     for (const [type, count] of Object.entries(typeCount)) {
-      console.log(`  ${formatType(type)}: ${chalk28.cyan(count)}`);
+      console.log(`  ${formatType(type)}: ${chalk27.cyan(count)}`);
     }
     console.log();
   } catch (error) {
-    console.error(chalk28.red(`
+    console.error(chalk27.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -5151,40 +3908,40 @@ async function searchEnvVars(query, options) {
       }
     }
     if (results.length === 0) {
-      console.log(chalk28.yellow(`
+      console.log(chalk27.yellow(`
 \u26A0\uFE0F  No environment variables found matching "${query}"
 `));
       return;
     }
-    console.log(chalk28.blue.bold(`
+    console.log(chalk27.blue.bold(`
 \u{1F50D} Found ${results.length} environment variable(s) matching "${query}"
 `));
     for (const [key, schema] of results) {
       const typeStr = formatType(schema.type);
-      const requiredStr = schema.required || schema.default !== void 0 ? chalk28.red("[required]") : chalk28.dim("[optional]");
-      console.log(`${chalk28.bold.cyan(key)} ${chalk28.dim("(")}${typeStr}${chalk28.dim(")")} ${requiredStr}`);
-      console.log(`  ${chalk28.dim(schema.description)}`);
+      const requiredStr = schema.required || schema.default !== void 0 ? chalk27.red("[required]") : chalk27.dim("[optional]");
+      console.log(`${chalk27.bold.cyan(key)} ${chalk27.dim("(")}${typeStr}${chalk27.dim(")")} ${requiredStr}`);
+      console.log(`  ${chalk27.dim(schema.description)}`);
       if (schema.default !== void 0) {
-        console.log(`  ${chalk28.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
+        console.log(`  ${chalk27.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
       }
       console.log();
     }
   } catch (error) {
-    console.error(chalk28.red(`
+    console.error(chalk27.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
   }
 }
-var envCommand = new Command12("env").description("Manage environment variables");
+var envCommand = new Command11("env").description("Manage environment variables");
 envCommand.command("list").description("List all environment variables from schema").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").option("-g, --group", "Group variables by target file").action(listEnvVars);
 envCommand.command("stats").description("Show environment variable statistics").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").action(showEnvStats);
 envCommand.command("search").description("Search environment variables").argument("<query>", "Search query (matches key or description)").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").action(searchEnvVars);
 function validateEnvOption(envValue) {
   if (!VALID_ENVS.includes(envValue)) {
-    console.error(chalk28.red(`
+    console.error(chalk27.red(`
 \u274C Invalid environment: "${envValue}"`));
-    console.log(chalk28.dim(`   Valid values: ${VALID_ENVS.join(", ")}
+    console.log(chalk27.dim(`   Valid values: ${VALID_ENVS.join(", ")}
 `));
     process.exit(1);
   }
@@ -5205,8 +3962,8 @@ async function initEnvFiles(options) {
       return acc;
     }, {});
     if (targetEnv) {
-      console.log(chalk28.blue.bold(`
-\u{1F680} Generating .env template files for ${chalk28.cyan(targetEnv)} environment
+      console.log(chalk27.blue.bold(`
+\u{1F680} Generating .env template files for ${chalk27.cyan(targetEnv)} environment
 `));
       const envSpecificFiles = {};
       const committedVars = allVars.filter(([_, schema]) => !schema.sensitive);
@@ -5222,25 +3979,24 @@ async function initEnvFiles(options) {
         writeEnvTemplate(cwd, file, vars, options.force ?? false);
       }
     } else {
-      console.log(chalk28.blue.bold(`
+      console.log(chalk27.blue.bold(`
 \u{1F680} Generating .env template files
 `));
       for (const [file, vars] of Object.entries(grouped)) {
         writeEnvTemplate(cwd, file, vars, options.force ?? false);
       }
     }
-    console.log(chalk28.dim("\n\u{1F4A1} Copy .example files to create your actual .env files:"));
-    console.log(chalk28.dim("   cp .env.example .env"));
-    console.log(chalk28.dim("   cp .env.local.example .env.local"));
-    console.log(chalk28.dim("   cp .env.server.example .env.server"));
-    console.log(chalk28.dim("   cp .env.server.local.example .env.server.local"));
+    console.log(chalk27.dim("\n\u{1F4A1} Copy .example files to create your actual .env files:"));
+    console.log(chalk27.dim("   cp .env.example .env"));
+    console.log(chalk27.dim("   cp .env.local.example .env.local"));
+    console.log(chalk27.dim("   cp .env.server.example .env.server"));
     if (targetEnv) {
-      console.log(chalk28.dim(`   cp .env.${targetEnv}.example .env.${targetEnv}`));
-      console.log(chalk28.dim(`   cp .env.${targetEnv}.local.example .env.${targetEnv}.local`));
+      console.log(chalk27.dim(`   cp .env.${targetEnv}.example .env.${targetEnv}`));
+      console.log(chalk27.dim(`   cp .env.${targetEnv}.local.example .env.${targetEnv}.local`));
     }
     console.log("");
   } catch (error) {
-    console.error(chalk28.red(`
+    console.error(chalk27.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -5248,12 +4004,12 @@ async function initEnvFiles(options) {
 }
 function writeEnvTemplate(cwd, file, vars, force) {
   const filePath = resolve2(cwd, file);
-  if (existsSync25(filePath) && !force) {
-    console.log(chalk28.yellow(`  \u23ED\uFE0F  ${file} already exists (use --force to overwrite)`));
+  if (existsSync22(filePath) && !force) {
+    console.log(chalk27.yellow(`  \u23ED\uFE0F  ${file} already exists (use --force to overwrite)`));
     return;
   }
-  writeFileSync19(filePath, generateEnvFileContent(vars), "utf-8");
-  console.log(chalk28.green(`  \u2705 ${file} (${vars.length} variables)`));
+  writeFileSync13(filePath, generateEnvFileContent(vars), "utf-8");
+  console.log(chalk27.green(`  \u2705 ${file} (${vars.length} variables)`));
 }
 function generateEnvFileContent(vars) {
   const lines = [
@@ -5288,7 +4044,7 @@ async function checkEnvFiles(options) {
     const envSchema = await loadEnvSchema(packageName);
     const allVars = Object.entries(envSchema);
     const envLabel = targetEnv ? ` (${targetEnv})` : "";
-    console.log(chalk28.blue.bold(`
+    console.log(chalk27.blue.bold(`
 \u{1F50D} Checking .env files against schema${envLabel}
 `));
     const filesToCheck = targetEnv ? getEnvFilesForEnvironment(targetEnv) : [...BASE_ENV_FILES.nextjs, ...BASE_ENV_FILES.server];
@@ -5297,7 +4053,7 @@ async function checkEnvFiles(options) {
     const warnings = [];
     for (const file of filesToCheck) {
       const filePath = resolve2(cwd, file);
-      if (!existsSync25(filePath)) {
+      if (!existsSync22(filePath)) {
         continue;
       }
       const content = readFileSync9(filePath, "utf-8");
@@ -5305,7 +4061,7 @@ async function checkEnvFiles(options) {
       for (const [key, value] of Object.entries(parsed)) {
         loadedEnv[key] = { value: value || "", file };
       }
-      console.log(chalk28.dim(`  \u{1F4C4} ${file} loaded`));
+      console.log(chalk27.dim(`  \u{1F4C4} ${file} loaded`));
     }
     console.log("");
     for (const [key, schema] of allVars) {
@@ -5313,7 +4069,7 @@ async function checkEnvFiles(options) {
       const found = loadedEnv[key];
       if (!found) {
         if (schema.required && schema.default === void 0) {
-          issues.push(`${chalk28.red("\u2717")} ${chalk28.cyan(key)} is required but not found in any .env file`);
+          issues.push(`${chalk27.red("\u2717")} ${chalk27.cyan(key)} is required but not found in any .env file`);
         }
         continue;
       }
@@ -5323,11 +4079,11 @@ async function checkEnvFiles(options) {
       if (!shouldBeNextjs && isNextjsFile && !isServerFile) {
         if (schema.sensitive) {
           issues.push(
-            `${chalk28.red("\u2717")} ${chalk28.cyan(key)} is sensitive and should be in ${chalk28.magenta(expectedFile)}, but found in ${chalk28.yellow(found.file)} (security risk!)`
+            `${chalk27.red("\u2717")} ${chalk27.cyan(key)} is sensitive and should be in ${chalk27.magenta(expectedFile)}, but found in ${chalk27.yellow(found.file)} (security risk!)`
           );
         } else {
           warnings.push(
-            `${chalk28.yellow("\u26A0")} ${chalk28.cyan(key)} should be in ${chalk28.magenta(expectedFile)}, but found in ${chalk28.dim(found.file)}`
+            `${chalk27.yellow("\u26A0")} ${chalk27.cyan(key)} should be in ${chalk27.magenta(expectedFile)}, but found in ${chalk27.dim(found.file)}`
           );
         }
       }
@@ -5335,34 +4091,34 @@ async function checkEnvFiles(options) {
     for (const [key, { file }] of Object.entries(loadedEnv)) {
       const inSchema = allVars.some(([k]) => k === key);
       if (!inSchema) {
-        warnings.push(`${chalk28.yellow("\u26A0")} ${chalk28.cyan(key)} in ${chalk28.dim(file)} is not in schema`);
+        warnings.push(`${chalk27.yellow("\u26A0")} ${chalk27.cyan(key)} in ${chalk27.dim(file)} is not in schema`);
       }
     }
     if (issues.length > 0) {
-      console.log(chalk28.red.bold("Issues:"));
+      console.log(chalk27.red.bold("Issues:"));
       for (const issue of issues) {
         console.log(`  ${issue}`);
       }
       console.log("");
     }
     if (warnings.length > 0) {
-      console.log(chalk28.yellow.bold("Warnings:"));
+      console.log(chalk27.yellow.bold("Warnings:"));
       for (const warning of warnings) {
         console.log(`  ${warning}`);
       }
       console.log("");
     }
     if (issues.length === 0 && warnings.length === 0) {
-      console.log(chalk28.green("\u2705 All environment variables are correctly configured!\n"));
+      console.log(chalk27.green("\u2705 All environment variables are correctly configured!\n"));
     } else {
-      console.log(chalk28.dim(`Found ${issues.length} issue(s) and ${warnings.length} warning(s)
+      console.log(chalk27.dim(`Found ${issues.length} issue(s) and ${warnings.length} warning(s)
 `));
       if (issues.length > 0) {
         process.exit(1);
       }
     }
   } catch (error) {
-    console.error(chalk28.red(`
+    console.error(chalk27.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -5374,17 +4130,17 @@ async function validateEnvVars(options) {
   const packages = options.packages || ["@spfn/core"];
   const targetEnv = options.env ? validateEnvOption(options.env) : void 0;
   if (targetEnv) {
-    const { loadEnv: loadEnv8 } = await import("@spfn/core/env/loader");
-    const result = loadEnv8({ nodeEnv: targetEnv });
-    console.log(chalk28.blue.bold(`
-\u{1F50D} Validating environment variables for ${chalk28.cyan(targetEnv)}
+    const { loadEnv: loadEnv9 } = await import("@spfn/core/env/loader");
+    const result = loadEnv9({ nodeEnv: targetEnv });
+    console.log(chalk27.blue.bold(`
+\u{1F50D} Validating environment variables for ${chalk27.cyan(targetEnv)}
 `));
     if (result.loadedFiles.length > 0) {
-      console.log(chalk28.dim(`  Loaded: ${result.loadedFiles.join(", ")}`));
+      console.log(chalk27.dim(`  Loaded: ${result.loadedFiles.join(", ")}`));
     }
     console.log("");
   } else {
-    console.log(chalk28.blue.bold(`
+    console.log(chalk27.blue.bold(`
 \u{1F50D} Validating environment variables
 `));
   }
@@ -5392,7 +4148,7 @@ async function validateEnvVars(options) {
   const allWarnings = [];
   for (const packageName of packages) {
     try {
-      console.log(chalk28.dim(`  \u{1F4E6} ${packageName}`));
+      console.log(chalk27.dim(`  \u{1F4E6} ${packageName}`));
       const envSchema = await loadEnvSchema(packageName);
       const { createEnvRegistry } = await import("@spfn/core/env");
       const registry = createEnvRegistry(envSchema);
@@ -5405,10 +4161,10 @@ async function validateEnvVars(options) {
       }
     } catch (error) {
       if (error instanceof Error && error.message.includes("does not export envSchema")) {
-        console.log(chalk28.dim(`    \u23ED\uFE0F  No envSchema exported, skipping`));
+        console.log(chalk27.dim(`    \u23ED\uFE0F  No envSchema exported, skipping`));
         continue;
       }
-      console.error(chalk28.red(`    \u274C Failed to load: ${error instanceof Error ? error.message : String(error)}`));
+      console.error(chalk27.red(`    \u274C Failed to load: ${error instanceof Error ? error.message : String(error)}`));
       if (options.strict) {
         process.exit(1);
       }
@@ -5416,32 +4172,32 @@ async function validateEnvVars(options) {
   }
   console.log("");
   if (allErrors.length > 0) {
-    console.log(chalk28.red.bold(`\u274C Validation Errors (${allErrors.length}):
+    console.log(chalk27.red.bold(`\u274C Validation Errors (${allErrors.length}):
 `));
     for (const error of allErrors) {
-      console.log(`  ${chalk28.red("\u2717")} ${chalk28.cyan(error.key)}`);
-      console.log(`    ${chalk28.dim(error.message)}`);
-      console.log(`    ${chalk28.dim(`from ${error.package}`)}`);
+      console.log(`  ${chalk27.red("\u2717")} ${chalk27.cyan(error.key)}`);
+      console.log(`    ${chalk27.dim(error.message)}`);
+      console.log(`    ${chalk27.dim(`from ${error.package}`)}`);
       console.log("");
     }
   }
   if (allWarnings.length > 0) {
-    console.log(chalk28.yellow.bold(`\u26A0\uFE0F  Warnings (${allWarnings.length}):
+    console.log(chalk27.yellow.bold(`\u26A0\uFE0F  Warnings (${allWarnings.length}):
 `));
     for (const warning of allWarnings) {
-      console.log(`  ${chalk28.yellow("\u26A0")} ${chalk28.cyan(warning.key)}`);
-      console.log(`    ${chalk28.dim(warning.message)}`);
+      console.log(`  ${chalk27.yellow("\u26A0")} ${chalk27.cyan(warning.key)}`);
+      console.log(`    ${chalk27.dim(warning.message)}`);
       console.log("");
     }
   }
   if (allErrors.length === 0 && allWarnings.length === 0) {
-    console.log(chalk28.green.bold("\u2705 All environment variables are valid!\n"));
+    console.log(chalk27.green.bold("\u2705 All environment variables are valid!\n"));
   } else if (allErrors.length === 0) {
-    console.log(chalk28.green("\u2705 No errors found."));
-    console.log(chalk28.yellow(`\u26A0\uFE0F  ${allWarnings.length} warning(s) found.
+    console.log(chalk27.green("\u2705 No errors found."));
+    console.log(chalk27.yellow(`\u26A0\uFE0F  ${allWarnings.length} warning(s) found.
 `));
   } else {
-    console.log(chalk28.red(`
+    console.log(chalk27.red(`
 \u274C Validation failed with ${allErrors.length} error(s)
 `));
     process.exit(1);
@@ -5451,12 +4207,11 @@ envCommand.command("validate").description("Validate environment variables again
 
 // src/index.ts
 init_version();
-var program = new Command13();
+var program = new Command12();
 program.name("spfn").description("SPFN CLI - The Missing Backend for Next.js").version(getCliVersion());
 program.addCommand(createCommand);
 program.addCommand(initCommand);
 program.addCommand(addCommand);
-program.addCommand(generateCommand);
 program.addCommand(devCommand);
 program.addCommand(buildCommand);
 program.addCommand(startCommand);