@upfluxhq/cli 0.1.0-beta.1 → 0.1.0-beta.3

package/README.md

@@ -1,6 +1,6 @@
 # @upfluxhq/cli
 
-Command-line interface for managing Upflux OTA updates.
+Command-line interface for managing Upflux OTA updates for React Native and Capacitor apps.
 
 ## Installation
 
@@ -18,7 +18,7 @@ upflux login --key <staging-publish-key>
 upflux login --key <production-publish-key>
 
 # 2. Upload a release (will prompt if multiple deployments)
-upflux release --platform android --label v1.0.0 --mandatory
+upflux release --label v1.0.0 --mandatory
 
 # 3. Check release status
 upflux status
@@ -40,9 +40,9 @@ upflux login --key <publishKey>
 
 **Example output with multiple logins:**
 ```
+🔐 Verifying with server...
 ✓ Login successful!
   App ID: app-970384d3
-  Platform: android
   Deployment: production
 
   Stored credentials (2):
@@ -79,6 +79,10 @@ upflux logout --all
 
 Bundle and upload a new release. **Prompts to select deployment** if multiple are stored.
 
+Automatically detects project type:
+- **React Native**: Uses `react-native bundle` command
+- **Capacitor**: Zips the web directory (detected via `capacitor.config.*`)
+
 ```bash
 upflux release [options]
 ```
@@ -86,8 +90,8 @@ upflux release [options]
 | Option | Required | Description |
 |--------|----------|-------------|
 | `-l, --label <label>` | ✓ | Release label (e.g., v1.0.0) |
-| `-p, --platform <platform>` | | Target platform (`ios` or `android`, auto-detected) |
-| `-a, --app <appId>` | | Application ID (auto-detected) |
+| `--platform <platform>` | | Target platform: `all`, `ios`, or `android` (defaults to `all`) |
+| `-a, --app <appId>` | | Application ID (auto-detected from credentials) |
 | `-d, --deployment <deploymentId>` | | Deployment ID (prompts if multiple) |
 | `-e, --entry-file <path>` | | Entry file for bundler (default: `index.js`) |
 | `-o, --output-dir <path>` | | Output directory for bundle (default: `./dist`) |
@@ -98,21 +102,75 @@ upflux release [options]
 | `-v, --version-range <range>` | | Binary version range (e.g., >=1.0.0) |
 | `--dev` | | Create development bundle |
 | `--skip-bundle` | | Skip bundling, use existing files in output dir |
+| `--schedule` | | Create as draft, set schedule time in dashboard |
+| `--capacitor` | | Force Capacitor mode (auto-detected if capacitor.config exists) |
+| `--web-dir <path>` | | Web directory to bundle for Capacitor (default: from config or www) |
+
+**Examples:**
+
+```bash
+# Release to selected deployment (prompts if multiple)
+upflux release --label v1.2.0
+
+# iOS-only hotfix
+upflux release --label v1.2.1-ios-fix --platform ios
 
-**Example with deployment selection:**
+# Android-only release with 50% rollout
+upflux release --label v1.2.2 --platform android --rollout 50
+
+# Mandatory update for all platforms
+upflux release --label v1.3.0 --mandatory
+
+# Schedule release (draft mode)
+upflux release --label v1.4.0 --schedule
+
+# Capacitor project with custom web directory
+upflux release --label v1.0.0 --capacitor --web-dir dist
 ```
-$ upflux release --platform android --label v1.2.0
 
-? Select deployment to release to:
-❯ production (app-970384d3)
-  staging (app-970384d3)
+**Example output:**
+```
+📦 Bundling for iOS...
+  ✓ iOS bundle created
+📦 Bundling for Android...
+  ✓ Android bundle created
+
+⬆ Uploading release...
+  App: app-970384d3
+  Deployment: 6933e683aa32fe18a1311bbb
+  Deployment Name: production
+  Label: v1.2.0
+  Platform: all
+  Bundle: ./dist/ios/index.ios.bundle
+  Assets: 24 file(s)
+  Rollout: 100%
+  Mandatory: No
+
+📋 Step 1/3: Requesting upload URLs...
+   ✓ Got 26 presigned URLs
+📤 Step 2/3: Uploading files directly to storage...
+   [1/26] index.ios.bundle
+   ...
+   ✓ Uploaded 26 files
+✅ Step 3/3: Confirming release...
+
+✓ Release uploaded successfully!
+──────────────────────────────────
+  ID: 693507a19f6d6a79267633e8
+  Label: v1.2.0
+  iOS Bundle: uploaded
+  Android Bundle: uploaded
+  Rollout: 100%
+  Mandatory: No
+  Status: active
+──────────────────────────────────
 ```
 
 ---
 
 ### `status`
 
-Check release status for an app or deployment.
+Check deployment status and recent releases.
 
 ```bash
 upflux status [options]
@@ -120,9 +178,28 @@ upflux status [options]
 
 | Option | Description |
 |--------|-------------|
-| `-a, --app <appId>` | Filter by application ID |
-| `-d, --deployment <deploymentId>` | Filter by deployment ID |
-| `-n, --limit <number>` | Number of releases to show (default: 10) |
+| `-n, --limit <number>` | Number of releases to show (default: 5) |
+
+**Example output:**
+```
+⚡ Fetching deployment status...
+
+╭────────────────────────────────────────────────╮
+│  📱 app-970384d3 → production                  │
+│  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  │
+│  Current Release: v1.2.0 (iOS & Android)       │
+│  Status: ● active • 100% rollout               │
+│  Published: 2h ago                             │
+╰────────────────────────────────────────────────╯
+
+📦 Recent Releases (15 total)
+
+  Label        Platform  Status      Rollout   Published
+  ────────────────────────────────────────────────────────
+  v1.2.0       all       ● active    100%      2h ago
+  v1.1.0       all       ○ expired   100%      3d ago
+  v1.0.0       ios       ○ expired   100%      1w ago
+```
 
 ---
 
@@ -139,6 +216,50 @@ upflux generate-manifest [options]
 | `-r, --release-id <id>` | ✓ | Release ID (MongoDB ObjectId) |
 | `-o, --output <path>` | | Save manifest to file |
 
+**Example:**
+```bash
+# Print manifest to stdout
+upflux generate-manifest --release-id 693507a19f6d6a79267633e8
+
+# Save to file
+upflux generate-manifest --release-id 693507a19f6d6a79267633e8 --output manifest.json
+```
+
+---
+
+## Scheduled Releases
+
+Schedule releases to go live at a specific date and time. Perfect for coordinating updates with marketing campaigns, feature launches, or maintenance windows.
+
+### How It Works
+
+1. Create a release with the `--schedule` flag
+2. The release is uploaded as a **Draft**
+3. Set the scheduled time in the Upflux Dashboard
+4. The release automatically goes live at the scheduled time
+
+### Creating a Scheduled Release
+
+```bash
+# Create a draft release for scheduling
+upflux release --label v2.0.0 --schedule
+
+# Output:
+# ✓ Release uploaded successfully!
+#   ...
+#   Status: DRAFT
+#   📅 Set schedule time in dashboard
+```
+
+### Use Cases
+
+- **Feature launches** - Coordinate with marketing announcements
+- **Global releases** - Release at optimal times for different regions
+- **Maintenance windows** - Deploy during low-traffic periods
+- **Campaign coordination** - Sync with promotional events
+
+> 💡 **Tip:** Combine scheduled releases with rollout percentages for safer deployments. For example, schedule a 10% rollout first, then manually increase after monitoring.
+
 ---
 
 ## Configuration
@@ -147,7 +268,7 @@ upflux generate-manifest [options]
 
 | Variable | Description | Default |
 |----------|-------------|---------|
-| `UPFLUX_API_URL` | API server URL | `http://localhost:3000/api` |
+| `UPFLUX_API_URL` | API server URL | `https://api.upflux.in/api` |
 
 ### Auth File
 
@@ -157,16 +278,14 @@ The CLI stores credentials in `.upflux` in the current directory:
 {
   "credentials": [
     {
-      "key": "pk_xxx...",
+      "key": "upflux_pub_xxx...",
       "appId": "app-970384d3",
-      "platform": "android",
       "deploymentId": "6933e683aa32fe18a1311bbb",
       "deploymentName": "production"
     },
     {
-      "key": "pk_yyy...",
+      "key": "upflux_pub_yyy...",
       "appId": "app-970384d3",
-      "platform": "android",
       "deploymentId": "6933e683aa32fe18a1311ccc",
       "deploymentName": "staging"
     }
@@ -175,6 +294,18 @@ The CLI stores credentials in `.upflux` in the current directory:
 }
 ```
 
+> ⚠️ **Important:** Never commit the `.upflux` file to version control. It contains your publish keys. Add it to your `.gitignore`.
+
+---
+
+## Publish Keys
+
+Publish keys are used to authenticate the CLI and can be found in the Upflux dashboard under **Settings → Keys**.
+
+Key format: `upflux_pub_<prefix>_<secret>`
+
+Example: `upflux_pub_prod_a1b2c3d4e5f6...`
+
 ---
 
 ## Development
@@ -190,6 +321,12 @@ pnpm run build
 node dist/index.js --help
 ```
 
+## Requirements
+
+- Node.js >= 18.0.0
+- For React Native projects: `react-native` CLI installed
+- For Capacitor projects: Built web assets in configured `webDir`
+
 ## License
 
 MIT

package/dist/client/apiClient.js

@@ -9,7 +9,8 @@ const configStore_1 = require("../config/configStore");
 /**
  * Default API base URL (can be overridden via environment variable)
  */
-const DEFAULT_BASE_URL = "https://api.upflux.in/api"; //"http://localhost:3000/api";
+// const DEFAULT_BASE_URL = "http://localhost:3000/api";
+const DEFAULT_BASE_URL = "https://api.upflux.in/api";
 console.log(process.env.UPFLUX_API_URL || DEFAULT_BASE_URL);
 exports.apiClient = axios_1.default.create({
     baseURL: process.env.UPFLUX_API_URL || DEFAULT_BASE_URL,

package/dist/client/directUpload.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Direct Upload Module
+ *
+ * Uploads files directly to R2/S3 using presigned URLs,
+ * bypassing Vercel's 4.5MB body size limit.
+ */
+interface UploadProgress {
+    filename: string;
+    loaded: number;
+    total: number;
+    percent: number;
+}
+/**
+ * Upload a single file to a presigned URL
+ */
+export declare function uploadToPresignedUrl(filePath: string, presignedUrl: string, contentType?: string, onProgress?: (progress: UploadProgress) => void): Promise<void>;
+interface FileManifestItem {
+    type: "bundle" | "asset";
+    platform?: "ios" | "android";
+    filename: string;
+    relativePath?: string;
+    localPath: string;
+    contentType?: string;
+    size?: number;
+}
+interface PresignedUrlResponse {
+    key: string;
+    uploadUrl: string;
+    publicUrl: string;
+    expiresIn: number;
+}
+/**
+ * Upload multiple files in parallel using presigned URLs
+ */
+export declare function uploadFilesWithPresignedUrls(files: FileManifestItem[], urls: PresignedUrlResponse[], options?: {
+    concurrency?: number;
+    onFileComplete?: (filename: string, index: number, total: number) => void;
+    onProgress?: (progress: UploadProgress) => void;
+}): Promise<void>;
+/**
+ * Guess content type from filename
+ */
+export declare function guessContentType(filename: string): string;
+/**
+ * Build file manifest from local bundle and asset paths
+ */
+export declare function buildFileManifest(platform: "ios" | "android" | "all", bundlePath?: string, assetFiles?: string[], iosBundlePath?: string, androidBundlePath?: string, iosAssetFiles?: string[], androidAssetFiles?: string[], assetsBaseDir?: string, iosAssetsBaseDir?: string, androidAssetsBaseDir?: string): FileManifestItem[];
+export {};

package/dist/client/directUpload.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Direct Upload Module
+ *
+ * Uploads files directly to R2/S3 using presigned URLs,
+ * bypassing Vercel's 4.5MB body size limit.
+ */
+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.uploadToPresignedUrl = uploadToPresignedUrl;
+exports.uploadFilesWithPresignedUrls = uploadFilesWithPresignedUrls;
+exports.guessContentType = guessContentType;
+exports.buildFileManifest = buildFileManifest;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const axios_1 = __importDefault(require("axios"));
+/**
+ * Upload a single file to a presigned URL
+ */
+async function uploadToPresignedUrl(filePath, presignedUrl, contentType = "application/octet-stream", onProgress) {
+    const stats = fs.statSync(filePath);
+    const fileStream = fs.createReadStream(filePath);
+    const filename = path.basename(filePath);
+    await axios_1.default.put(presignedUrl, fileStream, {
+        headers: {
+            "Content-Type": contentType,
+            "Content-Length": stats.size,
+        },
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+        onUploadProgress: (progressEvent) => {
+            if (onProgress && progressEvent.total) {
+                onProgress({
+                    filename,
+                    loaded: progressEvent.loaded,
+                    total: progressEvent.total,
+                    percent: Math.round((progressEvent.loaded / progressEvent.total) * 100),
+                });
+            }
+        },
+    });
+}
+/**
+ * Upload multiple files in parallel using presigned URLs
+ */
+async function uploadFilesWithPresignedUrls(files, urls, options) {
+    const { concurrency = 3, onFileComplete, onProgress } = options || {};
+    // Create a map of relativePath (or filename) to URL
+    // This handles duplicate filenames in different folders (e.g., drawable-mdpi/logo.png vs drawable-xhdpi/logo.png)
+    const urlMap = new Map();
+    for (const url of urls) {
+        // Extract relativePath from key (everything after release path)
+        // Key format: releases/appId/deployment/release/assets/drawable-mdpi/logo.png
+        const parts = url.key.split("/");
+        // Find where assets/ or android/ or ios/ starts to get the relativePath
+        let relativePath = parts[parts.length - 1]; // fallback to filename
+        for (let i = 0; i < parts.length; i++) {
+            if (parts[i] === 'assets' || parts[i] === 'android' || parts[i] === 'ios') {
+                relativePath = parts.slice(i).join('/');
+                break;
+            }
+        }
+        urlMap.set(relativePath, url);
+    }
+    // Upload files in batches
+    let completed = 0;
+    const total = files.length;
+    const uploadFile = async (file) => {
+        // Use relativePath for lookup if available, fallback to filename
+        const lookupKey = file.relativePath || file.filename;
+        const urlInfo = urlMap.get(lookupKey);
+        if (!urlInfo) {
+            throw new Error(`No presigned URL found for file: ${lookupKey}`);
+        }
+        await uploadToPresignedUrl(file.localPath, urlInfo.uploadUrl, file.contentType, onProgress);
+        completed++;
+        if (onFileComplete) {
+            onFileComplete(file.filename, completed, total);
+        }
+    };
+    // Process in batches for controlled concurrency
+    for (let i = 0; i < files.length; i += concurrency) {
+        const batch = files.slice(i, i + concurrency);
+        await Promise.all(batch.map(uploadFile));
+    }
+}
+/**
+ * Guess content type from filename
+ */
+function guessContentType(filename) {
+    var _a;
+    const ext = (_a = filename.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    const contentTypes = {
+        bundle: "application/javascript",
+        js: "application/javascript",
+        json: "application/json",
+        zip: "application/zip",
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        svg: "image/svg+xml",
+        webp: "image/webp",
+        ttf: "font/ttf",
+        woff: "font/woff",
+        woff2: "font/woff2",
+        css: "text/css",
+        html: "text/html",
+    };
+    return contentTypes[ext || ""] || "application/octet-stream";
+}
+/**
+ * Build file manifest from local bundle and asset paths
+ */
+function buildFileManifest(platform, bundlePath, assetFiles, iosBundlePath, androidBundlePath, iosAssetFiles, androidAssetFiles, 
+// Base directories for calculating relative paths
+assetsBaseDir, iosAssetsBaseDir, androidAssetsBaseDir) {
+    const files = [];
+    if (platform === "all") {
+        // Dual-bundle mode
+        if (iosBundlePath) {
+            const stats = fs.statSync(iosBundlePath);
+            files.push({
+                type: "bundle",
+                platform: "ios",
+                filename: path.basename(iosBundlePath),
+                localPath: iosBundlePath,
+                contentType: "application/javascript",
+                size: stats.size,
+            });
+        }
+        if (androidBundlePath) {
+            const stats = fs.statSync(androidBundlePath);
+            files.push({
+                type: "bundle",
+                platform: "android",
+                filename: path.basename(androidBundlePath),
+                localPath: androidBundlePath,
+                contentType: "application/javascript",
+                size: stats.size,
+            });
+        }
+        for (const assetPath of iosAssetFiles || []) {
+            // Calculate relative path from assets base directory
+            const relativePath = iosAssetsBaseDir
+                ? path.relative(iosAssetsBaseDir, assetPath)
+                : path.basename(assetPath);
+            files.push({
+                type: "asset",
+                platform: "ios",
+                filename: path.basename(assetPath),
+                relativePath,
+                localPath: assetPath,
+                contentType: guessContentType(assetPath),
+            });
+        }
+        for (const assetPath of androidAssetFiles || []) {
+            // Calculate relative path from assets base directory
+            const relativePath = androidAssetsBaseDir
+                ? path.relative(androidAssetsBaseDir, assetPath)
+                : path.basename(assetPath);
+            files.push({
+                type: "asset",
+                platform: "android",
+                filename: path.basename(assetPath),
+                relativePath,
+                localPath: assetPath,
+                contentType: guessContentType(assetPath),
+            });
+        }
+    }
+    else {
+        // Single-bundle mode
+        if (bundlePath) {
+            const stats = fs.statSync(bundlePath);
+            files.push({
+                type: "bundle",
+                filename: path.basename(bundlePath),
+                localPath: bundlePath,
+                contentType: "application/javascript",
+                size: stats.size,
+            });
+        }
+        for (const assetPath of assetFiles || []) {
+            // Calculate relative path from assets base directory
+            const relativePath = assetsBaseDir
+                ? path.relative(assetsBaseDir, assetPath)
+                : path.basename(assetPath);
+            files.push({
+                type: "asset",
+                filename: path.basename(assetPath),
+                relativePath,
+                localPath: assetPath,
+                contentType: guessContentType(assetPath),
+            });
+        }
+    }
+    return files;
+}

package/dist/commands/login.js

@@ -40,7 +40,6 @@ async function verifyKeyWithServer(key) {
         return {
             valid: true,
             appId: response.data.appId,
-            platform: response.data.platform,
             deploymentId: response.data.deploymentId,
             deploymentName: response.data.deploymentName,
         };
@@ -90,7 +89,6 @@ const login = new commander_1.Command("login")
         const credential = {
             key,
             appId: verification.appId,
-            platform: verification.platform,
             deploymentId: verification.deploymentId,
             deploymentName: verification.deploymentName,
         };
@@ -101,9 +99,6 @@ const login = new commander_1.Command("login")
             ? `${verification.deploymentName}`
             : verification.deploymentId;
         console.log(chalk_1.default.gray(`  App ID: ${verification.appId}`));
-        if (verification.platform) {
-            console.log(chalk_1.default.gray(`  Platform: ${verification.platform}`));
-        }
         console.log(chalk_1.default.gray(`  Deployment: ${deploymentDisplay}`));
         // Show all stored credentials
         const allCreds = configStore_1.configStore.getCredentials();

package/dist/commands/release.js

@@ -40,7 +40,6 @@ 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"));
@@ -215,7 +214,6 @@ function runBundler(options) {
     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}`,
@@ -261,7 +259,7 @@ const release = new commander_1.Command("release")
     .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("--platform <platform>", "Target platform for the release: all, ios, or android (defaults to all)", "all")
     .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")
@@ -275,7 +273,7 @@ const release = new commander_1.Command("release")
     .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;
+    var _a, _b;
     try {
         // ========================================
         // VALIDATION PHASE
@@ -312,30 +310,23 @@ const release = new commander_1.Command("release")
         else {
             // Multiple credentials - prompt for selection
             selectedCredential = await selectDeployment(credentials);
+            // Update activeIndex so subsequent commands use the same deployment
+            const selectedIndex = credentials.findIndex(c => c.deploymentId === selectedCredential.deploymentId);
+            if (selectedIndex >= 0) {
+                configStore_1.configStore.setActiveIndex(selectedIndex);
+            }
         }
         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())) {
+        // Validate platform
+        const platform = ((_a = opts.platform) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || 'all';
+        if (!['all', 'ios', 'android'].includes(platform)) {
             console.error(chalk_1.default.red(`✗ Invalid platform: ${platform}`));
-            console.error(chalk_1.default.gray(`Valid platforms: ${VALID_PLATFORMS.join(", ")}`));
+            console.error(chalk_1.default.gray("Valid values: all, ios, android"));
             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`));
@@ -376,6 +367,16 @@ const release = new commander_1.Command("release")
         // ========================================
         let bundlePath;
         let assetFiles = [];
+        // Dual-bundle variables
+        let iosBundlePath;
+        let androidBundlePath;
+        let iosAssetFiles = [];
+        let androidAssetFiles = [];
+        // Asset directories for calculating relative paths (preserves drawable-* structure)
+        // These point to the platform output directory (e.g., dist/android/) so paths include assets/
+        let assetsBaseDir;
+        let iosAssetsBaseDir;
+        let androidAssetsBaseDir;
         // Detect project type
         const isCapacitor = opts.capacitor || isCapacitorProject();
         if (isCapacitor) {
@@ -423,7 +424,7 @@ const release = new commander_1.Command("release")
             try {
                 fs.accessSync(bundlePath, fs.constants.R_OK);
             }
-            catch (_b) {
+            catch (_c) {
                 console.error(chalk_1.default.red(`✗ Cannot read bundle file: ${bundlePath}`));
                 process.exit(1);
             }
@@ -449,37 +450,104 @@ const release = new commander_1.Command("release")
                 }
             }
             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);
+            if (platform === 'all') {
+                // ========================================
+                // DUAL BUNDLING (iOS + Android)
+                // ========================================
+                if (!opts.skipBundle) {
+                    // Bundle for iOS
+                    console.log(chalk_1.default.blue("📦 Bundling for iOS..."));
+                    const iosOutputDir = path.join(outputDir, 'ios');
+                    fs.mkdirSync(iosOutputDir, { recursive: true });
+                    const iosResult = runBundler({
+                        platform: 'ios',
+                        entryFile: opts.entryFile,
+                        outputDir: iosOutputDir,
+                        dev: opts.dev,
+                    });
+                    iosBundlePath = iosResult.bundlePath;
+                    console.log(chalk_1.default.green(`  ✓ iOS bundle created`));
+                    // Bundle for Android
+                    console.log(chalk_1.default.blue("📦 Bundling for Android..."));
+                    const androidOutputDir = path.join(outputDir, 'android');
+                    fs.mkdirSync(androidOutputDir, { recursive: true });
+                    const androidResult = runBundler({
+                        platform: 'android',
+                        entryFile: opts.entryFile,
+                        outputDir: androidOutputDir,
+                        dev: opts.dev,
+                    });
+                    androidBundlePath = androidResult.bundlePath;
+                    console.log(chalk_1.default.green(`  ✓ Android bundle created`));
                 }
-                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 {
+                    // Skip bundle - use existing
+                    const iosOutputDir = path.join(outputDir, 'ios');
+                    const androidOutputDir = path.join(outputDir, 'android');
+                    iosBundlePath = path.join(iosOutputDir, 'index.ios.bundle');
+                    androidBundlePath = path.join(androidOutputDir, 'index.android.bundle');
+                    if (!fs.existsSync(iosBundlePath) || !fs.existsSync(androidBundlePath)) {
+                        console.error(chalk_1.default.red(`✗ Bundle not found for both platforms`));
+                        console.error(chalk_1.default.gray(`Expected: ${iosBundlePath} and ${androidBundlePath}`));
+                        process.exit(1);
+                    }
+                }
+                // Collect assets for iOS - base dir is the ios output dir so paths include assets/
+                const iosOutputDir = path.dirname(iosBundlePath);
+                iosAssetsBaseDir = iosOutputDir;
+                const iosAssetsPath = path.join(iosOutputDir, 'assets');
+                iosAssetFiles = opts.assets
+                    ? opts.assets.map((p) => path.resolve(p))
+                    : collectAssets(iosAssetsPath);
+                // Collect assets for Android - base dir is the android output dir so paths include assets/
+                const androidOutputDir = path.dirname(androidBundlePath);
+                androidAssetsBaseDir = androidOutputDir;
+                const androidAssetsPath = path.join(androidOutputDir, 'assets');
+                androidAssetFiles = opts.assets
+                    ? opts.assets.map((p) => path.resolve(p))
+                    : collectAssets(androidAssetsPath);
+                // Set bundlePath and assetFiles for display (use iOS as primary for logging)
+                bundlePath = iosBundlePath;
+                assetFiles = [...iosAssetFiles, ...androidAssetFiles];
             }
             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));
+                // ========================================
+                // SINGLE PLATFORM BUNDLING
+                // ========================================
+                const expectedBundle = path.join(outputDir, `index.${platform}.bundle`);
+                // Base dir is outputDir so relative paths include assets/ folder
+                assetsBaseDir = outputDir;
+                const assetsPath = 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(assetsPath);
+                }
+                // 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));
+                }
             }
         }
         // ========================================
@@ -501,51 +569,120 @@ const release = new commander_1.Command("release")
         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);
+        // ========================================
+        // PRESIGNED URL UPLOAD FLOW
+        // ========================================
+        // This flow bypasses Vercel's 4.5MB body size limit by:
+        // 1. Requesting presigned URLs from the API
+        // 2. Uploading files directly to R2
+        // 3. Confirming upload completion
+        const { buildFileManifest, uploadFilesWithPresignedUrls } = await Promise.resolve().then(() => __importStar(require("../client/directUpload")));
+        // Build file manifest for presigned URL request
+        const fileManifest = buildFileManifest(platform, platform !== 'all' ? bundlePath : undefined, platform !== 'all' ? assetFiles : undefined, platform === 'all' ? iosBundlePath : undefined, platform === 'all' ? androidBundlePath : undefined, platform === 'all' ? iosAssetFiles : undefined, platform === 'all' ? androidAssetFiles : undefined, 
+        // Asset base directories for relative path calculation
+        platform !== 'all' ? assetsBaseDir : undefined, platform === 'all' ? iosAssetsBaseDir : undefined, platform === 'all' ? androidAssetsBaseDir : undefined);
+        console.log(chalk_1.default.blue("\n📋 Step 1/3: Requesting upload URLs..."));
+        // Step 1: Request presigned URLs
+        const initResponse = await apiClient_1.apiClient.post("/cli/releases/upload/init", {
+            appId,
+            deploymentId,
+            releaseLabel: opts.label,
+            platform,
+            files: fileManifest.map(f => ({
+                type: f.type,
+                platform: f.platform,
+                filename: f.filename,
+                relativePath: f.relativePath, // Preserves folder structure like drawable-mdpi/logo.png
+                contentType: f.contentType,
+            })),
+        }, {
+            headers: {
+                "x-publish-key": authKey,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!initResponse.data.success) {
+            throw new Error("Failed to initialize upload");
         }
-        // Add asset files
-        for (const assetPath of assetFiles) {
-            form.append("assets", fs.createReadStream(assetPath));
+        console.log(chalk_1.default.green(`   ✓ Got ${initResponse.data.urls.length} presigned URLs`));
+        console.log(chalk_1.default.blue("\n📤 Step 2/3: Uploading files directly to storage..."));
+        // Step 2: Upload files directly to R2
+        let uploadedCount = 0;
+        await uploadFilesWithPresignedUrls(fileManifest, initResponse.data.urls, {
+            concurrency: 3,
+            onFileComplete: (filename, index, total) => {
+                uploadedCount++;
+                console.log(chalk_1.default.gray(`   [${uploadedCount}/${total}] ${filename}`));
+            },
+        });
+        console.log(chalk_1.default.green(`   ✓ Uploaded ${fileManifest.length} files`));
+        console.log(chalk_1.default.blue("\n✅ Step 3/3: Confirming release..."));
+        // Calculate bundle sizes from manifest
+        const bundleSizes = {};
+        for (const file of fileManifest) {
+            if (file.type === 'bundle' && file.size) {
+                if (file.platform === 'ios') {
+                    bundleSizes.ios = file.size;
+                }
+                else if (file.platform === 'android') {
+                    bundleSizes.android = file.size;
+                }
+                else {
+                    bundleSizes.single = file.size;
+                }
+            }
         }
-        // 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 }),
+        // Step 3: Complete upload and create release record
+        const completeResponse = await apiClient_1.apiClient.post("/cli/releases/upload/complete", {
+            uploadId: initResponse.data.uploadId,
+            releaseLabel: opts.label,
+            mandatory: opts.mandatory,
+            rolloutPercentage: rolloutValidation.value,
+            binaryVersionRange: opts.versionRange,
+            platform,
+            isDraft: opts.schedule,
+            // Include bundle sizes
+            iosBundleSize: bundleSizes.ios,
+            androidBundleSize: bundleSizes.android || bundleSizes.single,
+        }, {
+            headers: {
+                "x-publish-key": authKey,
+                "Content-Type": "application/json",
+            },
         });
+        if (!completeResponse.data.success) {
+            throw new Error("Failed to complete upload");
+        }
+        const releaseData = completeResponse.data.data;
         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(`  ID: ${releaseData.id}`);
+        console.log(`  Label: ${releaseData.releaseLabel}`);
+        // Display bundle URLs based on platform
+        if (platform === 'all') {
+            console.log(`  iOS Bundle: ${releaseData.iosBundleUrl || 'uploaded'}`);
+            console.log(`  Android Bundle: ${releaseData.androidBundleUrl || 'uploaded'}`);
+        }
+        else {
+            console.log(`  Bundle URL: ${releaseData.bundleUrl || releaseData.iosBundleUrl || releaseData.androidBundleUrl}`);
+        }
+        console.log(`  Rollout: ${releaseData.rolloutPercentage}%`);
+        console.log(`  Mandatory: ${releaseData.mandatory ? "Yes" : "No"}`);
+        if (releaseData.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'}`);
+            console.log(`  Status: ${releaseData.status || 'active'}`);
         }
-        if (response.data.binaryVersionRange) {
-            console.log(`  Version Range: ${response.data.binaryVersionRange}`);
+        if (releaseData.binaryVersionRange) {
+            console.log(`  Version Range: ${releaseData.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) {
+        if ((_b = error.response) === null || _b === void 0 ? void 0 : _b.data) {
             console.error(chalk_1.default.gray(JSON.stringify(error.response.data, null, 2)));
         }
         process.exit(1);

package/dist/commands/status.js

@@ -5,85 +5,189 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
 const apiClient_1 = require("../client/apiClient");
+const configStore_1 = require("../config/configStore");
 /**
- * Validate MongoDB ObjectId format
+ * Format relative time (e.g., "2 hours ago")
  */
-function isValidObjectId(id) {
-    return /^[a-fA-F0-9]{24}$/.test(id);
+function formatRelativeTime(dateStr) {
+    const date = new Date(dateStr);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffSecs = Math.floor(diffMs / 1000);
+    const diffMins = Math.floor(diffSecs / 60);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffDays > 0)
+        return `${diffDays}d ago`;
+    if (diffHours > 0)
+        return `${diffHours}h ago`;
+    if (diffMins > 0)
+        return `${diffMins}m ago`;
+    return "just now";
 }
 /**
- * Validate app ID format (alphanumeric with hyphens)
+ * Select deployment from multiple credentials
  */
-function isValidAppId(appId) {
-    return /^[a-zA-Z0-9-_]+$/.test(appId) && appId.length >= 3;
+async function selectDeployment(credentials) {
+    if (credentials.length === 1) {
+        return credentials[0];
+    }
+    const choices = credentials.map((cred) => ({
+        name: `${cred.deploymentName || cred.deploymentId} (${cred.appId})`,
+        value: cred,
+    }));
+    const { selected } = await inquirer_1.default.prompt([
+        {
+            type: "list",
+            name: "selected",
+            message: "Select deployment to check status:",
+            choices,
+        }
+    ]);
+    return selected;
+}
+/**
+ * Draw a box around text
+ */
+function drawBox(lines, width = 50) {
+    const output = [];
+    const border = "─".repeat(width - 2);
+    output.push(chalk_1.default.gray(`╭${border}╮`));
+    for (const line of lines) {
+        // Strip ANSI codes for length calculation
+        const plainLine = line.replace(/\x1b\[[0-9;]*m/g, "");
+        const padding = width - 4 - plainLine.length;
+        output.push(chalk_1.default.gray("│") + "  " + line + " ".repeat(Math.max(0, padding)) + chalk_1.default.gray("│"));
+    }
+    output.push(chalk_1.default.gray(`╰${border}╯`));
+    return output;
+}
+/**
+ * Get status indicator
+ */
+function getStatusIndicator(status) {
+    switch (status) {
+        case "active":
+            return chalk_1.default.green("●");
+        case "scheduled":
+            return chalk_1.default.yellow("◐");
+        case "expired":
+            return chalk_1.default.gray("○");
+        case "draft":
+            return chalk_1.default.blue("◑");
+        default:
+            return chalk_1.default.gray("○");
+    }
 }
 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")
+    .description("Check deployment status and releases")
+    .option("-n, --limit <number>", "Number of releases to show", "5")
     .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"));
+        // 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: 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);
+        // Select or determine credential to use
+        let selectedCredential;
+        if (credentials.length === 1) {
+            selectedCredential = credentials[0];
         }
-        // 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);
+        else {
+            selectedCredential = await selectDeployment(credentials);
+            // Update activeIndex
+            const selectedIndex = credentials.findIndex(c => c.deploymentId === selectedCredential.deploymentId);
+            if (selectedIndex >= 0) {
+                configStore_1.configStore.setActiveIndex(selectedIndex);
+            }
         }
-        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."));
+        console.log(chalk_1.default.blue("\n⚡ Fetching deployment status...\n"));
+        // Fetch status from API
+        const response = await apiClient_1.apiClient.get("/cli/status");
+        const data = response.data;
+        // ========================================
+        // DEPLOYMENT HEADER
+        // ========================================
+        const headerLines = [];
+        headerLines.push(chalk_1.default.bold(`📱 ${data.deployment.appId} → ${data.deployment.name}`));
+        headerLines.push(chalk_1.default.gray("━".repeat(40)));
+        // Show current releases
+        if (data.current.ios || data.current.android) {
+            if (data.current.ios && data.current.android) {
+                // Dual platform
+                if (data.current.ios.releaseLabel === data.current.android.releaseLabel) {
+                    // Same version for both
+                    headerLines.push(`Current Release: ${chalk_1.default.cyan(data.current.ios.releaseLabel)} ${chalk_1.default.gray("(iOS & Android)")}`);
+                    headerLines.push(`Status: ${getStatusIndicator(data.current.ios.status)} ${data.current.ios.status} • ${data.current.ios.rolloutPercentage}% rollout`);
+                    headerLines.push(`Published: ${formatRelativeTime(data.current.ios.publishedAt)}`);
+                }
+                else {
+                    // Different versions
+                    headerLines.push(`iOS: ${chalk_1.default.cyan(data.current.ios.releaseLabel)} ${getStatusIndicator(data.current.ios.status)} ${data.current.ios.rolloutPercentage}%`);
+                    headerLines.push(`Android: ${chalk_1.default.cyan(data.current.android.releaseLabel)} ${getStatusIndicator(data.current.android.status)} ${data.current.android.rolloutPercentage}%`);
+                }
+            }
+            else if (data.current.ios) {
+                headerLines.push(`iOS: ${chalk_1.default.cyan(data.current.ios.releaseLabel)} ${getStatusIndicator(data.current.ios.status)}`);
+                headerLines.push(`${data.current.ios.rolloutPercentage}% rollout • ${formatRelativeTime(data.current.ios.publishedAt)}`);
+            }
+            else if (data.current.android) {
+                headerLines.push(`Android: ${chalk_1.default.cyan(data.current.android.releaseLabel)} ${getStatusIndicator(data.current.android.status)}`);
+                headerLines.push(`${data.current.android.rolloutPercentage}% rollout • ${formatRelativeTime(data.current.android.publishedAt)}`);
             }
-            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}`));
+        else {
+            headerLines.push(chalk_1.default.yellow("No active release"));
+        }
+        // Draw the header box
+        const headerBox = drawBox(headerLines, 52);
+        headerBox.forEach(line => console.log(line));
+        // ========================================
+        // RELEASES TABLE
+        // ========================================
+        const limit = parseInt(opts.limit, 10) || 5;
+        const releases = data.releases.slice(0, limit);
+        if (releases.length > 0) {
+            console.log(chalk_1.default.bold(`\n📦 Recent Releases (${data.totalReleases} total)\n`));
+            // Table header
+            console.log(chalk_1.default.gray("  ") +
+                chalk_1.default.white.bold("Label".padEnd(12)) +
+                chalk_1.default.white.bold("Platform".padEnd(10)) +
+                chalk_1.default.white.bold("Status".padEnd(12)) +
+                chalk_1.default.white.bold("Rollout".padEnd(10)) +
+                chalk_1.default.white.bold("Published"));
+            console.log(chalk_1.default.gray("  " + "─".repeat(60)));
+            // Table rows
+            releases.forEach((release, index) => {
+                const statusIcon = getStatusIndicator(release.status);
+                const statusText = release.status.padEnd(10);
+                const platformText = release.platform.padEnd(10);
+                const rolloutText = `${release.rolloutPercentage}%`.padEnd(10);
+                const mandatoryFlag = release.mandatory ? chalk_1.default.red(" !") : "";
+                console.log(chalk_1.default.gray("  ") +
+                    chalk_1.default.cyan(release.releaseLabel.padEnd(12)) +
+                    chalk_1.default.gray(platformText) +
+                    statusIcon + " " + chalk_1.default.white(statusText) +
+                    chalk_1.default.yellow(rolloutText) +
+                    chalk_1.default.gray(formatRelativeTime(release.createdAt)) +
+                    mandatoryFlag);
+            });
+            if (data.totalReleases > limit) {
+                console.log(chalk_1.default.gray(`\n  ... and ${data.totalReleases - limit} more. Use --limit to see more.`));
             }
-            console.log("");
-        });
-        if (releases.length > limit) {
-            console.log(chalk_1.default.gray(`... and ${releases.length - limit} more. Use --limit to see more.`));
         }
+        else {
+            console.log(chalk_1.default.yellow("\nNo releases found."));
+        }
+        console.log(""); // Empty line at end
     }
     catch (error) {
-        console.error(chalk_1.default.red(`\n✗ Failed to fetch releases: ${error.message}`));
+        console.error(chalk_1.default.red(`\n✗ Failed to fetch status: ${error.message}`));
         process.exit(1);
     }
 });

package/dist/config/configStore.d.ts

@@ -4,7 +4,6 @@
 export interface Credential {
     key: string;
     appId: string;
-    platform?: 'ios' | 'android';
     deploymentId: string;
     deploymentName?: string;
 }

package/dist/index.js

@@ -14,7 +14,7 @@ const program = new commander_1.Command();
 program
     .name("upflux")
     .description("Upflux CLI for OTA updates")
-    .version("0.0.1");
+    .version("0.1.0-beta.1");
 program.addCommand(login_1.default);
 program.addCommand(logout_1.default);
 program.addCommand(release_1.default);

package/dist/types/index.d.ts

@@ -20,8 +20,15 @@ export interface ReleaseManifest {
 export interface ReleaseResponse {
     id: string;
     releaseLabel: string;
-    bundleUrl: string;
-    assets: string[];
+    bundleUrl?: string;
+    assets?: string[];
+    iosBundleUrl?: string;
+    androidBundleUrl?: string;
+    iosBundleSize?: number;
+    androidBundleSize?: number;
+    iosAssets?: string[];
+    androidAssets?: string[];
+    platform?: 'all' | 'ios' | 'android';
     rolloutPercentage: number;
     mandatory: boolean;
     binaryVersionRange?: string;
@@ -73,7 +80,7 @@ export interface AppResponse {
     id: string;
     appId: string;
     name: string;
-    platform: string;
+    sdkType: string;
     createdAt: string;
     updatedAt?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@upfluxhq/cli",
-    "version": "0.1.0-beta.1",
+    "version": "0.1.0-beta.3",
     "description": "Upflux CLI for managing OTA updates",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",