@cloudwerk/cli 0.12.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;
@@ -3142,6 +3186,797 @@ async function bindingsGenerateTypes(options) {
   }
 }
 
+// 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(
+      `  ${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).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 +3990,8 @@ 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);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwerk/cli",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Dev server, build, deploy commands for Cloudwerk",
   "repository": {
     "type": "git",
@@ -30,9 +30,9 @@
     "esbuild": "^0.25.0",
     "picocolors": "^1.1.0",
     "vite": "^6.0.0",
-    "@cloudwerk/ui": "^0.12.0",
-    "@cloudwerk/vite-plugin": "^0.5.0",
-    "@cloudwerk/core": "^0.12.0"
+    "@cloudwerk/core": "^0.13.0",
+    "@cloudwerk/ui": "^0.13.0",
+    "@cloudwerk/vite-plugin": "^0.6.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",