@cloudwerk/cli 0.10.0 → 0.11.0

package/dist/index.js

@@ -1148,6 +1148,1636 @@ 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);
+  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;
+}
+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 bindingExists(config, bindingName, env) {
+  const bindings2 = extractBindings(config, env);
+  return bindings2.some((b) => b.name === bindingName);
+}
+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"}-db${env ? `-${env}` : ""}`,
+    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"}-bucket${env ? `-${env}` : ""}`,
+      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"}-queue${env ? `-${env}` : ""}`,
+      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 runWranglerCommand(args) {
+  return new Promise((resolve4, reject) => {
+    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) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr || `wrangler exited with code ${code}`));
+      } else {
+        resolve4(stdout);
+      }
+    });
+  });
+}
+function runWranglerCommandWithInput(args, inputData) {
+  return new Promise((resolve4, reject) => {
+    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) => {
+      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/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";
+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)}`);
+    }
+    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/**/*"]')
+    );
+    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.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);
@@ -1156,4 +2786,9 @@ program.command("deploy [path]").description("Deploy to Cloudflare Workers").opt
 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);
+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();