@auth-gate/billing 0.8.0

package/dist/cli.cjs

@@ -0,0 +1,1365 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/pull-from-stripe.ts
+var pull_from_stripe_exports = {};
+__export(pull_from_stripe_exports, {
+  fetchStripeState: () => fetchStripeState
+});
+async function fetchStripeState(stripeKey) {
+  var _a, _b, _c, _d, _e;
+  const Stripe = (await import("stripe")).default;
+  const stripe = new Stripe(stripeKey);
+  const [products, prices] = await Promise.all([
+    stripe.products.list({ active: true, limit: 100 }),
+    stripe.prices.list({ active: true, limit: 100 })
+  ]);
+  const pricesByProduct = /* @__PURE__ */ new Map();
+  for (const sp of prices.data) {
+    const productId = typeof sp.product === "string" ? sp.product : sp.product.id;
+    const mapped = {
+      id: sp.id,
+      configKey: null,
+      amount: sp.unit_amount,
+      currency: sp.currency,
+      interval: (_b = (_a = sp.recurring) == null ? void 0 : _a.interval) != null ? _b : "monthly",
+      intervalCount: (_d = (_c = sp.recurring) == null ? void 0 : _c.interval_count) != null ? _d : 1,
+      isActive: sp.active,
+      stripePriceId: sp.id
+    };
+    pricesByProduct.set(productId, [
+      ...(_e = pricesByProduct.get(productId)) != null ? _e : [],
+      mapped
+    ]);
+  }
+  const serverProducts = products.data.map((p) => {
+    var _a2;
+    return {
+      id: p.id,
+      configKey: null,
+      name: p.name,
+      description: p.description,
+      features: [],
+      isActive: p.active,
+      managedBy: "config",
+      stripeProductId: p.id,
+      previousConfigKeys: [],
+      prices: (_a2 = pricesByProduct.get(p.id)) != null ? _a2 : []
+    };
+  });
+  return { products: serverProducts };
+}
+var init_pull_from_stripe = __esm({
+  "src/pull-from-stripe.ts"() {
+    "use strict";
+  }
+});
+
+// src/config-loader.ts
+var import_path = require("path");
+var import_fs = require("fs");
+
+// src/validation.ts
+function validateTiers(price, prefix) {
+  if (!Array.isArray(price.tiers) || price.tiers.length === 0) {
+    throw new Error(`${prefix}: tiered/metered price must have a non-empty "tiers" array.`);
+  }
+  if (!["graduated", "volume"].includes(price.tierMode)) {
+    throw new Error(`${prefix}.tierMode must be "graduated" or "volume".`);
+  }
+  for (let j = 0; j < price.tiers.length; j++) {
+    const tier = price.tiers[j];
+    if (typeof tier.unitAmount !== "number" || tier.unitAmount < 0) {
+      throw new Error(`${prefix}.tiers[${j}].unitAmount must be a non-negative number.`);
+    }
+  }
+}
+function validateConfig(config) {
+  var _a;
+  if (!config || typeof config !== "object") {
+    throw new Error("Billing config must be an object. Did you forget `export default defineBilling({ ... })`?");
+  }
+  const unwrapped = "_config" in config ? config._config : config;
+  const c = unwrapped;
+  if (!c.plans || typeof c.plans !== "object") {
+    throw new Error("Billing config must have a `plans` object.");
+  }
+  const plans = c.plans;
+  const planKeys = Object.keys(plans);
+  if (planKeys.length === 0) {
+    throw new Error("Billing config must define at least one plan.");
+  }
+  for (const key of planKeys) {
+    if (!/^[a-z][a-z0-9_]*$/.test(key)) {
+      throw new Error(
+        `Plan key "${key}" is invalid. Use lowercase alphanumeric with underscores (e.g., "pro", "team_plan").`
+      );
+    }
+    const plan = plans[key];
+    if (!plan || typeof plan !== "object") {
+      throw new Error(`Plan "${key}" must be an object.`);
+    }
+    if (!plan.name || typeof plan.name !== "string") {
+      throw new Error(`Plan "${key}" must have a "name" string.`);
+    }
+    if (plan.description !== void 0 && typeof plan.description !== "string") {
+      throw new Error(`Plan "${key}".description must be a string.`);
+    }
+    if (plan.features !== void 0) {
+      if (!Array.isArray(plan.features) || !plan.features.every((f) => typeof f === "string")) {
+        throw new Error(`Plan "${key}".features must be an array of strings.`);
+      }
+    }
+    if (plan.grandfathering !== void 0) {
+      const validStrategies = ["keep_price", "migrate_at_renewal", "migrate_immediately"];
+      if (!validStrategies.includes(plan.grandfathering)) {
+        throw new Error(
+          `Plan "${key}".grandfathering must be one of: ${validStrategies.join(", ")}.`
+        );
+      }
+    }
+    if (!Array.isArray(plan.prices) || plan.prices.length === 0) {
+      throw new Error(`Plan "${key}" must have at least one price.`);
+    }
+    for (let i = 0; i < plan.prices.length; i++) {
+      const price = plan.prices[i];
+      const prefix = `Plan "${key}".prices[${i}]`;
+      const priceType = (_a = price.type) != null ? _a : "recurring";
+      if (typeof price.currency !== "string" || price.currency.length !== 3) {
+        throw new Error(`${prefix}.currency must be a 3-letter ISO 4217 code (e.g., "usd").`);
+      }
+      if (!["monthly", "yearly"].includes(price.interval)) {
+        throw new Error(`${prefix}.interval must be "monthly" or "yearly".`);
+      }
+      if (price.intervalCount !== void 0) {
+        if (typeof price.intervalCount !== "number" || !Number.isInteger(price.intervalCount) || price.intervalCount < 1) {
+          throw new Error(`${prefix}.intervalCount must be a positive integer.`);
+        }
+      }
+      if (priceType === "recurring" || priceType === "per_seat") {
+        if (typeof price.amount !== "number" || !Number.isInteger(price.amount) || price.amount < 0) {
+          throw new Error(`${prefix}.amount must be a non-negative integer (cents).`);
+        }
+        if (priceType === "per_seat") {
+          if (typeof price.metric !== "string" || !price.metric) {
+            throw new Error(`${prefix}: per_seat price must have a "metric" string.`);
+          }
+        }
+      } else if (priceType === "metered") {
+        if (typeof price.metric !== "string" || !price.metric) {
+          throw new Error(`${prefix}: metered price must have a "metric" string.`);
+        }
+        validateTiers(price, prefix);
+      } else if (priceType === "tiered") {
+        validateTiers(price, prefix);
+      } else {
+        throw new Error(`${prefix}.type must be one of: "recurring", "per_seat", "metered", "tiered".`);
+      }
+    }
+  }
+  const featuresRegistry = c.features;
+  if (featuresRegistry !== void 0) {
+    if (typeof featuresRegistry !== "object" || Array.isArray(featuresRegistry)) {
+      throw new Error("Billing config `features` must be an object (features registry).");
+    }
+    for (const [fKey, fDef] of Object.entries(featuresRegistry)) {
+      if (!fDef || typeof fDef !== "object") {
+        throw new Error(`Feature "${fKey}" must be an object with a "type" field.`);
+      }
+      if (!["boolean", "metered"].includes(fDef.type)) {
+        throw new Error(`Feature "${fKey}".type must be "boolean" or "metered".`);
+      }
+    }
+  }
+  for (const key of planKeys) {
+    const plan = plans[key];
+    if (plan.entitlements !== void 0) {
+      if (typeof plan.entitlements !== "object" || plan.entitlements === null || Array.isArray(plan.entitlements)) {
+        throw new Error(`Plan "${key}".entitlements must be an object.`);
+      }
+      const entitlements = plan.entitlements;
+      for (const [eKey, eVal] of Object.entries(entitlements)) {
+        if (featuresRegistry && !featuresRegistry[eKey]) {
+          throw new Error(`Plan "${key}".entitlements.${eKey} is not defined in features registry.`);
+        }
+        const featureDef = featuresRegistry == null ? void 0 : featuresRegistry[eKey];
+        if (featureDef) {
+          if (featureDef.type === "metered") {
+            if (eVal === true || typeof eVal !== "object" || !eVal || !("limit" in eVal)) {
+              throw new Error(`Plan "${key}".entitlements.${eKey}: metered feature must have { limit: number }.`);
+            }
+          } else if (featureDef.type === "boolean") {
+            if (eVal !== true) {
+              throw new Error(`Plan "${key}".entitlements.${eKey}: boolean feature must be true.`);
+            }
+          }
+        }
+      }
+    }
+  }
+  const renameTargets = /* @__PURE__ */ new Map();
+  for (const key of planKeys) {
+    const plan = plans[key];
+    if (plan.renamedFrom !== void 0) {
+      if (typeof plan.renamedFrom !== "string") {
+        throw new Error(`Plan "${key}".renamedFrom must be a string.`);
+      }
+      if (plan.renamedFrom === key) {
+        throw new Error(`Plan "${key}".renamedFrom cannot equal its own key.`);
+      }
+      if (planKeys.includes(plan.renamedFrom)) {
+        throw new Error(
+          `Plan "${key}".renamedFrom "${plan.renamedFrom}" cannot reference an existing plan key.`
+        );
+      }
+      if (renameTargets.has(plan.renamedFrom)) {
+        throw new Error(
+          `renamedFrom "${plan.renamedFrom}" is claimed by multiple plans: "${renameTargets.get(plan.renamedFrom)}" and "${key}".`
+        );
+      }
+      renameTargets.set(plan.renamedFrom, key);
+    }
+  }
+  if (c.migrations !== void 0) {
+    if (!Array.isArray(c.migrations)) {
+      throw new Error("Billing config `migrations` must be an array.");
+    }
+    const migrationFroms = /* @__PURE__ */ new Set();
+    for (let i = 0; i < c.migrations.length; i++) {
+      const m = c.migrations[i];
+      const prefix = `migrations[${i}]`;
+      if (typeof m.from !== "string" || !m.from) {
+        throw new Error(`${prefix}.from must be a non-empty string.`);
+      }
+      if (typeof m.to !== "string" || !m.to) {
+        throw new Error(`${prefix}.to must be a non-empty string.`);
+      }
+      if (m.from === m.to) {
+        throw new Error(`${prefix}: migration "from" cannot equal "to".`);
+      }
+      if (!planKeys.includes(m.to)) {
+        throw new Error(`${prefix}: migration target "${m.to}" must reference an existing plan in config.`);
+      }
+      if (migrationFroms.has(m.from)) {
+        throw new Error(`${prefix}: duplicate migration from "${m.from}".`);
+      }
+      migrationFroms.add(m.from);
+      if (renameTargets.has(m.from)) {
+        throw new Error(
+          `Cannot rename and migrate the same key "${m.from}" in one sync. Rename first, then migrate in a subsequent sync.`
+        );
+      }
+      if (m.priceMapping !== void 0) {
+        if (typeof m.priceMapping !== "object" || m.priceMapping === null || Array.isArray(m.priceMapping)) {
+          throw new Error(`${prefix}.priceMapping must be an object { oldKey: newKey }.`);
+        }
+      }
+    }
+  }
+  return unwrapped;
+}
+
+// src/config-loader.ts
+var CONFIG_FILENAMES = [
+  "authgate.billing.ts",
+  "authgate.billing.js",
+  "authgate.billing.mjs"
+];
+async function loadConfig(cwd) {
+  var _a, _b;
+  let configPath = null;
+  for (const filename of CONFIG_FILENAMES) {
+    const candidate = (0, import_path.resolve)(cwd, filename);
+    if ((0, import_fs.existsSync)(candidate)) {
+      configPath = candidate;
+      break;
+    }
+  }
+  if (!configPath) {
+    throw new Error(
+      `No billing config found. Expected one of: ${CONFIG_FILENAMES.join(", ")}
+Run \`npx @auth-gate/billing init\` to create one.`
+    );
+  }
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(cwd, { interopDefault: true });
+  const mod = await jiti.import(configPath);
+  const raw = (_b = (_a = mod.default) != null ? _a : mod.billing) != null ? _b : mod;
+  const config = raw && typeof raw === "object" && "_config" in raw ? raw._config : raw;
+  return validateConfig(config);
+}
+
+// src/diff.ts
+function priceConfigKey(planKey, price) {
+  var _a, _b;
+  const interval = price.interval;
+  const count = (_a = price.intervalCount) != null ? _a : 1;
+  const suffix = count > 1 ? `_x${count}` : "";
+  const priceType = (_b = price.type) != null ? _b : "recurring";
+  if (priceType === "per_seat") {
+    const p2 = price;
+    return `${planKey}_seat_${p2.metric}_${interval}${suffix}_${p2.amount}_${p2.currency}`;
+  }
+  if (priceType === "metered") {
+    const p2 = price;
+    return `${planKey}_${p2.metric}_${interval}${suffix}_${p2.tierMode}_${p2.currency}`;
+  }
+  if (priceType === "tiered") {
+    const p2 = price;
+    return `${planKey}_${interval}${suffix}_${p2.tierMode}_${p2.currency}`;
+  }
+  const p = price;
+  return `${planKey}_${interval}${suffix}_${p.amount}_${p.currency}`;
+}
+function computeDiff(config, server, subscriberCounts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const planOps = [];
+  const priceOps = [];
+  let hasDestructive = false;
+  const serverByKey = /* @__PURE__ */ new Map();
+  const serverByPreviousKey = /* @__PURE__ */ new Map();
+  for (const product of server.products) {
+    if (product.configKey && product.managedBy === "config") {
+      serverByKey.set(product.configKey, product);
+    }
+    for (const prevKey of (_a = product.previousConfigKeys) != null ? _a : []) {
+      serverByPreviousKey.set(prevKey, product);
+    }
+  }
+  const renameMap = /* @__PURE__ */ new Map();
+  for (const [key, plan] of Object.entries(config.plans)) {
+    if (plan.renamedFrom) {
+      renameMap.set(plan.renamedFrom, key);
+    }
+  }
+  for (const [key, plan] of Object.entries(config.plans)) {
+    let existing = serverByKey.get(key);
+    if (!existing && plan.renamedFrom) {
+      existing = (_b = serverByKey.get(plan.renamedFrom)) != null ? _b : serverByPreviousKey.get(plan.renamedFrom);
+      if (existing) {
+        const subs = (_c = subscriberCounts[existing.id]) != null ? _c : 0;
+        planOps.push({ type: "rename", key, oldKey: plan.renamedFrom, plan, existing, activeSubscribers: subs });
+        const serverPricesByKey = /* @__PURE__ */ new Map();
+        for (const sp of existing.prices) {
+          if (sp.configKey && sp.isActive) {
+            serverPricesByKey.set(sp.configKey, sp);
+          }
+        }
+        const configPriceKeys = /* @__PURE__ */ new Set();
+        for (const price of plan.prices) {
+          const pk = priceConfigKey(key, price);
+          configPriceKeys.add(pk);
+          if (!serverPricesByKey.has(pk)) {
+            priceOps.push({ type: "create", planKey: key, price, configKey: pk });
+          }
+        }
+        for (const [pk, sp] of serverPricesByKey) {
+          if (!configPriceKeys.has(pk)) {
+            priceOps.push({ type: "archive", planKey: key, existing: sp, configKey: pk });
+          }
+        }
+        serverByKey.delete(existing.configKey);
+        serverByKey.delete(key);
+        continue;
+      }
+    }
+    if (!existing) {
+      planOps.push({ type: "create", key, plan });
+      for (const price of plan.prices) {
+        priceOps.push({
+          type: "create",
+          planKey: key,
+          price,
+          configKey: priceConfigKey(key, price)
+        });
+      }
+    } else {
+      const changes = [];
+      if (existing.name !== plan.name) changes.push(`name: "${existing.name}" \u2192 "${plan.name}"`);
+      if (((_d = existing.description) != null ? _d : void 0) !== ((_e = plan.description) != null ? _e : void 0)) {
+        changes.push(`description changed`);
+      }
+      const existingFeatures = ((_f = existing.features) != null ? _f : []).sort().join(",");
+      const configFeatures = ((_g = plan.features) != null ? _g : []).sort().join(",");
+      if (existingFeatures !== configFeatures) changes.push(`features changed`);
+      const existingEntitlements = JSON.stringify((_h = existing.entitlements) != null ? _h : null);
+      const configEntitlements = JSON.stringify((_i = plan.entitlements) != null ? _i : null);
+      if (existingEntitlements !== configEntitlements) changes.push(`entitlements changed`);
+      const serverPricesByKey = /* @__PURE__ */ new Map();
+      for (const sp of existing.prices) {
+        if (sp.configKey && sp.isActive) {
+          serverPricesByKey.set(sp.configKey, sp);
+        }
+      }
+      const configPriceKeys = /* @__PURE__ */ new Set();
+      for (const price of plan.prices) {
+        const pk = priceConfigKey(key, price);
+        configPriceKeys.add(pk);
+        if (!serverPricesByKey.has(pk)) {
+          priceOps.push({ type: "create", planKey: key, price, configKey: pk });
+        }
+      }
+      let hasPriceArchives = false;
+      for (const [pk, sp] of serverPricesByKey) {
+        if (!configPriceKeys.has(pk)) {
+          priceOps.push({ type: "archive", planKey: key, existing: sp, configKey: pk });
+          hasPriceArchives = true;
+        }
+      }
+      if (changes.length > 0 || hasPriceArchives) {
+        const versionBump = hasPriceArchives;
+        if (versionBump) changes.push("prices changed");
+        planOps.push(__spreadValues({
+          type: "update",
+          key,
+          plan,
+          existing,
+          changes
+        }, versionBump ? { versionBump: true, grandfathering: plan.grandfathering } : {}));
+      }
+    }
+    serverByKey.delete(key);
+  }
+  for (const [key, product] of serverByKey) {
+    if (renameMap.has(key)) continue;
+    if (product.isActive) {
+      const subs = (_j = subscriberCounts[product.id]) != null ? _j : 0;
+      if (subs > 0) hasDestructive = true;
+      planOps.push({ type: "archive", key, existing: product, activeSubscribers: subs });
+      for (const sp of product.prices) {
+        if (sp.isActive && sp.configKey) {
+          priceOps.push({ type: "archive", planKey: key, existing: sp, configKey: sp.configKey });
+        }
+      }
+    }
+  }
+  return { planOps, priceOps, hasDestructive };
+}
+
+// src/formatter.ts
+var import_chalk = __toESM(require("chalk"), 1);
+function formatAmount(cents, currency) {
+  const amount = (cents / 100).toFixed(2);
+  return `${currency.toUpperCase()} ${amount}`;
+}
+function formatInterval(interval, count) {
+  const c = count != null ? count : 1;
+  if (c === 1) return interval === "monthly" ? "/mo" : "/yr";
+  return `every ${c} ${interval.replace("ly", "s")}`;
+}
+function formatPrice(price) {
+  var _a;
+  const priceType = (_a = price.type) != null ? _a : "recurring";
+  const interval = formatInterval(price.interval, price.intervalCount);
+  if (priceType === "per_seat") {
+    const p2 = price;
+    return `per seat (${p2.metric}): ${formatAmount(p2.amount, p2.currency)}${interval}`;
+  }
+  if (priceType === "metered") {
+    const p2 = price;
+    return `metered (${p2.metric}): ${p2.tierMode} tiers ${p2.currency.toUpperCase()}${interval}`;
+  }
+  if (priceType === "tiered") {
+    const p2 = price;
+    return `tiered: ${p2.tierMode} tiers ${p2.currency.toUpperCase()}${interval}`;
+  }
+  const p = price;
+  return `${formatAmount(p.amount, p.currency)}${interval}`;
+}
+function formatPriceOp(op) {
+  if (op.type === "create") {
+    return formatPrice(op.price);
+  }
+  return op.configKey;
+}
+function formatDiff(diff, dryRun) {
+  var _a, _b;
+  const lines = [];
+  if (dryRun) {
+    lines.push(import_chalk.default.bold("AuthGate Billing Sync \u2014 DRY RUN") + import_chalk.default.dim(" (use --apply to execute)"));
+  } else {
+    lines.push(import_chalk.default.bold("AuthGate Billing Sync \u2014 APPLYING CHANGES"));
+  }
+  lines.push("");
+  if (diff.planOps.length === 0 && diff.priceOps.length === 0) {
+    lines.push(import_chalk.default.green("  Everything is in sync. No changes needed."));
+    return lines.join("\n");
+  }
+  for (const op of diff.planOps) {
+    if (op.type === "create") {
+      lines.push(import_chalk.default.green(`  + CREATE plan "${op.key}"`));
+      if (op.plan.description) {
+        lines.push(import_chalk.default.dim(`    ${op.plan.description}`));
+      }
+      if ((_a = op.plan.features) == null ? void 0 : _a.length) {
+        lines.push(import_chalk.default.dim(`    features: ${op.plan.features.join(", ")}`));
+      }
+      if (op.plan.entitlements && Object.keys(op.plan.entitlements).length > 0) {
+        const entries = Object.entries(op.plan.entitlements).map(
+          ([k, v]) => v === true ? k : `${k} (limit: ${v.limit})`
+        );
+        lines.push(import_chalk.default.dim(`    entitlements: ${entries.join(", ")}`));
+      }
+      for (const price of op.plan.prices) {
+        lines.push(
+          import_chalk.default.green(`    + price: ${formatPrice(price)}`)
+        );
+      }
+    } else if (op.type === "update") {
+      let updateLabel = `  ~ UPDATE plan "${op.key}"`;
+      if (op.versionBump) {
+        const oldVersion = (_b = op.existing.version) != null ? _b : 1;
+        updateLabel += ` (v${oldVersion} \u2192 v${oldVersion + 1})`;
+        if (op.grandfathering) {
+          updateLabel += import_chalk.default.dim(` [${op.grandfathering}]`);
+        }
+      }
+      lines.push(import_chalk.default.yellow(updateLabel));
+      for (const change of op.changes) {
+        lines.push(import_chalk.default.yellow(`    ${change}`));
+      }
+    } else if (op.type === "archive") {
+      lines.push(import_chalk.default.red(`  - ARCHIVE plan "${op.key}"`));
+      if (op.activeSubscribers > 0) {
+        lines.push(
+          import_chalk.default.red.bold(`    \u26A0 ${op.activeSubscribers} active subscriber${op.activeSubscribers > 1 ? "s" : ""} \u2014 they keep their current plan until cancellation`)
+        );
+      }
+    } else if (op.type === "rename") {
+      lines.push(import_chalk.default.cyan(`  ~ RENAME plan "${op.oldKey}" \u2192 "${op.key}"`));
+      if (op.activeSubscribers > 0) {
+        lines.push(import_chalk.default.dim(`    ${op.activeSubscribers} subscriber${op.activeSubscribers > 1 ? "s" : ""} preserved`));
+      }
+    }
+    lines.push("");
+  }
+  const standalonePriceOps = diff.priceOps.filter(
+    (op) => !diff.planOps.some((po) => po.type === "create" && po.key === op.planKey)
+  );
+  for (const op of standalonePriceOps) {
+    if (op.type === "create") {
+      lines.push(import_chalk.default.green(`    + price on "${op.planKey}": ${formatPriceOp(op)}`));
+    } else if (op.type === "archive") {
+      lines.push(import_chalk.default.red(`    - archive price on "${op.planKey}" (${op.configKey})`));
+    }
+  }
+  const creates = diff.planOps.filter((o) => o.type === "create").length;
+  const updates = diff.planOps.filter((o) => o.type === "update").length;
+  const archives = diff.planOps.filter((o) => o.type === "archive").length;
+  const renames = diff.planOps.filter((o) => o.type === "rename").length;
+  lines.push("");
+  lines.push(
+    import_chalk.default.dim(`  Summary: ${creates} create, ${updates} update, ${renames} rename, ${archives} archive.`) + (dryRun ? import_chalk.default.dim(" Run with --apply to execute.") : "")
+  );
+  if (diff.hasDestructive && dryRun) {
+    lines.push(
+      import_chalk.default.red.bold("\n  \u26A0 Destructive changes detected (plans with active subscribers).") + import_chalk.default.red(" Use --apply --force to proceed.")
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/sync.ts
+var SyncClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.environment = config.environment;
+  }
+  async request(method, path, body) {
+    var _a, _b;
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    if (this.environment) {
+      headers["X-AuthGate-Environment"] = this.environment;
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      let message;
+      try {
+        const json = JSON.parse(text);
+        message = (_b = (_a = json.error) != null ? _a : json.message) != null ? _b : text;
+      } catch (e) {
+        message = text;
+      }
+      throw new Error(`API error (${res.status}): ${message}`);
+    }
+    return res.json();
+  }
+  async getState() {
+    return this.request("GET", "/api/v1/billing/sync/state");
+  }
+  async getSubscriberCounts() {
+    return this.request("GET", "/api/v1/billing/sync/subscribers");
+  }
+  async apply(config, force) {
+    return this.request("POST", "/api/v1/billing/sync/apply", {
+      plans: config.plans,
+      migrations: config.migrations,
+      force
+    });
+  }
+  async getMigration(migrationId) {
+    return this.request(
+      "GET",
+      `/api/v1/billing/migrations/${migrationId}`
+    );
+  }
+  async executeMigration(migrationId, opts) {
+    return this.request(
+      "POST",
+      `/api/v1/billing/migrations/${migrationId}/execute`,
+      (opts == null ? void 0 : opts.batchSize) ? { batchSize: opts.batchSize } : void 0
+    );
+  }
+  async createMigration(from, to, opts) {
+    return this.request(
+      "POST",
+      "/api/v1/billing/migrations",
+      { from, to, priceMapping: opts == null ? void 0 : opts.priceMapping }
+    );
+  }
+};
+
+// src/pull.ts
+function slugify(name) {
+  let slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  if (/^[0-9]/.test(slug)) slug = `plan_${slug}`;
+  return slug || "plan";
+}
+function deduplicateKeys(keys) {
+  const seen = /* @__PURE__ */ new Map();
+  return keys.map((k) => {
+    var _a;
+    const count = ((_a = seen.get(k)) != null ? _a : 0) + 1;
+    seen.set(k, count);
+    return count > 1 ? `${k}_${count}` : k;
+  });
+}
+function serverStateToBillingConfig(state, options) {
+  const dashboardPlans = [];
+  const activeProducts = state.products.filter((p) => p.isActive);
+  const configProducts = [];
+  for (const product of activeProducts) {
+    if (product.managedBy === "dashboard" && !(options == null ? void 0 : options.includeDashboard)) {
+      dashboardPlans.push({
+        name: product.name,
+        suggestedKey: slugify(product.name)
+      });
+    } else {
+      configProducts.push(product);
+    }
+  }
+  const rawKeys = configProducts.map((p) => {
+    var _a;
+    return (_a = p.configKey) != null ? _a : slugify(p.name);
+  });
+  const keys = deduplicateKeys(rawKeys);
+  const plans = {};
+  for (let i = 0; i < configProducts.length; i++) {
+    const product = configProducts[i];
+    const key = keys[i];
+    const prices = product.prices.filter((p) => p.isActive).map((p) => {
+      var _a;
+      const price = {
+        amount: (_a = p.amount) != null ? _a : 0,
+        currency: p.currency,
+        interval: p.interval
+      };
+      if (p.intervalCount > 1) price.intervalCount = p.intervalCount;
+      return price;
+    });
+    const plan = { name: product.name, prices };
+    if (product.description) plan.description = product.description;
+    if (product.features.length > 0) plan.features = product.features;
+    if (product.entitlements && Object.keys(product.entitlements).length > 0) {
+      plan.entitlements = product.entitlements;
+    }
+    plans[key] = plan;
+  }
+  return { config: { plans }, dashboardPlans };
+}
+function renderConfigAsTypeScript(result) {
+  var _a;
+  const lines = [
+    'import { defineBilling } from "@auth-gate/billing";',
+    "",
+    "export default defineBilling({",
+    "  plans: {"
+  ];
+  const planEntries = Object.entries(result.config.plans);
+  for (const [key, plan] of planEntries) {
+    lines.push(`    ${key}: {`);
+    lines.push(`      name: ${JSON.stringify(plan.name)},`);
+    if (plan.description)
+      lines.push(`      description: ${JSON.stringify(plan.description)},`);
+    if ((_a = plan.features) == null ? void 0 : _a.length)
+      lines.push(`      features: ${JSON.stringify(plan.features)},`);
+    lines.push("      prices: [");
+    for (const price of plan.prices) {
+      const parts = [];
+      if ("amount" in price)
+        parts.push(`amount: ${price.amount}`);
+      parts.push(
+        `currency: ${JSON.stringify(price.currency)}`,
+        `interval: ${JSON.stringify(price.interval)}`
+      );
+      if (price.intervalCount && price.intervalCount > 1)
+        parts.push(`intervalCount: ${price.intervalCount}`);
+      lines.push(`        { ${parts.join(", ")} },`);
+    }
+    lines.push("      ],");
+    lines.push("    },");
+  }
+  lines.push("  },");
+  lines.push("});");
+  if (result.dashboardPlans.length > 0) {
+    lines.push("");
+    lines.push("// Dashboard-managed plans (not synced by config):");
+    for (const dp of result.dashboardPlans) {
+      lines.push(
+        `// ${dp.suggestedKey}: { name: ${JSON.stringify(dp.name)} }`
+      );
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/json-formatter.ts
+function calculateRevenueImpact(diff, subscriberCounts) {
+  var _a, _b;
+  const breakdown = [];
+  const archivedPrices = diff.priceOps.filter((op) => op.type === "archive");
+  for (const archived of archivedPrices) {
+    if (archived.type !== "archive") continue;
+    const matching = diff.priceOps.find(
+      (op) => op.type === "create" && op.planKey === archived.planKey && op.price.interval === archived.existing.interval && op.price.currency === archived.existing.currency
+    );
+    const subs = (_a = subscriberCounts[archived.planKey]) != null ? _a : 0;
+    const oldAmount = (_b = archived.existing.amount) != null ? _b : 0;
+    const newAmount = (matching == null ? void 0 : matching.type) === "create" ? matching.price.amount : 0;
+    const normalizer = archived.existing.interval === "yearly" ? 12 : 1;
+    const delta = Math.round((newAmount - oldAmount) / normalizer * subs);
+    if (delta !== 0) {
+      breakdown.push({
+        planKey: archived.planKey,
+        oldAmount,
+        newAmount,
+        subscribers: subs,
+        monthlyDelta: delta
+      });
+    }
+  }
+  return {
+    monthlyDelta: breakdown.reduce((s, b) => s + b.monthlyDelta, 0),
+    affectedSubscribers: breakdown.reduce((s, b) => s + b.subscribers, 0),
+    breakdown
+  };
+}
+function mapPlanOp(op) {
+  const base = { type: op.type, key: op.key };
+  switch (op.type) {
+    case "create":
+      base.name = op.plan.name;
+      break;
+    case "update":
+      base.name = op.plan.name;
+      base.changes = op.changes;
+      break;
+    case "archive":
+      base.name = op.existing.name;
+      base.activeSubscribers = op.activeSubscribers;
+      break;
+    case "rename":
+      base.name = op.plan.name;
+      base.oldKey = op.oldKey;
+      base.activeSubscribers = op.activeSubscribers;
+      break;
+  }
+  return base;
+}
+function mapPriceOp(op) {
+  var _a;
+  const base = {
+    type: op.type,
+    planKey: op.planKey,
+    configKey: op.configKey
+  };
+  if (op.type === "create") {
+    base.amount = op.price.amount;
+    base.currency = op.price.currency;
+    base.interval = op.price.interval;
+  } else {
+    base.amount = (_a = op.existing.amount) != null ? _a : void 0;
+    base.currency = op.existing.currency;
+    base.interval = op.existing.interval;
+  }
+  return base;
+}
+function formatDiffAsJson(diff, subscriberCounts, dryRun) {
+  const planOps = diff.planOps.map(mapPlanOp);
+  const priceOps = diff.priceOps.map(mapPriceOp);
+  const revenueImpact = calculateRevenueImpact(diff, subscriberCounts);
+  const creates = diff.planOps.filter((o) => o.type === "create").length;
+  const updates = diff.planOps.filter((o) => o.type === "update").length;
+  const archives = diff.planOps.filter((o) => o.type === "archive").length;
+  const renames = diff.planOps.filter((o) => o.type === "rename").length;
+  let summary;
+  if (planOps.length === 0 && priceOps.length === 0) {
+    summary = "No changes detected.";
+  } else {
+    const parts = [];
+    if (creates > 0) parts.push(`${creates} create`);
+    if (updates > 0) parts.push(`${updates} update`);
+    if (renames > 0) parts.push(`${renames} rename`);
+    if (archives > 0) parts.push(`${archives} archive`);
+    summary = parts.join(", ");
+    if (revenueImpact.monthlyDelta !== 0) {
+      const sign = revenueImpact.monthlyDelta > 0 ? "+" : "";
+      summary += ` | Revenue impact: ${sign}$${(revenueImpact.monthlyDelta / 100).toFixed(2)}/mo`;
+    }
+  }
+  return {
+    planOps,
+    priceOps,
+    revenueImpact,
+    hasDestructive: diff.hasDestructive,
+    dryRun,
+    summary
+  };
+}
+
+// src/env.ts
+var VALID_ENVIRONMENTS = [
+  "production",
+  "staging",
+  "preview",
+  "development",
+  "test"
+];
+function resolveEnvironment(opts) {
+  var _a, _b;
+  const value = (_b = (_a = opts.env) != null ? _a : process.env.AUTHGATE_ENV) != null ? _b : "production";
+  if (!VALID_ENVIRONMENTS.includes(value)) {
+    throw new Error(
+      `Invalid environment "${value}". Must be one of: ${VALID_ENVIRONMENTS.join(", ")}`
+    );
+  }
+  return value;
+}
+
+// src/codegen.ts
+function generateBillingConstants(config) {
+  const lines = [];
+  lines.push("// Auto-generated by @auth-gate/billing. Do not edit manually.");
+  lines.push("// Regenerate with: npx @auth-gate/billing generate");
+  lines.push("");
+  const planKeys = Object.keys(config.plans);
+  lines.push("export const Plans = {");
+  for (const key of planKeys) {
+    lines.push(`  ${key}: ${JSON.stringify(key)},`);
+  }
+  lines.push("} as const;");
+  lines.push("");
+  lines.push("export type PlanKey = (typeof Plans)[keyof typeof Plans];");
+  lines.push("");
+  if (config.features && Object.keys(config.features).length > 0) {
+    const featureKeys = Object.keys(config.features);
+    lines.push("export const Features = {");
+    for (const key of featureKeys) {
+      lines.push(`  ${key}: ${JSON.stringify(key)},`);
+    }
+    lines.push("} as const;");
+    lines.push("");
+    lines.push(
+      "export type FeatureKey = (typeof Features)[keyof typeof Features];"
+    );
+    lines.push("");
+    const meteredFeatures = featureKeys.filter(
+      (k) => config.features[k].type === "metered"
+    );
+    if (meteredFeatures.length > 0) {
+      lines.push("export const Limits = {");
+      for (const planKey of planKeys) {
+        const plan = config.plans[planKey];
+        const entitlements = plan.entitlements;
+        if (!entitlements) continue;
+        const meteredEntries = meteredFeatures.filter((f) => entitlements[f] && typeof entitlements[f] === "object").map((f) => {
+          const val = entitlements[f];
+          return `    ${f}: ${val.limit},`;
+        });
+        if (meteredEntries.length > 0) {
+          lines.push(`  ${planKey}: {`);
+          for (const entry of meteredEntries) {
+            lines.push(entry);
+          }
+          lines.push("  },");
+        }
+      }
+      lines.push("} as const;");
+      lines.push("");
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/cli.ts
+var import_chalk2 = __toESM(require("chalk"), 1);
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var HELP = `
+Usage: @auth-gate/billing <command> [options]
+
+Commands:
+  sync          Preview or apply billing config changes
+  pull          Generate config from existing plans
+  migrate       Execute a pending migration by ID
+  init          Create a starter authgate.billing.ts config file
+  generate      Generate typed constants from billing config
+  env list      List available environments
+
+Options (sync):
+  --apply       Apply changes (default: dry-run only)
+  --force       Allow archiving plans with active subscribers
+  --strict      Treat warnings as errors (recommended for CI/CD)
+  --json        Output diff as JSON (for CI/CD integrations)
+
+Options (pull):
+  --from-stripe        Pull from Stripe directly (requires STRIPE_SECRET_KEY)
+  --dry-run            Preview generated config without writing
+  --include-dashboard  Include dashboard-managed plans
+  --output <path>      Output file path (default: authgate.billing.ts)
+
+Options (migrate):
+  --id          Migration ID to execute
+  <from> <to>   Plan config keys to migrate between
+  --batch-size  Number of subscribers per batch (default: 100)
+  --dry-run     Preview migration without executing
+
+Global Options:
+  --env <name>  Target environment (default: production)
+
+Environment:
+  AUTHGATE_API_KEY    Your project API key (required)
+  AUTHGATE_BASE_URL   AuthGate instance URL (required)
+  AUTHGATE_ENV        Default environment (overridden by --env)
+  STRIPE_SECRET_KEY   Stripe secret key (for --from-stripe)
+`;
+function parseEnvFlag(args) {
+  const idx = args.indexOf("--env");
+  return idx !== -1 ? args[idx + 1] : void 0;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h") {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (command === "init") {
+    await runInit();
+    return;
+  }
+  if (command === "generate") {
+    const outputIdx = args.indexOf("--output");
+    const outputPath = outputIdx !== -1 ? args[outputIdx + 1] : void 0;
+    await runGenerate({ outputPath });
+    return;
+  }
+  if (command === "env") {
+    const subcommand = args[1];
+    if (subcommand === "list") {
+      console.log(import_chalk2.default.bold("Available environments:"));
+      for (const env of VALID_ENVIRONMENTS) {
+        const marker = env === "production" ? import_chalk2.default.dim(" (default)") : "";
+        console.log(`  ${env}${marker}`);
+      }
+      return;
+    }
+    console.error(import_chalk2.default.red(`Unknown env subcommand: ${subcommand != null ? subcommand : "(none)"}`));
+    process.exit(1);
+  }
+  if (command === "pull") {
+    const fromStripe = args.includes("--from-stripe");
+    const dryRun = args.includes("--dry-run");
+    const includeDashboard = args.includes("--include-dashboard");
+    const outputIdx = args.indexOf("--output");
+    const outputPath = outputIdx !== -1 ? args[outputIdx + 1] : void 0;
+    await runPull({ fromStripe, dryRun, includeDashboard, outputPath });
+    return;
+  }
+  if (command === "sync") {
+    const apply = args.includes("--apply");
+    const force = args.includes("--force");
+    const strict = args.includes("--strict");
+    const json = args.includes("--json");
+    const envFlag = parseEnvFlag(args);
+    await runSync({ apply, force, strict, json, envFlag });
+    return;
+  }
+  if (command === "migrate") {
+    const idIndex = args.indexOf("--id");
+    const migrationId = idIndex !== -1 ? args[idIndex + 1] : void 0;
+    const batchIndex = args.indexOf("--batch-size");
+    const batchSize = batchIndex !== -1 ? parseInt(args[batchIndex + 1], 10) : void 0;
+    const dryRun = args.includes("--dry-run");
+    const positionalArgs = args.slice(1).filter((a) => !a.startsWith("--") && args[args.indexOf(a) - 1] !== "--id" && args[args.indexOf(a) - 1] !== "--batch-size");
+    const fromKey = positionalArgs[0];
+    const toKey = positionalArgs[1];
+    await runMigrate({ migrationId, fromKey, toKey, batchSize, dryRun });
+    return;
+  }
+  console.error(import_chalk2.default.red(`Unknown command: ${command}`));
+  console.log(HELP);
+  process.exit(1);
+}
+async function runGenerate(opts) {
+  var _a;
+  console.log(import_chalk2.default.yellow(
+    "Note: The `generate` command is deprecated. defineBilling() now provides end-to-end type inference \u2014 use createBillingHooks(billing) and createBillingHelpers({ billing }) instead.\n"
+  ));
+  let config;
+  try {
+    config = await loadConfig(process.cwd());
+  } catch (err) {
+    console.error(import_chalk2.default.red(`Config error: ${err.message}`));
+    process.exit(1);
+  }
+  const output = generateBillingConstants(config);
+  const outPath = (_a = opts.outputPath) != null ? _a : (0, import_path2.resolve)(process.cwd(), "authgate.billing.generated.ts");
+  (0, import_fs2.writeFileSync)(outPath, output);
+  console.log(import_chalk2.default.green(`Generated ${outPath}`));
+  const planCount = Object.keys(config.plans).length;
+  const featureCount = config.features ? Object.keys(config.features).length : 0;
+  console.log(import_chalk2.default.dim(`${planCount} plans${featureCount > 0 ? `, ${featureCount} features` : ""}`));
+}
+async function runPull(opts) {
+  var _a;
+  let state;
+  if (opts.fromStripe) {
+    const stripeKey = process.env.STRIPE_SECRET_KEY;
+    if (!stripeKey) {
+      console.error(
+        import_chalk2.default.red("STRIPE_SECRET_KEY is required for --from-stripe")
+      );
+      process.exit(1);
+    }
+    const { fetchStripeState: fetchStripeState2 } = await Promise.resolve().then(() => (init_pull_from_stripe(), pull_from_stripe_exports));
+    state = await fetchStripeState2(stripeKey);
+  } else {
+    const apiKey = process.env.AUTHGATE_API_KEY;
+    const baseUrl = process.env.AUTHGATE_BASE_URL;
+    if (!apiKey || !baseUrl) {
+      console.error(
+        import_chalk2.default.red("AUTHGATE_API_KEY and AUTHGATE_BASE_URL required")
+      );
+      process.exit(1);
+    }
+    const environment = resolveEnvironment({});
+    const client = new SyncClient({ baseUrl, apiKey, environment });
+    state = await client.getState();
+  }
+  const result = serverStateToBillingConfig(state, {
+    includeDashboard: opts.includeDashboard
+  });
+  const output = renderConfigAsTypeScript(result);
+  const planCount = Object.keys(result.config.plans).length;
+  const priceCount = Object.values(result.config.plans).reduce(
+    (sum, p) => sum + p.prices.length,
+    0
+  );
+  if (opts.dryRun) {
+    console.log(output);
+  } else {
+    const outPath = (_a = opts.outputPath) != null ? _a : (0, import_path2.resolve)(process.cwd(), "authgate.billing.ts");
+    (0, import_fs2.writeFileSync)(outPath, output);
+    console.log(import_chalk2.default.green(`Created ${outPath}`));
+  }
+  console.log(
+    import_chalk2.default.dim(
+      `${planCount} plans, ${priceCount} prices${result.dashboardPlans.length > 0 ? `, ${result.dashboardPlans.length} dashboard-only plans skipped` : ""}`
+    )
+  );
+}
+async function runInit() {
+  const configPath = (0, import_path2.resolve)(process.cwd(), "authgate.billing.ts");
+  const template = `import { defineBilling } from "@auth-gate/billing";
+
+/**
+ * Billing config \u2014 plan/feature keys provide full IDE autocomplete.
+ *
+ * Sync: npx @auth-gate/billing sync --apply
+ */
+export const billing = defineBilling({
+  plans: {
+    starter: {
+      name: "Starter",
+      description: "For individuals and small projects",
+      prices: [
+        { amount: 999, currency: "usd", interval: "monthly" },
+        { amount: 9999, currency: "usd", interval: "yearly" },
+      ],
+    },
+    pro: {
+      name: "Pro",
+      description: "For growing teams",
+      prices: [
+        { amount: 2999, currency: "usd", interval: "monthly" },
+        { amount: 29999, currency: "usd", interval: "yearly" },
+      ],
+    },
+  },
+});
+
+// Default export for CLI compatibility
+export default billing;
+`;
+  (0, import_fs2.writeFileSync)(configPath, template, "utf-8");
+  console.log(import_chalk2.default.green(`Created ${configPath}`));
+  console.log(import_chalk2.default.dim("Edit your plans, then run: npx @auth-gate/billing sync"));
+}
+async function runSync(opts) {
+  var _a;
+  const apiKey = process.env.AUTHGATE_API_KEY;
+  const baseUrl = process.env.AUTHGATE_BASE_URL;
+  if (!apiKey) {
+    console.error(import_chalk2.default.red("Missing AUTHGATE_API_KEY environment variable."));
+    process.exit(1);
+  }
+  if (!baseUrl) {
+    console.error(import_chalk2.default.red("Missing AUTHGATE_BASE_URL environment variable."));
+    process.exit(1);
+  }
+  const environment = resolveEnvironment({ env: opts.envFlag });
+  let config;
+  try {
+    config = await loadConfig(process.cwd());
+  } catch (err) {
+    console.error(import_chalk2.default.red(`Config error: ${err.message}`));
+    process.exit(1);
+  }
+  const planCount = Object.keys(config.plans).length;
+  const envLabel = environment !== "production" ? ` [${environment}]` : "";
+  console.log(import_chalk2.default.dim(`Loaded config: ${planCount} plan${planCount > 1 ? "s" : ""}${envLabel}`));
+  const client = new SyncClient({ baseUrl, apiKey, environment });
+  let serverState;
+  let subscriberCounts;
+  try {
+    [serverState, subscriberCounts] = await Promise.all([
+      client.getState(),
+      client.getSubscriberCounts()
+    ]);
+  } catch (err) {
+    console.error(import_chalk2.default.red(`Failed to fetch server state: ${err.message}`));
+    process.exit(1);
+  }
+  const diff = computeDiff(config, serverState, subscriberCounts);
+  if (opts.json) {
+    const jsonOutput = formatDiffAsJson(diff, subscriberCounts, !opts.apply);
+    console.log(JSON.stringify(jsonOutput, null, 2));
+    process.exit(diff.hasDestructive && opts.strict ? 1 : 0);
+  }
+  console.log("");
+  console.log(formatDiff(diff, !opts.apply));
+  if (!opts.apply) {
+    if (opts.strict && diff.hasDestructive) {
+      console.error(import_chalk2.default.red.bold("\n  --strict: destructive changes detected. Failing."));
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+  if (diff.hasDestructive && !opts.force) {
+    console.error(import_chalk2.default.red("\nDestructive changes require --force flag."));
+    process.exit(1);
+  }
+  if (diff.planOps.length === 0 && diff.priceOps.length === 0) {
+    process.exit(0);
+  }
+  try {
+    console.log("");
+    const result = await client.apply(config, opts.force);
+    console.log(import_chalk2.default.green.bold("Sync complete!"));
+    if (result.created.length) console.log(import_chalk2.default.green(`  Created: ${result.created.join(", ")}`));
+    if (result.updated.length) console.log(import_chalk2.default.yellow(`  Updated: ${result.updated.join(", ")}`));
+    if (result.renamed.length) console.log(import_chalk2.default.cyan(`  Renamed: ${result.renamed.join(", ")}`));
+    if (result.archived.length) console.log(import_chalk2.default.red(`  Archived: ${result.archived.join(", ")}`));
+    if (result.warnings.length) {
+      for (const w of result.warnings) {
+        console.log(import_chalk2.default.yellow(`  Warning: ${w}`));
+      }
+      if (opts.strict) {
+        console.error(import_chalk2.default.red.bold(`
+  --strict: ${result.warnings.length} warning${result.warnings.length > 1 ? "s" : ""} treated as errors.`));
+        process.exit(1);
+      }
+    }
+    const ss = result.stripeSync;
+    if (ss.productsCreated || ss.pricesCreated || ss.pricesArchived) {
+      console.log(
+        import_chalk2.default.dim(`  Stripe: ${ss.productsCreated} products created, ${ss.pricesCreated} prices created, ${ss.pricesArchived} prices archived`)
+      );
+    }
+    if ((_a = result.migrationIds) == null ? void 0 : _a.length) {
+      for (const migId of result.migrationIds) {
+        console.log(import_chalk2.default.dim(`
+  Migration queued (ID: ${migId})`));
+        console.log(import_chalk2.default.dim("  Executing migration..."));
+        try {
+          const migResult = await client.executeMigration(migId);
+          console.log(import_chalk2.default.green(`  Migrated: ${migResult.migrated} subscribers`));
+          if (migResult.skipped > 0) console.log(import_chalk2.default.yellow(`  Skipped: ${migResult.skipped}`));
+          if (migResult.failed > 0) console.log(import_chalk2.default.red(`  Failed: ${migResult.failed}`));
+        } catch (err) {
+          console.log(import_chalk2.default.yellow(`  Migration execution deferred: ${err.message}`));
+          console.log(import_chalk2.default.dim(`  Run: npx @auth-gate/billing migrate --id ${migId}`));
+        }
+      }
+    }
+  } catch (err) {
+    console.error(import_chalk2.default.red(`Sync failed: ${err.message}`));
+    process.exit(1);
+  }
+}
+async function runMigrate(opts) {
+  if (!opts.migrationId && (!opts.fromKey || !opts.toKey)) {
+    console.error(import_chalk2.default.red("Usage: migrate --id <migrationId>  OR  migrate <from> <to>"));
+    process.exit(1);
+  }
+  const apiKey = process.env.AUTHGATE_API_KEY;
+  const baseUrl = process.env.AUTHGATE_BASE_URL;
+  if (!apiKey) {
+    console.error(import_chalk2.default.red("Missing AUTHGATE_API_KEY environment variable."));
+    process.exit(1);
+  }
+  if (!baseUrl) {
+    console.error(import_chalk2.default.red("Missing AUTHGATE_BASE_URL environment variable."));
+    process.exit(1);
+  }
+  const client = new SyncClient({ baseUrl, apiKey });
+  let migrationId = opts.migrationId;
+  if (!migrationId && opts.fromKey && opts.toKey) {
+    console.log(import_chalk2.default.dim(`Creating migration: ${opts.fromKey} \u2192 ${opts.toKey}`));
+    let createResult;
+    try {
+      createResult = await client.createMigration(opts.fromKey, opts.toKey);
+    } catch (err) {
+      console.error(import_chalk2.default.red(`Failed to create migration: ${err.message}`));
+      process.exit(1);
+    }
+    migrationId = createResult.migrationId;
+    console.log(import_chalk2.default.dim(`Migration ID: ${migrationId}`));
+    console.log("");
+    console.log(import_chalk2.default.bold("  Price mapping:"));
+    for (const [oldKey, newKey] of Object.entries(createResult.priceMapping)) {
+      console.log(import_chalk2.default.dim(`    ${oldKey}  \u2192  ${newKey}`));
+    }
+    console.log("");
+    console.log(import_chalk2.default.dim(`  Subscribers to migrate: ${createResult.totalSubscribers}`));
+    if (createResult.pastDueSkipped > 0) {
+      console.log(import_chalk2.default.yellow(`  past_due skipped: ${createResult.pastDueSkipped}`));
+    }
+    if (createResult.unmappedSkipped > 0) {
+      console.log(import_chalk2.default.yellow(`  Unmapped (no price match): ${createResult.unmappedSkipped}`));
+    }
+    console.log("");
+    if (opts.dryRun) {
+      console.log(import_chalk2.default.dim("  Dry run \u2014 no changes applied. Run without --dry-run to execute."));
+      process.exit(0);
+    }
+  }
+  let migration;
+  try {
+    migration = await client.getMigration(migrationId);
+  } catch (err) {
+    console.error(import_chalk2.default.red(`Failed to fetch migration: ${err.message}`));
+    process.exit(1);
+  }
+  console.log(import_chalk2.default.dim(`Migration: ${migration.fromConfigKey} \u2192 ${migration.toConfigKey}`));
+  console.log(import_chalk2.default.dim(`Status: ${migration.status} | Total: ${migration.totalCount} | Migrated: ${migration.migratedCount} | Failed: ${migration.failedCount}`));
+  if (opts.dryRun) {
+    console.log("");
+    console.log(import_chalk2.default.dim("  Dry run \u2014 no changes applied. Run without --dry-run to execute."));
+    process.exit(0);
+  }
+  if (migration.status === "completed") {
+    console.log(import_chalk2.default.green("Migration already completed."));
+    process.exit(0);
+  }
+  if (migration.status === "running") {
+    console.error(import_chalk2.default.yellow("Migration is already running. Check back later."));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(import_chalk2.default.cyan("Executing migration..."));
+  try {
+    const result = await client.executeMigration(migrationId, {
+      batchSize: opts.batchSize
+    });
+    console.log(import_chalk2.default.green.bold("Migration complete!"));
+    console.log(import_chalk2.default.green(`  Migrated: ${result.migrated}`));
+    if (result.skipped > 0) {
+      console.log(import_chalk2.default.yellow(`  Skipped: ${result.skipped}`));
+    }
+    if (result.failed > 0) {
+      console.log(import_chalk2.default.red(`  Failed: ${result.failed}`));
+    }
+  } catch (err) {
+    console.error(import_chalk2.default.red(`Migration failed: ${err.message}`));
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(import_chalk2.default.red(err.message));
+  process.exit(1);
+});