@creem_io/cli 0.2.1

package/dist/commands/migrate.js

@@ -0,0 +1,1073 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMigrateCommand = createMigrateCommand;
+const commander_1 = require("commander");
+const ora_1 = __importDefault(require("ora"));
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("@inquirer/prompts");
+const api_1 = require("../lib/api");
+const output = __importStar(require("../utils/output"));
+function isRetryableError(error) {
+    if (error instanceof Error) {
+        const message = error.message.toLowerCase();
+        // Retry on network errors, timeouts, and rate limits only
+        if (message.includes("econnreset") ||
+            message.includes("econnrefused") ||
+            message.includes("etimedout") ||
+            message.includes("socket hang up") ||
+            message.includes("network") ||
+            message.includes("timeout") ||
+            message.includes("fetch failed")) {
+            return true;
+        }
+    }
+    // Retry on 429 (rate limit) and 5xx (transient server errors)
+    if (error && typeof error === "object" && "status" in error) {
+        const status = error.status;
+        if (status === 429 || (status >= 500 && status <= 599))
+            return true;
+    }
+    // Also check error message for HTTP status codes (e.g. LemonSqueezyClient throws
+    // `new Error(...)` with status embedded in the message, not as a property)
+    if (error instanceof Error) {
+        const msg = error.message;
+        if (/\b429\b/.test(msg) || /rate.?limit/i.test(msg))
+            return true;
+        if (/\b5\d{2}\b/.test(msg))
+            return true;
+    }
+    return false;
+}
+async function withRetry(fn, label, maxAttempts = 3, baseDelayMs = 1000) {
+    if (maxAttempts < 1) {
+        throw new Error("maxAttempts must be at least 1");
+    }
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < maxAttempts && isRetryableError(error)) {
+                const delayMs = baseDelayMs * Math.pow(2, attempt - 1);
+                console.error(chalk_1.default.dim(`  ↻ Attempt ${attempt + 1}/${maxAttempts} for ${label} in ${delayMs}ms...`));
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+            else {
+                break;
+            }
+        }
+    }
+    throw lastError;
+}
+// ============================================================================
+// Lemon Squeezy API Client
+// ============================================================================
+class LemonSqueezyClient {
+    apiKey;
+    baseUrl = "https://api.lemonsqueezy.com/v1";
+    storeId;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    setStoreId(storeId) {
+        this.storeId = storeId;
+    }
+    async request(endpoint, page = 1, perPage = 100, filterByStore = false) {
+        return withRetry(async () => {
+            const url = new URL(`${this.baseUrl}${endpoint}`);
+            url.searchParams.set("page[number]", page.toString());
+            url.searchParams.set("page[size]", perPage.toString());
+            // Filter by store_id to only fetch data from the validated store
+            if (filterByStore && this.storeId) {
+                url.searchParams.set("filter[store_id]", this.storeId.toString());
+            }
+            const response = await fetch(url.toString(), {
+                headers: {
+                    Accept: "application/vnd.api+json",
+                    "Content-Type": "application/vnd.api+json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Lemon Squeezy API error (${response.status}): ${errorText}`);
+            }
+            return response.json();
+        }, `${endpoint} (page ${page})`);
+    }
+    async *paginate(endpoint, filterByStore = false) {
+        let page = 1;
+        let hasMore = true;
+        while (hasMore) {
+            const response = await this.request(endpoint, page, 100, filterByStore);
+            yield response.data;
+            // Check for both undefined and null - JSON:API spec allows null for unavailable links
+            hasMore = response.links.next != null;
+            page++;
+            // Rate limit: LS allows 300 requests per minute (5 req/sec)
+            // Using 200ms delay for safety margin
+            if (hasMore) {
+                await new Promise((resolve) => setTimeout(resolve, 200));
+            }
+        }
+    }
+    async fetchAll(endpoint, filterByStore = false) {
+        const items = [];
+        for await (const batch of this.paginate(endpoint, filterByStore)) {
+            items.push(...batch);
+        }
+        return items;
+    }
+    async getProducts() {
+        return this.fetchAll("/products", true);
+    }
+    async getVariants() {
+        // Variants endpoint doesn't support store_id filter - filter client-side via product_id
+        return this.fetchAll("/variants", false);
+    }
+    async getDiscounts() {
+        return this.fetchAll("/discounts", true);
+    }
+    async getCustomers() {
+        return this.fetchAll("/customers", true);
+    }
+    async getFiles() {
+        // Files endpoint doesn't support store_id filter - filtered in buildMigrationPlan via productMap
+        return this.fetchAll("/files", false);
+    }
+    async getStores() {
+        return this.fetchAll("/stores", false);
+    }
+    async validateKey() {
+        try {
+            const stores = await this.getStores();
+            if (stores.length === 0) {
+                return { valid: false, error: "No store found for this API key" };
+            }
+            return { valid: true, stores };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    }
+}
+function mapBillingPeriod(interval, intervalCount) {
+    // Missing interval for subscriptions should be skipped - can happen with deprecated LS variant fields
+    // This function is only called when is_subscription is true, so missing interval is invalid
+    if (!interval) {
+        return {
+            period: undefined,
+            warning: "Subscription variant missing billing interval (possibly deprecated LS field)",
+            skip: true,
+        };
+    }
+    // Map LS intervals to CREEM billing periods
+    if (interval === "month") {
+        // Handle undefined intervalCount as default monthly (same pattern as year branch)
+        if (intervalCount === 1 || intervalCount === undefined)
+            return { period: "every-month" };
+        if (intervalCount === 3)
+            return { period: "every-three-months" };
+        if (intervalCount === 6)
+            return { period: "every-six-months" };
+        // Unsupported month intervals (2, 4, 5, etc.) - skip with warning
+        return {
+            period: undefined,
+            warning: `${intervalCount}-month billing not supported in CREEM`,
+            skip: true,
+        };
+    }
+    if (interval === "year") {
+        if (intervalCount === 1 || intervalCount === undefined) {
+            return { period: "every-year" };
+        }
+        // Multi-year intervals not supported - skip to avoid pricing errors
+        return {
+            period: undefined,
+            warning: `${intervalCount}-year billing not supported in CREEM`,
+            skip: true,
+        };
+    }
+    // Day/week intervals not supported in CREEM - MUST skip to avoid wrong pricing
+    // A $5/week product silently becoming $5/month would be a 4x pricing error
+    return {
+        period: undefined,
+        warning: `${interval} billing interval not supported in CREEM (would cause incorrect pricing)`,
+        skip: true,
+    };
+}
+function mapDiscountType(amountType) {
+    return amountType === "percent" ? "percentage" : "fixed";
+}
+/**
+ * Map a Lemon Squeezy discount to CREEM discount format.
+ * Centralized helper to avoid duplication across skipped and active discount handling.
+ */
+function mapLsDiscountToCreemDiscount(discount, storeCurrency) {
+    const creemDiscount = {
+        name: discount.attributes.name,
+        code: discount.attributes.code,
+        type: mapDiscountType(discount.attributes.amount_type),
+        duration: discount.attributes.duration,
+        durationInMonths: discount.attributes.duration_in_months,
+        maxRedemptions: discount.attributes.is_limited_redemptions
+            ? discount.attributes.max_redemptions
+            : undefined,
+        expiryDate: discount.attributes.expires_at
+            ? new Date(discount.attributes.expires_at)
+            : undefined,
+    };
+    // Set amount/percentage based on discount type
+    if (discount.attributes.amount_type === "percent") {
+        creemDiscount.percentage = discount.attributes.amount;
+    }
+    else {
+        // Fixed amount - LS stores in cents, CREEM also expects cents
+        creemDiscount.amount = discount.attributes.amount;
+        creemDiscount.currency = storeCurrency;
+    }
+    return creemDiscount;
+}
+/**
+ * Get the effective price for a variant.
+ * For PWYW (Pay What You Want) variants, the `price` field is deprecated and may be 0.
+ * Instead, use min_price (minimum acceptable) or suggested_price (recommended) or 0 if none set.
+ */
+function getVariantPrice(variant) {
+    if (variant.attributes.pay_what_you_want) {
+        // For PWYW, prefer min_price (sets a floor), fall back to suggested_price, then 0
+        // Use || instead of ?? because min_price: 0 means "no minimum" in LS (should fall through)
+        return variant.attributes.min_price || variant.attributes.suggested_price || 0;
+    }
+    return variant.attributes.price;
+}
+/**
+ * Check if a variant is eligible for migration.
+ * Must match the same criteria used in the main migration loop.
+ */
+function isVariantMigrateable(variant, product) {
+    if (!product)
+        return false;
+    // Import all products regardless of status (draft, pending, published)
+    // Users may want to migrate their entire catalog including work-in-progress
+    // Skip variants with no price (unless PWYW)
+    if (variant.attributes.price === 0 && !variant.attributes.pay_what_you_want) {
+        return false;
+    }
+    // For recurring variants, check if billing interval is supported
+    if (variant.attributes.is_subscription) {
+        const billingResult = mapBillingPeriod(variant.attributes.interval, variant.attributes.interval_count);
+        if (billingResult.skip) {
+            return false;
+        }
+    }
+    return true;
+}
+function buildMigrationPlan(products, variants, discounts, customers, files, storeCurrency) {
+    const productMap = new Map(products.map((p) => [parseInt(p.id, 10), p]));
+    // Pre-compute migrateable variant counts per product to avoid O(N²) complexity
+    const migrateableVariantCounts = new Map();
+    for (const variant of variants) {
+        const productId = variant.attributes.product_id;
+        const product = productMap.get(productId);
+        if (isVariantMigrateable(variant, product)) {
+            migrateableVariantCounts.set(productId, (migrateableVariantCounts.get(productId) || 0) + 1);
+        }
+    }
+    // Build products from variants
+    // Uses isVariantMigrateable as the single source of truth for eligibility checks
+    const productPlan = [];
+    for (const variant of variants) {
+        const product = productMap.get(variant.attributes.product_id);
+        if (!product)
+            continue;
+        const isRecurring = variant.attributes.is_subscription;
+        const billingResult = isRecurring
+            ? mapBillingPeriod(variant.attributes.interval, variant.attributes.interval_count)
+            : { period: undefined };
+        // Use pre-computed count for naming decision
+        const productId = parseInt(product.id, 10);
+        const migrateableVariantCount = migrateableVariantCounts.get(productId) || 0;
+        const productName = migrateableVariantCount > 1
+            ? `${product.attributes.name} - ${variant.attributes.name}`
+            : product.attributes.name;
+        // Use isVariantMigrateable for all eligibility checks
+        if (!isVariantMigrateable(variant, product)) {
+            // Determine the specific reason for skipping - ALWAYS track and report
+            let skipReason;
+            const hasPrice = variant.attributes.price > 0 || variant.attributes.pay_what_you_want;
+            if (!hasPrice) {
+                skipReason = "Variant has no price set";
+            }
+            else if (billingResult.skip && billingResult.warning) {
+                skipReason = billingResult.warning;
+            }
+            else {
+                skipReason = "Unknown eligibility issue";
+            }
+            productPlan.push({
+                lsProduct: product,
+                lsVariant: variant,
+                creemProduct: {
+                    name: productName,
+                    description: product.attributes.description || "",
+                    price: getVariantPrice(variant),
+                    currency: storeCurrency,
+                    billingType: isRecurring ? "recurring" : "onetime",
+                    billingPeriod: billingResult.period,
+                    taxCategory: "saas",
+                },
+                skipped: true,
+                skipReason,
+            });
+            continue;
+        }
+        productPlan.push({
+            lsProduct: product,
+            lsVariant: variant,
+            creemProduct: {
+                name: productName,
+                description: product.attributes.description || "",
+                price: getVariantPrice(variant), // Use min_price/suggested_price for PWYW variants
+                currency: storeCurrency, // Use store's configured currency (LS supports 150+ currencies)
+                billingType: isRecurring ? "recurring" : "onetime",
+                billingPeriod: billingResult.period,
+                taxCategory: "saas",
+            },
+        });
+    }
+    // Build discounts
+    const discountPlan = [];
+    for (const discount of discounts) {
+        // Skip expired or inactive discounts
+        if (discount.attributes.status !== "published") {
+            discountPlan.push({
+                lsDiscount: discount,
+                creemDiscount: mapLsDiscountToCreemDiscount(discount, storeCurrency),
+                skipped: true,
+                skipReason: `Discount status is "${discount.attributes.status}" (not published)`,
+            });
+            continue;
+        }
+        // Skip product-scoped discounts - LS API doesn't expose which products they apply to
+        // Migrating them would apply to ALL products, potentially causing revenue loss
+        if (discount.attributes.is_limited_to_products) {
+            discountPlan.push({
+                lsDiscount: discount,
+                creemDiscount: mapLsDiscountToCreemDiscount(discount, storeCurrency),
+                skipped: true,
+                skipReason: "Product-scoped discount (requires manual setup in CREEM to avoid applying to wrong products)",
+            });
+            continue;
+        }
+        // Map LS discount to CREEM format using centralized helper
+        const creemDiscount = mapLsDiscountToCreemDiscount(discount, storeCurrency);
+        discountPlan.push({
+            lsDiscount: discount,
+            creemDiscount,
+        });
+    }
+    // Build customers
+    const customerPlan = [];
+    for (const customer of customers) {
+        customerPlan.push({
+            lsCustomer: customer,
+            creemCustomer: {
+                email: customer.attributes.email,
+                name: customer.attributes.name,
+                billingAddress: customer.attributes.city || customer.attributes.country
+                    ? {
+                        city: customer.attributes.city,
+                        country: customer.attributes.country,
+                    }
+                    : undefined,
+            },
+        });
+    }
+    // Build files (for later reference)
+    // Filter to only include files belonging to products in our store (via productMap)
+    const filePlan = [];
+    for (const file of files) {
+        const variant = variants.find((v) => parseInt(v.id, 10) === file.attributes.variant_id);
+        const product = variant ? productMap.get(variant.attributes.product_id) : undefined;
+        // Skip files that don't belong to products in our store
+        if (!product)
+            continue;
+        filePlan.push({
+            lsFile: file,
+            variantId: file.attributes.variant_id.toString(),
+            productName: product.attributes.name,
+        });
+    }
+    const migrateableProducts = productPlan.filter((p) => !p.skipped);
+    const skippedProducts = productPlan.filter((p) => p.skipped);
+    const migrateableDiscounts = discountPlan.filter((d) => !d.skipped);
+    const skippedDiscounts = discountPlan.filter((d) => d.skipped);
+    return {
+        products: productPlan,
+        discounts: discountPlan,
+        customers: customerPlan,
+        files: filePlan,
+        summary: {
+            totalProducts: migrateableProducts.length,
+            totalDiscounts: migrateableDiscounts.length,
+            totalCustomers: customerPlan.length,
+            totalFiles: filePlan.length,
+            skippedProducts: skippedProducts.length,
+            skippedDiscounts: skippedDiscounts.length,
+        },
+    };
+}
+// ============================================================================
+// Migration Execution
+// ============================================================================
+async function executeMigration(plan, options) {
+    const result = {
+        success: true,
+        created: { products: [], discounts: [], customers: [], files: [] },
+        failed: { products: [], discounts: [], customers: [], files: [] },
+        skipped: { products: [], discounts: [], customers: [] },
+    };
+    if (options.dryRun) {
+        console.log();
+        console.log(chalk_1.default.yellow("DRY RUN MODE - No changes will be made"));
+        console.log();
+        return result;
+    }
+    const client = (0, api_1.getClient)();
+    // Migrate Products (skip products with unsupported billing intervals)
+    const migrateableProducts = plan.products.filter((p) => !p.skipped);
+    const skippedProducts = plan.products.filter((p) => p.skipped);
+    console.log();
+    console.log(chalk_1.default.bold("Migrating Products..."));
+    // Record skipped products first
+    for (const skipped of skippedProducts) {
+        result.skipped.products.push({
+            name: skipped.creemProduct.name,
+            reason: skipped.skipReason || "Unsupported billing interval",
+        });
+    }
+    for (let i = 0; i < migrateableProducts.length; i++) {
+        const item = migrateableProducts[i];
+        const progress = `[${i + 1}/${migrateableProducts.length}]`;
+        const spinner = (0, ora_1.default)(`${progress} Creating: ${item.creemProduct.name}`).start();
+        try {
+            const params = {
+                name: item.creemProduct.name,
+                // CREEM API requires description to be a non-empty string
+                // Use product name as fallback if no description is provided
+                description: item.creemProduct.description || item.creemProduct.name,
+                price: item.creemProduct.price,
+                currency: item.creemProduct.currency,
+                billingType: item.creemProduct.billingType,
+                taxCategory: item.creemProduct.taxCategory,
+            };
+            if (item.creemProduct.billingPeriod) {
+                params.billingPeriod = item.creemProduct.billingPeriod;
+            }
+            // NOTE: Retrying a POST create is not idempotent — a transient failure after the server
+            // processes the request could lead to a duplicate product. This is an acceptable tradeoff:
+            // duplicates can be cleaned up manually, whereas failing the entire migration is worse.
+            const created = (await withRetry(() => client.products.create(params), `product "${item.creemProduct.name}"`));
+            result.created.products.push(created.id);
+            spinner.succeed(`${progress} Created: ${item.creemProduct.name}`);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : "Unknown error";
+            result.failed.products.push({
+                name: item.creemProduct.name,
+                error: errorMsg,
+            });
+            spinner.fail(`${progress} Failed: ${item.creemProduct.name} - ${errorMsg}`);
+            result.success = false;
+        }
+        // Small delay to avoid rate limiting
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    // Migrate Discounts (after products so we can apply to all created products)
+    const migrateableDiscounts = plan.discounts.filter((d) => !d.skipped);
+    const skippedDiscounts = plan.discounts.filter((d) => d.skipped);
+    if (plan.discounts.length > 0) {
+        console.log();
+        console.log(chalk_1.default.bold("Migrating Discounts..."));
+        // Record skipped discounts first
+        for (const skipped of skippedDiscounts) {
+            result.skipped.discounts.push({
+                code: skipped.creemDiscount.code,
+                reason: skipped.skipReason || "Discount not active",
+            });
+        }
+        // Skip discount creation if no products were successfully created
+        // CREEM API requires at least one product for discounts to apply to
+        if (result.created.products.length === 0 && migrateableDiscounts.length > 0) {
+            console.log(chalk_1.default.yellow(`  ⚠ Skipping ${migrateableDiscounts.length} discount(s): No products were created to apply them to`));
+            for (const item of migrateableDiscounts) {
+                result.skipped.discounts.push({
+                    code: item.creemDiscount.code,
+                    reason: "No products available to apply discount to",
+                });
+            }
+        }
+        // Create discounts - apply to all created products
+        for (let i = 0; i < (result.created.products.length > 0 ? migrateableDiscounts.length : 0); i++) {
+            const item = migrateableDiscounts[i];
+            const progress = `[${i + 1}/${migrateableDiscounts.length}]`;
+            const spinner = (0, ora_1.default)(`${progress} Creating: ${item.creemDiscount.code}`).start();
+            try {
+                // Build discount creation params
+                const params = {
+                    name: item.creemDiscount.name,
+                    code: item.creemDiscount.code,
+                    type: item.creemDiscount.type,
+                    duration: item.creemDiscount.duration,
+                    // Apply to all created products from this migration
+                    appliesToProducts: result.created.products,
+                };
+                // Set amount/percentage based on type
+                if (item.creemDiscount.type === "percentage" &&
+                    item.creemDiscount.percentage !== undefined) {
+                    params.percentage = item.creemDiscount.percentage;
+                }
+                else if (item.creemDiscount.type === "fixed" && item.creemDiscount.amount !== undefined) {
+                    params.amount = item.creemDiscount.amount;
+                    params.currency = item.creemDiscount.currency;
+                }
+                // Optional fields
+                if (item.creemDiscount.expiryDate) {
+                    params.expiryDate = item.creemDiscount.expiryDate;
+                }
+                if (item.creemDiscount.maxRedemptions !== undefined) {
+                    params.maxRedemptions = item.creemDiscount.maxRedemptions;
+                }
+                if (item.creemDiscount.duration === "repeating" &&
+                    item.creemDiscount.durationInMonths !== undefined) {
+                    params.durationInMonths = item.creemDiscount.durationInMonths;
+                }
+                // NOTE: Retrying a POST create is not idempotent — see product create comment above.
+                // Discount codes are unique, so duplicates will fail with a conflict error rather than
+                // silently creating duplicates.
+                const created = (await withRetry(() => client.discounts.create(params), `discount "${item.creemDiscount.code}"`));
+                result.created.discounts.push(created.id);
+                spinner.succeed(`${progress} Created: ${item.creemDiscount.code}`);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : "Unknown error";
+                result.failed.discounts.push({
+                    code: item.creemDiscount.code,
+                    error: errorMsg,
+                });
+                spinner.fail(`${progress} Failed: ${item.creemDiscount.code} - ${errorMsg}`);
+                result.success = false;
+            }
+            // Small delay to avoid rate limiting
+            await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+    }
+    // Note: Customer and File migration require additional CREEM API endpoints
+    // that are not yet available in the SDK. Logging for manual follow-up.
+    if (plan.customers.length > 0) {
+        console.log();
+        console.log(chalk_1.default.yellow(`⚠ ${plan.customers.length} customers found - will be created automatically on first purchase`));
+        console.log(chalk_1.default.dim("  Customers are auto-created in CREEM when they make their first purchase"));
+    }
+    if (plan.files.length > 0) {
+        console.log();
+        console.log(chalk_1.default.yellow(`⚠ ${plan.files.length} files found - manual upload required`));
+        console.log(chalk_1.default.dim("  Upload downloadable files in the CREEM dashboard"));
+    }
+    return result;
+}
+// ============================================================================
+// CLI Commands
+// ============================================================================
+function createLemonSqueezyCommand() {
+    const command = new commander_1.Command("lemon-squeezy")
+        .description("Migrate from Lemon Squeezy to CREEM")
+        .option("--ls-api-key <key>", "Lemon Squeezy API key")
+        .option("--ls-store-id <id>", "Lemon Squeezy store ID to migrate from")
+        .option("--dry-run", "Preview migration without making changes")
+        // Note: --log-file is not yet implemented - will be added in future version
+        .option("--json", "Output migration plan as JSON (implies --dry-run)")
+        .option("--exclude-discounts", "Skip migrating discounts entirely")
+        .action(async (options) => {
+        // Skip banner when outputting JSON to avoid corrupting stdout
+        if (!options.json) {
+            console.log();
+            console.log(chalk_1.default.bold.cyan("🍋 Lemon Squeezy → CREEM Migration"));
+            console.log(chalk_1.default.dim("Migrate your products, customers, and discounts"));
+            console.log();
+        }
+        // Verify CREEM authentication
+        try {
+            (0, api_1.getClient)();
+        }
+        catch {
+            output.error("Not authenticated with CREEM. Run `creem login` first.");
+            process.exit(1);
+        }
+        // Get Lemon Squeezy API key
+        let lsApiKey = options.lsApiKey;
+        if (!lsApiKey) {
+            try {
+                lsApiKey = await (0, prompts_1.password)({
+                    message: "Enter your Lemon Squeezy API key:",
+                    validate: (value) => (value.length > 0 ? true : "API key is required"),
+                });
+            }
+            catch {
+                console.log(chalk_1.default.dim("\nMigration cancelled."));
+                return;
+            }
+            if (!lsApiKey) {
+                console.log(chalk_1.default.dim("\nMigration cancelled."));
+                return;
+            }
+        }
+        // Validate Lemon Squeezy API key
+        const lsClient = new LemonSqueezyClient(lsApiKey);
+        const validateSpinner = (0, ora_1.default)("Validating Lemon Squeezy API key...").start();
+        const validation = await lsClient.validateKey();
+        if (!validation.valid) {
+            validateSpinner.fail("Invalid Lemon Squeezy API key");
+            output.error(validation.error || "Could not validate API key");
+            process.exit(1);
+        }
+        const stores = validation.stores || [];
+        validateSpinner.succeed(`Connected to Lemon Squeezy (${stores.length} store${stores.length === 1 ? "" : "s"} found)`);
+        let selectedStore;
+        if (options.lsStoreId) {
+            if (!/^\d+$/.test(options.lsStoreId)) {
+                output.error(`Invalid Lemon Squeezy store ID: ${options.lsStoreId}`);
+                process.exit(1);
+            }
+            const requestedStoreId = parseInt(options.lsStoreId, 10);
+            if (!Number.isInteger(requestedStoreId) || requestedStoreId <= 0) {
+                output.error(`Invalid Lemon Squeezy store ID: ${options.lsStoreId}`);
+                process.exit(1);
+            }
+            selectedStore = stores.find((store) => parseInt(store.id, 10) === requestedStoreId);
+            if (!selectedStore) {
+                output.error(`Lemon Squeezy store ID ${options.lsStoreId} was not found for this API key.`);
+                if (stores.length > 0) {
+                    output.dim(`Available store IDs: ${stores.map((store) => store.id).join(", ")}`);
+                }
+                process.exit(1);
+            }
+        }
+        else if (stores.length === 1) {
+            selectedStore = stores[0];
+        }
+        else {
+            try {
+                selectedStore = await (0, prompts_1.select)({
+                    message: "Which Lemon Squeezy store do you want to migrate?",
+                    choices: stores.map((store) => {
+                        const parts = [
+                            store.attributes.name,
+                            store.attributes.domain || store.attributes.slug,
+                            `ID: ${store.id}`,
+                            store.attributes.currency,
+                        ].filter(Boolean);
+                        return {
+                            name: parts.join(" · "),
+                            value: store,
+                        };
+                    }),
+                });
+            }
+            catch {
+                console.log(chalk_1.default.dim("\nMigration cancelled."));
+                return;
+            }
+        }
+        if (!selectedStore) {
+            output.error("No Lemon Squeezy store selected. Cannot proceed with migration.");
+            process.exit(1);
+        }
+        const selectedStoreId = parseInt(selectedStore.id, 10);
+        if (!Number.isInteger(selectedStoreId) || selectedStoreId <= 0) {
+            output.error(`Invalid Lemon Squeezy store ID: ${selectedStore.id}`);
+            process.exit(1);
+        }
+        const selectedStoreCurrency = selectedStore.attributes?.currency;
+        if (!selectedStoreCurrency) {
+            output.error("Store currency not found. Cannot proceed with migration.");
+            process.exit(1);
+        }
+        if (!options.json) {
+            console.log(chalk_1.default.dim(`Using Lemon Squeezy store: ${selectedStore.attributes.name} (ID: ${selectedStore.id})`));
+        }
+        // Set store ID for filtering subsequent API requests
+        lsClient.setStoreId(selectedStoreId);
+        // Validate store currency - CREEM only supports USD and EUR
+        const rawCurrency = selectedStoreCurrency.toUpperCase();
+        if (rawCurrency !== "USD" && rawCurrency !== "EUR") {
+            output.error(`Your Lemon Squeezy store uses ${rawCurrency}, but CREEM currently only supports USD and EUR.\n` +
+                `To migrate, please either:\n` +
+                `  1. Change your Lemon Squeezy store currency to USD or EUR before migration\n` +
+                `  2. Contact CREEM support for assistance with currency conversion\n` +
+                `\nNote: Migrating with incorrect currency would result in wrong pricing in CREEM.`);
+            process.exit(1);
+        }
+        const storeCurrency = rawCurrency;
+        // Fetch data from Lemon Squeezy
+        const fetchSpinner = (0, ora_1.default)("Fetching data from Lemon Squeezy...").start();
+        let products = [];
+        let variants = [];
+        let discounts = [];
+        let customers = [];
+        let files = [];
+        const fetchFailures = [];
+        fetchSpinner.text = "Fetching products...";
+        try {
+            products = await lsClient.getProducts();
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : "Unknown error";
+            fetchFailures.push({
+                type: "product",
+                label: "all products",
+                error: msg,
+            });
+            fetchSpinner.text = "Products fetch failed, continuing...";
+        }
+        fetchSpinner.text = "Fetching variants...";
+        try {
+            variants = await lsClient.getVariants();
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : "Unknown error";
+            fetchFailures.push({
+                type: "variant",
+                label: "all variants",
+                error: msg,
+            });
+            fetchSpinner.text = "Variants fetch failed, continuing...";
+        }
+        if (options.excludeDiscounts) {
+            discounts = [];
+        }
+        else {
+            fetchSpinner.text = "Fetching discounts...";
+            try {
+                discounts = await lsClient.getDiscounts();
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : "Unknown error";
+                fetchFailures.push({
+                    type: "discount",
+                    label: "all discounts",
+                    error: msg,
+                });
+                fetchSpinner.text = "Discounts fetch failed, continuing...";
+            }
+        }
+        fetchSpinner.text = "Fetching customers...";
+        try {
+            customers = await lsClient.getCustomers();
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : "Unknown error";
+            fetchFailures.push({
+                type: "customer",
+                label: "all customers",
+                error: msg,
+            });
+            fetchSpinner.text = "Customers fetch failed, continuing...";
+        }
+        fetchSpinner.text = "Fetching files...";
+        try {
+            files = await lsClient.getFiles();
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : "Unknown error";
+            fetchFailures.push({ type: "file", label: "all files", error: msg });
+            fetchSpinner.text = "Files fetch failed, continuing...";
+        }
+        {
+            const discountsLabel = options.excludeDiscounts
+                ? "discounts excluded"
+                : `${discounts.length} discounts`;
+            const failLabel = fetchFailures.length > 0
+                ? chalk_1.default.yellow(` (${fetchFailures.length} fetch failures)`)
+                : "";
+            fetchSpinner.succeed(`Fetched: ${products.length} products, ${variants.length} variants, ${discountsLabel}, ${customers.length} customers, ${files.length} files${failLabel}`);
+        }
+        if (fetchFailures.length > 0 && !options.json) {
+            console.error();
+            console.error(chalk_1.default.yellow("⚠ Some data could not be fetched after retries:"));
+            for (const f of fetchFailures) {
+                console.error(`  • ${f.type}: ${f.label} - ${f.error}`);
+            }
+            console.error(chalk_1.default.dim("  Migration will continue with the data that was successfully fetched."));
+        }
+        // Build migration plan (storeCurrency already validated as USD or EUR above)
+        const planSpinner = (0, ora_1.default)("Building migration plan...").start();
+        const plan = buildMigrationPlan(products, variants, discounts, customers, files, storeCurrency);
+        planSpinner.succeed("Migration plan ready");
+        // If JSON output requested, print and exit
+        if (options.json) {
+            const jsonOutput = fetchFailures.length > 0 ? { ...plan, fetchFailures } : plan;
+            output.outputJson(jsonOutput);
+            return;
+        }
+        // Display migration summary
+        console.log();
+        console.log(chalk_1.default.bold("Migration Summary"));
+        console.log(chalk_1.default.dim("─".repeat(50)));
+        console.log(`  Products:  ${chalk_1.default.cyan(plan.summary.totalProducts)} CREEM products from ${variants.length} LS variants`);
+        if (plan.summary.skippedProducts > 0) {
+            console.log(`  Skipped:   ${chalk_1.default.yellow(plan.summary.skippedProducts)} variants (see details below)`);
+        }
+        if (options.excludeDiscounts) {
+            console.log(`  Discounts: ${chalk_1.default.yellow("excluded")} (--exclude-discounts)`);
+        }
+        else {
+            console.log(`  Discounts: ${chalk_1.default.cyan(plan.summary.totalDiscounts)}${plan.summary.skippedDiscounts > 0 ? chalk_1.default.yellow(` (${plan.summary.skippedDiscounts} skipped)`) : ""}`);
+        }
+        console.log(`  Customers: ${chalk_1.default.cyan(plan.summary.totalCustomers)}`);
+        console.log(`  Files:     ${chalk_1.default.cyan(plan.summary.totalFiles)} (manual upload required)`);
+        console.log(chalk_1.default.dim("─".repeat(50)));
+        if (plan.summary.totalProducts === 0 && plan.summary.totalCustomers === 0) {
+            console.log();
+            if (plan.summary.skippedProducts > 0) {
+                // All products were skipped - show why
+                console.log(chalk_1.default.yellow(`No products can be migrated. ${plan.summary.skippedProducts} variant(s) were skipped:`));
+                console.log();
+                const skippedProductsList = plan.products.filter((p) => p.skipped);
+                // Group by skip reason for cleaner output
+                const reasonCounts = new Map();
+                for (const p of skippedProductsList) {
+                    const reason = p.skipReason || "Unknown reason";
+                    reasonCounts.set(reason, (reasonCounts.get(reason) || 0) + 1);
+                }
+                console.log(chalk_1.default.dim("Skip reasons:"));
+                for (const [reason, count] of reasonCounts) {
+                    console.log(`  • ${chalk_1.default.yellow(count)} variant(s): ${reason}`);
+                }
+                console.log();
+                console.log(chalk_1.default.dim("Products may be skipped due to unsupported billing intervals or pricing."));
+                console.log(chalk_1.default.dim("CREEM supports one-time, monthly, and yearly billing cycles."));
+            }
+            else {
+                console.log(chalk_1.default.yellow("Nothing to migrate. Your Lemon Squeezy account appears empty."));
+            }
+            return;
+        }
+        // Show sample products (only migrateable ones)
+        const migrateableProducts = plan.products.filter((p) => !p.skipped);
+        const skippedProductsList = plan.products.filter((p) => p.skipped);
+        if (migrateableProducts.length > 0) {
+            console.log();
+            console.log(chalk_1.default.dim("Sample products to be created:"));
+            const sample = migrateableProducts.slice(0, 5);
+            for (const p of sample) {
+                const price = output.formatCurrency(p.creemProduct.price, p.creemProduct.currency);
+                const billing = p.creemProduct.billingType === "recurring"
+                    ? `Recurring / ${p.creemProduct.billingPeriod?.replace("every-", "")}`
+                    : "One-time";
+                console.log(`  • ${p.creemProduct.name} - ${price} (${billing})`);
+            }
+            if (migrateableProducts.length > 5) {
+                console.log(chalk_1.default.dim(`  ... and ${migrateableProducts.length - 5} more`));
+            }
+        }
+        // Show skipped products with reasons
+        if (skippedProductsList.length > 0) {
+            console.log();
+            console.log(chalk_1.default.yellow(`⚠ ${skippedProductsList.length} variant(s) cannot be migrated:`));
+            // Group by skip reason for cleaner output
+            const reasonCounts = new Map();
+            for (const p of skippedProductsList) {
+                const reason = p.skipReason || "Unknown reason";
+                if (!reasonCounts.has(reason)) {
+                    reasonCounts.set(reason, []);
+                }
+                reasonCounts.get(reason).push(p.creemProduct.name);
+            }
+            for (const [reason, names] of reasonCounts) {
+                console.log(`  • ${reason}: ${chalk_1.default.dim(`${names.length} variant(s)`)}`);
+                // Show first 2 names as examples
+                for (const name of names.slice(0, 2)) {
+                    console.log(chalk_1.default.dim(`      - ${name}`));
+                }
+                if (names.length > 2) {
+                    console.log(chalk_1.default.dim(`      ... and ${names.length - 2} more`));
+                }
+            }
+        }
+        // Show skipped discounts with reasons
+        const skippedDiscountsList = plan.discounts.filter((d) => d.skipped);
+        if (skippedDiscountsList.length > 0) {
+            console.log();
+            console.log(chalk_1.default.yellow(`⚠ ${skippedDiscountsList.length} discount(s) require manual setup:`));
+            // Group by skip reason for cleaner output
+            const discountReasonCounts = new Map();
+            for (const d of skippedDiscountsList) {
+                const reason = d.skipReason || "Unknown reason";
+                if (!discountReasonCounts.has(reason)) {
+                    discountReasonCounts.set(reason, []);
+                }
+                discountReasonCounts.get(reason).push(d.creemDiscount.code);
+            }
+            for (const [reason, codes] of discountReasonCounts) {
+                console.log(`  • ${reason}: ${chalk_1.default.dim(`${codes.length} discount(s)`)}`);
+                // Show first 3 codes as examples
+                for (const code of codes.slice(0, 3)) {
+                    console.log(chalk_1.default.dim(`      - ${code}`));
+                }
+                if (codes.length > 3) {
+                    console.log(chalk_1.default.dim(`      ... and ${codes.length - 3} more`));
+                }
+            }
+        }
+        // Dry run mode
+        if (options.dryRun) {
+            console.log();
+            console.log(chalk_1.default.yellow.bold("DRY RUN MODE"));
+            console.log(chalk_1.default.dim("No changes were made. Remove --dry-run to execute migration."));
+            return;
+        }
+        // Confirmation prompt
+        console.log();
+        let proceed;
+        try {
+            proceed = await (0, prompts_1.confirm)({
+                message: "Proceed with migration?",
+                default: false,
+            });
+        }
+        catch {
+            console.log(chalk_1.default.dim("\nMigration cancelled."));
+            return;
+        }
+        if (!proceed) {
+            console.log(chalk_1.default.dim("\nMigration cancelled."));
+            return;
+        }
+        // Execute migration
+        console.log();
+        console.log(chalk_1.default.bold.green("Starting migration..."));
+        const result = await executeMigration(plan, {
+            dryRun: false,
+        });
+        // Display results
+        console.log();
+        console.log(chalk_1.default.bold("Migration Complete"));
+        console.log(chalk_1.default.dim("─".repeat(50)));
+        console.log(`  Products created:  ${chalk_1.default.green(result.created.products.length)}`);
+        console.log(`  Discounts created: ${chalk_1.default.green(result.created.discounts.length)}`);
+        if (result.failed.products.length > 0 || result.failed.discounts.length > 0) {
+            console.log();
+            console.log(chalk_1.default.red("Failed items:"));
+            for (const f of result.failed.products) {
+                console.log(`  • Product: ${f.name} - ${f.error}`);
+            }
+            for (const f of result.failed.discounts) {
+                console.log(`  • Discount: ${f.code} - ${f.error}`);
+            }
+        }
+        if (result.skipped.discounts.length > 0) {
+            console.log();
+            console.log(chalk_1.default.yellow("Skipped discounts:"));
+            for (const s of result.skipped.discounts.slice(0, 5)) {
+                console.log(`  • ${s.code}: ${s.reason}`);
+            }
+            if (result.skipped.discounts.length > 5) {
+                console.log(chalk_1.default.dim(`  ... and ${result.skipped.discounts.length - 5} more`));
+            }
+        }
+        console.log(chalk_1.default.dim("─".repeat(50)));
+        if (fetchFailures.length > 0) {
+            console.error();
+            console.error(chalk_1.default.red("Failed to fetch (after retries):"));
+            for (const f of fetchFailures) {
+                console.error(`  • ${f.type}: ${f.label} - ${f.error}`);
+            }
+        }
+        if (result.success && fetchFailures.length === 0) {
+            console.log();
+            console.log(chalk_1.default.green.bold("✓ Migration completed successfully!"));
+        }
+        else {
+            console.log();
+            console.log(chalk_1.default.yellow.bold("⚠ Migration completed with some errors."));
+            if (fetchFailures.length > 0) {
+                console.log(chalk_1.default.dim("  Re-run the migration to retry failed fetches."));
+            }
+        }
+        console.log();
+        console.log(chalk_1.default.dim("Next steps:"));
+        console.log(chalk_1.default.dim("  1. Review your products at https://creem.io/dashboard/products"));
+        console.log(chalk_1.default.dim("  2. Review your discounts at https://creem.io/dashboard/discounts"));
+        console.log(chalk_1.default.dim("  3. Upload downloadable files in the dashboard if needed"));
+        console.log(chalk_1.default.dim("  4. Update your checkout links to use CREEM"));
+    });
+    return command;
+}
+function createMigrateCommand() {
+    const command = new commander_1.Command("migrate")
+        .description("Migrate from other platforms to CREEM")
+        .addHelpText("after", `
+${chalk_1.default.dim("Available migrations:")}
+  ${chalk_1.default.cyan("creem migrate lemon-squeezy")}    Migrate from Lemon Squeezy
+
+${chalk_1.default.dim("Options:")}
+  --dry-run               Preview what would be migrated without making changes
+  --ls-api-key <key>      Provide API key via flag (skips interactive prompt)
+  --ls-store-id <id>      Lemon Squeezy store ID to migrate from
+  --json                  Output migration plan as JSON
+  --exclude-discounts     Skip migrating discounts entirely
+
+${chalk_1.default.dim("Examples:")}
+  ${chalk_1.default.cyan("creem migrate lemon-squeezy")}                    Interactive migration wizard
+  ${chalk_1.default.cyan("creem migrate lemon-squeezy --dry-run")}          Preview migration plan
+  ${chalk_1.default.cyan("creem migrate lemon-squeezy --ls-store-id 123")}  Skip store selection prompt
+  ${chalk_1.default.cyan("creem migrate lemon-squeezy --ls-api-key ls_xxx --ls-store-id 123")}  Non-interactive migration
+  ${chalk_1.default.cyan("creem migrate lemon-squeezy --json > plan.json")} Export migration plan
+`);
+    command.addCommand(createLemonSqueezyCommand());
+    return command;
+}
+//# sourceMappingURL=migrate.js.map