@cloudwerk/cli 0.11.0 → 0.13.0

package/dist/index.js

@@ -265,7 +265,13 @@ import {
   resolveLayouts,
   resolveMiddleware,
   loadConfig,
-  resolveRoutesPath
+  resolveRoutesPath,
+  scanQueues,
+  buildQueueManifest,
+  QUEUES_DIR,
+  scanServices,
+  buildServiceManifest,
+  SERVICES_DIR
 } from "@cloudwerk/core/build";
 var DEFAULT_OUTPUT_DIR = "./dist";
 var BUILD_TEMP_DIR = ".cloudwerk-build";
@@ -313,6 +319,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,6 +356,9 @@ 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);
@@ -1206,6 +1239,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;
@@ -1217,97 +1261,7 @@ function getEnvConfig(config, env) {
 }
 function extractBindings(config, env) {
   const envConfig = getEnvConfig(config, env);
-  const bindings2 = [];
-  if (envConfig.d1_databases) {
-    for (const db of envConfig.d1_databases) {
-      bindings2.push({
-        type: "d1",
-        name: db.binding,
-        resourceId: db.database_id,
-        resourceName: db.database_name
-      });
-    }
-  }
-  if (envConfig.kv_namespaces) {
-    for (const kv of envConfig.kv_namespaces) {
-      bindings2.push({
-        type: "kv",
-        name: kv.binding,
-        resourceId: kv.id
-      });
-    }
-  }
-  if (envConfig.r2_buckets) {
-    for (const r2 of envConfig.r2_buckets) {
-      bindings2.push({
-        type: "r2",
-        name: r2.binding,
-        resourceName: r2.bucket_name
-      });
-    }
-  }
-  if (envConfig.queues?.producers) {
-    for (const queue of envConfig.queues.producers) {
-      bindings2.push({
-        type: "queue",
-        name: queue.binding,
-        resourceName: queue.queue
-      });
-    }
-  }
-  if (envConfig.durable_objects?.bindings) {
-    for (const doBinding of envConfig.durable_objects.bindings) {
-      bindings2.push({
-        type: "do",
-        name: doBinding.name,
-        resourceName: doBinding.class_name,
-        extra: doBinding.script_name ? { script_name: doBinding.script_name } : void 0
-      });
-    }
-  }
-  if (envConfig.services) {
-    for (const service of envConfig.services) {
-      bindings2.push({
-        type: "service",
-        name: service.binding,
-        resourceName: service.service,
-        extra: service.environment ? { environment: service.environment } : void 0
-      });
-    }
-  }
-  if (envConfig.vars) {
-    for (const [name] of Object.entries(envConfig.vars)) {
-      bindings2.push({
-        type: "secret",
-        name
-      });
-    }
-  }
-  if (envConfig.ai) {
-    bindings2.push({
-      type: "ai",
-      name: envConfig.ai.binding
-    });
-  }
-  if (envConfig.vectorize) {
-    for (const vec of envConfig.vectorize) {
-      bindings2.push({
-        type: "vectorize",
-        name: vec.binding,
-        resourceName: vec.index_name
-      });
-    }
-  }
-  if (envConfig.hyperdrive) {
-    for (const hd of envConfig.hyperdrive) {
-      bindings2.push({
-        type: "hyperdrive",
-        name: hd.binding,
-        resourceId: hd.id
-      });
-    }
-  }
-  return bindings2;
+  return extractBindingsFromConfig(envConfig);
 }
 function getEnvironments(config) {
   if (!config.env) {
@@ -1521,10 +1475,109 @@ function removeBinding(cwd, bindingName, env) {
   }
   return removed;
 }
+function setAccountId(cwd, accountId) {
+  const config = readWranglerToml(cwd);
+  config.account_id = accountId;
+  writeWranglerToml(cwd, config);
+}
 function bindingExists(config, bindingName, env) {
-  const bindings2 = extractBindings(config, env);
+  const targetConfig = env && config.env?.[env] ? config.env[env] : config;
+  const bindings2 = extractBindingsFromConfig(targetConfig);
   return bindings2.some((b) => b.name === bindingName);
 }
+function extractBindingsFromConfig(config) {
+  const bindings2 = [];
+  if (config.d1_databases) {
+    for (const db of config.d1_databases) {
+      bindings2.push({
+        type: "d1",
+        name: db.binding,
+        resourceId: db.database_id,
+        resourceName: db.database_name
+      });
+    }
+  }
+  if (config.kv_namespaces) {
+    for (const kv of config.kv_namespaces) {
+      bindings2.push({
+        type: "kv",
+        name: kv.binding,
+        resourceId: kv.id
+      });
+    }
+  }
+  if (config.r2_buckets) {
+    for (const r2 of config.r2_buckets) {
+      bindings2.push({
+        type: "r2",
+        name: r2.binding,
+        resourceName: r2.bucket_name
+      });
+    }
+  }
+  if (config.queues?.producers) {
+    for (const queue of config.queues.producers) {
+      bindings2.push({
+        type: "queue",
+        name: queue.binding,
+        resourceName: queue.queue
+      });
+    }
+  }
+  if (config.durable_objects?.bindings) {
+    for (const doBinding of config.durable_objects.bindings) {
+      bindings2.push({
+        type: "do",
+        name: doBinding.name,
+        resourceName: doBinding.class_name,
+        extra: doBinding.script_name ? { script_name: doBinding.script_name } : void 0
+      });
+    }
+  }
+  if (config.services) {
+    for (const service of config.services) {
+      bindings2.push({
+        type: "service",
+        name: service.binding,
+        resourceName: service.service,
+        extra: service.environment ? { environment: service.environment } : void 0
+      });
+    }
+  }
+  if (config.vars) {
+    for (const [name] of Object.entries(config.vars)) {
+      bindings2.push({
+        type: "secret",
+        name
+      });
+    }
+  }
+  if (config.ai) {
+    bindings2.push({
+      type: "ai",
+      name: config.ai.binding
+    });
+  }
+  if (config.vectorize) {
+    for (const vec of config.vectorize) {
+      bindings2.push({
+        type: "vectorize",
+        name: vec.binding,
+        resourceName: vec.index_name
+      });
+    }
+  }
+  if (config.hyperdrive) {
+    for (const hd of config.hyperdrive) {
+      bindings2.push({
+        type: "hyperdrive",
+        name: hd.binding,
+        resourceId: hd.id
+      });
+    }
+  }
+  return bindings2;
+}
 function getBindingTypeName(type) {
   switch (type) {
     case "d1":
@@ -1826,7 +1879,7 @@ async function addD1(cwd, options) {
   });
   const databaseName = await input({
     message: "Database name:",
-    default: `${config.name || "my-app"}-db${env ? `-${env}` : ""}`,
+    default: `${config.name || "my-app"}${env ? `-${env}` : ""}-db`,
     validate: (value) => {
       if (!value.trim()) return "Database name is required";
       return true;
@@ -1963,7 +2016,7 @@ async function addR2(cwd, options) {
   if (createNew) {
     bucketName = await input({
       message: "Bucket name:",
-      default: `${config.name || "my-app"}-bucket${env ? `-${env}` : ""}`,
+      default: `${config.name || "my-app"}${env ? `-${env}` : ""}-bucket`,
       validate: (value) => {
         if (!value.trim()) return "Bucket name is required";
         return true;
@@ -2021,7 +2074,7 @@ async function addQueue(cwd, options) {
   if (createNew) {
     queueName = await input({
       message: "Queue name:",
-      default: `${config.name || "my-app"}-queue${env ? `-${env}` : ""}`,
+      default: `${config.name || "my-app"}${env ? `-${env}` : ""}-queue`,
       validate: (value) => {
         if (!value.trim()) return "Queue name is required";
         return true;
@@ -2163,8 +2216,59 @@ function showTypeHint(bindingName, type) {
   console.log();
   console.log(pc5.dim(`TypeScript type: ${bindingName}: ${tsType}`));
 }
-function runWranglerCommand(args) {
-  return new Promise((resolve4, reject) => {
+function parseAccountsFromError(errorMessage) {
+  const accounts = [];
+  const accountRegex = /`([^`]+)`:\s*`([a-f0-9]+)`/g;
+  let match;
+  while ((match = accountRegex.exec(errorMessage)) !== null) {
+    accounts.push({
+      name: match[1],
+      id: match[2]
+    });
+  }
+  return accounts;
+}
+function isMultiAccountError(errorMessage) {
+  return errorMessage.includes("More than one account available");
+}
+async function promptForAccount(accounts) {
+  console.log();
+  const selected = await select({
+    message: "Multiple Cloudflare accounts available. Which account do you want to use?",
+    choices: accounts.map((account) => ({
+      name: `${account.name} (${account.id.slice(0, 8)}...)`,
+      value: account.id
+    }))
+  });
+  return selected;
+}
+async function handleWranglerResult(result, retryFn, cwd) {
+  if (result.error && isMultiAccountError(result.stderr)) {
+    const accounts = parseAccountsFromError(result.stderr);
+    if (accounts.length > 0) {
+      const selectedAccountId = await promptForAccount(accounts);
+      const projectCwd = cwd || process.cwd();
+      setAccountId(projectCwd, selectedAccountId);
+      console.log(pc5.green("\u2713") + " Set account_id in wrangler.toml");
+      console.log();
+      const retryResult = await retryFn();
+      if (retryResult.error) {
+        throw new Error(retryResult.stderr || `wrangler exited with code ${retryResult.code}`);
+      }
+      return retryResult.stdout;
+    }
+  }
+  if (result.error) {
+    throw new Error(result.stderr || `wrangler exited with code ${result.code}`);
+  }
+  return result.stdout;
+}
+async function runWranglerCommand(args, cwd) {
+  const result = await runWranglerCommandRaw(args);
+  return handleWranglerResult(result, () => runWranglerCommandRaw(args), cwd);
+}
+function runWranglerCommandRaw(args) {
+  return new Promise((resolve4) => {
     let stdout = "";
     let stderr = "";
     const child = spawn2("npx", ["wrangler", ...args], {
@@ -2177,19 +2281,23 @@ function runWranglerCommand(args) {
       stderr += data.toString();
     });
     child.on("error", (error) => {
-      reject(error);
+      resolve4({ stdout, stderr: error.message, code: null, error: true });
     });
     child.on("close", (code) => {
-      if (code !== 0) {
-        reject(new Error(stderr || `wrangler exited with code ${code}`));
-      } else {
-        resolve4(stdout);
-      }
+      resolve4({ stdout, stderr, code, error: code !== 0 });
     });
   });
 }
-function runWranglerCommandWithInput(args, inputData) {
-  return new Promise((resolve4, reject) => {
+async function runWranglerCommandWithInput(args, inputData, cwd) {
+  const result = await runWranglerCommandWithInputRaw(args, inputData);
+  return handleWranglerResult(
+    result,
+    () => runWranglerCommandWithInputRaw(args, inputData),
+    cwd
+  );
+}
+function runWranglerCommandWithInputRaw(args, inputData) {
+  return new Promise((resolve4) => {
     let stdout = "";
     let stderr = "";
     const child = spawn2("npx", ["wrangler", ...args], {
@@ -2202,14 +2310,10 @@ function runWranglerCommandWithInput(args, inputData) {
       stderr += data.toString();
     });
     child.on("error", (error) => {
-      reject(error);
+      resolve4({ stdout, stderr: error.message, code: null, error: true });
     });
     child.on("close", (code) => {
-      if (code !== 0) {
-        reject(new Error(stderr || `wrangler exited with code ${code}`));
-      } else {
-        resolve4(stdout);
-      }
+      resolve4({ stdout, stderr, code, error: code !== 0 });
     });
     child.stdin?.write(inputData);
     child.stdin?.end();
@@ -2726,69 +2830,1168 @@ function runWranglerCommandWithInput2(args, inputData) {
 
 // src/commands/bindings/generate-types.ts
 import pc8 from "picocolors";
-async function bindingsGenerateTypes(options) {
-  const verbose = options.verbose ?? false;
-  const logger = createLogger(verbose);
-  try {
-    const cwd = process.cwd();
-    const wranglerPath = findWranglerToml(cwd);
-    if (!wranglerPath) {
-      throw new CliError(
-        "wrangler.toml not found",
-        "ENOENT",
-        "Create a wrangler.toml file or run this command from a Cloudwerk project directory."
-      );
+
+// src/utils/type-generator.ts
+import * as fs9 from "fs";
+import * as path10 from "path";
+var CLOUDWERK_TYPES_DIR = ".cloudwerk/types";
+var BINDINGS_DTS = "bindings.d.ts";
+var CONTEXT_DTS = "context.d.ts";
+function generateCloudwerkTypes(cwd, bindings2, options = {}) {
+  const includeTimestamp = options.includeTimestamp ?? true;
+  const typesDir = path10.join(cwd, CLOUDWERK_TYPES_DIR);
+  fs9.mkdirSync(typesDir, { recursive: true });
+  const bindingsPath = path10.join(typesDir, BINDINGS_DTS);
+  const bindingsContent = generateBindingsDts(bindings2, includeTimestamp);
+  fs9.writeFileSync(bindingsPath, bindingsContent, "utf-8");
+  const contextPath = path10.join(typesDir, CONTEXT_DTS);
+  const contextContent = generateContextDts(bindings2, includeTimestamp);
+  fs9.writeFileSync(contextPath, contextContent, "utf-8");
+  const bindingInfo = bindings2.map((b) => ({
+    name: b.name,
+    type: getTypeForBinding(b.type)
+  }));
+  return {
+    typesDir,
+    files: {
+      bindings: bindingsPath,
+      context: contextPath
+    },
+    bindingCount: bindings2.length,
+    bindings: bindingInfo
+  };
+}
+function generateBindingsDts(bindings2, includeTimestamp) {
+  const lines = [];
+  lines.push("// Auto-generated by cloudwerk bindings - DO NOT EDIT");
+  if (includeTimestamp) {
+    lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  }
+  lines.push("//");
+  lines.push("// This file provides type information for @cloudwerk/core/bindings");
+  lines.push('// Add ".cloudwerk/types" to your tsconfig.json include array');
+  lines.push("");
+  lines.push("declare module '@cloudwerk/core/bindings' {");
+  const bindingsByType = groupBindingsByType(bindings2);
+  const typeOrder = [
+    "d1",
+    "kv",
+    "r2",
+    "queue",
+    "do",
+    "service",
+    "ai",
+    "vectorize",
+    "hyperdrive",
+    "secret"
+  ];
+  let firstSection = true;
+  for (const type of typeOrder) {
+    const typeBindings = bindingsByType.get(type);
+    if (!typeBindings || typeBindings.length === 0) continue;
+    const tsType = getTypeForBinding(type);
+    const sectionName = getSectionName2(type);
+    if (!firstSection) {
+      lines.push("");
     }
-    logger.debug(`Found wrangler config: ${wranglerPath}`);
-    const config = readWranglerToml(cwd);
-    const bindings2 = extractBindings(config);
-    if (bindings2.length === 0) {
-      console.log();
-      console.log(pc8.yellow("No bindings found in wrangler.toml."));
-      console.log();
-      console.log(
-        pc8.dim(`Use 'cloudwerk bindings add' to add a binding first.`)
-      );
-      console.log();
-      return;
+    lines.push(`  // ${sectionName}`);
+    firstSection = false;
+    for (const binding of typeBindings) {
+      lines.push(`  export const ${binding.name}: ${tsType}`);
     }
-    console.log();
-    logger.info("Generating TypeScript types...");
-    const result = generateEnvTypes(cwd, bindings2);
-    console.log();
-    console.log(
-      pc8.green("\u2713") + ` Updated ${pc8.bold("env.d.ts")} with ${result.bindingCount} binding(s):`
-    );
-    console.log();
-    for (const binding of result.bindings) {
-      console.log(`    ${pc8.cyan(binding.name)}: ${pc8.dim(binding.type)}`);
+  }
+  lines.push("");
+  lines.push("  // Bindings proxy object (for dynamic access)");
+  lines.push("  export const bindings: Record<string, unknown>");
+  lines.push("");
+  lines.push("  // Helper functions");
+  lines.push("  export function getBinding<T = unknown>(name: string): T");
+  lines.push("  export function hasBinding(name: string): boolean");
+  lines.push("  export function getBindingNames(): string[]");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateContextDts(bindings2, includeTimestamp) {
+  const lines = [];
+  lines.push("// Auto-generated by cloudwerk bindings - DO NOT EDIT");
+  if (includeTimestamp) {
+    lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  }
+  lines.push("//");
+  lines.push("// This file provides type information for @cloudwerk/core/context");
+  lines.push('// Add ".cloudwerk/types" to your tsconfig.json include array');
+  lines.push("");
+  lines.push("interface CloudwerkEnv {");
+  const bindingsByType = groupBindingsByType(bindings2);
+  const typeOrder = [
+    "d1",
+    "kv",
+    "r2",
+    "queue",
+    "do",
+    "service",
+    "ai",
+    "vectorize",
+    "hyperdrive",
+    "secret"
+  ];
+  let firstSection = true;
+  for (const type of typeOrder) {
+    const typeBindings = bindingsByType.get(type);
+    if (!typeBindings || typeBindings.length === 0) continue;
+    const tsType = getTypeForBinding(type);
+    const sectionName = getSectionName2(type);
+    if (!firstSection) {
+      lines.push("");
+    }
+    lines.push(`  // ${sectionName}`);
+    firstSection = false;
+    for (const binding of typeBindings) {
+      lines.push(`  ${binding.name}: ${tsType}`);
+    }
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("declare module '@cloudwerk/core/context' {");
+  lines.push("  // Route parameters proxy");
+  lines.push("  export const params: Record<string, string>");
+  lines.push("");
+  lines.push("  // Current request proxy");
+  lines.push("  export const request: Request");
+  lines.push("");
+  lines.push("  // Environment bindings proxy (typed from wrangler.toml)");
+  lines.push("  export const env: CloudwerkEnv");
+  lines.push("");
+  lines.push("  // Cloudflare execution context proxy");
+  lines.push("  export const executionCtx: {");
+  lines.push("    waitUntil(promise: Promise<unknown>): void");
+  lines.push("    passThroughOnException(): void");
+  lines.push("  }");
+  lines.push("");
+  lines.push("  // Helper functions");
+  lines.push("  export function getRequestId(): string");
+  lines.push("  export function get<T>(key: string): T | undefined");
+  lines.push("  export function set<T>(key: string, value: T): void");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function groupBindingsByType(bindings2) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const binding of bindings2) {
+    const existing = grouped.get(binding.type) || [];
+    existing.push(binding);
+    grouped.set(binding.type, existing);
+  }
+  return grouped;
+}
+function getSectionName2(type) {
+  switch (type) {
+    case "d1":
+      return "D1 Databases";
+    case "kv":
+      return "KV Namespaces";
+    case "r2":
+      return "R2 Buckets";
+    case "queue":
+      return "Queues";
+    case "do":
+      return "Durable Objects";
+    case "service":
+      return "Services";
+    case "secret":
+      return "Environment Variables";
+    case "ai":
+      return "AI";
+    case "vectorize":
+      return "Vectorize Indexes";
+    case "hyperdrive":
+      return "Hyperdrive";
+    default:
+      return "Other";
+  }
+}
+
+// src/utils/tsconfig-updater.ts
+import * as fs10 from "fs";
+import * as path11 from "path";
+var CLOUDWERK_TYPES_INCLUDE = ".cloudwerk/types/**/*";
+var BINDINGS_PATH_KEY = "@cloudwerk/core/bindings";
+var CONTEXT_PATH_KEY = "@cloudwerk/core/context";
+function updateTsConfigPaths(cwd) {
+  const tsconfigPath = path11.join(cwd, "tsconfig.json");
+  const changes = {
+    addedIncludes: [],
+    addedPaths: [],
+    setBaseUrl: false
+  };
+  if (!fs10.existsSync(tsconfigPath)) {
+    const newConfig = {
+      compilerOptions: {
+        baseUrl: ".",
+        paths: {
+          [BINDINGS_PATH_KEY]: ["./.cloudwerk/types/bindings.d.ts"],
+          [CONTEXT_PATH_KEY]: ["./.cloudwerk/types/context.d.ts"]
+        }
+      },
+      include: [CLOUDWERK_TYPES_INCLUDE]
+    };
+    fs10.writeFileSync(tsconfigPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+    return {
+      tsconfigPath,
+      modified: true,
+      changes: {
+        addedIncludes: [CLOUDWERK_TYPES_INCLUDE],
+        addedPaths: [BINDINGS_PATH_KEY, CONTEXT_PATH_KEY],
+        setBaseUrl: true
+      }
+    };
+  }
+  const content = fs10.readFileSync(tsconfigPath, "utf-8");
+  let config;
+  try {
+    config = JSON.parse(content);
+  } catch {
+    throw new Error(
+      `Invalid JSON in tsconfig.json. Please fix the syntax and try again.`
+    );
+  }
+  let modified = false;
+  if (!config.compilerOptions) {
+    config.compilerOptions = {};
+  }
+  if (!config.compilerOptions.baseUrl) {
+    config.compilerOptions.baseUrl = ".";
+    changes.setBaseUrl = true;
+    modified = true;
+  }
+  if (!config.compilerOptions.paths) {
+    config.compilerOptions.paths = {};
+  }
+  if (!config.compilerOptions.paths[BINDINGS_PATH_KEY]) {
+    config.compilerOptions.paths[BINDINGS_PATH_KEY] = [
+      "./.cloudwerk/types/bindings.d.ts"
+    ];
+    changes.addedPaths.push(BINDINGS_PATH_KEY);
+    modified = true;
+  }
+  if (!config.compilerOptions.paths[CONTEXT_PATH_KEY]) {
+    config.compilerOptions.paths[CONTEXT_PATH_KEY] = [
+      "./.cloudwerk/types/context.d.ts"
+    ];
+    changes.addedPaths.push(CONTEXT_PATH_KEY);
+    modified = true;
+  }
+  if (!config.include) {
+    config.include = [];
+  }
+  if (!config.include.includes(CLOUDWERK_TYPES_INCLUDE)) {
+    config.include.unshift(CLOUDWERK_TYPES_INCLUDE);
+    changes.addedIncludes.push(CLOUDWERK_TYPES_INCLUDE);
+    modified = true;
+  }
+  if (modified) {
+    const newContent = JSON.stringify(config, null, 2) + "\n";
+    fs10.writeFileSync(tsconfigPath, newContent, "utf-8");
+  }
+  return {
+    tsconfigPath,
+    modified,
+    changes
+  };
+}
+
+// src/commands/bindings/generate-types.ts
+async function bindingsGenerateTypes(options) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  try {
+    const cwd = process.cwd();
+    const wranglerPath = findWranglerToml(cwd);
+    if (!wranglerPath) {
+      throw new CliError(
+        "wrangler.toml not found",
+        "ENOENT",
+        "Create a wrangler.toml file or run this command from a Cloudwerk project directory."
+      );
+    }
+    logger.debug(`Found wrangler config: ${wranglerPath}`);
+    const config = readWranglerToml(cwd);
+    const bindings2 = extractBindings(config);
+    if (bindings2.length === 0) {
+      console.log();
+      console.log(pc8.yellow("No bindings found in wrangler.toml."));
+      console.log();
+      console.log(
+        pc8.dim(`Use 'cloudwerk bindings add' to add a binding first.`)
+      );
+      console.log();
+      return;
     }
     console.log();
-    logger.success("Types generated successfully!");
+    logger.info("Generating TypeScript types...");
+    const result = generateEnvTypes(cwd, bindings2);
+    console.log();
+    console.log(
+      pc8.green("\u2713") + ` Updated ${pc8.bold("env.d.ts")} with ${result.bindingCount} binding(s):`
+    );
+    console.log();
+    for (const binding of result.bindings) {
+      console.log(`    ${pc8.cyan(binding.name)}: ${pc8.dim(binding.type)}`);
+    }
+    logger.debug("Generating .cloudwerk/types/...");
+    const cloudwerkResult = generateCloudwerkTypes(cwd, bindings2);
     console.log();
     console.log(
-      pc8.dim("Make sure env.d.ts is included in your tsconfig.json:")
+      pc8.green("\u2713") + ` Generated ${pc8.bold(".cloudwerk/types/")} for importable bindings:`
     );
+    console.log(`    ${pc8.dim(cloudwerkResult.files.bindings)}`);
+    console.log(`    ${pc8.dim(cloudwerkResult.files.context)}`);
+    logger.debug("Updating tsconfig.json...");
+    const tsconfigResult = updateTsConfigPaths(cwd);
+    if (tsconfigResult.modified) {
+      console.log();
+      console.log(
+        pc8.green("\u2713") + ` Updated ${pc8.bold("tsconfig.json")}:`
+      );
+      if (tsconfigResult.changes.setBaseUrl) {
+        console.log(`    ${pc8.dim('Added baseUrl: "."')}`);
+      }
+      for (const pathKey of tsconfigResult.changes.addedPaths) {
+        console.log(`    ${pc8.dim(`Added paths: "${pathKey}"`)}`);
+      }
+      for (const include of tsconfigResult.changes.addedIncludes) {
+        console.log(`    ${pc8.dim(`Added include: "${include}"`)}`);
+      }
+    } else {
+      logger.debug("tsconfig.json already configured");
+    }
+    console.log();
+    logger.success("Types generated successfully!");
+    console.log();
+    console.log(pc8.bold("Usage:"));
+    console.log();
+    console.log(pc8.dim("  // Import bindings directly (new)"));
+    console.log(pc8.cyan(`  import { ${bindings2[0]?.name || "DB"} } from '@cloudwerk/core/bindings'`));
+    console.log();
+    console.log(pc8.dim("  // Import context helpers (new)"));
+    console.log(pc8.cyan(`  import { params, request, get } from '@cloudwerk/core/context'`));
+    console.log();
+    console.log(pc8.dim("  // Or use getContext() (existing)"));
+    console.log(pc8.cyan(`  import { getContext } from '@cloudwerk/core'`));
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/triggers.ts
+import pc9 from "picocolors";
+import {
+  loadConfig as loadConfig3,
+  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 loadConfig3(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 loadConfig4,
+  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 loadConfig4(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(
-      pc8.dim('  "include": ["env.d.ts", "app/**/*"]')
+      `  ${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 loadConfig5,
+  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 loadConfig5(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 loadConfig6,
+  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 loadConfig6(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/index.ts
-program.name("cloudwerk").description("Cloudwerk CLI - Build and deploy full-stack apps to Cloudflare").version(VERSION);
+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);
 program.command("build [path]").description("Build project for production deployment to Cloudflare Workers").option("-o, --output <dir>", "Output directory", "./dist").option("--ssg", "Generate static pages for routes with rendering: static").option("--minify", "Minify bundles (default: true)").option("--no-minify", "Disable minification").option("--sourcemap", "Generate source maps").option("-c, --config <path>", "Path to config file").option("--verbose", "Enable verbose logging").action(build);
 program.command("deploy [path]").description("Deploy to Cloudflare Workers").option("-e, --env <environment>", "Environment to deploy to").option("--dry-run", "Preview deployment without executing").option("--skip-build", "Skip the build step").option("-c, --config <path>", "Path to config file").option("--verbose", "Enable verbose logging").action(deploy);
 var configCmd = program.command("config").description("Manage Cloudwerk configuration");
 configCmd.command("get <key>").description("Get a configuration value").action(configGet);
 configCmd.command("set <key> <value>").description("Set a configuration value").action(configSet);
-var bindingsCmd = program.command("bindings").description("Manage Cloudflare bindings (D1, KV, R2, Queues, etc.)").option("-e, --env <environment>", "Environment to operate on").option("--verbose", "Enable verbose logging").action(bindings);
+var bindingsCmd = program.command("bindings").description("Manage Cloudflare bindings (D1, KV, R2, Queues, etc.)").enablePositionalOptions().passThroughOptions().option("--verbose", "Enable verbose logging").action(bindings);
 bindingsCmd.command("add [type]").description("Add a new binding (d1, kv, r2, queue, do, secret)").option("-e, --env <environment>", "Environment to add binding to").option("--skip-types", "Skip TypeScript type generation").option("--verbose", "Enable verbose logging").action(bindingsAdd);
 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);
 program.parse();