@auth-gate/billing 0.8.0

package/dist/cli.mjs

@@ -0,0 +1,821 @@
+#!/usr/bin/env node
+import {
+  computeDiff,
+  renderConfigAsTypeScript,
+  serverStateToBillingConfig,
+  validateConfig
+} from "./chunk-AHCLNQ6P.mjs";
+import "./chunk-I4E63NIC.mjs";
+
+// src/config-loader.ts
+import { resolve } from "path";
+import { existsSync } from "fs";
+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 = resolve(cwd, filename);
+    if (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/formatter.ts
+import chalk from "chalk";
+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(chalk.bold("AuthGate Billing Sync \u2014 DRY RUN") + chalk.dim(" (use --apply to execute)"));
+  } else {
+    lines.push(chalk.bold("AuthGate Billing Sync \u2014 APPLYING CHANGES"));
+  }
+  lines.push("");
+  if (diff.planOps.length === 0 && diff.priceOps.length === 0) {
+    lines.push(chalk.green("  Everything is in sync. No changes needed."));
+    return lines.join("\n");
+  }
+  for (const op of diff.planOps) {
+    if (op.type === "create") {
+      lines.push(chalk.green(`  + CREATE plan "${op.key}"`));
+      if (op.plan.description) {
+        lines.push(chalk.dim(`    ${op.plan.description}`));
+      }
+      if ((_a = op.plan.features) == null ? void 0 : _a.length) {
+        lines.push(chalk.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(chalk.dim(`    entitlements: ${entries.join(", ")}`));
+      }
+      for (const price of op.plan.prices) {
+        lines.push(
+          chalk.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 += chalk.dim(` [${op.grandfathering}]`);
+        }
+      }
+      lines.push(chalk.yellow(updateLabel));
+      for (const change of op.changes) {
+        lines.push(chalk.yellow(`    ${change}`));
+      }
+    } else if (op.type === "archive") {
+      lines.push(chalk.red(`  - ARCHIVE plan "${op.key}"`));
+      if (op.activeSubscribers > 0) {
+        lines.push(
+          chalk.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(chalk.cyan(`  ~ RENAME plan "${op.oldKey}" \u2192 "${op.key}"`));
+      if (op.activeSubscribers > 0) {
+        lines.push(chalk.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(chalk.green(`    + price on "${op.planKey}": ${formatPriceOp(op)}`));
+    } else if (op.type === "archive") {
+      lines.push(chalk.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(
+    chalk.dim(`  Summary: ${creates} create, ${updates} update, ${renames} rename, ${archives} archive.`) + (dryRun ? chalk.dim(" Run with --apply to execute.") : "")
+  );
+  if (diff.hasDestructive && dryRun) {
+    lines.push(
+      chalk.red.bold("\n  \u26A0 Destructive changes detected (plans with active subscribers).") + chalk.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/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
+import chalk2 from "chalk";
+import { writeFileSync } from "fs";
+import { resolve as resolve2 } from "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(chalk2.bold("Available environments:"));
+      for (const env of VALID_ENVIRONMENTS) {
+        const marker = env === "production" ? chalk2.dim(" (default)") : "";
+        console.log(`  ${env}${marker}`);
+      }
+      return;
+    }
+    console.error(chalk2.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(chalk2.red(`Unknown command: ${command}`));
+  console.log(HELP);
+  process.exit(1);
+}
+async function runGenerate(opts) {
+  var _a;
+  console.log(chalk2.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(chalk2.red(`Config error: ${err.message}`));
+    process.exit(1);
+  }
+  const output = generateBillingConstants(config);
+  const outPath = (_a = opts.outputPath) != null ? _a : resolve2(process.cwd(), "authgate.billing.generated.ts");
+  writeFileSync(outPath, output);
+  console.log(chalk2.green(`Generated ${outPath}`));
+  const planCount = Object.keys(config.plans).length;
+  const featureCount = config.features ? Object.keys(config.features).length : 0;
+  console.log(chalk2.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(
+        chalk2.red("STRIPE_SECRET_KEY is required for --from-stripe")
+      );
+      process.exit(1);
+    }
+    const { fetchStripeState } = await import("./pull-from-stripe-GX2Y5XMC.mjs");
+    state = await fetchStripeState(stripeKey);
+  } else {
+    const apiKey = process.env.AUTHGATE_API_KEY;
+    const baseUrl = process.env.AUTHGATE_BASE_URL;
+    if (!apiKey || !baseUrl) {
+      console.error(
+        chalk2.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 : resolve2(process.cwd(), "authgate.billing.ts");
+    writeFileSync(outPath, output);
+    console.log(chalk2.green(`Created ${outPath}`));
+  }
+  console.log(
+    chalk2.dim(
+      `${planCount} plans, ${priceCount} prices${result.dashboardPlans.length > 0 ? `, ${result.dashboardPlans.length} dashboard-only plans skipped` : ""}`
+    )
+  );
+}
+async function runInit() {
+  const configPath = resolve2(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;
+`;
+  writeFileSync(configPath, template, "utf-8");
+  console.log(chalk2.green(`Created ${configPath}`));
+  console.log(chalk2.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(chalk2.red("Missing AUTHGATE_API_KEY environment variable."));
+    process.exit(1);
+  }
+  if (!baseUrl) {
+    console.error(chalk2.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(chalk2.red(`Config error: ${err.message}`));
+    process.exit(1);
+  }
+  const planCount = Object.keys(config.plans).length;
+  const envLabel = environment !== "production" ? ` [${environment}]` : "";
+  console.log(chalk2.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(chalk2.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(chalk2.red.bold("\n  --strict: destructive changes detected. Failing."));
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+  if (diff.hasDestructive && !opts.force) {
+    console.error(chalk2.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(chalk2.green.bold("Sync complete!"));
+    if (result.created.length) console.log(chalk2.green(`  Created: ${result.created.join(", ")}`));
+    if (result.updated.length) console.log(chalk2.yellow(`  Updated: ${result.updated.join(", ")}`));
+    if (result.renamed.length) console.log(chalk2.cyan(`  Renamed: ${result.renamed.join(", ")}`));
+    if (result.archived.length) console.log(chalk2.red(`  Archived: ${result.archived.join(", ")}`));
+    if (result.warnings.length) {
+      for (const w of result.warnings) {
+        console.log(chalk2.yellow(`  Warning: ${w}`));
+      }
+      if (opts.strict) {
+        console.error(chalk2.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(
+        chalk2.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(chalk2.dim(`
+  Migration queued (ID: ${migId})`));
+        console.log(chalk2.dim("  Executing migration..."));
+        try {
+          const migResult = await client.executeMigration(migId);
+          console.log(chalk2.green(`  Migrated: ${migResult.migrated} subscribers`));
+          if (migResult.skipped > 0) console.log(chalk2.yellow(`  Skipped: ${migResult.skipped}`));
+          if (migResult.failed > 0) console.log(chalk2.red(`  Failed: ${migResult.failed}`));
+        } catch (err) {
+          console.log(chalk2.yellow(`  Migration execution deferred: ${err.message}`));
+          console.log(chalk2.dim(`  Run: npx @auth-gate/billing migrate --id ${migId}`));
+        }
+      }
+    }
+  } catch (err) {
+    console.error(chalk2.red(`Sync failed: ${err.message}`));
+    process.exit(1);
+  }
+}
+async function runMigrate(opts) {
+  if (!opts.migrationId && (!opts.fromKey || !opts.toKey)) {
+    console.error(chalk2.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(chalk2.red("Missing AUTHGATE_API_KEY environment variable."));
+    process.exit(1);
+  }
+  if (!baseUrl) {
+    console.error(chalk2.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(chalk2.dim(`Creating migration: ${opts.fromKey} \u2192 ${opts.toKey}`));
+    let createResult;
+    try {
+      createResult = await client.createMigration(opts.fromKey, opts.toKey);
+    } catch (err) {
+      console.error(chalk2.red(`Failed to create migration: ${err.message}`));
+      process.exit(1);
+    }
+    migrationId = createResult.migrationId;
+    console.log(chalk2.dim(`Migration ID: ${migrationId}`));
+    console.log("");
+    console.log(chalk2.bold("  Price mapping:"));
+    for (const [oldKey, newKey] of Object.entries(createResult.priceMapping)) {
+      console.log(chalk2.dim(`    ${oldKey}  \u2192  ${newKey}`));
+    }
+    console.log("");
+    console.log(chalk2.dim(`  Subscribers to migrate: ${createResult.totalSubscribers}`));
+    if (createResult.pastDueSkipped > 0) {
+      console.log(chalk2.yellow(`  past_due skipped: ${createResult.pastDueSkipped}`));
+    }
+    if (createResult.unmappedSkipped > 0) {
+      console.log(chalk2.yellow(`  Unmapped (no price match): ${createResult.unmappedSkipped}`));
+    }
+    console.log("");
+    if (opts.dryRun) {
+      console.log(chalk2.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(chalk2.red(`Failed to fetch migration: ${err.message}`));
+    process.exit(1);
+  }
+  console.log(chalk2.dim(`Migration: ${migration.fromConfigKey} \u2192 ${migration.toConfigKey}`));
+  console.log(chalk2.dim(`Status: ${migration.status} | Total: ${migration.totalCount} | Migrated: ${migration.migratedCount} | Failed: ${migration.failedCount}`));
+  if (opts.dryRun) {
+    console.log("");
+    console.log(chalk2.dim("  Dry run \u2014 no changes applied. Run without --dry-run to execute."));
+    process.exit(0);
+  }
+  if (migration.status === "completed") {
+    console.log(chalk2.green("Migration already completed."));
+    process.exit(0);
+  }
+  if (migration.status === "running") {
+    console.error(chalk2.yellow("Migration is already running. Check back later."));
+    process.exit(1);
+  }
+  console.log("");
+  console.log(chalk2.cyan("Executing migration..."));
+  try {
+    const result = await client.executeMigration(migrationId, {
+      batchSize: opts.batchSize
+    });
+    console.log(chalk2.green.bold("Migration complete!"));
+    console.log(chalk2.green(`  Migrated: ${result.migrated}`));
+    if (result.skipped > 0) {
+      console.log(chalk2.yellow(`  Skipped: ${result.skipped}`));
+    }
+    if (result.failed > 0) {
+      console.log(chalk2.red(`  Failed: ${result.failed}`));
+    }
+  } catch (err) {
+    console.error(chalk2.red(`Migration failed: ${err.message}`));
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(chalk2.red(err.message));
+  process.exit(1);
+});