@cloudwerk/cli 0.11.0 → 0.12.0

package/dist/index.js

@@ -1217,97 +1217,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 +1431,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 +1835,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 +1972,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 +2030,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 +2172,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 +2237,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 +2266,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,6 +2786,279 @@ function runWranglerCommandWithInput2(args, inputData) {
 
 // src/commands/bindings/generate-types.ts
 import pc8 from "picocolors";
+
+// 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("");
+    }
+    lines.push(`  // ${sectionName}`);
+    firstSection = false;
+    for (const binding of typeBindings) {
+      lines.push(`  export const ${binding.name}: ${tsType}`);
+    }
+  }
+  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);
@@ -2763,15 +3096,46 @@ async function bindingsGenerateTypes(options) {
     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();
-    logger.success("Types generated successfully!");
-    console.log();
-    console.log(
-      pc8.dim("Make sure env.d.ts is included in your tsconfig.json:")
-    );
     console.log(
-      pc8.dim('  "include": ["env.d.ts", "app/**/*"]')
+      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);
@@ -2779,14 +3143,14 @@ async function bindingsGenerateTypes(options) {
 }
 
 // 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwerk/cli",
-  "version": "0.11.0",
+  "version": "0.12.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/vite-plugin": "^0.4.1",
-    "@cloudwerk/ui": "^0.11.0",
-    "@cloudwerk/core": "^0.11.0"
+    "@cloudwerk/ui": "^0.12.0",
+    "@cloudwerk/vite-plugin": "^0.5.0",
+    "@cloudwerk/core": "^0.12.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",