spfn 0.1.0-alpha.88 → 0.2.0-beta.10

package/dist/index.js

@@ -1,36 +1,1085 @@
-import {
-  setupCommand
-} from "./chunk-K5K5BTB7.js";
-import {
-  initCommand
-} from "./chunk-526QKBO7.js";
-import {
-  detectPackageManager,
-  logger
-} from "./chunk-QH74KQEW.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// src/index.ts
-import { Command as Command10 } from "commander";
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    logger = {
+      info: (message) => {
+        console.log(chalk.blue("\u2139"), message);
+      },
+      success: (message) => {
+        console.log(chalk.green("\u2713"), message);
+      },
+      warn: (message) => {
+        console.log(chalk.yellow("\u26A0"), message);
+      },
+      error: (message) => {
+        console.log(chalk.red("\u2717"), message);
+      },
+      step: (message) => {
+        console.log(chalk.cyan("\u25B8"), message);
+      }
+    };
+  }
+});
 
-// src/commands/create.ts
-import { Command } from "commander";
+// src/utils/package-manager.ts
 import { existsSync } from "fs";
 import { join } from "path";
-import prompts from "prompts";
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  let currentDir = cwd;
+  let depth = 0;
+  const maxDepth = 5;
+  while (depth < maxDepth) {
+    const parentDir = join(currentDir, "..");
+    if (parentDir === currentDir) {
+      break;
+    }
+    if (existsSync(join(parentDir, "pnpm-lock.yaml"))) {
+      return "pnpm";
+    }
+    if (existsSync(join(parentDir, "yarn.lock"))) {
+      return "yarn";
+    }
+    if (existsSync(join(parentDir, "bun.lockb"))) {
+      return "bun";
+    }
+    currentDir = parentDir;
+    depth++;
+  }
+  return "npm";
+}
+var init_package_manager = __esm({
+  "src/utils/package-manager.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  setupCommand: () => setupCommand,
+  setupIcons: () => setupIcons
+});
+import { Command } from "commander";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 import ora from "ora";
 import { execa } from "execa";
-import chalk from "chalk";
+import fse from "fs-extra";
+import chalk2 from "chalk";
+async function setupIcons() {
+  const cwd = process.cwd();
+  logger.info("Setting up SVGR for SVG icon management...\n");
+  const packageJsonPath = join2(cwd, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    logger.error("No package.json found. Please run this in a Next.js project.");
+    process.exit(1);
+  }
+  const packageJson = JSON.parse(
+    readFileSync(packageJsonPath, "utf-8")
+  );
+  const hasNext = packageJson.dependencies?.next || packageJson.devDependencies?.next;
+  if (!hasNext) {
+    logger.error("Next.js not detected in dependencies. This setup is for Next.js projects only.");
+    process.exit(1);
+  }
+  const hasSvgr = packageJson.devDependencies?.["@svgr/webpack"];
+  if (hasSvgr) {
+    logger.warn("@svgr/webpack is already installed.");
+    logger.info("Skipping installation, but will create directory structure...\n");
+  }
+  if (!hasSvgr) {
+    const pm = detectPackageManager(cwd);
+    logger.step(`Detected package manager: ${pm}`);
+    const spinner2 = ora("Installing @svgr/webpack...").start();
+    try {
+      await execa(
+        pm,
+        pm === "npm" ? ["install", "--save-dev", "@svgr/webpack"] : ["add", "-D", "@svgr/webpack"],
+        { cwd }
+      );
+      spinner2.succeed("@svgr/webpack installed");
+    } catch (error) {
+      spinner2.fail("Failed to install @svgr/webpack");
+      logger.error(String(error));
+      process.exit(1);
+    }
+  }
+  const spinner = ora("Updating next.config...").start();
+  try {
+    const possibleConfigs = [
+      "next.config.ts",
+      "next.config.js",
+      "next.config.mjs"
+    ];
+    let configPath = null;
+    for (const config of possibleConfigs) {
+      const path5 = join2(cwd, config);
+      if (existsSync2(path5)) {
+        configPath = path5;
+        break;
+      }
+    }
+    if (!configPath) {
+      spinner.warn("next.config not found, creating next.config.ts...");
+      configPath = join2(cwd, "next.config.ts");
+      const newConfig = `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  webpack(config) {
+    // SVGR: Import SVG as React components
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const fileLoaderRule = (config.module.rules as any[])
+      .find((rule: any) => Array.isArray(rule.oneOf))
+      ?.oneOf.find((rule: any) => rule.test?.test?.('.svg'));
+
+    if (fileLoaderRule) {
+      fileLoaderRule.exclude = /\\.svg$/i;
+    }
+
+    config.module.rules.unshift({
+      test: /\\.svg$/i,
+      use: ['@svgr/webpack'],
+    });
+
+    return config;
+  },
+  turbopack: {
+    rules: {
+      '*.svg': {
+        loaders: ['@svgr/webpack'],
+        as: '*.js',
+      },
+    },
+  },
+};
+
+export default nextConfig;
+`;
+      writeFileSync(configPath, newConfig);
+      spinner.succeed("Created next.config.ts with SVGR support");
+    } else {
+      let configContent = readFileSync(configPath, "utf-8");
+      if (configContent.includes("@svgr/webpack")) {
+        spinner.warn("SVGR already configured in next.config");
+      } else {
+        const hasWebpack = configContent.includes("webpack(");
+        const hasTurbopack = configContent.includes("turbopack:");
+        if (hasWebpack || hasTurbopack) {
+          spinner.info("Manual update required for next.config");
+          logger.warn("\nYou need to manually add SVGR configuration to your next.config file.");
+          logger.info("See: https://react-svgr.com/docs/next/");
+          logger.info("\nAdd this to your next.config:\n");
+          console.log(chalk2.gray(`
+webpack(config) {
+  const fileLoaderRule = config.module.rules
+    .find(rule => rule.oneOf)
+    ?.oneOf.find(rule => rule.test?.test?.('.svg'));
+
+  if (fileLoaderRule) {
+    fileLoaderRule.exclude = /\\.svg$/i;
+  }
+
+  config.module.rules.unshift({
+    test: /\\.svg$/i,
+    use: ['@svgr/webpack'],
+  });
+
+  return config;
+},
+turbopack: {
+  rules: {
+    '*.svg': {
+      loaders: ['@svgr/webpack'],
+      as: '*.js',
+    },
+  },
+},
+                `));
+        } else {
+          const webpackConfig = `  webpack(config) {
+    // SVGR: Import SVG as React components
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const fileLoaderRule = (config.module.rules as any[])
+      .find((rule: any) => Array.isArray(rule.oneOf))
+      ?.oneOf.find((rule: any) => rule.test?.test?.('.svg'));
+
+    if (fileLoaderRule) {
+      fileLoaderRule.exclude = /\\.svg$/i;
+    }
+
+    config.module.rules.unshift({
+      test: /\\.svg$/i,
+      use: ['@svgr/webpack'],
+    });
+
+    return config;
+  },`;
+          const turbopackConfig = `  turbopack: {
+    rules: {
+      '*.svg': {
+        loaders: ['@svgr/webpack'],
+        as: '*.js',
+      },
+    },
+  },`;
+          const emptyConfigPattern = /const\s+\w+:\s*NextConfig\s*=\s*\{\s*\};/;
+          if (emptyConfigPattern.test(configContent)) {
+            configContent = configContent.replace(
+              emptyConfigPattern,
+              `const nextConfig: NextConfig = {
+${webpackConfig}
+${turbopackConfig}
+};`
+            );
+          } else {
+            const configObjectPattern = /(const\s+\w+:\s*NextConfig\s*=\s*\{)([^}]*?)(\};)/s;
+            if (configObjectPattern.test(configContent)) {
+              configContent = configContent.replace(
+                configObjectPattern,
+                (_match, opening, content, closing) => {
+                  const trimmedContent = content.trim();
+                  if (trimmedContent) {
+                    return `${opening}${content}
+${webpackConfig}
+${turbopackConfig}
+${closing}`;
+                  } else {
+                    return `${opening}
+${webpackConfig}
+${turbopackConfig}
+${closing}`;
+                  }
+                }
+              );
+            }
+          }
+          writeFileSync(configPath, configContent);
+          spinner.succeed("Added SVGR configuration to next.config");
+        }
+      }
+    }
+  } catch (error) {
+    spinner.fail("Failed to update next.config");
+    logger.error(String(error));
+  }
+  const iconsSpinner = ora("Creating src/assets/icons/ directory...").start();
+  try {
+    const iconsDir = join2(cwd, "src", "assets", "icons");
+    ensureDirSync(iconsDir);
+    const readmePath = join2(iconsDir, "README.md");
+    const readmeContent = `# Icons
+
+This directory manages SVG icons for the project.
+
+## Usage
+
+Import SVG files as React components using SVGR:
+
+\`\`\`tsx
+import Logo from '@/assets/icons/logo.svg';
+
+function MyComponent() {
+  return (
+    <Logo className="size-8 text-gray-900 dark:text-white" />
+  );
+}
+\`\`\`
+
+## Color Control
+
+Use \`fill="currentColor"\` in your SVG files to control colors via Tailwind CSS:
+
+\`\`\`tsx
+// Light mode: gray-900, Dark mode: white
+<Logo className="size-8 text-gray-900 dark:text-white" />
+
+// Custom colors
+<Icon className="size-6 text-blue-600" />
+\`\`\`
+
+## Adding New Icons
+
+1. Add SVG file to this directory
+2. Set \`fill="currentColor"\` for color control (optional)
+3. Remove \`width\` and \`height\` attributes for flexible sizing
+4. Import and use as React component
+
+\`\`\`tsx
+import NewIcon from '@/assets/icons/new-icon.svg';
+\`\`\`
+
+## Configuration
+
+- **next.config.ts**: SVGR webpack loader configuration
+- **Turbopack**: SVG loader rules for fast refresh
+
+## Example SVG Structure
+
+\`\`\`xml
+<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="..." fill="currentColor"/>
+</svg>
+\`\`\`
+
+Note: Remove \`width\` and \`height\` for flexible sizing with Tailwind utilities.
+`;
+    writeFileSync(readmePath, readmeContent);
+    iconsSpinner.succeed("Created src/assets/icons/ directory with README.md");
+  } catch (error) {
+    iconsSpinner.fail("Failed to create directory structure");
+    logger.error(String(error));
+  }
+  console.log("\n" + chalk2.green.bold("\u2713 SVGR setup completed!\n"));
+  console.log("Next steps:");
+  console.log("  1. Add SVG files to " + chalk2.cyan("src/assets/icons/"));
+  console.log("  2. Import them as React components:");
+  console.log("     " + chalk2.gray("import Logo from '@/assets/icons/logo.svg';"));
+  console.log("  3. Use with Tailwind classes:");
+  console.log("     " + chalk2.gray('<Logo className="size-8 text-gray-900 dark:text-white" />'));
+  console.log("\nDocumentation: " + chalk2.cyan("src/assets/icons/README.md"));
+}
+var ensureDirSync, writeFileSync, readFileSync, setupCommand;
+var init_setup = __esm({
+  "src/commands/setup.ts"() {
+    "use strict";
+    init_logger();
+    init_package_manager();
+    ({ ensureDirSync, writeFileSync, readFileSync } = fse);
+    setupCommand = new Command("setup").description("Setup additional features for your project");
+    setupCommand.command("icons").description("Setup SVGR for SVG icon management").action(setupIcons);
+  }
+});
+
+// src/commands/init/steps/validate.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import prompts from "prompts";
+async function validateProject(cwd, skipPrompts) {
+  const packageJsonPath = join3(cwd, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    logger.error("No package.json found. Please run this in a Next.js project.");
+    process.exit(1);
+  }
+  const packageJson = JSON.parse(await import("fs").then(
+    (fs5) => fs5.promises.readFile(packageJsonPath, "utf-8")
+  ));
+  const hasNext = packageJson.dependencies?.next || packageJson.devDependencies?.next;
+  if (!hasNext) {
+    logger.warn("Next.js not detected in dependencies.");
+    if (!skipPrompts) {
+      const { proceed } = await prompts(
+        {
+          type: "confirm",
+          name: "proceed",
+          message: "Continue anyway?",
+          initial: false
+        }
+      );
+      if (!proceed) {
+        process.exit(0);
+      }
+    }
+  }
+  logger.info("Initializing SPFN in your Next.js project...\n");
+  if (existsSync3(join3(cwd, "src", "server"))) {
+    logger.warn("src/server directory already exists.");
+    if (!skipPrompts) {
+      const { overwrite } = await prompts(
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: "Overwrite existing files?",
+          initial: false
+        }
+      );
+      if (!overwrite) {
+        logger.info("Cancelled.");
+        process.exit(0);
+      }
+    }
+  }
+  let includeAuth = false;
+  if (!skipPrompts) {
+    const { auth } = await prompts(
+      {
+        type: "confirm",
+        name: "auth",
+        message: "Include authentication (@spfn/auth)?",
+        initial: true
+      }
+    );
+    includeAuth = auth;
+  }
+  return { packageJson, packageJsonPath, includeAuth };
+}
+var init_validate = __esm({
+  "src/commands/init/steps/validate.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/commands/init/utils/templates.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, dirname } from "path";
+import { fileURLToPath } from "url";
+function findTemplatesPath() {
+  const bundledPath = join4(__dirname, "templates");
+  if (existsSync4(bundledPath)) {
+    return bundledPath;
+  }
+  const npmPath = join4(__dirname, "..", "..", "templates");
+  if (existsSync4(npmPath)) {
+    return npmPath;
+  }
+  const devPath = join4(__dirname, "..", "..", "..", "templates");
+  if (existsSync4(devPath)) {
+    return devPath;
+  }
+  throw new Error("Templates directory not found. Please rebuild the package.");
+}
+var __dirname;
+var init_templates = __esm({
+  "src/commands/init/utils/templates.ts"() {
+    "use strict";
+    __dirname = dirname(fileURLToPath(import.meta.url));
+  }
+});
+
+// src/commands/init/steps/server-structure.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+import ora2 from "ora";
+import fse2 from "fs-extra";
+async function setupServerStructure(cwd) {
+  const spinner = ora2("Setting up server structure...").start();
+  try {
+    const templatesDir = findTemplatesPath();
+    const serverTemplateDir = join5(templatesDir, "server");
+    const targetDir = join5(cwd, "src", "server");
+    if (!existsSync5(serverTemplateDir)) {
+      spinner.fail("Failed to create server structure");
+      logger.error(`Server templates not found at: ${serverTemplateDir}`);
+      process.exit(1);
+    }
+    ensureDirSync2(targetDir);
+    copySync(serverTemplateDir, targetDir);
+    const libTemplateDir = join5(templatesDir, "lib");
+    const libTargetDir = join5(cwd, "src", "lib");
+    if (existsSync5(libTemplateDir)) {
+      ensureDirSync2(libTargetDir);
+      copySync(libTemplateDir, libTargetDir);
+    }
+    const envConfigTemplate = join5(serverTemplateDir, "config", "env.config.ts");
+    const envConfigTarget = join5(targetDir, "config", "env.config.ts");
+    if (existsSync5(envConfigTemplate)) {
+      ensureDirSync2(join5(targetDir, "config"));
+      copySync(envConfigTemplate, envConfigTarget);
+      logger.success("Created src/server/config/env.config.ts (environment management)");
+    }
+    spinner.succeed("Server structure created");
+  } catch (error) {
+    spinner.fail("Failed to create server structure");
+    logger.error(String(error));
+    process.exit(1);
+  }
+}
+var copySync, ensureDirSync2;
+var init_server_structure = __esm({
+  "src/commands/init/steps/server-structure.ts"() {
+    "use strict";
+    init_logger();
+    init_templates();
+    ({ copySync, ensureDirSync: ensureDirSync2 } = fse2);
+  }
+});
+
+// src/commands/init/steps/api-proxy.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import fse3 from "fs-extra";
+async function setupApiProxy(cwd, includeAuth) {
+  const srcAppDir = join6(cwd, "src", "app");
+  const rootAppDir = join6(cwd, "app");
+  let appDir;
+  if (existsSync6(srcAppDir)) {
+    appDir = srcAppDir;
+  } else if (existsSync6(rootAppDir)) {
+    appDir = rootAppDir;
+  } else {
+    logger.error("Next.js app directory not found. Expected src/app or app directory.");
+    process.exit(1);
+  }
+  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);
+  }
+  ensureDirSync3(rpcDir);
+  const authImport = includeAuth ? `import '@spfn/auth/nextjs/api';
+` : "";
+  const routeContent = `/**
+ * SPFN RPC Proxy
+ *
+ * Resolves routeName to actual HTTP method and path from routeMap,
+ * then forwards requests to SPFN API server with automatic:
+ * - Cookie forwarding
+ * - Interceptor execution
+ * - Header manipulation
+ *
+ * Note: Uses generated route-map to avoid loading server code in Next.js process.
+ * Run \`spfn codegen run\` if route-map.ts is missing.
+ */
+
+${authImport}import { routeMap } from '@/generated/route-map';
+import { createRpcProxy } from '@spfn/core/nextjs/server';
+
+export const { GET, POST } = createRpcProxy({ routeMap });
+`;
+  writeFileSync2(rpcRoutePath, routeContent);
+  const relativePath = rpcRoutePath.replace(cwd + "/", "");
+  logger.success(`Created ${relativePath} (RPC proxy)`);
+}
+var ensureDirSync3, writeFileSync2;
+var init_api_proxy = __esm({
+  "src/commands/init/steps/api-proxy.ts"() {
+    "use strict";
+    init_logger();
+    ({ ensureDirSync: ensureDirSync3, writeFileSync: writeFileSync2 } = fse3);
+  }
+});
+
+// src/commands/init/steps/docker.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+import fse4 from "fs-extra";
+async function setupDockerFiles(cwd) {
+  const templatesDir = findTemplatesPath();
+  const dockerComposePath = join7(cwd, "docker-compose.yml");
+  if (!existsSync7(dockerComposePath)) {
+    try {
+      const dockerComposeTemplate = join7(templatesDir, "docker-compose.yml");
+      if (existsSync7(dockerComposeTemplate)) {
+        copySync2(dockerComposeTemplate, dockerComposePath);
+        logger.success("Created docker-compose.yml (PostgreSQL + Redis)");
+      }
+    } catch (error) {
+      logger.warn("Could not copy docker-compose.yml");
+    }
+  }
+  try {
+    const dockerfilePath = join7(cwd, "Dockerfile");
+    if (!existsSync7(dockerfilePath)) {
+      const dockerfileTemplate = join7(templatesDir, "Dockerfile");
+      if (existsSync7(dockerfileTemplate)) {
+        copySync2(dockerfileTemplate, dockerfilePath);
+        logger.success("Created Dockerfile");
+      }
+    }
+    const dockerignorePath = join7(cwd, ".dockerignore");
+    if (!existsSync7(dockerignorePath)) {
+      const dockerignoreTemplate = join7(templatesDir, ".dockerignore");
+      if (existsSync7(dockerignoreTemplate)) {
+        copySync2(dockerignoreTemplate, dockerignorePath);
+        logger.success("Created .dockerignore");
+      }
+    }
+    const dockerComposeProdPath = join7(cwd, "docker-compose.production.yml");
+    if (!existsSync7(dockerComposeProdPath)) {
+      const dockerComposeProdTemplate = join7(templatesDir, "docker-compose.production.yml");
+      if (existsSync7(dockerComposeProdTemplate)) {
+        copySync2(dockerComposeProdTemplate, dockerComposeProdPath);
+        logger.success("Created docker-compose.production.yml");
+      }
+    }
+  } catch (error) {
+    logger.warn("Could not copy Docker files (you can create them manually)");
+  }
+}
+var copySync2;
+var init_docker = __esm({
+  "src/commands/init/steps/docker.ts"() {
+    "use strict";
+    init_logger();
+    init_templates();
+    ({ copySync: copySync2 } = fse4);
+  }
+});
+
+// src/commands/init/steps/deployment-config.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
+import fse5 from "fs-extra";
+async function setupDeploymentConfig(cwd, packageJson, packageManager) {
+  const deploymentConfigPath = join8(cwd, "spfn.config.js");
+  if (!existsSync8(deploymentConfigPath)) {
+    try {
+      const projectName = packageJson.name?.replace(/[@\/]/g, "-").toLowerCase() || cwd.split("/").pop()?.toLowerCase() || "my-app";
+      const configContent = `/**
+ * SPFN Configuration
+ *
+ * This file configures your SPFN application deployment settings.
+ *
+ * @type {import('spfn').SpfnConfig}
+ */
+export default {
+  /**
+   * Package manager to use for dependency installation
+   * Options: 'npm' | 'yarn' | 'pnpm' | 'bun'
+   */
+  packageManager: '${packageManager}',
+
+  /**
+   * Deployment configuration for SPFN cloud platform
+   */
+  deployment: {
+    /**
+     * Your app's subdomain on spfn.app
+     *
+     * This will automatically create region-specific domains:
+     * - {subdomain}.{region}.spfn.app \u2192 Next.js frontend (port 3790)
+     * - api-{subdomain}.{region}.spfn.app \u2192 SPFN backend (port 8790)
+     *
+     * Example: subdomain: '${projectName}', region: 'us' creates:
+     * - ${projectName}.us.spfn.app
+     * - api-${projectName}.us.spfn.app
+     */
+    subdomain: '${projectName}',
+
+    /**
+     * Deployment region (optional, defaults to 'us')
+     *
+     * Available regions:
+     * - 'us': Virginia, USA (default)
+     * - 'kr': Seoul, South Korea
+     * - 'jp': Tokyo, Japan [Coming soon]
+     * - 'sg': Singapore [Coming soon]
+     * - 'eu': Frankfurt, Germany [Coming soon]
+     */
+    region: 'us',
+
+    /**
+     * Custom domains (optional)
+     *
+     * Add your own custom domains here. Make sure to configure DNS:
+     * - CNAME record pointing to spfn.app
+     *
+     * Example:
+     * customDomains: {
+     *   nextjs: ['www.example.com', 'example.com'],
+     *   spfn: ['api.example.com']
+     * }
+     */
+    customDomains: {
+      /**
+       * Custom domains for Next.js frontend
+       */
+      nextjs: [],
+
+      /**
+       * Custom domains for SPFN backend API
+       */
+      spfn: []
+    },
+
+    /**
+     * Environment variables (optional)
+     *
+     * Most environment variables are auto-generated by the CI/CD pipeline.
+     * Only add custom values if you need to override defaults.
+     *
+     * \u{1F527} Auto-generated variables (leave env empty for defaults):
+     * - NEXT_PUBLIC_API_URL: https://api-{subdomain}.{region}.spfn.app
+     *   (Used by browser/client-side code)
+     * - API_URL: http://localhost:8790
+     *   (Used by Next.js SSR/API Routes - same container, internal)
+     *
+     * \u{1F4CB} When to add custom env:
+     * - Using custom API domain (not *.spfn.app)
+     * - Additional environment variables for your app
+     *
+     * \u26A0\uFE0F  SECURITY WARNING:
+     * - These values are committed to Git
+     * - Do NOT put sensitive credentials here (DB passwords, API keys, etc.)
+     * - For production secrets, use your CI/CD secrets management
+     *
+     * Example (custom API domain):
+     * env: {
+     *   NEXT_PUBLIC_API_URL: 'https://api.custom.com',
+     *   API_URL: 'https://api.custom.com',
+     *   NEXT_PUBLIC_FEATURE_FLAG: 'true'
+     * }
+     */
+    env: {}
+  }
+}
+`;
+      writeFileSync3(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 init_deployment_config = __esm({
+  "src/commands/init/steps/deployment-config.ts"() {
+    "use strict";
+    init_logger();
+    ({ writeFileSync: writeFileSync3 } = fse5);
+  }
+});
+
+// src/utils/version.ts
+function getCliVersion() {
+  return "0.2.0-beta.10";
+}
+function getTagFromVersion(version) {
+  const match = version.match(/-([a-z]+)\./i);
+  return match ? match[1] : "latest";
+}
+function getSpfnTag() {
+  return getTagFromVersion(getCliVersion());
+}
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/init/steps/package.ts
+import ora3 from "ora";
+import { execa as execa2 } from "execa";
+import fse6 from "fs-extra";
+async function setupPackageJson(cwd, packageJsonPath, packageJson, packageManager, includeAuth) {
+  const spinner = ora3("Updating package.json...").start();
+  packageJson.dependencies = packageJson.dependencies || {};
+  packageJson.devDependencies = packageJson.devDependencies || {};
+  packageJson.scripts = packageJson.scripts || {};
+  const spfnTag = getSpfnTag();
+  packageJson.dependencies["@spfn/core"] = spfnTag;
+  packageJson.dependencies["@sinclair/typebox"] = "^0.34.0";
+  packageJson.dependencies["drizzle-typebox"] = "^0.1.0";
+  packageJson.dependencies["spfn"] = spfnTag;
+  packageJson.dependencies["concurrently"] = "^9.2.1";
+  if (includeAuth) {
+    packageJson.dependencies["@spfn/auth"] = spfnTag;
+  }
+  packageJson.devDependencies["@types/node"] = "^20.11.0";
+  packageJson.devDependencies["tsx"] = "^4.20.6";
+  packageJson.devDependencies["tsup"] = "^8.5.0";
+  packageJson.devDependencies["drizzle-kit"] = "^0.31.5";
+  packageJson.devDependencies["dotenv"] = "^17.2.3";
+  if (!packageJson.scripts["build"]) {
+    packageJson.scripts["build"] = "next build --turbopack";
+  }
+  if (!packageJson.scripts["start"]) {
+    packageJson.scripts["start"] = "next start";
+  }
+  packageJson.scripts["spfn:dev"] = "spfn dev";
+  packageJson.scripts["spfn:server"] = "spfn dev --server-only";
+  packageJson.scripts["spfn:next"] = "next dev --turbo --port 3790";
+  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));
+  spinner.succeed("package.json updated");
+  spinner.start("Installing dependencies...");
+  try {
+    const installArgs = packageManager === "npm" ? ["install", "--legacy-peer-deps"] : ["install"];
+    await execa2(packageManager, installArgs, { cwd });
+    spinner.succeed("Dependencies installed");
+  } catch (error) {
+    spinner.fail("Failed to install dependencies");
+    logger.error(String(error));
+    process.exit(1);
+  }
+}
+var writeFileSync4;
+var init_package = __esm({
+  "src/commands/init/steps/package.ts"() {
+    "use strict";
+    init_logger();
+    init_version();
+    ({ writeFileSync: writeFileSync4 } = fse6);
+  }
+});
+
+// src/commands/init/steps/config-files.ts
+import { existsSync as existsSync9, readFileSync as readFileSync2 } from "fs";
+import { join as join9 } from "path";
+import fse7 from "fs-extra";
+async function setupConfigFiles(cwd) {
+  const envExamplePath = join9(cwd, ".env.local.example");
+  if (!existsSync9(envExamplePath)) {
+    const envExampleContent = `# Environment
+NODE_ENV=local
+
+# Logging
+SPFN_LOG_LEVEL=info
+
+# Database (matches docker-compose.yml)
+DATABASE_URL=postgresql://spfn:spfn@localhost:5432/spfn_dev
+
+# Cache - Redis/Valkey (optional)
+CACHE_URL=redis://localhost:6379
+
+# SPFN API Server URL (for API Route Proxy and SSR)
+SPFN_API_URL=http://localhost:8790
+`;
+    writeFileSync5(envExamplePath, envExampleContent);
+    logger.success("Created .env.local.example");
+  }
+  const spfnrcPath = join9(cwd, ".spfnrc.ts");
+  if (!existsSync9(spfnrcPath)) {
+    const spfnrcContent = `import { defineConfig, defineGenerator } from '@spfn/core/codegen';
+
+/**
+ * SPFN Codegen Configuration
+ *
+ * Configure code generators here. Generators run during \`spfn dev\` and \`spfn codegen run\`.
+ */
+
+export default defineConfig({
+    generators: [
+        // Route map generator - generates routeName \u2192 {method, path} mappings
+        // Used by RPC proxy to resolve routes without importing server code
+        defineGenerator({
+            name: '@spfn/core:route-map',
+            routerPath: './src/server/router.ts',
+            outputPath: './src/generated/route-map.ts',
+        }),
+    ]
+});
+`;
+    writeFileSync5(spfnrcPath, spfnrcContent);
+    logger.success("Created .spfnrc.ts (codegen configuration)");
+  }
+  const gitignorePath = join9(cwd, ".gitignore");
+  if (existsSync9(gitignorePath)) {
+    try {
+      const gitignoreContent = readFileSync2(gitignorePath, "utf-8");
+      if (!gitignoreContent.includes(".spfn")) {
+        const updatedContent = gitignoreContent.replace(
+          /# production\n\/build/,
+          "# production\n/build\n\n# spfn\n/.spfn/"
+        );
+        writeFileSync5(gitignorePath, updatedContent);
+        logger.success("Updated .gitignore with .spfn directory");
+      }
+    } catch (error) {
+      logger.warn("Could not update .gitignore (you can add .spfn manually)");
+    }
+  }
+  const tsconfigPath = join9(cwd, "tsconfig.json");
+  if (existsSync9(tsconfigPath)) {
+    try {
+      const tsconfigContent = readFileSync2(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");
+        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 init_config_files = __esm({
+  "src/commands/init/steps/config-files.ts"() {
+    "use strict";
+    init_logger();
+    ({ writeFileSync: writeFileSync5 } = fse7);
+  }
+});
+
+// src/commands/init/index.ts
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand,
+  initializeSpfn: () => initializeSpfn
+});
+import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
+async function initializeSpfn(options = {}) {
+  const cwd = process.cwd();
+  const { packageJson, packageJsonPath, includeAuth } = await validateProject(cwd, options.yes || false);
+  const pm = detectPackageManager(cwd);
+  logger.step(`Detected package manager: ${pm}`);
+  await setupServerStructure(cwd);
+  await setupApiProxy(cwd, includeAuth);
+  await setupDockerFiles(cwd);
+  await setupDeploymentConfig(cwd, packageJson, pm);
+  await setupPackageJson(cwd, packageJsonPath, packageJson, pm, includeAuth);
+  await setupConfigFiles(cwd);
+  console.log("\n" + chalk3.green.bold("\u2713 SPFN initialized successfully!\n"));
+  console.log("Next steps:");
+  console.log("  1. Start PostgreSQL & Redis (if not installed locally):");
+  console.log("     " + chalk3.cyan("docker compose up -d"));
+  console.log("  2. Copy .env.local.example to .env.local");
+  console.log("     " + chalk3.cyan("cp .env.local.example .env.local"));
+  console.log("  3. Run: " + chalk3.cyan(pm === "npm" ? "npm run spfn:dev" : `${pm} run spfn:dev`));
+  console.log("  4. Visit:");
+  console.log("     - Next.js: " + chalk3.cyan("http://localhost:3790"));
+  console.log("     - API:     " + chalk3.cyan("http://localhost:8790/health"));
+  console.log("\nAvailable commands:");
+  console.log("  \u2022 " + chalk3.cyan(pm === "npm" ? "npm run spfn:dev" : `${pm} spfn:dev`) + "       - Start SPFN + Next.js");
+  console.log("  \u2022 " + chalk3.cyan("spfn env:validate") + "   - Validate environment variables");
+  console.log("  \u2022 " + chalk3.cyan("spfn env:docs") + "       - Generate env documentation");
+  console.log("  \u2022 " + chalk3.cyan("spfn env:check") + "      - Check environment status");
+  console.log("\n" + chalk3.blue("\u{1F4A1} Tip:") + " Edit " + chalk3.cyan("src/server/config/env.config.ts") + " to manage environment variables");
+}
+var initCommand;
+var init_init = __esm({
+  "src/commands/init/index.ts"() {
+    "use strict";
+    init_package_manager();
+    init_logger();
+    init_validate();
+    init_server_structure();
+    init_api_proxy();
+    init_docker();
+    init_deployment_config();
+    init_package();
+    init_config_files();
+    initCommand = new Command2("init").description("Initialize SPFN in your Next.js project").option("-y, --yes", "Skip prompts and use defaults").action(initializeSpfn);
+  }
+});
+
+// src/utils/function-migrations.ts
+var function_migrations_exports = {};
+__export(function_migrations_exports, {
+  discoverFunctionMigrations: () => discoverFunctionMigrations,
+  executeFunctionMigrations: () => executeFunctionMigrations
+});
+import chalk11 from "chalk";
+import { join as join15 } from "path";
+import { env as env2 } from "@spfn/core/config";
+import { loadEnvFiles as loadEnvFiles2 } from "@spfn/core/server";
+import { existsSync as existsSync16, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
+function discoverFunctionMigrations(cwd = process.cwd()) {
+  const nodeModulesPath = join15(cwd, "node_modules");
+  if (!existsSync16(nodeModulesPath)) {
+    return [];
+  }
+  const functions = [];
+  const spfnDir = join15(nodeModulesPath, "@spfn");
+  if (!existsSync16(spfnDir)) {
+    return [];
+  }
+  const packages = readdirSync2(spfnDir);
+  for (const pkg of packages) {
+    const packagePath = join15(spfnDir, pkg);
+    const packageJsonPath = join15(packagePath, "package.json");
+    if (!existsSync16(packageJsonPath)) {
+      continue;
+    }
+    try {
+      const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
+      const spfnConfig = packageJson.spfn;
+      if (!spfnConfig?.migrations) {
+        continue;
+      }
+      const migrationsDir = join15(packagePath, spfnConfig.migrations.dir);
+      if (!existsSync16(migrationsDir)) {
+        console.warn(
+          chalk11.yellow(`\u26A0\uFE0F  Package @spfn/${pkg} specifies migrations but directory not found: ${migrationsDir}`)
+        );
+        continue;
+      }
+      functions.push({
+        packageName: `@spfn/${pkg}`,
+        migrationsDir,
+        packagePath
+      });
+    } catch (error) {
+      console.warn(chalk11.yellow(`\u26A0\uFE0F  Failed to parse package.json for @spfn/${pkg}`));
+    }
+  }
+  return functions;
+}
+async function executeFunctionMigrations(functionMigrations) {
+  let executedCount = 0;
+  const { drizzle } = await import("drizzle-orm/postgres-js");
+  const { migrate } = await import("drizzle-orm/postgres-js/migrator");
+  const postgres = await import("postgres");
+  loadEnvFiles2();
+  if (!env2.DATABASE_URL) {
+    throw new Error("DATABASE_URL not found in environment");
+  }
+  const connection = postgres.default(env2.DATABASE_URL, { max: 1 });
+  const db = drizzle(connection);
+  try {
+    for (const func of functionMigrations) {
+      console.log(chalk11.blue(`
+  \u{1F4E6} Running ${func.packageName} migrations...`));
+      await migrate(db, { migrationsFolder: func.migrationsDir });
+      console.log(chalk11.green(`  \u2713 ${func.packageName} migrations applied`));
+      executedCount++;
+    }
+  } finally {
+    await connection.end();
+  }
+  return executedCount;
+}
+var init_function_migrations = __esm({
+  "src/utils/function-migrations.ts"() {
+    "use strict";
+  }
+});
+
+// src/index.ts
+import { Command as Command13 } from "commander";
+
+// src/commands/create.ts
+init_logger();
+init_package_manager();
+import { Command as Command3 } from "commander";
+import { existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
+import prompts2 from "prompts";
+import ora4 from "ora";
+import { execa as execa3 } from "execa";
+import chalk4 from "chalk";
 async function createProject(projectName, options) {
   const cwd = process.cwd();
-  const projectPath = join(cwd, projectName);
-  if (existsSync(projectPath)) {
+  const projectPath = join10(cwd, projectName);
+  if (existsSync10(projectPath)) {
     logger.error(`Directory ${projectName} already exists.`);
     process.exit(1);
   }
-  console.log(chalk.blue.bold("\n\u{1F680} Creating Next.js project with SPFN...\n"));
+  console.log(chalk4.blue.bold("\n\u{1F680} Creating Next.js project with SPFN...\n"));
   let pm = options.pm || detectPackageManager(cwd);
   if (!options.yes && !options.pm) {
-    const { selectedPm } = await prompts({
+    const { selectedPm } = await prompts2({
       type: "select",
       name: "selectedPm",
       message: "Which package manager do you want to use?",
@@ -48,7 +1097,7 @@ async function createProject(projectName, options) {
     pm = selectedPm;
   }
   logger.step(`Using package manager: ${pm}`);
-  const spinner = ora("Creating Next.js project...").start();
+  const spinner = ora4("Creating Next.js project...").start();
   try {
     const createNextAppArgs = [
       "create-next-app@latest",
@@ -71,7 +1120,7 @@ async function createProject(projectName, options) {
     }
     const createCommand2 = pm === "npm" ? "npx" : pm === "yarn" ? "yarn" : pm === "pnpm" ? "pnpm" : "bunx";
     const createArgs = createCommand2 === "npx" ? createNextAppArgs : ["dlx", ...createNextAppArgs];
-    await execa(createCommand2, createArgs, {
+    await execa3(createCommand2, createArgs, {
       cwd,
       stdio: "inherit"
     });
@@ -85,22 +1134,22 @@ async function createProject(projectName, options) {
   logger.info(`
 \u{1F4C2} Changed directory to ${projectName}
 `);
-  const iconsSpinner = ora("Setting up SVGR for icon management...").start();
+  const iconsSpinner = ora4("Setting up SVGR for icon management...").start();
   try {
     const installArgs = pm === "npm" ? ["install", "--save-dev", "@svgr/webpack"] : pm === "yarn" ? ["add", "-D", "@svgr/webpack"] : pm === "pnpm" ? ["add", "-D", "@svgr/webpack"] : ["add", "-d", "@svgr/webpack"];
-    await execa(pm, installArgs, { cwd: projectPath });
-    const { setupIcons } = await import("./setup-JA2ADEQ6.js");
-    await setupIcons();
+    await execa3(pm, installArgs, { cwd: projectPath });
+    const { setupIcons: setupIcons2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+    await setupIcons2();
     iconsSpinner.succeed("SVGR setup completed");
   } catch (error) {
     iconsSpinner.warn("Failed to setup SVGR (you can run `spfn setup icons` later)");
   }
   if (options.shadcn) {
-    const shadcnSpinner = ora("Setting up shadcn/ui...").start();
+    const shadcnSpinner = ora4("Setting up shadcn/ui...").start();
     try {
       const shadcnCommand = pm === "npm" ? "npx" : pm === "pnpm" ? "pnpx" : pm === "yarn" ? "yarn dlx" : "bunx";
       const shadcnArgs = pm === "yarn" ? ["shadcn@latest", "init", "--yes", "--defaults"] : ["shadcn@latest", "init", "--yes", "--defaults"];
-      await execa(shadcnCommand, shadcnArgs, {
+      await execa3(shadcnCommand, shadcnArgs, {
         cwd: projectPath,
         stdio: "inherit"
       });
@@ -109,95 +1158,103 @@ async function createProject(projectName, options) {
       shadcnSpinner.warn("Failed to initialize shadcn/ui (you can run `npx shadcn@latest init` later)");
     }
   }
-  const initSpinner = ora("Initializing SPFN...").start();
+  const initSpinner = ora4("Initializing SPFN...").start();
   try {
-    const { initializeSpfn } = await import("./init-EKWKKNUL.js");
-    await initializeSpfn({ yes: true });
+    const { initializeSpfn: initializeSpfn2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    await initializeSpfn2({ yes: true });
     initSpinner.succeed("SPFN initialized");
   } catch (error) {
     initSpinner.fail("Failed to initialize SPFN");
     logger.error(String(error));
     process.exit(1);
   }
-  console.log("\n" + chalk.green.bold("\u2713 Project created successfully!\n"));
-  console.log(chalk.bold("Next steps:\n"));
-  console.log(`  ${chalk.cyan("cd")} ${projectName}`);
-  console.log(`  ${chalk.cyan("docker compose up -d")}  ${chalk.gray("# Start PostgreSQL & Redis")}`);
-  console.log(`  ${chalk.cyan("cp .env.local.example .env.local")}  ${chalk.gray("# Configure environment")}`);
-  console.log(`  ${chalk.cyan(`${pm === "npm" ? "npm run" : pm + " run"} spfn:dev`)}  ${chalk.gray("# Start dev server")}
+  console.log("\n" + chalk4.green.bold("\u2713 Project created successfully!\n"));
+  console.log(chalk4.bold("Next steps:\n"));
+  console.log(`  ${chalk4.cyan("cd")} ${projectName}`);
+  console.log(`  ${chalk4.cyan("docker compose up -d")}  ${chalk4.gray("# Start PostgreSQL & Redis")}`);
+  console.log(`  ${chalk4.cyan("cp .env.local.example .env.local")}  ${chalk4.gray("# Configure environment")}`);
+  console.log(`  ${chalk4.cyan(`${pm === "npm" ? "npm run" : pm + " run"} spfn:dev`)}  ${chalk4.gray("# Start dev server")}
 `);
-  console.log(chalk.bold("Your app will be available at:\n"));
-  console.log(`  ${chalk.cyan("http://localhost:3790")}  ${chalk.gray("(Next.js)")}`);
-  console.log(`  ${chalk.cyan("http://localhost:8790")}  ${chalk.gray("(SPFN API)")}
+  console.log(chalk4.bold("Your app will be available at:\n"));
+  console.log(`  ${chalk4.cyan("http://localhost:3790")}  ${chalk4.gray("(Next.js)")}`);
+  console.log(`  ${chalk4.cyan("http://localhost:8790")}  ${chalk4.gray("(SPFN API)")}
 `);
-  console.log(chalk.bold("\u{1F680} Ready for production?\n"));
-  console.log("  " + chalk.cyan("Build for production:"));
-  console.log(`    ${chalk.cyan(pm === "npm" ? "npm run" : pm + " run")} spfn:build`);
-  console.log(`    ${chalk.cyan(pm === "npm" ? "npm run" : pm + " run")} spfn:start
+  console.log(chalk4.bold("\u{1F680} Ready for production?\n"));
+  console.log("  " + chalk4.cyan("Build for production:"));
+  console.log(`    ${chalk4.cyan(pm === "npm" ? "npm run" : pm + " run")} spfn:build`);
+  console.log(`    ${chalk4.cyan(pm === "npm" ? "npm run" : pm + " run")} spfn:start
 `);
-  console.log("  " + chalk.cyan("Or deploy with Docker:"));
-  console.log(`    ${chalk.cyan("docker compose -f docker-compose.production.yml up --build -d")}
+  console.log("  " + chalk4.cyan("Or deploy with Docker:"));
+  console.log(`    ${chalk4.cyan("docker compose -f docker-compose.production.yml up --build -d")}
 `);
-  console.log(chalk.dim("  \u{1F4D6} See .guide/deployment.md for complete deployment guide"));
-  console.log(chalk.dim("  \u{1F310} Documentation: https://github.com/spfn/spfn\n"));
+  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 Command("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) => {
+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) => {
   await createProject(projectName, options);
 });
 
+// src/index.ts
+init_init();
+
 // src/commands/dev.ts
-import { Command as Command2 } from "commander";
-import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join as join2 } from "path";
-import { execa as execa2 } from "execa";
+init_logger();
+init_package_manager();
+import { Command as Command4 } from "commander";
+import { existsSync as existsSync11, readFileSync as readFileSync3, writeFileSync as writeFileSync6, mkdirSync } from "fs";
+import { join as join11 } from "path";
+import { execa as execa4 } from "execa";
 import chokidar from "chokidar";
-var devCommand = new Command2("dev").description("Start SPFN development server (detects and runs Next.js + Hono)").option("-p, --port <port>", "Server port", "8790").option("-h, --host <host>", "Server host", "localhost").option("--routes <path>", "Routes directory path").option("--server-only", "Run only Hono server (skip Next.js)").option("--no-watch", "Disable hot reload (watch mode)").action(async (options) => {
+var devCommand = new Command4("dev").description("Start SPFN development server (detects and runs Next.js + Hono)").option("-p, --port <port>", "Server port").option("-H, --host <host>", "Server host").option("--routes <path>", "Routes directory path").option("--server-only", "Run only Hono server (skip Next.js)").option("--watch", "Enable hot reload (watch mode)").action(async (options) => {
   process.setMaxListeners(20);
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "development";
   }
   const cwd = process.cwd();
-  const serverDir = join2(cwd, "src", "server");
-  if (!existsSync2(serverDir)) {
+  const serverDir = join11(cwd, "src", "server");
+  if (!existsSync11(serverDir)) {
     logger.error("src/server directory not found.");
     logger.info('Run "spfn init" first to initialize SPFN in your project.');
     process.exit(1);
   }
-  const packageJsonPath = join2(cwd, "package.json");
+  const packageJsonPath = join11(cwd, "package.json");
   let hasNext = false;
-  if (existsSync2(packageJsonPath)) {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  if (existsSync11(packageJsonPath)) {
+    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
     hasNext = !!(packageJson.dependencies?.next || packageJson.devDependencies?.next);
   }
-  const tempDir = join2(cwd, "node_modules", ".spfn");
-  const serverEntry = join2(tempDir, "server.mjs");
-  const watcherEntry = join2(tempDir, "watcher.mjs");
+  const tempDir = join11(cwd, ".spfn");
+  const serverEntry = join11(tempDir, "server.mjs");
+  const watcherEntry = join11(tempDir, "watcher.mjs");
   mkdirSync(tempDir, { recursive: true });
-  writeFileSync(serverEntry, `
+  const configParts = [];
+  if (options.port) configParts.push(`port: ${options.port}`);
+  if (options.host) configParts.push(`host: '${options.host}'`);
+  if (options.routes) configParts.push(`routesPath: '${options.routes}'`);
+  configParts.push("debug: true");
+  writeFileSync6(serverEntry, `
 // Load environment variables FIRST (before any imports that depend on them)
 // Use centralized environment loader for standard dotenv priority
-const { loadEnvironment } = await import('@spfn/core/env');
-loadEnvironment({ debug: true });
+await import('@spfn/core/config');
 
 // Import and start server
 const { startServer } = await import('@spfn/core/server');
 
 await startServer({
-    port: ${options.port},
-    host: '${options.host}',
-    ${options.routes ? `routesPath: '${options.routes}',` : ""}debug: true
+    ${configParts.join(",\n    ")}
 });
 `);
-  writeFileSync(watcherEntry, `
+  writeFileSync6(watcherEntry, `
 // Load environment variables
-const { loadEnvironment } = await import('@spfn/core/env');
-loadEnvironment({ debug: false });
-
-// Initialize database for generators that need it
-const { initDatabase, closeDatabase } = await import('@spfn/core/db');
-await initDatabase({
-    pool: { max: 3 }  // Watcher needs fewer connections than server
-});
+// const { loadEnvFiles } = await import('@spfn/core/server');
+// loadEnvFiles();
+// await import('@spfn/core/config');
+//
+// // Initialize database for generators that need it
+// const { initDatabase, closeDatabase } = await import('@spfn/core/db');
+// await initDatabase({
+//     pool: { max: 3 }  // Watcher needs fewer connections than server
+// });
 
 import { CodegenOrchestrator, loadCodegenConfig, createGeneratorsFromConfig } from '@spfn/core/codegen';
 
@@ -215,7 +1272,6 @@ const orchestrator = new CodegenOrchestrator({
 const cleanup = async () =>
 {
     await orchestrator.close();
-    await closeDatabase();
 };
 
 process.on('SIGTERM', async () =>
@@ -229,15 +1285,23 @@ process.on('SIGINT', async () =>
     process.exit(0);
 });
 
-await orchestrator.watch();
-
-// Keep process alive
-await new Promise(() => {});
+// Start watching - this will run indefinitely until the watcher is closed
+try
+{
+    await orchestrator.watch();
+}
+catch (error)
+{
+    console.error('[SPFN] Codegen watcher error:', error);
+    process.exit(1);
+}
 `);
   const pm = detectPackageManager(cwd);
   if (options.serverOnly || !hasNext) {
-    const watchMode2 = options.watch !== false;
-    logger.info(`Starting SPFN Server on http://${options.host}:${options.port}${watchMode2 ? " (watch mode)" : ""}
+    const watchMode2 = options.watch === true;
+    const host = options.host ?? process.env.HOST ?? "localhost";
+    const port = options.port ?? process.env.PORT ?? "4000";
+    logger.info(`Starting SPFN Server on http://${host}:${port}${watchMode2 ? " (watch mode)" : ""}
 `);
     let serverProcess2 = null;
     let watcherProcess2 = null;
@@ -245,7 +1309,7 @@ await new Promise(() => {});
     const startWatcher2 = () => {
       const watcherCmd = pm === "npm" ? "npx" : pm;
       const watcherArgs = pm === "npm" ? ["tsx", watcherEntry] : ["exec", "tsx", watcherEntry];
-      watcherProcess2 = execa2(watcherCmd, watcherArgs, {
+      watcherProcess2 = execa4(watcherCmd, watcherArgs, {
         cwd,
         stdio: "inherit",
         reject: false
@@ -260,7 +1324,7 @@ await new Promise(() => {});
     const startServer2 = () => {
       const serverCmd = pm === "npm" ? "npx" : pm;
       const serverArgs = pm === "npm" ? ["tsx", serverEntry] : ["exec", "tsx", serverEntry];
-      serverProcess2 = execa2(serverCmd, serverArgs, {
+      serverProcess2 = execa4(serverCmd, serverArgs, {
         cwd,
         stdio: "inherit",
         reject: false
@@ -275,7 +1339,7 @@ await new Promise(() => {});
           serverProcess2.kill("SIGTERM");
           await serverProcess2.catch(() => {
           });
-          await new Promise((resolve) => setTimeout(resolve, 500));
+          await new Promise((resolve2) => setTimeout(resolve2, 500));
         } catch (error) {
         }
       }
@@ -293,16 +1357,16 @@ await new Promise(() => {});
           pollInterval: 50
         }
       });
-      watcher.on("change", (path2) => {
-        logger.info(`[SPFN] Changed: ${path2.replace(cwd + "/", "")}`);
+      watcher.on("change", (path5) => {
+        logger.info(`[SPFN] Changed: ${path5.replace(cwd + "/", "")}`);
         restartServer2();
       });
-      watcher.on("add", (path2) => {
-        logger.info(`[SPFN] Added: ${path2.replace(cwd + "/", "")}`);
+      watcher.on("add", (path5) => {
+        logger.info(`[SPFN] Added: ${path5.replace(cwd + "/", "")}`);
         restartServer2();
       });
-      watcher.on("unlink", (path2) => {
-        logger.info(`[SPFN] Removed: ${path2.replace(cwd + "/", "")}`);
+      watcher.on("unlink", (path5) => {
+        logger.info(`[SPFN] Removed: ${path5.replace(cwd + "/", "")}`);
         restartServer2();
       });
     }
@@ -319,11 +1383,17 @@ await new Promise(() => {});
     process.on("SIGTERM", cleanup2);
     startWatcher2();
     startServer2();
-    await new Promise(() => {
+    await new Promise((resolve2) => {
+      const keepAlive = setInterval(() => {
+      }, 1e6);
+      process.once("beforeExit", () => {
+        clearInterval(keepAlive);
+        resolve2();
+      });
     });
     return;
   }
-  const watchMode = options.watch !== false;
+  const watchMode = options.watch === true;
   logger.info(`Starting SPFN server + Next.js (Turbopack)${watchMode ? " (watch mode)" : ""}...
 `);
   let serverProcess = null;
@@ -333,7 +1403,7 @@ await new Promise(() => {});
   const startWatcher = () => {
     const watcherCmd = pm === "npm" ? "npx" : pm;
     const watcherArgs = pm === "npm" ? ["tsx", watcherEntry] : ["exec", "tsx", watcherEntry];
-    watcherProcess = execa2(watcherCmd, watcherArgs, {
+    watcherProcess = execa4(watcherCmd, watcherArgs, {
       cwd,
       stdio: "inherit",
       reject: false
@@ -348,7 +1418,7 @@ await new Promise(() => {});
   const startNext = () => {
     const nextCmd = pm === "npm" ? "npm" : pm;
     const nextArgs = pm === "npm" ? ["run", "spfn:next"] : ["run", "spfn:next"];
-    nextProcess = execa2(nextCmd, nextArgs, {
+    nextProcess = execa4(nextCmd, nextArgs, {
       cwd,
       stdio: "inherit",
       reject: false
@@ -363,7 +1433,7 @@ await new Promise(() => {});
   const startServer = () => {
     const serverCmd = pm === "npm" ? "npx" : pm;
     const serverArgs = pm === "npm" ? ["tsx", serverEntry] : ["exec", "tsx", serverEntry];
-    serverProcess = execa2(serverCmd, serverArgs, {
+    serverProcess = execa4(serverCmd, serverArgs, {
       cwd,
       stdio: "inherit",
       reject: false
@@ -378,7 +1448,7 @@ await new Promise(() => {});
         serverProcess.kill("SIGTERM");
         await serverProcess.catch(() => {
         });
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
       } catch (error) {
       }
     }
@@ -396,16 +1466,16 @@ await new Promise(() => {});
         pollInterval: 50
       }
     });
-    watcher.on("change", (path2) => {
-      logger.info(`[SPFN] Changed: ${path2.replace(cwd + "/", "")}`);
+    watcher.on("change", (path5) => {
+      logger.info(`[SPFN] Changed: ${path5.replace(cwd + "/", "")}`);
       restartServer();
     });
-    watcher.on("add", (path2) => {
-      logger.info(`[SPFN] Added: ${path2.replace(cwd + "/", "")}`);
+    watcher.on("add", (path5) => {
+      logger.info(`[SPFN] Added: ${path5.replace(cwd + "/", "")}`);
       restartServer();
     });
-    watcher.on("unlink", (path2) => {
-      logger.info(`[SPFN] Removed: ${path2.replace(cwd + "/", "")}`);
+    watcher.on("unlink", (path5) => {
+      logger.info(`[SPFN] Removed: ${path5.replace(cwd + "/", "")}`);
       restartServer();
     });
   }
@@ -425,39 +1495,50 @@ await new Promise(() => {});
   process.on("SIGTERM", cleanup);
   startWatcher();
   startServer();
-  await new Promise((resolve) => setTimeout(resolve, 2e3));
+  await new Promise((resolve2) => setTimeout(resolve2, 2e3));
   startNext();
-  await new Promise(() => {
+  await new Promise((resolve2) => {
+    const keepAlive = setInterval(() => {
+    }, 1e6);
+    process.once("beforeExit", () => {
+      clearInterval(keepAlive);
+      resolve2();
+    });
   });
 });
 
 // src/commands/build.ts
-import { Command as Command3 } from "commander";
-import { existsSync as existsSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3 } from "path";
-import { execa as execa3 } from "execa";
-import ora2 from "ora";
-import chalk2 from "chalk";
+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 { join as join12 } from "path";
+import { execa as execa5 } from "execa";
+import ora5 from "ora";
+import chalk5 from "chalk";
 import { build } from "tsup";
 async function buildProject(options) {
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "production";
   }
+  if (!process.env.LOG_LEVEL) {
+    process.env.LOG_LEVEL = "warn";
+  }
   const cwd = process.cwd();
   const pm = detectPackageManager(cwd);
-  const packageJsonPath = join3(cwd, "package.json");
+  const packageJsonPath = join12(cwd, "package.json");
   let hasNext = false;
-  if (existsSync3(packageJsonPath)) {
+  if (existsSync12(packageJsonPath)) {
     const packageJson = JSON.parse(await import("fs").then(
-      (fs2) => fs2.promises.readFile(packageJsonPath, "utf-8")
+      (fs5) => fs5.promises.readFile(packageJsonPath, "utf-8")
     ));
     hasNext = !!(packageJson.dependencies?.next || packageJson.devDependencies?.next);
   }
-  const serverDir = join3(cwd, "src", "server");
-  const hasServer = existsSync3(serverDir);
-  console.log(chalk2.blue.bold("\n\u{1F3D7}\uFE0F  Building SPFN project for production...\n"));
+  const serverDir = join12(cwd, "src", "server");
+  const hasServer = existsSync12(serverDir);
+  console.log(chalk5.blue.bold("\n\u{1F3D7}\uFE0F  Building SPFN project for production...\n"));
   if (hasServer) {
-    const spinner = ora2("Generating API client...").start();
+    const spinner = ora5("Generating API client...").start();
     try {
       const { CodegenOrchestrator, loadCodegenConfig, createGeneratorsFromConfig } = await import("@spfn/core/codegen");
       const config = loadCodegenConfig(cwd);
@@ -465,7 +1546,7 @@ async function buildProject(options) {
       const orchestrator = new CodegenOrchestrator({
         generators,
         cwd,
-        debug: false
+        debug: true
       });
       await orchestrator.generateAll();
       spinner.succeed("API client generated");
@@ -475,9 +1556,9 @@ async function buildProject(options) {
     }
   }
   if (hasNext && !options.serverOnly) {
-    const spinner = ora2("Building Next.js...").start();
+    const spinner = ora5("Building Next.js...").start();
     try {
-      await execa3(pm, ["run", "build"], {
+      await execa5(pm, ["run", "build"], {
         cwd,
         stdio: "inherit"
       });
@@ -489,12 +1570,12 @@ async function buildProject(options) {
     }
   }
   if (hasServer && !options.nextOnly) {
-    const spinner = ora2("Building SPFN server...").start();
+    const spinner = ora5("Building SPFN server...").start();
     try {
-      const outputDir = join3(cwd, ".spfn", "server");
+      const outputDir = join12(cwd, ".spfn", "server");
       mkdirSync2(outputDir, { recursive: true });
-      const serverDir2 = join3(cwd, "src", "server");
-      if (!existsSync3(serverDir2)) {
+      const serverDir2 = join12(cwd, "src", "server");
+      if (!existsSync12(serverDir2)) {
         spinner.fail("SPFN server build failed");
         logger.error("src/server/ directory not found");
         logger.error('Please run "spfn init" to initialize the project.');
@@ -518,15 +1599,14 @@ async function buildProject(options) {
           "@sinclair/typebox",
           "@spfn/core"
         ],
-        silent: false,
+        silent: true,
         onSuccess: async () => {
         }
       });
-      const prodServerPath = join3(cwd, ".spfn", "prod-server.mjs");
+      const prodServerPath = join12(cwd, ".spfn", "prod-server.mjs");
       const prodServerContent = `// Load environment variables FIRST (before any imports that depend on them)
 // Use centralized environment loader for standard dotenv priority
-const { loadEnvironment } = await import('@spfn/core/env');
-loadEnvironment({ debug: false });
+const { env } = await import('@spfn/core/config');
 
 // Now import server (logger singleton will be created with correct NODE_ENV)
 const { startServer } = await import('@spfn/core/server');
@@ -537,8 +1617,8 @@ import { dirname } from 'path';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 // Environment variables: from .env files OR injected by container/kubernetes
-const port = process.env.SPFN_PORT || process.env.PORT || '8790';
-const host = process.env.SPFN_HOST || process.env.HOST || '0.0.0.0';
+const port = env.SPFN_PORT || '8790';
+const host = env.SPFN_HOST || '0.0.0.0';
 
 await startServer({
     port: Number(port),
@@ -547,11 +1627,41 @@ await startServer({
     debug: false
 });
 `;
-      writeFileSync2(prodServerPath, prodServerContent);
+      writeFileSync7(prodServerPath, prodServerContent);
       spinner.succeed(`SPFN server build completed \u2192 .spfn/server`);
+      const routesDir = join12(cwd, ".spfn", "server", "routes");
+      if (existsSync12(routesDir)) {
+        console.log();
+        console.log(chalk5.bold("Route (api)"));
+        try {
+          const routes = readdirSync(routesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
+          if (routes.length > 0) {
+            routes.forEach((route, index) => {
+              const isLast = index === routes.length - 1;
+              const prefix = isLast ? "\u2514" : "\u251C";
+              const routePath = `/api/${route}`;
+              if (route === "health") {
+                console.log(`${prefix} ${chalk5.green("GET")}  ${routePath}`);
+              } else {
+                console.log(`${prefix} ${chalk5.cyan("*")}    ${routePath}`);
+              }
+            });
+            console.log();
+            console.log(chalk5.cyan("*") + "  (Hono)  multiple methods supported");
+          }
+        } catch (error) {
+        }
+      }
     } catch (error) {
       spinner.fail("SPFN server build failed");
-      logger.error(String(error));
+      if (error instanceof Error) {
+        console.error("\n" + chalk5.red(error.message));
+        if (error.stack) {
+          console.error(chalk5.dim("\n" + error.stack));
+        }
+      } else {
+        logger.error(String(error));
+      }
       process.exit(1);
     }
   }
@@ -559,41 +1669,42 @@ await startServer({
     logger.error("No Next.js or SPFN server found in this project.");
     process.exit(1);
   }
-  console.log("\n" + chalk2.green.bold("\u2713 Build completed successfully!\n"));
-  console.log(chalk2.bold("Next steps:\n"));
-  console.log("  " + chalk2.cyan("Start production server:"));
-  console.log(`    ${chalk2.cyan(pm === "npm" ? "npm run" : pm + " run")} spfn:start  ${chalk2.gray("# Start SPFN + Next.js")}
+  console.log("\n" + chalk5.green.bold("\u2713 Build completed successfully!\n"));
+  console.log(chalk5.bold("Next steps:\n"));
+  console.log("  " + chalk5.cyan("Start production server:"));
+  console.log(`    ${chalk5.cyan(pm === "npm" ? "npm run" : pm + " run")} spfn:start  ${chalk5.gray("# Start SPFN + Next.js")}
 `);
-  console.log("  " + chalk2.cyan("Or deploy with Docker:"));
-  console.log(`    ${chalk2.cyan("docker compose -f docker-compose.production.yml up --build -d")}
+  console.log("  " + chalk5.cyan("Or deploy with Docker:"));
+  console.log(`    ${chalk5.cyan("docker compose -f docker-compose.production.yml up --build -d")}
 `);
-  console.log(chalk2.dim("  \u{1F4D6} See .guide/deployment.md for complete deployment guide\n"));
 }
-var buildCommand = new Command3("build").description("Build SPFN project for production (Next.js + Server)").option("--server-only", "Build only SPFN server (skip Next.js)").option("--next-only", "Build only Next.js (skip SPFN server)").option("--turbo", "Use Turbopack for Next.js build").action(async (options) => {
+var buildCommand = new Command5("build").description("Build SPFN project for production (Next.js + Server)").option("--server-only", "Build only SPFN server (skip Next.js)").option("--next-only", "Build only Next.js (skip SPFN server)").option("--turbo", "Use Turbopack for Next.js build").action(async (options) => {
   await buildProject(options);
 });
 
 // src/commands/start.ts
-import { Command as Command4 } from "commander";
-import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
-import { join as join4 } from "path";
-import { execa as execa4 } from "execa";
-import chalk3 from "chalk";
-var startCommand = new Command4("start").description("Start SPFN production server (Next.js + Hono)").option("--server-only", "Run only SPFN server (skip Next.js)").option("--next-only", "Run only Next.js (skip SPFN server)").option("-p, --port <port>", "Server port", "8790").option("-h, --host <host>", "Server host", "0.0.0.0").action(async (options) => {
+init_logger();
+init_package_manager();
+import { Command as Command6 } from "commander";
+import { existsSync as existsSync13, readFileSync as readFileSync4 } from "fs";
+import { join as join13 } from "path";
+import { execa as execa6 } from "execa";
+import chalk6 from "chalk";
+var startCommand = new Command6("start").description("Start SPFN production server (Next.js + Hono)").option("--server-only", "Run only SPFN server (skip Next.js)").option("--next-only", "Run only Next.js (skip SPFN server)").option("-p, --port <port>", "Server port", "8790").option("-h, --host <host>", "Server host", "0.0.0.0").action(async (options) => {
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "production";
   }
   const cwd = process.cwd();
-  const packageJsonPath = join4(cwd, "package.json");
+  const packageJsonPath = join13(cwd, "package.json");
   let hasNext = false;
-  if (existsSync4(packageJsonPath)) {
-    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+  if (existsSync13(packageJsonPath)) {
+    const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
     hasNext = !!(packageJson.dependencies?.next || packageJson.devDependencies?.next);
   }
-  const builtServerDir = join4(cwd, ".spfn", "server");
-  const hasBuiltServer = existsSync4(builtServerDir);
-  const nextBuildDir = join4(cwd, ".next");
-  const hasNextBuild = existsSync4(nextBuildDir);
+  const builtServerDir = join13(cwd, ".spfn", "server");
+  const hasBuiltServer = existsSync13(builtServerDir);
+  const nextBuildDir = join13(cwd, ".next");
+  const hasNextBuild = existsSync13(nextBuildDir);
   if (!options.nextOnly && !hasBuiltServer) {
     logger.error('.spfn/server directory not found. Please run "spfn build" first.');
     process.exit(1);
@@ -603,8 +1714,8 @@ var startCommand = new Command4("start").description("Start SPFN production serv
     process.exit(1);
   }
   const pm = detectPackageManager(cwd);
-  const serverEntry = join4(cwd, ".spfn", "prod-server.mjs");
-  if (!existsSync4(serverEntry)) {
+  const serverEntry = join13(cwd, ".spfn", "prod-server.mjs");
+  if (!existsSync13(serverEntry)) {
     logger.error('.spfn/prod-server.mjs not found. Please run "spfn build" first.');
     process.exit(1);
   }
@@ -614,7 +1725,7 @@ var startCommand = new Command4("start").description("Start SPFN production serv
     logger.info(`Starting SPFN Server (production) on http://${options.host}:${options.port}
 `);
     try {
-      await execa4("node", [serverEntry], {
+      await execa6("node", [serverEntry], {
         stdio: "inherit",
         cwd,
         env: { ...process.env }
@@ -628,7 +1739,7 @@ var startCommand = new Command4("start").description("Start SPFN production serv
   if (options.nextOnly) {
     logger.info("Starting Next.js (production) on http://0.0.0.0:3790\n");
     try {
-      await execa4("npx", ["next", "start", "-H", "0.0.0.0", "-p", "3790"], {
+      await execa6("npx", ["next", "start", "-H", "0.0.0.0", "-p", "3790"], {
         stdio: "inherit",
         cwd
       });
@@ -640,12 +1751,12 @@ var startCommand = new Command4("start").description("Start SPFN production serv
   }
   const nextCmd = "next start -H 0.0.0.0 -p 3790";
   const serverCmd = `node ${serverEntry}`;
-  console.log(chalk3.blue.bold("\n\u{1F680} Starting SPFN production server...\n"));
+  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}
 `);
   try {
-    await execa4(
+    await execa6(
       pm === "npm" ? "npx" : pm,
       pm === "npm" ? ["concurrently", "--raw", "--kill-others", `"${nextCmd}"`, `"${serverCmd}"`] : ["exec", "concurrently", "--raw", "--kill-others", `"${nextCmd}"`, `"${serverCmd}"`],
       {
@@ -666,15 +1777,16 @@ var startCommand = new Command4("start").description("Start SPFN production serv
 });
 
 // src/commands/codegen.ts
-import { Command as Command5 } from "commander";
-import { existsSync as existsSync5, writeFileSync as writeFileSync3 } from "fs";
-import { join as join5 } from "path";
-import chalk4 from "chalk";
+init_logger();
+import { Command as Command7 } from "commander";
+import { existsSync as existsSync14, writeFileSync as writeFileSync8 } from "fs";
+import { join as join14 } from "path";
+import chalk7 from "chalk";
 async function initCodegen(options) {
   const cwd = process.cwd();
-  const rcPath = join5(cwd, ".spfnrc.json");
-  if (existsSync5(rcPath)) {
-    logger.warn(".spfnrc.json already exists");
+  const rcPath = join14(cwd, ".spfnrc.ts");
+  if (existsSync14(rcPath)) {
+    logger.warn(".spfnrc.ts already exists");
     logger.info("Edit manually to add custom generators");
     process.exit(0);
   }
@@ -688,15 +1800,15 @@ async function initCodegen(options) {
       ]
     }
   };
-  writeFileSync3(rcPath, JSON.stringify(config, null, 2) + "\n");
-  console.log("\n" + chalk4.green.bold("\u2713 Created .spfnrc.json\n"));
+  writeFileSync8(rcPath, JSON.stringify(config, null, 2) + "\n");
+  console.log("\n" + chalk7.green.bold("\u2713 Created .spfnrc.ts\n"));
   console.log("Configuration:");
-  console.log(chalk4.gray(JSON.stringify(config, null, 2)));
+  console.log(chalk7.gray(JSON.stringify(config, null, 2)));
   if (options.withExample) {
-    console.log("\n" + chalk4.yellow("\u{1F4DD} To add custom generators:"));
+    console.log("\n" + chalk7.yellow("\u{1F4DD} To add custom generators:"));
     console.log("  1. Create your generator file (e.g., src/generators/my-generator.ts)");
-    console.log("  2. Add to .spfnrc.json:");
-    console.log(chalk4.gray(`
+    console.log("  2. Add to .spfnrc.ts:");
+    console.log(chalk7.gray(`
 {
   "codegen": {
     "generators": [
@@ -706,11 +1818,11 @@ async function initCodegen(options) {
   }
 }
         `));
-    console.log("  3. Run: " + chalk4.cyan("spfn dev") + " (generators run automatically)");
+    console.log("  3. Run: " + chalk7.cyan("spfn dev") + " (generators run automatically)");
   } else {
-    console.log("\n" + chalk4.yellow("\u{1F4DD} Next steps:"));
-    console.log("  \u2022 Add custom generators to .spfnrc.json");
-    console.log("  \u2022 Run: " + chalk4.cyan("spfn dev") + " to start development with code generation");
+    console.log("\n" + chalk7.yellow("\u{1F4DD} Next steps:"));
+    console.log("  \u2022 Add custom generators to .spfnrc.ts");
+    console.log("  \u2022 Run: " + chalk7.cyan("spfn dev") + " to start development with code generation");
   }
 }
 async function listGenerators() {
@@ -723,10 +1835,10 @@ async function listGenerators() {
     logger.info('Run "spfn codegen init" to initialize configuration');
     return;
   }
-  console.log("\n" + chalk4.bold("Registered Generators:"));
+  console.log("\n" + chalk7.bold("Registered Generators:"));
   generators.forEach((gen, index) => {
-    console.log(`  ${index + 1}. ${chalk4.cyan(gen.name)}`);
-    console.log(`     Patterns: ${chalk4.gray(gen.watchPatterns.join(", "))}`);
+    console.log(`  ${index + 1}. ${chalk7.cyan(gen.name)}`);
+    console.log(`     Patterns: ${chalk7.gray(gen.watchPatterns.join(", "))}`);
   });
   console.log("");
 }
@@ -744,21 +1856,22 @@ async function runGenerators() {
   const orchestrator = new CodegenOrchestrator({
     generators,
     cwd,
-    debug: false
+    debug: true
   });
   await orchestrator.generateAll();
-  console.log("\n" + chalk4.green.bold("\u2713 Code generation completed"));
+  console.log("\n" + chalk7.green.bold("\u2713 Code generation completed"));
 }
-var codegenCommand = new Command5("codegen").description("Code generation management");
-codegenCommand.command("init").description("Initialize .spfnrc.json with codegen configuration").option("--with-example", "Show example custom generator usage").action(initCodegen);
+var codegenCommand = new Command7("codegen").description("Code generation management");
+codegenCommand.command("init").description("Initialize .spfnrc.ts with codegen configuration").option("--with-example", "Show example custom generator usage").action(initCodegen);
 codegenCommand.command("list").alias("ls").description("List registered code generators").action(listGenerators);
 codegenCommand.command("run").description("Run code generators once (no watch mode)").action(runGenerators);
 
 // src/commands/key.ts
-import { Command as Command6 } from "commander";
+init_logger();
+import { Command as Command8 } from "commander";
 import { randomBytes } from "crypto";
 import { execSync } from "child_process";
-import chalk5 from "chalk";
+import chalk8 from "chalk";
 var PRESETS = {
   "auth-encryption": {
     bytes: 32,
@@ -809,62 +1922,62 @@ function copyToClipboard(text) {
   }
 }
 function generateSecret(bytes, preset, envVarName, copy) {
-  const key = randomBytes(bytes).toString("hex");
+  const key = randomBytes(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
   const config = preset ? PRESETS[preset] : null;
-  console.log("\n" + chalk5.green.bold("\u2713 Generated secret key:"));
+  console.log("\n" + chalk8.green.bold("\u2713 Generated secret key:"));
   if (config) {
-    console.log(chalk5.dim(`  ${config.description} (${bytes * 8} bits)`));
+    console.log(chalk8.dim(`  ${config.description} (${bytes * 8} bits)`));
   } else {
-    console.log(chalk5.dim(`  ${bytes * 8}-bit secret`));
+    console.log(chalk8.dim(`  ${bytes * 8}-bit secret`));
   }
-  console.log("\n" + chalk5.cyan(key) + "\n");
+  console.log("\n" + chalk8.cyan(key) + "\n");
   const varName = envVarName || config?.envVar || "SECRET_KEY";
-  console.log(chalk5.dim("Add to your .env file:"));
-  console.log(chalk5.yellow(`${varName}=${key}
+  console.log(chalk8.dim("Add to your .env file:"));
+  console.log(chalk8.yellow(`${varName}=${key}
 `));
   if (config?.usage) {
-    console.log(chalk5.dim("Usage:"));
-    console.log(chalk5.gray(`  ${config.usage}
+    console.log(chalk8.dim("Usage:"));
+    console.log(chalk8.gray(`  ${config.usage}
 `));
   }
   if (copy) {
     if (copyToClipboard(key)) {
-      console.log(chalk5.green("\u2713 Copied to clipboard!\n"));
+      console.log(chalk8.green("\u2713 Copied to clipboard!\n"));
     } else {
       logger.warn("Could not copy to clipboard");
     }
   }
 }
 function listPresets() {
-  console.log("\n" + chalk5.bold("Available presets:"));
+  console.log("\n" + chalk8.bold("Available presets:"));
   console.log();
   Object.entries(PRESETS).forEach(([name, config]) => {
-    console.log(`  ${chalk5.cyan(name.padEnd(20))} ${chalk5.dim(config.description)}`);
-    console.log(`  ${" ".repeat(20)} ${chalk5.gray(`\u2192 ${config.envVar} (${config.bytes * 8} bits)`)}`);
+    console.log(`  ${chalk8.cyan(name.padEnd(20))} ${chalk8.dim(config.description)}`);
+    console.log(`  ${" ".repeat(20)} ${chalk8.gray(`\u2192 ${config.envVar} (${config.bytes * 8} bits)`)}`);
     console.log();
   });
-  console.log(chalk5.dim("Usage:"));
-  console.log(chalk5.gray("  spfn key <preset>"));
-  console.log(chalk5.gray("  spfn key auth-encryption --copy"));
+  console.log(chalk8.dim("Usage:"));
+  console.log(chalk8.gray("  spfn key <preset>"));
+  console.log(chalk8.gray("  spfn key auth-encryption --copy"));
   console.log();
 }
-var generateValueCommand = new Command6("generate").alias("gen").description("Generate random value (simple output, no metadata)").option("-b, --bytes <number>", "Number of random bytes", "32").option("-c, --copy", "Copy to clipboard").action((options) => {
+var generateValueCommand = new Command8("generate").alias("gen").description("Generate random value (simple output, no metadata)").option("-b, --bytes <number>", "Number of random bytes", "32").option("-c, --copy", "Copy to clipboard").action((options) => {
   const bytes = parseInt(options.bytes, 10);
   if (isNaN(bytes) || bytes < 1 || bytes > 128) {
     logger.error("Invalid bytes value. Must be between 1 and 128.");
     process.exit(1);
   }
-  const value = randomBytes(bytes).toString("hex");
+  const value = randomBytes(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
   console.log(value);
   if (options.copy) {
     if (copyToClipboard(value)) {
-      console.error(chalk5.green("\u2713 Copied to clipboard"));
+      console.error(chalk8.green("\u2713 Copied to clipboard"));
     } else {
-      console.error(chalk5.yellow("\u26A0 Could not copy to clipboard"));
+      console.error(chalk8.yellow("\u26A0 Could not copy to clipboard"));
     }
   }
 });
-var keyCommand = new Command6("key").alias("k").description("Generate secure random keys and secrets").argument("[preset]", `Preset type (use --list to see all)`).option("-l, --list", "List all available presets").option("-b, --bytes <number>", "Number of random bytes to generate", "32").option("-e, --env <name>", "Environment variable name").option("-c, --copy", "Copy to clipboard").action((preset, options) => {
+var keyCommand = new Command8("key").alias("k").description("Generate secure random keys and secrets").argument("[preset]", `Preset type (use --list to see all)`).option("-l, --list", "List all available presets").option("-b, --bytes <number>", "Number of random bytes to generate", "32").option("-e, --env <name>", "Environment variable name").option("-c, --copy", "Copy to clipboard").action((preset, options) => {
   if (options.list) {
     listPresets();
     return;
@@ -878,9 +1991,9 @@ var keyCommand = new Command6("key").alias("k").description("Generate secure ran
     logger.error(`Unknown preset: ${preset}`);
     console.log("\nAvailable presets:");
     Object.entries(PRESETS).forEach(([name, config]) => {
-      console.log(`  ${chalk5.cyan(name)}: ${config.description}`);
+      console.log(`  ${chalk8.cyan(name)}: ${config.description}`);
     });
-    console.log("\nUse " + chalk5.cyan("--list") + " to see detailed information");
+    console.log("\nUse " + chalk8.cyan("--list") + " to see detailed information");
     process.exit(1);
   }
   generateSecret(
@@ -892,41 +2005,145 @@ var keyCommand = new Command6("key").alias("k").description("Generate secure ran
 });
 keyCommand.addCommand(generateValueCommand);
 
-// src/commands/db.ts
-import { Command as Command7 } from "commander";
-import { existsSync as existsSync6, writeFileSync as writeFileSync4, unlinkSync } from "fs";
-import { promises as fs } from "fs";
-import path from "path";
-import { exec, spawn } from "child_process";
-import { promisify } from "util";
-import chalk6 from "chalk";
-import ora3 from "ora";
-import prompts2 from "prompts";
-import net from "net";
-var execAsync = promisify(exec);
-async function isPortAvailable(port) {
-  return new Promise((resolve) => {
-    const server = net.createServer();
-    server.once("error", () => {
-      server.close();
-      resolve(false);
+// src/index.ts
+init_setup();
+
+// src/commands/db/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/db/generate.ts
+import chalk10 from "chalk";
+
+// src/commands/db/utils/drizzle.ts
+import { existsSync as existsSync15, writeFileSync as writeFileSync9, unlinkSync } from "fs";
+import { spawn } from "child_process";
+import chalk9 from "chalk";
+import ora6 from "ora";
+import { env } from "@spfn/core/config";
+import { loadEnvFiles } from "@spfn/core/server";
+function validateDatabasePrerequisites() {
+  loadEnvFiles();
+  if (!env.DATABASE_URL) {
+    console.error(chalk9.red("\u274C DATABASE_URL not found in environment"));
+    console.log(chalk9.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    throw new Error("DATABASE_URL is required for database operations");
+  }
+}
+async function runDrizzleCommand(command) {
+  const hasUserConfig = existsSync15("./drizzle.config.ts");
+  const tempConfigPath = `./drizzle.config.${process.pid}.${Date.now()}.temp.ts`;
+  const configPath = hasUserConfig ? "./drizzle.config.ts" : tempConfigPath;
+  if (!hasUserConfig) {
+    loadEnvFiles();
+    if (!env.DATABASE_URL) {
+      console.error(chalk9.red("\u274C DATABASE_URL not found in environment"));
+      console.log(chalk9.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+      process.exit(1);
+    }
+    const { generateDrizzleConfigFile } = await import("@spfn/core/db");
+    const configContent = generateDrizzleConfigFile({
+      cwd: process.cwd(),
+      // Exclude package schemas to avoid .ts/.js mixing (packages use migrations instead)
+      disablePackageDiscovery: true,
+      // Expand globs and auto-detect PostgreSQL schemas for push/generate compatibility
+      expandGlobs: true,
+      autoDetectSchemas: true
     });
-    server.once("listening", () => {
-      server.close();
-      resolve(true);
+    writeFileSync9(tempConfigPath, configContent);
+    console.log(chalk9.dim("Using auto-generated Drizzle config\n"));
+  }
+  const args = command.split(" ");
+  args.push(`--config=${configPath}`);
+  return new Promise((resolve2, reject) => {
+    const drizzleProcess = spawn("drizzle-kit", args, {
+      stdio: "inherit",
+      // Allow interactive input
+      shell: true
+    });
+    const cleanup = () => {
+      if (!hasUserConfig && existsSync15(tempConfigPath)) {
+        unlinkSync(tempConfigPath);
+      }
+    };
+    drizzleProcess.on("close", (code) => {
+      cleanup();
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`drizzle-kit ${command} exited with code ${code}`));
+      }
+    });
+    drizzleProcess.on("error", (error) => {
+      cleanup();
+      reject(error);
     });
-    server.listen(port, "127.0.0.1");
   });
 }
-async function findAvailablePort(startPort, maxAttempts = 10) {
-  for (let i = 0; i < maxAttempts; i++) {
-    const port = startPort + i;
-    if (await isPortAvailable(port)) {
-      return port;
+async function runWithSpinner(spinnerText, command, successMessage, failMessage) {
+  const spinner = ora6(spinnerText).start();
+  try {
+    spinner.stop();
+    await runDrizzleCommand(command);
+    console.log(chalk9.green(`\u2705 ${successMessage}`));
+  } catch (error) {
+    spinner.fail(failMessage);
+    console.error(chalk9.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/db/generate.ts
+async function dbGenerate() {
+  try {
+    await runDrizzleCommand("generate");
+    console.log(chalk10.green("\n\u2705 Migrations generated successfully"));
+  } catch (error) {
+    console.error(chalk10.red("\n\u274C Failed to generate migrations"));
+    console.error(chalk10.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/commands/db/push.ts
+import chalk12 from "chalk";
+import "@spfn/core/config";
+async function dbPush() {
+  await runWithSpinner(
+    "Pushing schema changes to database...",
+    "push",
+    "Schema pushed successfully",
+    "Failed to push schema"
+  );
+  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(chalk12.blue("\n\u{1F4E6} Applying function package migrations:"));
+    functions.forEach((func) => {
+      console.log(chalk12.dim(`  - ${func.packageName}`));
+    });
+    try {
+      await executeFunctionMigrations2(functions);
+      console.log(chalk12.green("\n\u2705 All function migrations applied\n"));
+    } catch (error) {
+      console.error(chalk12.red("\n\u274C Failed to apply function migrations"));
+      console.error(chalk12.red(error instanceof Error ? error.message : "Unknown error"));
+      process.exit(1);
     }
   }
-  throw new Error(`No available ports found between ${startPort} and ${startPort + maxAttempts - 1}`);
 }
+
+// src/commands/db/migrate.ts
+import chalk16 from "chalk";
+
+// src/commands/db/backup.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import { spawn as spawn2 } from "child_process";
+import chalk15 from "chalk";
+import ora7 from "ora";
+
+// src/commands/db/utils/database.ts
+import net from "net";
 function parseDatabaseUrl(dbUrl) {
   try {
     const url = new URL(dbUrl);
@@ -942,61 +2159,64 @@ function parseDatabaseUrl(dbUrl) {
     throw new Error(`Invalid DATABASE_URL format: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
 }
-function formatBytes(bytes) {
-  if (bytes === 0) {
-    return "0 B";
-  }
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
-}
-function formatTimestamp() {
-  const now = /* @__PURE__ */ new Date();
-  const year = now.getFullYear();
-  const month = String(now.getMonth() + 1).padStart(2, "0");
-  const day = String(now.getDate()).padStart(2, "0");
-  const hours = String(now.getHours()).padStart(2, "0");
-  const minutes = String(now.getMinutes()).padStart(2, "0");
-  const seconds = String(now.getSeconds()).padStart(2, "0");
-  return `${year}-${month}-${day}_${hours}${minutes}${seconds}`;
+async function isPortAvailable(port) {
+  return new Promise((resolve2) => {
+    const server = net.createServer();
+    server.once("error", () => {
+      server.close();
+      resolve2(false);
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve2(true);
+    });
+    server.listen(port, "127.0.0.1");
+  });
 }
-async function ensureBackupInGitignore() {
-  const gitignorePath = path.join(process.cwd(), ".gitignore");
-  try {
-    let content = "";
-    let exists = existsSync6(gitignorePath);
-    if (exists) {
-      content = await fs.readFile(gitignorePath, "utf-8");
-    }
-    const lines = content.split("\n");
-    const hasBackupsIgnore = lines.some(
-      (line) => line.trim() === "backups/" || line.trim() === "/backups/" || line.trim() === "backups"
-    );
-    if (!hasBackupsIgnore) {
-      const entry = exists && content && !content.endsWith("\n") ? "\n\n# Database backups\nbackups/\n" : "# Database backups\nbackups/\n";
-      await fs.appendFile(gitignorePath, entry);
-      console.log(chalk6.dim("\u2713 Added backups/ to .gitignore"));
+async function findAvailablePort(startPort, maxAttempts = 10) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (await isPortAvailable(port)) {
+      return port;
     }
-  } catch (error) {
-    console.log(chalk6.dim("\u26A0\uFE0F  Could not update .gitignore"));
   }
+  throw new Error(`No available ports found between ${startPort} and ${startPort + maxAttempts - 1}`);
+}
+
+// src/commands/db/utils/formatters.ts
+function formatBytes(bytes) {
+  if (bytes === 0) {
+    return "0 B";
+  }
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
 }
-async function ensureBackupDir() {
-  const backupDir = path.join(process.cwd(), "backups");
-  try {
-    await fs.mkdir(backupDir, { recursive: true });
-    const gitignorePath = path.join(backupDir, ".gitignore");
-    const gitignoreExists = existsSync6(gitignorePath);
-    if (!gitignoreExists) {
-      await fs.writeFile(gitignorePath, "# Ignore all backup files\n*.sql\n*.dump\n*.meta.json\n");
-    }
-    await ensureBackupInGitignore();
-    return backupDir;
-  } catch (error) {
-    throw new Error(`Failed to create backup directory: ${error instanceof Error ? error.message : "Unknown error"}`);
-  }
+function formatTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  return `${year}-${month}-${day}_${hours}${minutes}${seconds}`;
 }
+
+// src/commands/db/utils/backup-files.ts
+import { promises as fs2 } from "fs";
+import { existsSync as existsSync17 } from "fs";
+import path2 from "path";
+import chalk14 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 chalk13 from "chalk";
+var execAsync = promisify(exec);
 async function collectGitInfo() {
   try {
     const { stdout: isRepo } = await execAsync('git rev-parse --is-inside-work-tree 2>/dev/null || echo "false"');
@@ -1058,7 +2278,7 @@ async function collectMigrationInfo(dbUrl) {
       await pool.end();
     }
   } catch (error) {
-    console.log(chalk6.dim("\u26A0\uFE0F  Could not fetch migration info"));
+    console.log(chalk13.dim("\u26A0\uFE0F  Could not fetch migration info"));
     return void 0;
   }
 }
@@ -1066,9 +2286,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(chalk6.dim(`\u2713 Metadata saved: ${path.basename(metadataPath)}`));
+    console.log(chalk13.dim(`\u2713 Metadata saved: ${path.basename(metadataPath)}`));
   } catch (error) {
-    console.log(chalk6.dim("\u26A0\uFE0F  Could not save metadata"));
+    console.log(chalk13.dim("\u26A0\uFE0F  Could not save metadata"));
   }
 }
 async function loadBackupMetadata(backupFilename) {
@@ -1080,14 +2300,52 @@ async function loadBackupMetadata(backupFilename) {
     return void 0;
   }
 }
+
+// src/commands/db/utils/backup-files.ts
+async function ensureBackupInGitignore() {
+  const gitignorePath = path2.join(process.cwd(), ".gitignore");
+  try {
+    let content = "";
+    let exists = existsSync17(gitignorePath);
+    if (exists) {
+      content = await fs2.readFile(gitignorePath, "utf-8");
+    }
+    const lines = content.split("\n");
+    const hasBackupsIgnore = lines.some(
+      (line) => line.trim() === "backups/" || line.trim() === "/backups/" || line.trim() === "backups"
+    );
+    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(chalk14.dim("\u2713 Added backups/ to .gitignore"));
+    }
+  } catch (error) {
+    console.log(chalk14.dim("\u26A0\uFE0F  Could not update .gitignore"));
+  }
+}
+async function ensureBackupDir() {
+  const backupDir = path2.join(process.cwd(), "backups");
+  try {
+    await fs2.mkdir(backupDir, { recursive: true });
+    const gitignorePath = path2.join(backupDir, ".gitignore");
+    const gitignoreExists = existsSync17(gitignorePath);
+    if (!gitignoreExists) {
+      await fs2.writeFile(gitignorePath, "# Ignore all backup files\n*.sql\n*.dump\n*.meta.json\n");
+    }
+    await ensureBackupInGitignore();
+    return backupDir;
+  } catch (error) {
+    throw new Error(`Failed to create backup directory: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
 async function listBackupFiles() {
-  const backupDir = path.join(process.cwd(), "backups");
+  const backupDir = path2.join(process.cwd(), "backups");
   try {
-    const files = await fs.readdir(backupDir);
+    const files = await fs2.readdir(backupDir);
     const backups = await Promise.all(
       files.filter((f) => f.endsWith(".sql") || f.endsWith(".dump")).map(async (f) => {
-        const filepath = path.join(backupDir, f);
-        const stats = await fs.stat(filepath);
+        const filepath = path2.join(backupDir, f);
+        const stats = await fs2.stat(filepath);
         const metadata = await loadBackupMetadata(filepath);
         return {
           name: f,
@@ -1107,93 +2365,136 @@ async function listBackupFiles() {
     throw error;
   }
 }
-async function runDrizzleCommand(command) {
-  const { loadEnvironment } = await import("@spfn/core/env");
-  loadEnvironment({ debug: false });
-  const hasUserConfig = existsSync6("./drizzle.config.ts");
-  const tempConfigPath = `./drizzle.config.${process.pid}.${Date.now()}.temp.ts`;
-  try {
-    const configPath = hasUserConfig ? "./drizzle.config.ts" : tempConfigPath;
-    if (!hasUserConfig) {
-      if (!process.env.DATABASE_URL) {
-        console.error(chalk6.red("\u274C DATABASE_URL not found in environment"));
-        console.log(chalk6.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
-        process.exit(1);
-      }
-      const { generateDrizzleConfigFile } = await import("@spfn/core/db");
-      const configContent = generateDrizzleConfigFile({
-        cwd: process.cwd(),
-        // Exclude package schemas to avoid .ts/.js mixing (packages use migrations instead)
-        disablePackageDiscovery: true
-      });
-      writeFileSync4(tempConfigPath, configContent);
-      console.log(chalk6.dim("Using auto-generated Drizzle config\n"));
-    }
-    const fullCommand = `drizzle-kit ${command} --config=${configPath}`;
-    const { stdout, stderr } = await execAsync(fullCommand);
-    if (stdout) {
-      console.log(stdout);
-    }
-    if (stderr) {
-      console.error(stderr);
-    }
-  } finally {
-    if (!hasUserConfig && existsSync6(tempConfigPath)) {
-      unlinkSync(tempConfigPath);
-    }
+
+// src/commands/db/backup.ts
+import { env as env3 } from "@spfn/core/config";
+import { loadEnvFiles as loadEnvFiles3 } from "@spfn/core/server";
+async function dbBackup(options) {
+  console.log(chalk15.blue("\u{1F4BE} Creating database backup...\n"));
+  loadEnvFiles3();
+  const dbUrl = env3.DATABASE_URL;
+  if (!dbUrl) {
+    console.error(chalk15.red("\u274C DATABASE_URL not found in environment"));
+    console.log(chalk15.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    process.exit(1);
   }
-}
-async function runWithSpinner(spinnerText, command, successMessage, failMessage) {
-  const spinner = ora3(spinnerText).start();
-  try {
-    spinner.stop();
-    await runDrizzleCommand(command);
-    console.log(chalk6.green(`\u2705 ${successMessage}`));
-  } catch (error) {
-    spinner.fail(failMessage);
-    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+  const dbInfo = parseDatabaseUrl(dbUrl);
+  const backupDir = await ensureBackupDir();
+  const timestamp = formatTimestamp();
+  const format = options.format || "sql";
+  const ext = format === "sql" ? "sql" : "dump";
+  const filename = options.output || path3.join(backupDir, `${dbInfo.database}_${timestamp}.${ext}`);
+  if (options.dataOnly && options.schemaOnly) {
+    console.error(chalk15.red("\u274C Cannot use --data-only and --schema-only together"));
     process.exit(1);
   }
-}
-async function dbGenerate() {
-  await runWithSpinner(
-    "Generating database migrations...",
-    "generate",
-    "Migrations generated successfully",
-    "Failed to generate migrations"
-  );
-}
-async function dbPush() {
-  const { loadEnvironment } = await import("@spfn/core/env");
-  loadEnvironment({ debug: false });
-  await runWithSpinner(
-    "Pushing schema changes to database...",
-    "push",
-    "Schema pushed successfully",
-    "Failed to push schema"
-  );
-  const { discoverFunctionMigrations, executeFunctionMigrations } = await import("./function-migrations-AXX6HWXL.js");
-  const functions = discoverFunctionMigrations(process.cwd());
-  if (functions.length > 0) {
-    console.log(chalk6.blue("\n\u{1F4E6} Applying function package migrations:"));
-    functions.forEach((func) => {
-      console.log(chalk6.dim(`  - ${func.packageName}`));
+  const args = [
+    "-h",
+    dbInfo.host,
+    "-p",
+    dbInfo.port,
+    "-U",
+    dbInfo.user,
+    "-d",
+    dbInfo.database,
+    "-f",
+    filename
+  ];
+  if (format === "custom") {
+    args.push("-Fc");
+  }
+  if (options.schema) {
+    args.push("-n", options.schema);
+  }
+  if (options.dataOnly) {
+    args.push("--data-only");
+  }
+  if (options.schemaOnly) {
+    args.push("--schema-only");
+  }
+  const spinner = ora7("Creating backup...").start();
+  const pgDump = spawn2("pg_dump", args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      PGPASSWORD: dbInfo.password
+    }
+  });
+  let errorOutput = "";
+  pgDump.stderr?.on("data", (data) => {
+    errorOutput += data.toString();
+  });
+  await new Promise((resolve2, reject) => {
+    pgDump.on("close", async (code) => {
+      if (code === 0) {
+        try {
+          const stats = await fs3.stat(filename);
+          const size = formatBytes(stats.size);
+          spinner.succeed("Backup created");
+          console.log(chalk15.green(`
+\u2705 Backup created successfully`));
+          console.log(chalk15.gray(`   File: ${filename}`));
+          console.log(chalk15.gray(`   Size: ${size}`));
+          console.log(chalk15.dim("\n\u{1F4CB} Collecting metadata..."));
+          const [gitInfo, migrationInfo] = await Promise.all([
+            collectGitInfo(),
+            collectMigrationInfo(dbUrl)
+          ]);
+          const tags = [];
+          if (options.tag) {
+            tags.push(...options.tag.split(",").map((t) => t.trim()));
+          }
+          const metadata = {
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            database: dbInfo.database,
+            environment: options.env || process.env.NODE_ENV,
+            git: gitInfo,
+            migrations: migrationInfo,
+            backup: {
+              filename: path3.basename(filename),
+              format,
+              sizeBytes: stats.size,
+              schema: options.schema,
+              dataOnly: options.dataOnly,
+              schemaOnly: options.schemaOnly
+            },
+            tags: tags.length > 0 ? tags : void 0
+          };
+          await saveBackupMetadata(metadata, filename);
+          resolve2();
+        } catch (error) {
+          reject(error);
+        }
+      } else {
+        spinner.fail("Backup failed");
+        reject(new Error(errorOutput || "pg_dump failed"));
+      }
     });
-    try {
-      await executeFunctionMigrations(functions);
-      console.log(chalk6.green("\n\u2705 All function migrations applied\n"));
-    } catch (error) {
-      console.error(chalk6.red("\n\u274C Failed to apply function migrations"));
-      console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
-      process.exit(1);
+    pgDump.on("error", (error) => {
+      spinner.fail("Backup failed");
+      reject(error);
+    });
+  }).catch((error) => {
+    console.error(chalk15.red("\n\u274C Failed to create backup"));
+    if (errorOutput.includes("pg_dump: command not found") || errorOutput.includes("not found")) {
+      console.error(chalk15.yellow("\n\u{1F4A1} pg_dump is not installed. Please install PostgreSQL client tools."));
+    } else {
+      console.error(chalk15.red(error instanceof Error ? error.message : "Unknown error"));
     }
-  }
+    process.exit(1);
+  });
 }
+
+// src/commands/db/migrate.ts
+import "@spfn/core/config";
 async function dbMigrate(options = {}) {
-  const { loadEnvironment } = await import("@spfn/core/env");
-  loadEnvironment({ debug: false });
+  try {
+    validateDatabasePrerequisites();
+  } catch (error) {
+    process.exit(1);
+  }
   if (options.withBackup) {
-    console.log(chalk6.blue("\u{1F4E6} Creating pre-migration backup...\n"));
+    console.log(chalk16.blue("\u{1F4E6} Creating pre-migration backup...\n"));
     await dbBackup({
       format: "custom",
       tag: "pre-migration",
@@ -1201,19 +2502,19 @@ async function dbMigrate(options = {}) {
     });
     console.log("");
   }
-  const { discoverFunctionMigrations, executeFunctionMigrations } = await import("./function-migrations-AXX6HWXL.js");
-  const functions = discoverFunctionMigrations(process.cwd());
+  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(chalk6.blue("\u{1F4E6} Applying function package migrations:"));
+    console.log(chalk16.blue("\u{1F4E6} Applying function package migrations:"));
     functions.forEach((func) => {
-      console.log(chalk6.dim(`  - ${func.packageName}`));
+      console.log(chalk16.dim(`  - ${func.packageName}`));
     });
     try {
-      await executeFunctionMigrations(functions);
-      console.log(chalk6.green("\u2705 Function migrations applied\n"));
+      await executeFunctionMigrations2(functions);
+      console.log(chalk16.green("\u2705 Function migrations applied\n"));
     } catch (error) {
-      console.error(chalk6.red("\n\u274C Failed to apply function migrations"));
-      console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+      console.error(chalk16.red("\n\u274C Failed to apply function migrations"));
+      console.error(chalk16.red(error instanceof Error ? error.message : "Unknown error"));
       process.exit(1);
     }
   }
@@ -1224,66 +2525,73 @@ async function dbMigrate(options = {}) {
     "Failed to run project migrations"
   );
 }
+
+// src/commands/db/studio.ts
+import chalk17 from "chalk";
+import { existsSync as existsSync18, writeFileSync as writeFileSync10, unlinkSync as unlinkSync2 } from "fs";
+import { spawn as spawn3 } from "child_process";
+import { env as env4 } from "@spfn/core/config";
+import "@spfn/core/config";
 async function dbStudio(requestedPort) {
-  console.log(chalk6.blue("\u{1F3A8} Opening Drizzle Studio...\n"));
-  const { loadEnvironment } = await import("@spfn/core/env");
-  loadEnvironment({ debug: false });
+  console.log(chalk17.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(chalk6.yellow(`\u26A0\uFE0F  Port ${startPort} is in use, using port ${port} instead
+      console.log(chalk17.yellow(`\u26A0\uFE0F  Port ${startPort} is in use, using port ${port} instead
 `));
     }
   } catch (error) {
-    console.error(chalk6.red(error instanceof Error ? error.message : "Failed to find available port"));
+    console.error(chalk17.red(error instanceof Error ? error.message : "Failed to find available port"));
     process.exit(1);
   }
-  const hasUserConfig = existsSync6("./drizzle.config.ts");
+  const hasUserConfig = existsSync18("./drizzle.config.ts");
   const tempConfigPath = `./drizzle.config.${process.pid}.${Date.now()}.temp.ts`;
   try {
     const configPath = hasUserConfig ? "./drizzle.config.ts" : tempConfigPath;
     if (!hasUserConfig) {
-      if (!process.env.DATABASE_URL) {
-        console.error(chalk6.red("\u274C DATABASE_URL not found in environment"));
-        console.log(chalk6.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+      if (!env4.DATABASE_URL) {
+        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 { generateDrizzleConfigFile } = await import("@spfn/core/db");
       const configContent = generateDrizzleConfigFile({
         cwd: process.cwd(),
-        disablePackageDiscovery: true
+        disablePackageDiscovery: true,
+        expandGlobs: true
+        // Expand glob patterns for Studio compatibility
       });
-      writeFileSync4(tempConfigPath, configContent);
-      console.log(chalk6.dim("Using auto-generated Drizzle config\n"));
+      writeFileSync10(tempConfigPath, configContent);
+      console.log(chalk17.dim("Using auto-generated Drizzle config\n"));
     }
-    const studioProcess = spawn("drizzle-kit", ["studio", `--port=${port}`, `--config=${configPath}`], {
+    const studioProcess = spawn3("drizzle-kit", ["studio", `--port=${port}`, `--config=${configPath}`], {
       stdio: "inherit",
       shell: true
     });
     const cleanup = () => {
-      if (!hasUserConfig && existsSync6(tempConfigPath)) {
-        unlinkSync(tempConfigPath);
+      if (!hasUserConfig && existsSync18(tempConfigPath)) {
+        unlinkSync2(tempConfigPath);
       }
     };
     studioProcess.on("exit", (code) => {
       cleanup();
       if (code !== 0 && code !== null) {
-        console.error(chalk6.red(`
+        console.error(chalk17.red(`
 \u274C Drizzle Studio exited with code ${code}`));
         process.exit(code);
       }
     });
     studioProcess.on("error", (error) => {
       cleanup();
-      console.error(chalk6.red("\u274C Failed to start Drizzle Studio"));
-      console.error(chalk6.red(error.message));
+      console.error(chalk17.red("\u274C Failed to start Drizzle Studio"));
+      console.error(chalk17.red(error.message));
       process.exit(1);
     });
     process.on("SIGINT", () => {
-      console.log(chalk6.yellow("\n\n\u{1F44B} Shutting down Drizzle Studio..."));
+      console.log(chalk17.yellow("\n\n\u{1F44B} Shutting down Drizzle Studio..."));
       studioProcess.kill("SIGTERM");
       cleanup();
       process.exit(0);
@@ -1294,24 +2602,28 @@ async function dbStudio(requestedPort) {
       process.exit(0);
     });
   } catch (error) {
-    if (!hasUserConfig && existsSync6(tempConfigPath)) {
-      unlinkSync(tempConfigPath);
+    if (!hasUserConfig && existsSync18(tempConfigPath)) {
+      unlinkSync2(tempConfigPath);
     }
-    console.error(chalk6.red("\u274C Failed to start Drizzle Studio"));
-    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk17.red("\u274C Failed to start Drizzle Studio"));
+    console.error(chalk17.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
+
+// src/commands/db/drop.ts
+import chalk18 from "chalk";
+import prompts3 from "prompts";
 async function dbDrop() {
-  console.log(chalk6.yellow("\u26A0\uFE0F  WARNING: This will drop all tables in your database!"));
-  const { confirm } = await prompts2({
+  console.log(chalk18.yellow("\u26A0\uFE0F  WARNING: This will drop all tables in your database!"));
+  const { confirm } = await prompts3({
     type: "confirm",
     name: "confirm",
     message: "Are you sure you want to drop all tables?",
     initial: false
   });
   if (!confirm) {
-    console.log(chalk6.gray("Cancelled."));
+    console.log(chalk18.gray("Cancelled."));
     process.exit(0);
   }
   await runWithSpinner(
@@ -1321,144 +2633,47 @@ async function dbDrop() {
     "Failed to drop tables"
   );
 }
+
+// src/commands/db/check.ts
+import chalk19 from "chalk";
+import ora8 from "ora";
 async function dbCheck() {
-  const spinner = ora3("Checking database connection...").start();
+  const spinner = ora8("Checking database connection...").start();
   try {
     await runDrizzleCommand("check");
     spinner.succeed("Database connection OK");
   } catch (error) {
     spinner.fail("Database connection failed");
-    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
-    process.exit(1);
-  }
-}
-async function dbBackup(options) {
-  console.log(chalk6.blue("\u{1F4BE} Creating database backup...\n"));
-  const { loadEnvironment } = await import("@spfn/core/env");
-  loadEnvironment({ debug: false });
-  const dbUrl = process.env.DATABASE_URL;
-  if (!dbUrl) {
-    console.error(chalk6.red("\u274C DATABASE_URL not found in environment"));
-    console.log(chalk6.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
-    process.exit(1);
-  }
-  const dbInfo = parseDatabaseUrl(dbUrl);
-  const backupDir = await ensureBackupDir();
-  const timestamp = formatTimestamp();
-  const format = options.format || "sql";
-  const ext = format === "sql" ? "sql" : "dump";
-  const filename = options.output || path.join(backupDir, `${dbInfo.database}_${timestamp}.${ext}`);
-  if (options.dataOnly && options.schemaOnly) {
-    console.error(chalk6.red("\u274C Cannot use --data-only and --schema-only together"));
+    console.error(chalk19.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
-  const args = [
-    "-h",
-    dbInfo.host,
-    "-p",
-    dbInfo.port,
-    "-U",
-    dbInfo.user,
-    "-d",
-    dbInfo.database,
-    "-f",
-    filename
-  ];
-  if (format === "custom") {
-    args.push("-Fc");
-  }
-  if (options.schema) {
-    args.push("-n", options.schema);
-  }
-  if (options.dataOnly) {
-    args.push("--data-only");
-  }
-  if (options.schemaOnly) {
-    args.push("--schema-only");
-  }
-  const spinner = ora3("Creating backup...").start();
-  const pgDump = spawn("pg_dump", args, {
-    stdio: ["ignore", "pipe", "pipe"],
-    env: {
-      ...process.env,
-      PGPASSWORD: dbInfo.password
-    }
-  });
-  let errorOutput = "";
-  pgDump.stderr?.on("data", (data) => {
-    errorOutput += data.toString();
-  });
-  pgDump.on("close", async (code) => {
-    if (code === 0) {
-      const stats = await fs.stat(filename);
-      const size = formatBytes(stats.size);
-      spinner.succeed("Backup created");
-      console.log(chalk6.green(`
-\u2705 Backup created successfully`));
-      console.log(chalk6.gray(`   File: ${filename}`));
-      console.log(chalk6.gray(`   Size: ${size}`));
-      console.log(chalk6.dim("\n\u{1F4CB} Collecting metadata..."));
-      const [gitInfo, migrationInfo] = await Promise.all([
-        collectGitInfo(),
-        collectMigrationInfo(dbUrl)
-      ]);
-      const tags = [];
-      if (options.tag) {
-        tags.push(...options.tag.split(",").map((t) => t.trim()));
-      }
-      const metadata = {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        database: dbInfo.database,
-        environment: options.env || process.env.NODE_ENV,
-        git: gitInfo,
-        migrations: migrationInfo,
-        backup: {
-          filename: path.basename(filename),
-          format,
-          sizeBytes: stats.size,
-          schema: options.schema,
-          dataOnly: options.dataOnly,
-          schemaOnly: options.schemaOnly
-        },
-        tags: tags.length > 0 ? tags : void 0
-      };
-      await saveBackupMetadata(metadata, filename);
-    } else {
-      spinner.fail("Backup failed");
-      console.error(chalk6.red("\n\u274C Failed to create backup"));
-      if (errorOutput.includes("pg_dump: command not found") || errorOutput.includes("not found")) {
-        console.error(chalk6.yellow("\n\u{1F4A1} pg_dump is not installed. Please install PostgreSQL client tools."));
-      } else if (errorOutput) {
-        console.error(chalk6.red(errorOutput));
-      }
-      process.exit(1);
-    }
-  });
-  pgDump.on("error", (error) => {
-    spinner.fail("Backup failed");
-    console.error(chalk6.red("\n\u274C Failed to start pg_dump"));
-    console.error(chalk6.red(error.message));
-    process.exit(1);
-  });
 }
+
+// src/commands/db/restore.ts
+import path4 from "path";
+import { spawn as spawn4 } from "child_process";
+import chalk20 from "chalk";
+import ora9 from "ora";
+import prompts4 from "prompts";
+import { env as env5 } from "@spfn/core/config";
+import { loadEnvFiles as loadEnvFiles4 } from "@spfn/core/server";
 async function dbRestore(backupFile, options = {}) {
-  console.log(chalk6.blue("\u267B\uFE0F  Restoring database from backup...\n"));
-  const { loadEnvironment } = await import("@spfn/core/env");
-  loadEnvironment({ debug: false });
-  const dbUrl = process.env.DATABASE_URL;
+  console.log(chalk20.blue("\u267B\uFE0F  Restoring database from backup...\n"));
+  loadEnvFiles4();
+  const dbUrl = env5.DATABASE_URL;
   if (!dbUrl) {
-    console.error(chalk6.red("\u274C DATABASE_URL not found in environment"));
-    console.log(chalk6.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    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);
   }
   let file = backupFile;
   if (!file) {
     const backups = await listBackupFiles();
     if (backups.length === 0) {
-      console.log(chalk6.yellow("No backups found in ./backups directory"));
+      console.log(chalk20.yellow("No backups found in ./backups directory"));
       process.exit(0);
     }
-    const { selected } = await prompts2({
+    const { selected } = await prompts4({
       type: "select",
       name: "selected",
       message: "Select backup to restore:",
@@ -1468,74 +2683,74 @@ async function dbRestore(backupFile, options = {}) {
       }))
     });
     if (!selected) {
-      console.log(chalk6.gray("Cancelled"));
+      console.log(chalk20.gray("Cancelled"));
       process.exit(0);
     }
     file = selected;
   }
   if (!file) {
-    console.error(chalk6.red("\u274C No backup file selected"));
+    console.error(chalk20.red("\u274C No backup file selected"));
     process.exit(1);
   }
   const metadata = await loadBackupMetadata(file);
   if (metadata) {
-    console.log(chalk6.blue("\n\u{1F4CB} Backup Information:\n"));
-    console.log(chalk6.dim(`  Database: ${metadata.database}`));
-    console.log(chalk6.dim(`  Created: ${new Date(metadata.timestamp).toLocaleString()}`));
+    console.log(chalk20.blue("\n\u{1F4CB} Backup Information:\n"));
+    console.log(chalk20.dim(`  Database: ${metadata.database}`));
+    console.log(chalk20.dim(`  Created: ${new Date(metadata.timestamp).toLocaleString()}`));
     if (metadata.environment) {
-      console.log(chalk6.dim(`  Environment: ${metadata.environment}`));
+      console.log(chalk20.dim(`  Environment: ${metadata.environment}`));
     }
     if (metadata.tags && metadata.tags.length > 0) {
-      console.log(chalk6.dim(`  Tags: ${metadata.tags.join(", ")}`));
+      console.log(chalk20.dim(`  Tags: ${metadata.tags.join(", ")}`));
     }
     if (metadata.backup.dataOnly) {
-      console.log(chalk6.yellow("  \u26A0\uFE0F  Data-only backup (no schema)"));
+      console.log(chalk20.yellow("  \u26A0\uFE0F  Data-only backup (no schema)"));
     }
     if (metadata.backup.schemaOnly) {
-      console.log(chalk6.yellow("  \u26A0\uFE0F  Schema-only backup (no data)"));
+      console.log(chalk20.yellow("  \u26A0\uFE0F  Schema-only backup (no data)"));
     }
-    const warnings = [];
+    const warnings2 = [];
     const [currentGitInfo, currentMigrationInfo] = await Promise.all([
       collectGitInfo(),
       collectMigrationInfo(dbUrl)
     ]);
     if (metadata.git && currentGitInfo) {
       if (metadata.git.commit !== currentGitInfo.commit) {
-        warnings.push(`Git commit mismatch: backup from ${metadata.git.commit.substring(0, 7)}, current is ${currentGitInfo.commit.substring(0, 7)}`);
+        warnings2.push(`Git commit mismatch: backup from ${metadata.git.commit.substring(0, 7)}, current is ${currentGitInfo.commit.substring(0, 7)}`);
       }
       if (metadata.git.branch !== currentGitInfo.branch) {
-        warnings.push(`Git branch mismatch: backup from '${metadata.git.branch}', current is '${currentGitInfo.branch}'`);
+        warnings2.push(`Git branch mismatch: backup from '${metadata.git.branch}', current is '${currentGitInfo.branch}'`);
       }
     }
     if (metadata.migrations && currentMigrationInfo) {
       if (metadata.migrations.hash !== currentMigrationInfo.hash) {
-        warnings.push(`Migration version mismatch: backup has ${metadata.migrations.count} migrations, current has ${currentMigrationInfo.count}`);
-        warnings.push(`  Last migration in backup: ${metadata.migrations.hash}`);
-        warnings.push(`  Current last migration: ${currentMigrationInfo.hash}`);
+        warnings2.push(`Migration version mismatch: backup has ${metadata.migrations.count} migrations, current has ${currentMigrationInfo.count}`);
+        warnings2.push(`  Last migration in backup: ${metadata.migrations.hash}`);
+        warnings2.push(`  Current last migration: ${currentMigrationInfo.hash}`);
       }
     }
-    if (warnings.length > 0) {
-      console.log(chalk6.yellow("\n\u26A0\uFE0F  Version Warnings:\n"));
-      warnings.forEach((warning) => console.log(chalk6.yellow(`  - ${warning}`)));
+    if (warnings2.length > 0) {
+      console.log(chalk20.yellow("\n\u26A0\uFE0F  Version Warnings:\n"));
+      warnings2.forEach((warning) => console.log(chalk20.yellow(`  - ${warning}`)));
       console.log("");
     }
   }
-  const { confirm } = await prompts2({
+  const { confirm } = await prompts4({
     type: "confirm",
     name: "confirm",
-    message: chalk6.yellow("\u26A0\uFE0F  This will replace all data in the database. Continue?"),
+    message: chalk20.yellow("\u26A0\uFE0F  This will replace all data in the database. Continue?"),
     initial: false
   });
   if (!confirm) {
-    console.log(chalk6.gray("Cancelled"));
+    console.log(chalk20.gray("Cancelled"));
     process.exit(0);
   }
   if (options.dataOnly && options.schemaOnly) {
-    console.error(chalk6.red("\u274C Cannot use --data-only and --schema-only together"));
+    console.error(chalk20.red("\u274C Cannot use --data-only and --schema-only together"));
     process.exit(1);
   }
   const dbInfo = parseDatabaseUrl(dbUrl);
-  const ext = path.extname(file);
+  const ext = path4.extname(file);
   const isCustomFormat = ext === ".dump";
   const command = isCustomFormat ? "pg_restore" : "psql";
   const args = [];
@@ -1544,6 +2759,7 @@ async function dbRestore(backupFile, options = {}) {
     args.push("-p", dbInfo.port);
     args.push("-U", dbInfo.user);
     args.push("-d", dbInfo.database);
+    args.push("--verbose");
     if (options.drop) {
       args.push("--clean");
     }
@@ -1559,58 +2775,128 @@ async function dbRestore(backupFile, options = {}) {
     args.push(file);
   } else {
     if (options.dataOnly || options.schemaOnly) {
-      console.log(chalk6.yellow("\u26A0\uFE0F  Note: --data-only and --schema-only options only work with custom format backups (.dump)"));
-      console.log(chalk6.yellow("    For SQL files, the backup must have been created with the desired option.\n"));
+      console.log(chalk20.yellow("\u26A0\uFE0F  Note: --data-only and --schema-only options only work with custom format backups (.dump)"));
+      console.log(chalk20.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);
     args.push("-U", dbInfo.user);
     args.push("-d", dbInfo.database);
+    args.push("-v", "ON_ERROR_STOP=1");
     args.push("-f", file);
   }
-  const spinner = ora3("Restoring backup...").start();
-  const restoreProcess = spawn(command, args, {
+  const verbose = options.verbose ?? false;
+  const spinner = ora9("Restoring backup...").start();
+  const restoreProcess = spawn4(command, args, {
     stdio: ["ignore", "pipe", "pipe"],
     env: {
       ...process.env,
       PGPASSWORD: dbInfo.password
     }
   });
-  let errorOutput = "";
+  const warnings = [];
+  const errors = [];
+  let objectCount = 0;
+  let lastObject = "";
   restoreProcess.stderr?.on("data", (data) => {
-    errorOutput += data.toString();
+    const lines = data.toString().split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      if (/^pg_restore:.*warning:/i.test(line) || /^WARNING:/i.test(line)) {
+        warnings.push(line.trim());
+      } else if (/^pg_restore:.*error:/i.test(line) || /^ERROR:/i.test(line) || /^psql:.*ERROR/i.test(line)) {
+        errors.push(line.trim());
+      }
+      const objectMatch = line.match(/processing item (\d+)\/(\d+)/);
+      if (objectMatch) {
+        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(chalk20.dim(`  ${line.trim()}`));
+        spinner.start();
+      }
+    }
   });
-  restoreProcess.on("close", (code) => {
-    if (code === 0) {
-      spinner.succeed("Restore completed");
-      console.log(chalk6.green("\n\u2705 Database restored successfully"));
-    } else {
-      spinner.fail("Restore failed");
-      console.error(chalk6.red("\n\u274C Failed to restore database"));
-      if (errorOutput) {
-        console.error(chalk6.red(errorOutput));
+  restoreProcess.stdout?.on("data", (data) => {
+    if (verbose) {
+      spinner.stop();
+      console.log(chalk20.dim(`  ${data.toString().trim()}`));
+      spinner.start();
+    }
+  });
+  await new Promise((resolve2, reject) => {
+    restoreProcess.on("close", (code) => {
+      if (code === 0) {
+        const summary = objectCount > 0 ? ` (${objectCount} objects)` : "";
+        spinner.succeed(`Restore completed${summary}`);
+        if (warnings.length > 0) {
+          console.log(chalk20.yellow(`
+\u26A0\uFE0F  Warnings during restore (${warnings.length}):
+`));
+          for (const w of warnings) {
+            console.log(chalk20.yellow(`  - ${w}`));
+          }
+        }
+        console.log(chalk20.green("\n\u2705 Database restored successfully"));
+        resolve2();
+      } else {
+        spinner.fail("Restore failed");
+        if (errors.length > 0) {
+          console.error(chalk20.red(`
+\u274C Errors (${errors.length}):
+`));
+          for (const e of errors) {
+            console.error(chalk20.red(`  - ${e}`));
+          }
+        }
+        if (warnings.length > 0) {
+          console.log(chalk20.yellow(`
+\u26A0\uFE0F  Warnings (${warnings.length}):
+`));
+          for (const w of warnings) {
+            console.log(chalk20.yellow(`  - ${w}`));
+          }
+        }
+        const fallback = errors.length === 0 && warnings.length === 0 ? "Restore failed with no output" : "";
+        reject(new Error(fallback));
       }
-      process.exit(1);
+    });
+    restoreProcess.on("error", (error) => {
+      spinner.fail("Restore failed");
+      reject(error);
+    });
+  }).catch((error) => {
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    if (msg) {
+      console.error(chalk20.red(`
+\u274C ${msg}`));
     }
-  });
-  restoreProcess.on("error", (error) => {
-    spinner.fail("Restore failed");
-    console.error(chalk6.red(`
-\u274C Failed to start ${command}`));
-    console.error(chalk6.red(error.message));
     process.exit(1);
   });
 }
+
+// src/commands/db/list.ts
+import chalk21 from "chalk";
 async function dbBackupList() {
-  console.log(chalk6.blue("\u{1F4CB} Database backups:\n"));
+  console.log(chalk21.blue("\u{1F4CB} Database backups:\n"));
   const backups = await listBackupFiles();
   if (backups.length === 0) {
-    console.log(chalk6.yellow("No backups found in ./backups directory"));
-    console.log(chalk6.gray("\n\u{1F4A1} Create a backup with: pnpm spfn db backup\n"));
+    console.log(chalk21.yellow("No backups found in ./backups directory"));
+    console.log(chalk21.gray("\n\u{1F4A1} Create a backup with: pnpm spfn db backup\n"));
     return;
   }
-  console.log(chalk6.bold("  Date                  Size        File"));
-  console.log(chalk6.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(chalk21.bold("  Date                  Size        File"));
+  console.log(chalk21.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",
@@ -1621,17 +2907,23 @@ async function dbBackupList() {
       second: "2-digit"
     });
     const sizeStr = backup.size.padEnd(10);
-    console.log(chalk6.white(`  ${date}  ${sizeStr}  ${backup.name}`));
+    console.log(chalk21.white(`  ${date}  ${sizeStr}  ${backup.name}`));
   });
-  console.log(chalk6.gray(`
+  console.log(chalk21.gray(`
   Total: ${backups.length} backup(s)
 `));
 }
+
+// src/commands/db/clean.ts
+import { promises as fs4 } from "fs";
+import chalk22 from "chalk";
+import ora10 from "ora";
+import prompts5 from "prompts";
 async function dbBackupClean(options) {
-  console.log(chalk6.blue("\u{1F9F9} Cleaning old backups...\n"));
+  console.log(chalk22.blue("\u{1F9F9} Cleaning old backups...\n"));
   const backups = await listBackupFiles();
   if (backups.length === 0) {
-    console.log(chalk6.yellow("No backups found"));
+    console.log(chalk22.yellow("No backups found"));
     return;
   }
   let toDelete = [];
@@ -1648,277 +2940,39 @@ async function dbBackupClean(options) {
     toDelete = backups.slice(defaultKeep);
   }
   if (toDelete.length === 0) {
-    console.log(chalk6.green("\u2705 No backups to clean"));
+    console.log(chalk22.green("\u2705 No backups to clean"));
     return;
   }
-  console.log(chalk6.yellow(`The following ${toDelete.length} backup(s) will be deleted:
+  console.log(chalk22.yellow(`The following ${toDelete.length} backup(s) will be deleted:
 `));
   toDelete.forEach((backup) => {
-    console.log(chalk6.gray(`  - ${backup.name} (${backup.size})`));
+    console.log(chalk22.gray(`  - ${backup.name} (${backup.size})`));
   });
-  const { confirm } = await prompts2({
+  const { confirm } = await prompts5({
     type: "confirm",
     name: "confirm",
     message: "\nProceed with deletion?",
     initial: false
   });
   if (!confirm) {
-    console.log(chalk6.gray("Cancelled"));
+    console.log(chalk22.gray("Cancelled"));
     return;
   }
-  const spinner = ora3("Deleting backups...").start();
+  const spinner = ora10("Deleting backups...").start();
   try {
-    await Promise.all(toDelete.map((backup) => fs.unlink(backup.path)));
+    await Promise.all(toDelete.map((backup) => fs4.unlink(backup.path)));
     spinner.succeed("Backups deleted");
-    console.log(chalk6.green(`
+    console.log(chalk22.green(`
 \u2705 Deleted ${toDelete.length} backup(s)`));
   } catch (error) {
     spinner.fail("Failed to delete backups");
-    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
-    process.exit(1);
-  }
-}
-async function dbSync(target, options) {
-  console.log(chalk6.blue("\u{1F504} Database sync\n"));
-  const { loadEnvironment } = await import("@spfn/core/env");
-  loadEnvironment({ debug: false });
-  const {
-    validateSyncEnvironments,
-    testDatabaseConnection,
-    getDatabaseInfo,
-    isProductionLike,
-    getAvailableSyncTargets
-  } = await import("./db-sync-NBLWUZMH.js");
-  const sourceName = options.pull ? target : "local";
-  const targetName = options.pull ? "local" : target;
-  let source, targetEnv;
-  try {
-    const envs = await validateSyncEnvironments(sourceName, targetName);
-    source = envs.source;
-    targetEnv = envs.target;
-  } catch (error) {
-    console.error(chalk6.red(`\u274C ${error instanceof Error ? error.message : "Environment validation failed"}`));
-    const available = getAvailableSyncTargets();
-    if (available.length > 0) {
-      console.log(chalk6.yellow(`
-\u{1F4A1} Available sync targets: ${available.join(", ")}`));
-      console.log(chalk6.dim(`   Configure in .env: SPFN_DB_${target.toUpperCase()}=postgresql://...`));
-    } else {
-      console.log(chalk6.yellow("\n\u{1F4A1} No sync targets configured"));
-      console.log(chalk6.dim("   Add to .env: SPFN_DB_DEV=postgresql://..."));
-    }
-    process.exit(1);
-  }
-  if (isProductionLike(targetEnv.name) && !options.force) {
-    console.error(chalk6.red(`\u274C Cannot sync to production-like environment '${targetEnv.name}' without --force flag`));
-    console.log(chalk6.yellow("   This is a safety measure to prevent accidental data loss"));
-    console.log(chalk6.dim("   Use --force if you really want to do this"));
-    process.exit(1);
-  }
-  console.log(chalk6.dim("Testing database connections..."));
-  const spinner = ora3("Connecting to source database...").start();
-  const sourceConnected = await testDatabaseConnection(source);
-  if (!sourceConnected) {
-    spinner.fail("Failed to connect to source database");
-    console.error(chalk6.red(`\u274C Cannot connect to ${source.name} database`));
-    process.exit(1);
-  }
-  spinner.text = "Connecting to target database...";
-  const targetConnected = await testDatabaseConnection(targetEnv);
-  if (!targetConnected) {
-    spinner.fail("Failed to connect to target database");
-    console.error(chalk6.red(`\u274C Cannot connect to ${targetEnv.name} database`));
-    process.exit(1);
-  }
-  spinner.succeed("Database connections OK");
-  console.log(chalk6.dim("\nCollecting database information..."));
-  const [sourceInfo, targetInfo] = await Promise.all([
-    getDatabaseInfo(source),
-    getDatabaseInfo(targetEnv)
-  ]);
-  console.log(chalk6.blue("\n\u{1F4CB} Sync Plan:\n"));
-  console.log(chalk6.white(`  Source:  ${chalk6.cyan(source.name)} (${source.connection.database})`));
-  console.log(chalk6.dim(`           ${sourceInfo.tableCount} tables, ${sourceInfo.size}`));
-  console.log("");
-  console.log(chalk6.white(`  Target:  ${chalk6.yellow(targetEnv.name)} (${targetEnv.connection.database})`));
-  console.log(chalk6.dim(`           ${targetInfo.tableCount} tables, ${targetInfo.size}`));
-  console.log("");
-  if (options.tables) {
-    console.log(chalk6.dim(`  Tables: ${options.tables}`));
-  }
-  if (options.excludeTables) {
-    console.log(chalk6.dim(`  Exclude: ${options.excludeTables}`));
-  }
-  if (options.dataOnly) {
-    console.log(chalk6.yellow("  \u26A0\uFE0F  Data only (schema will not be changed)"));
-  }
-  if (options.schemaOnly) {
-    console.log(chalk6.yellow("  \u26A0\uFE0F  Schema only (data will not be changed)"));
-  }
-  console.log(chalk6.yellow("\n  \u26A0\uFE0F  Target database will be completely replaced!"));
-  console.log(chalk6.dim("  \u2139\uFE0F  Target will be backed up before sync\n"));
-  if (options.dryRun) {
-    console.log(chalk6.green("\u2705 Dry run complete (no changes made)"));
-    return;
-  }
-  if (!options.yes) {
-    const { confirm } = await prompts2({
-      type: "confirm",
-      name: "confirm",
-      message: chalk6.yellow(`Sync ${source.name} \u2192 ${targetEnv.name}?`),
-      initial: false
-    });
-    if (!confirm) {
-      console.log(chalk6.gray("Cancelled"));
-      process.exit(0);
-    }
-  }
-  console.log(chalk6.blue("\n\u{1F4E6} Step 1/4: Creating target backup...\n"));
-  const originalDatabaseUrl = process.env.DATABASE_URL;
-  process.env.DATABASE_URL = targetEnv.url;
-  try {
-    await dbBackup({
-      format: "custom",
-      tag: `pre-sync-from-${source.name}`,
-      env: targetEnv.name
-    });
-  } finally {
-    process.env.DATABASE_URL = originalDatabaseUrl;
-  }
-  console.log(chalk6.blue("\n\u{1F4E4} Step 2/4: Dumping source database..."));
-  const tempDir = path.join(process.cwd(), "backups");
-  const timestamp = formatTimestamp();
-  const tempDumpFile = path.join(tempDir, `_temp_sync_${timestamp}.dump`);
-  const dumpSpinner = ora3("Creating source dump...").start();
-  const dumpArgs = [
-    "-h",
-    source.connection.host,
-    "-p",
-    source.connection.port,
-    "-U",
-    source.connection.user,
-    "-d",
-    source.connection.database,
-    "-f",
-    tempDumpFile,
-    "-Fc"
-    // Custom format
-  ];
-  if (options.tables) {
-    const tables = options.tables.split(",").map((t) => t.trim());
-    tables.forEach((table) => {
-      dumpArgs.push("-t", table);
-    });
-  }
-  if (options.excludeTables) {
-    const tables = options.excludeTables.split(",").map((t) => t.trim());
-    tables.forEach((table) => {
-      dumpArgs.push("-T", table);
-    });
-  }
-  if (options.dataOnly) {
-    dumpArgs.push("--data-only");
-  }
-  if (options.schemaOnly) {
-    dumpArgs.push("--schema-only");
-  }
-  const dumpProcess = spawn("pg_dump", dumpArgs, {
-    stdio: ["ignore", "pipe", "pipe"],
-    env: {
-      ...process.env,
-      PGPASSWORD: source.connection.password
-    }
-  });
-  let dumpError = "";
-  dumpProcess.stderr?.on("data", (data) => {
-    dumpError += data.toString();
-  });
-  await new Promise((resolve, reject) => {
-    dumpProcess.on("close", (code) => {
-      if (code === 0) {
-        dumpSpinner.succeed("Source dump created");
-        resolve();
-      } else {
-        dumpSpinner.fail("Source dump failed");
-        reject(new Error(dumpError || "pg_dump failed"));
-      }
-    });
-    dumpProcess.on("error", (error) => {
-      dumpSpinner.fail("Source dump failed");
-      reject(error);
-    });
-  }).catch((error) => {
-    console.error(chalk6.red(`
-\u274C ${error instanceof Error ? error.message : "Failed to dump source"}`));
-    process.exit(1);
-  });
-  console.log(chalk6.blue("\n\u{1F4E5} Step 3/4: Restoring to target database..."));
-  const restoreSpinner = ora3("Restoring to target...").start();
-  const restoreArgs = [
-    "-h",
-    targetEnv.connection.host,
-    "-p",
-    targetEnv.connection.port,
-    "-U",
-    targetEnv.connection.user,
-    "-d",
-    targetEnv.connection.database,
-    "--clean",
-    // Drop existing objects
-    "--if-exists"
-    // Don't error if objects don't exist
-  ];
-  if (options.dataOnly) {
-    restoreArgs.push("--data-only");
-  }
-  if (options.schemaOnly) {
-    restoreArgs.push("--schema-only");
-  }
-  restoreArgs.push(tempDumpFile);
-  const restoreProcess = spawn("pg_restore", restoreArgs, {
-    stdio: ["ignore", "pipe", "pipe"],
-    env: {
-      ...process.env,
-      PGPASSWORD: targetEnv.connection.password
-    }
-  });
-  let restoreError = "";
-  restoreProcess.stderr?.on("data", (data) => {
-    restoreError += data.toString();
-  });
-  await new Promise((resolve, reject) => {
-    restoreProcess.on("close", (code) => {
-      if (code === 0) {
-        restoreSpinner.succeed("Target restored");
-        resolve();
-      } else {
-        restoreSpinner.fail("Target restore failed");
-        reject(new Error(restoreError || "pg_restore failed"));
-      }
-    });
-    restoreProcess.on("error", (error) => {
-      restoreSpinner.fail("Target restore failed");
-      reject(error);
-    });
-  }).catch((error) => {
-    console.error(chalk6.red(`
-\u274C ${error instanceof Error ? error.message : "Failed to restore target"}`));
-    console.log(chalk6.yellow("\n\u{1F4A1} You can restore the target from the backup created in Step 1"));
+    console.error(chalk22.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
-  });
-  console.log(chalk6.blue("\n\u{1F9F9} Step 4/4: Cleaning up..."));
-  try {
-    await fs.unlink(tempDumpFile);
-    console.log(chalk6.dim("\u2713 Temporary files deleted"));
-  } catch (error) {
-    console.log(chalk6.dim("\u26A0\uFE0F  Could not delete temporary dump file"));
   }
-  console.log(chalk6.green(`
-\u2705 Sync completed successfully!`));
-  console.log(chalk6.dim(`   ${source.name} \u2192 ${targetEnv.name}`));
-  console.log("");
 }
-var dbCommand = new Command7("db").description("Database management commands (wraps Drizzle Kit)");
+
+// src/commands/db/index.ts
+var dbCommand = new Command9("db").description("Database management commands (wraps Drizzle Kit)");
 dbCommand.command("generate").alias("g").description("Generate database migrations from schema changes").action(dbGenerate);
 dbCommand.command("push").description("Push schema changes directly to database (no migrations)").action(dbPush);
 dbCommand.command("migrate").alias("m").description("Run pending migrations").option("--with-backup", "Create backup before running migrations").action((options) => dbMigrate(options));
@@ -1926,36 +2980,35 @@ dbCommand.command("studio").description("Open Drizzle Studio (database GUI)").op
 dbCommand.command("drop").description("Drop all database tables (\u26A0\uFE0F  dangerous!)").action(dbDrop);
 dbCommand.command("check").description("Check database connection").action(dbCheck);
 dbCommand.command("backup").description("Create a database backup").option("-f, --format <format>", "Backup format (sql or custom)", "sql").option("-o, --output <path>", "Custom output path").option("-s, --schema <name>", "Backup specific schema only").option("--data-only", "Backup data only (no schema)").option("--schema-only", "Backup schema only (no data)").option("--tag <tags>", "Comma-separated tags for this backup").option("--env <environment>", "Environment label (e.g., production, staging)").action((options) => dbBackup(options));
-dbCommand.command("restore [file]").description("Restore database from backup").option("--drop", "Drop existing tables before restore").option("-s, --schema <name>", "Restore specific schema only").option("--data-only", "Restore data only (requires custom format .dump file)").option("--schema-only", "Restore schema only (requires custom format .dump file)").action((file, options) => dbRestore(file, options));
+dbCommand.command("restore [file]").description("Restore database from backup").option("--drop", "Drop existing tables before restore").option("-s, --schema <name>", "Restore specific schema only").option("--data-only", "Restore data only (requires custom format .dump file)").option("--schema-only", "Restore schema only (requires custom format .dump file)").option("-v, --verbose", "Show detailed restore progress").action((file, options) => dbRestore(file, options));
 dbCommand.command("backup:list").description("List all database backups").action(dbBackupList);
 dbCommand.command("backup:clean").description("Clean old database backups").option("-k, --keep <number>", "Keep N most recent backups", parseInt).option("-o, --older-than <days>", "Delete backups older than N days", parseInt).action((options) => dbBackupClean(options));
-dbCommand.command("sync <target>").description("Sync database between environments").option("--pull", "Pull from target to local (reverse direction)").option("--tables <tables>", "Sync only specific tables (comma-separated)").option("--exclude-tables <tables>", "Exclude specific tables (comma-separated)").option("--data-only", "Sync data only (schema unchanged)").option("--schema-only", "Sync schema only (data unchanged)").option("--force", "Allow syncing to production-like environments").option("--dry-run", "Show sync plan without making changes").option("-y, --yes", "Skip confirmation prompt").action((target, options) => dbSync(target, options));
 
 // src/commands/add.ts
-import { Command as Command8 } from "commander";
-import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { Command as Command10 } from "commander";
+import { existsSync as existsSync19, readFileSync as readFileSync6 } from "fs";
+import { join as join16 } from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import chalk7 from "chalk";
-import ora4 from "ora";
+import chalk23 from "chalk";
+import ora11 from "ora";
 var execAsync2 = promisify2(exec2);
 async function addPackage(packageName) {
   if (!packageName.includes("/")) {
-    console.error(chalk7.red("\u274C Please specify full package name"));
-    console.log(chalk7.yellow("\n\u{1F4A1} Examples:"));
-    console.log(chalk7.gray("  pnpm spfn add @spfn/cms"));
-    console.log(chalk7.gray("  pnpm spfn add @mycompany/spfn-analytics"));
+    console.error(chalk23.red("\u274C Please specify full package name"));
+    console.log(chalk23.yellow("\n\u{1F4A1} Examples:"));
+    console.log(chalk23.gray("  pnpm spfn add @spfn/cms"));
+    console.log(chalk23.gray("  pnpm spfn add @mycompany/spfn-analytics"));
     process.exit(1);
   }
-  console.log(chalk7.blue(`
+  console.log(chalk23.blue(`
 \u{1F4E6} Setting up ${packageName}...
 `));
   try {
-    const pkgPath = join6(process.cwd(), "node_modules", ...packageName.split("/"));
-    const pkgJsonPath = join6(pkgPath, "package.json");
-    if (!existsSync7(pkgJsonPath)) {
-      const installSpinner = ora4("Installing package...").start();
+    const pkgPath = join16(process.cwd(), "node_modules", ...packageName.split("/"));
+    const pkgJsonPath = join16(pkgPath, "package.json");
+    if (!existsSync19(pkgJsonPath)) {
+      const installSpinner = ora11("Installing package...").start();
       try {
         await execAsync2(`pnpm add ${packageName}`);
         installSpinner.succeed("Package installed");
@@ -1964,73 +3017,74 @@ async function addPackage(packageName) {
         throw error;
       }
     } else {
-      console.log(chalk7.gray("\u2713 Package already installed (using local version)\n"));
+      console.log(chalk23.gray("\u2713 Package already installed (using local version)\n"));
     }
-    if (!existsSync7(pkgJsonPath)) {
+    if (!existsSync19(pkgJsonPath)) {
       throw new Error(`Package ${packageName} not found after installation`);
     }
-    const pkgJson = JSON.parse(readFileSync3(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(readFileSync6(pkgJsonPath, "utf-8"));
     if (pkgJson.spfn?.migrations) {
-      console.log(chalk7.blue(`
+      console.log(chalk23.blue(`
 \u{1F5C4}\uFE0F  Setting up database for ${packageName}...
 `));
-      const { loadEnvironment } = await import("@spfn/core/env");
-      loadEnvironment({ debug: false });
-      if (!process.env.DATABASE_URL) {
-        console.log(chalk7.yellow("\u26A0\uFE0F  DATABASE_URL not found"));
-        console.log(chalk7.gray("Skipping database setup. Run migrations manually when ready:\n"));
-        console.log(chalk7.gray(`  pnpm spfn db push
+      const { env: env6 } = await import("@spfn/core/config");
+      if (!env6.DATABASE_URL) {
+        console.log(chalk23.yellow("\u26A0\uFE0F  DATABASE_URL not found"));
+        console.log(chalk23.gray("Skipping database setup. Run migrations manually when ready:\n"));
+        console.log(chalk23.gray(`  pnpm spfn db push
 `));
       } else {
-        const { discoverFunctionMigrations, executeFunctionMigrations } = await import("./function-migrations-AXX6HWXL.js");
-        const functions = discoverFunctionMigrations(process.cwd());
+        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 = ora4("Applying migrations...").start();
+          const spinner = ora11("Applying migrations...").start();
           try {
-            await executeFunctionMigrations([targetFunction]);
+            await executeFunctionMigrations2([targetFunction]);
             spinner.succeed("Migrations applied");
           } catch (error) {
             spinner.fail("Failed to apply migrations");
             throw error;
           }
         } else {
-          console.log(chalk7.gray("\u2139\uFE0F  No migrations found for this package"));
+          console.log(chalk23.gray("\u2139\uFE0F  No migrations found for this package"));
         }
       }
     } else {
-      console.log(chalk7.gray("\n\u2139\uFE0F  No database migrations to apply"));
+      console.log(chalk23.gray("\n\u2139\uFE0F  No database migrations to apply"));
     }
-    console.log(chalk7.green(`
+    console.log(chalk23.green(`
 \u2705 ${packageName} installed successfully!
 `));
     if (pkgJson.spfn?.setupMessage) {
-      console.log(chalk7.cyan("\u{1F4DA} Setup Guide:"));
+      console.log(chalk23.cyan("\u{1F4DA} Setup Guide:"));
       console.log(pkgJson.spfn.setupMessage);
       console.log();
     }
   } catch (error) {
-    console.error(chalk7.red(`
+    console.error(chalk23.red(`
 \u274C Failed to install ${packageName}
 `));
-    console.error(chalk7.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk23.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
-var addCommand = new Command8("add").description("Install and set up SPFN ecosystem packages").argument("<package>", "Package name (e.g., @spfn/cms, @mycompany/spfn-analytics)").action(addPackage);
+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
-import { Command as Command9 } from "commander";
-import ora5 from "ora";
-import { join as join15 } from "path";
-import { existsSync as existsSync10 } from "fs";
-import chalk9 from "chalk";
+init_logger();
+import { Command as Command11 } from "commander";
+import ora12 from "ora";
+import { join as join25 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import chalk25 from "chalk";
 
 // src/commands/generate/prompts.ts
-import prompts3 from "prompts";
-import chalk8 from "chalk";
+init_logger();
+import prompts6 from "prompts";
+import chalk24 from "chalk";
 async function promptScope() {
-  const response = await prompts3({
+  const response = await prompts6({
     type: "text",
     name: "scope",
     message: "NPM scope (e.g., @mycompany, @username):",
@@ -2052,7 +3106,7 @@ async function promptScope() {
   return response.scope;
 }
 async function promptFunctionName() {
-  const response = await prompts3({
+  const response = await prompts6({
     type: "text",
     name: "fnName",
     message: "Function name:",
@@ -2073,7 +3127,7 @@ async function promptFunctionName() {
   return response.fnName;
 }
 async function promptDescription(fnName) {
-  const response = await prompts3({
+  const response = await prompts6({
     type: "text",
     name: "description",
     message: "Function description:",
@@ -2082,7 +3136,7 @@ async function promptDescription(fnName) {
   return response.description || "A description of what this module does";
 }
 async function promptEntities() {
-  const response = await prompts3({
+  const response = await prompts6({
     type: "list",
     name: "entities",
     message: "Entity names (comma-separated, press enter to skip):",
@@ -2094,14 +3148,14 @@ async function promptEntities() {
 async function confirmConfiguration(config) {
   const { scope, fnName, description, entities, enableCache, enableRoutes } = config;
   console.log("");
-  logger.info(chalk8.bold("\u26A1 Function Configuration:"));
-  console.log(`  ${chalk8.gray("Package:")}     ${chalk8.cyan(`${scope}/${fnName}`)}`);
-  console.log(`  ${chalk8.gray("Description:")} ${description}`);
-  console.log(`  ${chalk8.gray("Entities:")}    ${entities.length > 0 ? entities.join(", ") : chalk8.gray("none")}`);
-  console.log(`  ${chalk8.gray("Cache:")}       ${enableCache ? chalk8.green("yes") : chalk8.gray("no")}`);
-  console.log(`  ${chalk8.gray("Routes:")}      ${enableRoutes ? chalk8.green("yes") : chalk8.gray("no")}`);
+  logger.info(chalk24.bold("\u26A1 Function Configuration:"));
+  console.log(`  ${chalk24.gray("Package:")}     ${chalk24.cyan(`${scope}/${fnName}`)}`);
+  console.log(`  ${chalk24.gray("Description:")} ${description}`);
+  console.log(`  ${chalk24.gray("Entities:")}    ${entities.length > 0 ? entities.join(", ") : chalk24.gray("none")}`);
+  console.log(`  ${chalk24.gray("Cache:")}       ${enableCache ? chalk24.green("yes") : chalk24.gray("no")}`);
+  console.log(`  ${chalk24.gray("Routes:")}      ${enableRoutes ? chalk24.green("yes") : chalk24.gray("no")}`);
   console.log("");
-  const { confirmed } = await prompts3({
+  const { confirmed } = await prompts6({
     type: "confirm",
     name: "confirmed",
     message: "Create function?",
@@ -2115,12 +3169,12 @@ async function confirmConfiguration(config) {
 }
 
 // src/commands/generate/generators/structure.ts
-import { join as join14 } from "path";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync12 } from "fs";
+import { join as join24 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync17 } from "fs";
 
 // src/commands/generate/generators/config.ts
-import { join as join8 } from "path";
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync3 } from "fs";
+import { join as join18 } from "path";
+import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync3 } from "fs";
 
 // src/commands/generate/string-utils.ts
 function toPascalCase(str) {
@@ -2149,30 +3203,30 @@ function toSafeSchemaName(str) {
 }
 
 // src/commands/generate/template-loader.ts
-import { readFileSync as readFileSync4, existsSync as existsSync8 } from "fs";
-import { join as join7, dirname } from "path";
-import { fileURLToPath } from "url";
-function findTemplatesPath() {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
-  const distPath = join7(__dirname, "commands", "generate", "templates");
-  if (existsSync8(distPath)) {
+import { readFileSync as readFileSync7, existsSync as existsSync20 } from "fs";
+import { join as join17, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function findTemplatesPath2() {
+  const __filename = fileURLToPath2(import.meta.url);
+  const __dirname2 = dirname2(__filename);
+  const distPath = join17(__dirname2, "commands", "generate", "templates");
+  if (existsSync20(distPath)) {
     return distPath;
   }
-  const sameDirPath = join7(__dirname, "templates");
-  if (existsSync8(sameDirPath)) {
+  const sameDirPath = join17(__dirname2, "templates");
+  if (existsSync20(sameDirPath)) {
     return sameDirPath;
   }
-  const srcPath = join7(__dirname, "..", "..", "src", "commands", "generate", "templates");
-  if (existsSync8(srcPath)) {
+  const srcPath = join17(__dirname2, "..", "..", "src", "commands", "generate", "templates");
+  if (existsSync20(srcPath)) {
     return srcPath;
   }
   throw new Error(`Templates directory not found. Tried: ${distPath}, ${sameDirPath}, ${srcPath}`);
 }
 function loadTemplate(templateName, variables) {
-  const templatesDir = findTemplatesPath();
-  const templatePath = join7(templatesDir, `${templateName}.template`);
-  let content = readFileSync4(templatePath, "utf-8");
+  const templatesDir = findTemplatesPath2();
+  const templatePath = join17(templatesDir, `${templateName}.template`);
+  let content = readFileSync7(templatePath, "utf-8");
   for (const [key, value] of Object.entries(variables)) {
     const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
     content = content.replace(regex, value);
@@ -2274,8 +3328,8 @@ function generatePackageJson(fnDir, scope, fnName, description) {
       vitest: "^4.0.6"
     }
   };
-  writeFileSync6(
-    join8(fnDir, "package.json"),
+  writeFileSync11(
+    join18(fnDir, "package.json"),
     JSON.stringify(content, null, 4) + "\n"
   );
 }
@@ -2308,8 +3362,8 @@ function generateTsConfig(fnDir) {
     include: ["src/**/*"],
     exclude: ["node_modules", "dist", "**/*.test.ts", "**/__tests__/**"]
   };
-  writeFileSync6(
-    join8(fnDir, "tsconfig.json"),
+  writeFileSync11(
+    join18(fnDir, "tsconfig.json"),
     JSON.stringify(content, null, 4) + "\n"
   );
 }
@@ -2385,7 +3439,7 @@ export default defineConfig({
     ],
 });
 `;
-  writeFileSync6(join8(fnDir, "tsup.config.ts"), content);
+  writeFileSync11(join18(fnDir, "tsup.config.ts"), content);
 }
 function generateDrizzleConfig(fnDir, scope, fnName) {
   const schemaName = `spfn_${toSnakeCase(fnName)}`;
@@ -2405,7 +3459,7 @@ export default defineConfig({
     schemaFilter: ['${schemaName}'], // Only generate for ${fnName} schema
 });
 `;
-  writeFileSync6(join8(fnDir, "drizzle.config.ts"), content);
+  writeFileSync11(join18(fnDir, "drizzle.config.ts"), content);
 }
 function generateExampleGenerator(fnDir, scope, fnName) {
   const pascalName = toPascalCase(fnName);
@@ -2474,10 +3528,10 @@ export const moduleName = '${fnName}';
     };
 }
 `;
-  const generatorsDir = join8(fnDir, "src/server/generators");
+  const generatorsDir = join18(fnDir, "src/server/generators");
   mkdirSync3(generatorsDir, { recursive: true });
-  writeFileSync6(
-    join8(generatorsDir, "example-generator.ts"),
+  writeFileSync11(
+    join18(generatorsDir, "example-generator.ts"),
     content
   );
   const indexContent = `/**
@@ -2491,8 +3545,8 @@ export const moduleName = '${fnName}';
 
 export { create${pascalName}ExampleGenerator } from './example-generator.js';
 `;
-  writeFileSync6(
-    join8(generatorsDir, "index.ts"),
+  writeFileSync11(
+    join18(generatorsDir, "index.ts"),
     indexContent
   );
 }
@@ -2981,15 +4035,15 @@ Contributions are welcome! Please follow the development workflow above.
 
 MIT
 `;
-  writeFileSync6(join8(fnDir, "README.md"), content);
+  writeFileSync11(join18(fnDir, "README.md"), content);
 }
 
 // src/commands/generate/generators/entity.ts
-import { join as join9 } from "path";
-import { writeFileSync as writeFileSync7, existsSync as existsSync9 } from "fs";
+import { join as join19 } from "path";
+import { writeFileSync as writeFileSync12, existsSync as existsSync21 } from "fs";
 function generateSchema(fnDir, scope, fnName) {
-  const schemaFilePath = join9(fnDir, "src/server/entities/schema.ts");
-  if (existsSync9(schemaFilePath)) {
+  const schemaFilePath = join19(fnDir, "src/server/entities/schema.ts");
+  if (existsSync21(schemaFilePath)) {
     return;
   }
   const packageName = `${scope}/${fnName}`;
@@ -3000,7 +4054,7 @@ function generateSchema(fnDir, scope, fnName) {
     PACKAGE_NAME: packageName,
     SCHEMA_VAR_NAME: schemaVarName
   });
-  writeFileSync7(schemaFilePath, content);
+  writeFileSync12(schemaFilePath, content);
 }
 function generateEntity(fnDir, scope, fnName, entityName) {
   const safeScope = toSafeSchemaName(scope);
@@ -3019,8 +4073,8 @@ function generateEntity(fnDir, scope, fnName, entityName) {
     SCHEMA_VAR_NAME: schemaVarName,
     SCHEMA_FILE_NAME: schemaFileName
   });
-  writeFileSync7(
-    join9(fnDir, `src/server/entities/${toKebabCase(entityName)}.ts`),
+  writeFileSync12(
+    join19(fnDir, `src/server/entities/${toKebabCase(entityName)}.ts`),
     content
   );
 }
@@ -3028,12 +4082,12 @@ 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");
-  writeFileSync7(join9(fnDir, "src/server/entities/index.ts"), content + "\n");
+  writeFileSync12(join19(fnDir, "src/server/entities/index.ts"), content + "\n");
 }
 
 // src/commands/generate/generators/repository.ts
-import { join as join10 } from "path";
-import { writeFileSync as writeFileSync8 } from "fs";
+import { join as join20 } from "path";
+import { writeFileSync as writeFileSync13 } from "fs";
 function generateRepository(fnDir, entityName) {
   const pascalName = toPascalCase(entityName);
   const repoName = `${entityName}Repository`;
@@ -3042,19 +4096,19 @@ function generateRepository(fnDir, entityName) {
     ENTITY_NAME: entityName,
     REPO_NAME: repoName
   });
-  writeFileSync8(
-    join10(fnDir, `src/server/repositories/${toKebabCase(entityName)}.repository.ts`),
+  writeFileSync13(
+    join20(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");
-  writeFileSync8(join10(fnDir, "src/server/repositories/index.ts"), exports + "\n");
+  writeFileSync13(join20(fnDir, "src/server/repositories/index.ts"), exports + "\n");
 }
 
 // src/commands/generate/generators/route.ts
-import { join as join11 } from "path";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync9 } from "fs";
+import { join as join21 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync14 } from "fs";
 function generateRoute(fnDir, entityName) {
   const pascalName = toPascalCase(entityName);
   const repoName = `${entityName}Repository`;
@@ -3065,29 +4119,29 @@ function generateRoute(fnDir, entityName) {
     REPO_NAME: repoName,
     KEBAB_NAME: kebabName
   });
-  const routeDir = join11(fnDir, `src/server/routes/${kebabName}`);
+  const routeDir = join21(fnDir, `src/server/routes/${kebabName}`);
   mkdirSync4(routeDir, { recursive: true });
-  writeFileSync9(join11(routeDir, "index.ts"), content);
+  writeFileSync14(join21(routeDir, "index.ts"), content);
 }
 
 // src/commands/generate/generators/contract.ts
-import { join as join12 } from "path";
-import { writeFileSync as writeFileSync10 } from "fs";
+import { join as join22 } from "path";
+import { writeFileSync as writeFileSync15 } from "fs";
 function generateContract(fnDir, entityName) {
   const pascalName = toPascalCase(entityName);
   const content = loadTemplate("contract", {
     PASCAL_NAME: pascalName,
     ENTITY_NAME: entityName
   });
-  writeFileSync10(
-    join12(fnDir, `src/lib/contracts/${toKebabCase(entityName)}.ts`),
+  writeFileSync15(
+    join22(fnDir, `src/lib/contracts/${toKebabCase(entityName)}.ts`),
     content
   );
 }
 
 // src/commands/generate/generators/index-files.ts
-import { join as join13 } from "path";
-import { writeFileSync as writeFileSync11 } from "fs";
+import { join as join23 } from "path";
+import { writeFileSync as writeFileSync16 } from "fs";
 function generateMainIndex(fnDir, fnName) {
   const content = `/**
  * @spfn/${fnName}
@@ -3113,7 +4167,7 @@ export * from '@/lib/types/index';
 
 export * from '@/server/entities/index';
 `;
-  writeFileSync11(join13(fnDir, "src/index.ts"), content);
+  writeFileSync16(join23(fnDir, "src/index.ts"), content);
 }
 function generateServerIndex(fnDir) {
   const content = `/**
@@ -3148,7 +4202,7 @@ export * from '@/server/repositories/index';
 
 // TODO: Export helpers here
 `;
-  writeFileSync11(join13(fnDir, "src/server.ts"), content);
+  writeFileSync16(join23(fnDir, "src/server.ts"), content);
 }
 function generateClientIndex(fnDir) {
   const content = `/**
@@ -3181,7 +4235,7 @@ export * from './client/store';
 
 export * from './client/components';
 `;
-  writeFileSync11(join13(fnDir, "src/client.ts"), content);
+  writeFileSync16(join23(fnDir, "src/client.ts"), content);
 }
 function generateTypesFile(fnDir, fnName) {
   const content = `/**
@@ -3193,7 +4247,7 @@ function generateTypesFile(fnDir, fnName) {
 
 export * from '@/lib/types/index';
 `;
-  writeFileSync11(join13(fnDir, "src/types.ts"), content);
+  writeFileSync16(join23(fnDir, "src/types.ts"), content);
 }
 
 // src/commands/generate/generators/structure.ts
@@ -3215,7 +4269,7 @@ async function generateFunctionStructure(options) {
     "src/client/store",
     "src/client/components"
   ];
-  dirs.forEach((dir) => mkdirSync5(join14(fnDir, dir), { recursive: true }));
+  dirs.forEach((dir) => mkdirSync5(join24(fnDir, dir), { recursive: true }));
   generatePackageJson(fnDir, scope, fnName, description);
   generateTsConfig(fnDir);
   generateTsupConfig(fnDir);
@@ -3235,15 +4289,15 @@ async function generateFunctionStructure(options) {
     generateEntitiesIndex(fnDir, entities);
     generateRepositoriesIndex(fnDir, entities);
   } else {
-    writeFileSync12(join14(fnDir, "src/server/entities/index.ts"), "// Export your entities here\nexport {}\n");
-    writeFileSync12(join14(fnDir, "src/server/repositories/index.ts"), "// Export your repositories here\nexport {}\n");
-  }
-  writeFileSync12(join14(fnDir, "src/client/hooks/index.ts"), "/**\n * Client Hooks\n */\n\n// TODO: Add hooks (e.g., useAuth, useData, etc.)\nexport {}\n");
-  writeFileSync12(join14(fnDir, "src/client/store/index.ts"), "/**\n * Client Store\n */\n\n// TODO: Add Zustand store if needed\nexport {}\n");
-  writeFileSync12(join14(fnDir, "src/client/components/index.ts"), "/**\n * Client Components\n */\n\n// TODO: Add React components\nexport {}\n");
-  writeFileSync12(join14(fnDir, "src/client/index.ts"), "/**\n * Client Module Entry\n */\n\nexport * from './hooks';\nexport * from './store';\nexport * from './components';\n");
-  writeFileSync12(join14(fnDir, "src/lib/types/index.ts"), "/**\n * Shared Type Definitions\n */\n\n// Add your shared types here\nexport {}\n");
-  writeFileSync12(join14(fnDir, "src/lib/contracts/index.ts"), "/**\n * API Contracts\n */\n\n// Export your contracts here\nexport {}\n");
+    writeFileSync17(join24(fnDir, "src/server/entities/index.ts"), "// Export your entities here\nexport {}\n");
+    writeFileSync17(join24(fnDir, "src/server/repositories/index.ts"), "// Export your repositories here\nexport {}\n");
+  }
+  writeFileSync17(join24(fnDir, "src/client/hooks/index.ts"), "/**\n * Client Hooks\n */\n\n// TODO: Add hooks (e.g., useAuth, useData, etc.)\nexport {}\n");
+  writeFileSync17(join24(fnDir, "src/client/store/index.ts"), "/**\n * Client Store\n */\n\n// TODO: Add Zustand store if needed\nexport {}\n");
+  writeFileSync17(join24(fnDir, "src/client/components/index.ts"), "/**\n * Client Components\n */\n\n// TODO: Add React components\nexport {}\n");
+  writeFileSync17(join24(fnDir, "src/client/index.ts"), "/**\n * Client Module Entry\n */\n\nexport * from './hooks';\nexport * from './store';\nexport * from './components';\n");
+  writeFileSync17(join24(fnDir, "src/lib/types/index.ts"), "/**\n * Shared Type Definitions\n */\n\n// Add your shared types here\nexport {}\n");
+  writeFileSync17(join24(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);
@@ -3267,8 +4321,8 @@ async function generateFunction(name, options) {
     logger.error("Function name is required");
     process.exit(1);
   }
-  const fnDir = join15(cwd, fnName);
-  if (existsSync10(fnDir)) {
+  const fnDir = join25(cwd, fnName);
+  if (existsSync22(fnDir)) {
     logger.error(`Directory ${fnName} already exists at ${fnDir}`);
     process.exit(1);
   }
@@ -3300,7 +4354,7 @@ async function generateFunction(name, options) {
       process.exit(0);
     }
   }
-  const spinner = ora5("Generating function structure...").start();
+  const spinner = ora12("Generating function structure...").start();
   try {
     await generateFunctionStructure({
       fnDir,
@@ -3313,13 +4367,13 @@ async function generateFunction(name, options) {
     });
     spinner.succeed("Function structure generated");
     console.log("");
-    logger.success(`\u2728 Package ${chalk9.cyan(`${scope}/${fnName}`)} created successfully!
+    logger.success(`\u2728 Package ${chalk25.cyan(`${scope}/${fnName}`)} created successfully!
 `);
-    logger.info(chalk9.bold("\u{1F4DA} Next steps:"));
-    console.log(`  ${chalk9.gray("1.")} cd ${fnName}`);
-    console.log(`  ${chalk9.gray("2.")} pnpm install ${chalk9.dim("(in monorepo root)")}`);
-    console.log(`  ${chalk9.gray("3.")} pnpm build`);
-    console.log(`  ${chalk9.gray("4.")} ${chalk9.dim("Use the package in your app")}`);
+    logger.info(chalk25.bold("\u{1F4DA} Next steps:"));
+    console.log(`  ${chalk25.gray("1.")} cd ${fnName}`);
+    console.log(`  ${chalk25.gray("2.")} pnpm install ${chalk25.dim("(in monorepo root)")}`);
+    console.log(`  ${chalk25.gray("3.")} pnpm build`);
+    console.log(`  ${chalk25.gray("4.")} ${chalk25.dim("Use the package in your app")}`);
     console.log("");
   } catch (error) {
     spinner.fail("Failed to generate function");
@@ -3327,12 +4381,434 @@ async function generateFunction(name, options) {
     process.exit(1);
   }
 }
-var generateCommand = new Command9("generate").alias("g").description("Generate SPFN resources");
+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 chalk26 from "chalk";
+import { existsSync as existsSync23, readFileSync as readFileSync8, writeFileSync as writeFileSync18 } from "fs";
+import { resolve } from "path";
+import { parse } from "dotenv";
+var ENV_FILES = {
+  nextjs: [".env", ".env.local"],
+  server: [".env.server", ".env.server.local"]
+};
+function getTargetFile(schema) {
+  const isNextjs = schema.nextjs ?? schema.key?.startsWith("NEXT_PUBLIC_");
+  if (isNextjs) {
+    return schema.sensitive ? ".env.local" : ".env";
+  }
+  return schema.sensitive ? ".env.server.local" : ".env.server";
+}
+async function loadEnvSchema(packageName) {
+  try {
+    const schemaPath = `${packageName}/config`;
+    const module = await import(schemaPath);
+    if (!module.envSchema) {
+      throw new Error(`Package ${packageName} does not export envSchema from config`);
+    }
+    return module.envSchema;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("does not export envSchema")) {
+      throw error;
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load package ${packageName}: ${errorMessage}`);
+  }
+}
+function formatType(type) {
+  const typeColors = {
+    string: chalk26.green,
+    number: chalk26.blue,
+    boolean: chalk26.yellow,
+    url: chalk26.cyan,
+    enum: chalk26.magenta,
+    json: chalk26.red
+  };
+  const colorFn = typeColors[type] || chalk26.white;
+  return colorFn(type);
+}
+function formatDefault(value, type) {
+  if (value === void 0) {
+    return chalk26.dim("(none)");
+  }
+  if (type === "string" || type === "url") {
+    return chalk26.green(`"${value}"`);
+  }
+  if (type === "boolean") {
+    return value ? chalk26.green("true") : chalk26.red("false");
+  }
+  return chalk26.cyan(String(value));
+}
+async function listEnvVars(options) {
+  const packageName = options.package || "@spfn/core";
+  try {
+    const envSchema = await loadEnvSchema(packageName);
+    const allVars = Object.entries(envSchema);
+    if (options.group) {
+      const grouped = allVars.reduce((acc, [key, schema]) => {
+        const target = getTargetFile(schema);
+        if (!acc[target]) acc[target] = [];
+        acc[target].push([key, schema]);
+        return acc;
+      }, {});
+      console.log(chalk26.blue.bold(`
+\u{1F4CB} Environment Variables by File (${packageName})
+`));
+      for (const [file, vars] of Object.entries(grouped)) {
+        console.log(chalk26.bold.magenta(`
+${file}`));
+        console.log(chalk26.dim("\u2500".repeat(50)));
+        for (const [key, schema] of vars) {
+          printEnvVar(key, schema);
+        }
+      }
+    } else {
+      console.log(chalk26.blue.bold(`
+\u{1F4CB} Environment Variables (${packageName})
+`));
+      for (const [key, schema] of allVars) {
+        printEnvVar(key, schema, true);
+      }
+    }
+    console.log(chalk26.dim("\n\u{1F4A1} Tip: Use `spfn env init` to generate .env template files\n"));
+  } catch (error) {
+    console.error(chalk26.red(`
+\u274C ${error instanceof Error ? error.message : "Unknown error"}
+`));
+    process.exit(1);
+  }
+}
+function printEnvVar(key, schema, showFile = false) {
+  const typeStr = formatType(schema.type);
+  const requiredStr = schema.required || schema.default !== void 0 ? chalk26.red("[required]") : chalk26.dim("[optional]");
+  const sensitiveStr = schema.sensitive ? chalk26.yellow(" [sensitive]") : "";
+  const fileStr = showFile ? chalk26.dim(` \u2192 ${getTargetFile(schema)}`) : "";
+  console.log(`${chalk26.bold.cyan(key)} ${chalk26.dim("(")}${typeStr}${chalk26.dim(")")} ${requiredStr}${sensitiveStr}${fileStr}`);
+  console.log(`  ${chalk26.dim(schema.description)}`);
+  if (schema.default !== void 0) {
+    console.log(`  ${chalk26.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(`  ${chalk26.dim("Examples:")} ${exampleStr}`);
+  }
+  console.log();
+}
+async function showEnvStats(options) {
+  const packageName = options.package || "@spfn/core";
+  try {
+    const envSchema = await loadEnvSchema(packageName);
+    console.log(chalk26.blue.bold(`
+\u{1F4CA} Environment Variable Statistics (${packageName})
+`));
+    const allVars = Object.entries(envSchema);
+    const required = allVars.filter(([_, schema]) => schema.required || schema.default !== void 0);
+    const optional = allVars.filter(([_, schema]) => !schema.required && schema.default === void 0);
+    const sensitive = allVars.filter(([_, schema]) => schema.sensitive);
+    const nextjsVars = allVars.filter(
+      ([_, schema]) => schema.nextjs ?? schema.key?.startsWith("NEXT_PUBLIC_")
+    );
+    const serverOnlyVars = allVars.filter(
+      ([_, schema]) => !(schema.nextjs ?? schema.key?.startsWith("NEXT_PUBLIC_"))
+    );
+    const typeCount = allVars.reduce((acc, [_, schema]) => {
+      acc[schema.type] = (acc[schema.type] || 0) + 1;
+      return acc;
+    }, {});
+    const fileCount = allVars.reduce((acc, [_, schema]) => {
+      const file = getTargetFile(schema);
+      acc[file] = (acc[file] || 0) + 1;
+      return acc;
+    }, {});
+    console.log(`${chalk26.bold("Total variables:")} ${chalk26.cyan(allVars.length)}`);
+    console.log(`${chalk26.bold("Required:")} ${chalk26.red(required.length)}`);
+    console.log(`${chalk26.bold("Optional:")} ${chalk26.dim(optional.length)}`);
+    console.log(`${chalk26.bold("Sensitive:")} ${chalk26.yellow(sensitive.length)}`);
+    console.log(chalk26.bold("\nBy Target:"));
+    console.log(`  ${chalk26.blue("Next.js accessible:")} ${chalk26.cyan(nextjsVars.length)}`);
+    console.log(`  ${chalk26.magenta("SPFN server only:")} ${chalk26.cyan(serverOnlyVars.length)}`);
+    console.log(chalk26.bold("\nBy File:"));
+    for (const [file, count] of Object.entries(fileCount)) {
+      console.log(`  ${chalk26.dim(file)}: ${chalk26.cyan(count)}`);
+    }
+    console.log(chalk26.bold("\nBy Type:"));
+    for (const [type, count] of Object.entries(typeCount)) {
+      console.log(`  ${formatType(type)}: ${chalk26.cyan(count)}`);
+    }
+    console.log();
+  } catch (error) {
+    console.error(chalk26.red(`
+\u274C ${error instanceof Error ? error.message : "Unknown error"}
+`));
+    process.exit(1);
+  }
+}
+async function searchEnvVars(query, options) {
+  const packageName = options.package || "@spfn/core";
+  try {
+    const envSchema = await loadEnvSchema(packageName);
+    const normalizedQuery = query.toLowerCase();
+    const results = [];
+    for (const [key, schema] of Object.entries(envSchema)) {
+      const matchesKey = key.toLowerCase().includes(normalizedQuery);
+      const matchesDescription = schema.description.toLowerCase().includes(normalizedQuery);
+      if (matchesKey || matchesDescription) {
+        results.push([key, schema]);
+      }
+    }
+    if (results.length === 0) {
+      console.log(chalk26.yellow(`
+\u26A0\uFE0F  No environment variables found matching "${query}"
+`));
+      return;
+    }
+    console.log(chalk26.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 ? chalk26.red("[required]") : chalk26.dim("[optional]");
+      console.log(`${chalk26.bold.cyan(key)} ${chalk26.dim("(")}${typeStr}${chalk26.dim(")")} ${requiredStr}`);
+      console.log(`  ${chalk26.dim(schema.description)}`);
+      if (schema.default !== void 0) {
+        console.log(`  ${chalk26.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
+      }
+      console.log();
+    }
+  } catch (error) {
+    console.error(chalk26.red(`
+\u274C ${error instanceof Error ? error.message : "Unknown error"}
+`));
+    process.exit(1);
+  }
+}
+var envCommand = new Command12("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);
+async function initEnvFiles(options) {
+  const packageName = options.package || "@spfn/core";
+  const cwd = process.cwd();
+  try {
+    const envSchema = await loadEnvSchema(packageName);
+    const allVars = Object.entries(envSchema);
+    const grouped = allVars.reduce((acc, [key, schema]) => {
+      const target = getTargetFile(schema);
+      const exampleFile = target + ".example";
+      if (!acc[exampleFile]) acc[exampleFile] = [];
+      acc[exampleFile].push([key, schema]);
+      return acc;
+    }, {});
+    console.log(chalk26.blue.bold(`
+\u{1F680} Generating .env template files
+`));
+    for (const [file, vars] of Object.entries(grouped)) {
+      const filePath = resolve(cwd, file);
+      if (existsSync23(filePath) && !options.force) {
+        console.log(chalk26.yellow(`  \u23ED\uFE0F  ${file} already exists (use --force to overwrite)`));
+        continue;
+      }
+      const content = generateEnvFileContent(vars);
+      writeFileSync18(filePath, content, "utf-8");
+      console.log(chalk26.green(`  \u2705 ${file} (${vars.length} variables)`));
+    }
+    console.log(chalk26.dim("\n\u{1F4A1} Copy .example files to create your actual .env files:"));
+    console.log(chalk26.dim("   cp .env.example .env"));
+    console.log(chalk26.dim("   cp .env.local.example .env.local"));
+    console.log(chalk26.dim("   cp .env.server.example .env.server"));
+    console.log(chalk26.dim("   cp .env.server.local.example .env.server.local\n"));
+  } catch (error) {
+    console.error(chalk26.red(`
+\u274C ${error instanceof Error ? error.message : "Unknown error"}
+`));
+    process.exit(1);
+  }
+}
+function generateEnvFileContent(vars) {
+  const lines = [
+    "# Auto-generated by spfn env init",
+    "# Copy this file and fill in the values",
+    ""
+  ];
+  for (const [key, schema] of vars) {
+    lines.push(`# ${schema.description}`);
+    if (schema.required) {
+      lines.push(`# [required]`);
+    }
+    if (schema.sensitive) {
+      lines.push(`# [sensitive] - Do not commit this value!`);
+    }
+    let value = "";
+    if (schema.default !== void 0) {
+      value = String(schema.default);
+    } else if (schema.examples && schema.examples.length > 0) {
+      value = String(schema.examples[0]);
+    }
+    lines.push(`${key}=${value}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function checkEnvFiles(options) {
+  const packageName = options.package || "@spfn/core";
+  const cwd = process.cwd();
+  try {
+    const envSchema = await loadEnvSchema(packageName);
+    const allVars = Object.entries(envSchema);
+    console.log(chalk26.blue.bold(`
+\u{1F50D} Checking .env files against schema
+`));
+    const allFiles = [...ENV_FILES.nextjs, ...ENV_FILES.server];
+    const loadedEnv = {};
+    const issues = [];
+    const warnings = [];
+    for (const file of allFiles) {
+      const filePath = resolve(cwd, file);
+      if (!existsSync23(filePath)) {
+        continue;
+      }
+      const content = readFileSync8(filePath, "utf-8");
+      const parsed = parse(content);
+      for (const [key, value] of Object.entries(parsed)) {
+        loadedEnv[key] = { value: value || "", file };
+      }
+      console.log(chalk26.dim(`  \u{1F4C4} ${file} loaded`));
+    }
+    console.log("");
+    for (const [key, schema] of allVars) {
+      const expectedFile = getTargetFile(schema);
+      const found = loadedEnv[key];
+      if (!found) {
+        if (schema.required && schema.default === void 0) {
+          issues.push(`${chalk26.red("\u2717")} ${chalk26.cyan(key)} is required but not found in any .env file`);
+        }
+        continue;
+      }
+      const isNextjsFile = ENV_FILES.nextjs.includes(found.file);
+      const isServerFile = ENV_FILES.server.includes(found.file);
+      const shouldBeNextjs = schema.nextjs ?? key.startsWith("NEXT_PUBLIC_");
+      if (!shouldBeNextjs && isNextjsFile && !isServerFile) {
+        if (schema.sensitive) {
+          issues.push(
+            `${chalk26.red("\u2717")} ${chalk26.cyan(key)} is sensitive and should be in ${chalk26.magenta(expectedFile)}, but found in ${chalk26.yellow(found.file)} (security risk!)`
+          );
+        } else {
+          warnings.push(
+            `${chalk26.yellow("\u26A0")} ${chalk26.cyan(key)} should be in ${chalk26.magenta(expectedFile)}, but found in ${chalk26.dim(found.file)}`
+          );
+        }
+      }
+    }
+    for (const [key, { file }] of Object.entries(loadedEnv)) {
+      const inSchema = allVars.some(([k]) => k === key);
+      if (!inSchema) {
+        warnings.push(`${chalk26.yellow("\u26A0")} ${chalk26.cyan(key)} in ${chalk26.dim(file)} is not in schema`);
+      }
+    }
+    if (issues.length > 0) {
+      console.log(chalk26.red.bold("Issues:"));
+      for (const issue of issues) {
+        console.log(`  ${issue}`);
+      }
+      console.log("");
+    }
+    if (warnings.length > 0) {
+      console.log(chalk26.yellow.bold("Warnings:"));
+      for (const warning of warnings) {
+        console.log(`  ${warning}`);
+      }
+      console.log("");
+    }
+    if (issues.length === 0 && warnings.length === 0) {
+      console.log(chalk26.green("\u2705 All environment variables are correctly configured!\n"));
+    } else {
+      console.log(chalk26.dim(`Found ${issues.length} issue(s) and ${warnings.length} warning(s)
+`));
+      if (issues.length > 0) {
+        process.exit(1);
+      }
+    }
+  } catch (error) {
+    console.error(chalk26.red(`
+\u274C ${error instanceof Error ? error.message : "Unknown error"}
+`));
+    process.exit(1);
+  }
+}
+envCommand.command("init").description("Generate .env template files from schema").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").option("-f, --force", "Overwrite existing files").action(initEnvFiles);
+envCommand.command("check").description("Check .env files against schema").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").action(checkEnvFiles);
+async function validateEnvVars(options) {
+  const packages = options.packages || ["@spfn/core"];
+  console.log(chalk26.blue.bold(`
+\u{1F50D} Validating environment variables
+`));
+  const allErrors = [];
+  const allWarnings = [];
+  for (const packageName of packages) {
+    try {
+      console.log(chalk26.dim(`  \u{1F4E6} ${packageName}`));
+      const envSchema = await loadEnvSchema(packageName);
+      const { createEnvRegistry } = await import("@spfn/core/env");
+      const registry = createEnvRegistry(envSchema);
+      const result = registry.validateAll();
+      for (const error of result.errors) {
+        allErrors.push({ ...error, package: packageName });
+      }
+      for (const warning of result.warnings) {
+        allWarnings.push({ ...warning, package: packageName });
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("does not export envSchema")) {
+        console.log(chalk26.dim(`    \u23ED\uFE0F  No envSchema exported, skipping`));
+        continue;
+      }
+      console.error(chalk26.red(`    \u274C Failed to load: ${error instanceof Error ? error.message : String(error)}`));
+      if (options.strict) {
+        process.exit(1);
+      }
+    }
+  }
+  console.log("");
+  if (allErrors.length > 0) {
+    console.log(chalk26.red.bold(`\u274C Validation Errors (${allErrors.length}):
+`));
+    for (const error of allErrors) {
+      console.log(`  ${chalk26.red("\u2717")} ${chalk26.cyan(error.key)}`);
+      console.log(`    ${chalk26.dim(error.message)}`);
+      console.log(`    ${chalk26.dim(`from ${error.package}`)}`);
+      console.log("");
+    }
+  }
+  if (allWarnings.length > 0) {
+    console.log(chalk26.yellow.bold(`\u26A0\uFE0F  Warnings (${allWarnings.length}):
+`));
+    for (const warning of allWarnings) {
+      console.log(`  ${chalk26.yellow("\u26A0")} ${chalk26.cyan(warning.key)}`);
+      console.log(`    ${chalk26.dim(warning.message)}`);
+      console.log("");
+    }
+  }
+  if (allErrors.length === 0 && allWarnings.length === 0) {
+    console.log(chalk26.green.bold("\u2705 All environment variables are valid!\n"));
+  } else if (allErrors.length === 0) {
+    console.log(chalk26.green("\u2705 No errors found."));
+    console.log(chalk26.yellow(`\u26A0\uFE0F  ${allWarnings.length} warning(s) found.
+`));
+  } else {
+    console.log(chalk26.red(`
+\u274C Validation failed with ${allErrors.length} error(s)
+`));
+    process.exit(1);
+  }
+}
+envCommand.command("validate").description("Validate environment variables against schema (for CI/CD)").option("-p, --packages <packages...>", "Packages to validate", ["@spfn/core"]).option("-s, --strict", "Exit on any error (including load failures)").action(validateEnvVars);
+
 // src/index.ts
-var program = new Command10();
-program.name("spfn").description("SPFN CLI - The Missing Backend for Next.js").version("0.1.0");
+init_version();
+var program = new Command13();
+program.name("spfn").description("SPFN CLI - The Missing Backend for Next.js").version(getCliVersion());
 program.addCommand(createCommand);
 program.addCommand(initCommand);
 program.addCommand(addCommand);
@@ -3344,6 +4820,7 @@ program.addCommand(codegenCommand);
 program.addCommand(keyCommand);
 program.addCommand(setupCommand);
 program.addCommand(dbCommand);
+program.addCommand(envCommand);
 async function run() {
   await program.parseAsync(process.argv);
 }