kaven-cli 0.1.0-alpha.1 → 0.3.5

package/dist/commands/module/publish.js

@@ -0,0 +1,291 @@
+"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.moduleJsonSchema = void 0;
+exports.modulePublish = modulePublish;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const crypto_1 = __importDefault(require("crypto"));
+const os_1 = __importDefault(require("os"));
+const zod_1 = require("zod");
+const AuthService_1 = require("../../core/AuthService");
+const MarketplaceClient_1 = require("../../infrastructure/MarketplaceClient");
+// Zod schema for module.json
+exports.moduleJsonSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    slug: zod_1.z.string().min(1).regex(/^[a-z0-9-]+$/),
+    version: zod_1.z.string().regex(/^\d+\.\d+\.\d+$/),
+    description: zod_1.z.string().min(1),
+    author: zod_1.z.string().optional(),
+    license: zod_1.z.string().optional(),
+    tier: zod_1.z.enum(["free", "starter", "complete", "pro"]),
+});
+const SIGNING_KEY_PATH = path_1.default.join(os_1.default.homedir(), ".kaven", "signing-key.json");
+/** Load or generate Ed25519 signing key pair. */
+async function getSigningKey() {
+    if (await fs_extra_1.default.pathExists(SIGNING_KEY_PATH)) {
+        try {
+            const stored = await fs_extra_1.default.readJson(SIGNING_KEY_PATH);
+            const privateKey = crypto_1.default.createPrivateKey({
+                key: Buffer.from(stored.privateKey, "base64"),
+                type: "pkcs8",
+                format: "der",
+            });
+            const publicKey = crypto_1.default.createPublicKey(privateKey);
+            return { privateKey, publicKey };
+        }
+        catch {
+            // Fall through to generate new key
+        }
+    }
+    const { privateKey, publicKey } = crypto_1.default.generateKeyPairSync("ed25519");
+    const privateKeyDer = privateKey.export({ type: "pkcs8", format: "der" });
+    const publicKeyDer = publicKey.export({ type: "spki", format: "der" });
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(SIGNING_KEY_PATH));
+    await fs_extra_1.default.writeJson(SIGNING_KEY_PATH, {
+        privateKey: privateKeyDer.toString("base64"),
+        publicKey: publicKeyDer.toString("base64"),
+    }, { spaces: 2 });
+    if (process.platform !== "win32") {
+        await fs_extra_1.default.chmod(SIGNING_KEY_PATH, 0o600);
+    }
+    return { privateKey, publicKey };
+}
+/** Generate SHA-256 checksum of a file. */
+async function sha256File(filePath) {
+    const data = await fs_extra_1.default.readFile(filePath);
+    return crypto_1.default.createHash("sha256").update(data).digest("hex");
+}
+/** Create tar.gz archive of current directory, excluding common noise. */
+async function createTarball(sourceDir, outputPath) {
+    const tar = await Promise.resolve().then(() => __importStar(require("tar")));
+    await tar.create({
+        gzip: true,
+        file: outputPath,
+        cwd: sourceDir,
+        filter: (filePath) => {
+            const normalized = filePath.replace(/\\/g, "/");
+            const excluded = [
+                "node_modules",
+                ".git",
+                "dist",
+                ".env",
+            ];
+            for (const exc of excluded) {
+                if (normalized.startsWith(exc + "/") ||
+                    normalized === exc ||
+                    normalized.endsWith(".log")) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    }, ["."]);
+}
+async function modulePublish(options) {
+    const cwd = process.cwd();
+    // 1. Read and validate module.json
+    const moduleJsonPath = path_1.default.join(cwd, "module.json");
+    if (!(await fs_extra_1.default.pathExists(moduleJsonPath))) {
+        console.error(chalk_1.default.red("Error: module.json not found in current directory."));
+        console.error(chalk_1.default.gray("Try: run this command from inside a module directory"));
+        process.exit(1);
+    }
+    let moduleJson;
+    try {
+        const raw = await fs_extra_1.default.readJson(moduleJsonPath);
+        const result = exports.moduleJsonSchema.safeParse(raw);
+        if (!result.success) {
+            console.error(chalk_1.default.red("Error: Invalid module.json:"));
+            for (const issue of result.error.issues) {
+                console.error(chalk_1.default.red(`  - ${issue.path.join(".")}: ${issue.message}`));
+            }
+            process.exit(1);
+        }
+        moduleJson = result.data;
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: Failed to parse module.json: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+    console.log();
+    console.log(chalk_1.default.bold(`Publishing module: ${moduleJson.name} v${moduleJson.version}`));
+    console.log(chalk_1.default.gray(`Slug: ${moduleJson.slug} | Tier: ${moduleJson.tier}`));
+    console.log();
+    // 2. Create tar.gz
+    const tarballPath = path_1.default.join(os_1.default.tmpdir(), `kaven-${moduleJson.slug}-${moduleJson.version}.tar.gz`);
+    const packageSpinner = (0, ora_1.default)("Creating module package...").start();
+    try {
+        await createTarball(cwd, tarballPath);
+        const stats = await fs_extra_1.default.stat(tarballPath);
+        packageSpinner.succeed(`Package created (${(stats.size / 1024).toFixed(1)} KB)`);
+    }
+    catch (error) {
+        packageSpinner.fail("Failed to create package");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+    }
+    // 3. Generate checksum
+    const checksumSpinner = (0, ora_1.default)("Computing SHA-256 checksum...").start();
+    let checksum;
+    try {
+        checksum = await sha256File(tarballPath);
+        checksumSpinner.succeed(`Checksum: ${checksum.substring(0, 16)}...`);
+    }
+    catch {
+        checksumSpinner.fail("Failed to compute checksum");
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    // 4. Sign the checksum
+    const signSpinner = (0, ora_1.default)("Signing package...").start();
+    let signatureBase64;
+    let publicKeyBase64;
+    try {
+        const { privateKey, publicKey } = await getSigningKey();
+        const signature = crypto_1.default.sign(null, Buffer.from(checksum), privateKey);
+        signatureBase64 = signature.toString("base64");
+        const publicKeyDer = publicKey.export({
+            type: "spki", format: "der",
+        });
+        publicKeyBase64 = publicKeyDer.toString("base64");
+        signSpinner.succeed(`Package signed (${signatureBase64.substring(0, 16)}...)`);
+    }
+    catch {
+        signSpinner.fail("Failed to sign package");
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    if (options.dryRun) {
+        console.log();
+        console.log(chalk_1.default.yellow("Dry-run mode: skipping upload and release creation."));
+        console.log(chalk_1.default.green("✅ Package validated successfully."));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        return;
+    }
+    // 5. Get presigned upload URL
+    const authService = new AuthService_1.AuthService();
+    try {
+        await authService.getValidToken();
+    }
+    catch {
+        console.error(chalk_1.default.red("Error: Not authenticated. Run 'kaven auth login' first."));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    const client = new MarketplaceClient_1.MarketplaceClient(authService);
+    const stats = await fs_extra_1.default.stat(tarballPath);
+    const urlSpinner = (0, ora_1.default)("Getting upload URL...").start();
+    let uploadUrl;
+    let s3Key;
+    try {
+        const uploadUrlResult = await client.getUploadUrl(moduleJson.slug, moduleJson.version, stats.size);
+        uploadUrl = uploadUrlResult.uploadUrl;
+        s3Key = uploadUrlResult.s3Key;
+        urlSpinner.succeed("Upload URL received");
+    }
+    catch (error) {
+        urlSpinner.fail("Failed to get upload URL");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    // 6. Upload tar.gz to presigned URL
+    const uploadSpinner = (0, ora_1.default)(`Uploading package (${(stats.size / 1024).toFixed(1)} KB)...`).start();
+    try {
+        const fileBuffer = await fs_extra_1.default.readFile(tarballPath);
+        const response = await fetch(uploadUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/gzip",
+                "Content-Length": String(stats.size),
+            },
+            body: fileBuffer,
+        });
+        if (!response.ok) {
+            throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
+        }
+        uploadSpinner.succeed("Package uploaded successfully");
+    }
+    catch (error) {
+        uploadSpinner.fail("Upload failed");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    // 7. Create release record
+    const releaseSpinner = (0, ora_1.default)("Creating release record...").start();
+    try {
+        const release = await client.createRelease({
+            moduleSlug: moduleJson.slug,
+            version: moduleJson.version,
+            s3Key,
+            checksum,
+            signature: signatureBase64,
+            publicKey: publicKeyBase64,
+            changelog: options.changelog,
+        });
+        releaseSpinner.succeed(`Release created: ${moduleJson.slug}@${release.version} (ID: ${release.id})`);
+    }
+    catch (error) {
+        releaseSpinner.fail("Failed to create release");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        await fs_extra_1.default.remove(tarballPath).catch(() => { });
+        process.exit(1);
+        return;
+    }
+    // Cleanup temp file
+    await fs_extra_1.default.remove(tarballPath).catch(() => { });
+    console.log();
+    console.log(chalk_1.default.green(`✅ Published ${moduleJson.name} v${moduleJson.version} to the Kaven Marketplace!`));
+    console.log(chalk_1.default.gray(`View your module at: https://marketplace.kaven.sh/modules/${moduleJson.slug}`));
+    // Show next steps
+    console.log();
+    console.log(chalk_1.default.bold("Next steps:"));
+    console.log(chalk_1.default.gray("  1. Share your module with the community"));
+    console.log(chalk_1.default.gray("  2. Monitor installation metrics"));
+    console.log(chalk_1.default.gray("  3. Update module with 'kaven module publish' when ready"));
+}

package/dist/commands/upgrade/check.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upgradeCheck = upgradeCheck;
+exports.upgradeInstall = upgradeInstall;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const packageJsonPath = path_1.default.join(__dirname, "../../..", "package.json");
+const PACKAGE_JSON = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf8"));
+const CURRENT_VERSION = PACKAGE_JSON.version;
+const CLI_NAME = "kaven-cli";
+/**
+ * C2.3: Check for CLI updates
+ */
+async function upgradeCheck() {
+    const spinner = (0, ora_1.default)("Checking for updates...").start();
+    try {
+        // Fetch latest version from npm registry
+        const response = await fetch(`https://registry.npmjs.org/${CLI_NAME}`);
+        if (!response.ok) {
+            spinner.fail("Could not check for updates");
+            return;
+        }
+        const data = (await response.json());
+        const distTags = data["dist-tags"];
+        const latestVersion = distTags?.latest || CURRENT_VERSION;
+        spinner.stop();
+        console.log();
+        console.log(chalk_1.default.bold("Version Check:"));
+        console.log(`  Current:  ${chalk_1.default.cyan(CURRENT_VERSION)}`);
+        console.log(`  Latest:   ${chalk_1.default.cyan(latestVersion)}`);
+        console.log();
+        if (latestVersion === CURRENT_VERSION) {
+            console.log(chalk_1.default.green("✅ You're on the latest version!"));
+            return;
+        }
+        // Check if update available
+        const current = parseVersion(CURRENT_VERSION);
+        const latest = parseVersion(latestVersion);
+        if (latest.major > current.major ||
+            (latest.major === current.major && latest.minor > current.minor) ||
+            (latest.major === current.major &&
+                latest.minor === current.minor &&
+                latest.patch > current.patch)) {
+            console.log(chalk_1.default.yellow(`⚠ Update available: ${latestVersion}`));
+            console.log();
+            console.log(chalk_1.default.bold("To upgrade, run:"));
+            console.log(chalk_1.default.cyan(`  npm install -g ${CLI_NAME}@latest`));
+            console.log(chalk_1.default.cyan(`  or`));
+            console.log(chalk_1.default.cyan(`  pnpm add -g ${CLI_NAME}@latest`));
+            console.log();
+            console.log(chalk_1.default.gray("Release notes: https://github.com/kaven-co/kaven-cli/releases"));
+        }
+        else {
+            console.log(chalk_1.default.green("✅ You're on the latest version!"));
+        }
+    }
+    catch (error) {
+        spinner.fail(`Check failed: ${error instanceof Error ? error.message : String(error)}`);
+        console.log(chalk_1.default.gray("You can manually check at: https://www.npmjs.com/package/kaven-cli"));
+    }
+}
+/**
+ * C2.3: Install latest CLI version
+ */
+async function upgradeInstall() {
+    console.log();
+    const spinner = (0, ora_1.default)("Fetching latest version...").start();
+    try {
+        // Get latest version
+        const response = await fetch(`https://registry.npmjs.org/${CLI_NAME}`);
+        if (!response.ok) {
+            throw new Error("Failed to fetch package info");
+        }
+        const data = (await response.json());
+        const distTags = data["dist-tags"];
+        const latestVersion = distTags?.latest || CURRENT_VERSION;
+        if (latestVersion === CURRENT_VERSION) {
+            spinner.succeed("Already on latest version");
+            return;
+        }
+        spinner.text = `Installing ${CLI_NAME}@${latestVersion}...`;
+        // Determine package manager
+        const packageManager = process.env.npm_config_user_agent?.includes("pnpm")
+            ? "pnpm"
+            : "npm";
+        // Install with appropriate package manager
+        const exitCode = await runCommand(packageManager, [
+            "install",
+            "-g",
+            `${CLI_NAME}@${latestVersion}`,
+        ]);
+        if (exitCode !== 0) {
+            spinner.fail(`Installation failed with exit code ${exitCode}`);
+            console.error(chalk_1.default.gray(`Try: ${packageManager} install -g ${CLI_NAME}@latest`));
+            process.exit(1);
+            return;
+        }
+        spinner.succeed(`Updated to ${latestVersion}`);
+        // Health check after install
+        const healthSpinner = (0, ora_1.default)("Running health check...").start();
+        const health = await verifyInstallation();
+        if (health.ok) {
+            healthSpinner.succeed("Installation verified");
+            console.log();
+            console.log(chalk_1.default.green("✅ CLI upgraded successfully!"));
+            console.log(chalk_1.default.gray("Try: kaven --version"));
+        }
+        else {
+            healthSpinner.warn("Installation verification failed");
+            console.log(chalk_1.default.yellow(health.errors.join("\n")));
+        }
+    }
+    catch (error) {
+        spinner.fail(`Installation failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+/**
+ * Verify CLI installation is working
+ */
+async function verifyInstallation() {
+    const errors = [];
+    try {
+        // Check if kaven command is available
+        const code = await runCommand("kaven", ["--version"], { stdio: "pipe" });
+        if (code !== 0) {
+            errors.push("kaven command not available in PATH");
+        }
+    }
+    catch {
+        errors.push("Could not execute kaven command");
+    }
+    return { ok: errors.length === 0, errors };
+}
+/**
+ * Run shell command
+ */
+function runCommand(cmd, args, options) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(cmd, args, options || { stdio: "inherit" });
+        proc.on("error", reject);
+        proc.on("close", (code) => resolve(code ?? 0));
+    });
+}
+/**
+ * Parse semver version
+ */
+function parseVersion(version) {
+    const cleaned = version.replace(/^v/, "").split("-")[0];
+    const [major, minor, patch] = cleaned.split(".").map(Number);
+    return {
+        major: major || 0,
+        minor: minor || 0,
+        patch: patch || 0,
+    };
+}

package/dist/commands/upgrade/index.js

@@ -0,0 +1,218 @@
+"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.upgradeInstall = exports.upgradeCheck = void 0;
+exports.upgradeCommand = upgradeCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const open_1 = __importDefault(require("open"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const AuthService_1 = require("../../core/AuthService");
+const MarketplaceClient_1 = require("../../infrastructure/MarketplaceClient");
+const check_1 = require("./check");
+Object.defineProperty(exports, "upgradeCheck", { enumerable: true, get: function () { return check_1.upgradeCheck; } });
+Object.defineProperty(exports, "upgradeInstall", { enumerable: true, get: function () { return check_1.upgradeInstall; } });
+const LICENSE_PATH = path_1.default.join(os_1.default.homedir(), ".kaven", "license.json");
+const TIERS = ["starter", "complete", "pro", "enterprise"];
+const TIER_LABELS = {
+    starter: "Starter",
+    complete: "Complete",
+    pro: "Pro",
+    enterprise: "Enterprise",
+};
+const POLL_INTERVAL_MS = 5000;
+const MAX_POLLS = 120; // 10 minutes
+async function loadLicenseKey() {
+    if (!(await fs_extra_1.default.pathExists(LICENSE_PATH)))
+        return null;
+    try {
+        const data = await fs_extra_1.default.readJson(LICENSE_PATH);
+        return data.key || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveLicenseTier(tier) {
+    let existing = {};
+    if (await fs_extra_1.default.pathExists(LICENSE_PATH)) {
+        try {
+            existing = await fs_extra_1.default.readJson(LICENSE_PATH);
+        }
+        catch {
+            // ignore
+        }
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(LICENSE_PATH));
+    await fs_extra_1.default.writeJson(LICENSE_PATH, { ...existing, tier }, { spaces: 2 });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function upgradeCommand(options) {
+    // 1. Require auth
+    const authService = new AuthService_1.AuthService();
+    try {
+        await authService.getValidToken();
+    }
+    catch {
+        console.error(chalk_1.default.red("Error: Not authenticated. Run 'kaven auth login' first."));
+        process.exit(1);
+        return;
+    }
+    // 2. Load current license key
+    const licenseKey = await loadLicenseKey();
+    if (!licenseKey) {
+        console.error(chalk_1.default.red("Error: No license found. Add your license key first with 'kaven license status'."));
+        process.exit(1);
+        return;
+    }
+    // 3. Get current tier
+    const client = new MarketplaceClient_1.MarketplaceClient(authService);
+    const tierSpinner = (0, ora_1.default)("Loading your current license...").start();
+    let currentTier;
+    try {
+        const licenseStatus = await client.getLicenseStatus(licenseKey);
+        currentTier = licenseStatus.tier.toLowerCase();
+        tierSpinner.succeed(`Current tier: ${chalk_1.default.bold(TIER_LABELS[currentTier] || currentTier)}`);
+    }
+    catch {
+        tierSpinner.fail("Could not load license status");
+        console.error(chalk_1.default.gray("Try: kaven license status"));
+        process.exit(1);
+        return;
+    }
+    // 4. Show tier comparison table (imported from license command)
+    const { printTierComparisonTable } = await Promise.resolve().then(() => __importStar(require("../license/tier-table")));
+    printTierComparisonTable(currentTier, "pro");
+    console.log();
+    // 5. Prompt target tier (exclude current tier)
+    const { select } = await Promise.resolve().then(() => __importStar(require("@inquirer/prompts")));
+    const availableTiers = TIERS.filter((t) => t !== currentTier && t !== "enterprise");
+    if (availableTiers.length === 0) {
+        console.log(chalk_1.default.yellow(`You're already on the highest available tier (${TIER_LABELS[currentTier] || currentTier}).`));
+        console.log(chalk_1.default.gray("For Enterprise plans, contact: enterprise@kaven.sh"));
+        return;
+    }
+    const targetTier = await select({
+        message: "Select target tier:",
+        choices: availableTiers.map((t) => ({
+            name: TIER_LABELS[t],
+            value: t,
+        })),
+    });
+    // 6. Guard: same tier
+    if (targetTier === currentTier) {
+        console.log(chalk_1.default.yellow(`Already on ${TIER_LABELS[currentTier] || currentTier}.`));
+        return;
+    }
+    // 7. Create checkout session
+    const checkoutSpinner = (0, ora_1.default)("Creating checkout session...").start();
+    let sessionUrl;
+    let sessionId;
+    try {
+        const session = await client.createCheckoutSession(targetTier, licenseKey);
+        sessionUrl = session.sessionUrl;
+        sessionId = session.sessionId;
+        checkoutSpinner.succeed("Checkout session created");
+    }
+    catch (error) {
+        checkoutSpinner.fail("Failed to create checkout session");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+        return;
+    }
+    // 8. Open browser
+    if (options.browser !== false) {
+        console.log(chalk_1.default.cyan(`Opening checkout in your browser...`));
+        console.log(chalk_1.default.gray(`URL: ${sessionUrl}`));
+        try {
+            await (0, open_1.default)(sessionUrl);
+        }
+        catch {
+            console.log(chalk_1.default.yellow("Could not open browser automatically. Open this URL manually:"));
+            console.log(chalk_1.default.cyan(sessionUrl));
+        }
+    }
+    else {
+        console.log(chalk_1.default.cyan("Open this URL to complete checkout:"));
+        console.log(chalk_1.default.bold(sessionUrl));
+    }
+    console.log();
+    // 9. Poll for checkout status
+    const pollSpinner = (0, ora_1.default)(`Waiting for payment confirmation (checking every 5s, max 10 min)...`).start();
+    for (let i = 0; i < MAX_POLLS; i++) {
+        await sleep(POLL_INTERVAL_MS);
+        const remaining = MAX_POLLS - i - 1;
+        pollSpinner.text = `Waiting for payment confirmation... (${remaining * 5}s remaining)`;
+        try {
+            const status = await client.getCheckoutStatus(sessionId);
+            if (status.status === "confirmed") {
+                pollSpinner.succeed("Payment confirmed!");
+                const newTier = status.tier || targetTier;
+                await saveLicenseTier(newTier);
+                console.log();
+                console.log(chalk_1.default.green(`✅ Successfully upgraded to ${TIER_LABELS[newTier] || newTier}!`));
+                console.log(chalk_1.default.gray("Your new features are now unlocked."));
+                return;
+            }
+            if (status.status === "cancelled") {
+                pollSpinner.fail("Checkout was cancelled.");
+                console.log(chalk_1.default.gray("No changes were made to your subscription."));
+                return;
+            }
+            if (status.status === "failed") {
+                pollSpinner.fail("Payment failed.");
+                console.log(chalk_1.default.gray("Please try again or contact support@kaven.sh"));
+                process.exit(1);
+                return;
+            }
+            // status === "pending" — continue polling
+        }
+        catch {
+            // Network hiccup — keep polling
+        }
+    }
+    // Timeout
+    pollSpinner.warn("Timed out waiting for payment confirmation.");
+    console.log();
+    console.log(chalk_1.default.yellow("If you completed payment, your upgrade may take a few minutes to activate."));
+    console.log(chalk_1.default.gray("Check your upgrade status at: https://dashboard.kaven.sh/billing"));
+}