@cloudwerk/cli 0.10.0 → 0.12.0

package/dist/index.js

@@ -1148,12 +1148,2011 @@ async function askConfirmation(question, defaultValue) {
   });
 }
 
+// src/commands/bindings.ts
+import * as path8 from "path";
+import pc4 from "picocolors";
+
+// src/utils/command-error-handler.ts
+import pc3 from "picocolors";
+function handleCommandError(error, verbose = false) {
+  if (error instanceof CliError) {
+    printError(error.message, error.suggestion);
+    process.exit(1);
+  }
+  if (error instanceof Error && (error.message.includes("User force closed") || error.name === "ExitPromptError")) {
+    console.log();
+    console.log(pc3.dim("Cancelled."));
+    process.exit(0);
+  }
+  if (error instanceof Error) {
+    printError(error.message);
+    if (verbose && error.stack) {
+      console.log(error.stack);
+    }
+    process.exit(1);
+  }
+  printError(String(error));
+  process.exit(1);
+}
+
+// src/utils/wrangler-toml.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+import TOML from "@iarna/toml";
+function findWranglerToml(cwd) {
+  const wranglerPath = path7.join(cwd, "wrangler.toml");
+  if (fs7.existsSync(wranglerPath)) {
+    return wranglerPath;
+  }
+  const wranglerJsonPath = path7.join(cwd, "wrangler.json");
+  if (fs7.existsSync(wranglerJsonPath)) {
+    return wranglerJsonPath;
+  }
+  return null;
+}
+function readWranglerToml(cwd) {
+  const configPath = findWranglerToml(cwd);
+  if (!configPath) {
+    return {};
+  }
+  const content = fs7.readFileSync(configPath, "utf-8");
+  if (configPath.endsWith(".json")) {
+    return JSON.parse(content);
+  }
+  return TOML.parse(content);
+}
+function writeWranglerToml(cwd, config) {
+  const configPath = path7.join(cwd, "wrangler.toml");
+  const content = TOML.stringify(config);
+  fs7.writeFileSync(configPath, content, "utf-8");
+}
+function getEnvConfig(config, env) {
+  if (!env || !config.env?.[env]) {
+    return config;
+  }
+  return {
+    ...config,
+    ...config.env[env]
+  };
+}
+function extractBindings(config, env) {
+  const envConfig = getEnvConfig(config, env);
+  return extractBindingsFromConfig(envConfig);
+}
+function getEnvironments(config) {
+  if (!config.env) {
+    return [];
+  }
+  return Object.keys(config.env);
+}
+function addD1Binding(cwd, bindingName, databaseName, databaseId, env) {
+  const config = readWranglerToml(cwd);
+  const newBinding = {
+    binding: bindingName,
+    database_name: databaseName,
+    database_id: databaseId
+  };
+  if (env) {
+    if (!config.env) config.env = {};
+    if (!config.env[env]) config.env[env] = {};
+    if (!config.env[env].d1_databases) config.env[env].d1_databases = [];
+    config.env[env].d1_databases.push(newBinding);
+  } else {
+    if (!config.d1_databases) config.d1_databases = [];
+    config.d1_databases.push(newBinding);
+  }
+  writeWranglerToml(cwd, config);
+}
+function addKVBinding(cwd, bindingName, namespaceId, previewId, env) {
+  const config = readWranglerToml(cwd);
+  const newBinding = {
+    binding: bindingName,
+    id: namespaceId
+  };
+  if (previewId) {
+    newBinding.preview_id = previewId;
+  }
+  if (env) {
+    if (!config.env) config.env = {};
+    if (!config.env[env]) config.env[env] = {};
+    if (!config.env[env].kv_namespaces) config.env[env].kv_namespaces = [];
+    config.env[env].kv_namespaces.push(newBinding);
+  } else {
+    if (!config.kv_namespaces) config.kv_namespaces = [];
+    config.kv_namespaces.push(newBinding);
+  }
+  writeWranglerToml(cwd, config);
+}
+function addR2Binding(cwd, bindingName, bucketName, env) {
+  const config = readWranglerToml(cwd);
+  const newBinding = {
+    binding: bindingName,
+    bucket_name: bucketName
+  };
+  if (env) {
+    if (!config.env) config.env = {};
+    if (!config.env[env]) config.env[env] = {};
+    if (!config.env[env].r2_buckets) config.env[env].r2_buckets = [];
+    config.env[env].r2_buckets.push(newBinding);
+  } else {
+    if (!config.r2_buckets) config.r2_buckets = [];
+    config.r2_buckets.push(newBinding);
+  }
+  writeWranglerToml(cwd, config);
+}
+function addQueueBinding(cwd, bindingName, queueName, env) {
+  const config = readWranglerToml(cwd);
+  const newBinding = {
+    binding: bindingName,
+    queue: queueName
+  };
+  if (env) {
+    if (!config.env) config.env = {};
+    if (!config.env[env]) config.env[env] = {};
+    if (!config.env[env].queues) config.env[env].queues = {};
+    if (!config.env[env].queues.producers)
+      config.env[env].queues.producers = [];
+    config.env[env].queues.producers.push(newBinding);
+  } else {
+    if (!config.queues) config.queues = {};
+    if (!config.queues.producers) config.queues.producers = [];
+    config.queues.producers.push(newBinding);
+  }
+  writeWranglerToml(cwd, config);
+}
+function addDurableObjectBinding(cwd, bindingName, className, scriptName, env) {
+  const config = readWranglerToml(cwd);
+  const newBinding = {
+    name: bindingName,
+    class_name: className
+  };
+  if (scriptName) {
+    newBinding.script_name = scriptName;
+  }
+  if (env) {
+    if (!config.env) config.env = {};
+    if (!config.env[env]) config.env[env] = {};
+    if (!config.env[env].durable_objects)
+      config.env[env].durable_objects = { bindings: [] };
+    config.env[env].durable_objects.bindings.push(newBinding);
+  } else {
+    if (!config.durable_objects) config.durable_objects = { bindings: [] };
+    if (!config.durable_objects.bindings) config.durable_objects.bindings = [];
+    config.durable_objects.bindings.push(newBinding);
+  }
+  writeWranglerToml(cwd, config);
+}
+function addSecretBinding(cwd, name, value, env) {
+  const config = readWranglerToml(cwd);
+  if (env) {
+    if (!config.env) config.env = {};
+    if (!config.env[env]) config.env[env] = {};
+    if (!config.env[env].vars) config.env[env].vars = {};
+    config.env[env].vars[name] = value;
+  } else {
+    if (!config.vars) config.vars = {};
+    config.vars[name] = value;
+  }
+  writeWranglerToml(cwd, config);
+}
+function removeBinding(cwd, bindingName, env) {
+  const config = readWranglerToml(cwd);
+  let removed = false;
+  const removeFromConfig = (cfg) => {
+    let found = false;
+    if (cfg.d1_databases) {
+      const idx = cfg.d1_databases.findIndex((b) => b.binding === bindingName);
+      if (idx !== -1) {
+        cfg.d1_databases.splice(idx, 1);
+        if (cfg.d1_databases.length === 0) delete cfg.d1_databases;
+        found = true;
+      }
+    }
+    if (cfg.kv_namespaces) {
+      const idx = cfg.kv_namespaces.findIndex((b) => b.binding === bindingName);
+      if (idx !== -1) {
+        cfg.kv_namespaces.splice(idx, 1);
+        if (cfg.kv_namespaces.length === 0) delete cfg.kv_namespaces;
+        found = true;
+      }
+    }
+    if (cfg.r2_buckets) {
+      const idx = cfg.r2_buckets.findIndex((b) => b.binding === bindingName);
+      if (idx !== -1) {
+        cfg.r2_buckets.splice(idx, 1);
+        if (cfg.r2_buckets.length === 0) delete cfg.r2_buckets;
+        found = true;
+      }
+    }
+    if (cfg.queues?.producers) {
+      const idx = cfg.queues.producers.findIndex(
+        (b) => b.binding === bindingName
+      );
+      if (idx !== -1) {
+        cfg.queues.producers.splice(idx, 1);
+        if (cfg.queues.producers.length === 0) delete cfg.queues.producers;
+        if (!cfg.queues.producers && !cfg.queues.consumers) delete cfg.queues;
+        found = true;
+      }
+    }
+    if (cfg.durable_objects?.bindings) {
+      const idx = cfg.durable_objects.bindings.findIndex(
+        (b) => b.name === bindingName
+      );
+      if (idx !== -1) {
+        cfg.durable_objects.bindings.splice(idx, 1);
+        if (cfg.durable_objects.bindings.length === 0)
+          delete cfg.durable_objects;
+        found = true;
+      }
+    }
+    if (cfg.services) {
+      const idx = cfg.services.findIndex((b) => b.binding === bindingName);
+      if (idx !== -1) {
+        cfg.services.splice(idx, 1);
+        if (cfg.services.length === 0) delete cfg.services;
+        found = true;
+      }
+    }
+    if (cfg.vars && bindingName in cfg.vars) {
+      delete cfg.vars[bindingName];
+      if (Object.keys(cfg.vars).length === 0) delete cfg.vars;
+      found = true;
+    }
+    if (cfg.ai && cfg.ai.binding === bindingName) {
+      delete cfg.ai;
+      found = true;
+    }
+    if (cfg.vectorize) {
+      const idx = cfg.vectorize.findIndex((b) => b.binding === bindingName);
+      if (idx !== -1) {
+        cfg.vectorize.splice(idx, 1);
+        if (cfg.vectorize.length === 0) delete cfg.vectorize;
+        found = true;
+      }
+    }
+    if (cfg.hyperdrive) {
+      const idx = cfg.hyperdrive.findIndex((b) => b.binding === bindingName);
+      if (idx !== -1) {
+        cfg.hyperdrive.splice(idx, 1);
+        if (cfg.hyperdrive.length === 0) delete cfg.hyperdrive;
+        found = true;
+      }
+    }
+    return found;
+  };
+  if (env && config.env?.[env]) {
+    removed = removeFromConfig(config.env[env]);
+  } else {
+    removed = removeFromConfig(config);
+  }
+  if (removed) {
+    writeWranglerToml(cwd, config);
+  }
+  return removed;
+}
+function setAccountId(cwd, accountId) {
+  const config = readWranglerToml(cwd);
+  config.account_id = accountId;
+  writeWranglerToml(cwd, config);
+}
+function bindingExists(config, bindingName, 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":
+      return "D1";
+    case "kv":
+      return "KV";
+    case "r2":
+      return "R2";
+    case "queue":
+      return "Queue";
+    case "do":
+      return "Durable Object";
+    case "service":
+      return "Service";
+    case "secret":
+      return "Secret/Var";
+    case "ai":
+      return "AI";
+    case "vectorize":
+      return "Vectorize";
+    case "hyperdrive":
+      return "Hyperdrive";
+    default:
+      return type;
+  }
+}
+function truncateId(id, maxLen = 12) {
+  if (id.length <= maxLen) return id;
+  return id.slice(0, maxLen - 3) + "...";
+}
+
+// src/commands/bindings.ts
+async function bindings(options) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  const env = options.env;
+  try {
+    const cwd = process.cwd();
+    const wranglerPath = findWranglerToml(cwd);
+    if (!wranglerPath) {
+      throw new CliError(
+        "wrangler.toml not found",
+        "ENOENT",
+        "Create a wrangler.toml file or run this command from a Cloudwerk project directory."
+      );
+    }
+    logger.debug(`Found wrangler config: ${wranglerPath}`);
+    const config = readWranglerToml(cwd);
+    const projectName = config.name || path8.basename(cwd);
+    const bindingsList = extractBindings(config, env);
+    const environments = getEnvironments(config);
+    console.log();
+    const envLabel = env ? env : "production";
+    console.log(
+      pc4.bold(`Bindings for ${projectName}`) + pc4.dim(` (${envLabel}):`)
+    );
+    console.log();
+    if (bindingsList.length === 0) {
+      console.log(pc4.dim("  No bindings configured."));
+      console.log();
+      console.log(
+        pc4.dim(
+          `  Use 'cloudwerk bindings add' to add a new binding${env ? ` --env ${env}` : ""}.`
+        )
+      );
+    } else {
+      console.log(
+        pc4.dim("  Type            Binding        Resource")
+      );
+      console.log(
+        pc4.dim("  " + "\u2500".repeat(14) + "  " + "\u2500".repeat(13) + "  " + "\u2500".repeat(30))
+      );
+      for (const binding of bindingsList) {
+        const typeName = getBindingTypeName(binding.type).padEnd(14);
+        const bindingName = binding.name.padEnd(13);
+        let resource = "";
+        if (binding.resourceName && binding.resourceId) {
+          resource = `${binding.resourceName} (${truncateId(binding.resourceId)})`;
+        } else if (binding.resourceName) {
+          resource = binding.resourceName;
+        } else if (binding.resourceId) {
+          resource = `(${truncateId(binding.resourceId)})`;
+        } else {
+          resource = pc4.dim("(configured)");
+        }
+        console.log(`  ${pc4.cyan(typeName)}  ${pc4.bold(bindingName)}  ${resource}`);
+      }
+    }
+    console.log();
+    if (environments.length > 0 && !env) {
+      console.log(
+        pc4.dim("Environments: ") + environments.join(", ")
+      );
+      console.log();
+    }
+    const envFlag = env ? ` --env ${env}` : "";
+    console.log(pc4.dim(`Use 'cloudwerk bindings add${envFlag}' to add a new binding.`));
+    if (!env && environments.length > 0) {
+      console.log(
+        pc4.dim(`Use 'cloudwerk bindings --env <name>' to view environment bindings.`)
+      );
+    }
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/bindings/add.ts
+import { spawn as spawn2 } from "child_process";
+import pc5 from "picocolors";
+import { select, input, confirm } from "@inquirer/prompts";
+
+// src/utils/env-types.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+var TYPE_MAPPINGS = {
+  d1: "D1Database",
+  kv: "KVNamespace",
+  r2: "R2Bucket",
+  queue: "Queue",
+  do: "DurableObjectNamespace",
+  service: "Fetcher",
+  secret: "string",
+  ai: "Ai",
+  vectorize: "VectorizeIndex",
+  hyperdrive: "Hyperdrive"
+};
+function getTypeForBinding(type) {
+  return TYPE_MAPPINGS[type] || "unknown";
+}
+function generateEnvTypes(cwd, bindings2, options = {}) {
+  const outputPath = options.outputPath || path9.join(cwd, "env.d.ts");
+  const includeTimestamp = options.includeTimestamp ?? true;
+  const bindingsByType = /* @__PURE__ */ new Map();
+  for (const binding of bindings2) {
+    const existing = bindingsByType.get(binding.type) || [];
+    existing.push(binding);
+    bindingsByType.set(binding.type, existing);
+  }
+  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("interface CloudflareBindings {");
+  const typeOrder = [
+    "d1",
+    "kv",
+    "r2",
+    "queue",
+    "do",
+    "service",
+    "ai",
+    "vectorize",
+    "hyperdrive",
+    "secret"
+  ];
+  const resultBindings = [];
+  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 = getSectionName(type);
+    if (!firstSection) {
+      lines.push("");
+    }
+    lines.push(`  // ${sectionName}`);
+    firstSection = false;
+    for (const binding of typeBindings) {
+      lines.push(`  ${binding.name}: ${tsType}`);
+      resultBindings.push({ name: binding.name, type: tsType });
+    }
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("// Re-export for convenience");
+  lines.push("type Env = CloudflareBindings");
+  lines.push("export type { Env, CloudflareBindings }");
+  lines.push("");
+  fs8.writeFileSync(outputPath, lines.join("\n"), "utf-8");
+  return {
+    outputPath,
+    bindingCount: bindings2.length,
+    bindings: resultBindings
+  };
+}
+function getSectionName(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/commands/bindings/add.ts
+async function bindingsAdd(bindingType, options) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  const env = options.env;
+  try {
+    const cwd = process.cwd();
+    const wranglerPath = findWranglerToml(cwd);
+    if (!wranglerPath) {
+      throw new CliError(
+        "wrangler.toml not found",
+        "ENOENT",
+        "Create a wrangler.toml file or run this command from a Cloudwerk project directory."
+      );
+    }
+    logger.debug(`Found wrangler config: ${wranglerPath}`);
+    const type = bindingType || await promptForBindingType();
+    const envLabel = env ? ` (${env})` : "";
+    console.log();
+    logger.info(`Adding ${type.toUpperCase()} binding${envLabel}...`);
+    switch (type.toLowerCase()) {
+      case "d1":
+        await addD1(cwd, options);
+        break;
+      case "kv":
+        await addKV(cwd, options);
+        break;
+      case "r2":
+        await addR2(cwd, options);
+        break;
+      case "queue":
+        await addQueue(cwd, options);
+        break;
+      case "do":
+        await addDurableObject(cwd, options);
+        break;
+      case "secret":
+        await addSecret(cwd, options);
+        break;
+      default:
+        throw new CliError(
+          `Unknown binding type: ${type}`,
+          "EINVAL",
+          "Valid types are: d1, kv, r2, queue, do, secret"
+        );
+    }
+    if (!options.skipTypes) {
+      await regenerateTypes(cwd);
+    }
+    console.log();
+    logger.success("Binding added successfully!");
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+async function promptForBindingType() {
+  return select({
+    message: "What type of binding do you want to add?",
+    choices: [
+      { name: "D1 Database", value: "d1" },
+      { name: "KV Namespace", value: "kv" },
+      { name: "R2 Bucket", value: "r2" },
+      { name: "Queue", value: "queue" },
+      { name: "Durable Object", value: "do" },
+      { name: "Secret / Environment Variable", value: "secret" }
+    ]
+  });
+}
+async function addD1(cwd, options) {
+  const config = readWranglerToml(cwd);
+  const env = options.env;
+  const bindingName = await input({
+    message: "Binding name (e.g., DB):",
+    validate: (value) => {
+      if (!value.trim()) return "Binding name is required";
+      if (!/^[A-Z_][A-Z0-9_]*$/i.test(value))
+        return "Binding name must be alphanumeric with underscores";
+      if (bindingExists(config, value, env))
+        return `Binding "${value}" already exists`;
+      return true;
+    }
+  });
+  const databaseName = await input({
+    message: "Database name:",
+    default: `${config.name || "my-app"}${env ? `-${env}` : ""}-db`,
+    validate: (value) => {
+      if (!value.trim()) return "Database name is required";
+      return true;
+    }
+  });
+  const createNew = await confirm({
+    message: "Create a new D1 database?",
+    default: true
+  });
+  let databaseId;
+  if (createNew) {
+    console.log();
+    console.log(pc5.dim(`Creating D1 database "${databaseName}"...`));
+    const result = await runWranglerCommand(["d1", "create", databaseName]);
+    const idMatch = result.match(/database_id\s*=\s*"([^"]+)"/);
+    if (!idMatch) {
+      throw new CliError(
+        "Failed to parse database ID from wrangler output",
+        "EPARSE",
+        "Try creating the database manually with: wrangler d1 create " + databaseName
+      );
+    }
+    databaseId = idMatch[1];
+    console.log(pc5.green("\u2713") + ` Created database: ${databaseId}`);
+  } else {
+    const databases = await listD1Databases();
+    if (databases.length === 0) {
+      throw new CliError(
+        "No D1 databases found",
+        "ENOENT",
+        "Create a database first with: wrangler d1 create <name>"
+      );
+    }
+    const selected = await select({
+      message: "Select an existing database:",
+      choices: databases.map((db) => ({
+        name: `${db.name} (${db.uuid.slice(0, 8)}...)`,
+        value: db.uuid
+      }))
+    });
+    databaseId = selected;
+  }
+  addD1Binding(cwd, bindingName, databaseName, databaseId, env);
+  console.log(pc5.green("\u2713") + " Updated wrangler.toml");
+  showTypeHint(bindingName, "d1");
+}
+async function listD1Databases() {
+  const output = await runWranglerCommand(["d1", "list", "--json"]);
+  return JSON.parse(output);
+}
+async function addKV(cwd, options) {
+  const config = readWranglerToml(cwd);
+  const env = options.env;
+  const bindingName = await input({
+    message: "Binding name (e.g., CACHE):",
+    validate: (value) => {
+      if (!value.trim()) return "Binding name is required";
+      if (!/^[A-Z_][A-Z0-9_]*$/i.test(value))
+        return "Binding name must be alphanumeric with underscores";
+      if (bindingExists(config, value, env))
+        return `Binding "${value}" already exists`;
+      return true;
+    }
+  });
+  const createNew = await confirm({
+    message: "Create a new KV namespace?",
+    default: true
+  });
+  let namespaceId;
+  if (createNew) {
+    console.log();
+    console.log(pc5.dim(`Creating KV namespace "${bindingName}"...`));
+    const result = await runWranglerCommand([
+      "kv",
+      "namespace",
+      "create",
+      bindingName
+    ]);
+    const idMatch = result.match(/id\s*=\s*"([^"]+)"/);
+    if (!idMatch) {
+      throw new CliError(
+        "Failed to parse namespace ID from wrangler output",
+        "EPARSE",
+        "Try creating the namespace manually with: wrangler kv namespace create " + bindingName
+      );
+    }
+    namespaceId = idMatch[1];
+    console.log(pc5.green("\u2713") + ` Created namespace: ${namespaceId}`);
+  } else {
+    const namespaces = await listKVNamespaces();
+    if (namespaces.length === 0) {
+      throw new CliError(
+        "No KV namespaces found",
+        "ENOENT",
+        "Create a namespace first with: wrangler kv namespace create <name>"
+      );
+    }
+    const selected = await select({
+      message: "Select an existing namespace:",
+      choices: namespaces.map((ns) => ({
+        name: `${ns.title} (${ns.id.slice(0, 8)}...)`,
+        value: ns.id
+      }))
+    });
+    namespaceId = selected;
+  }
+  addKVBinding(cwd, bindingName, namespaceId, void 0, env);
+  console.log(pc5.green("\u2713") + " Updated wrangler.toml");
+  showTypeHint(bindingName, "kv");
+}
+async function listKVNamespaces() {
+  const output = await runWranglerCommand(["kv", "namespace", "list", "--json"]);
+  return JSON.parse(output);
+}
+async function addR2(cwd, options) {
+  const config = readWranglerToml(cwd);
+  const env = options.env;
+  const bindingName = await input({
+    message: "Binding name (e.g., STORAGE):",
+    validate: (value) => {
+      if (!value.trim()) return "Binding name is required";
+      if (!/^[A-Z_][A-Z0-9_]*$/i.test(value))
+        return "Binding name must be alphanumeric with underscores";
+      if (bindingExists(config, value, env))
+        return `Binding "${value}" already exists`;
+      return true;
+    }
+  });
+  const createNew = await confirm({
+    message: "Create a new R2 bucket?",
+    default: true
+  });
+  let bucketName;
+  if (createNew) {
+    bucketName = await input({
+      message: "Bucket name:",
+      default: `${config.name || "my-app"}${env ? `-${env}` : ""}-bucket`,
+      validate: (value) => {
+        if (!value.trim()) return "Bucket name is required";
+        return true;
+      }
+    });
+    console.log();
+    console.log(pc5.dim(`Creating R2 bucket "${bucketName}"...`));
+    await runWranglerCommand(["r2", "bucket", "create", bucketName]);
+    console.log(pc5.green("\u2713") + ` Created bucket: ${bucketName}`);
+  } else {
+    const buckets = await listR2Buckets();
+    if (buckets.length === 0) {
+      throw new CliError(
+        "No R2 buckets found",
+        "ENOENT",
+        "Create a bucket first with: wrangler r2 bucket create <name>"
+      );
+    }
+    const selected = await select({
+      message: "Select an existing bucket:",
+      choices: buckets.map((bucket) => ({
+        name: bucket.name,
+        value: bucket.name
+      }))
+    });
+    bucketName = selected;
+  }
+  addR2Binding(cwd, bindingName, bucketName, env);
+  console.log(pc5.green("\u2713") + " Updated wrangler.toml");
+  showTypeHint(bindingName, "r2");
+}
+async function listR2Buckets() {
+  const output = await runWranglerCommand(["r2", "bucket", "list", "--json"]);
+  return JSON.parse(output);
+}
+async function addQueue(cwd, options) {
+  const config = readWranglerToml(cwd);
+  const env = options.env;
+  const bindingName = await input({
+    message: "Binding name (e.g., JOBS):",
+    validate: (value) => {
+      if (!value.trim()) return "Binding name is required";
+      if (!/^[A-Z_][A-Z0-9_]*$/i.test(value))
+        return "Binding name must be alphanumeric with underscores";
+      if (bindingExists(config, value, env))
+        return `Binding "${value}" already exists`;
+      return true;
+    }
+  });
+  const createNew = await confirm({
+    message: "Create a new queue?",
+    default: true
+  });
+  let queueName;
+  if (createNew) {
+    queueName = await input({
+      message: "Queue name:",
+      default: `${config.name || "my-app"}${env ? `-${env}` : ""}-queue`,
+      validate: (value) => {
+        if (!value.trim()) return "Queue name is required";
+        return true;
+      }
+    });
+    console.log();
+    console.log(pc5.dim(`Creating queue "${queueName}"...`));
+    await runWranglerCommand(["queues", "create", queueName]);
+    console.log(pc5.green("\u2713") + ` Created queue: ${queueName}`);
+  } else {
+    const queues = await listQueues();
+    if (queues.length === 0) {
+      throw new CliError(
+        "No queues found",
+        "ENOENT",
+        "Create a queue first with: wrangler queues create <name>"
+      );
+    }
+    const selected = await select({
+      message: "Select an existing queue:",
+      choices: queues.map((queue) => ({
+        name: queue.queue_name,
+        value: queue.queue_name
+      }))
+    });
+    queueName = selected;
+  }
+  addQueueBinding(cwd, bindingName, queueName, env);
+  console.log(pc5.green("\u2713") + " Updated wrangler.toml");
+  showTypeHint(bindingName, "queue");
+}
+async function listQueues() {
+  const output = await runWranglerCommand(["queues", "list", "--json"]);
+  return JSON.parse(output);
+}
+async function addDurableObject(cwd, options) {
+  const config = readWranglerToml(cwd);
+  const env = options.env;
+  const bindingName = await input({
+    message: "Binding name (e.g., COUNTER):",
+    validate: (value) => {
+      if (!value.trim()) return "Binding name is required";
+      if (!/^[A-Z_][A-Z0-9_]*$/i.test(value))
+        return "Binding name must be alphanumeric with underscores";
+      if (bindingExists(config, value, env))
+        return `Binding "${value}" already exists`;
+      return true;
+    }
+  });
+  const className = await input({
+    message: "Durable Object class name:",
+    default: bindingName.split("_").map((s) => s.charAt(0).toUpperCase() + s.slice(1).toLowerCase()).join(""),
+    validate: (value) => {
+      if (!value.trim()) return "Class name is required";
+      return true;
+    }
+  });
+  const isExternal = await confirm({
+    message: "Is this a Durable Object from another Worker?",
+    default: false
+  });
+  let scriptName;
+  if (isExternal) {
+    scriptName = await input({
+      message: "Worker script name:",
+      validate: (value) => {
+        if (!value.trim()) return "Script name is required";
+        return true;
+      }
+    });
+  }
+  addDurableObjectBinding(cwd, bindingName, className, scriptName, env);
+  console.log(pc5.green("\u2713") + " Updated wrangler.toml");
+  showTypeHint(bindingName, "do");
+  if (!isExternal) {
+    console.log();
+    console.log(pc5.dim("Remember to export your Durable Object class:"));
+    console.log(pc5.dim(`  export class ${className} extends DurableObject { ... }`));
+  }
+}
+async function addSecret(cwd, options) {
+  const config = readWranglerToml(cwd);
+  const env = options.env;
+  const varName = await input({
+    message: "Variable name (e.g., API_KEY):",
+    validate: (value) => {
+      if (!value.trim()) return "Variable name is required";
+      if (!/^[A-Z_][A-Z0-9_]*$/i.test(value))
+        return "Variable name must be alphanumeric with underscores";
+      if (bindingExists(config, value, env))
+        return `Variable "${value}" already exists`;
+      return true;
+    }
+  });
+  const isSecret = await confirm({
+    message: "Is this a secret (sensitive value)?",
+    default: true
+  });
+  if (isSecret) {
+    console.log();
+    console.log(pc5.dim("Enter the secret value (will be hidden):"));
+    const varValue = await input({
+      message: "Secret value:"
+    });
+    console.log();
+    console.log(pc5.dim(`Setting secret "${varName}"...`));
+    const args = ["secret", "put", varName];
+    if (env) args.push("--env", env);
+    await runWranglerCommandWithInput(args, varValue);
+    console.log(pc5.green("\u2713") + ` Secret "${varName}" set`);
+    console.log();
+    console.log(
+      pc5.dim("Note: Secrets are stored securely and not written to wrangler.toml.")
+    );
+  } else {
+    const varValue = await input({
+      message: "Variable value:",
+      validate: (value) => {
+        if (!value.trim()) return "Value is required";
+        return true;
+      }
+    });
+    addSecretBinding(cwd, varName, varValue, env);
+    console.log(pc5.green("\u2713") + " Updated wrangler.toml");
+  }
+  showTypeHint(varName, "secret");
+}
+async function regenerateTypes(cwd) {
+  const config = readWranglerToml(cwd);
+  const bindings2 = extractBindings(config);
+  if (bindings2.length === 0) {
+    return;
+  }
+  const result = generateEnvTypes(cwd, bindings2);
+  console.log(pc5.green("\u2713") + ` Updated env.d.ts with ${result.bindingCount} binding(s)`);
+}
+function showTypeHint(bindingName, type) {
+  const tsType = getTypeForBinding(type);
+  console.log();
+  console.log(pc5.dim(`TypeScript type: ${bindingName}: ${tsType}`));
+}
+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], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", (error) => {
+      resolve4({ stdout, stderr: error.message, code: null, error: true });
+    });
+    child.on("close", (code) => {
+      resolve4({ stdout, stderr, code, error: code !== 0 });
+    });
+  });
+}
+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], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", (error) => {
+      resolve4({ stdout, stderr: error.message, code: null, error: true });
+    });
+    child.on("close", (code) => {
+      resolve4({ stdout, stderr, code, error: code !== 0 });
+    });
+    child.stdin?.write(inputData);
+    child.stdin?.end();
+  });
+}
+
+// src/commands/bindings/remove.ts
+import pc6 from "picocolors";
+import { confirm as confirm2, select as select2 } from "@inquirer/prompts";
+async function bindingsRemove(bindingName, options) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  const env = options.env;
+  try {
+    const cwd = process.cwd();
+    const wranglerPath = findWranglerToml(cwd);
+    if (!wranglerPath) {
+      throw new CliError(
+        "wrangler.toml not found",
+        "ENOENT",
+        "Create a wrangler.toml file or run this command from a Cloudwerk project directory."
+      );
+    }
+    logger.debug(`Found wrangler config: ${wranglerPath}`);
+    const config = readWranglerToml(cwd);
+    const bindings2 = extractBindings(config, env);
+    if (bindings2.length === 0) {
+      const envLabel = env ? ` in ${env}` : "";
+      throw new CliError(
+        `No bindings found${envLabel}`,
+        "ENOENT",
+        `Use 'cloudwerk bindings add' to add a binding first.`
+      );
+    }
+    let targetBinding = bindingName;
+    if (!targetBinding) {
+      targetBinding = await select2({
+        message: "Select a binding to remove:",
+        choices: bindings2.map((b) => ({
+          name: `${b.name} (${getBindingTypeName(b.type)})`,
+          value: b.name
+        }))
+      });
+    }
+    const binding = bindings2.find((b) => b.name === targetBinding);
+    if (!binding) {
+      const envLabel = env ? ` in ${env}` : "";
+      throw new CliError(
+        `Binding "${targetBinding}" not found${envLabel}`,
+        "ENOENT",
+        `Use 'cloudwerk bindings' to see available bindings.`
+      );
+    }
+    if (!options.force) {
+      const confirmed = await confirm2({
+        message: `Remove binding "${targetBinding}" (${getBindingTypeName(binding.type)})?`,
+        default: false
+      });
+      if (!confirmed) {
+        console.log(pc6.dim("Cancelled."));
+        return;
+      }
+    }
+    console.log();
+    const removed = removeBinding(cwd, targetBinding, env);
+    if (!removed) {
+      throw new CliError(
+        `Failed to remove binding "${targetBinding}"`,
+        "EREMOVE",
+        "The binding may have already been removed."
+      );
+    }
+    console.log(pc6.green("\u2713") + ` Removed binding "${targetBinding}" from wrangler.toml`);
+    if (!options.skipTypes) {
+      const updatedConfig = readWranglerToml(cwd);
+      const updatedBindings = extractBindings(updatedConfig);
+      if (updatedBindings.length > 0) {
+        const result = generateEnvTypes(cwd, updatedBindings);
+        console.log(
+          pc6.green("\u2713") + ` Updated env.d.ts with ${result.bindingCount} binding(s)`
+        );
+      } else {
+        console.log(
+          pc6.dim("Note: No bindings remain. Consider removing env.d.ts manually.")
+        );
+      }
+    }
+    console.log();
+    logger.success("Binding removed successfully!");
+    console.log();
+    console.log(
+      pc6.dim(
+        "Note: The Cloudflare resource itself was not deleted. Use wrangler to delete the resource if needed."
+      )
+    );
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
+// src/commands/bindings/update.ts
+import { spawn as spawn3 } from "child_process";
+import pc7 from "picocolors";
+import { input as input2, select as select3 } from "@inquirer/prompts";
+async function bindingsUpdate(bindingName, options) {
+  const verbose = options.verbose ?? false;
+  const logger = createLogger(verbose);
+  const env = options.env;
+  try {
+    const cwd = process.cwd();
+    const wranglerPath = findWranglerToml(cwd);
+    if (!wranglerPath) {
+      throw new CliError(
+        "wrangler.toml not found",
+        "ENOENT",
+        "Create a wrangler.toml file or run this command from a Cloudwerk project directory."
+      );
+    }
+    logger.debug(`Found wrangler config: ${wranglerPath}`);
+    const config = readWranglerToml(cwd);
+    const bindings2 = extractBindings(config, env);
+    if (bindings2.length === 0) {
+      const envLabel = env ? ` in ${env}` : "";
+      throw new CliError(
+        `No bindings found${envLabel}`,
+        "ENOENT",
+        `Use 'cloudwerk bindings add' to add a binding first.`
+      );
+    }
+    let targetBinding = bindingName;
+    if (!targetBinding) {
+      targetBinding = await select3({
+        message: "Select a binding to update:",
+        choices: bindings2.map((b) => ({
+          name: `${b.name} (${getBindingTypeName(b.type)})`,
+          value: b.name
+        }))
+      });
+    }
+    const binding = bindings2.find((b) => b.name === targetBinding);
+    if (!binding) {
+      const envLabel = env ? ` in ${env}` : "";
+      throw new CliError(
+        `Binding "${targetBinding}" not found${envLabel}`,
+        "ENOENT",
+        `Use 'cloudwerk bindings' to see available bindings.`
+      );
+    }
+    console.log();
+    logger.info(
+      `Updating ${getBindingTypeName(binding.type)} binding "${targetBinding}"...`
+    );
+    const updated = await updateBinding(cwd, config, binding, env);
+    if (!updated) {
+      console.log(pc7.dim("No changes made."));
+      return;
+    }
+    if (!options.skipTypes) {
+      const updatedConfig = readWranglerToml(cwd);
+      const updatedBindings = extractBindings(updatedConfig);
+      if (updatedBindings.length > 0) {
+        const result = generateEnvTypes(cwd, updatedBindings);
+        console.log(
+          pc7.green("\u2713") + ` Updated env.d.ts with ${result.bindingCount} binding(s)`
+        );
+      }
+    }
+    console.log();
+    logger.success("Binding updated successfully!");
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+async function updateBinding(cwd, config, binding, env) {
+  const updateOptions = getUpdateOptions(binding);
+  if (updateOptions.length === 0) {
+    console.log(pc7.dim("This binding type has no updatable fields."));
+    return false;
+  }
+  const field = await select3({
+    message: "What do you want to update?",
+    choices: updateOptions
+  });
+  const targetConfig = env ? config.env?.[env] ?? config : config;
+  switch (binding.type) {
+    case "d1":
+      return updateD1(cwd, config, targetConfig, binding.name, field);
+    case "kv":
+      return updateKV(cwd, config, targetConfig, binding.name, field);
+    case "r2":
+      return updateR2(cwd, config, targetConfig, binding.name, field);
+    case "queue":
+      return updateQueue(cwd, config, targetConfig, binding.name, field);
+    case "do":
+      return updateDurableObject(cwd, config, targetConfig, binding.name, field);
+    case "secret":
+      return updateSecret(cwd, config, targetConfig, binding.name, field, env);
+    default:
+      console.log(pc7.dim(`Updating ${binding.type} bindings is not yet supported.`));
+      return false;
+  }
+}
+function getUpdateOptions(binding) {
+  switch (binding.type) {
+    case "d1":
+      return [
+        { name: "Binding name", value: "name" },
+        { name: "Database name", value: "database_name" },
+        { name: "Database ID", value: "database_id" }
+      ];
+    case "kv":
+      return [
+        { name: "Binding name", value: "name" },
+        { name: "Namespace ID", value: "id" },
+        { name: "Preview ID", value: "preview_id" }
+      ];
+    case "r2":
+      return [
+        { name: "Binding name", value: "name" },
+        { name: "Bucket name", value: "bucket_name" }
+      ];
+    case "queue":
+      return [
+        { name: "Binding name", value: "name" },
+        { name: "Queue name", value: "queue" }
+      ];
+    case "do":
+      return [
+        { name: "Binding name", value: "name" },
+        { name: "Class name", value: "class_name" },
+        { name: "Script name", value: "script_name" }
+      ];
+    case "secret":
+      return [
+        { name: "Variable name", value: "name" },
+        { name: "Value", value: "value" }
+      ];
+    default:
+      return [];
+  }
+}
+async function updateD1(cwd, config, targetConfig, bindingName, field) {
+  const bindings2 = targetConfig.d1_databases;
+  if (!bindings2) return false;
+  const binding = bindings2.find((b) => b.binding === bindingName);
+  if (!binding) return false;
+  switch (field) {
+    case "name": {
+      const newName = await input2({
+        message: "New binding name:",
+        default: binding.binding
+      });
+      if (newName === binding.binding) return false;
+      binding.binding = newName;
+      break;
+    }
+    case "database_name": {
+      const newName = await input2({
+        message: "New database name:",
+        default: binding.database_name
+      });
+      if (newName === binding.database_name) return false;
+      binding.database_name = newName;
+      break;
+    }
+    case "database_id": {
+      const newId = await input2({
+        message: "New database ID:",
+        default: binding.database_id
+      });
+      if (newId === binding.database_id) return false;
+      binding.database_id = newId;
+      break;
+    }
+  }
+  writeWranglerToml(cwd, config);
+  console.log(pc7.green("\u2713") + " Updated wrangler.toml");
+  return true;
+}
+async function updateKV(cwd, config, targetConfig, bindingName, field) {
+  const bindings2 = targetConfig.kv_namespaces;
+  if (!bindings2) return false;
+  const binding = bindings2.find((b) => b.binding === bindingName);
+  if (!binding) return false;
+  switch (field) {
+    case "name": {
+      const newName = await input2({
+        message: "New binding name:",
+        default: binding.binding
+      });
+      if (newName === binding.binding) return false;
+      binding.binding = newName;
+      break;
+    }
+    case "id": {
+      const newId = await input2({
+        message: "New namespace ID:",
+        default: binding.id
+      });
+      if (newId === binding.id) return false;
+      binding.id = newId;
+      break;
+    }
+    case "preview_id": {
+      const newId = await input2({
+        message: "New preview ID (leave empty to remove):",
+        default: binding.preview_id || ""
+      });
+      if (newId === (binding.preview_id || "")) return false;
+      if (newId) {
+        binding.preview_id = newId;
+      } else {
+        delete binding.preview_id;
+      }
+      break;
+    }
+  }
+  writeWranglerToml(cwd, config);
+  console.log(pc7.green("\u2713") + " Updated wrangler.toml");
+  return true;
+}
+async function updateR2(cwd, config, targetConfig, bindingName, field) {
+  const bindings2 = targetConfig.r2_buckets;
+  if (!bindings2) return false;
+  const binding = bindings2.find((b) => b.binding === bindingName);
+  if (!binding) return false;
+  switch (field) {
+    case "name": {
+      const newName = await input2({
+        message: "New binding name:",
+        default: binding.binding
+      });
+      if (newName === binding.binding) return false;
+      binding.binding = newName;
+      break;
+    }
+    case "bucket_name": {
+      const newName = await input2({
+        message: "New bucket name:",
+        default: binding.bucket_name
+      });
+      if (newName === binding.bucket_name) return false;
+      binding.bucket_name = newName;
+      break;
+    }
+  }
+  writeWranglerToml(cwd, config);
+  console.log(pc7.green("\u2713") + " Updated wrangler.toml");
+  return true;
+}
+async function updateQueue(cwd, config, targetConfig, bindingName, field) {
+  const bindings2 = targetConfig.queues?.producers;
+  if (!bindings2) return false;
+  const binding = bindings2.find((b) => b.binding === bindingName);
+  if (!binding) return false;
+  switch (field) {
+    case "name": {
+      const newName = await input2({
+        message: "New binding name:",
+        default: binding.binding
+      });
+      if (newName === binding.binding) return false;
+      binding.binding = newName;
+      break;
+    }
+    case "queue": {
+      const newName = await input2({
+        message: "New queue name:",
+        default: binding.queue
+      });
+      if (newName === binding.queue) return false;
+      binding.queue = newName;
+      break;
+    }
+  }
+  writeWranglerToml(cwd, config);
+  console.log(pc7.green("\u2713") + " Updated wrangler.toml");
+  return true;
+}
+async function updateDurableObject(cwd, config, targetConfig, bindingName, field) {
+  const bindings2 = targetConfig.durable_objects?.bindings;
+  if (!bindings2) return false;
+  const binding = bindings2.find((b) => b.name === bindingName);
+  if (!binding) return false;
+  switch (field) {
+    case "name": {
+      const newName = await input2({
+        message: "New binding name:",
+        default: binding.name
+      });
+      if (newName === binding.name) return false;
+      binding.name = newName;
+      break;
+    }
+    case "class_name": {
+      const newName = await input2({
+        message: "New class name:",
+        default: binding.class_name
+      });
+      if (newName === binding.class_name) return false;
+      binding.class_name = newName;
+      break;
+    }
+    case "script_name": {
+      const newName = await input2({
+        message: "New script name (leave empty to remove):",
+        default: binding.script_name || ""
+      });
+      if (newName === (binding.script_name || "")) return false;
+      if (newName) {
+        binding.script_name = newName;
+      } else {
+        delete binding.script_name;
+      }
+      break;
+    }
+  }
+  writeWranglerToml(cwd, config);
+  console.log(pc7.green("\u2713") + " Updated wrangler.toml");
+  return true;
+}
+async function updateSecret(cwd, config, targetConfig, varName, field, env) {
+  const vars = targetConfig.vars;
+  const isInToml = vars && varName in vars;
+  if (!isInToml) {
+    if (field === "name") {
+      console.log();
+      console.log(
+        pc7.yellow("\u26A0") + " Secrets managed by wrangler cannot be renamed directly."
+      );
+      console.log(
+        pc7.dim(
+          "  To rename, delete the old secret and create a new one with:"
+        )
+      );
+      console.log(pc7.dim(`    wrangler secret delete ${varName}`));
+      console.log(pc7.dim(`    wrangler secret put <new-name>`));
+      return false;
+    }
+    console.log();
+    console.log(
+      pc7.dim("This is a secret managed by wrangler. Enter the new value:")
+    );
+    const newValue = await input2({
+      message: "New secret value:"
+    });
+    if (!newValue.trim()) {
+      console.log(pc7.dim("No value provided."));
+      return false;
+    }
+    const args = ["secret", "put", varName];
+    if (env) args.push("--env", env);
+    console.log();
+    console.log(pc7.dim(`Updating secret "${varName}"...`));
+    await runWranglerCommandWithInput2(args, newValue);
+    console.log(pc7.green("\u2713") + ` Secret "${varName}" updated`);
+    return true;
+  }
+  switch (field) {
+    case "name": {
+      const newName = await input2({
+        message: "New variable name:",
+        default: varName
+      });
+      if (newName === varName) return false;
+      const value = vars[varName];
+      delete vars[varName];
+      vars[newName] = value;
+      break;
+    }
+    case "value": {
+      const newValue = await input2({
+        message: "New value:",
+        default: vars[varName]
+      });
+      if (newValue === vars[varName]) return false;
+      vars[varName] = newValue;
+      break;
+    }
+  }
+  writeWranglerToml(cwd, config);
+  console.log(pc7.green("\u2713") + " Updated wrangler.toml");
+  return true;
+}
+function runWranglerCommandWithInput2(args, inputData) {
+  return new Promise((resolve4, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const child = spawn3("npx", ["wrangler", ...args], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr || `wrangler exited with code ${code}`));
+      } else {
+        resolve4(stdout);
+      }
+    });
+    child.stdin?.write(inputData);
+    child.stdin?.end();
+  });
+}
+
+// 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);
+  try {
+    const cwd = process.cwd();
+    const wranglerPath = findWranglerToml(cwd);
+    if (!wranglerPath) {
+      throw new CliError(
+        "wrangler.toml not found",
+        "ENOENT",
+        "Create a wrangler.toml file or run this command from a Cloudwerk project directory."
+      );
+    }
+    logger.debug(`Found wrangler config: ${wranglerPath}`);
+    const config = readWranglerToml(cwd);
+    const bindings2 = extractBindings(config);
+    if (bindings2.length === 0) {
+      console.log();
+      console.log(pc8.yellow("No bindings found in wrangler.toml."));
+      console.log();
+      console.log(
+        pc8.dim(`Use 'cloudwerk bindings add' to add a binding first.`)
+      );
+      console.log();
+      return;
+    }
+    console.log();
+    logger.info("Generating TypeScript types...");
+    const result = generateEnvTypes(cwd, bindings2);
+    console.log();
+    console.log(
+      pc8.green("\u2713") + ` Updated ${pc8.bold("env.d.ts")} with ${result.bindingCount} binding(s):`
+    );
+    console.log();
+    for (const binding of result.bindings) {
+      console.log(`    ${pc8.cyan(binding.name)}: ${pc8.dim(binding.type)}`);
+    }
+    logger.debug("Generating .cloudwerk/types/...");
+    const cloudwerkResult = generateCloudwerkTypes(cwd, bindings2);
+    console.log();
+    console.log(
+      pc8.green("\u2713") + ` Generated ${pc8.bold(".cloudwerk/types/")} for importable bindings:`
+    );
+    console.log(`    ${pc8.dim(cloudwerkResult.files.bindings)}`);
+    console.log(`    ${pc8.dim(cloudwerkResult.files.context)}`);
+    logger.debug("Updating tsconfig.json...");
+    const tsconfigResult = updateTsConfigPaths(cwd);
+    if (tsconfigResult.modified) {
+      console.log();
+      console.log(
+        pc8.green("\u2713") + ` Updated ${pc8.bold("tsconfig.json")}:`
+      );
+      if (tsconfigResult.changes.setBaseUrl) {
+        console.log(`    ${pc8.dim('Added baseUrl: "."')}`);
+      }
+      for (const pathKey of tsconfigResult.changes.addedPaths) {
+        console.log(`    ${pc8.dim(`Added paths: "${pathKey}"`)}`);
+      }
+      for (const include of tsconfigResult.changes.addedIncludes) {
+        console.log(`    ${pc8.dim(`Added include: "${include}"`)}`);
+      }
+    } else {
+      logger.debug("tsconfig.json already configured");
+    }
+    console.log();
+    logger.success("Types generated successfully!");
+    console.log();
+    console.log(pc8.bold("Usage:"));
+    console.log();
+    console.log(pc8.dim("  // Import bindings directly (new)"));
+    console.log(pc8.cyan(`  import { ${bindings2[0]?.name || "DB"} } from '@cloudwerk/core/bindings'`));
+    console.log();
+    console.log(pc8.dim("  // Import context helpers (new)"));
+    console.log(pc8.cyan(`  import { params, request, get } from '@cloudwerk/core/context'`));
+    console.log();
+    console.log(pc8.dim("  // Or use getContext() (existing)"));
+    console.log(pc8.cyan(`  import { getContext } from '@cloudwerk/core'`));
+    console.log();
+  } catch (error) {
+    handleCommandError(error, verbose);
+  }
+}
+
 // src/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.)").enablePositionalOptions().passThroughOptions().option("--verbose", "Enable verbose logging").action(bindings);
+bindingsCmd.command("add [type]").description("Add a new binding (d1, kv, r2, queue, do, secret)").option("-e, --env <environment>", "Environment to add binding to").option("--skip-types", "Skip TypeScript type generation").option("--verbose", "Enable verbose logging").action(bindingsAdd);
+bindingsCmd.command("remove [name]").description("Remove a binding").option("-e, --env <environment>", "Environment to remove binding from").option("-f, --force", "Skip confirmation prompt").option("--skip-types", "Skip TypeScript type generation").option("--verbose", "Enable verbose logging").action(bindingsRemove);
+bindingsCmd.command("update [name]").description("Update an existing binding").option("-e, --env <environment>", "Environment to update binding in").option("--skip-types", "Skip TypeScript type generation").option("--verbose", "Enable verbose logging").action(bindingsUpdate);
+bindingsCmd.command("generate-types").description("Regenerate TypeScript type definitions").option("--verbose", "Enable verbose logging").action(bindingsGenerateTypes);
 program.parse();