@cloudwerk/cli 0.12.0 → 0.14.0

package/dist/index.js

@@ -7,9 +7,11 @@ import { program } from "commander";
 import * as path from "path";
 import * as fs from "fs";
 import * as os from "os";
-import { createServer } from "vite";
+import { createServer, mergeConfig as mergeViteConfig } from "vite";
 import devServer from "@hono/vite-dev-server";
+import cloudflareAdapter from "@hono/vite-dev-server/cloudflare";
 import cloudwerk from "@cloudwerk/vite-plugin";
+import { loadConfig } from "@cloudwerk/core";
 
 // src/types.ts
 var CliError = class extends Error {
@@ -138,7 +140,9 @@ async function dev(pathArg, options) {
         "Port must be a number between 1 and 65535"
       );
     }
-    const viteConfig = {
+    const config = await loadConfig(cwd);
+    logger.debug(`Loaded cloudwerk config`);
+    const baseViteConfig = {
       root: cwd,
       mode: "development",
       server: {
@@ -151,6 +155,7 @@ async function dev(pathArg, options) {
           verbose
         }),
         devServer({
+          adapter: cloudflareAdapter,
           entry: "virtual:cloudwerk/server-entry"
         })
       ],
@@ -158,6 +163,15 @@ async function dev(pathArg, options) {
       logLevel: verbose ? "info" : "warn",
       clearScreen: false
     };
+    let viteConfig = baseViteConfig;
+    if (config.vite) {
+      const userPlugins = config.vite.plugins;
+      const { plugins: _, ...userConfigWithoutPlugins } = config.vite;
+      viteConfig = mergeViteConfig(baseViteConfig, userConfigWithoutPlugins);
+      if (userPlugins) {
+        viteConfig.plugins = [...userPlugins, ...baseViteConfig.plugins ?? []];
+      }
+    }
     logger.debug(`Starting Vite dev server...`);
     const server = await createServer(viteConfig);
     await server.listen();
@@ -257,15 +271,22 @@ function setupGracefulShutdown(server, logger) {
 import { builtinModules } from "module";
 import * as path2 from "path";
 import * as fs2 from "fs";
-import { build as viteBuild } from "vite";
+import { build as viteBuild, mergeConfig as mergeViteConfig2 } from "vite";
+import { getPlatformProxy } from "wrangler";
 import cloudwerk2, { generateServerEntry } from "@cloudwerk/vite-plugin";
 import {
   scanRoutes,
   buildRouteManifest,
   resolveLayouts,
   resolveMiddleware,
-  loadConfig,
-  resolveRoutesPath
+  loadConfig as loadConfig2,
+  resolveRoutesPath,
+  scanQueues,
+  buildQueueManifest,
+  QUEUES_DIR,
+  scanServices,
+  buildServiceManifest,
+  SERVICES_DIR
 } from "@cloudwerk/core/build";
 var DEFAULT_OUTPUT_DIR = "./dist";
 var BUILD_TEMP_DIR = ".cloudwerk-build";
@@ -298,7 +319,7 @@ async function build(pathArg, options) {
     if (!fs2.existsSync(tempDir)) {
       fs2.mkdirSync(tempDir, { recursive: true });
     }
-    const cloudwerkConfig = await loadConfig(cwd);
+    const cloudwerkConfig = await loadConfig2(cwd);
     const appDir = cloudwerkConfig.appDir;
     const routesDir = cloudwerkConfig.routesDir ?? "routes";
     const routesPath = resolveRoutesPath(routesDir, appDir, cwd);
@@ -313,6 +334,30 @@ async function build(pathArg, options) {
       resolveMiddleware
     );
     logger.debug(`Found ${manifest.routes.length} routes`);
+    const queuesPath = path2.resolve(cwd, appDir, QUEUES_DIR);
+    let queueManifest = null;
+    if (fs2.existsSync(queuesPath)) {
+      const queueScanResult = await scanQueues(
+        path2.resolve(cwd, appDir),
+        { extensions: cloudwerkConfig.extensions }
+      );
+      queueManifest = buildQueueManifest(queueScanResult, cwd, { appName: "cloudwerk" });
+      if (queueManifest.queues.length > 0) {
+        logger.debug(`Found ${queueManifest.queues.length} queue(s)`);
+      }
+    }
+    const servicesPath = path2.resolve(cwd, appDir, SERVICES_DIR);
+    let serviceManifest = null;
+    if (fs2.existsSync(servicesPath)) {
+      const serviceScanResult = await scanServices(
+        path2.resolve(cwd, appDir),
+        { extensions: cloudwerkConfig.extensions }
+      );
+      serviceManifest = buildServiceManifest(serviceScanResult, cwd);
+      if (serviceManifest.services.length > 0) {
+        logger.debug(`Found ${serviceManifest.services.length} service(s)`);
+      }
+    }
     const renderer = cloudwerkConfig.ui?.renderer ?? "hono-jsx";
     const serverEntryCode = generateServerEntry(manifest, scanResult, {
       appDir,
@@ -326,12 +371,15 @@ async function build(pathArg, options) {
       publicDir: cloudwerkConfig.publicDir ?? "public",
       root: cwd,
       isProduction: true
+    }, {
+      queueManifest,
+      serviceManifest
     });
     const tempEntryPath = path2.join(tempDir, "_server-entry.ts");
     fs2.writeFileSync(tempEntryPath, serverEntryCode);
     logger.debug(`Generated temp entry: ${tempEntryPath}`);
     logger.debug(`Building client assets...`);
-    const clientConfig = {
+    const baseClientConfig = {
       root: cwd,
       mode: "production",
       logLevel: verbose ? "info" : "warn",
@@ -353,6 +401,15 @@ async function build(pathArg, options) {
         }
       }
     };
+    let clientConfig = baseClientConfig;
+    if (cloudwerkConfig.vite) {
+      const userPlugins = cloudwerkConfig.vite.plugins;
+      const { plugins: _, ...userConfigWithoutPlugins } = cloudwerkConfig.vite;
+      clientConfig = mergeViteConfig2(baseClientConfig, userConfigWithoutPlugins);
+      if (userPlugins) {
+        clientConfig.plugins = [...userPlugins, ...baseClientConfig.plugins ?? []];
+      }
+    }
     try {
       await viteBuild(clientConfig);
       logger.debug(`Client assets built successfully`);
@@ -362,7 +419,7 @@ async function build(pathArg, options) {
       }
     }
     logger.debug(`Building server bundle...`);
-    const serverConfig = {
+    const baseServerConfig = {
       root: cwd,
       mode: "production",
       logLevel: verbose ? "info" : "warn",
@@ -397,8 +454,31 @@ async function build(pathArg, options) {
         conditions: ["workerd", "worker", "browser", "import", "module", "default"]
       }
     };
+    let serverConfig = baseServerConfig;
+    if (cloudwerkConfig.vite) {
+      const userPlugins = cloudwerkConfig.vite.plugins;
+      const { plugins: _, ...userConfigWithoutPlugins } = cloudwerkConfig.vite;
+      serverConfig = mergeViteConfig2(baseServerConfig, userConfigWithoutPlugins);
+      if (userPlugins) {
+        serverConfig.plugins = [...userPlugins, ...baseServerConfig.plugins ?? []];
+      }
+    }
     await viteBuild(serverConfig);
     logger.debug(`Server bundle built successfully`);
+    let ssgPaths = [];
+    if (options.ssg) {
+      logger.info(`Generating static pages...`);
+      ssgPaths = await generateStaticPages(
+        manifest,
+        cwd,
+        outputDir,
+        logger,
+        verbose
+      );
+      if (ssgPaths.length > 0) {
+        logger.debug(`Generated ${ssgPaths.length} static page(s)`);
+      }
+    }
     const buildDuration = Date.now() - startTime;
     const serverBundlePath = path2.join(outputDir, "index.js");
     const serverSize = fs2.existsSync(serverBundlePath) ? fs2.statSync(serverBundlePath).size : 0;
@@ -415,7 +495,7 @@ async function build(pathArg, options) {
       }
     }
     console.log();
-    printBuildSummary(serverSize, clientSize, buildDuration, logger);
+    printBuildSummary(serverSize, clientSize, ssgPaths.length, buildDuration, logger);
     console.log();
     logger.success(`Build completed in ${buildDuration}ms`);
   } catch (error) {
@@ -444,7 +524,7 @@ async function build(pathArg, options) {
     }
   }
 }
-function printBuildSummary(serverSize, clientSize, buildDuration, logger) {
+function printBuildSummary(serverSize, clientSize, ssgPageCount, buildDuration, logger) {
   logger.log("Build Output:");
   logger.log("");
   logger.log("  Server:");
@@ -455,6 +535,11 @@ function printBuildSummary(serverSize, clientSize, buildDuration, logger) {
     logger.log(`    Total:      ${formatSize(clientSize)}`);
     logger.log("");
   }
+  if (ssgPageCount > 0) {
+    logger.log("  Static Pages:");
+    logger.log(`    Generated:  ${ssgPageCount}`);
+    logger.log("");
+  }
   const totalSize = serverSize + clientSize;
   logger.log(`  Total:        ${formatSize(totalSize)}`);
   logger.log(`  Duration:     ${buildDuration}ms`);
@@ -468,6 +553,76 @@ function formatSize(bytes) {
   }
   return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
 }
+async function generateStaticPages(_manifest, cwd, outputDir, logger, verbose) {
+  const generatedPaths = [];
+  const { env, dispose } = await getPlatformProxy({
+    configPath: path2.join(cwd, "wrangler.toml")
+  });
+  if (verbose) {
+    logger.debug(`SSG env bindings: ${Object.keys(env).join(", ")}`);
+  }
+  try {
+    const { createServer: createServer2 } = await import("vite");
+    const { toSSG } = await import("./ssg-DR2ZOVQ7.js");
+    const fsPromises = await import("fs/promises");
+    const vite = await createServer2({
+      root: cwd,
+      server: { middlewareMode: true },
+      appType: "custom",
+      logLevel: verbose ? "info" : "warn",
+      plugins: [cloudwerk2({ verbose })]
+    });
+    try {
+      const tempEntryPath = path2.join(cwd, ".cloudwerk-build", "_server-entry.ts");
+      const appModule = await vite.ssrLoadModule(
+        fs2.existsSync(tempEntryPath) ? tempEntryPath : "virtual:cloudwerk/server-entry"
+      );
+      const app = appModule.default;
+      if (!app || typeof app.fetch !== "function") {
+        logger.debug("No valid Hono app found for SSG");
+        return generatedPaths;
+      }
+      const originalFetch = app.fetch.bind(app);
+      app.fetch = (request, passedEnv, executionCtx) => {
+        const mergedEnv = { ...env, ...passedEnv };
+        if (verbose) {
+          const envKeys = Object.keys(mergedEnv);
+          logger.debug(`SSG fetch ${request.url} with env: ${envKeys.join(", ")}`);
+        }
+        return originalFetch(request, mergedEnv, executionCtx);
+      };
+      const staticDir = path2.join(outputDir, "static");
+      const result = await toSSG(app, fsPromises, {
+        dir: staticDir
+        // Only generate pages that have ssgParams middleware
+        // (pages with generateStaticParams export)
+      });
+      if (result.files) {
+        for (const file of result.files) {
+          const relativePath = path2.relative(staticDir, file);
+          const urlPath = "/" + relativePath.replace(/\/index\.html$/, "").replace(/\.html$/, "");
+          generatedPaths.push(urlPath || "/");
+          if (verbose) {
+            logger.debug(`Generated: ${urlPath || "/"} -> ${relativePath}`);
+          }
+        }
+      }
+      if (generatedPaths.length > 0) {
+        logger.info(`Generated ${generatedPaths.length} static page(s)`);
+      }
+    } finally {
+      await vite.close();
+    }
+  } catch (error) {
+    if (verbose) {
+      logger.debug(`SSG error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    logger.warn(`Static generation failed: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    await dispose();
+  }
+  return generatedPaths;
+}
 
 // src/commands/deploy.ts
 import * as path3 from "path";
@@ -565,7 +720,7 @@ import pc2 from "picocolors";
 // src/utils/configWriter.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
-import { loadConfig as loadConfig2 } from "@cloudwerk/core/build";
+import { loadConfig as loadConfig3 } from "@cloudwerk/core/build";
 var CONFIG_FILE_NAMES = [
   "cloudwerk.config.ts",
   "cloudwerk.config.js",
@@ -1206,6 +1361,17 @@ function writeWranglerToml(cwd, config) {
   const content = TOML.stringify(config);
   fs7.writeFileSync(configPath, content, "utf-8");
 }
+function readWranglerTomlRaw(cwd) {
+  const configPath = findWranglerToml(cwd);
+  if (!configPath || configPath.endsWith(".json")) {
+    return "";
+  }
+  return fs7.readFileSync(configPath, "utf-8");
+}
+function writeWranglerTomlRaw(cwd, content) {
+  const configPath = path7.join(cwd, "wrangler.toml");
+  fs7.writeFileSync(configPath, content, "utf-8");
+}
 function getEnvConfig(config, env) {
   if (!env || !config.env?.[env]) {
     return config;
@@ -3142,6 +3308,2480 @@ async function bindingsGenerateTypes(options) {
   }
 }
 
+// src/commands/triggers.ts
+import pc9 from "picocolors";
+import {
+  loadConfig as loadConfig4,
+  scanTriggers,
+  buildTriggerManifest,
+  getTriggerSummary
+} from "@cloudwerk/core/build";
+var SOURCE_TYPE_LABELS = {
+  scheduled: { label: "cron", color: pc9.blue },
+  queue: { label: "queue", color: pc9.green },
+  r2: { label: "R2", color: pc9.yellow },
+  webhook: { label: "webhook", color: pc9.magenta },
+  email: { label: "email", color: pc9.cyan },
+  d1: { label: "D1", color: pc9.red },
+  tail: { label: "tail", color: pc9.gray }
+};
+function formatSourceType(type) {
+  const config = SOURCE_TYPE_LABELS[type] || { label: type, color: pc9.dim };
+  return config.color(config.label);
+}
+async function triggers(options = {}) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig4(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for triggers in ${appDir}/triggers/...`);
+    const scanResult = await scanTriggers(appDir, {
+      extensions: config.extensions
+    });
+    const manifest = buildTriggerManifest(scanResult, appDir);
+    const summary = getTriggerSummary(manifest);
+    console.log();
+    console.log(pc9.bold("Cloudwerk Triggers"));
+    console.log();
+    console.log(pc9.dim(`  Found ${summary.total} triggers:`));
+    if (summary.total > 0) {
+      if (summary.scheduled > 0) {
+        console.log(pc9.dim(`    - ${summary.scheduled} scheduled (cron)`));
+      }
+      if (summary.queue > 0) {
+        console.log(pc9.dim(`    - ${summary.queue} queue consumers`));
+      }
+      if (summary.r2 > 0) {
+        console.log(pc9.dim(`    - ${summary.r2} R2 notifications`));
+      }
+      if (summary.webhook > 0) {
+        console.log(pc9.dim(`    - ${summary.webhook} webhooks`));
+      }
+      if (summary.email > 0) {
+        console.log(pc9.dim(`    - ${summary.email} email handlers`));
+      }
+    }
+    console.log();
+    if (manifest.triggers.length > 0) {
+      for (const trigger of manifest.triggers) {
+        const sourceType = formatSourceType(trigger.source?.type ?? "unknown");
+        const sourceInfo = getSourceInfo(trigger);
+        console.log(
+          `    ${pc9.cyan(trigger.name)} ${pc9.dim("(")}${sourceType}${sourceInfo ? pc9.dim(": ") + pc9.dim(sourceInfo) : ""}${pc9.dim(")")}`
+        );
+      }
+      console.log();
+    }
+    if (manifest.warnings.length > 0) {
+      console.log(pc9.yellow("Warnings:"));
+      for (const warning of manifest.warnings) {
+        console.log(pc9.dim(`  - ${warning.file}: ${warning.message}`));
+      }
+      console.log();
+    }
+    console.log(pc9.bold("Commands:"));
+    console.log();
+    console.log(pc9.dim("  cloudwerk triggers list        ") + "List all triggers with details");
+    console.log(pc9.dim("  cloudwerk triggers validate    ") + "Validate trigger configurations");
+    console.log(pc9.dim("  cloudwerk triggers generate    ") + "Regenerate wrangler config");
+    console.log();
+    if (manifest.triggers.length === 0) {
+      console.log(pc9.bold("Quick Start:"));
+      console.log();
+      console.log(pc9.dim("  Create a scheduled trigger at app/triggers/daily-cleanup.ts:"));
+      console.log();
+      console.log(pc9.cyan("    import { defineTrigger } from '@cloudwerk/trigger'"));
+      console.log();
+      console.log(pc9.cyan("    export default defineTrigger({"));
+      console.log(pc9.cyan("      source: { type: 'scheduled', cron: '0 0 * * *' },"));
+      console.log(pc9.cyan("      async handle(event, ctx) {"));
+      console.log(pc9.cyan("        console.log(`[${ctx.traceId}] Running cleanup`)"));
+      console.log(pc9.cyan("        await cleanupOldRecords()"));
+      console.log(pc9.cyan("      }"));
+      console.log(pc9.cyan("    })"));
+      console.log();
+    }
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+function getSourceInfo(trigger) {
+  const source = trigger.source;
+  if (!source) return "";
+  const type = source.type;
+  switch (type) {
+    case "scheduled":
+      return String(source.cron ?? "");
+    case "queue":
+      return String(source.queue ?? "");
+    case "r2":
+      return String(source.bucket ?? "");
+    case "webhook":
+      return String(source.path ?? "");
+    case "email":
+      return String(source.address ?? "");
+    default:
+      return "";
+  }
+}
+
+// src/commands/triggers/list.ts
+import pc10 from "picocolors";
+import {
+  loadConfig as loadConfig5,
+  scanTriggers as scanTriggers2,
+  buildTriggerManifest as buildTriggerManifest2
+} from "@cloudwerk/core/build";
+var SOURCE_TYPE_COLORS = {
+  scheduled: pc10.blue,
+  queue: pc10.green,
+  r2: pc10.yellow,
+  webhook: pc10.magenta,
+  email: pc10.cyan,
+  d1: pc10.red,
+  tail: pc10.gray
+};
+async function triggersList(options = {}) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig5(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for triggers in ${appDir}/triggers/...`);
+    const scanResult = await scanTriggers2(appDir, {
+      extensions: config.extensions
+    });
+    const manifest = buildTriggerManifest2(scanResult, appDir);
+    let triggers2 = manifest.triggers;
+    if (options.type) {
+      triggers2 = triggers2.filter((t) => t.source?.type === options.type);
+    }
+    if (options.json) {
+      console.log(JSON.stringify({
+        triggers: triggers2.map(formatTriggerJson),
+        count: triggers2.length,
+        errors: manifest.errors,
+        warnings: manifest.warnings
+      }, null, 2));
+      return;
+    }
+    console.log();
+    console.log(pc10.bold("Triggers"));
+    console.log();
+    if (triggers2.length === 0) {
+      if (options.type) {
+        console.log(pc10.dim(`  No triggers of type '${options.type}' found.`));
+      } else {
+        console.log(pc10.dim("  No triggers found."));
+      }
+      console.log();
+      return;
+    }
+    console.log(
+      `  ${pc10.dim("NAME".padEnd(25))} ${pc10.dim("TYPE".padEnd(12))} ${pc10.dim("SOURCE".padEnd(30))} ${pc10.dim("ERROR HANDLER")}`
+    );
+    console.log(pc10.dim("  " + "-".repeat(80)));
+    for (const trigger of triggers2) {
+      const color = SOURCE_TYPE_COLORS[trigger.source?.type ?? "unknown"] ?? pc10.dim;
+      const sourceType = trigger.source?.type ?? "unknown";
+      const sourceInfo = getSourceInfo2(trigger);
+      const hasError = trigger.hasOnError ? pc10.green("yes") : pc10.dim("no");
+      console.log(
+        `  ${pc10.cyan(trigger.name.padEnd(25))} ${color(sourceType.padEnd(12))} ${pc10.dim(sourceInfo.padEnd(30))} ${hasError}`
+      );
+    }
+    console.log();
+    console.log(pc10.dim(`  ${triggers2.length} trigger(s)`));
+    console.log();
+    if (manifest.errors.length > 0) {
+      console.log(pc10.red("Errors:"));
+      for (const error of manifest.errors) {
+        console.log(pc10.dim(`  - ${error.file}: ${error.message}`));
+      }
+      console.log();
+    }
+    if (manifest.warnings.length > 0) {
+      console.log(pc10.yellow("Warnings:"));
+      for (const warning of manifest.warnings) {
+        console.log(pc10.dim(`  - ${warning.file}: ${warning.message}`));
+      }
+      console.log();
+    }
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+function getSourceInfo2(trigger) {
+  const source = trigger.source;
+  if (!source) return "unknown";
+  switch (source.type) {
+    case "scheduled":
+      return source.cron;
+    case "queue":
+      return source.queue;
+    case "r2": {
+      const r2 = source;
+      return `${r2.bucket} (${r2.events.join(", ")})`;
+    }
+    case "webhook":
+      return source.path;
+    case "email":
+      return source.address;
+    default:
+      return source.type;
+  }
+}
+function formatTriggerJson(trigger) {
+  return {
+    name: trigger.name,
+    bindingName: trigger.bindingName,
+    filePath: trigger.filePath,
+    sourceType: trigger.source?.type,
+    source: trigger.source,
+    hasOnError: trigger.hasOnError,
+    retry: trigger.retry,
+    timeout: trigger.timeout,
+    fanOutGroup: trigger.fanOutGroup
+  };
+}
+
+// src/commands/triggers/validate.ts
+import pc11 from "picocolors";
+import {
+  loadConfig as loadConfig6,
+  scanTriggers as scanTriggers3,
+  buildTriggerManifest as buildTriggerManifest3,
+  hasTriggerErrors,
+  hasTriggerWarnings
+} from "@cloudwerk/core/build";
+async function triggersValidate(options = {}) {
+  const verbose = options.verbose ?? false;
+  const strict = options.strict ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig6(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for triggers in ${appDir}/triggers/...`);
+    const scanResult = await scanTriggers3(appDir, {
+      extensions: config.extensions
+    });
+    const manifest = buildTriggerManifest3(scanResult, appDir);
+    const hasErrors = hasTriggerErrors(manifest);
+    const hasWarnings = hasTriggerWarnings(manifest);
+    if (options.json) {
+      console.log(JSON.stringify({
+        valid: !hasErrors && (!strict || !hasWarnings),
+        triggerCount: manifest.triggers.length,
+        errors: manifest.errors,
+        warnings: manifest.warnings
+      }, null, 2));
+      if (hasErrors || strict && hasWarnings) {
+        process.exit(1);
+      }
+      return;
+    }
+    console.log();
+    console.log(pc11.bold("Validating Triggers"));
+    console.log();
+    if (manifest.triggers.length === 0) {
+      console.log(pc11.dim("  No triggers found to validate."));
+      console.log();
+      return;
+    }
+    for (const trigger of manifest.triggers) {
+      const triggerErrors = manifest.errors.filter(
+        (e) => e.file === trigger.filePath
+      );
+      const triggerWarnings = manifest.warnings.filter(
+        (w) => w.file === trigger.filePath
+      );
+      if (triggerErrors.length > 0) {
+        console.log(`  ${pc11.red("\u2717")} ${pc11.cyan(trigger.name)} ${pc11.dim(`(${trigger.filePath})`)}`);
+        for (const error of triggerErrors) {
+          console.log(`      ${pc11.red("error:")} ${error.message}`);
+        }
+      } else if (triggerWarnings.length > 0) {
+        console.log(`  ${pc11.yellow("!")} ${pc11.cyan(trigger.name)} ${pc11.dim(`(${trigger.filePath})`)}`);
+        for (const warning of triggerWarnings) {
+          console.log(`      ${pc11.yellow("warning:")} ${warning.message}`);
+        }
+      } else {
+        console.log(`  ${pc11.green("\u2713")} ${pc11.cyan(trigger.name)} ${pc11.dim("- valid")}`);
+      }
+    }
+    console.log();
+    const errorCount = manifest.errors.length;
+    const warningCount = manifest.warnings.length;
+    if (hasErrors) {
+      console.log(pc11.red(`  ${errorCount} error(s), ${warningCount} warning(s)`));
+      console.log();
+      process.exit(1);
+    } else if (hasWarnings) {
+      console.log(pc11.yellow(`  ${warningCount} warning(s)`));
+      console.log();
+      if (strict) {
+        process.exit(1);
+      }
+    } else {
+      console.log(pc11.green(`  All ${manifest.triggers.length} trigger(s) valid`));
+      console.log();
+    }
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/triggers/generate.ts
+import pc12 from "picocolors";
+import {
+  loadConfig as loadConfig7,
+  scanTriggers as scanTriggers4,
+  buildTriggerManifest as buildTriggerManifest4
+} from "@cloudwerk/core/build";
+
+// src/utils/trigger-wrangler.ts
+import * as fs11 from "fs";
+import * as path12 from "path";
+function generateCronToml(manifest, includeComments) {
+  const cronTriggers = manifest.triggers.filter(
+    (t) => t.source?.type === "scheduled"
+  );
+  if (cronTriggers.length === 0) {
+    return "";
+  }
+  const lines = [];
+  if (includeComments) {
+    lines.push("# Scheduled (Cron) Triggers");
+  }
+  lines.push("[triggers]");
+  const cronExpressions = /* @__PURE__ */ new Set();
+  for (const trigger of cronTriggers) {
+    const source = trigger.source;
+    cronExpressions.add(source.cron);
+  }
+  const crons = Array.from(cronExpressions).map((cron) => `"${cron}"`).join(", ");
+  lines.push(`crons = [${crons}]`);
+  return lines.join("\n");
+}
+function generateQueueConsumerToml(manifest, includeComments) {
+  const queueTriggers = manifest.triggers.filter(
+    (t) => t.source?.type === "queue"
+  );
+  if (queueTriggers.length === 0) {
+    return "";
+  }
+  const lines = [];
+  for (const trigger of queueTriggers) {
+    const source = trigger.source;
+    if (includeComments) {
+      lines.push(`# Queue trigger '${trigger.name}' (from app/triggers/${trigger.filePath})`);
+    }
+    lines.push("[[queues.consumers]]");
+    lines.push(`queue = "${source.queue}"`);
+    if (source.batch?.size !== void 0 && source.batch.size !== 10) {
+      lines.push(`max_batch_size = ${source.batch.size}`);
+    }
+    if (source.batch?.timeout !== void 0) {
+      const timeoutSeconds = parseDurationToSeconds(source.batch.timeout);
+      if (timeoutSeconds !== 5) {
+        lines.push(`max_batch_timeout = ${timeoutSeconds}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+function generateR2NotificationToml(manifest, includeComments) {
+  const r2Triggers = manifest.triggers.filter(
+    (t) => t.source?.type === "r2"
+  );
+  if (r2Triggers.length === 0) {
+    return "";
+  }
+  const lines = [];
+  const bucketTriggers = /* @__PURE__ */ new Map();
+  for (const trigger of r2Triggers) {
+    const source = trigger.source;
+    const existing = bucketTriggers.get(source.bucket) || [];
+    existing.push(trigger);
+    bucketTriggers.set(source.bucket, existing);
+  }
+  for (const [bucket, triggers2] of bucketTriggers) {
+    if (includeComments) {
+      const triggerNames = triggers2.map((t) => t.name).join(", ");
+      lines.push(`# R2 bucket notifications for '${bucket}' (triggers: ${triggerNames})`);
+    }
+    const eventTypes = /* @__PURE__ */ new Set();
+    let prefix;
+    let suffix;
+    for (const trigger of triggers2) {
+      const source = trigger.source;
+      for (const event of source.events) {
+        eventTypes.add(event);
+      }
+      if (!prefix && source.prefix) prefix = source.prefix;
+      if (!suffix && source.suffix) suffix = source.suffix;
+    }
+    lines.push("[[r2_buckets]]");
+    lines.push(`binding = "${bucket.toUpperCase()}_BUCKET"`);
+    lines.push(`bucket_name = "${bucket}"`);
+    lines.push("");
+    lines.push("[[r2_buckets.event_notifications.rules]]");
+    if (prefix) {
+      lines.push(`prefix = "${prefix}"`);
+    }
+    if (suffix) {
+      lines.push(`suffix = "${suffix}"`);
+    }
+    const actions = [];
+    if (eventTypes.has("object-create")) {
+      actions.push('"PutObject"', '"CopyObject"', '"CompleteMultipartUpload"');
+    }
+    if (eventTypes.has("object-delete")) {
+      actions.push('"DeleteObject"');
+    }
+    if (actions.length > 0) {
+      lines.push(`actions = [${actions.join(", ")}]`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+function parseDurationToSeconds(duration) {
+  if (typeof duration === "number") {
+    return duration;
+  }
+  const match = duration.match(/^(\d+)(s|m|h)$/);
+  if (!match) {
+    return 5;
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return value;
+    case "m":
+      return value * 60;
+    case "h":
+      return value * 3600;
+    default:
+      return 5;
+  }
+}
+function generateTriggerToml(manifest, includeComments = true) {
+  if (manifest.triggers.length === 0) {
+    return "";
+  }
+  const lines = [];
+  if (includeComments) {
+    lines.push("# ============================================================================");
+    lines.push("# Cloudwerk Triggers - Auto-generated from app/triggers/");
+    lines.push("# ============================================================================");
+    lines.push("");
+  }
+  const cronToml = generateCronToml(manifest, includeComments);
+  if (cronToml) {
+    lines.push(cronToml);
+    lines.push("");
+  }
+  const queueToml = generateQueueConsumerToml(manifest, includeComments);
+  if (queueToml) {
+    lines.push(queueToml);
+    lines.push("");
+  }
+  const r2Toml = generateR2NotificationToml(manifest, includeComments);
+  if (r2Toml) {
+    lines.push(r2Toml);
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+var TRIGGER_SECTION_START = "# ============================================================================";
+var TRIGGER_SECTION_MARKER = "# Cloudwerk Triggers - Auto-generated";
+function hasTriggerSection(content) {
+  return content.includes(TRIGGER_SECTION_MARKER);
+}
+function removeTriggerSection(content) {
+  const startIndex = content.indexOf(TRIGGER_SECTION_START);
+  if (startIndex === -1 || !content.includes(TRIGGER_SECTION_MARKER)) {
+    return content;
+  }
+  const lines = content.split("\n");
+  let sectionStartLine = -1;
+  let sectionEndLine = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(TRIGGER_SECTION_MARKER)) {
+      sectionStartLine = i > 0 && lines[i - 1].includes("===") ? i - 1 : i;
+      break;
+    }
+  }
+  if (sectionStartLine === -1) {
+    return content;
+  }
+  for (let i = sectionStartLine + 2; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "" || line.startsWith("#")) {
+      continue;
+    }
+    if (line.startsWith("[[") || line.startsWith("[")) {
+      if (line.includes("triggers") || line.includes("queues.consumers") || line.includes("r2_buckets")) {
+        continue;
+      }
+      sectionEndLine = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, sectionStartLine);
+  const after = lines.slice(sectionEndLine);
+  while (before.length > 0 && before[before.length - 1].trim() === "") {
+    before.pop();
+  }
+  return [...before, "", ...after].join("\n");
+}
+function generateTriggerWrangler(cwd, manifest, options = {}) {
+  const { dryRun = false, includeComments = true } = options;
+  const wranglerPath = findWranglerToml(cwd) || path12.join(cwd, "wrangler.toml");
+  const generatedToml = generateTriggerToml(manifest, includeComments);
+  const result = {
+    wranglerPath,
+    changed: false,
+    triggers: manifest.triggers.map((t) => ({
+      name: t.name,
+      sourceType: t.source?.type ?? "unknown",
+      bindingName: t.bindingName
+    })),
+    generatedToml
+  };
+  if (manifest.triggers.length === 0) {
+    return result;
+  }
+  if (dryRun) {
+    result.changed = true;
+    return result;
+  }
+  let content = "";
+  if (fs11.existsSync(wranglerPath)) {
+    content = readWranglerTomlRaw(cwd);
+  }
+  if (hasTriggerSection(content)) {
+    content = removeTriggerSection(content);
+  }
+  const newContent = content.trim() + "\n\n" + generatedToml + "\n";
+  writeWranglerTomlRaw(cwd, newContent);
+  result.changed = true;
+  return result;
+}
+
+// src/utils/trigger-type-generator.ts
+import * as fs12 from "fs";
+import * as path13 from "path";
+var CLOUDWERK_TYPES_DIR2 = ".cloudwerk/types";
+var TRIGGERS_DTS = "triggers.d.ts";
+function generateTriggerTypes(cwd, manifest, options = {}) {
+  const includeTimestamp = options.includeTimestamp ?? true;
+  const typesDir = path13.join(cwd, CLOUDWERK_TYPES_DIR2);
+  fs12.mkdirSync(typesDir, { recursive: true });
+  const triggersPath = path13.join(typesDir, TRIGGERS_DTS);
+  const triggersContent = generateTriggersDts(manifest.triggers, includeTimestamp);
+  fs12.writeFileSync(triggersPath, triggersContent, "utf-8");
+  const triggerInfo = manifest.triggers.map((t) => ({
+    name: t.name,
+    bindingName: t.bindingName,
+    sourceType: t.source?.type ?? "unknown"
+  }));
+  return {
+    typesDir,
+    file: triggersPath,
+    triggerCount: manifest.triggers.length,
+    triggers: triggerInfo
+  };
+}
+function generateTriggersDts(triggers2, includeTimestamp) {
+  const lines = [];
+  lines.push("// Auto-generated by cloudwerk triggers - DO NOT EDIT");
+  if (includeTimestamp) {
+    lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  }
+  lines.push("//");
+  lines.push("// This file provides type information for triggers");
+  lines.push('// Add ".cloudwerk/types" to your tsconfig.json include array');
+  lines.push("");
+  lines.push("import type { EmitOptions, EmitResult } from '@cloudwerk/trigger'");
+  lines.push("");
+  const scheduled = triggers2.filter((t) => t.source?.type === "scheduled");
+  const queue = triggers2.filter((t) => t.source?.type === "queue");
+  const r2 = triggers2.filter((t) => t.source?.type === "r2");
+  const webhook = triggers2.filter((t) => t.source?.type === "webhook");
+  const email = triggers2.filter((t) => t.source?.type === "email");
+  lines.push("// ============================================================================");
+  lines.push("// Trigger Names");
+  lines.push("// ============================================================================");
+  lines.push("");
+  const allNames = triggers2.map((t) => `'${t.name}'`);
+  if (allNames.length > 0) {
+    lines.push(`type TriggerName = ${allNames.join(" | ")}`);
+  } else {
+    lines.push("type TriggerName = never");
+  }
+  lines.push("");
+  if (scheduled.length > 0) {
+    const names = scheduled.map((t) => `'${t.name}'`);
+    lines.push(`type ScheduledTriggerName = ${names.join(" | ")}`);
+  }
+  if (queue.length > 0) {
+    const names = queue.map((t) => `'${t.name}'`);
+    lines.push(`type QueueTriggerName = ${names.join(" | ")}`);
+  }
+  if (r2.length > 0) {
+    const names = r2.map((t) => `'${t.name}'`);
+    lines.push(`type R2TriggerName = ${names.join(" | ")}`);
+  }
+  if (webhook.length > 0) {
+    const names = webhook.map((t) => `'${t.name}'`);
+    lines.push(`type WebhookTriggerName = ${names.join(" | ")}`);
+  }
+  if (email.length > 0) {
+    const names = email.map((t) => `'${t.name}'`);
+    lines.push(`type EmailTriggerName = ${names.join(" | ")}`);
+  }
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Trigger Registry");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push("interface TriggerRegistry {");
+  for (const trigger of triggers2) {
+    const sourceType = trigger.source?.type ?? "unknown";
+    lines.push(`  /** ${sourceType} trigger: ${trigger.name} */`);
+    lines.push(`  '${trigger.name}': {`);
+    lines.push(`    name: '${trigger.name}'`);
+    lines.push(`    bindingName: '${trigger.bindingName}'`);
+    lines.push(`    sourceType: '${sourceType}'`);
+    lines.push("  }");
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Module Augmentation");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push("declare module '@cloudwerk/trigger' {");
+  lines.push("  /**");
+  lines.push("   * Type-safe emit to other triggers.");
+  lines.push("   * Only triggers defined in app/triggers/ are valid targets.");
+  lines.push("   */");
+  lines.push("  export function emit<T extends TriggerName>(");
+  lines.push("    trigger: T,");
+  lines.push("    payload: unknown,");
+  lines.push("    options?: EmitOptions");
+  lines.push("  ): Promise<EmitResult>");
+  lines.push("");
+  lines.push("  /** Get list of all trigger names */");
+  lines.push("  export function getTriggerNames(): TriggerName[]");
+  lines.push("");
+  lines.push("  /** Check if a trigger exists */");
+  lines.push("  export function triggerExists(name: string): name is TriggerName");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/triggers/generate.ts
+async function triggersGenerate(options = {}) {
+  const verbose = options.verbose ?? false;
+  const dryRun = options.dryRun ?? false;
+  const logger = createLogger(verbose);
+  const generateWrangler = options.wrangler ?? !options.types;
+  const generateTypes = options.types ?? !options.wrangler;
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig7(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for triggers in ${appDir}/triggers/...`);
+    const scanResult = await scanTriggers4(appDir, {
+      extensions: config.extensions
+    });
+    const manifest = buildTriggerManifest4(scanResult, appDir);
+    if (options.json) {
+      const result = {
+        triggerCount: manifest.triggers.length,
+        dryRun
+      };
+      if (generateWrangler) {
+        const wranglerResult = generateTriggerWrangler(cwd, manifest, { dryRun });
+        result.wrangler = {
+          path: wranglerResult.wranglerPath,
+          changed: wranglerResult.changed,
+          triggers: wranglerResult.triggers,
+          generatedToml: dryRun ? wranglerResult.generatedToml : void 0
+        };
+      }
+      if (generateTypes) {
+        const typesResult = generateTriggerTypes(cwd, manifest, { includeTimestamp: !dryRun });
+        result.types = {
+          path: typesResult.file,
+          triggerCount: typesResult.triggerCount,
+          triggers: typesResult.triggers
+        };
+      }
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log();
+    console.log(pc12.bold("Generating Trigger Configuration"));
+    console.log();
+    if (manifest.triggers.length === 0) {
+      console.log(pc12.dim("  No triggers found. Nothing to generate."));
+      console.log();
+      return;
+    }
+    console.log(pc12.dim(`  Found ${manifest.triggers.length} trigger(s)`));
+    console.log();
+    if (generateWrangler) {
+      const wranglerResult = generateTriggerWrangler(cwd, manifest, {
+        dryRun,
+        includeComments: true
+      });
+      if (dryRun) {
+        console.log(pc12.cyan("  wrangler.toml (dry run):"));
+        console.log();
+        const lines = wranglerResult.generatedToml.split("\n");
+        for (const line of lines) {
+          console.log(`    ${line}`);
+        }
+        console.log();
+      } else {
+        console.log(`  ${pc12.green("\u2713")} Updated ${pc12.dim(wranglerResult.wranglerPath)}`);
+        for (const trigger of wranglerResult.triggers) {
+          console.log(pc12.dim(`      - ${trigger.name} (${trigger.sourceType})`));
+        }
+      }
+    }
+    if (generateTypes) {
+      if (!dryRun) {
+        const typesResult = generateTriggerTypes(cwd, manifest, { includeTimestamp: true });
+        console.log(`  ${pc12.green("\u2713")} Generated ${pc12.dim(typesResult.file)}`);
+        console.log(pc12.dim(`      - ${typesResult.triggerCount} trigger type(s)`));
+      } else {
+        console.log(pc12.cyan("  TypeScript types (dry run):"));
+        console.log(pc12.dim(`      Would generate .cloudwerk/types/triggers.d.ts`));
+      }
+    }
+    console.log();
+    if (!dryRun && generateTypes) {
+      console.log(pc12.dim('  Tip: Add ".cloudwerk/types" to your tsconfig.json include array'));
+      console.log();
+    }
+    if (manifest.errors.length > 0) {
+      console.log(pc12.red("Errors:"));
+      for (const error of manifest.errors) {
+        console.log(pc12.dim(`  - ${error.file}: ${error.message}`));
+      }
+      console.log();
+    }
+    if (manifest.warnings.length > 0) {
+      console.log(pc12.yellow("Warnings:"));
+      for (const warning of manifest.warnings) {
+        console.log(pc12.dim(`  - ${warning.file}: ${warning.message}`));
+      }
+      console.log();
+    }
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/objects.ts
+import pc13 from "picocolors";
+import {
+  loadConfig as loadConfig8,
+  scanDurableObjects,
+  buildDurableObjectManifest
+} from "@cloudwerk/core/build";
+async function objects(options = {}) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig8(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for durable objects in ${appDir}/objects/...`);
+    const scanResult = await scanDurableObjects(appDir, {
+      extensions: config.extensions
+    });
+    const manifest = buildDurableObjectManifest(scanResult, appDir);
+    console.log();
+    console.log(pc13.bold("Cloudwerk Durable Objects"));
+    console.log();
+    const sqliteCount = manifest.durableObjects.filter((o) => o.sqlite).length;
+    const regularCount = manifest.durableObjects.length - sqliteCount;
+    console.log(pc13.dim(`  Found ${manifest.durableObjects.length} durable objects:`));
+    if (manifest.durableObjects.length > 0) {
+      console.log(pc13.dim(`    - ${sqliteCount} with SQLite storage`));
+      console.log(pc13.dim(`    - ${regularCount} with KV storage`));
+    }
+    console.log();
+    if (manifest.durableObjects.length > 0) {
+      for (const obj of manifest.durableObjects) {
+        const storage = obj.sqlite ? pc13.yellow("SQLite") : pc13.green("KV");
+        const methods = obj.methodNames.length > 0 ? pc13.dim(`${obj.methodNames.length} methods`) : pc13.dim("no methods");
+        console.log(
+          `    ${pc13.cyan(obj.className)} ${pc13.dim("(")}${storage}${pc13.dim(", ")}${methods}${pc13.dim(")")}`
+        );
+      }
+      console.log();
+    }
+    console.log(pc13.bold("Commands:"));
+    console.log();
+    console.log(pc13.dim("  cloudwerk objects list           ") + "List all durable objects");
+    console.log(pc13.dim("  cloudwerk objects info <name>    ") + "Show durable object details");
+    console.log(pc13.dim("  cloudwerk objects migrations     ") + "Show migration history");
+    console.log(pc13.dim("  cloudwerk objects generate       ") + "Regenerate wrangler config");
+    console.log();
+    if (manifest.durableObjects.length === 0) {
+      console.log(pc13.bold("Quick Start:"));
+      console.log();
+      console.log(pc13.dim("  Create a durable object at app/objects/counter.ts:"));
+      console.log();
+      console.log(pc13.cyan("    import { defineDurableObject } from '@cloudwerk/durable-object'"));
+      console.log();
+      console.log(pc13.cyan("    interface CounterState { value: number }"));
+      console.log();
+      console.log(pc13.cyan("    export default defineDurableObject<CounterState>({"));
+      console.log(pc13.cyan("      init: () => ({ value: 0 }),"));
+      console.log();
+      console.log(pc13.cyan("      methods: {"));
+      console.log(pc13.cyan("        async increment(amount = 1) {"));
+      console.log(pc13.cyan("          this.state.value += amount"));
+      console.log(pc13.cyan("          return this.state.value"));
+      console.log(pc13.cyan("        }"));
+      console.log(pc13.cyan("      }"));
+      console.log(pc13.cyan("    })"));
+      console.log();
+      console.log(pc13.dim("  Then use it in your routes:"));
+      console.log();
+      console.log(pc13.cyan("    import { durableObjects } from '@cloudwerk/core/bindings'"));
+      console.log();
+      console.log(pc13.cyan("    export async function POST(request, { params }) {"));
+      console.log(pc13.cyan("      const id = durableObjects.Counter.idFromName(params.id)"));
+      console.log(pc13.cyan("      const counter = durableObjects.Counter.get(id)"));
+      console.log(pc13.cyan("      const value = await counter.increment(1)"));
+      console.log(pc13.cyan("      return Response.json({ value })"));
+      console.log(pc13.cyan("    }"));
+      console.log();
+    }
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/objects/list.ts
+import pc14 from "picocolors";
+import {
+  loadConfig as loadConfig9,
+  scanDurableObjects as scanDurableObjects2,
+  buildDurableObjectManifest as buildDurableObjectManifest2
+} from "@cloudwerk/core/build";
+async function objectsList(options = {}) {
+  const verbose = options.verbose ?? false;
+  const format = options.format ?? "table";
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig9(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for durable objects in ${appDir}/objects/...`);
+    const scanResult = await scanDurableObjects2(appDir, {
+      extensions: config.extensions
+    });
+    const manifest = buildDurableObjectManifest2(scanResult, appDir);
+    if (format === "json") {
+      console.log(JSON.stringify(manifest, null, 2));
+      return;
+    }
+    console.log();
+    console.log(
+      pc14.bold("Durable Objects") + pc14.dim(` (${manifest.durableObjects.length} found):`)
+    );
+    console.log();
+    if (manifest.durableObjects.length === 0) {
+      console.log(pc14.dim("  No durable objects found."));
+      console.log();
+      console.log(pc14.dim("  Create a durable object at app/objects/counter.ts:"));
+      console.log();
+      console.log(pc14.dim("    import { defineDurableObject } from '@cloudwerk/durable-object'"));
+      console.log(pc14.dim("    export default defineDurableObject({"));
+      console.log(pc14.dim("      methods: {"));
+      console.log(pc14.dim("        async increment(amount) { ... }"));
+      console.log(pc14.dim("      }"));
+      console.log(pc14.dim("    })"));
+      console.log();
+      return;
+    }
+    console.log(
+      pc14.dim(
+        "  Class              Binding              Storage   Methods  Handlers"
+      )
+    );
+    console.log(
+      pc14.dim(
+        "  " + "\u2500".repeat(18) + "  " + "\u2500".repeat(18) + "  " + "\u2500".repeat(7) + "  " + "\u2500".repeat(7) + "  " + "\u2500".repeat(20)
+      )
+    );
+    for (const obj of manifest.durableObjects) {
+      const className = obj.className.padEnd(18);
+      const binding = obj.bindingName.padEnd(18);
+      const storage = obj.sqlite ? pc14.yellow("SQLite ") : pc14.green("KV     ");
+      const methods = obj.methodNames.length.toString().padEnd(7);
+      const handlers = [];
+      if (obj.hasFetch) handlers.push("fetch");
+      if (obj.hasAlarm) handlers.push("alarm");
+      if (obj.hasWebSocket) handlers.push("websocket");
+      const handlersStr = handlers.length > 0 ? handlers.join(", ") : pc14.dim("none");
+      console.log(
+        `  ${pc14.cyan(className)}  ${pc14.dim(binding)}  ${storage}  ${methods}  ${handlersStr}`
+      );
+    }
+    console.log();
+    if (manifest.errors.length > 0) {
+      console.log(pc14.red("Errors:"));
+      for (const error of manifest.errors) {
+        console.log(pc14.red(`  - ${error.file}: ${error.message}`));
+      }
+      console.log();
+    }
+    if (manifest.warnings.length > 0) {
+      console.log(pc14.yellow("Warnings:"));
+      for (const warning of manifest.warnings) {
+        console.log(pc14.yellow(`  - ${warning.file}: ${warning.message}`));
+      }
+      console.log();
+    }
+    console.log(pc14.dim("Use 'cloudwerk objects info <name>' for details."));
+    console.log(pc14.dim("Use 'cloudwerk objects generate' to update wrangler.toml."));
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/objects/info.ts
+import pc15 from "picocolors";
+import {
+  loadConfig as loadConfig10,
+  scanDurableObjects as scanDurableObjects3,
+  buildDurableObjectManifest as buildDurableObjectManifest3
+} from "@cloudwerk/core/build";
+async function objectsInfo(name, options = {}) {
+  const verbose = options.verbose ?? false;
+  const format = options.format ?? "table";
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig10(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for durable objects in ${appDir}/objects/...`);
+    const scanResult = await scanDurableObjects3(appDir, {
+      extensions: config.extensions
+    });
+    const manifest = buildDurableObjectManifest3(scanResult, appDir);
+    const obj = manifest.durableObjects.find(
+      (o) => o.name === name || o.className === name || o.bindingName === name
+    );
+    if (!obj) {
+      console.log();
+      console.log(pc15.red(`Durable object '${name}' not found.`));
+      console.log();
+      if (manifest.durableObjects.length > 0) {
+        console.log(pc15.dim("Available durable objects:"));
+        for (const o of manifest.durableObjects) {
+          console.log(pc15.dim(`  - ${o.className} (${o.name})`));
+        }
+      } else {
+        console.log(pc15.dim("No durable objects found in app/objects/."));
+      }
+      console.log();
+      return;
+    }
+    if (format === "json") {
+      console.log(JSON.stringify(obj, null, 2));
+      return;
+    }
+    console.log();
+    console.log(pc15.bold(`Durable Object: ${obj.className}`));
+    console.log();
+    console.log(pc15.dim("  Configuration:"));
+    console.log(`    Name:         ${pc15.cyan(obj.name)}`);
+    console.log(`    Class:        ${pc15.cyan(obj.className)}`);
+    console.log(`    Binding:      ${pc15.yellow(obj.bindingName)}`);
+    console.log(`    File:         ${pc15.dim(obj.filePath)}`);
+    console.log(
+      `    Storage:      ${obj.sqlite ? pc15.yellow("SQLite") : pc15.green("KV")}`
+    );
+    console.log();
+    console.log(pc15.dim("  Handlers:"));
+    console.log(
+      `    fetch:        ${obj.hasFetch ? pc15.green("yes") : pc15.dim("no")}`
+    );
+    console.log(
+      `    alarm:        ${obj.hasAlarm ? pc15.green("yes") : pc15.dim("no")}`
+    );
+    console.log(
+      `    webSocket:    ${obj.hasWebSocket ? pc15.green("yes") : pc15.dim("no")}`
+    );
+    console.log();
+    console.log(pc15.dim("  RPC Methods:"));
+    if (obj.methodNames.length > 0) {
+      for (const method of obj.methodNames) {
+        console.log(`    - ${pc15.cyan(method)}()`);
+      }
+    } else {
+      console.log(pc15.dim("    No RPC methods defined"));
+    }
+    console.log();
+    console.log(pc15.dim("  wrangler.toml binding:"));
+    console.log();
+    console.log(pc15.cyan("    [durable_objects]"));
+    console.log(pc15.cyan("    bindings = ["));
+    console.log(
+      pc15.cyan(
+        `      { name = "${obj.bindingName}", class_name = "${obj.className}" }`
+      )
+    );
+    console.log(pc15.cyan("    ]"));
+    console.log();
+    console.log(pc15.cyan("    [[migrations]]"));
+    console.log(pc15.cyan('    tag = "v1"'));
+    if (obj.sqlite) {
+      console.log(pc15.cyan(`    new_sqlite_classes = ["${obj.className}"]`));
+    } else {
+      console.log(pc15.cyan(`    new_classes = ["${obj.className}"]`));
+    }
+    console.log();
+    console.log(pc15.dim("  Usage in routes:"));
+    console.log();
+    console.log(pc15.cyan("    import { durableObjects } from '@cloudwerk/core/bindings'"));
+    console.log();
+    console.log(pc15.cyan("    export async function POST(request, { params }) {"));
+    console.log(
+      pc15.cyan(`      const id = durableObjects.${obj.className}.idFromName(params.id)`)
+    );
+    console.log(
+      pc15.cyan(`      const stub = durableObjects.${obj.className}.get(id)`)
+    );
+    if (obj.methodNames.length > 0) {
+      console.log(
+        pc15.cyan(`      const result = await stub.${obj.methodNames[0]}()`)
+      );
+    } else if (obj.hasFetch) {
+      console.log(pc15.cyan("      const response = await stub.fetch(request)"));
+    }
+    console.log(pc15.cyan("      return Response.json({ result })"));
+    console.log(pc15.cyan("    }"));
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/objects/migrations.ts
+import pc16 from "picocolors";
+import {
+  loadConfig as loadConfig11,
+  scanDurableObjects as scanDurableObjects4,
+  buildDurableObjectManifest as buildDurableObjectManifest4
+} from "@cloudwerk/core/build";
+
+// src/utils/durable-object-wrangler.ts
+import * as fs13 from "fs";
+import * as path14 from "path";
+function generateBindingsToml(entries, includeComments) {
+  const lines = [];
+  if (includeComments) {
+    lines.push("# Durable object bindings");
+  }
+  lines.push("[durable_objects]");
+  lines.push("bindings = [");
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const comma = i < entries.length - 1 ? "," : "";
+    if (includeComments) {
+      lines.push(`  # ${entry.name} (from app/objects/${entry.filePath})`);
+    }
+    lines.push(`  { name = "${entry.bindingName}", class_name = "${entry.className}" }${comma}`);
+  }
+  lines.push("]");
+  return lines.join("\n");
+}
+function generateMigrationToml(entries, migrationTag, includeComments) {
+  const sqliteClasses = entries.filter((e) => e.sqlite).map((e) => e.className);
+  const regularClasses = entries.filter((e) => !e.sqlite).map((e) => e.className);
+  if (sqliteClasses.length === 0 && regularClasses.length === 0) {
+    return "";
+  }
+  const lines = [];
+  if (includeComments) {
+    lines.push("# Durable object migrations");
+  }
+  lines.push("[[migrations]]");
+  lines.push(`tag = "${migrationTag}"`);
+  if (sqliteClasses.length > 0) {
+    const classList = sqliteClasses.map((c) => `"${c}"`).join(", ");
+    lines.push(`new_sqlite_classes = [${classList}]`);
+  }
+  if (regularClasses.length > 0) {
+    const classList = regularClasses.map((c) => `"${c}"`).join(", ");
+    lines.push(`new_classes = [${classList}]`);
+  }
+  return lines.join("\n");
+}
+function generateDurableObjectToml(manifest, includeComments = true, migrationTag) {
+  if (manifest.durableObjects.length === 0) {
+    return "";
+  }
+  const lines = [];
+  if (includeComments) {
+    lines.push("# ============================================================================");
+    lines.push("# Cloudwerk Durable Objects - Auto-generated from app/objects/");
+    lines.push("# ============================================================================");
+    lines.push("");
+  }
+  lines.push(generateBindingsToml(manifest.durableObjects, includeComments));
+  lines.push("");
+  const tag = migrationTag || generateMigrationTag();
+  const migrationToml = generateMigrationToml(manifest.durableObjects, tag, includeComments);
+  if (migrationToml) {
+    lines.push(migrationToml);
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+function generateMigrationTag() {
+  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 hour = String(now.getHours()).padStart(2, "0");
+  const min = String(now.getMinutes()).padStart(2, "0");
+  return `v${year}${month}${day}${hour}${min}`;
+}
+function extractExistingMigrationTags(content) {
+  const tags = [];
+  const regex = /^\s*tag\s*=\s*"([^"]+)"/gm;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    tags.push(match[1]);
+  }
+  return tags;
+}
+var DO_SECTION_START = "# ============================================================================";
+var DO_SECTION_MARKER = "# Cloudwerk Durable Objects - Auto-generated";
+function hasDurableObjectSection(content) {
+  return content.includes(DO_SECTION_MARKER);
+}
+function removeDurableObjectSection(content) {
+  const startIndex = content.indexOf(DO_SECTION_START);
+  if (startIndex === -1 || !content.includes(DO_SECTION_MARKER)) {
+    return content;
+  }
+  const lines = content.split("\n");
+  let sectionStartLine = -1;
+  let sectionEndLine = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(DO_SECTION_MARKER)) {
+      sectionStartLine = i > 0 && lines[i - 1].includes("===") ? i - 1 : i;
+      break;
+    }
+  }
+  if (sectionStartLine === -1) {
+    return content;
+  }
+  for (let i = sectionStartLine + 2; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "" || line.startsWith("#")) {
+      continue;
+    }
+    if (line.startsWith("[[") && !line.includes("durable_objects") && !line.includes("migrations")) {
+      sectionEndLine = i;
+      break;
+    }
+    if (line.startsWith("[") && !line.startsWith("[[") && !line.includes("durable_objects")) {
+      sectionEndLine = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, sectionStartLine);
+  const after = lines.slice(sectionEndLine);
+  while (before.length > 0 && before[before.length - 1].trim() === "") {
+    before.pop();
+  }
+  return [...before, "", ...after].join("\n");
+}
+function generateDurableObjectWrangler(cwd, manifest, options = {}) {
+  const { dryRun = false, includeComments = true, migrationTag } = options;
+  const wranglerPath = findWranglerToml(cwd) || path14.join(cwd, "wrangler.toml");
+  const generatedToml = generateDurableObjectToml(manifest, includeComments, migrationTag);
+  const result = {
+    wranglerPath,
+    changed: false,
+    durableObjects: manifest.durableObjects.map((obj) => ({
+      name: obj.name,
+      bindingName: obj.bindingName,
+      className: obj.className
+    })),
+    generatedToml
+  };
+  if (manifest.durableObjects.length === 0) {
+    return result;
+  }
+  if (dryRun) {
+    result.changed = true;
+    return result;
+  }
+  let content = "";
+  if (fs13.existsSync(wranglerPath)) {
+    content = readWranglerTomlRaw(cwd);
+  }
+  if (hasDurableObjectSection(content)) {
+    content = removeDurableObjectSection(content);
+  }
+  const newContent = content.trim() + "\n\n" + generatedToml + "\n";
+  writeWranglerTomlRaw(cwd, newContent);
+  result.changed = true;
+  return result;
+}
+
+// src/commands/objects/migrations.ts
+async function objectsMigrations(options = {}) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig11(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for durable objects in ${appDir}/objects/...`);
+    const scanResult = await scanDurableObjects4(appDir, {
+      extensions: config.extensions
+    });
+    const manifest = buildDurableObjectManifest4(scanResult, appDir);
+    console.log();
+    console.log(pc16.bold("Durable Object Migrations"));
+    console.log();
+    const wranglerPath = findWranglerToml(cwd);
+    if (!wranglerPath) {
+      console.log(pc16.dim("  No wrangler.toml found."));
+      console.log();
+      console.log(pc16.dim("  Run 'cloudwerk objects generate' to create configuration."));
+      console.log();
+      return;
+    }
+    const content = readWranglerTomlRaw(cwd);
+    const tags = extractExistingMigrationTags(content);
+    if (tags.length === 0) {
+      console.log(pc16.dim("  No migrations found in wrangler.toml."));
+      console.log();
+      if (manifest.durableObjects.length > 0) {
+        console.log(pc16.dim("  Run 'cloudwerk objects generate' to create migrations."));
+        console.log();
+      }
+      return;
+    }
+    console.log(pc16.dim(`  Found ${tags.length} migration(s):`));
+    console.log();
+    for (let i = 0; i < tags.length; i++) {
+      const tag = tags[i];
+      const isLatest = i === tags.length - 1;
+      console.log(
+        `    ${isLatest ? pc16.green("\u25CF") : pc16.dim("\u25CB")} ${pc16.cyan(tag)}${isLatest ? pc16.green(" (current)") : ""}`
+      );
+    }
+    console.log();
+    console.log(pc16.dim("  Current durable objects:"));
+    console.log();
+    if (manifest.durableObjects.length === 0) {
+      console.log(pc16.dim("    No durable objects defined."));
+    } else {
+      for (const obj of manifest.durableObjects) {
+        const storage = obj.sqlite ? pc16.yellow("SQLite") : pc16.green("KV");
+        console.log(`    ${pc16.cyan(obj.className)} ${pc16.dim("(")}${storage}${pc16.dim(")")}`);
+      }
+    }
+    console.log();
+    console.log(pc16.dim("  Tips:"));
+    console.log(pc16.dim("    - Migrations are applied automatically on deploy"));
+    console.log(pc16.dim("    - Each tag should be unique and incremental"));
+    console.log(
+      pc16.dim("    - Deleting a class will delete all data for that class")
+    );
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/objects/generate.ts
+import pc17 from "picocolors";
+import {
+  loadConfig as loadConfig12,
+  scanDurableObjects as scanDurableObjects5,
+  buildDurableObjectManifest as buildDurableObjectManifest5
+} from "@cloudwerk/core/build";
+
+// src/utils/durable-object-type-generator.ts
+import * as fs14 from "fs";
+import * as path15 from "path";
+var CLOUDWERK_TYPES_DIR3 = ".cloudwerk/types";
+var DURABLE_OBJECTS_DTS = "durable-objects.d.ts";
+function generateDurableObjectTypes(cwd, manifest, options = {}) {
+  const includeTimestamp = options.includeTimestamp ?? true;
+  const typesDir = path15.join(cwd, CLOUDWERK_TYPES_DIR3);
+  fs14.mkdirSync(typesDir, { recursive: true });
+  const dtsPath = path15.join(typesDir, DURABLE_OBJECTS_DTS);
+  const dtsContent = generateDurableObjectsDts(manifest.durableObjects, includeTimestamp);
+  fs14.writeFileSync(dtsPath, dtsContent, "utf-8");
+  const objectInfo = manifest.durableObjects.map((obj) => ({
+    name: obj.name,
+    bindingName: obj.bindingName,
+    className: obj.className
+  }));
+  return {
+    typesDir,
+    file: dtsPath,
+    objectCount: manifest.durableObjects.length,
+    durableObjects: objectInfo
+  };
+}
+function generateDurableObjectsDts(durableObjects, includeTimestamp) {
+  const lines = [];
+  lines.push("// Auto-generated by cloudwerk objects - DO NOT EDIT");
+  if (includeTimestamp) {
+    lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  }
+  lines.push("//");
+  lines.push("// This file provides type information for durable object namespaces");
+  lines.push('// Add ".cloudwerk/types" to your tsconfig.json include array');
+  lines.push("");
+  lines.push("import type { DurableObjectNamespace, DurableObjectStub } from '@cloudwerk/core/bindings'");
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Durable Object Stub Interfaces");
+  lines.push("// ============================================================================");
+  lines.push("//");
+  lines.push("// Define method signatures for your durable objects.");
+  lines.push("// The RPC methods from your defineDurableObject() will be available on stubs.");
+  lines.push("//");
+  lines.push("");
+  for (const obj of durableObjects) {
+    lines.push(`/** Stub interface for the '${obj.name}' durable object */`);
+    lines.push(`interface ${obj.className}Stub extends DurableObjectStub {`);
+    if (obj.methodNames.length > 0) {
+      lines.push("  // RPC methods defined in app/objects/" + obj.filePath);
+      for (const methodName of obj.methodNames) {
+        lines.push(`  ${methodName}(...args: unknown[]): Promise<unknown>`);
+      }
+    } else {
+      lines.push("  // No RPC methods defined - add methods to defineDurableObject({ methods: { ... } })");
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  lines.push("// ============================================================================");
+  lines.push("// Durable Object Namespace Interfaces");
+  lines.push("// ============================================================================");
+  lines.push("");
+  for (const obj of durableObjects) {
+    lines.push(`/** Namespace for the '${obj.name}' durable object (binding: ${obj.bindingName}) */`);
+    lines.push(`interface ${obj.className}Namespace extends DurableObjectNamespace<${obj.className}Stub> {`);
+    lines.push(`  get(id: import('@cloudwerk/core/bindings').DurableObjectId): ${obj.className}Stub`);
+    lines.push("}");
+    lines.push("");
+  }
+  lines.push("// ============================================================================");
+  lines.push("// Combined Durable Objects Interface");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push("interface CloudwerkDurableObjects {");
+  for (const obj of durableObjects) {
+    lines.push(`  /** Durable object namespace for '${obj.name}' (binding: ${obj.bindingName}) */`);
+    lines.push(`  ${obj.className}: ${obj.className}Namespace`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Module Augmentation");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push("declare module '@cloudwerk/core/bindings' {");
+  lines.push("  /** Typed durable object namespaces based on app/objects/ definitions */");
+  lines.push("  export const durableObjects: CloudwerkDurableObjects");
+  lines.push("");
+  lines.push("  /** Get a typed durable object namespace by name */");
+  lines.push("  export function getDurableObject<K extends keyof CloudwerkDurableObjects>(");
+  lines.push("    name: K");
+  lines.push("  ): CloudwerkDurableObjects[K]");
+  lines.push("}");
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Env Type Extension");
+  lines.push("// ============================================================================");
+  lines.push("//");
+  lines.push("// Extend your Env type with these bindings:");
+  lines.push("//");
+  lines.push("// interface Env {");
+  for (const obj of durableObjects) {
+    lines.push(`//   ${obj.bindingName}: DurableObjectNamespace<${obj.className}Stub>`);
+  }
+  lines.push("// }");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/objects/generate.ts
+async function objectsGenerate(options = {}) {
+  const verbose = options.verbose ?? false;
+  const dryRun = options.dryRun ?? false;
+  const skipTypes = options.skipTypes ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig12(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for durable objects in ${appDir}/objects/...`);
+    const scanResult = await scanDurableObjects5(appDir, {
+      extensions: config.extensions
+    });
+    const manifest = buildDurableObjectManifest5(scanResult, appDir);
+    console.log();
+    console.log(pc17.bold("Generating Durable Object Configuration"));
+    console.log();
+    if (manifest.durableObjects.length === 0) {
+      console.log(pc17.dim("  No durable objects found."));
+      console.log();
+      console.log(pc17.dim("  Create a durable object at app/objects/counter.ts first."));
+      console.log();
+      return;
+    }
+    console.log(pc17.dim(`  Found ${manifest.durableObjects.length} durable object(s):`));
+    for (const obj of manifest.durableObjects) {
+      const storage = obj.sqlite ? pc17.yellow("SQLite") : pc17.green("KV");
+      console.log(`    - ${pc17.cyan(obj.className)} ${pc17.dim("(")}${storage}${pc17.dim(")")}`);
+    }
+    console.log();
+    if (dryRun) {
+      console.log(pc17.yellow("  Dry run - no files will be written."));
+      console.log();
+    }
+    console.log(pc17.dim("  Generating wrangler.toml bindings..."));
+    const wranglerResult = generateDurableObjectWrangler(cwd, manifest, {
+      dryRun,
+      includeComments: true
+    });
+    if (wranglerResult.changed) {
+      console.log(pc17.green(`    \u2713 Updated ${wranglerResult.wranglerPath}`));
+    } else {
+      console.log(pc17.dim("    No changes needed"));
+    }
+    if (!skipTypes) {
+      console.log();
+      console.log(pc17.dim("  Generating TypeScript types..."));
+      if (!dryRun) {
+        const typesResult = generateDurableObjectTypes(cwd, manifest);
+        console.log(pc17.green(`    \u2713 Generated ${typesResult.file}`));
+      } else {
+        console.log(pc17.dim("    Would generate .cloudwerk/types/durable-objects.d.ts"));
+      }
+    }
+    console.log();
+    if (verbose || dryRun) {
+      console.log(pc17.dim("  Generated wrangler.toml section:"));
+      console.log();
+      for (const line of wranglerResult.generatedToml.split("\n")) {
+        console.log(pc17.cyan(`    ${line}`));
+      }
+      console.log();
+    }
+    if (manifest.errors.length > 0) {
+      console.log(pc17.red("  Errors:"));
+      for (const error of manifest.errors) {
+        console.log(pc17.red(`    - ${error.file}: ${error.message}`));
+      }
+      console.log();
+    }
+    if (manifest.warnings.length > 0) {
+      console.log(pc17.yellow("  Warnings:"));
+      for (const warning of manifest.warnings) {
+        console.log(pc17.yellow(`    - ${warning.file}: ${warning.message}`));
+      }
+      console.log();
+    }
+    if (!dryRun) {
+      console.log(pc17.green("  Configuration generated successfully!"));
+      console.log();
+      console.log(pc17.dim("  Next steps:"));
+      console.log(pc17.dim("    1. Review wrangler.toml for correctness"));
+      console.log(pc17.dim("    2. Add .cloudwerk/types to your tsconfig.json include"));
+      console.log(pc17.dim("    3. Run 'pnpm dev' to test locally"));
+      console.log(pc17.dim("    4. Run 'pnpm deploy' to deploy to Cloudflare"));
+      console.log();
+    }
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/services.ts
+import pc18 from "picocolors";
+import { loadConfig as loadConfig13, scanServices as scanServices2, buildServiceManifest as buildServiceManifest2 } from "@cloudwerk/core/build";
+async function services(options = {}) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig13(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for services in ${appDir}/services/...`);
+    const scanResult = await scanServices2(appDir, { extensions: config.extensions });
+    const manifest = buildServiceManifest2(scanResult, appDir);
+    console.log();
+    console.log(pc18.bold("Cloudwerk Services"));
+    console.log();
+    const localCount = manifest.services.filter((s) => s.mode === "local").length;
+    const extractedCount = manifest.services.filter((s) => s.mode === "extracted").length;
+    console.log(pc18.dim(`  Found ${manifest.services.length} services:`));
+    if (manifest.services.length > 0) {
+      console.log(pc18.dim(`    - ${localCount} local (direct calls)`));
+      console.log(pc18.dim(`    - ${extractedCount} extracted (separate Workers)`));
+    }
+    console.log();
+    if (manifest.services.length > 0) {
+      for (const service of manifest.services) {
+        const mode = service.mode === "extracted" ? pc18.yellow("extracted") : pc18.green("local");
+        console.log(`    ${pc18.cyan(service.name)} ${pc18.dim("(")}${mode}${pc18.dim(")")}`);
+      }
+      console.log();
+    }
+    console.log(pc18.bold("Commands:"));
+    console.log();
+    console.log(pc18.dim("  cloudwerk services list           ") + "List all services");
+    console.log(pc18.dim("  cloudwerk services info <name>    ") + "Show service details");
+    console.log(pc18.dim("  cloudwerk services extract <name> ") + "Extract to separate Worker");
+    console.log(pc18.dim("  cloudwerk services inline <name>  ") + "Convert back to local mode");
+    console.log(pc18.dim("  cloudwerk services deploy <name>  ") + "Deploy extracted service");
+    console.log(pc18.dim("  cloudwerk services status         ") + "Show all services status");
+    console.log();
+    if (manifest.services.length === 0) {
+      console.log(pc18.bold("Quick Start:"));
+      console.log();
+      console.log(pc18.dim("  Create a service at app/services/<name>/service.ts:"));
+      console.log();
+      console.log(pc18.cyan("    import { defineService } from '@cloudwerk/service'"));
+      console.log();
+      console.log(pc18.cyan("    export default defineService({"));
+      console.log(pc18.cyan("      methods: {"));
+      console.log(pc18.cyan("        async send({ to, subject, body }) {"));
+      console.log(pc18.cyan("          // Your service logic here"));
+      console.log(pc18.cyan("          return { success: true }"));
+      console.log(pc18.cyan("        }"));
+      console.log(pc18.cyan("      }"));
+      console.log(pc18.cyan("    })"));
+      console.log();
+      console.log(pc18.dim("  Then use it in your routes:"));
+      console.log();
+      console.log(pc18.cyan("    import { services } from '@cloudwerk/core/bindings'"));
+      console.log();
+      console.log(pc18.cyan("    export async function POST() {"));
+      console.log(pc18.cyan("      const result = await services.email.send({ to: '...' })"));
+      console.log(pc18.cyan("      return json(result)"));
+      console.log(pc18.cyan("    }"));
+      console.log();
+    }
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/services/list.ts
+import pc19 from "picocolors";
+import { loadConfig as loadConfig14, scanServices as scanServices3, buildServiceManifest as buildServiceManifest3 } from "@cloudwerk/core/build";
+async function servicesList(options = {}) {
+  const verbose = options.verbose ?? false;
+  const format = options.format ?? "table";
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig14(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for services in ${appDir}/services/...`);
+    const scanResult = await scanServices3(appDir, { extensions: config.extensions });
+    const manifest = buildServiceManifest3(scanResult, appDir);
+    if (format === "json") {
+      console.log(JSON.stringify(manifest, null, 2));
+      return;
+    }
+    console.log();
+    console.log(pc19.bold("Services") + pc19.dim(` (${manifest.services.length} found):`));
+    console.log();
+    if (manifest.services.length === 0) {
+      console.log(pc19.dim("  No services found."));
+      console.log();
+      console.log(pc19.dim("  Create a service at app/services/<name>/service.ts:"));
+      console.log();
+      console.log(pc19.dim("    import { defineService } from '@cloudwerk/service'"));
+      console.log(pc19.dim("    export default defineService({"));
+      console.log(pc19.dim("      methods: {"));
+      console.log(pc19.dim("        async myMethod(params) { ... }"));
+      console.log(pc19.dim("      }"));
+      console.log(pc19.dim("    })"));
+      console.log();
+      return;
+    }
+    console.log(pc19.dim("  Name              Mode       Methods  Bindings"));
+    console.log(pc19.dim("  " + "\u2500".repeat(16) + "  " + "\u2500".repeat(9) + "  " + "\u2500".repeat(7) + "  " + "\u2500".repeat(20)));
+    for (const service of manifest.services) {
+      const name = service.name.padEnd(16);
+      const mode = service.mode === "extracted" ? pc19.yellow("extracted") : pc19.green("local    ");
+      const methods = service.methodNames.length.toString().padEnd(7);
+      const bindings2 = service.requiredBindings.length > 0 ? service.requiredBindings.join(", ") : pc19.dim("none");
+      console.log(`  ${pc19.cyan(name)}  ${mode}  ${methods}  ${bindings2}`);
+    }
+    console.log();
+    if (manifest.errors.length > 0) {
+      console.log(pc19.red("Errors:"));
+      for (const error of manifest.errors) {
+        console.log(pc19.red(`  - ${error.file}: ${error.message}`));
+      }
+      console.log();
+    }
+    if (manifest.warnings.length > 0) {
+      console.log(pc19.yellow("Warnings:"));
+      for (const warning of manifest.warnings) {
+        console.log(pc19.yellow(`  - ${warning.file}: ${warning.message}`));
+      }
+      console.log();
+    }
+    console.log(pc19.dim("Use 'cloudwerk services info <name>' for details."));
+    console.log(pc19.dim("Use 'cloudwerk services extract <name>' to extract a service."));
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/services/info.ts
+import pc20 from "picocolors";
+import { loadConfig as loadConfig15, scanServices as scanServices4, buildServiceManifest as buildServiceManifest4 } from "@cloudwerk/core/build";
+async function servicesInfo(serviceName, options = {}) {
+  const verbose = options.verbose ?? false;
+  const format = options.format ?? "text";
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig15(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for services in ${appDir}/services/...`);
+    const scanResult = await scanServices4(appDir, { extensions: config.extensions });
+    const manifest = buildServiceManifest4(scanResult, appDir);
+    const service = manifest.services.find((s) => s.name === serviceName);
+    if (!service) {
+      const available = manifest.services.map((s) => s.name);
+      throw new CliError(
+        `Service '${serviceName}' not found`,
+        "ENOENT",
+        available.length > 0 ? `Available services: ${available.join(", ")}` : "No services found in app/services/"
+      );
+    }
+    if (format === "json") {
+      console.log(JSON.stringify(service, null, 2));
+      return;
+    }
+    console.log();
+    console.log(pc20.bold(`Service: ${service.name}`));
+    console.log();
+    console.log(pc20.dim("  Location:     ") + service.filePath);
+    console.log(pc20.dim("  Mode:         ") + (service.mode === "extracted" ? pc20.yellow("extracted") : pc20.green("local")));
+    console.log(pc20.dim("  Binding:      ") + service.bindingName);
+    console.log(pc20.dim("  Worker Name:  ") + service.workerName);
+    console.log(pc20.dim("  Entrypoint:   ") + service.entrypointClass);
+    console.log();
+    console.log(pc20.dim("  Methods:"));
+    if (service.methodNames.length > 0) {
+      for (const method of service.methodNames) {
+        console.log(`    - ${pc20.cyan(method)}()`);
+      }
+    } else {
+      console.log(pc20.dim("    (methods will be detected after service is loaded)"));
+    }
+    console.log();
+    console.log(pc20.dim("  Required Bindings:"));
+    if (service.requiredBindings.length > 0) {
+      for (const binding of service.requiredBindings) {
+        console.log(`    - ${binding}`);
+      }
+    } else {
+      console.log(pc20.dim("    none configured"));
+    }
+    console.log();
+    console.log(pc20.dim("  Hooks:        ") + (service.hasHooks ? pc20.green("yes") : pc20.dim("no")));
+    console.log();
+    if (service.mode === "local") {
+      console.log(pc20.dim("Actions:"));
+      console.log(pc20.dim(`  Extract:  cloudwerk services extract ${serviceName}`));
+    } else {
+      console.log(pc20.dim("Actions:"));
+      console.log(pc20.dim(`  Inline:   cloudwerk services inline ${serviceName}`));
+      console.log(pc20.dim(`  Deploy:   cloudwerk services deploy ${serviceName}`));
+    }
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/services/extract.ts
+import pc21 from "picocolors";
+import { loadConfig as loadConfig16, scanServices as scanServices5, buildServiceManifest as buildServiceManifest5 } from "@cloudwerk/core/build";
+
+// src/utils/service-worker-generator.ts
+import * as fs15 from "fs";
+import * as path16 from "path";
+var EXTRACTED_DIR = ".cloudwerk/extracted";
+function generateServiceWorker(cwd, service, options = {}) {
+  const includeTimestamp = options.includeTimestamp ?? true;
+  const workerDir = path16.join(cwd, EXTRACTED_DIR, service.workerName);
+  fs15.mkdirSync(workerDir, { recursive: true });
+  const workerPath = path16.join(workerDir, "worker.ts");
+  const workerContent = generateWorkerEntrypoint(cwd, service, includeTimestamp);
+  fs15.writeFileSync(workerPath, workerContent, "utf-8");
+  const wranglerPath = path16.join(workerDir, "wrangler.toml");
+  const wranglerContent = generateWorkerWranglerToml(service, includeTimestamp);
+  fs15.writeFileSync(wranglerPath, wranglerContent, "utf-8");
+  return {
+    workerDir,
+    workerFile: workerPath,
+    wranglerFile: wranglerPath,
+    service
+  };
+}
+function generateWorkerEntrypoint(cwd, service, includeTimestamp) {
+  const lines = [];
+  const workerDir = path16.join(cwd, EXTRACTED_DIR, service.workerName);
+  const relativePath = path16.relative(workerDir, service.absolutePath).replace(/\\/g, "/").replace(/\.tsx?$/, "");
+  lines.push("// Auto-generated by cloudwerk services - DO NOT EDIT");
+  if (includeTimestamp) {
+    lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  }
+  lines.push("//");
+  lines.push(`// WorkerEntrypoint wrapper for ${service.name} service`);
+  lines.push(`// Source: ${service.filePath}`);
+  lines.push("");
+  lines.push("import { WorkerEntrypoint } from 'cloudflare:workers'");
+  lines.push(`import service from '${relativePath}'`);
+  lines.push("");
+  lines.push("// Environment bindings for this service");
+  lines.push("interface Env {");
+  if (service.requiredBindings.length > 0) {
+    for (const binding of service.requiredBindings) {
+      lines.push(`  ${binding}: unknown`);
+    }
+  } else {
+    lines.push("  // Add binding types here");
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("/**");
+  lines.push(` * ${service.entrypointClass} - WorkerEntrypoint for ${service.name} service`);
+  lines.push(" *");
+  lines.push(" * This class wraps the service methods and handles lifecycle hooks.");
+  lines.push(" * Cloudflare's service binding RPC will call methods directly on this class.");
+  lines.push(" */");
+  lines.push(`export class ${service.entrypointClass} extends WorkerEntrypoint<Env> {`);
+  lines.push("  private initialized = false");
+  lines.push("");
+  lines.push("  /**");
+  lines.push("   * Initialize the service (runs onInit hook once).");
+  lines.push("   */");
+  lines.push("  private async ensureInitialized(): Promise<void> {");
+  lines.push("    if (this.initialized) return");
+  lines.push("    this.initialized = true");
+  lines.push("");
+  lines.push("    if (service.hooks?.onInit) {");
+  lines.push("      await service.hooks.onInit()");
+  lines.push("    }");
+  lines.push("  }");
+  lines.push("");
+  if (service.methodNames.length > 0) {
+    for (const methodName of service.methodNames) {
+      lines.push(`  /**`);
+      lines.push(`   * ${methodName} - wrapped service method`);
+      lines.push("   */");
+      lines.push(`  async ${methodName}(...args: unknown[]): Promise<unknown> {`);
+      lines.push("    await this.ensureInitialized()");
+      lines.push("");
+      lines.push("    // Run onBefore hook");
+      lines.push("    if (service.hooks?.onBefore) {");
+      lines.push(`      await service.hooks.onBefore('${methodName}', args)`);
+      lines.push("    }");
+      lines.push("");
+      lines.push("    try {");
+      lines.push("      // Call the actual service method");
+      lines.push(`      const method = service.methods.${methodName}`);
+      lines.push("      const result = await method.apply({ env: this.env }, args)");
+      lines.push("");
+      lines.push("      // Run onAfter hook");
+      lines.push("      if (service.hooks?.onAfter) {");
+      lines.push(`        await service.hooks.onAfter('${methodName}', result)`);
+      lines.push("      }");
+      lines.push("");
+      lines.push("      return result");
+      lines.push("    } catch (error) {");
+      lines.push("      // Run onError hook");
+      lines.push("      if (service.hooks?.onError) {");
+      lines.push(`        await service.hooks.onError('${methodName}', error as Error)`);
+      lines.push("      }");
+      lines.push("      throw error");
+      lines.push("    }");
+      lines.push("  }");
+      lines.push("");
+    }
+  } else {
+    lines.push("  // Method wrappers will be generated once service is loaded");
+    lines.push("  // Run `cloudwerk services extract` after defining methods");
+    lines.push("");
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("// Default export for direct worker access");
+  lines.push("export default {");
+  lines.push("  async fetch(): Promise<Response> {");
+  lines.push(`    return new Response('${service.name} service is running. Use service binding RPC to call methods.')`);
+  lines.push("  },");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateWorkerWranglerToml(service, includeTimestamp) {
+  const lines = [];
+  lines.push("# Auto-generated by cloudwerk services - DO NOT EDIT");
+  if (includeTimestamp) {
+    lines.push(`# Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  }
+  lines.push("#");
+  lines.push(`# Wrangler configuration for ${service.name} service`);
+  lines.push(`# Source: ${service.filePath}`);
+  lines.push("");
+  lines.push(`name = "${service.workerName}"`);
+  lines.push('main = "worker.ts"');
+  lines.push('compatibility_date = "2024-09-23"');
+  lines.push("");
+  if (service.requiredBindings.length > 0) {
+    lines.push("# Bindings required by this service");
+    lines.push("# Update these with your actual binding configurations");
+    lines.push("");
+    for (const binding of service.requiredBindings) {
+      if (binding.includes("DB") || binding.includes("D1")) {
+        lines.push("[[d1_databases]]");
+        lines.push(`binding = "${binding}"`);
+        lines.push(`database_name = "\${${binding}_NAME}"`);
+        lines.push(`database_id = "\${${binding}_ID}"`);
+      } else if (binding.includes("KV") || binding.includes("CACHE")) {
+        lines.push("[[kv_namespaces]]");
+        lines.push(`binding = "${binding}"`);
+        lines.push(`id = "\${${binding}_ID}"`);
+      } else if (binding.includes("R2") || binding.includes("BUCKET") || binding.includes("STORAGE")) {
+        lines.push("[[r2_buckets]]");
+        lines.push(`binding = "${binding}"`);
+        lines.push(`bucket_name = "\${${binding}_NAME}"`);
+      } else if (binding.includes("QUEUE")) {
+        lines.push("[[queues.producers]]");
+        lines.push(`queue = "\${${binding}_NAME}"`);
+        lines.push(`binding = "${binding}"`);
+      } else {
+        lines.push("[vars]");
+        lines.push(`# ${binding} = "..."`);
+      }
+      lines.push("");
+    }
+  } else {
+    lines.push("# No bindings configured");
+    lines.push("# Add bindings in your service definition:");
+    lines.push("#   config: {");
+    lines.push("#     extraction: {");
+    lines.push("#       bindings: ['DB', 'CACHE'],");
+    lines.push("#     }");
+    lines.push("#   }");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function serviceWorkerExists(cwd, serviceName) {
+  const workerDir = path16.join(cwd, EXTRACTED_DIR, `${serviceName}-service`);
+  return fs15.existsSync(workerDir);
+}
+function deleteServiceWorker(cwd, serviceName) {
+  const workerDir = path16.join(cwd, EXTRACTED_DIR, `${serviceName}-service`);
+  if (fs15.existsSync(workerDir)) {
+    fs15.rmSync(workerDir, { recursive: true, force: true });
+    return true;
+  }
+  return false;
+}
+function getExtractedDir(cwd) {
+  return path16.join(cwd, EXTRACTED_DIR);
+}
+function getExtractedServiceDirs(cwd) {
+  const extractedDir = path16.join(cwd, EXTRACTED_DIR);
+  if (!fs15.existsSync(extractedDir)) {
+    return [];
+  }
+  return fs15.readdirSync(extractedDir).map((name) => path16.join(extractedDir, name)).filter((p) => fs15.statSync(p).isDirectory());
+}
+
+// src/utils/service-wrangler.ts
+import * as fs16 from "fs";
+import * as path17 from "path";
+function generateServiceBindingToml(service, includeComments) {
+  const lines = [];
+  if (includeComments) {
+    lines.push(`# Service binding for '${service.name}' (from app/services/${service.filePath})`);
+  }
+  lines.push("[[services]]");
+  lines.push(`binding = "${service.bindingName}"`);
+  lines.push(`service = "${service.workerName}"`);
+  lines.push(`entrypoint = "${service.entrypointClass}"`);
+  return lines.join("\n");
+}
+function generateServiceToml(manifest, includeComments = true) {
+  const extractedServices = manifest.services.filter((s) => s.mode === "extracted");
+  if (extractedServices.length === 0) {
+    return "";
+  }
+  const lines = [];
+  if (includeComments) {
+    lines.push("# ============================================================================");
+    lines.push("# Cloudwerk Services - Auto-generated from app/services/");
+    lines.push("# ============================================================================");
+    lines.push("#");
+    lines.push("# These service bindings connect to extracted Workers.");
+    lines.push("# Each service runs as a separate Worker and is called via RPC.");
+    lines.push("#");
+    lines.push("# To deploy extracted services, run:");
+    lines.push("#   cloudwerk services deploy <name>");
+    lines.push("#");
+    lines.push("");
+  }
+  for (const service of extractedServices) {
+    lines.push(generateServiceBindingToml(service, includeComments));
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+var SERVICE_SECTION_START = "# ============================================================================";
+var SERVICE_SECTION_MARKER = "# Cloudwerk Services - Auto-generated";
+function hasServiceSection(content) {
+  return content.includes(SERVICE_SECTION_MARKER);
+}
+function removeServiceSection(content) {
+  const startIndex = content.indexOf(SERVICE_SECTION_START);
+  if (startIndex === -1 || !content.includes(SERVICE_SECTION_MARKER)) {
+    return content;
+  }
+  const lines = content.split("\n");
+  let sectionStartLine = -1;
+  let sectionEndLine = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(SERVICE_SECTION_MARKER)) {
+      sectionStartLine = i > 0 && lines[i - 1].includes("===") ? i - 1 : i;
+      break;
+    }
+  }
+  if (sectionStartLine === -1) {
+    return content;
+  }
+  for (let i = sectionStartLine + 2; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "" || line.startsWith("#")) {
+      continue;
+    }
+    if (line.startsWith("[[") && !line.includes("services]]")) {
+      sectionEndLine = i;
+      break;
+    }
+    if (line.startsWith("[") && !line.startsWith("[[") && !line.includes("services")) {
+      sectionEndLine = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, sectionStartLine);
+  const after = lines.slice(sectionEndLine);
+  while (before.length > 0 && before[before.length - 1].trim() === "") {
+    before.pop();
+  }
+  return [...before, "", ...after].join("\n");
+}
+function generateServiceWrangler(cwd, manifest, options = {}) {
+  const { dryRun = false, includeComments = true } = options;
+  const wranglerPath = findWranglerToml(cwd) || path17.join(cwd, "wrangler.toml");
+  const generatedToml = generateServiceToml(manifest, includeComments);
+  const extractedServices = manifest.services.filter((s) => s.mode === "extracted");
+  const result = {
+    wranglerPath,
+    changed: false,
+    services: extractedServices.map((s) => ({
+      name: s.name,
+      workerName: s.workerName,
+      bindingName: s.bindingName,
+      mode: s.mode
+    })),
+    generatedToml
+  };
+  if (extractedServices.length === 0) {
+    return result;
+  }
+  if (dryRun) {
+    result.changed = true;
+    return result;
+  }
+  let content = "";
+  if (fs16.existsSync(wranglerPath)) {
+    content = readWranglerTomlRaw(cwd);
+  }
+  if (hasServiceSection(content)) {
+    content = removeServiceSection(content);
+  }
+  const newContent = content.trim() + "\n\n" + generatedToml + "\n";
+  writeWranglerTomlRaw(cwd, newContent);
+  result.changed = true;
+  return result;
+}
+function removeServiceWrangler(cwd) {
+  const wranglerPath = findWranglerToml(cwd);
+  if (!wranglerPath) {
+    return false;
+  }
+  const content = readWranglerTomlRaw(cwd);
+  if (!hasServiceSection(content)) {
+    return false;
+  }
+  const newContent = removeServiceSection(content);
+  writeWranglerTomlRaw(cwd, newContent);
+  return true;
+}
+function hasServiceInWrangler(cwd, serviceName) {
+  const wranglerPath = findWranglerToml(cwd);
+  if (!wranglerPath) {
+    return false;
+  }
+  const content = readWranglerTomlRaw(cwd);
+  const bindingPattern = new RegExp(`binding\\s*=\\s*["']${serviceName.toUpperCase()}_SERVICE["']`);
+  return bindingPattern.test(content);
+}
+
+// src/utils/service-type-generator.ts
+import * as fs17 from "fs";
+import * as path18 from "path";
+var CLOUDWERK_TYPES_DIR4 = ".cloudwerk/types";
+var SERVICES_DTS = "services.d.ts";
+function generateServiceTypes(cwd, manifest, options = {}) {
+  const includeTimestamp = options.includeTimestamp ?? true;
+  const typesDir = path18.join(cwd, CLOUDWERK_TYPES_DIR4);
+  fs17.mkdirSync(typesDir, { recursive: true });
+  const servicesPath = path18.join(typesDir, SERVICES_DTS);
+  const servicesContent = generateServicesDts(manifest.services, includeTimestamp);
+  fs17.writeFileSync(servicesPath, servicesContent, "utf-8");
+  const serviceInfo = manifest.services.map((s) => ({
+    name: s.name,
+    bindingName: s.bindingName,
+    mode: s.mode
+  }));
+  return {
+    typesDir,
+    file: servicesPath,
+    serviceCount: manifest.services.length,
+    services: serviceInfo
+  };
+}
+function generateServicesDts(services2, includeTimestamp) {
+  const lines = [];
+  lines.push("// Auto-generated by cloudwerk services - DO NOT EDIT");
+  if (includeTimestamp) {
+    lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  }
+  lines.push("//");
+  lines.push("// This file provides type information for service interfaces");
+  lines.push('// Add ".cloudwerk/types" to your tsconfig.json include array');
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Service Interfaces");
+  lines.push("// ============================================================================");
+  lines.push("//");
+  lines.push("// Define your service interfaces below or in separate type files.");
+  lines.push("// These interfaces should match the methods defined in your service.ts files.");
+  lines.push("//");
+  lines.push("// Example:");
+  lines.push("//   interface EmailServiceMethods {");
+  lines.push("//     send(params: { to: string; subject: string; body: string }): Promise<{ success: boolean }>");
+  lines.push("//     sendBatch(emails: Array<{ to: string; subject: string }>): Promise<{ sent: number }>");
+  lines.push("//   }");
+  lines.push("//");
+  lines.push("");
+  for (const service of services2) {
+    const interfaceName = `${capitalizeFirst(service.name)}ServiceMethods`;
+    const modeComment = service.mode === "extracted" ? " (extracted)" : " (local)";
+    lines.push(`/** Methods for the '${service.name}' service${modeComment} */`);
+    lines.push(`// eslint-disable-next-line @typescript-eslint/no-empty-interface`);
+    lines.push(`interface ${interfaceName} {`);
+    if (service.methodNames.length > 0) {
+      for (const methodName of service.methodNames) {
+        lines.push(`  /** Method: ${methodName} */`);
+        lines.push(`  ${methodName}(...args: unknown[]): Promise<unknown>`);
+      }
+    } else {
+      lines.push("  // Add method signatures here");
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  lines.push("// ============================================================================");
+  lines.push("// Services Interface");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push("interface CloudwerkServices {");
+  for (const service of services2) {
+    const interfaceName = `${capitalizeFirst(service.name)}ServiceMethods`;
+    const modeComment = service.mode === "extracted" ? `extracted (binding: ${service.bindingName})` : "local (direct calls)";
+    lines.push(`  /** Service '${service.name}' - ${modeComment} */`);
+    lines.push(`  ${service.name}: ${interfaceName}`);
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Module Augmentation");
+  lines.push("// ============================================================================");
+  lines.push("");
+  lines.push("declare module '@cloudwerk/core/bindings' {");
+  lines.push("  /** Typed services based on app/services/ definitions */");
+  lines.push("  export const services: CloudwerkServices");
+  lines.push("");
+  lines.push("  /** Get a typed service by name */");
+  lines.push("  export function getService<K extends keyof CloudwerkServices>(");
+  lines.push("    name: K");
+  lines.push("  ): CloudwerkServices[K]");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function capitalizeFirst(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/commands/services/extract.ts
+async function servicesExtract(serviceName, options = {}) {
+  const verbose = options.verbose ?? false;
+  const dryRun = options.dryRun ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig16(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for services in ${appDir}/services/...`);
+    const scanResult = await scanServices5(appDir, { extensions: config.extensions });
+    const serviceModes = { [serviceName]: "extracted" };
+    const manifest = buildServiceManifest5(scanResult, appDir, {
+      defaultMode: "local",
+      serviceModes
+    });
+    const service = manifest.services.find((s) => s.name === serviceName);
+    if (!service) {
+      const available = manifest.services.map((s) => s.name);
+      throw new CliError(
+        `Service '${serviceName}' not found`,
+        "ENOENT",
+        available.length > 0 ? `Available services: ${available.join(", ")}` : "No services found in app/services/"
+      );
+    }
+    console.log();
+    console.log(pc21.bold(`Extracting service: ${serviceName}`));
+    console.log();
+    if (dryRun) {
+      console.log(pc21.yellow("Dry run - no changes will be made"));
+      console.log();
+    }
+    logger.debug("Generating WorkerEntrypoint wrapper...");
+    const workerResult = generateServiceWorker(cwd, service, { includeTimestamp: true });
+    console.log(`  ${pc21.green("\u2713")} Worker generated: ${workerResult.workerFile}`);
+    console.log(`  ${pc21.green("\u2713")} Wrangler config: ${workerResult.wranglerFile}`);
+    if (!dryRun) {
+      logger.debug("Updating wrangler.toml with service binding...");
+      const wranglerResult = generateServiceWrangler(cwd, manifest);
+      if (wranglerResult.changed) {
+        console.log(`  ${pc21.green("\u2713")} Service binding added to ${wranglerResult.wranglerPath}`);
+      }
+    }
+    if (!dryRun) {
+      logger.debug("Updating type definitions...");
+      const typesResult = generateServiceTypes(cwd, manifest);
+      console.log(`  ${pc21.green("\u2713")} Types updated: ${typesResult.file}`);
+    }
+    console.log();
+    console.log(pc21.bold("Next steps:"));
+    console.log();
+    console.log(pc21.dim(`  1. Review the generated files in .cloudwerk/extracted/${service.workerName}/`));
+    console.log(pc21.dim(`  2. Update the wrangler.toml with your binding configurations`));
+    console.log(pc21.dim(`  3. Deploy the extracted service:`));
+    console.log();
+    console.log(`     cloudwerk services deploy ${serviceName}`);
+    console.log();
+    console.log(pc21.dim(`  4. Deploy the main worker to use the service binding:`));
+    console.log();
+    console.log("     cloudwerk deploy");
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/services/inline.ts
+import pc22 from "picocolors";
+import { loadConfig as loadConfig17, scanServices as scanServices6, buildServiceManifest as buildServiceManifest6 } from "@cloudwerk/core/build";
+async function servicesInline(serviceName, options = {}) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig17(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for services in ${appDir}/services/...`);
+    const scanResult = await scanServices6(appDir, { extensions: config.extensions });
+    const manifest = buildServiceManifest6(scanResult, appDir, {
+      defaultMode: "local"
+    });
+    const service = manifest.services.find((s) => s.name === serviceName);
+    if (!service) {
+      const available = manifest.services.map((s) => s.name);
+      throw new CliError(
+        `Service '${serviceName}' not found`,
+        "ENOENT",
+        available.length > 0 ? `Available services: ${available.join(", ")}` : "No services found in app/services/"
+      );
+    }
+    console.log();
+    console.log(pc22.bold(`Converting service to local mode: ${serviceName}`));
+    console.log();
+    const hasExtracted = serviceWorkerExists(cwd, serviceName);
+    if (hasExtracted) {
+      logger.debug("Removing extracted worker files...");
+      const deleted = deleteServiceWorker(cwd, serviceName);
+      if (deleted) {
+        console.log(`  ${pc22.green("\u2713")} Removed extracted worker files`);
+      }
+    } else {
+      console.log(`  ${pc22.dim("\u2713")} No extracted worker files to remove`);
+    }
+    logger.debug("Updating wrangler.toml...");
+    const removed = removeServiceWrangler(cwd);
+    if (removed) {
+      console.log(`  ${pc22.green("\u2713")} Removed service binding from wrangler.toml`);
+    } else {
+      console.log(`  ${pc22.dim("\u2713")} No service binding to remove`);
+    }
+    logger.debug("Updating type definitions...");
+    const typesResult = generateServiceTypes(cwd, manifest);
+    console.log(`  ${pc22.green("\u2713")} Types updated: ${typesResult.file}`);
+    console.log();
+    console.log(pc22.green(`Service '${serviceName}' is now running in local mode.`));
+    console.log();
+    console.log(pc22.dim("The service will be called directly within your main Worker."));
+    console.log(pc22.dim("Deploy your main Worker to apply the changes:"));
+    console.log();
+    console.log("  cloudwerk deploy");
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/services/deploy.ts
+import * as path19 from "path";
+import { spawn as spawn4 } from "child_process";
+import pc23 from "picocolors";
+import { loadConfig as loadConfig18, scanServices as scanServices7, buildServiceManifest as buildServiceManifest7 } from "@cloudwerk/core/build";
+async function servicesDeploy(serviceName, options = {}) {
+  const verbose = options.verbose ?? false;
+  const dryRun = options.dryRun ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig18(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for services in ${appDir}/services/...`);
+    const scanResult = await scanServices7(appDir, { extensions: config.extensions });
+    const manifest = buildServiceManifest7(scanResult, appDir);
+    const service = manifest.services.find((s) => s.name === serviceName);
+    if (!service) {
+      const available = manifest.services.map((s) => s.name);
+      throw new CliError(
+        `Service '${serviceName}' not found`,
+        "ENOENT",
+        available.length > 0 ? `Available services: ${available.join(", ")}` : "No services found in app/services/"
+      );
+    }
+    const hasExtracted = serviceWorkerExists(cwd, serviceName);
+    if (!hasExtracted) {
+      throw new CliError(
+        `Service '${serviceName}' is not extracted`,
+        "EINVAL",
+        `Run 'cloudwerk services extract ${serviceName}' first.`
+      );
+    }
+    const workerDir = path19.join(getExtractedDir(cwd), service.workerName);
+    console.log();
+    console.log(pc23.bold(`Deploying service: ${serviceName}`));
+    console.log();
+    console.log(pc23.dim(`  Worker:   ${service.workerName}`));
+    console.log(pc23.dim(`  Location: ${workerDir}`));
+    console.log();
+    if (dryRun) {
+      console.log(pc23.yellow("Dry run - would run:"));
+      console.log(`  cd ${workerDir} && wrangler deploy`);
+      console.log();
+      return;
+    }
+    console.log(pc23.dim("Running wrangler deploy..."));
+    console.log();
+    await new Promise((resolve4, reject) => {
+      const wrangler = spawn4("wrangler", ["deploy"], {
+        cwd: workerDir,
+        stdio: "inherit",
+        shell: true
+      });
+      wrangler.on("close", (code) => {
+        if (code === 0) {
+          resolve4();
+        } else {
+          reject(new CliError(
+            `wrangler deploy failed with code ${code}`,
+            "EEXEC",
+            "Check the output above for details."
+          ));
+        }
+      });
+      wrangler.on("error", (err) => {
+        reject(new CliError(
+          `Failed to run wrangler: ${err.message}`,
+          "EEXEC",
+          "Make sure wrangler is installed: npm install -g wrangler"
+        ));
+      });
+    });
+    console.log();
+    console.log(pc23.green(`Service '${serviceName}' deployed successfully!`));
+    console.log();
+    console.log(pc23.dim("Next steps:"));
+    console.log(pc23.dim("  1. Deploy your main worker to use the service binding:"));
+    console.log();
+    console.log("     cloudwerk deploy");
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/services/status.ts
+import pc24 from "picocolors";
+import { loadConfig as loadConfig19, scanServices as scanServices8, buildServiceManifest as buildServiceManifest8 } from "@cloudwerk/core/build";
+async function servicesStatus(options = {}) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    logger.debug("Loading configuration...");
+    const config = await loadConfig19(cwd);
+    const appDir = config.appDir;
+    logger.debug(`Scanning for services in ${appDir}/services/...`);
+    const scanResult = await scanServices8(appDir, { extensions: config.extensions });
+    const manifest = buildServiceManifest8(scanResult, appDir);
+    console.log();
+    console.log(pc24.bold("Services Status"));
+    console.log();
+    if (manifest.services.length === 0) {
+      console.log(pc24.dim("  No services found in app/services/"));
+      console.log();
+      return;
+    }
+    const localCount = manifest.services.filter((s) => s.mode === "local").length;
+    const extractedCount = manifest.services.filter((s) => s.mode === "extracted").length;
+    console.log(pc24.dim(`  Total:     ${manifest.services.length} services`));
+    console.log(pc24.dim(`  Local:     ${localCount}`));
+    console.log(pc24.dim(`  Extracted: ${extractedCount}`));
+    console.log();
+    console.log(pc24.dim("  Service           Mode       Worker Files  Binding"));
+    console.log(pc24.dim("  " + "\u2500".repeat(16) + "  " + "\u2500".repeat(9) + "  " + "\u2500".repeat(12) + "  " + "\u2500".repeat(10)));
+    for (const service of manifest.services) {
+      const name = service.name.padEnd(16);
+      const mode = service.mode === "extracted" ? pc24.yellow("extracted") : pc24.green("local    ");
+      const hasFiles = serviceWorkerExists(cwd, service.name);
+      const filesStatus = hasFiles ? pc24.green("\u2713 generated ") : pc24.dim("- not needed");
+      const hasBinding = hasServiceInWrangler(cwd, service.name);
+      const bindingStatus = service.mode === "extracted" ? hasBinding ? pc24.green("\u2713 yes") : pc24.yellow("\u2717 missing") : pc24.dim("n/a       ");
+      console.log(`  ${pc24.cyan(name)}  ${mode}  ${filesStatus}  ${bindingStatus}`);
+    }
+    console.log();
+    const extractedDirs = getExtractedServiceDirs(cwd);
+    const serviceWorkerNames = manifest.services.map((s) => s.workerName);
+    const orphanedDirs = extractedDirs.filter((dir) => {
+      const dirName = dir.split("/").pop() || "";
+      return !serviceWorkerNames.includes(dirName);
+    });
+    if (orphanedDirs.length > 0) {
+      console.log(pc24.yellow("Orphaned extracted workers (no matching service):"));
+      for (const dir of orphanedDirs) {
+        console.log(pc24.yellow(`  - ${dir}`));
+      }
+      console.log();
+      console.log(pc24.dim("  These can be safely deleted if no longer needed."));
+      console.log();
+    }
+    if (manifest.errors.length > 0) {
+      console.log(pc24.red("Errors:"));
+      for (const error of manifest.errors) {
+        console.log(pc24.red(`  - ${error.file}: ${error.message}`));
+      }
+      console.log();
+    }
+    if (manifest.warnings.length > 0) {
+      console.log(pc24.yellow("Warnings:"));
+      for (const warning of manifest.warnings) {
+        console.log(pc24.yellow(`  - ${warning.file}: ${warning.message}`));
+      }
+      console.log();
+    }
+    console.log(pc24.dim("Use 'cloudwerk services list' for a simple list."));
+    console.log(pc24.dim("Use 'cloudwerk services info <name>' for details on a specific service."));
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
 // src/index.ts
 program.name("cloudwerk").description("Cloudwerk CLI - Build and deploy full-stack apps to Cloudflare").version(VERSION).enablePositionalOptions();
 program.command("dev [path]").description("Start development server").option("-p, --port <number>", "Port to listen on", String(DEFAULT_PORT)).option("-H, --host <host>", "Host to bind", DEFAULT_HOST).option("-c, --config <path>", "Path to config file").option("--verbose", "Enable verbose logging").action(dev);
@@ -3155,4 +5795,20 @@ bindingsCmd.command("add [type]").description("Add a new binding (d1, kv, r2, qu
 bindingsCmd.command("remove [name]").description("Remove a binding").option("-e, --env <environment>", "Environment to remove binding from").option("-f, --force", "Skip confirmation prompt").option("--skip-types", "Skip TypeScript type generation").option("--verbose", "Enable verbose logging").action(bindingsRemove);
 bindingsCmd.command("update [name]").description("Update an existing binding").option("-e, --env <environment>", "Environment to update binding in").option("--skip-types", "Skip TypeScript type generation").option("--verbose", "Enable verbose logging").action(bindingsUpdate);
 bindingsCmd.command("generate-types").description("Regenerate TypeScript type definitions").option("--verbose", "Enable verbose logging").action(bindingsGenerateTypes);
+var triggersCmd = program.command("triggers").description("Manage Cloudwerk triggers (scheduled, queue, R2, webhook, etc.)").enablePositionalOptions().passThroughOptions().option("--verbose", "Enable verbose logging").action(triggers);
+triggersCmd.command("list").description("List all triggers with details").option("-t, --type <type>", "Filter by source type (scheduled, queue, r2, webhook, email)").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(triggersList);
+triggersCmd.command("validate").description("Validate trigger configurations").option("-s, --strict", "Exit with error code if warnings are present").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(triggersValidate);
+triggersCmd.command("generate").description("Regenerate wrangler.toml and TypeScript types").option("--wrangler", "Only generate wrangler.toml config").option("--types", "Only generate TypeScript types").option("--dry-run", "Show what would be generated without writing").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(triggersGenerate);
+var objectsCmd = program.command("objects").description("Manage Cloudwerk Durable Objects").enablePositionalOptions().passThroughOptions().option("--verbose", "Enable verbose logging").action(objects);
+objectsCmd.command("list").description("List all durable objects with details").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(objectsList);
+objectsCmd.command("info <name>").description("Show durable object details").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(objectsInfo);
+objectsCmd.command("migrations").description("Show migration history for SQLite durable objects").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(objectsMigrations);
+objectsCmd.command("generate").description("Regenerate wrangler.toml and TypeScript types").option("--wrangler", "Only generate wrangler.toml config").option("--types", "Only generate TypeScript types").option("--dry-run", "Show what would be generated without writing").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(objectsGenerate);
+var servicesCmd = program.command("services").description("Manage Cloudwerk services (RPC bindings)").enablePositionalOptions().passThroughOptions().option("--verbose", "Enable verbose logging").action(services);
+servicesCmd.command("list").description("List all services with details").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(servicesList);
+servicesCmd.command("info <name>").description("Show service details").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(servicesInfo);
+servicesCmd.command("extract <name>").description("Extract service to separate Worker").option("--verbose", "Enable verbose logging").action(servicesExtract);
+servicesCmd.command("inline <name>").description("Convert extracted service back to local mode").option("--verbose", "Enable verbose logging").action(servicesInline);
+servicesCmd.command("deploy <name>").description("Deploy extracted service").option("-e, --env <environment>", "Environment to deploy to").option("--verbose", "Enable verbose logging").action(servicesDeploy);
+servicesCmd.command("status").description("Show status of all services").option("--json", "Output as JSON").option("--verbose", "Enable verbose logging").action(servicesStatus);
 program.parse();