better-cf 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1065 @@
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { spawn } from 'child_process';
+import fs7 from 'fs';
+import path3 from 'path';
+import { Project, SyntaxKind, Node } from 'ts-morph';
+import { applyEdits, modify, parse } from 'jsonc-parser';
+import chokidar from 'chokidar';
+
+// src/cli/index.ts
+function printLine(message) {
+  process.stdout.write(`${message}
+`);
+}
+function printErrLine(message) {
+  process.stderr.write(`${message}
+`);
+}
+var logger = {
+  header(title) {
+    printLine(pc.bold(pc.cyan(`== ${title} ==`)));
+  },
+  info(message) {
+    printLine(`${pc.blue("[*]")} ${message}`);
+  },
+  success(message) {
+    printLine(`${pc.green("[+]")} ${message}`);
+  },
+  warn(message) {
+    printLine(`${pc.yellow("[!]")} ${message}`);
+  },
+  error(message) {
+    printErrLine(`${pc.red("[x]")} ${message}`);
+  },
+  section(message) {
+    printLine("");
+    printLine(pc.bold(pc.white(`-- ${message} --`)));
+  },
+  item(label, value) {
+    printLine(`  -> ${pc.bold(label)}${value ? `: ${value}` : ""}`);
+  }
+};
+function runCommand(command, args, cwd, stdio = "inherit") {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio,
+      env: process.env
+    });
+    child.once("error", (error) => reject(error));
+    child.once("close", (code) => resolve(code ?? 0));
+  });
+}
+function spawnCommand(command, args, cwd) {
+  return spawn(command, args, {
+    cwd,
+    stdio: "inherit",
+    env: process.env
+  });
+}
+var DEFAULT_IGNORE = ["node_modules", ".better-cf", "dist", ".wrangler"];
+function loadCliConfig(rootDir = process.cwd()) {
+  const defaults = {
+    rootDir,
+    ignore: [...DEFAULT_IGNORE],
+    workerEntry: void 0,
+    legacyServiceWorker: false
+  };
+  const configPath = path3.join(rootDir, "better-cf.config.ts");
+  if (!fs7.existsSync(configPath)) {
+    return defaults;
+  }
+  const project = new Project({
+    compilerOptions: {
+      target: 99,
+      module: 99,
+      moduleResolution: 99
+    }
+  });
+  const sourceFile = project.addSourceFileAtPath(configPath);
+  const variable = sourceFile.getVariableDeclarations().find((decl) => decl.getName() === "betterCfConfig" && decl.getVariableStatement()?.isExported());
+  if (!variable) {
+    return defaults;
+  }
+  const initializer = variable.getInitializer();
+  if (!initializer || initializer.getKind() !== SyntaxKind.ObjectLiteralExpression) {
+    return defaults;
+  }
+  const configObject = initializer;
+  const workerEntry = readString(configObject, "workerEntry");
+  const legacyServiceWorker = readBoolean(configObject, "legacyServiceWorker");
+  const ignore = readStringArray(configObject, "ignore");
+  return {
+    rootDir,
+    workerEntry,
+    legacyServiceWorker: legacyServiceWorker ?? defaults.legacyServiceWorker,
+    ignore: ignore ? [.../* @__PURE__ */ new Set([...defaults.ignore, ...ignore])] : defaults.ignore
+  };
+}
+function readString(node, key) {
+  const property = node.getProperties().find((prop) => {
+    return Node.isPropertyAssignment(prop) && prop.getName() === key;
+  });
+  if (!property || !Node.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  if (!initializer || !Node.isStringLiteral(initializer)) {
+    return void 0;
+  }
+  return initializer.getLiteralText();
+}
+function readBoolean(node, key) {
+  const property = node.getProperties().find((prop) => {
+    return Node.isPropertyAssignment(prop) && prop.getName() === key;
+  });
+  if (!property || !Node.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() === SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (initializer.getKind() === SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  return void 0;
+}
+function readStringArray(node, key) {
+  const property = node.getProperties().find((prop) => {
+    return Node.isPropertyAssignment(prop) && prop.getName() === key;
+  });
+  if (!property || !Node.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  if (!initializer || !Node.isArrayLiteralExpression(initializer)) {
+    return void 0;
+  }
+  const values = initializer.getElements().filter((element) => Node.isStringLiteral(element)).map((element) => element.getLiteralText());
+  return values.length > 0 ? values : void 0;
+}
+function resolveWorkerEntry(config) {
+  const candidates = [
+    config.workerEntry,
+    "worker.ts",
+    "src/worker.ts",
+    "index.ts",
+    "src/index.ts"
+  ].filter((value) => Boolean(value));
+  for (const candidate of candidates) {
+    const absolutePath = path3.isAbsolute(candidate) ? candidate : path3.join(config.rootDir, candidate);
+    if (fs7.existsSync(absolutePath)) {
+      return absolutePath;
+    }
+  }
+  throw new Error(
+    "Could not find worker entry. Provide betterCfConfig.workerEntry in better-cf.config.ts or create worker.ts."
+  );
+}
+
+// src/cli/codegen.ts
+function generateCode(discovery, config) {
+  const outputDir = path3.join(config.rootDir, ".better-cf");
+  fs7.mkdirSync(outputDir, { recursive: true });
+  const workerEntryAbsolute = resolveWorkerEntry(config);
+  const entryContents = renderEntryFile(discovery, workerEntryAbsolute, outputDir, config);
+  const typesContents = renderTypesFile(discovery);
+  const entryPath = path3.join(outputDir, "entry.ts");
+  const typesPath = path3.join(outputDir, "types.d.ts");
+  fs7.writeFileSync(entryPath, entryContents, "utf8");
+  fs7.writeFileSync(typesPath, typesContents, "utf8");
+  return {
+    entryPath,
+    typesPath
+  };
+}
+function renderEntryFile(discovery, workerEntryAbsolute, outDir, config) {
+  const imports = [];
+  const bindings = [];
+  const queueMap = [];
+  imports.push(`import workerDefault, * as workerModule from '${toImportPath(outDir, workerEntryAbsolute)}';`);
+  imports.push(`import { getQueueInternals, resolveWorkerHandlers } from 'better-cf/queue/internal';`);
+  for (const queue of discovery.queues) {
+    const queueImportPath = toImportPath(outDir, queue.absoluteFilePath);
+    if (queue.isDefaultExport) {
+      imports.push(`import ${queue.importName} from '${queueImportPath}';`);
+    } else {
+      imports.push(`import { ${queue.exportName} as ${queue.importName} } from '${queueImportPath}';`);
+    }
+    bindings.push(`getQueueInternals(${queue.importName}).setBinding('${queue.bindingName}');`);
+    queueMap.push(`  '${queue.queueName}': ${queue.importName}`);
+  }
+  const scheduledBlock = `
+const __workerHandlers = resolveWorkerHandlers({ default: workerDefault, ...workerModule });
+
+export default {
+  async fetch(request: Request, env: unknown, ctx: ExecutionContext): Promise<Response> {
+    return __workerHandlers.fetch(request, env, ctx);
+  },
+
+  async queue(batch: MessageBatch<unknown>, env: unknown, ctx: ExecutionContext): Promise<void> {
+    const consumer = __queues[batch.queue];
+    if (!consumer) {
+      console.error(\`[better-cf] No queue consumer for "\${batch.queue}". Acking batch to avoid infinite retries.\`);
+      batch.ackAll();
+      return;
+    }
+
+    await getQueueInternals(consumer).consume(batch, env, ctx);
+  },
+
+  ...(__workerHandlers.scheduled
+    ? {
+        async scheduled(event: ScheduledEvent, env: unknown, ctx: ExecutionContext): Promise<void> {
+          await __workerHandlers.scheduled?.(event, env, ctx);
+        }
+      }
+    : {})
+};`;
+  const legacyWarning = config.legacyServiceWorker ? "console.warn('[better-cf] legacyServiceWorker mode is compatibility-only. Consider migrating to module workers.');" : "";
+  return `// Auto-generated by better-cf. Do not edit.
+${imports.join("\n")}
+
+${bindings.join("\n")}
+
+const __queues: Record<string, unknown> = {
+${queueMap.join(",\n")}
+};
+
+${legacyWarning}
+${scheduledBlock}
+`;
+}
+function renderTypesFile(discovery) {
+  const lines = discovery.queues.map((queue) => {
+    return `    ${queue.bindingName}: Queue;`;
+  });
+  return `// Auto-generated by better-cf. Do not edit.
+import type { Queue } from '@cloudflare/workers-types';
+
+declare module 'better-cf/queue' {
+  interface BetterCfGeneratedBindings {
+${lines.join("\n")}
+  }
+}
+
+export {};
+`;
+}
+function toImportPath(fromDir, targetFile) {
+  const relative = path3.relative(fromDir, targetFile).replace(/\\/g, "/");
+  if (relative.startsWith(".")) {
+    return relative.replace(/\.tsx?$/, "");
+  }
+  return `./${relative.replace(/\.tsx?$/, "")}`;
+}
+
+// src/cli/discovery/naming.ts
+function deriveQueueName(input) {
+  const withoutSuffix = input.replace(/Queue$/, "");
+  const kebab = withoutSuffix.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+  return kebab || input.toLowerCase();
+}
+function deriveBindingName(queueName) {
+  return `QUEUE_${queueName.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").toUpperCase()}`;
+}
+function makeImportName(queueName, isDefaultExport, exportName) {
+  if (!isDefaultExport) {
+    return exportName;
+  }
+  return `__queue_${queueName.replace(/-/g, "_")}`;
+}
+
+// src/cli/discovery/scanner.ts
+var RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "retry",
+  "retryDelay",
+  "deadLetter",
+  "visibilityTimeout",
+  "batch",
+  "message",
+  "process",
+  "processBatch",
+  "onFailure"
+]);
+async function scanQueues(config) {
+  const diagnostics = [];
+  const candidates = collectSourceFiles(config.rootDir, config.ignore);
+  const project = createProject(config.rootDir);
+  const queues = [];
+  for (const absolutePath of candidates) {
+    try {
+      const sourceFile = project.addSourceFileAtPath(absolutePath);
+      const localDefineQueueNames = getDefineQueueLocalNames(sourceFile);
+      if (localDefineQueueNames.size === 0) {
+        project.removeSourceFile(sourceFile);
+        continue;
+      }
+      for (const declaration of sourceFile.getVariableDeclarations()) {
+        const variableStatement = declaration.getVariableStatement();
+        if (!variableStatement || !variableStatement.isExported()) {
+          continue;
+        }
+        const call = declaration.getInitializerIfKind(SyntaxKind.CallExpression);
+        if (!call || !isDefineQueueCall(call, localDefineQueueNames)) {
+          continue;
+        }
+        const exportName = declaration.getName();
+        const queueName = deriveQueueName(exportName);
+        const extracted = extractQueueConfig(call, absolutePath, diagnostics, config.rootDir);
+        queues.push({
+          exportName,
+          queueName,
+          bindingName: deriveBindingName(queueName),
+          filePath: path3.relative(config.rootDir, absolutePath),
+          absoluteFilePath: absolutePath,
+          isDefaultExport: false,
+          importName: makeImportName(queueName, false, exportName),
+          config: extracted
+        });
+      }
+      for (const exportAssignment of sourceFile.getExportAssignments()) {
+        if (exportAssignment.isExportEquals()) {
+          continue;
+        }
+        const call = resolveCallExpressionFromExportAssignment(exportAssignment.getExpression());
+        if (!call || !isDefineQueueCall(call, localDefineQueueNames)) {
+          continue;
+        }
+        const basename = path3.basename(absolutePath, path3.extname(absolutePath));
+        const queueName = deriveQueueName(basename);
+        const extracted = extractQueueConfig(call, absolutePath, diagnostics, config.rootDir);
+        queues.push({
+          exportName: "default",
+          queueName,
+          bindingName: deriveBindingName(queueName),
+          filePath: path3.relative(config.rootDir, absolutePath),
+          absoluteFilePath: absolutePath,
+          isDefaultExport: true,
+          importName: makeImportName(queueName, true, "default"),
+          config: extracted
+        });
+      }
+      project.removeSourceFile(sourceFile);
+    } catch (error) {
+      diagnostics.push({
+        level: "error",
+        code: "SCANNER_FILE_ERROR",
+        message: `Failed to parse ${absolutePath}: ${toErrorMessage(error)}`,
+        filePath: path3.relative(config.rootDir, absolutePath)
+      });
+    }
+  }
+  addConflictDiagnostics(queues, diagnostics);
+  if (queues.length === 0) {
+    diagnostics.push({
+      level: "warning",
+      code: "NO_QUEUES_FOUND",
+      message: "No defineQueue exports found in this project."
+    });
+  }
+  return {
+    queues,
+    diagnostics
+  };
+}
+function createProject(rootDir) {
+  const tsConfigPath = path3.join(rootDir, "tsconfig.json");
+  if (fs7.existsSync(tsConfigPath)) {
+    return new Project({
+      tsConfigFilePath: tsConfigPath,
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  return new Project({
+    compilerOptions: {
+      target: 99,
+      module: 99,
+      moduleResolution: 99,
+      allowJs: false
+    }
+  });
+}
+function collectSourceFiles(rootDir, ignore) {
+  const files = [];
+  const ignoreSet = new Set(ignore);
+  function walk(currentPath) {
+    const entries = fs7.readdirSync(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".git")) {
+        continue;
+      }
+      if (ignoreSet.has(entry.name)) {
+        continue;
+      }
+      const absolutePath = path3.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        walk(absolutePath);
+        continue;
+      }
+      if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
+        const content = fs7.readFileSync(absolutePath, "utf8");
+        if (content.includes("defineQueue")) {
+          files.push(absolutePath);
+        }
+      }
+    }
+  }
+  walk(rootDir);
+  return files;
+}
+function getDefineQueueLocalNames(sourceFile) {
+  const names = /* @__PURE__ */ new Set();
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const specifier = importDecl.getModuleSpecifierValue();
+    if (!specifier.includes("better-cf.config")) {
+      continue;
+    }
+    for (const namedImport of importDecl.getNamedImports()) {
+      if (namedImport.getName() !== "defineQueue") {
+        continue;
+      }
+      names.add(namedImport.getAliasNode()?.getText() ?? namedImport.getName());
+    }
+  }
+  return names;
+}
+function isDefineQueueCall(call, localNames) {
+  const expression = call.getExpression();
+  if (expression.getKind() !== SyntaxKind.Identifier) {
+    return false;
+  }
+  return localNames.has(expression.getText());
+}
+function resolveCallExpressionFromExportAssignment(expression) {
+  if (expression.getKind() === SyntaxKind.CallExpression) {
+    return expression;
+  }
+  if (expression.getKind() !== SyntaxKind.Identifier) {
+    return void 0;
+  }
+  const symbol = expression.getSymbol();
+  const declaration = symbol?.getValueDeclaration();
+  if (!declaration || !Node.isVariableDeclaration(declaration)) {
+    return void 0;
+  }
+  return declaration.getInitializerIfKind(SyntaxKind.CallExpression) ?? void 0;
+}
+function extractQueueConfig(call, absolutePath, diagnostics, rootDir) {
+  const firstArg = call.getArguments()[0];
+  if (!firstArg || firstArg.getKind() !== SyntaxKind.ObjectLiteralExpression) {
+    return {
+      hasProcess: false,
+      hasProcessBatch: false,
+      isMultiJob: false
+    };
+  }
+  const objectLiteral = firstArg;
+  const hasProcess = hasProperty(objectLiteral, "process");
+  const hasProcessBatch = hasProperty(objectLiteral, "processBatch");
+  if (hasProcess && hasProcessBatch) {
+    diagnostics.push({
+      level: "error",
+      code: "INVALID_PROCESS_MODE",
+      message: "Queue config cannot include both process and processBatch.",
+      filePath: path3.relative(rootDir, absolutePath)
+    });
+  }
+  const retry = readNumberProperty(objectLiteral, "retry", diagnostics, absolutePath, rootDir);
+  const retryDelay = readNumberOrStringProperty(
+    objectLiteral,
+    "retryDelay",
+    diagnostics,
+    absolutePath,
+    rootDir
+  );
+  const deadLetter = readStringProperty(objectLiteral, "deadLetter", diagnostics, absolutePath, rootDir);
+  const visibilityTimeout = readNumberOrStringProperty(
+    objectLiteral,
+    "visibilityTimeout",
+    diagnostics,
+    absolutePath,
+    rootDir
+  );
+  const batchObject = getObjectLiteralProperty(objectLiteral, "batch");
+  const batchMaxSize = batchObject ? readNumberProperty(batchObject, "maxSize", diagnostics, absolutePath, rootDir) : void 0;
+  const batchTimeout = batchObject ? readNumberOrStringProperty(batchObject, "timeout", diagnostics, absolutePath, rootDir) : void 0;
+  const maxConcurrency = batchObject ? readNumberProperty(batchObject, "maxConcurrency", diagnostics, absolutePath, rootDir) : void 0;
+  let isMultiJob = false;
+  if (!hasProcess && !hasProcessBatch) {
+    for (const property of objectLiteral.getProperties()) {
+      if (!Node.isPropertyAssignment(property)) {
+        continue;
+      }
+      const propertyName = property.getName();
+      if (RESERVED_KEYS.has(propertyName)) {
+        continue;
+      }
+      const initializer = property.getInitializer();
+      if (!initializer || initializer.getKind() !== SyntaxKind.ObjectLiteralExpression) {
+        continue;
+      }
+      const jobObject = initializer;
+      if (hasProperty(jobObject, "message") && hasProperty(jobObject, "process")) {
+        isMultiJob = true;
+        break;
+      }
+    }
+  }
+  return {
+    retry,
+    retryDelay,
+    deadLetter,
+    batchMaxSize,
+    batchTimeout,
+    maxConcurrency,
+    visibilityTimeout,
+    hasProcess,
+    hasProcessBatch,
+    isMultiJob
+  };
+}
+function hasProperty(objectLiteral, name) {
+  return objectLiteral.getProperties().some((property) => {
+    return Node.isPropertyAssignment(property) && property.getName() === name;
+  });
+}
+function getObjectLiteralProperty(objectLiteral, name) {
+  for (const property of objectLiteral.getProperties()) {
+    if (!Node.isPropertyAssignment(property) || property.getName() !== name) {
+      continue;
+    }
+    const initializer = property.getInitializer();
+    if (initializer && initializer.getKind() === SyntaxKind.ObjectLiteralExpression) {
+      return initializer;
+    }
+  }
+  return void 0;
+}
+function readNumberProperty(objectLiteral, name, diagnostics, absolutePath, rootDir) {
+  const prop = objectLiteral.getProperties().find((property) => {
+    return Node.isPropertyAssignment(property) && property.getName() === name;
+  });
+  if (!prop || !Node.isPropertyAssignment(prop)) {
+    return void 0;
+  }
+  const initializer = prop.getInitializer();
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() !== SyntaxKind.NumericLiteral) {
+    diagnostics.push({
+      level: "warning",
+      code: "NON_STATIC_CONFIG",
+      message: `Config key ${name} in ${path3.relative(rootDir, absolutePath)} is not a static number literal.`,
+      filePath: path3.relative(rootDir, absolutePath)
+    });
+    return void 0;
+  }
+  return Number(initializer.getText());
+}
+function readStringProperty(objectLiteral, name, diagnostics, absolutePath, rootDir) {
+  const prop = objectLiteral.getProperties().find((property) => {
+    return Node.isPropertyAssignment(property) && property.getName() === name;
+  });
+  if (!prop || !Node.isPropertyAssignment(prop)) {
+    return void 0;
+  }
+  const initializer = prop.getInitializer();
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() !== SyntaxKind.StringLiteral) {
+    diagnostics.push({
+      level: "warning",
+      code: "NON_STATIC_CONFIG",
+      message: `Config key ${name} in ${path3.relative(rootDir, absolutePath)} is not a static string literal.`,
+      filePath: path3.relative(rootDir, absolutePath)
+    });
+    return void 0;
+  }
+  return initializer.getText().slice(1, -1);
+}
+function readNumberOrStringProperty(objectLiteral, name, diagnostics, absolutePath, rootDir) {
+  const prop = objectLiteral.getProperties().find((property) => {
+    return Node.isPropertyAssignment(property) && property.getName() === name;
+  });
+  if (!prop || !Node.isPropertyAssignment(prop)) {
+    return void 0;
+  }
+  const initializer = prop.getInitializer();
+  if (!initializer) {
+    return void 0;
+  }
+  if (initializer.getKind() === SyntaxKind.NumericLiteral) {
+    return Number(initializer.getText());
+  }
+  if (initializer.getKind() === SyntaxKind.StringLiteral) {
+    return initializer.getText().slice(1, -1);
+  }
+  diagnostics.push({
+    level: "warning",
+    code: "NON_STATIC_CONFIG",
+    message: `Config key ${name} in ${path3.relative(rootDir, absolutePath)} is not static.`,
+    filePath: path3.relative(rootDir, absolutePath)
+  });
+  return void 0;
+}
+function addConflictDiagnostics(queues, diagnostics) {
+  const queueNameMap = /* @__PURE__ */ new Map();
+  const bindingNameMap = /* @__PURE__ */ new Map();
+  for (const queue of queues) {
+    queueNameMap.set(queue.queueName, [...queueNameMap.get(queue.queueName) ?? [], queue.filePath]);
+    bindingNameMap.set(
+      queue.bindingName,
+      [...bindingNameMap.get(queue.bindingName) ?? [], queue.filePath]
+    );
+  }
+  for (const [queueName, files] of queueNameMap.entries()) {
+    if (files.length < 2) {
+      continue;
+    }
+    diagnostics.push({
+      level: "error",
+      code: "QUEUE_NAME_CONFLICT",
+      message: `Queue name conflict for ${queueName}: ${files.join(", ")}`
+    });
+  }
+  for (const [bindingName, files] of bindingNameMap.entries()) {
+    if (files.length < 2) {
+      continue;
+    }
+    diagnostics.push({
+      level: "error",
+      code: "BINDING_NAME_CONFLICT",
+      message: `Binding name conflict for ${bindingName}: ${files.join(", ")}`
+    });
+  }
+}
+function toErrorMessage(value) {
+  if (value instanceof Error) {
+    return value.message;
+  }
+  return String(value);
+}
+function patchJsoncConfig(filePath, discovery) {
+  let text = fs7.readFileSync(filePath, "utf8");
+  text = applyEdits(
+    text,
+    modify(text, ["main"], ".better-cf/entry.ts", {
+      formattingOptions: { insertSpaces: true, tabSize: 2 }
+    })
+  );
+  const producers = discovery.queues.map((queue) => ({
+    queue: queue.queueName,
+    binding: queue.bindingName
+  }));
+  const consumers = discovery.queues.map((queue) => ({
+    queue: queue.queueName,
+    ...queue.config.batchMaxSize !== void 0 ? { max_batch_size: queue.config.batchMaxSize } : {},
+    ...queue.config.batchTimeout !== void 0 ? { max_batch_timeout: parseDurationSeconds(queue.config.batchTimeout) } : {},
+    ...queue.config.retry !== void 0 ? { max_retries: queue.config.retry } : {},
+    ...queue.config.deadLetter !== void 0 ? { dead_letter_queue: queue.config.deadLetter } : {},
+    ...queue.config.maxConcurrency !== void 0 ? { max_concurrency: queue.config.maxConcurrency } : {},
+    ...queue.config.retryDelay !== void 0 ? { retry_delay: parseDurationSeconds(queue.config.retryDelay) } : {}
+  }));
+  text = applyEdits(
+    text,
+    modify(text, ["queues"], { producers, consumers, better_cf_managed: true }, {
+      formattingOptions: { insertSpaces: true, tabSize: 2 }
+    })
+  );
+  fs7.writeFileSync(filePath, text, "utf8");
+}
+function ensureJsoncExists(rootDir) {
+  const filePath = path3.join(rootDir, "wrangler.jsonc");
+  if (!fs7.existsSync(filePath)) {
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const content = `{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "my-worker",
+  "main": ".better-cf/entry.ts",
+  "compatibility_date": "${date}",
+  "queues": {
+    "producers": [],
+    "consumers": []
+  }
+}
+`;
+    fs7.writeFileSync(filePath, content, "utf8");
+  } else {
+    const parsed = parse(fs7.readFileSync(filePath, "utf8"));
+    if (!parsed.queues) {
+      patchJsoncConfig(filePath, { queues: []});
+    }
+  }
+  return filePath;
+}
+function parseDurationSeconds(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const match = value.match(/^(\d+)(s|m|h)$/);
+  if (!match) {
+    return Number(value) || 0;
+  }
+  const amount = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  if (unit === "s") {
+    return amount;
+  }
+  if (unit === "m") {
+    return amount * 60;
+  }
+  return amount * 3600;
+}
+var START_MARKER = "# --- better-cf:start ---";
+var END_MARKER = "# --- better-cf:end ---";
+function patchTomlConfig(filePath, discovery) {
+  let content = fs7.readFileSync(filePath, "utf8");
+  content = ensureMainEntry(content);
+  const generatedSection = renderQueueSection(discovery);
+  const startIndex = content.indexOf(START_MARKER);
+  const endIndex = content.indexOf(END_MARKER);
+  if (startIndex >= 0 && endIndex > startIndex) {
+    const head = content.slice(0, startIndex + START_MARKER.length);
+    const tail = content.slice(endIndex);
+    content = `${head}
+${generatedSection}
+${tail}`;
+  } else {
+    content = `${content.trimEnd()}
+
+${START_MARKER}
+${generatedSection}
+${END_MARKER}
+`;
+  }
+  fs7.writeFileSync(filePath, content, "utf8");
+}
+function ensureTomlExists(rootDir) {
+  const filePath = path3.join(rootDir, "wrangler.toml");
+  if (!fs7.existsSync(filePath)) {
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const initial = `name = "my-worker"
+main = ".better-cf/entry.ts"
+compatibility_date = "${date}"
+
+${START_MARKER}
+${END_MARKER}
+`;
+    fs7.writeFileSync(filePath, initial, "utf8");
+  }
+  return filePath;
+}
+function ensureMainEntry(content) {
+  if (/^main\s*=\s*".*"/m.test(content)) {
+    return content.replace(/^main\s*=\s*".*"/m, 'main = ".better-cf/entry.ts"');
+  }
+  return `main = ".better-cf/entry.ts"
+${content}`;
+}
+function renderQueueSection(discovery) {
+  const lines = [];
+  for (const queue of discovery.queues) {
+    lines.push("[[queues.producers]]");
+    lines.push(`queue = "${queue.queueName}"`);
+    lines.push(`binding = "${queue.bindingName}"`);
+    lines.push("");
+    lines.push("[[queues.consumers]]");
+    lines.push(`queue = "${queue.queueName}"`);
+    if (queue.config.batchMaxSize !== void 0) {
+      lines.push(`max_batch_size = ${queue.config.batchMaxSize}`);
+    }
+    if (queue.config.batchTimeout !== void 0) {
+      lines.push(`max_batch_timeout = ${parseDurationSeconds2(queue.config.batchTimeout)}`);
+    }
+    if (queue.config.retry !== void 0) {
+      lines.push(`max_retries = ${queue.config.retry}`);
+    }
+    if (queue.config.deadLetter !== void 0) {
+      lines.push(`dead_letter_queue = "${queue.config.deadLetter}"`);
+    }
+    if (queue.config.maxConcurrency !== void 0) {
+      lines.push(`max_concurrency = ${queue.config.maxConcurrency}`);
+    }
+    if (queue.config.retryDelay !== void 0) {
+      lines.push(`retry_delay = ${parseDurationSeconds2(queue.config.retryDelay)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+function parseDurationSeconds2(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const match = value.match(/^(\d+)(s|m|h)$/);
+  if (!match) {
+    return Number(value) || 0;
+  }
+  const amount = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  if (unit === "s") {
+    return amount;
+  }
+  if (unit === "m") {
+    return amount * 60;
+  }
+  return amount * 3600;
+}
+
+// src/cli/wrangler/index.ts
+function patchWranglerConfig(config, discovery) {
+  const existing = detectWranglerConfig(config.rootDir);
+  if (existing && (existing.endsWith(".jsonc") || existing.endsWith(".json"))) {
+    patchJsoncConfig(existing, discovery);
+    return existing;
+  }
+  if (existing && existing.endsWith(".toml")) {
+    patchTomlConfig(existing, discovery);
+    return existing;
+  }
+  const created = ensureTomlExists(config.rootDir);
+  patchTomlConfig(created, discovery);
+  return created;
+}
+function detectWranglerConfig(rootDir) {
+  const preferred = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
+  for (const fileName of preferred) {
+    const absolutePath = path3.join(rootDir, fileName);
+    if (fs7.existsSync(absolutePath)) {
+      return absolutePath;
+    }
+  }
+  if (fs7.existsSync(path3.join(rootDir, "package.json")) && fs7.existsSync(path3.join(rootDir, "src"))) {
+    return ensureJsoncExists(rootDir);
+  }
+  return void 0;
+}
+
+// src/cli/commands/generate.ts
+async function runGenerate(rootDir = process.cwd()) {
+  const config = loadCliConfig(rootDir);
+  const discovery = await scanQueues(config);
+  for (const diagnostic of discovery.diagnostics) {
+    if (diagnostic.level === "error") {
+      logger.error(diagnostic.message);
+    } else {
+      logger.warn(diagnostic.message);
+    }
+  }
+  const hasErrors = discovery.diagnostics.some((diag) => diag.level === "error");
+  if (hasErrors) {
+    throw new Error("Queue discovery failed due to configuration errors.");
+  }
+  const generated = generateCode(discovery, config);
+  const wranglerConfigPath = patchWranglerConfig(config, discovery);
+  return {
+    discovery,
+    generatedEntryPath: generated.entryPath,
+    generatedTypesPath: generated.typesPath,
+    wranglerConfigPath
+  };
+}
+async function generateCommand(rootDir = process.cwd()) {
+  const result = await runGenerate(rootDir);
+  logger.success(`Generated ${result.discovery.queues.length} queue(s)`);
+  logger.item("entry", result.generatedEntryPath);
+  logger.item("types", result.generatedTypesPath);
+  logger.item("wrangler", result.wranglerConfigPath);
+}
+
+// src/cli/commands/deploy.ts
+async function deployCommand(rootDir = process.cwd()) {
+  const result = await runGenerate(rootDir);
+  logger.section("Deploying with wrangler");
+  const code = await runCommand("npx", ["wrangler", "deploy"], rootDir, "inherit");
+  if (code !== 0) {
+    throw new Error(`wrangler deploy failed with code ${code}`);
+  }
+  logger.success("Deployment complete");
+  logger.section("Active queue bindings");
+  for (const queue of result.discovery.queues) {
+    logger.item(queue.queueName, queue.bindingName);
+  }
+}
+function createProjectWatcher(rootDir, options) {
+  const watcher = chokidar.watch(["**/*.ts", "**/*.tsx"], {
+    cwd: rootDir,
+    ignored: options.ignored.map((entry) => `${entry}/**`),
+    ignoreInitial: true
+  });
+  const handler = async (filePath) => {
+    if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) {
+      return;
+    }
+    await options.onRelevantChange(filePath);
+  };
+  watcher.on("add", handler);
+  watcher.on("change", handler);
+  watcher.on("unlink", handler);
+  return watcher;
+}
+
+// src/cli/commands/dev.ts
+async function devCommand(options, rootDir = process.cwd()) {
+  if (options.remote) {
+    throw new Error("Cloudflare Queues do not support wrangler dev --remote. Use local mode only.");
+  }
+  let wranglerProcess = null;
+  let isRebuilding = false;
+  const buildAndRestart = async (reason) => {
+    if (isRebuilding) {
+      return;
+    }
+    isRebuilding = true;
+    try {
+      const result = await runGenerate(rootDir);
+      logger.success(`Regenerated project (${reason}) with ${result.discovery.queues.length} queue(s)`);
+      if (wranglerProcess) {
+        wranglerProcess.kill();
+      }
+      wranglerProcess = spawnCommand("npx", ["wrangler", "dev", "--port", options.port], rootDir);
+      wranglerProcess.once("error", (error) => {
+        logger.error(`Failed to start wrangler dev: ${error.message}`);
+      });
+    } finally {
+      isRebuilding = false;
+    }
+  };
+  await buildAndRestart("initial build");
+  if (options.watch) {
+    const watcher = createProjectWatcher(rootDir, {
+      ignored: ["node_modules", ".better-cf", "dist"],
+      onRelevantChange: async (filePath) => {
+        await buildAndRestart(`file changed: ${filePath}`);
+      }
+    });
+    process.on("SIGINT", async () => {
+      await watcher.close();
+      wranglerProcess?.kill();
+      process.exit(0);
+    });
+  } else {
+    process.on("SIGINT", () => {
+      wranglerProcess?.kill();
+      process.exit(0);
+    });
+  }
+}
+async function initCommand(rootDir = process.cwd()) {
+  const configPath = path3.join(rootDir, "better-cf.config.ts");
+  if (!fs7.existsSync(configPath)) {
+    fs7.writeFileSync(configPath, defaultConfigTemplate(), "utf8");
+    logger.success("Created better-cf.config.ts");
+  }
+  const workerPath = path3.join(rootDir, "worker.ts");
+  const srcWorkerPath = path3.join(rootDir, "src", "worker.ts");
+  if (!fs7.existsSync(workerPath) && !fs7.existsSync(srcWorkerPath)) {
+    fs7.writeFileSync(workerPath, defaultWorkerTemplate(), "utf8");
+    logger.success("Created worker.ts");
+  }
+  const outputDir = path3.join(rootDir, ".better-cf");
+  fs7.mkdirSync(outputDir, { recursive: true });
+  const gitignorePath = path3.join(rootDir, ".gitignore");
+  if (!fs7.existsSync(gitignorePath)) {
+    fs7.writeFileSync(gitignorePath, ".better-cf/\nnode_modules/\n", "utf8");
+    logger.success("Created .gitignore");
+  } else {
+    const existing = fs7.readFileSync(gitignorePath, "utf8");
+    if (!existing.includes(".better-cf/")) {
+      fs7.appendFileSync(gitignorePath, "\n.better-cf/\n", "utf8");
+      logger.success("Updated .gitignore");
+    }
+  }
+  const packageJsonPath = path3.join(rootDir, "package.json");
+  if (fs7.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs7.readFileSync(packageJsonPath, "utf8"));
+    packageJson.scripts = packageJson.scripts ?? {};
+    packageJson.scripts.dev = packageJson.scripts.dev ?? "better-cf dev";
+    packageJson.scripts.deploy = packageJson.scripts.deploy ?? "better-cf deploy";
+    packageJson.scripts.generate = "better-cf generate";
+    fs7.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+    logger.success("Updated package.json scripts");
+  }
+  const wranglerTomlPath = path3.join(rootDir, "wrangler.toml");
+  const wranglerJsoncPath = path3.join(rootDir, "wrangler.jsonc");
+  const wranglerJsonPath = path3.join(rootDir, "wrangler.json");
+  if (!fs7.existsSync(wranglerTomlPath) && !fs7.existsSync(wranglerJsoncPath) && !fs7.existsSync(wranglerJsonPath)) {
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    fs7.writeFileSync(
+      wranglerTomlPath,
+      `name = "my-worker"
+main = ".better-cf/entry.ts"
+compatibility_date = "${date}"
+
+# --- better-cf:start ---
+# --- better-cf:end ---
+`,
+      "utf8"
+    );
+    logger.success("Created wrangler.toml");
+  }
+  logger.info("Next steps: create a queue export and run `better-cf dev`.");
+}
+function defaultConfigTemplate() {
+  return `import { createSDK } from 'better-cf/queue';
+
+export type Env = {
+  // DB: D1Database;
+};
+
+export const { defineQueue, defineWorker } = createSDK<Env>();
+
+export const betterCfConfig = {
+  // workerEntry: 'worker.ts',
+  // ignore: ['coverage'],
+  legacyServiceWorker: false,
+};
+`;
+}
+function defaultWorkerTemplate() {
+  return `import { defineWorker } from './better-cf.config';
+
+export default defineWorker({
+  async fetch() {
+    return new Response('better-cf ready');
+  },
+});
+`;
+}
+
+// src/cli/index.ts
+async function run(argv = process.argv.slice(2)) {
+  const program = new Command();
+  program.name("better-cf").description("better-cf queue SDK CLI").version("0.1.0");
+  program.command("init").description("Initialize better-cf in the current project").action(async () => {
+    await initCommand();
+  });
+  program.command("generate").description("Scan queues and regenerate .better-cf files").action(async () => {
+    await generateCommand();
+  });
+  program.command("dev").description("Run local development with queue codegen and wrangler dev").option("-p, --port <port>", "Port to pass to wrangler dev", "8787").option("--no-watch", "Disable file watcher").option("--remote", "Pass through remote mode (blocked for queues)").action(async (options) => {
+    await devCommand(options);
+  });
+  program.command("deploy").description("Generate and deploy via wrangler deploy").action(async () => {
+    await deployCommand();
+  });
+  try {
+    await program.parseAsync(argv, { from: "user" });
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}
+
+export { run };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map