@upfluxhq/cli 0.1.0-beta.1

package/dist/commands/release.js

@@ -0,0 +1,554 @@
+"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 });
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const form_data_1 = __importDefault(require("form-data"));
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const archiver_1 = __importDefault(require("archiver"));
+const apiClient_1 = require("../client/apiClient");
+const configStore_1 = require("../config/configStore");
+/**
+ * Default output directory for React Native bundle
+ */
+const DEFAULT_OUTPUT_DIR = "./dist";
+const DEFAULT_ENTRY_FILE = "index.js";
+/**
+ * Supported platforms
+ */
+const VALID_PLATFORMS = ["ios", "android", "web"];
+/**
+ * Capacitor config file names to check
+ */
+const CAPACITOR_CONFIG_FILES = [
+    "capacitor.config.ts",
+    "capacitor.config.js",
+    "capacitor.config.json",
+];
+/**
+ * Check if current directory is a Capacitor project
+ */
+function isCapacitorProject() {
+    return CAPACITOR_CONFIG_FILES.some((file) => fs.existsSync(path.resolve(file)));
+}
+/**
+ * Get Capacitor webDir from config
+ */
+function getCapacitorWebDir() {
+    // Check capacitor.config.json first
+    const jsonConfig = path.resolve("capacitor.config.json");
+    if (fs.existsSync(jsonConfig)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(jsonConfig, "utf-8"));
+            return config.webDir || "www";
+        }
+        catch (_a) {
+            // Ignore parse errors
+        }
+    }
+    // Check capacitor.config.ts/js for webDir (simple regex)
+    for (const file of ["capacitor.config.ts", "capacitor.config.js"]) {
+        const filePath = path.resolve(file);
+        if (fs.existsSync(filePath)) {
+            try {
+                const content = fs.readFileSync(filePath, "utf-8");
+                const match = content.match(/webDir:\s*['"]([^'"]+)['"]/);
+                if (match) {
+                    return match[1];
+                }
+            }
+            catch (_b) {
+                // Ignore read errors
+            }
+        }
+    }
+    // Default Capacitor webDir
+    return "www";
+}
+/**
+ * Zip a directory for Capacitor upload
+ */
+async function zipDirectory(sourceDir, outPath) {
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(outPath);
+        const archive = (0, archiver_1.default)("zip", { zlib: { level: 9 } });
+        output.on("close", () => {
+            console.log(chalk_1.default.gray(`   Zip created: ${archive.pointer()} bytes`));
+            resolve(outPath);
+        });
+        archive.on("error", (err) => {
+            reject(err);
+        });
+        archive.pipe(output);
+        archive.directory(sourceDir, false);
+        archive.finalize();
+    });
+}
+/**
+ * Validate MongoDB ObjectId format
+ */
+function isValidObjectId(id) {
+    return /^[a-fA-F0-9]{24}$/.test(id);
+}
+/**
+ * Validate app ID format (alphanumeric with hyphens)
+ */
+function isValidAppId(appId) {
+    return /^[a-zA-Z0-9-_]+$/.test(appId) && appId.length >= 3;
+}
+/**
+ * Validate release label format (semver-like)
+ */
+function isValidReleaseLabel(label) {
+    // Allow v1.0.0, 1.0.0, v1.0.0-beta, etc.
+    return /^v?\d+\.\d+\.\d+(-[a-zA-Z0-9._-]+)?$/.test(label);
+}
+/**
+ * Validate version range format
+ */
+function isValidVersionRange(range) {
+    // Allow >=1.0.0, >1.0.0, <2.0.0, ^1.0.0, ~1.0.0, 1.0.0 - 2.0.0, etc.
+    return /^[<>=^~]?\d+\.\d+\.\d+(\s*-\s*\d+\.\d+\.\d+)?$/.test(range);
+}
+/**
+ * Select deployment from multiple credentials
+ */
+async function selectDeployment(credentials) {
+    if (credentials.length === 1) {
+        return credentials[0];
+    }
+    const choices = credentials.map((cred, i) => ({
+        name: `${cred.deploymentName || cred.deploymentId} (${cred.appId})`,
+        value: cred,
+    }));
+    const { selected } = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "selected",
+            message: "Select deployment to release to:",
+            choices,
+        }
+    ]);
+    return selected;
+}
+/**
+ * Validate rollout percentage
+ */
+function isValidRollout(rollout) {
+    const num = parseInt(rollout, 10);
+    if (isNaN(num)) {
+        return { valid: false, error: "Rollout must be a number" };
+    }
+    if (num < 0 || num > 100) {
+        return { valid: false, error: "Rollout must be between 0 and 100" };
+    }
+    return { valid: true, value: num };
+}
+/**
+ * Validate entry file exists
+ */
+function validateEntryFile(entryFile) {
+    const resolved = path.resolve(entryFile);
+    if (!fs.existsSync(resolved)) {
+        return { valid: false, error: `Entry file not found: ${resolved}` };
+    }
+    return { valid: true, path: resolved };
+}
+/**
+ * Check if React Native is available
+ */
+function isReactNativeAvailable() {
+    try {
+        (0, child_process_1.execSync)("npx react-native --version", { stdio: "pipe" });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Run React Native bundler
+ */
+function runBundler(options) {
+    const { platform, entryFile, outputDir, dev } = options;
+    const bundleOutput = path.join(outputDir, `index.${platform}.bundle`);
+    const assetsDir = path.join(outputDir, "assets");
+    // Ensure output directory exists
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    console.log(chalk_1.default.blue(`📦 Bundling for ${platform}...`));
+    const command = [
+        "npx react-native bundle",
+        `--platform ${platform}`,
+        `--entry-file ${entryFile}`,
+        `--bundle-output ${bundleOutput}`,
+        `--assets-dest ${assetsDir}`,
+        `--dev ${dev}`,
+    ].join(" ");
+    console.log(chalk_1.default.gray(`   ${command}\n`));
+    try {
+        (0, child_process_1.execSync)(command, {
+            stdio: "inherit",
+            cwd: process.cwd(),
+        });
+    }
+    catch (error) {
+        throw new Error("Bundle failed. Check the error above.");
+    }
+    return { bundlePath: bundleOutput, assetsDir };
+}
+/**
+ * Collect all asset files from a directory recursively
+ */
+function collectAssets(dir) {
+    const assets = [];
+    if (!fs.existsSync(dir)) {
+        return assets;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            assets.push(...collectAssets(fullPath));
+        }
+        else {
+            assets.push(fullPath);
+        }
+    }
+    return assets;
+}
+const release = new commander_1.Command("release")
+    .description("Bundle and upload a new release to Upflux")
+    .option("-a, --app <appId>", "Application ID (uses stored value if not provided)")
+    .option("-d, --deployment <deploymentId>", "Deployment ID (uses stored value if not provided)")
+    .requiredOption("-l, --label <label>", "Release label (e.g., v1.0.0)")
+    .option("-p, --platform <platform>", "Target platform (ios or android)")
+    .option("-e, --entry-file <path>", "Entry file for bundler", DEFAULT_ENTRY_FILE)
+    .option("-o, --output-dir <path>", "Output directory for bundle", DEFAULT_OUTPUT_DIR)
+    .option("-b, --bundle <path>", "Skip bundling, use existing bundle file")
+    .option("--assets <paths...>", "Skip auto-detection, use these asset files")
+    .option("-m, --mandatory", "Mark update as mandatory", false)
+    .option("-r, --rollout <number>", "Rollout percentage (0-100)", "100")
+    .option("-v, --version-range <range>", "Binary version range (e.g., >=1.0.0)")
+    .option("--dev", "Create development bundle", false)
+    .option("--schedule", "Create as draft, set schedule time in dashboard")
+    .option("--skip-bundle", "Skip bundling, use existing files in output dir", false)
+    .option("--capacitor", "Force Capacitor mode (auto-detected if capacitor.config exists)")
+    .option("--web-dir <path>", "Web directory to bundle for Capacitor (default: from config or www)")
+    .action(async (opts) => {
+    var _a;
+    try {
+        // ========================================
+        // VALIDATION PHASE
+        // ========================================
+        // Validation 1: Check for credentials
+        const credentials = configStore_1.configStore.getCredentials();
+        if (credentials.length === 0) {
+            console.error(chalk_1.default.red("✗ Not authenticated"));
+            console.error(chalk_1.default.gray("Run 'upflux login --key <publishKey>' first."));
+            process.exit(1);
+        }
+        // Validation 2: Select or determine credential to use
+        let selectedCredential;
+        if (opts.deployment) {
+            // User provided deployment ID - find matching credential
+            const cred = configStore_1.configStore.getCredentialByDeployment(opts.deployment);
+            if (!cred) {
+                console.error(chalk_1.default.red(`✗ No credential found for deployment: ${opts.deployment}`));
+                console.error(chalk_1.default.gray("Available deployments:"));
+                credentials.forEach(c => {
+                    const name = c.deploymentName || c.deploymentId;
+                    console.error(chalk_1.default.gray(`  - ${name} (${c.deploymentId})`));
+                });
+                process.exit(1);
+            }
+            selectedCredential = cred;
+        }
+        else if (credentials.length === 1) {
+            // Only one credential, use it
+            selectedCredential = credentials[0];
+            const name = selectedCredential.deploymentName || selectedCredential.deploymentId;
+            console.log(chalk_1.default.gray(`Using deployment: ${name}`));
+        }
+        else {
+            // Multiple credentials - prompt for selection
+            selectedCredential = await selectDeployment(credentials);
+        }
+        const appId = selectedCredential.appId;
+        const deploymentId = selectedCredential.deploymentId;
+        const authKey = selectedCredential.key;
+        const deploymentName = selectedCredential.deploymentName;
+        // Validation 3: Platform - use stored value if not provided
+        let platform = opts.platform;
+        if (!platform) {
+            if (selectedCredential.platform) {
+                platform = selectedCredential.platform;
+                console.log(chalk_1.default.gray(`Using stored platform: ${platform}`));
+            }
+            else {
+                console.error(chalk_1.default.red("✗ Platform is required"));
+                console.error(chalk_1.default.gray("Provide --platform <ios|android> or re-login to store it."));
+                process.exit(1);
+            }
+        }
+        if (!VALID_PLATFORMS.includes(platform.toLowerCase())) {
+            console.error(chalk_1.default.red(`✗ Invalid platform: ${platform}`));
+            console.error(chalk_1.default.gray(`Valid platforms: ${VALID_PLATFORMS.join(", ")}`));
+            process.exit(1);
+        }
+        platform = platform.toLowerCase();
+        // Validate app ID if provided matches selected credential
+        if (opts.app && opts.app !== appId) {
+            console.error(chalk_1.default.red(`✗ App ID mismatch`));
+            console.error(chalk_1.default.gray(`Provided: ${opts.app}`));
+            console.error(chalk_1.default.gray(`Selected credential's app: ${appId}`));
+            process.exit(1);
+        }
+        if (!isValidAppId(appId)) {
+            console.error(chalk_1.default.red("✗ Invalid app ID format"));
+            console.error(chalk_1.default.gray("App ID should be alphanumeric with hyphens, minimum 3 characters"));
+            process.exit(1);
+        }
+        if (!isValidObjectId(deploymentId)) {
+            console.error(chalk_1.default.red("✗ Invalid deployment ID format"));
+            console.error(chalk_1.default.gray("Deployment ID should be a 24-character MongoDB ObjectId"));
+            process.exit(1);
+        }
+        // Validation 5: Release label format
+        if (!isValidReleaseLabel(opts.label)) {
+            console.error(chalk_1.default.red("✗ Invalid release label format"));
+            console.error(chalk_1.default.gray("Use semantic versioning: v1.0.0, 1.0.0-beta, etc."));
+            process.exit(1);
+        }
+        // Validation 6: Rollout percentage
+        const rolloutValidation = isValidRollout(opts.rollout);
+        if (!rolloutValidation.valid) {
+            console.error(chalk_1.default.red(`✗ Invalid rollout: ${rolloutValidation.error}`));
+            process.exit(1);
+        }
+        // Validation 7: Version range (if provided)
+        if (opts.versionRange && !isValidVersionRange(opts.versionRange)) {
+            console.error(chalk_1.default.red("✗ Invalid version range format"));
+            console.error(chalk_1.default.gray("Examples: >=1.0.0, ^1.0.0, 1.0.0 - 2.0.0"));
+            process.exit(1);
+        }
+        // ========================================
+        // BUNDLING PHASE
+        // ========================================
+        let bundlePath;
+        let assetFiles = [];
+        // Detect project type
+        const isCapacitor = opts.capacitor || isCapacitorProject();
+        if (isCapacitor) {
+            // ========================================
+            // CAPACITOR BUNDLING
+            // ========================================
+            console.log(chalk_1.default.blue("📱 Detected Capacitor project"));
+            // Get web directory
+            const webDir = opts.webDir || getCapacitorWebDir();
+            const webDirPath = path.resolve(webDir);
+            if (!fs.existsSync(webDirPath)) {
+                console.error(chalk_1.default.red(`✗ Web directory not found: ${webDirPath}`));
+                console.error(chalk_1.default.gray("Run your build command first (e.g., npm run build)"));
+                process.exit(1);
+            }
+            // Check for index.html
+            const indexPath = path.join(webDirPath, "index.html");
+            if (!fs.existsSync(indexPath)) {
+                console.error(chalk_1.default.red(`✗ index.html not found in: ${webDirPath}`));
+                console.error(chalk_1.default.gray("Make sure your web app is built correctly."));
+                process.exit(1);
+            }
+            // Ensure output directory exists
+            const outputDir = path.resolve(opts.outputDir);
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            // Zip the web directory
+            console.log(chalk_1.default.blue(`📦 Zipping ${webDir}/ directory...`));
+            const zipPath = path.join(outputDir, `bundle-${opts.label}.zip`);
+            bundlePath = await zipDirectory(webDirPath, zipPath);
+            console.log(chalk_1.default.green(`✓ Bundle created: ${bundlePath}`));
+            // No separate assets for Capacitor - all in zip
+            assetFiles = [];
+        }
+        else if (opts.bundle) {
+            // ========================================
+            // PRE-BUILT BUNDLE PROVIDED
+            // ========================================
+            bundlePath = path.resolve(opts.bundle);
+            if (!fs.existsSync(bundlePath)) {
+                console.error(chalk_1.default.red(`✗ Bundle file not found: ${bundlePath}`));
+                process.exit(1);
+            }
+            try {
+                fs.accessSync(bundlePath, fs.constants.R_OK);
+            }
+            catch (_b) {
+                console.error(chalk_1.default.red(`✗ Cannot read bundle file: ${bundlePath}`));
+                process.exit(1);
+            }
+            if (opts.assets) {
+                assetFiles = opts.assets.map((p) => path.resolve(p));
+            }
+        }
+        else {
+            // ========================================
+            // REACT NATIVE BUNDLING
+            // ========================================
+            if (!opts.skipBundle) {
+                const entryValidation = validateEntryFile(opts.entryFile);
+                if (!entryValidation.valid) {
+                    console.error(chalk_1.default.red(`✗ ${entryValidation.error}`));
+                    process.exit(1);
+                }
+                if (!isReactNativeAvailable()) {
+                    console.error(chalk_1.default.red("✗ React Native CLI not found"));
+                    console.error(chalk_1.default.gray("Make sure you're in a React Native project with react-native installed."));
+                    console.error(chalk_1.default.gray("Or use --bundle to provide a pre-built bundle, or use --capacitor for web apps."));
+                    process.exit(1);
+                }
+            }
+            const outputDir = path.resolve(opts.outputDir);
+            const expectedBundle = path.join(outputDir, `index.${platform}.bundle`);
+            const assetsDir = path.join(outputDir, "assets");
+            if (opts.skipBundle) {
+                if (!fs.existsSync(expectedBundle)) {
+                    console.error(chalk_1.default.red(`✗ Bundle not found: ${expectedBundle}`));
+                    console.error(chalk_1.default.gray("Run without --skip-bundle to create a new bundle."));
+                    process.exit(1);
+                }
+                bundlePath = expectedBundle;
+                console.log(chalk_1.default.blue("⏭ Skipping bundle, using existing files..."));
+            }
+            else {
+                const result = runBundler({
+                    platform: platform,
+                    entryFile: opts.entryFile,
+                    outputDir,
+                    dev: opts.dev,
+                });
+                bundlePath = result.bundlePath;
+            }
+            if (opts.assets) {
+                assetFiles = opts.assets.map((p) => path.resolve(p));
+            }
+            else {
+                assetFiles = collectAssets(assetsDir);
+            }
+            // Validate asset files
+            const invalidAssets = assetFiles.filter(p => !fs.existsSync(p));
+            if (invalidAssets.length > 0) {
+                console.warn(chalk_1.default.yellow(`⚠ ${invalidAssets.length} asset(s) not found, will be skipped`));
+                assetFiles = assetFiles.filter(p => fs.existsSync(p));
+            }
+        }
+        // ========================================
+        // UPLOAD PHASE
+        // ========================================
+        console.log(chalk_1.default.blue("\n⬆ Uploading release..."));
+        console.log(`  App: ${appId}`);
+        console.log(`  Deployment: ${deploymentId}`);
+        console.log(`  Deployment Name: ${deploymentName}`);
+        console.log(`  Label: ${opts.label}`);
+        console.log(`  Platform: ${platform}`);
+        console.log(`  Bundle: ${bundlePath}`);
+        console.log(`  Assets: ${assetFiles.length} file(s)`);
+        console.log(`  Rollout: ${rolloutValidation.value}%`);
+        console.log(`  Mandatory: ${opts.mandatory ? "Yes" : "No"}`);
+        if (opts.schedule) {
+            console.log(`  Schedule: ${chalk_1.default.yellow("Draft (set time in dashboard)")}`);
+        }
+        if (opts.versionRange) {
+            console.log(`  Version Range: ${opts.versionRange}`);
+        }
+        // Create form data
+        const form = new form_data_1.default();
+        form.append("bundle", fs.createReadStream(bundlePath));
+        form.append("releaseLabel", opts.label);
+        form.append("appId", appId);
+        form.append("deploymentId", deploymentId);
+        form.append("deploymentName", deploymentName);
+        form.append("mandatory", String(opts.mandatory));
+        form.append("rolloutPercentage", String(rolloutValidation.value));
+        if (opts.schedule) {
+            form.append("isDraft", "true");
+        }
+        if (opts.versionRange) {
+            form.append("binaryVersionRange", opts.versionRange);
+        }
+        // Add asset files
+        for (const assetPath of assetFiles) {
+            form.append("assets", fs.createReadStream(assetPath));
+        }
+        // Upload to API (using selected credential's key)
+        const response = await apiClient_1.apiClient.post("/releases", form, {
+            headers: Object.assign(Object.assign({}, form.getHeaders()), { "x-publish-key": authKey }),
+        });
+        console.log(chalk_1.default.green("\n✓ Release uploaded successfully!"));
+        console.log(chalk_1.default.gray("──────────────────────────────────"));
+        console.log(`  ID: ${response.data.id}`);
+        console.log(`  Label: ${response.data.releaseLabel}`);
+        console.log(`  Bundle URL: ${response.data.bundleUrl}`);
+        console.log(`  Rollout: ${response.data.rolloutPercentage}%`);
+        console.log(`  Mandatory: ${response.data.mandatory ? "Yes" : "No"}`);
+        if (response.data.status === 'draft') {
+            console.log(chalk_1.default.yellow(`  Status: DRAFT`));
+            console.log(chalk_1.default.gray(`  📅 Set schedule time in dashboard`));
+        }
+        else {
+            console.log(`  Status: ${response.data.status || 'active'}`);
+        }
+        if (response.data.binaryVersionRange) {
+            console.log(`  Version Range: ${response.data.binaryVersionRange}`);
+        }
+        console.log(chalk_1.default.gray("──────────────────────────────────"));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`\n✗ Failed to upload release: ${error.message}`));
+        if ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) {
+            console.error(chalk_1.default.gray(JSON.stringify(error.response.data, null, 2)));
+        }
+        process.exit(1);
+    }
+});
+exports.default = release;

package/dist/commands/status.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+declare const status: Command;
+export default status;

package/dist/commands/status.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const apiClient_1 = require("../client/apiClient");
+/**
+ * Validate MongoDB ObjectId format
+ */
+function isValidObjectId(id) {
+    return /^[a-fA-F0-9]{24}$/.test(id);
+}
+/**
+ * Validate app ID format (alphanumeric with hyphens)
+ */
+function isValidAppId(appId) {
+    return /^[a-zA-Z0-9-_]+$/.test(appId) && appId.length >= 3;
+}
+const status = new commander_1.Command("status")
+    .description("Check app release status")
+    .option("-a, --app <appId>", "Filter by application ID")
+    .option("-d, --deployment <deploymentId>", "Filter by deployment ID")
+    .option("-n, --limit <number>", "Number of releases to show", "10")
+    .action(async (opts) => {
+    try {
+        // Validation 1: App ID format (if provided)
+        if (opts.app && !isValidAppId(opts.app)) {
+            console.error(chalk_1.default.red("✗ Invalid app ID format"));
+            console.error(chalk_1.default.gray("App ID should be alphanumeric with hyphens, minimum 3 characters"));
+            process.exit(1);
+        }
+        // Validation 2: Deployment ID format (if provided)
+        if (opts.deployment && !isValidObjectId(opts.deployment)) {
+            console.error(chalk_1.default.red("✗ Invalid deployment ID format"));
+            console.error(chalk_1.default.gray("Deployment ID should be a 24-character MongoDB ObjectId"));
+            process.exit(1);
+        }
+        // Validation 3: Limit is a positive number
+        const limit = parseInt(opts.limit, 10);
+        if (isNaN(limit) || limit < 1 || limit > 100) {
+            console.error(chalk_1.default.red("✗ Invalid limit value"));
+            console.error(chalk_1.default.gray("Limit should be a number between 1 and 100"));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.blue("⚡ Fetching releases...\n"));
+        // Build query params
+        const params = {};
+        if (opts.app)
+            params.appId = opts.app;
+        if (opts.deployment)
+            params.deploymentId = opts.deployment;
+        const response = await apiClient_1.apiClient.get("/releases", { params });
+        const releases = response.data.releases;
+        if (releases.length === 0) {
+            console.log(chalk_1.default.yellow("No releases found."));
+            if (opts.app || opts.deployment) {
+                console.log(chalk_1.default.gray("Try removing filters to see all releases."));
+            }
+            return;
+        }
+        // Limit results
+        const displayReleases = releases.slice(0, limit);
+        console.log(chalk_1.default.white.bold(`Found ${releases.length} release(s)${releases.length > limit ? ` (showing ${limit})` : ""}:\n`));
+        // Display each release
+        displayReleases.forEach((release, index) => {
+            const mandatoryTag = release.mandatory ? chalk_1.default.red(" [MANDATORY]") : "";
+            const rolloutTag = release.rolloutPercentage < 100
+                ? chalk_1.default.yellow(` (${release.rolloutPercentage}% rollout)`)
+                : "";
+            console.log(chalk_1.default.cyan(`${index + 1}. ${release.releaseLabel}`) + mandatoryTag + rolloutTag);
+            console.log(chalk_1.default.gray(`   ID: ${release.id}`));
+            console.log(chalk_1.default.gray(`   App: ${release.appId} | Deployment: ${release.deploymentId}`));
+            console.log(chalk_1.default.gray(`   Created: ${new Date(release.createdAt).toLocaleString()}`));
+            if (release.binaryVersionRange) {
+                console.log(chalk_1.default.gray(`   Version Range: ${release.binaryVersionRange}`));
+            }
+            console.log("");
+        });
+        if (releases.length > limit) {
+            console.log(chalk_1.default.gray(`... and ${releases.length - limit} more. Use --limit to see more.`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`\n✗ Failed to fetch releases: ${error.message}`));
+        process.exit(1);
+    }
+});
+exports.default = status;