swiftpatch-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,4942 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/lib/config.ts
+import Conf from "conf";
+var store, config;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    store = new Conf({
+      projectName: "swiftpatch-cli-config"
+    });
+    config = {
+      get(key) {
+        return store.get(key);
+      },
+      set(key, value) {
+        store.set(key, value);
+      },
+      delete(key) {
+        store.delete(key);
+      },
+      getAll() {
+        return store.store;
+      },
+      clear() {
+        store.clear();
+      },
+      get path() {
+        return store.path;
+      }
+    };
+  }
+});
+
+// src/lib/api.ts
+var api_exports = {};
+__export(api_exports, {
+  api: () => api
+});
+import axios from "axios";
+function warnIfInsecure(url) {
+  if (url.startsWith("http://") && !url.includes("localhost") && !url.includes("127.0.0.1")) {
+    console.warn(
+      "\x1B[33m\u26A0 Warning: API URL uses HTTP instead of HTTPS. This is insecure for production use.\x1B[0m"
+    );
+  }
+}
+function normalizeIds(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (Array.isArray(obj)) return obj.map(normalizeIds);
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "_id") {
+        result["id"] = value;
+      } else if (key === "__v") {
+        continue;
+      } else {
+        result[key] = normalizeIds(value);
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+var API_BASE_URL, ApiClient, api;
+var init_api = __esm({
+  "src/lib/api.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_auth();
+    init_config();
+    API_BASE_URL = process.env.SWIFTPATCH_API_URL || "https://swiftpatch.hyperbrainlabs.com/api/v1";
+    ApiClient = class {
+      client;
+      constructor() {
+        const baseURL = config.get("apiUrl") || API_BASE_URL;
+        warnIfInsecure(baseURL);
+        this.client = axios.create({
+          baseURL,
+          timeout: 3e4,
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": "swiftpatch-cli/1.0.0"
+          }
+        });
+        this.client.interceptors.request.use((reqConfig) => {
+          const authHeaders = auth.getAuthHeader();
+          Object.assign(reqConfig.headers, authHeaders);
+          return reqConfig;
+        });
+        this.client.interceptors.response.use(
+          (response) => response,
+          (error) => {
+            if (error.response) {
+              const data = error.response.data;
+              const message = data?.error?.message || error.message;
+              if (error.response.status === 401) {
+                throw new Error("Authentication failed. Please run: swiftpatch login");
+              }
+              throw new Error(message);
+            }
+            throw error;
+          }
+        );
+      }
+      // AUTH
+      async createLoginSession() {
+        const { data } = await this.client.post("/auth/cli/session");
+        return normalizeIds(data.data);
+      }
+      async checkLoginSession(sessionId) {
+        const { data } = await this.client.get(`/auth/cli/session/${sessionId}`);
+        return normalizeIds(data.data);
+      }
+      // USER
+      async getCurrentUser() {
+        const { data } = await this.client.get("/auth/me");
+        return normalizeIds(data.data);
+      }
+      async getOrganizations() {
+        const { data } = await this.client.get("/orgs");
+        return normalizeIds(data.data);
+      }
+      // APPS (org-scoped)
+      async getApps(orgId) {
+        const { data } = await this.client.get(`/orgs/${orgId}/apps`);
+        return normalizeIds(data.data);
+      }
+      async getApp(orgId, appId) {
+        const { data } = await this.client.get(`/orgs/${orgId}/apps/${appId}`);
+        return normalizeIds(data.data);
+      }
+      async createApp(orgId, params) {
+        const { data } = await this.client.post(`/orgs/${orgId}/apps`, params);
+        return normalizeIds(data.data);
+      }
+      async updateApp(orgId, appId, params) {
+        const { data } = await this.client.patch(`/orgs/${orgId}/apps/${appId}`, params);
+        return normalizeIds(data.data);
+      }
+      async deleteApp(orgId, appId) {
+        await this.client.delete(`/orgs/${orgId}/apps/${appId}`);
+      }
+      // RELEASES (org-scoped)
+      async getReleases(orgId, appId, params) {
+        const { data } = await this.client.get(`/orgs/${orgId}/apps/${appId}/releases`, { params });
+        const normalized = normalizeIds(data);
+        return {
+          releases: normalized.data || [],
+          pagination: normalized.pagination
+        };
+      }
+      async getRelease(orgId, appId, releaseId) {
+        const { data } = await this.client.get(`/orgs/${orgId}/apps/${appId}/releases/${releaseId}`);
+        return normalizeIds(data.data?.release || data.data);
+      }
+      async createRelease(orgId, appId, params) {
+        const { data } = await this.client.post(`/orgs/${orgId}/apps/${appId}/releases`, params);
+        return normalizeIds(data.data?.release || data.data);
+      }
+      async completeUpload(orgId, appId, releaseId, params) {
+        const { data } = await this.client.post(
+          `/orgs/${orgId}/apps/${appId}/releases/${releaseId}/upload-complete`,
+          params
+        );
+        return normalizeIds(data.data?.release || data.data);
+      }
+      async publishRelease(orgId, appId, releaseId, params) {
+        const { data } = await this.client.post(
+          `/orgs/${orgId}/apps/${appId}/releases/${releaseId}/publish`,
+          params
+        );
+        return normalizeIds(data.data?.release || data.data);
+      }
+      async updateRollout(orgId, appId, releaseId, rolloutPercent) {
+        const { data } = await this.client.patch(
+          `/orgs/${orgId}/apps/${appId}/releases/${releaseId}/rollout`,
+          { rolloutPercent }
+        );
+        return normalizeIds(data.data?.release || data.data);
+      }
+      async disableRelease(orgId, appId, releaseId, reason) {
+        const { data } = await this.client.post(
+          `/orgs/${orgId}/apps/${appId}/releases/${releaseId}/disable`,
+          { reason }
+        );
+        return normalizeIds(data.data?.release || data.data);
+      }
+      async rollbackRelease(orgId, appId, releaseId, reason) {
+        const { data } = await this.client.post(
+          `/orgs/${orgId}/apps/${appId}/releases/${releaseId}/rollback`,
+          { reason }
+        );
+        return normalizeIds(data.data?.release || data.data);
+      }
+      // CHANNELS (org-scoped)
+      async getChannels(orgId, appId) {
+        const { data } = await this.client.get(`/orgs/${orgId}/apps/${appId}/channels`);
+        return normalizeIds(data.data);
+      }
+      async createChannel(orgId, appId, params) {
+        const { data } = await this.client.post(`/orgs/${orgId}/apps/${appId}/channels`, params);
+        return normalizeIds(data.data);
+      }
+      async updateChannel(orgId, appId, channelId, params) {
+        const { data } = await this.client.patch(`/orgs/${orgId}/apps/${appId}/channels/${channelId}`, params);
+        return normalizeIds(data.data);
+      }
+      async deleteChannel(orgId, appId, channelId) {
+        await this.client.delete(`/orgs/${orgId}/apps/${appId}/channels/${channelId}`);
+      }
+      // ANALYTICS (org-scoped)
+      async getAnalytics(orgId, appId, params) {
+        const { data } = await this.client.get(`/orgs/${orgId}/apps/${appId}/analytics/overview`, { params });
+        return normalizeIds(data.data);
+      }
+      // ── AI ENDPOINTS ────────────────────────────────────────────────
+      getBaseUrl() {
+        return this.client.defaults.baseURL || API_BASE_URL;
+      }
+      getAuthHeaders() {
+        return auth.getAuthHeader();
+      }
+      async aiRiskAssessment(orgId, appId, releaseId) {
+        const { data } = await this.client.post(
+          `/orgs/${orgId}/apps/${appId}/releases/${releaseId}/ai/risk-assessment`
+        );
+        return normalizeIds(data.data);
+      }
+      async aiCrashGroups(orgId, appId, params) {
+        const { data } = await this.client.get(`/orgs/${orgId}/apps/${appId}/ai/crash-groups`, { params });
+        return normalizeIds(data.data);
+      }
+      async aiInsights(orgId, appId, params) {
+        const { data } = await this.client.get(`/orgs/${orgId}/apps/${appId}/ai/insights`, { params });
+        return normalizeIds(data.data);
+      }
+      // ── CLAUDE AI KEY (platform-provisioned) ──────────────────────
+      async getClaudeApiKey() {
+        const { data } = await this.client.get("/ai/claude-key");
+        return normalizeIds(data.data);
+      }
+      // ── CLI ENDPOINTS ──────────────────────────────────────────────
+      /**
+       * Generate a signed S3 URL for bundle upload.
+       * Uses /cli/gen-signed-url (user auth) or /cli/ci/gen-signed-url (CI token auth).
+       */
+      async generateSignedUrl(params, ciToken) {
+        const headers = {};
+        const endpoint = ciToken ? "/cli/ci/gen-signed-url" : "/cli/gen-signed-url";
+        if (ciToken) {
+          headers["x-ci-token"] = ciToken;
+        }
+        const { data } = await this.client.post(endpoint, params, { headers });
+        return normalizeIds(data.data);
+      }
+      /**
+       * Promote a published bundle to a release.
+       */
+      async promoteBundle(params, ciToken) {
+        const { data } = await this.client.post("/cli/ci/promote", params, {
+          headers: { "x-ci-token": ciToken }
+        });
+        return normalizeIds(data.data);
+      }
+      /**
+       * Update an existing release via CLI.
+       */
+      async updateReleaseCli(params, ciToken) {
+        const { data } = await this.client.post("/cli/ci/update-release", params, {
+          headers: { "x-ci-token": ciToken }
+        });
+        return normalizeIds(data.data);
+      }
+      // ── CI TOKENS ─────────────────────────────────────────────────
+      async getCITokens(orgId, appId) {
+        const { data } = await this.client.get(`/orgs/${orgId}/apps/${appId}/ci-tokens`);
+        return normalizeIds(data.data);
+      }
+      async createCIToken(orgId, appId, name) {
+        const { data } = await this.client.post(`/orgs/${orgId}/apps/${appId}/ci-tokens`, { name });
+        return normalizeIds(data.data);
+      }
+      async deleteCIToken(orgId, appId, tokenId) {
+        await this.client.delete(`/orgs/${orgId}/apps/${appId}/ci-tokens/${tokenId}`);
+      }
+      async regenerateCIToken(orgId, appId, tokenId) {
+        const { data } = await this.client.post(`/orgs/${orgId}/apps/${appId}/ci-tokens/${tokenId}/regenerate`);
+        return normalizeIds(data.data);
+      }
+      // ── WEBHOOKS ──────────────────────────────────────────────────
+      async getWebhooks(orgId) {
+        const { data } = await this.client.get(`/orgs/${orgId}/webhooks`);
+        return normalizeIds(data.data);
+      }
+      async createWebhook(orgId, params) {
+        const { data } = await this.client.post(`/orgs/${orgId}/webhooks`, params);
+        return normalizeIds(data.data);
+      }
+      async updateWebhook(orgId, webhookId, params) {
+        const { data } = await this.client.patch(`/orgs/${orgId}/webhooks/${webhookId}`, params);
+        return normalizeIds(data.data);
+      }
+      async deleteWebhook(orgId, webhookId) {
+        await this.client.delete(`/orgs/${orgId}/webhooks/${webhookId}`);
+      }
+      async testWebhook(orgId, webhookId) {
+        const { data } = await this.client.post(`/orgs/${orgId}/webhooks/${webhookId}/test`);
+        return normalizeIds(data.data);
+      }
+    };
+    api = new ApiClient();
+  }
+});
+
+// src/lib/auth.ts
+import Conf2 from "conf";
+import crypto from "crypto";
+import os from "os";
+function deriveEncryptionKey() {
+  const material = [
+    os.hostname(),
+    os.userInfo().username,
+    os.homedir(),
+    "swiftpatch-cli"
+  ].join(":");
+  return crypto.createHash("sha256").update(material).digest("hex");
+}
+function createStore() {
+  try {
+    return new Conf2({
+      projectName: "swiftpatch-cli",
+      encryptionKey: deriveEncryptionKey()
+    });
+  } catch {
+    const fresh = new Conf2({
+      projectName: "swiftpatch-cli",
+      encryptionKey: deriveEncryptionKey()
+    });
+    fresh.clear();
+    return fresh;
+  }
+}
+var store2, auth;
+var init_auth = __esm({
+  "src/lib/auth.ts"() {
+    "use strict";
+    init_esm_shims();
+    store2 = createStore();
+    auth = {
+      isLoggedIn() {
+        return !!(store2.get("token") || store2.get("apiKey"));
+      },
+      getToken() {
+        return store2.get("token") || store2.get("apiKey");
+      },
+      getAuthHeader() {
+        const token = this.getToken();
+        if (!token) return {};
+        return { Authorization: `Bearer ${token}` };
+      },
+      saveToken(token) {
+        store2.set("token", token);
+        store2.delete("apiKey");
+      },
+      async loginWithApiKey(apiKey) {
+        const originalToken = store2.get("token");
+        const originalApiKey = store2.get("apiKey");
+        store2.set("apiKey", apiKey);
+        store2.delete("token");
+        try {
+          const { api: api2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+          await api2.getCurrentUser();
+          return true;
+        } catch (error) {
+          if (originalToken) store2.set("token", originalToken);
+          else store2.delete("token");
+          if (originalApiKey) store2.set("apiKey", originalApiKey);
+          else store2.delete("apiKey");
+          throw error;
+        }
+      },
+      saveUser(user) {
+        store2.set("user", user);
+      },
+      getUser() {
+        return store2.get("user");
+      },
+      logout() {
+        store2.delete("token");
+        store2.delete("apiKey");
+        store2.delete("user");
+      },
+      getClaudeApiKey() {
+        return store2.get("claudeApiKey");
+      },
+      setClaudeApiKey(key) {
+        store2.set("claudeApiKey", key);
+      },
+      deleteClaudeApiKey() {
+        store2.delete("claudeApiKey");
+      },
+      getConfigPath() {
+        return store2.path;
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/cli.ts
+init_esm_shims();
+import { Command as Command47 } from "commander";
+import chalk45 from "chalk";
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/commands/login.ts
+init_esm_shims();
+init_auth();
+init_api();
+import { Command } from "commander";
+import chalk2 from "chalk";
+import inquirer from "inquirer";
+import open from "open";
+import ora from "ora";
+
+// src/utils/logger.ts
+init_esm_shims();
+import chalk from "chalk";
+import figures from "figures";
+var logger = {
+  info(message) {
+    console.log(chalk.blue(figures.info) + " " + message);
+  },
+  success(message) {
+    console.log(chalk.green(figures.tick) + " " + message);
+  },
+  warning(message) {
+    console.log(chalk.yellow(figures.warning) + " " + message);
+  },
+  error(message) {
+    console.log(chalk.red(figures.cross) + " " + message);
+  },
+  debug(message) {
+    if (process.env.DEBUG) {
+      console.log(chalk.gray(figures.pointer) + " " + chalk.gray(message));
+    }
+  },
+  blank() {
+    console.log("");
+  },
+  divider() {
+    console.log(chalk.gray("\u2500".repeat(50)));
+  }
+};
+
+// src/commands/login.ts
+var loginCommand = new Command("login").description("Authenticate with SwiftPatch").option("-k, --api-key <key>", "Login with API key (for CI/CD)").option("-i, --interactive", "Force interactive login").action(async (options) => {
+  const existingToken = auth.getToken();
+  if (existingToken && !options.interactive && !options.apiKey) {
+    const user = await api.getCurrentUser().catch(() => null);
+    if (user) {
+      logger.info(`Already logged in as ${chalk2.cyan(user.email)}`);
+      const { reauth } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "reauth",
+          message: "Do you want to log in with a different account?",
+          default: false
+        }
+      ]);
+      if (!reauth) return;
+    }
+  }
+  if (options.apiKey) {
+    const spinner = ora("Validating API key...").start();
+    try {
+      const isValid = await auth.loginWithApiKey(options.apiKey);
+      if (isValid) {
+        spinner.succeed("Logged in with API key");
+        const user = await api.getCurrentUser();
+        logger.success(`Authenticated as ${chalk2.cyan(user.email)}`);
+      } else {
+        spinner.fail("Invalid API key");
+        process.exit(1);
+      }
+    } catch (error) {
+      spinner.fail(`Login failed: ${error.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+  const { method } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "method",
+      message: "How would you like to authenticate?",
+      choices: [
+        { name: "Login with browser (recommended)", value: "browser" },
+        { name: "Enter API key", value: "apikey" }
+      ]
+    }
+  ]);
+  if (method === "browser") {
+    await browserLogin();
+  } else {
+    await apiKeyLogin();
+  }
+});
+async function browserLogin() {
+  const spinner = ora("Opening browser...").start();
+  try {
+    const { sessionId, loginUrl } = await api.createLoginSession();
+    spinner.text = "Waiting for authentication...";
+    await open(loginUrl);
+    logger.info(`
+If browser doesn't open, visit:
+${chalk2.cyan(loginUrl)}
+`);
+    const token = await pollForToken(sessionId, spinner);
+    auth.saveToken(token);
+    spinner.succeed("Login successful!");
+    const user = await api.getCurrentUser();
+    console.log("");
+    logger.success(`Welcome, ${chalk2.bold(user.name)}!`);
+    logger.info(`Email: ${chalk2.cyan(user.email)}`);
+    const orgs = await api.getOrganizations();
+    if (orgs.length > 0) {
+      logger.info(`Organizations: ${orgs.map((o) => chalk2.cyan(o.name)).join(", ")}`);
+    }
+  } catch (error) {
+    spinner.fail(`Login failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+async function pollForToken(sessionId, spinner) {
+  const maxAttempts = 60;
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    try {
+      const result = await api.checkLoginSession(sessionId);
+      if (result.status === "completed" && result.token) {
+        return result.token;
+      }
+      if (result.status === "expired") {
+        throw new Error("Login session expired. Please try again.");
+      }
+    } catch (error) {
+      if (error.message.includes("expired")) {
+        throw error;
+      }
+    }
+    await sleep(5e3);
+    attempts++;
+    const remainingSeconds = (maxAttempts - attempts) * 5;
+    const remainingMinutes = Math.floor(remainingSeconds / 60);
+    const remainingSecs = remainingSeconds % 60;
+    spinner.text = `Waiting for authentication... (${remainingMinutes}m ${remainingSecs}s remaining)`;
+  }
+  throw new Error("Login timed out. Please try again.");
+}
+async function apiKeyLogin() {
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "Enter your API key:",
+      mask: "*",
+      validate: (input) => {
+        if (!input) return "API key is required";
+        if (!input.startsWith("sp_")) return "Invalid API key format";
+        return true;
+      }
+    }
+  ]);
+  const spinner = ora("Validating API key...").start();
+  try {
+    await auth.loginWithApiKey(apiKey);
+    spinner.succeed("Login successful!");
+    const user = await api.getCurrentUser();
+    logger.success(`Authenticated as ${chalk2.cyan(user.email)}`);
+  } catch (error) {
+    spinner.fail(`Login failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/logout.ts
+init_esm_shims();
+init_auth();
+import { Command as Command2 } from "commander";
+import inquirer2 from "inquirer";
+var logoutCommand = new Command2("logout").description("Log out from SwiftPatch").option("-f, --force", "Logout without confirmation").action(async (options) => {
+  if (!auth.isLoggedIn()) {
+    logger.info("You are not logged in");
+    return;
+  }
+  if (!options.force) {
+    const { confirm } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to log out?",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      logger.info("Logout cancelled");
+      return;
+    }
+  }
+  auth.logout();
+  logger.success("Logged out successfully");
+});
+
+// src/commands/whoami.ts
+init_esm_shims();
+init_auth();
+init_api();
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+var whoamiCommand = new Command3("whoami").description("Show current authenticated user").action(async () => {
+  if (!auth.isLoggedIn()) {
+    logger.error("Not logged in. Run " + chalk3.cyan("swiftpatch login") + " first.");
+    process.exit(1);
+  }
+  try {
+    const user = await api.getCurrentUser();
+    const orgs = await api.getOrganizations();
+    console.log("");
+    console.log(chalk3.bold("  Current User"));
+    console.log("");
+    console.log(`  Name:   ${chalk3.cyan(user.name)}`);
+    console.log(`  Email:  ${chalk3.cyan(user.email)}`);
+    console.log(`  ID:     ${chalk3.gray(user.id)}`);
+    console.log("");
+    if (orgs.length > 0) {
+      console.log(chalk3.bold("  Organizations"));
+      console.log("");
+      orgs.forEach((org) => {
+        console.log(`  \u2022 ${chalk3.cyan(org.name)} ${chalk3.gray(`(${org.slug})`)}`);
+        console.log(`    Plan: ${org.plan} | Apps: ${org.usage.appsCount}`);
+      });
+      console.log("");
+    }
+  } catch (error) {
+    logger.error(`Failed to get user info: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/apps/index.ts
+init_esm_shims();
+import { Command as Command9 } from "commander";
+
+// src/commands/apps/list.ts
+init_esm_shims();
+init_api();
+import { Command as Command4 } from "commander";
+import chalk7 from "chalk";
+import ora2 from "ora";
+
+// src/utils/auth-guard.ts
+init_esm_shims();
+init_auth();
+import chalk4 from "chalk";
+async function requireAuth() {
+  if (!auth.isLoggedIn()) {
+    logger.error("You must be logged in to run this command");
+    console.log("");
+    console.log("Run " + chalk4.cyan("swiftpatch login") + " to authenticate");
+    console.log("");
+    process.exit(1);
+  }
+}
+
+// src/utils/org-resolver.ts
+init_esm_shims();
+init_api();
+init_config();
+import chalk5 from "chalk";
+import inquirer3 from "inquirer";
+async function resolveOrgId(explicitOrgId) {
+  if (explicitOrgId) {
+    return explicitOrgId;
+  }
+  const defaultOrg = config.get("defaultOrg");
+  if (defaultOrg) {
+    return defaultOrg;
+  }
+  const orgs = await api.getOrganizations();
+  if (orgs.length === 0) {
+    logger.error("No organizations found. Please create one at https://app.swiftpatch.io");
+    process.exit(1);
+  }
+  if (orgs.length === 1) {
+    return orgs[0].id;
+  }
+  const { selectedOrg } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "selectedOrg",
+      message: "Select organization:",
+      choices: orgs.map((org) => ({
+        name: `${org.name} ${chalk5.gray(`(${org.slug})`)}`,
+        value: org.id
+      }))
+    }
+  ]);
+  const { saveDefault } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "saveDefault",
+      message: "Save as default organization?",
+      default: true
+    }
+  ]);
+  if (saveDefault) {
+    config.set("defaultOrg", selectedOrg);
+    logger.info(`Default organization saved. Change with: ${chalk5.cyan("swiftpatch config set defaultOrg <org-id>")}`);
+  }
+  return selectedOrg;
+}
+
+// src/utils/table.ts
+init_esm_shims();
+import Table from "cli-table3";
+import chalk6 from "chalk";
+function createTable(options) {
+  const tableConfig = {
+    head: options.head.map((h) => chalk6.bold(h)),
+    style: {
+      head: [],
+      border: []
+    },
+    chars: {
+      "top": "\u2500",
+      "top-mid": "\u252C",
+      "top-left": "\u250C",
+      "top-right": "\u2510",
+      "bottom": "\u2500",
+      "bottom-mid": "\u2534",
+      "bottom-left": "\u2514",
+      "bottom-right": "\u2518",
+      "left": "\u2502",
+      "left-mid": "\u251C",
+      "mid": "\u2500",
+      "mid-mid": "\u253C",
+      "right": "\u2502",
+      "right-mid": "\u2524",
+      "middle": "\u2502"
+    }
+  };
+  if (options.colWidths) {
+    tableConfig.colWidths = options.colWidths;
+  }
+  const table = new Table(tableConfig);
+  for (const row of options.rows) {
+    table.push(row.map((v) => v == null ? "" : String(v)));
+  }
+  return table.toString();
+}
+
+// src/commands/apps/list.ts
+var listAppsCommand = new Command4("list").description("List all apps").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const spinner = ora2("Fetching apps...").start();
+  try {
+    const apps = await api.getApps(orgId);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(apps, null, 2));
+      return;
+    }
+    if (apps.length === 0) {
+      console.log("");
+      console.log(chalk7.gray("  No apps found."));
+      console.log("");
+      console.log("  Create one with: " + chalk7.cyan("swiftpatch apps create"));
+      console.log("");
+      return;
+    }
+    console.log("");
+    console.log(chalk7.bold("  Your Apps"));
+    console.log("");
+    const table = createTable({
+      head: ["Name", "Platform", "Deployment Key", "Releases"],
+      rows: apps.map((app) => [
+        chalk7.cyan(app.name || ""),
+        app.platform || "",
+        chalk7.gray((app.deploymentKey || "").slice(0, 20) + "..."),
+        String(app.stats?.totalReleases ?? 0)
+      ])
+    });
+    console.log(table);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to fetch apps: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/apps/create.ts
+init_esm_shims();
+init_api();
+import { Command as Command5 } from "commander";
+import chalk8 from "chalk";
+import ora3 from "ora";
+var createAppCommand = new Command5("create").description("Create a new app").option("-n, --name <name>", "App name").option("-p, --platform <platform>", "Platform (ios, android, or both)").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let appName = options.name;
+  if (!appName) {
+    const inquirer24 = (await import("inquirer")).default;
+    const { name } = await inquirer24.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "App name:",
+        validate: (input) => {
+          if (!input.trim()) return "App name is required";
+          if (input.length < 2) return "Name must be at least 2 characters";
+          return true;
+        }
+      }
+    ]);
+    appName = name;
+  }
+  let platform = options.platform?.toUpperCase();
+  if (!platform || !["IOS", "ANDROID", "BOTH"].includes(platform)) {
+    const inquirer24 = (await import("inquirer")).default;
+    const { selectedPlatform } = await inquirer24.prompt([
+      {
+        type: "list",
+        name: "selectedPlatform",
+        message: "Select platform:",
+        choices: [
+          { name: "iOS", value: "IOS" },
+          { name: "Android", value: "ANDROID" },
+          { name: "Both (iOS & Android)", value: "BOTH" }
+        ]
+      }
+    ]);
+    platform = selectedPlatform;
+  }
+  const spinner = ora3("Creating app...").start();
+  try {
+    const app = await api.createApp(orgId, {
+      name: appName,
+      platform
+    });
+    spinner.succeed("App created!");
+    if (options.json) {
+      console.log(JSON.stringify(app, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(chalk8.bold("  App Details"));
+    console.log("");
+    console.log(`  Name:           ${chalk8.cyan(app.name)}`);
+    console.log(`  ID:             ${chalk8.gray(app.id)}`);
+    console.log(`  Platform:       ${app.platform}`);
+    console.log(`  Deployment Key: ${chalk8.gray(app.deploymentKey)}`);
+    console.log("");
+    console.log(chalk8.gray("  Add this to your React Native app:"));
+    console.log(`  ${chalk8.cyan(`deploymentKey: "${app.deploymentKey}"`)}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to create app: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/apps/info.ts
+init_esm_shims();
+init_api();
+import { Command as Command6 } from "commander";
+import chalk9 from "chalk";
+import ora4 from "ora";
+var infoAppCommand = new Command6("info").description("Show app details").argument("<app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const spinner = ora4("Fetching app details...").start();
+  try {
+    const app = await api.getApp(orgId, appId);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(app, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(chalk9.bold("  App Details"));
+    console.log("");
+    console.log(`  Name:           ${chalk9.cyan(app.name)}`);
+    console.log(`  ID:             ${chalk9.gray(app.id)}`);
+    console.log(`  Slug:           ${chalk9.gray(app.slug)}`);
+    console.log(`  Platform:       ${app.platform}`);
+    console.log(`  Deployment Key: ${chalk9.gray(app.deploymentKey)}`);
+    console.log(`  Signing:        ${app.signingEnabled ? chalk9.green("Enabled") : chalk9.gray("Disabled")}`);
+    const orgDisplay = typeof app.organizationId === "object" && app.organizationId?.name ? `${app.organizationId.name} (${app.organizationId.id || app.organizationId._id})` : app.organizationId;
+    console.log(`  Organization:   ${chalk9.gray(orgDisplay)}`);
+    if (app.stats) {
+      console.log("");
+      console.log(chalk9.bold("  Stats"));
+      console.log(`  Total Releases: ${app.stats.totalReleases}`);
+      console.log(`  Total Installs: ${app.stats.totalInstalls}`);
+      console.log(`  Active Devices: ${app.stats.activeDevices}`);
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to fetch app: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/apps/update.ts
+init_esm_shims();
+init_api();
+import { Command as Command7 } from "commander";
+import chalk10 from "chalk";
+import inquirer4 from "inquirer";
+import ora5 from "ora";
+var updateAppCommand = new Command7("update").description("Update app settings").argument("<app-id>", "App ID").option("-n, --name <name>", "New app name").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const spinner = ora5("Fetching app details...").start();
+  const app = await api.getApp(orgId, appId);
+  spinner.stop();
+  let name = options.name;
+  if (!name) {
+    const answers = await inquirer4.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "New app name:",
+        default: app.name,
+        validate: (input) => {
+          if (!input.trim()) return "App name is required";
+          return true;
+        }
+      }
+    ]);
+    name = answers.name;
+  }
+  const updateSpinner = ora5("Updating app...").start();
+  try {
+    const updated = await api.updateApp(orgId, appId, { name });
+    updateSpinner.succeed("App updated!");
+    if (options.json) {
+      console.log(JSON.stringify(updated, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(`  Name: ${chalk10.cyan(updated.name)}`);
+    console.log(`  Slug: ${chalk10.gray(updated.slug)}`);
+    console.log("");
+  } catch (error) {
+    updateSpinner.fail(`Failed to update app: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/apps/delete.ts
+init_esm_shims();
+init_api();
+import { Command as Command8 } from "commander";
+import chalk11 from "chalk";
+import inquirer5 from "inquirer";
+import ora6 from "ora";
+var deleteAppCommand = new Command8("delete").description("Delete an app").argument("<app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("-y, --yes", "Skip confirmation").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const app = await api.getApp(orgId, appId);
+  if (!options.yes) {
+    console.log("");
+    logger.warning(`You are about to delete: ${chalk11.bold(app.name)}`);
+    console.log(chalk11.gray("  This action cannot be undone."));
+    console.log("");
+    const { confirm } = await inquirer5.prompt([
+      {
+        type: "input",
+        name: "confirm",
+        message: `Type "${app.name}" to confirm deletion:`,
+        validate: (input) => {
+          if (input !== app.name) return `Please type "${app.name}" to confirm`;
+          return true;
+        }
+      }
+    ]);
+    if (confirm !== app.name) {
+      logger.info("Deletion cancelled");
+      return;
+    }
+  }
+  const spinner = ora6("Deleting app...").start();
+  try {
+    await api.deleteApp(orgId, appId);
+    spinner.succeed(`App "${app.name}" deleted`);
+  } catch (error) {
+    spinner.fail(`Failed to delete app: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/apps/index.ts
+var appsCommands = new Command9("apps").description("Manage apps");
+appsCommands.addCommand(listAppsCommand);
+appsCommands.addCommand(createAppCommand);
+appsCommands.addCommand(infoAppCommand);
+appsCommands.addCommand(updateAppCommand);
+appsCommands.addCommand(deleteAppCommand);
+
+// src/commands/release.ts
+init_esm_shims();
+init_api();
+import { Command as Command10 } from "commander";
+import chalk12 from "chalk";
+import inquirer6 from "inquirer";
+import ora7 from "ora";
+import path4 from "path";
+import fs6 from "fs-extra";
+
+// src/lib/bundler.ts
+init_esm_shims();
+import { spawn } from "child_process";
+import path2 from "path";
+import fs from "fs-extra";
+import os2 from "os";
+var bundler = {
+  async bundle(options) {
+    const {
+      platform,
+      entryFile = "index.js",
+      dev = false,
+      minify = true,
+      sourcemap = false
+    } = options;
+    const tempDir = path2.join(os2.tmpdir(), `swiftpatch-bundle-${Date.now()}`);
+    await fs.ensureDir(tempDir);
+    const bundlePath = path2.join(tempDir, `index.${platform}.bundle`);
+    const sourcemapPath = sourcemap ? path2.join(tempDir, `index.${platform}.bundle.map`) : void 0;
+    const args = [
+      "react-native",
+      "bundle",
+      "--platform",
+      platform,
+      "--entry-file",
+      entryFile,
+      "--bundle-output",
+      bundlePath,
+      "--dev",
+      String(dev),
+      "--minify",
+      String(minify),
+      "--reset-cache"
+    ];
+    if (sourcemap && sourcemapPath) {
+      args.push("--sourcemap-output", sourcemapPath);
+    }
+    await runCommand("npx", args);
+    const stats = await fs.stat(bundlePath);
+    return {
+      bundlePath,
+      bundleSize: stats.size,
+      sourcemapPath
+    };
+  },
+  async bundleWithConfig(configPath) {
+    const config2 = await fs.readJson(configPath);
+    return this.bundle(config2);
+  }
+};
+function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: true
+    });
+    let stderr = "";
+    child.stdout?.on("data", () => {
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Bundle failed: ${stderr}`));
+      }
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+
+// src/lib/uploader.ts
+init_esm_shims();
+import axios2 from "axios";
+import fs2 from "fs-extra";
+var uploader = {
+  async uploadBundle(uploadUrl, bundlePath, onProgress) {
+    const fileSize = (await fs2.stat(bundlePath)).size;
+    const fileStream = fs2.createReadStream(bundlePath);
+    let uploadedBytes = 0;
+    fileStream.on("data", (chunk) => {
+      uploadedBytes += chunk.length;
+      const percent = Math.round(uploadedBytes / fileSize * 100);
+      onProgress?.(percent);
+    });
+    await axios2.put(uploadUrl, fileStream, {
+      headers: {
+        "Content-Type": "application/javascript",
+        "Content-Length": fileSize
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity
+    });
+  },
+  /**
+   * Upload a ZIP file to S3 via presigned URL (for publish-bundle).
+   */
+  async uploadZip(uploadUrl, zipPath, onProgress) {
+    const fileSize = (await fs2.stat(zipPath)).size;
+    const fileStream = fs2.createReadStream(zipPath);
+    let uploadedBytes = 0;
+    fileStream.on("data", (chunk) => {
+      uploadedBytes += chunk.length;
+      const percent = Math.round(uploadedBytes / fileSize * 100);
+      onProgress?.(percent);
+    });
+    await axios2.put(uploadUrl, fileStream, {
+      headers: {
+        "Content-Type": "application/zip",
+        "Content-Length": fileSize
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity
+    });
+  },
+  async uploadWithRetry(uploadUrl, bundlePath, onProgress, maxRetries = 3) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        await this.uploadBundle(uploadUrl, bundlePath, onProgress);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (attempt < maxRetries) {
+          await sleep2(1e3 * Math.pow(2, attempt));
+        }
+      }
+    }
+    throw lastError || new Error("Upload failed");
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/lib/hash.ts
+init_esm_shims();
+import crypto2 from "crypto";
+import fs3 from "fs-extra";
+import { readFileSync } from "fs";
+async function hashBundle(bundlePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto2.createHash("sha256");
+    const stream = fs3.createReadStream(bundlePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+function calculateZipHash(filePath) {
+  try {
+    const fileBuffer = readFileSync(filePath);
+    return crypto2.createHash("sha256").update(fileBuffer).digest("hex");
+  } catch {
+    return null;
+  }
+}
+async function hashFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto2.createHash("sha256");
+    const stream = fs3.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+
+// src/lib/signing.ts
+init_esm_shims();
+import crypto3 from "crypto";
+import fs4 from "fs-extra";
+import path3 from "path";
+import jwt from "jsonwebtoken";
+var BUNDLE_EXTENSION = ".swiftpatchsigned";
+async function signBundle(bundlePath, privateKeyPath) {
+  const absolutePath = path3.resolve(privateKeyPath);
+  if (!await fs4.pathExists(absolutePath)) {
+    throw new Error(`Private key not found: ${absolutePath}`);
+  }
+  const privateKey = await fs4.readFile(absolutePath, "utf-8");
+  const bundleContent = await fs4.readFile(bundlePath);
+  const sign = crypto3.createSign("RSA-SHA256");
+  sign.update(bundleContent);
+  sign.end();
+  const signature = sign.sign(privateKey, "base64");
+  return signature;
+}
+async function signBundleDirectory(bundlePath, privateKeyPath) {
+  if (!privateKeyPath) return;
+  let privateKey;
+  try {
+    privateKey = await fs4.readFile(path3.resolve(privateKeyPath));
+  } catch {
+    throw new Error(`The path specified for the signing key ("${privateKeyPath}") was not valid.`);
+  }
+  const signedFilePath = path3.join(bundlePath, BUNDLE_EXTENSION);
+  const fileHashMap = await generatePackageManifest(bundlePath, bundlePath);
+  const packageHash = await computePackageHash(fileHashMap);
+  const payload = { packageHash };
+  try {
+    const signedJwt = jwt.sign(payload, privateKey, { algorithm: "RS256" });
+    await fs4.writeFile(signedFilePath, signedJwt);
+  } catch (err) {
+    throw new Error(`Error signing bundle: ${err.message}`);
+  }
+}
+async function generatePackageManifest(directoryPath, basePath) {
+  const fileHashMap = /* @__PURE__ */ new Map();
+  const filePathList = await getFilePathsInDir(directoryPath);
+  if (!filePathList || filePathList.length === 0) {
+    throw new Error("Error: Can't sign the release because no files were found.");
+  }
+  for (const filePath of filePathList) {
+    const relativePath = normalizePath(path3.relative(basePath, filePath));
+    if (!isIgnored(relativePath)) {
+      const hash = await hashFile(filePath);
+      fileHashMap.set(relativePath, hash);
+    }
+  }
+  return fileHashMap;
+}
+async function computePackageHash(fileHashMap) {
+  let entries = [];
+  fileHashMap.forEach((hash, name) => {
+    entries.push(name + ":" + hash);
+  });
+  entries = entries.sort();
+  return crypto3.createHash("sha256").update(JSON.stringify(entries)).digest("hex");
+}
+async function generateKeyPair(outputDir) {
+  const { publicKey, privateKey } = crypto3.generateKeyPairSync("rsa", {
+    modulusLength: 2048,
+    publicKeyEncoding: {
+      type: "spki",
+      format: "pem"
+    },
+    privateKeyEncoding: {
+      type: "pkcs8",
+      format: "pem"
+    }
+  });
+  const publicKeyPath = path3.join(outputDir, "swiftpatch-public.pem");
+  const privateKeyPath = path3.join(outputDir, "swiftpatch-private.pem");
+  await fs4.ensureDir(outputDir);
+  await fs4.writeFile(publicKeyPath, publicKey);
+  await fs4.writeFile(privateKeyPath, privateKey, { mode: 384 });
+  return { publicKeyPath, privateKeyPath };
+}
+async function readBundleSignature(bundlePath) {
+  const signedFilePath = path3.join(bundlePath, BUNDLE_EXTENSION);
+  if (!await fs4.pathExists(signedFilePath)) {
+    return null;
+  }
+  const signature = await fs4.readFile(signedFilePath, "utf-8");
+  return signature.trim();
+}
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+async function getFilePathsInDir(dir) {
+  const stats = await fs4.stat(dir);
+  if (stats.isDirectory()) {
+    let files = [];
+    for (const file of await fs4.readdir(dir)) {
+      files = files.concat(await getFilePathsInDir(path3.join(dir, file)));
+    }
+    return files;
+  } else {
+    return [dir];
+  }
+}
+function isIgnored(relativeFilePath) {
+  const MACOSX = "__MACOSX/";
+  const DS_STORE = ".DS_Store";
+  const CODEPUSH_META = ".codepushrelease";
+  return relativeFilePath.startsWith(MACOSX) || relativeFilePath === DS_STORE || relativeFilePath.endsWith("/" + DS_STORE) || relativeFilePath === CODEPUSH_META || relativeFilePath.endsWith("/" + CODEPUSH_META);
+}
+
+// src/utils/detect.ts
+init_esm_shims();
+import fs5 from "fs-extra";
+async function detectAppInfo(platform) {
+  try {
+    if (platform === "ios") {
+      return await detectIosVersion();
+    } else {
+      return await detectAndroidVersion();
+    }
+  } catch {
+    return null;
+  }
+}
+async function detectIosVersion() {
+  try {
+    const pkg = await fs5.readJson("./package.json");
+    if (pkg.version) {
+      return { version: pkg.version };
+    }
+  } catch {
+  }
+  return null;
+}
+async function detectAndroidVersion() {
+  try {
+    const pkg = await fs5.readJson("./package.json");
+    if (pkg.version) {
+      return { version: pkg.version };
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/commands/release.ts
+var releaseCommand = new Command10("release").description("Bundle and publish a new release (deprecated: use publish-bundle + release-bundle)").option("-a, --app <app-id>", "App ID or slug").option("-o, --org <org-id>", "Organization ID").option("-p, --platform <platform>", "Target platform (ios or android)").option("-t, --target <versions...>", "Target binary version(s)").option("-c, --channel <channel>", "Release channel", "production").option("-m, --mandatory", "Mark as mandatory update", false).option("-r, --rollout <percent>", "Rollout percentage", "100").option("-n, --note <note>", "Release notes").option("--bundle-path <path>", "Path to pre-built bundle").option("--dry-run", "Simulate release without uploading", false).option("-y, --yes", "Skip confirmation prompts", false).option("--sign", "Sign the bundle", false).option("--private-key <path>", "Path to private key for signing").action(async (options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  console.log("");
+  logger.warning(
+    chalk12.yellow('The "release" command is deprecated. Use "publish-bundle" + "release-bundle" instead.')
+  );
+  console.log("");
+  logger.info(chalk12.bold("SwiftPatch Release"));
+  console.log("");
+  let appId = options.app;
+  if (!appId) {
+    const configApp = await detectAppFromConfig();
+    if (configApp) {
+      appId = configApp;
+      logger.info(`Using app from config: ${chalk12.cyan(appId)}`);
+    } else {
+      const apps = await api.getApps(orgId);
+      if (apps.length === 0) {
+        logger.error("No apps found. Create one with: swiftpatch apps create");
+        process.exit(1);
+      }
+      const { selectedApp } = await inquirer6.prompt([
+        {
+          type: "list",
+          name: "selectedApp",
+          message: "Select app:",
+          choices: apps.map((app2) => ({
+            name: `${app2.name} (${app2.platform})`,
+            value: app2.id
+          }))
+        }
+      ]);
+      appId = selectedApp;
+    }
+  }
+  const app = await api.getApp(orgId, appId);
+  logger.info(`App: ${chalk12.cyan(app.name)}`);
+  let platform = options.platform;
+  if (!platform) {
+    if (app.platform === "BOTH") {
+      const { selectedPlatform } = await inquirer6.prompt([
+        {
+          type: "list",
+          name: "selectedPlatform",
+          message: "Select platform:",
+          choices: [
+            { name: "iOS", value: "ios" },
+            { name: "Android", value: "android" }
+          ]
+        }
+      ]);
+      platform = selectedPlatform;
+    } else {
+      platform = app.platform.toLowerCase();
+    }
+  }
+  logger.info(`Platform: ${chalk12.cyan(platform)}`);
+  let targetVersions = options.target;
+  if (!targetVersions || targetVersions.length === 0) {
+    const detectedVersion = await detectAppInfo(platform);
+    const { version: version2 } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "version",
+        message: "Target binary version:",
+        default: detectedVersion?.version || "1.0.0",
+        validate: (input) => {
+          if (!input) return "Version is required";
+          if (!/^\d+\.\d+\.\d+/.test(input)) return "Invalid version format (use semver)";
+          return true;
+        }
+      }
+    ]);
+    targetVersions = [version2];
+  }
+  logger.info(`Target version: ${chalk12.cyan(targetVersions.join(", "))}`);
+  let releaseNote = options.note;
+  if (!releaseNote && !options.yes) {
+    const { note } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "note",
+        message: "Release notes (optional):"
+      }
+    ]);
+    releaseNote = note || void 0;
+  }
+  const rolloutPercent = parseInt(options.rollout || "100", 10);
+  let bundlePath = options.bundlePath;
+  if (!bundlePath) {
+    const spinner = ora7("Bundling JavaScript...").start();
+    try {
+      const result = await bundler.bundle({
+        platform,
+        entryFile: "index.js",
+        dev: false
+      });
+      bundlePath = result.bundlePath;
+      spinner.succeed(`Bundle created: ${chalk12.gray(formatBytes(result.bundleSize))}`);
+    } catch (error) {
+      spinner.fail(`Bundling failed: ${error.message}`);
+      process.exit(1);
+    }
+  } else {
+    if (!await fs6.pathExists(bundlePath)) {
+      logger.error(`Bundle not found: ${bundlePath}`);
+      process.exit(1);
+    }
+    logger.info(`Using existing bundle: ${chalk12.gray(bundlePath)}`);
+  }
+  const spinner2 = ora7("Computing bundle hash...").start();
+  const bundleHash = await hashBundle(bundlePath);
+  const bundleSize = (await fs6.stat(bundlePath)).size;
+  spinner2.succeed(`Bundle hash: ${chalk12.gray(bundleHash.slice(0, 16))}...`);
+  let signature;
+  if (options.sign || app.signingEnabled) {
+    const spinner3 = ora7("Signing bundle...").start();
+    try {
+      const privateKeyPath = options.privateKey || "./swiftpatch-private.pem";
+      signature = await signBundle(bundlePath, privateKeyPath);
+      spinner3.succeed("Bundle signed");
+    } catch (error) {
+      spinner3.fail(`Signing failed: ${error.message}`);
+      if (app.signingEnabled) {
+        logger.error("Bundle signing is required for this app");
+        process.exit(1);
+      }
+    }
+  }
+  console.log("");
+  console.log(chalk12.bold("  Release Summary"));
+  console.log("");
+  console.log(`  App:        ${chalk12.cyan(app.name)}`);
+  console.log(`  Platform:   ${chalk12.cyan(platform)}`);
+  console.log(`  Target:     ${chalk12.cyan(targetVersions.join(", "))}`);
+  console.log(`  Channel:    ${chalk12.cyan(options.channel || "production")}`);
+  console.log(`  Rollout:    ${chalk12.cyan(rolloutPercent + "%")}`);
+  console.log(`  Mandatory:  ${options.mandatory ? chalk12.yellow("Yes") : chalk12.gray("No")}`);
+  console.log(`  Bundle:     ${chalk12.gray(formatBytes(bundleSize))}`);
+  console.log(`  Hash:       ${chalk12.gray(bundleHash.slice(0, 16))}...`);
+  if (signature) {
+    console.log(`  Signed:     ${chalk12.green("Yes")}`);
+  }
+  if (releaseNote) {
+    console.log(`  Notes:      ${chalk12.gray(releaseNote.slice(0, 50))}${releaseNote.length > 50 ? "..." : ""}`);
+  }
+  console.log("");
+  if (options.dryRun) {
+    logger.info("Dry run - skipping upload");
+    return;
+  }
+  if (!options.yes) {
+    const { confirm } = await inquirer6.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Publish this release?",
+        default: true
+      }
+    ]);
+    if (!confirm) {
+      logger.info("Release cancelled");
+      return;
+    }
+  }
+  const spinner4 = ora7("Creating release...").start();
+  try {
+    const release = await api.createRelease(orgId, app.id, {
+      version: targetVersions[0],
+      platform: platform.toUpperCase(),
+      targetVersions,
+      isMandatory: options.mandatory || false,
+      releaseNote
+    });
+    spinner4.text = "Uploading bundle...";
+    await uploader.uploadBundle(release.uploadUrl, bundlePath, (progress) => {
+      spinner4.text = `Uploading bundle... ${progress}%`;
+    });
+    spinner4.text = "Processing...";
+    await api.completeUpload(orgId, app.id, release.id, {
+      bundleHash,
+      bundleSize,
+      signature
+    });
+    const finalRelease = await waitForProcessing(orgId, app.id, release.id, spinner4);
+    spinner4.text = "Publishing...";
+    await api.publishRelease(orgId, app.id, release.id, { rolloutPercent });
+    spinner4.succeed("Release published!");
+    console.log("");
+    console.log(chalk12.green("  Release published successfully!"));
+    console.log("");
+    console.log(`  Version:    ${chalk12.cyan(finalRelease.version)}`);
+    console.log(`  Release ID: ${chalk12.gray(release.id)}`);
+    console.log(`  Status:     ${chalk12.green("RELEASED")}`);
+    console.log(`  Rollout:    ${chalk12.cyan(rolloutPercent + "%")}`);
+    console.log("");
+    console.log(`  View in dashboard: ${chalk12.cyan(`https://app.swiftpatch.io/apps/${app.id}/releases/${release.id}`)}`);
+    console.log("");
+  } catch (error) {
+    spinner4.fail(`Release failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+async function detectAppFromConfig() {
+  const configPaths = [
+    "./swiftpatch.config.js",
+    "./swiftpatch.config.json",
+    "./.swiftpatchrc"
+  ];
+  for (const configPath of configPaths) {
+    if (await fs6.pathExists(configPath)) {
+      try {
+        const config2 = configPath.endsWith(".js") ? (await import(path4.resolve(configPath))).default : await fs6.readJson(configPath);
+        return config2.appId || config2.app;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return void 0;
+}
+async function waitForProcessing(orgId, appId, releaseId, spinner) {
+  const maxAttempts = 12;
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    const release2 = await api.getRelease(orgId, appId, releaseId);
+    if (release2.status === "READY" || release2.status === "RELEASED") {
+      return release2;
+    }
+    if (release2.status === "FAILED") {
+      throw new Error(release2.statusMessage || "Processing failed");
+    }
+    if (attempts >= 3 && release2.status === "PROCESSING") {
+      return release2;
+    }
+    await sleep3(5e3);
+    attempts++;
+    spinner.text = `Processing... (${attempts * 5}s)`;
+  }
+  const release = await api.getRelease(orgId, appId, releaseId);
+  if (release.status === "PROCESSING") {
+    return release;
+  }
+  throw new Error("Processing timed out");
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + " KB";
+  return (bytes / 1024 / 1024).toFixed(1) + " MB";
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/releases/index.ts
+init_esm_shims();
+import { Command as Command16 } from "commander";
+
+// src/commands/releases/list.ts
+init_esm_shims();
+init_api();
+import { Command as Command11 } from "commander";
+import chalk13 from "chalk";
+import ora8 from "ora";
+var listReleasesCommand = new Command11("list").description("List releases for an app").argument("<app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("--page <page>", "Page number", "1").option("--limit <limit>", "Items per page", "20").option("--json", "Output as JSON").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const spinner = ora8("Fetching releases...").start();
+  try {
+    const result = await api.getReleases(orgId, appId, {
+      page: parseInt(options.page, 10),
+      limit: parseInt(options.limit, 10)
+    });
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.releases.length === 0) {
+      console.log("");
+      console.log(chalk13.gray("  No releases found."));
+      console.log("");
+      console.log("  Publish one with: " + chalk13.cyan("swiftpatch release"));
+      console.log("");
+      return;
+    }
+    console.log("");
+    console.log(chalk13.bold("  Releases"));
+    console.log("");
+    const table = createTable({
+      head: ["Version", "Platform", "Status", "Rollout", "Mandatory", "Created"],
+      rows: result.releases.map((r) => [
+        chalk13.cyan(r.version),
+        r.platform,
+        formatStatus(r.status),
+        `${r.rolloutPercent}%`,
+        r.isMandatory ? chalk13.yellow("Yes") : chalk13.gray("No"),
+        new Date(r.createdAt).toLocaleDateString()
+      ])
+    });
+    console.log(table);
+    if (result.pagination) {
+      console.log("");
+      console.log(chalk13.gray(
+        `  Page ${result.pagination.page} of ${result.pagination.totalPages} (${result.pagination.total} total)`
+      ));
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to fetch releases: ${error.message}`);
+    process.exit(1);
+  }
+});
+function formatStatus(status) {
+  switch (status) {
+    case "RELEASED":
+      return chalk13.green(status);
+    case "ROLLED_BACK":
+      return chalk13.red(status);
+    case "PROCESSING":
+      return chalk13.yellow(status);
+    case "READY":
+      return chalk13.blue(status);
+    case "FAILED":
+      return chalk13.red(status);
+    default:
+      return chalk13.gray(status);
+  }
+}
+
+// src/commands/releases/info.ts
+init_esm_shims();
+init_api();
+import { Command as Command12 } from "commander";
+import chalk14 from "chalk";
+import ora9 from "ora";
+import inquirer7 from "inquirer";
+var infoReleaseCommand = new Command12("info").description("Show release details").argument("<release-id>", "Release ID").option("-a, --app <app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (releaseId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let appId = options.app;
+  if (!appId) {
+    const apps = await api.getApps(orgId);
+    const { selectedApp } = await inquirer7.prompt([
+      {
+        type: "list",
+        name: "selectedApp",
+        message: "Select app:",
+        choices: apps.map((app) => ({ name: app.name, value: app.id }))
+      }
+    ]);
+    appId = selectedApp;
+  }
+  const spinner = ora9("Fetching release details...").start();
+  try {
+    const release = await api.getRelease(orgId, appId, releaseId);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(release, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(chalk14.bold("  Release Details"));
+    console.log("");
+    console.log(`  Version:     ${chalk14.cyan(release.version)}`);
+    console.log(`  ID:          ${chalk14.gray(release.id)}`);
+    console.log(`  Platform:    ${release.platform}`);
+    console.log(`  Status:      ${formatStatus2(release.status)}`);
+    console.log(`  Rollout:     ${chalk14.cyan(release.rolloutPercent + "%")}`);
+    console.log(`  Mandatory:   ${release.isMandatory ? chalk14.yellow("Yes") : chalk14.gray("No")}`);
+    console.log(`  Bundle Size: ${chalk14.gray(formatBytes2(release.bundleSize))}`);
+    console.log(`  Bundle Hash: ${chalk14.gray(release.bundleHash?.slice(0, 16) || "N/A")}...`);
+    console.log(`  Created:     ${new Date(release.createdAt).toLocaleString()}`);
+    if (release.releasedAt) {
+      console.log(`  Released:    ${new Date(release.releasedAt).toLocaleString()}`);
+    }
+    if (release.releaseNote) {
+      console.log("");
+      console.log(chalk14.bold("  Release Notes"));
+      console.log(`  ${release.releaseNote}`);
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to fetch release: ${error.message}`);
+    process.exit(1);
+  }
+});
+function formatStatus2(status) {
+  switch (status) {
+    case "RELEASED":
+      return chalk14.green(status);
+    case "ROLLED_BACK":
+      return chalk14.red(status);
+    case "PROCESSING":
+      return chalk14.yellow(status);
+    default:
+      return chalk14.gray(status);
+  }
+}
+function formatBytes2(bytes) {
+  if (!bytes) return "N/A";
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + " KB";
+  return (bytes / 1024 / 1024).toFixed(1) + " MB";
+}
+
+// src/commands/releases/rollout.ts
+init_esm_shims();
+init_api();
+import { Command as Command13 } from "commander";
+import chalk15 from "chalk";
+import inquirer8 from "inquirer";
+import ora10 from "ora";
+var rolloutCommand = new Command13("rollout").description("Update rollout percentage for a release").argument("<release-id>", "Release ID").option("-a, --app <app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("-p, --percent <percent>", "Rollout percentage (0-100)").action(async (releaseId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let appId = options.app;
+  if (!appId) {
+    const apps = await api.getApps(orgId);
+    const { selectedApp } = await inquirer8.prompt([
+      {
+        type: "list",
+        name: "selectedApp",
+        message: "Select app:",
+        choices: apps.map((app) => ({ name: app.name, value: app.id }))
+      }
+    ]);
+    appId = selectedApp;
+  }
+  let rolloutPercent = options.percent ? parseInt(options.percent, 10) : null;
+  if (rolloutPercent !== null && (isNaN(rolloutPercent) || rolloutPercent < 0 || rolloutPercent > 100)) {
+    console.error(chalk15.red("Rollout percentage must be a number between 0 and 100"));
+    process.exit(1);
+  }
+  if (rolloutPercent === null) {
+    const release = await api.getRelease(orgId, appId, releaseId);
+    const { percent } = await inquirer8.prompt([
+      {
+        type: "number",
+        name: "percent",
+        message: `Current rollout: ${release.rolloutPercent}%. New percentage:`,
+        default: release.rolloutPercent,
+        validate: (input) => {
+          if (input < 0 || input > 100) return "Must be between 0 and 100";
+          return true;
+        }
+      }
+    ]);
+    rolloutPercent = percent;
+  }
+  const spinner = ora10("Updating rollout...").start();
+  try {
+    const release = await api.updateRollout(orgId, appId, releaseId, rolloutPercent);
+    spinner.succeed(`Rollout updated to ${chalk15.cyan(rolloutPercent + "%")}`);
+    console.log("");
+    console.log(`  Release: ${chalk15.gray(release.version)}`);
+    console.log(`  Status:  ${chalk15.green(release.status)}`);
+    console.log(`  Rollout: ${chalk15.cyan(release.rolloutPercent + "%")}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to update rollout: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/releases/rollback.ts
+init_esm_shims();
+init_api();
+import { Command as Command14 } from "commander";
+import chalk16 from "chalk";
+import inquirer9 from "inquirer";
+import ora11 from "ora";
+var rollbackCommand = new Command14("rollback").description("Rollback (disable) a release").argument("<release-id>", "Release ID").option("-a, --app <app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("-r, --reason <reason>", "Rollback reason").option("-y, --yes", "Skip confirmation").action(async (releaseId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let appId = options.app;
+  if (!appId) {
+    const apps = await api.getApps(orgId);
+    const { selectedApp } = await inquirer9.prompt([
+      {
+        type: "list",
+        name: "selectedApp",
+        message: "Select app:",
+        choices: apps.map((app) => ({ name: app.name, value: app.id }))
+      }
+    ]);
+    appId = selectedApp;
+  }
+  const release = await api.getRelease(orgId, appId, releaseId);
+  console.log("");
+  logger.warning("You are about to rollback this release:");
+  console.log("");
+  console.log(`  Version:  ${chalk16.cyan(release.version)}`);
+  console.log(`  Platform: ${release.platform}`);
+  console.log(`  Status:   ${release.status}`);
+  console.log(`  Rollout:  ${release.rolloutPercent}%`);
+  console.log("");
+  if (!options.yes) {
+    const { confirm } = await inquirer9.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to rollback this release?",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      logger.info("Rollback cancelled");
+      return;
+    }
+  }
+  let reason = options.reason;
+  if (!reason && !options.yes) {
+    const { inputReason } = await inquirer9.prompt([
+      {
+        type: "input",
+        name: "inputReason",
+        message: "Reason for rollback (optional):"
+      }
+    ]);
+    reason = inputReason || void 0;
+  }
+  const spinner = ora11("Rolling back release...").start();
+  try {
+    await api.rollbackRelease(orgId, appId, releaseId, reason);
+    spinner.succeed("Release rolled back");
+    console.log("");
+    console.log(chalk16.yellow("  Release has been disabled"));
+    console.log(chalk16.gray("  Users will no longer receive this update"));
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Rollback failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/releases/disable.ts
+init_esm_shims();
+init_api();
+import { Command as Command15 } from "commander";
+import chalk17 from "chalk";
+import inquirer10 from "inquirer";
+import ora12 from "ora";
+var disableCommand = new Command15("disable").description("Disable a release (stops serving to new devices)").argument("<release-id>", "Release ID").option("-a, --app <app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("-r, --reason <reason>", "Reason for disabling").option("-y, --yes", "Skip confirmation").action(async (releaseId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let appId = options.app;
+  if (!appId) {
+    const apps = await api.getApps(orgId);
+    const { selectedApp } = await inquirer10.prompt([
+      {
+        type: "list",
+        name: "selectedApp",
+        message: "Select app:",
+        choices: apps.map((app) => ({ name: app.name, value: app.id }))
+      }
+    ]);
+    appId = selectedApp;
+  }
+  const release = await api.getRelease(orgId, appId, releaseId);
+  console.log("");
+  logger.warning("You are about to disable this release:");
+  console.log("");
+  console.log(`  Version:  ${chalk17.cyan(release.version)}`);
+  console.log(`  Platform: ${release.platform}`);
+  console.log(`  Status:   ${release.status}`);
+  console.log(`  Rollout:  ${release.rolloutPercent}%`);
+  console.log("");
+  if (!options.yes) {
+    const { confirm } = await inquirer10.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to disable this release?",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      logger.info("Cancelled");
+      return;
+    }
+  }
+  let reason = options.reason;
+  if (!reason && !options.yes) {
+    const { inputReason } = await inquirer10.prompt([
+      {
+        type: "input",
+        name: "inputReason",
+        message: "Reason for disabling (optional):"
+      }
+    ]);
+    reason = inputReason || void 0;
+  }
+  const spinner = ora12("Disabling release...").start();
+  try {
+    await api.disableRelease(orgId, appId, releaseId, reason);
+    spinner.succeed("Release disabled");
+    console.log("");
+    console.log(chalk17.yellow("  Release has been disabled"));
+    console.log(chalk17.gray("  New devices will not receive this update"));
+    console.log(chalk17.gray("  Devices that already installed it are unaffected"));
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to disable release: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/releases/index.ts
+var releasesCommands = new Command16("releases").description("Manage releases");
+releasesCommands.addCommand(listReleasesCommand);
+releasesCommands.addCommand(infoReleaseCommand);
+releasesCommands.addCommand(rolloutCommand);
+releasesCommands.addCommand(rollbackCommand);
+releasesCommands.addCommand(disableCommand);
+
+// src/commands/channels/index.ts
+init_esm_shims();
+import { Command as Command21 } from "commander";
+
+// src/commands/channels/list.ts
+init_esm_shims();
+init_api();
+import { Command as Command17 } from "commander";
+import chalk18 from "chalk";
+import ora13 from "ora";
+var listChannelsCommand = new Command17("list").description("List channels for an app").argument("<app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const spinner = ora13("Fetching channels...").start();
+  try {
+    const channels = await api.getChannels(orgId, appId);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(channels, null, 2));
+      return;
+    }
+    if (channels.length === 0) {
+      console.log("");
+      console.log(chalk18.gray("  No channels found."));
+      console.log("");
+      return;
+    }
+    console.log("");
+    console.log(chalk18.bold("  Channels"));
+    console.log("");
+    const table = createTable({
+      head: ["Name", "Slug", "Created"],
+      rows: channels.map((ch) => [
+        chalk18.cyan(ch.name),
+        chalk18.gray(ch.slug),
+        new Date(ch.createdAt).toLocaleDateString()
+      ])
+    });
+    console.log(table);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to fetch channels: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/channels/create.ts
+init_esm_shims();
+init_api();
+import { Command as Command18 } from "commander";
+import chalk19 from "chalk";
+import inquirer11 from "inquirer";
+import ora14 from "ora";
+var createChannelCommand = new Command18("create").description("Create a new channel").argument("<app-id>", "App ID").option("-n, --name <name>", "Channel name").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let channelName = options.name;
+  if (!channelName) {
+    const { name } = await inquirer11.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Channel name:",
+        validate: (input) => {
+          if (!input.trim()) return "Channel name is required";
+          return true;
+        }
+      }
+    ]);
+    channelName = name;
+  }
+  const spinner = ora14("Creating channel...").start();
+  try {
+    const channel = await api.createChannel(orgId, appId, { name: channelName });
+    spinner.succeed("Channel created!");
+    if (options.json) {
+      console.log(JSON.stringify(channel, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(`  Name: ${chalk19.cyan(channel.name)}`);
+    console.log(`  Slug: ${chalk19.gray(channel.slug)}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to create channel: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/channels/update.ts
+init_esm_shims();
+init_api();
+import { Command as Command19 } from "commander";
+import chalk20 from "chalk";
+import inquirer12 from "inquirer";
+import ora15 from "ora";
+var updateChannelCommand = new Command19("update").description("Update a channel").argument("<app-id>", "App ID").argument("<channel-id>", "Channel ID").option("-n, --name <name>", "New channel name").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (appId, channelId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let channelName = options.name;
+  if (!channelName) {
+    const answers = await inquirer12.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "New channel name:",
+        validate: (input) => {
+          if (!input.trim()) return "Channel name is required";
+          return true;
+        }
+      }
+    ]);
+    channelName = answers.name;
+  }
+  const spinner = ora15("Updating channel...").start();
+  try {
+    const channel = await api.updateChannel(orgId, appId, channelId, { name: channelName });
+    spinner.succeed("Channel updated!");
+    if (options.json) {
+      console.log(JSON.stringify(channel, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(`  Name: ${chalk20.cyan(channel.name)}`);
+    console.log(`  Slug: ${chalk20.gray(channel.slug)}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to update channel: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/channels/delete.ts
+init_esm_shims();
+init_api();
+import { Command as Command20 } from "commander";
+import chalk21 from "chalk";
+import inquirer13 from "inquirer";
+import ora16 from "ora";
+var deleteChannelCommand = new Command20("delete").description("Delete a channel").argument("<app-id>", "App ID").argument("<channel-id>", "Channel ID").option("-o, --org <org-id>", "Organization ID").option("-y, --yes", "Skip confirmation").action(async (appId, channelId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  if (!options.yes) {
+    const { confirm } = await inquirer13.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to delete this channel? This cannot be undone.",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      console.log(chalk21.gray("  Cancelled"));
+      return;
+    }
+  }
+  const spinner = ora16("Deleting channel...").start();
+  try {
+    await api.deleteChannel(orgId, appId, channelId);
+    spinner.succeed("Channel deleted");
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to delete channel: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/channels/index.ts
+var channelsCommands = new Command21("channels").description("Manage channels");
+channelsCommands.addCommand(listChannelsCommand);
+channelsCommands.addCommand(createChannelCommand);
+channelsCommands.addCommand(updateChannelCommand);
+channelsCommands.addCommand(deleteChannelCommand);
+
+// src/commands/ci-tokens/index.ts
+init_esm_shims();
+import { Command as Command26 } from "commander";
+
+// src/commands/ci-tokens/list.ts
+init_esm_shims();
+init_api();
+import { Command as Command22 } from "commander";
+import chalk22 from "chalk";
+import inquirer14 from "inquirer";
+import ora17 from "ora";
+var listCITokensCommand = new Command22("list").description("List CI tokens for an app").argument("[app-id]", "App ID").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  if (!appId) {
+    const apps = await api.getApps(orgId);
+    const { selectedApp } = await inquirer14.prompt([
+      {
+        type: "list",
+        name: "selectedApp",
+        message: "Select app:",
+        choices: apps.map((app) => ({ name: app.name, value: app.id }))
+      }
+    ]);
+    appId = selectedApp;
+  }
+  const spinner = ora17("Fetching CI tokens...").start();
+  try {
+    const tokens = await api.getCITokens(orgId, appId);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(tokens, null, 2));
+      return;
+    }
+    if (tokens.length === 0) {
+      console.log("");
+      console.log(chalk22.gray("  No CI tokens found."));
+      console.log(chalk22.gray("  Create one with: swiftpatch ci-tokens create"));
+      console.log("");
+      return;
+    }
+    console.log("");
+    console.log(chalk22.bold("  CI Tokens"));
+    console.log("");
+    const table = createTable({
+      head: ["Name", "Prefix", "Status", "Uses", "Last Used", "Created"],
+      rows: tokens.map((t) => [
+        chalk22.cyan(t.name),
+        chalk22.gray(t.tokenPrefix + "..."),
+        t.isActive ? chalk22.green("Active") : chalk22.red("Revoked"),
+        String(t.usageCount),
+        t.lastUsedAt ? new Date(t.lastUsedAt).toLocaleDateString() : chalk22.gray("Never"),
+        new Date(t.createdAt).toLocaleDateString()
+      ])
+    });
+    console.log(table);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to fetch CI tokens: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/ci-tokens/create.ts
+init_esm_shims();
+init_api();
+import { Command as Command23 } from "commander";
+import chalk23 from "chalk";
+import inquirer15 from "inquirer";
+import ora18 from "ora";
+var createCITokenCommand = new Command23("create").description("Create a new CI token").argument("[app-id]", "App ID").option("-n, --name <name>", "Token name").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  if (!appId) {
+    const apps = await api.getApps(orgId);
+    const { selectedApp } = await inquirer15.prompt([
+      {
+        type: "list",
+        name: "selectedApp",
+        message: "Select app:",
+        choices: apps.map((app) => ({ name: app.name, value: app.id }))
+      }
+    ]);
+    appId = selectedApp;
+  }
+  let tokenName = options.name;
+  if (!tokenName) {
+    const answers = await inquirer15.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: 'Token name (e.g., "GitHub Actions", "Jenkins"):',
+        validate: (input) => {
+          if (!input.trim()) return "Token name is required";
+          return true;
+        }
+      }
+    ]);
+    tokenName = answers.name;
+  }
+  const spinner = ora18("Creating CI token...").start();
+  try {
+    const result = await api.createCIToken(orgId, appId, tokenName);
+    spinner.succeed("CI token created!");
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(chalk23.bold("  Your CI Token (shown only once):"));
+    console.log("");
+    console.log(`  ${chalk23.green(result.token)}`);
+    console.log("");
+    logger.warning("Save this token now. It will not be shown again.");
+    console.log("");
+    console.log(chalk23.gray("  Usage in CI/CD:"));
+    console.log(chalk23.gray("  $ swiftpatch publish-bundle -p ios --ci-token <token>"));
+    console.log(chalk23.gray("  $ swiftpatch release-bundle --hash <hash> --app-version 1.0.0 --ci-token <token>"));
+    console.log("");
+    console.log(chalk23.gray("  Or set as environment variable:"));
+    console.log(chalk23.gray("  $ export SWIFTPATCH_CI_TOKEN=<token>"));
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to create CI token: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/ci-tokens/delete.ts
+init_esm_shims();
+init_api();
+import { Command as Command24 } from "commander";
+import chalk24 from "chalk";
+import inquirer16 from "inquirer";
+import ora19 from "ora";
+var deleteCITokenCommand = new Command24("delete").description("Revoke a CI token").argument("<token-id>", "Token ID").option("-a, --app <app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("-y, --yes", "Skip confirmation").action(async (tokenId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let appId = options.app;
+  if (!appId) {
+    const apps = await api.getApps(orgId);
+    const { selectedApp } = await inquirer16.prompt([
+      {
+        type: "list",
+        name: "selectedApp",
+        message: "Select app:",
+        choices: apps.map((app) => ({ name: app.name, value: app.id }))
+      }
+    ]);
+    appId = selectedApp;
+  }
+  if (!options.yes) {
+    const { confirm } = await inquirer16.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to revoke this CI token? Any pipelines using it will stop working.",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      console.log(chalk24.gray("  Cancelled"));
+      return;
+    }
+  }
+  const spinner = ora19("Revoking CI token...").start();
+  try {
+    await api.deleteCIToken(orgId, appId, tokenId);
+    spinner.succeed("CI token revoked");
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to revoke CI token: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/ci-tokens/regenerate.ts
+init_esm_shims();
+init_api();
+import { Command as Command25 } from "commander";
+import chalk25 from "chalk";
+import inquirer17 from "inquirer";
+import ora20 from "ora";
+var regenerateCITokenCommand = new Command25("regenerate").description("Regenerate a CI token (revokes old one)").argument("<token-id>", "Token ID").option("-a, --app <app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("-y, --yes", "Skip confirmation").option("--json", "Output as JSON").action(async (tokenId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let appId = options.app;
+  if (!appId) {
+    const apps = await api.getApps(orgId);
+    const { selectedApp } = await inquirer17.prompt([
+      {
+        type: "list",
+        name: "selectedApp",
+        message: "Select app:",
+        choices: apps.map((app) => ({ name: app.name, value: app.id }))
+      }
+    ]);
+    appId = selectedApp;
+  }
+  if (!options.yes) {
+    const { confirm } = await inquirer17.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "This will revoke the old token. Pipelines using it will need to be updated. Continue?",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      console.log(chalk25.gray("  Cancelled"));
+      return;
+    }
+  }
+  const spinner = ora20("Regenerating CI token...").start();
+  try {
+    const result = await api.regenerateCIToken(orgId, appId, tokenId);
+    spinner.succeed("CI token regenerated!");
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(chalk25.bold("  Your new CI Token (shown only once):"));
+    console.log("");
+    console.log(`  ${chalk25.green(result.token)}`);
+    console.log("");
+    logger.warning("Save this token now. It will not be shown again.");
+    logger.warning("The old token has been revoked.");
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to regenerate CI token: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/ci-tokens/index.ts
+var ciTokensCommands = new Command26("ci-tokens").description("Manage CI/CD tokens");
+ciTokensCommands.addCommand(listCITokensCommand);
+ciTokensCommands.addCommand(createCITokenCommand);
+ciTokensCommands.addCommand(deleteCITokenCommand);
+ciTokensCommands.addCommand(regenerateCITokenCommand);
+
+// src/commands/webhooks/index.ts
+init_esm_shims();
+import { Command as Command32 } from "commander";
+
+// src/commands/webhooks/list.ts
+init_esm_shims();
+init_api();
+import { Command as Command27 } from "commander";
+import chalk26 from "chalk";
+import ora21 from "ora";
+var listWebhooksCommand = new Command27("list").description("List webhooks").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const spinner = ora21("Fetching webhooks...").start();
+  try {
+    const webhooks = await api.getWebhooks(orgId);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(webhooks, null, 2));
+      return;
+    }
+    if (webhooks.length === 0) {
+      console.log("");
+      console.log(chalk26.gray("  No webhooks configured."));
+      console.log(chalk26.gray("  Create one with: swiftpatch webhooks create"));
+      console.log("");
+      return;
+    }
+    console.log("");
+    console.log(chalk26.bold("  Webhooks"));
+    console.log("");
+    const table = createTable({
+      head: ["ID", "URL", "Events", "Status", "Deliveries"],
+      rows: webhooks.map((w) => [
+        chalk26.gray(w.id.slice(0, 8) + "..."),
+        chalk26.cyan(w.url.length > 40 ? w.url.slice(0, 40) + "..." : w.url),
+        w.events.join(", "),
+        w.isActive ? chalk26.green("Active") : chalk26.red("Inactive"),
+        w.stats ? `${w.stats.successfulDeliveries}/${w.stats.totalDeliveries}` : "0/0"
+      ])
+    });
+    console.log(table);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to fetch webhooks: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/webhooks/create.ts
+init_esm_shims();
+init_api();
+import { Command as Command28 } from "commander";
+import chalk27 from "chalk";
+import inquirer18 from "inquirer";
+import ora22 from "ora";
+var WEBHOOK_EVENTS = [
+  "release.published",
+  "release.disabled",
+  "update.success",
+  "update.failed",
+  "app.created",
+  "app.deleted"
+];
+var createWebhookCommand = new Command28("create").description("Create a webhook").option("-u, --url <url>", "Webhook URL").option("-e, --events <events...>", "Events to subscribe to").option("-s, --secret <secret>", "Webhook signing secret").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  let url = options.url;
+  if (!url) {
+    const answers = await inquirer18.prompt([
+      {
+        type: "input",
+        name: "url",
+        message: "Webhook URL:",
+        validate: (input) => {
+          if (!input.trim()) return "URL is required";
+          try {
+            new URL(input);
+            return true;
+          } catch {
+            return "Invalid URL";
+          }
+        }
+      }
+    ]);
+    url = answers.url;
+  }
+  let events = options.events;
+  if (!events || events.length === 0) {
+    const answers = await inquirer18.prompt([
+      {
+        type: "checkbox",
+        name: "events",
+        message: "Select events to subscribe to:",
+        choices: WEBHOOK_EVENTS,
+        validate: (input) => {
+          if (input.length === 0) return "Select at least one event";
+          return true;
+        }
+      }
+    ]);
+    events = answers.events;
+  }
+  const spinner = ora22("Creating webhook...").start();
+  try {
+    const webhook = await api.createWebhook(orgId, {
+      url,
+      events,
+      secret: options.secret
+    });
+    spinner.succeed("Webhook created!");
+    if (options.json) {
+      console.log(JSON.stringify(webhook, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(`  ID:     ${chalk27.gray(webhook.id)}`);
+    console.log(`  URL:    ${chalk27.cyan(webhook.url)}`);
+    console.log(`  Events: ${webhook.events.join(", ")}`);
+    if (webhook.secret) {
+      console.log(`  Secret: ${chalk27.green(webhook.secret)}`);
+      console.log(chalk27.yellow("  Save this secret \u2014 it will not be shown again."));
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to create webhook: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/webhooks/update.ts
+init_esm_shims();
+init_api();
+import { Command as Command29 } from "commander";
+import chalk28 from "chalk";
+import ora23 from "ora";
+var updateWebhookCommand = new Command29("update").description("Update a webhook").argument("<webhook-id>", "Webhook ID").option("-u, --url <url>", "New URL").option("-e, --events <events...>", "New events list").option("-s, --secret <secret>", "New signing secret").option("--enable", "Enable webhook").option("--disable", "Disable webhook").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (webhookId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const params = {};
+  if (options.url) params.url = options.url;
+  if (options.events) params.events = options.events;
+  if (options.secret) params.secret = options.secret;
+  if (options.enable) params.isActive = true;
+  if (options.disable) params.isActive = false;
+  if (Object.keys(params).length === 0) {
+    console.log(chalk28.yellow("  No changes specified. Use --url, --events, --secret, --enable, or --disable"));
+    process.exit(1);
+  }
+  const spinner = ora23("Updating webhook...").start();
+  try {
+    const webhook = await api.updateWebhook(orgId, webhookId, params);
+    spinner.succeed("Webhook updated!");
+    if (options.json) {
+      console.log(JSON.stringify(webhook, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(`  URL:    ${chalk28.cyan(webhook.url)}`);
+    console.log(`  Events: ${webhook.events.join(", ")}`);
+    console.log(`  Status: ${webhook.isActive ? chalk28.green("Active") : chalk28.red("Inactive")}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to update webhook: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/webhooks/delete.ts
+init_esm_shims();
+init_api();
+import { Command as Command30 } from "commander";
+import chalk29 from "chalk";
+import inquirer19 from "inquirer";
+import ora24 from "ora";
+var deleteWebhookCommand = new Command30("delete").description("Delete a webhook").argument("<webhook-id>", "Webhook ID").option("-o, --org <org-id>", "Organization ID").option("-y, --yes", "Skip confirmation").action(async (webhookId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  if (!options.yes) {
+    const { confirm } = await inquirer19.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Are you sure you want to delete this webhook?",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      console.log(chalk29.gray("  Cancelled"));
+      return;
+    }
+  }
+  const spinner = ora24("Deleting webhook...").start();
+  try {
+    await api.deleteWebhook(orgId, webhookId);
+    spinner.succeed("Webhook deleted");
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to delete webhook: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/webhooks/test.ts
+init_esm_shims();
+init_api();
+import { Command as Command31 } from "commander";
+import ora25 from "ora";
+var testWebhookCommand = new Command31("test").description("Send a test event to a webhook").argument("<webhook-id>", "Webhook ID").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (webhookId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const spinner = ora25("Sending test event...").start();
+  try {
+    const result = await api.testWebhook(orgId, webhookId);
+    if (result.success) {
+      spinner.succeed(`Test event delivered (status ${result.statusCode})`);
+    } else {
+      spinner.fail(`Test event failed: ${result.error || "Unknown error"}`);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to send test event: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/webhooks/index.ts
+var webhooksCommands = new Command32("webhooks").description("Manage webhooks");
+webhooksCommands.addCommand(listWebhooksCommand);
+webhooksCommands.addCommand(createWebhookCommand);
+webhooksCommands.addCommand(updateWebhookCommand);
+webhooksCommands.addCommand(deleteWebhookCommand);
+webhooksCommands.addCommand(testWebhookCommand);
+
+// src/commands/analytics.ts
+init_esm_shims();
+init_api();
+import { Command as Command33 } from "commander";
+import chalk30 from "chalk";
+import ora26 from "ora";
+var analyticsCommand = new Command33("analytics").description("View analytics for an app").argument("<app-id>", "App ID").option("-o, --org <org-id>", "Organization ID").option("-r, --release <release-id>", "Filter by release").option("-d, --days <days>", "Time range in days", "7").option("--json", "Output as JSON").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  const spinner = ora26("Fetching analytics...").start();
+  try {
+    const analytics = await api.getAnalytics(orgId, appId, {
+      days: parseInt(options.days, 10),
+      releaseId: options.release
+    });
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(analytics, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(chalk30.bold("  Analytics Overview"));
+    console.log("");
+    console.log(`  Total Updates:      ${chalk30.cyan((analytics.totalUpdates ?? 0).toLocaleString())}`);
+    console.log(`  Success Rate:       ${chalk30.green((analytics.successRate ?? 0).toFixed(1) + "%")}`);
+    console.log(`  Avg Patch Size:     ${chalk30.cyan(formatBytes3(analytics.avgPatchSize ?? 0))}`);
+    console.log(`  Bandwidth Saved:    ${chalk30.green(formatBytes3(analytics.bandwidthSaved ?? 0))}`);
+    console.log(`  Bandwidth Used:     ${chalk30.gray(formatBytes3(analytics.totalBandwidthUsed ?? 0))}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to fetch analytics: ${error.message}`);
+    process.exit(1);
+  }
+});
+function formatBytes3(bytes) {
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + " KB";
+  return (bytes / 1024 / 1024).toFixed(1) + " MB";
+}
+
+// src/commands/ai.ts
+init_esm_shims();
+init_api();
+import { Command as Command37 } from "commander";
+import chalk35 from "chalk";
+import ora30 from "ora";
+
+// src/commands/ai-doctor.ts
+init_esm_shims();
+import { Command as Command34 } from "commander";
+import chalk32 from "chalk";
+import ora27 from "ora";
+import path5 from "path";
+import fs7 from "fs-extra";
+
+// src/lib/claude.ts
+init_esm_shims();
+init_auth();
+init_api();
+import Anthropic from "@anthropic-ai/sdk";
+var CLAUDE_MODEL = "claude-sonnet-4-5-20250929";
+var MAX_TOKENS = 4096;
+var TIMEOUT_MS = 12e4;
+async function resolveApiKey() {
+  const envKey = process.env.SWIFTPATCH_CLAUDE_API_KEY;
+  if (envKey && isValidClaudeKey(envKey)) {
+    return envKey;
+  }
+  const storedKey = auth.getClaudeApiKey();
+  if (storedKey && isValidClaudeKey(storedKey)) {
+    return storedKey;
+  }
+  if (auth.isLoggedIn()) {
+    try {
+      const { apiKey } = await api.getClaudeApiKey();
+      if (apiKey && isValidClaudeKey(apiKey)) {
+        return apiKey;
+      }
+    } catch {
+      logger.debug("Platform Claude key not available, skipping");
+    }
+  }
+  return null;
+}
+function isValidClaudeKey(key) {
+  return typeof key === "string" && key.startsWith("sk-ant-") && key.length > 20;
+}
+async function createClient() {
+  const apiKey = await resolveApiKey();
+  if (!apiKey) {
+    throw new Error(
+      "No Claude API key configured.\n\n  Set one with:\n    swiftpatch config set claudeApiKey <your-key>\n\n  Or set the SWIFTPATCH_CLAUDE_API_KEY environment variable.\n\n  Get a key at: https://console.anthropic.com/settings/keys"
+    );
+  }
+  return new Anthropic({
+    apiKey,
+    timeout: TIMEOUT_MS,
+    maxRetries: 2
+  });
+}
+async function claudeChat(messages, options = {}) {
+  const client = await createClient();
+  const response = await client.messages.create({
+    model: CLAUDE_MODEL,
+    max_tokens: options.maxTokens || MAX_TOKENS,
+    ...options.system ? { system: options.system } : {},
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+    messages
+  });
+  const textBlock = response.content.find((block) => block.type === "text");
+  if (!textBlock || textBlock.type !== "text") {
+    throw new Error("Unexpected response format from Claude");
+  }
+  return textBlock.text;
+}
+async function claudeStream(messages, options = {}) {
+  const client = await createClient();
+  let fullText = "";
+  const stream = client.messages.stream({
+    model: CLAUDE_MODEL,
+    max_tokens: options.maxTokens || MAX_TOKENS,
+    ...options.system ? { system: options.system } : {},
+    ...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+    messages
+  });
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+      process.stdout.write(event.delta.text);
+      fullText += event.delta.text;
+    }
+  }
+  return fullText;
+}
+
+// src/utils/consent.ts
+init_esm_shims();
+init_config();
+import chalk31 from "chalk";
+import inquirer20 from "inquirer";
+var SCOPE_DESCRIPTIONS = {
+  "project-files": "Project config files (package.json, build.gradle, Podfile)",
+  "git-history": "Git commit messages, file change names, and diff stats",
+  "git-diff": "Code diff content from your changed JS/TS files",
+  "project-structure": "Project directory structure and file existence checks"
+};
+async function requireConsent(scopes, options = {}) {
+  if (options.yes) {
+    return true;
+  }
+  const consentedScopes = config.get("aiConsentScopes");
+  if (consentedScopes) {
+    const allConsented = scopes.every((s) => consentedScopes.includes(s));
+    if (allConsented) {
+      return true;
+    }
+  }
+  console.log("");
+  console.log(chalk31.bold("  Data Access Notice"));
+  console.log("");
+  console.log("  This command will read the following local data and send");
+  console.log("  a summary to Claude AI (Anthropic) for analysis:");
+  console.log("");
+  for (const scope of scopes) {
+    console.log(`    ${chalk31.cyan("\u2022")} ${SCOPE_DESCRIPTIONS[scope]}`);
+  }
+  console.log("");
+  console.log(chalk31.gray("  No source code is stored. Data is sent via encrypted HTTPS."));
+  console.log(chalk31.gray("  See: https://docs.swiftpatch.io/privacy/ai"));
+  console.log("");
+  const { consent } = await inquirer20.prompt([
+    {
+      type: "confirm",
+      name: "consent",
+      message: "Allow SwiftPatch AI to analyze this data?",
+      default: true
+    }
+  ]);
+  if (!consent) {
+    logger.info("AI analysis cancelled. No data was sent.");
+    return false;
+  }
+  const { remember } = await inquirer20.prompt([
+    {
+      type: "confirm",
+      name: "remember",
+      message: "Remember this choice for future runs?",
+      default: true
+    }
+  ]);
+  if (remember) {
+    const existing = config.get("aiConsentScopes") || [];
+    const merged = [.../* @__PURE__ */ new Set([...existing, ...scopes])];
+    config.set("aiConsentScopes", merged);
+    logger.info(`Consent saved. Reset with: ${chalk31.cyan("swiftpatch config delete aiConsentScopes")}`);
+  }
+  return true;
+}
+
+// src/commands/ai-doctor.ts
+async function collectDiagnostics(projectRoot) {
+  const diag = {
+    projectRoot,
+    packageJson: null,
+    reactNativeVersion: null,
+    nativeDeps: [],
+    assets: [],
+    hermesEnabled: false,
+    hasSigningKey: false,
+    podfileLockHash: null,
+    gradleDeps: [],
+    warnings: []
+  };
+  const pkgPath = path5.join(projectRoot, "package.json");
+  if (await fs7.pathExists(pkgPath)) {
+    try {
+      diag.packageJson = await fs7.readJson(pkgPath);
+      const deps = { ...diag.packageJson?.dependencies, ...diag.packageJson?.devDependencies };
+      diag.reactNativeVersion = deps?.["react-native"] || null;
+      const nativeModulePatterns = [
+        "react-native-",
+        "@react-native/",
+        "@react-native-community/",
+        "expo-",
+        "react-native-reanimated",
+        "react-native-gesture-handler",
+        "react-native-screens",
+        "react-native-svg",
+        "lottie-react-native",
+        "@shopify/react-native-skia"
+      ];
+      for (const [dep] of Object.entries(deps || {})) {
+        if (nativeModulePatterns.some((p) => dep.startsWith(p) || dep === p)) {
+          diag.nativeDeps.push(`${dep}@${deps[dep]}`);
+        }
+      }
+    } catch {
+      diag.warnings.push("Failed to parse package.json");
+    }
+  } else {
+    diag.warnings.push("No package.json found \u2014 are you in a React Native project root?");
+  }
+  const assetDirs = ["assets", "src/assets", "app/assets", "src/images"];
+  for (const dir of assetDirs) {
+    const fullDir = path5.join(projectRoot, dir);
+    if (await fs7.pathExists(fullDir)) {
+      try {
+        const files = await fs7.readdir(fullDir);
+        for (const file of files.slice(0, 50)) {
+          try {
+            const stat = await fs7.stat(path5.join(fullDir, file));
+            if (stat.isFile() && stat.size > 100 * 1024) {
+              diag.assets.push({ name: `${dir}/${file}`, sizeKB: Math.round(stat.size / 1024) });
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  const gradlePath = path5.join(projectRoot, "android/app/build.gradle");
+  if (await fs7.pathExists(gradlePath)) {
+    try {
+      const gradle = await fs7.readFile(gradlePath, "utf-8");
+      diag.hermesEnabled = gradle.includes("hermesEnabled") && !gradle.includes("hermesEnabled: false");
+      const depMatches = gradle.match(/implementation\s+['"]([^'"]+)['"]/g);
+      if (depMatches) {
+        diag.gradleDeps = depMatches.slice(0, 20).map((m) => m.replace(/implementation\s+['"]/, "").replace(/['"]/, ""));
+      }
+    } catch {
+    }
+  }
+  const gradlePropsPath = path5.join(projectRoot, "android/gradle.properties");
+  if (await fs7.pathExists(gradlePropsPath)) {
+    try {
+      const props = await fs7.readFile(gradlePropsPath, "utf-8");
+      if (props.includes("newArchEnabled=true")) {
+        diag.warnings.push("New Architecture is enabled \u2014 ensure your OTA bundle is compatible");
+      }
+    } catch {
+    }
+  }
+  const signingPaths = [
+    path5.join(projectRoot, "swiftpatch-private.pem"),
+    path5.join(projectRoot, ".swiftpatch/private.pem"),
+    path5.join(projectRoot, "keys/swiftpatch-private.pem")
+  ];
+  for (const p of signingPaths) {
+    if (await fs7.pathExists(p)) {
+      diag.hasSigningKey = true;
+      break;
+    }
+  }
+  const podfileLock = path5.join(projectRoot, "ios/Podfile.lock");
+  if (await fs7.pathExists(podfileLock)) {
+    try {
+      const stat = await fs7.stat(podfileLock);
+      diag.podfileLockHash = `modified:${stat.mtimeMs}`;
+    } catch {
+    }
+  }
+  return diag;
+}
+var aiDoctorCommand = new Command34("doctor").description("AI-powered pre-publish diagnostics for your React Native project").option("-d, --dir <path>", "Project root directory", process.cwd()).option("-y, --yes", "Skip consent prompt (for CI/CD)").option("--json", "Output raw diagnostics as JSON").action(async (options) => {
+  const projectRoot = path5.resolve(options.dir);
+  if (!await fs7.pathExists(path5.join(projectRoot, "package.json"))) {
+    logger.error("No package.json found. Run this from your React Native project root.");
+    process.exit(1);
+  }
+  const consented = await requireConsent(
+    ["project-files", "project-structure"],
+    { yes: options.yes }
+  );
+  if (!consented) {
+    process.exit(0);
+  }
+  const spinner = ora27("Scanning project...").start();
+  let diag;
+  try {
+    diag = await collectDiagnostics(projectRoot);
+    spinner.succeed("Project scanned");
+  } catch (error) {
+    spinner.fail(`Scan failed: ${error.message}`);
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(diag, null, 2));
+    return;
+  }
+  console.log("");
+  console.log(chalk32.bold("  Project Diagnostics"));
+  console.log("");
+  if (diag.reactNativeVersion) {
+    console.log(`  React Native:  ${chalk32.cyan(diag.reactNativeVersion)}`);
+  }
+  console.log(`  Native deps:   ${chalk32.cyan(String(diag.nativeDeps.length))}`);
+  console.log(`  Hermes:        ${diag.hermesEnabled ? chalk32.green("Enabled") : chalk32.yellow("Disabled")}`);
+  console.log(`  Signing key:   ${diag.hasSigningKey ? chalk32.green("Found") : chalk32.yellow("Not found")}`);
+  if (diag.assets.length > 0) {
+    console.log("");
+    console.log(chalk32.bold("  Large Assets (>100KB):"));
+    for (const asset of diag.assets.slice(0, 10)) {
+      const color = asset.sizeKB > 500 ? chalk32.red : chalk32.yellow;
+      console.log(`    ${color(`${asset.sizeKB}KB`)}  ${asset.name}`);
+    }
+    if (diag.assets.length > 10) {
+      console.log(chalk32.gray(`    ... and ${diag.assets.length - 10} more`));
+    }
+  }
+  if (diag.warnings.length > 0) {
+    console.log("");
+    for (const w of diag.warnings) {
+      logger.warning(w);
+    }
+  }
+  const aiSpinner = ora27("Analyzing with Claude AI...").start();
+  try {
+    const systemPrompt = "You are SwiftPatch Doctor, an expert in React Native OTA (Over-The-Air) updates. Analyze the project diagnostics and provide a concise, actionable report. Focus on:\n1. Native dependency risks: identify deps that require a full app store release if changed\n2. Bundle size concerns: large assets, unnecessary imports\n3. Hermes compatibility: is the config optimal for OTA?\n4. Signing: is bundle signing configured?\n5. Overall OTA readiness score (1-10)\n\nFormat your response with clear sections using markdown-style headers (##). Be direct and specific. Do not explain what OTA is. The user is a developer.";
+    const diagnosticsSummary = JSON.stringify({
+      reactNativeVersion: diag.reactNativeVersion,
+      nativeDeps: diag.nativeDeps,
+      largeAssets: diag.assets,
+      hermesEnabled: diag.hermesEnabled,
+      hasSigningKey: diag.hasSigningKey,
+      hasPodfileLock: !!diag.podfileLockHash,
+      gradleDeps: diag.gradleDeps,
+      localWarnings: diag.warnings
+    }, null, 2);
+    const analysis = await claudeChat(
+      [{ role: "user", content: `Analyze this React Native project for OTA update readiness:
+
+${diagnosticsSummary}` }],
+      { system: systemPrompt, temperature: 0.3 }
+    );
+    aiSpinner.succeed("AI analysis complete");
+    console.log("");
+    console.log(chalk32.bold("  AI Analysis"));
+    console.log("");
+    for (const line of analysis.split("\n")) {
+      console.log(`  ${line}`);
+    }
+    console.log("");
+  } catch (error) {
+    aiSpinner.fail(`AI analysis failed: ${error.message}`);
+    console.log("");
+    console.log(chalk32.gray("  Local diagnostics above are still valid."));
+    console.log("");
+    process.exit(1);
+  }
+});
+
+// src/commands/ai-explain.ts
+init_esm_shims();
+import { Command as Command35 } from "commander";
+import chalk33 from "chalk";
+import ora28 from "ora";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var MAX_CONTEXT_BYTES = 12e3;
+async function gitCommand(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd,
+      maxBuffer: 512 * 1024,
+      timeout: 15e3
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function getLastReleaseTag(cwd) {
+  const patterns = ["swiftpatch-*", "release-*", "v*"];
+  for (const pattern of patterns) {
+    const tag = await gitCommand(
+      ["describe", "--tags", "--match", pattern, "--abbrev=0", "HEAD~1"],
+      cwd
+    );
+    if (tag) return tag;
+  }
+  const anyTag = await gitCommand(["describe", "--tags", "--abbrev=0", "HEAD~1"], cwd);
+  return anyTag;
+}
+var aiExplainCommand = new Command35("explain").description("Generate a changelog from git history using AI").option("-f, --from <ref>", "Start ref (tag, commit, or branch). Defaults to last tag.").option("-t, --to <ref>", "End ref", "HEAD").option("--format <type>", "Output format: markdown, plain, json", "markdown").option("--max-commits <n>", "Maximum commits to analyze", "50").option("-y, --yes", "Skip consent prompt (for CI/CD)").option("--json", "Output structured JSON").action(async (options) => {
+  const cwd = process.cwd();
+  const isGit = await gitCommand(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (isGit !== "true") {
+    logger.error("Not a git repository. Run this from your project root.");
+    process.exit(1);
+  }
+  const consented = await requireConsent(
+    ["git-history"],
+    { yes: options.yes }
+  );
+  if (!consented) {
+    process.exit(0);
+  }
+  const spinner = ora28("Gathering git history...").start();
+  let fromRef = options.from;
+  if (!fromRef) {
+    fromRef = await getLastReleaseTag(cwd);
+    if (!fromRef) {
+      fromRef = `HEAD~${Math.min(parseInt(options.maxCommits, 10), 50)}`;
+      spinner.text = `No release tags found. Using last ${options.maxCommits} commits...`;
+    }
+  }
+  const toRef = options.to;
+  const maxCommits = Math.min(Math.max(parseInt(options.maxCommits, 10) || 50, 1), 100);
+  const logOutput = await gitCommand(
+    ["log", `${fromRef}..${toRef}`, `--max-count=${maxCommits}`, "--pretty=format:%h|%s|%an|%ad", "--date=short"],
+    cwd
+  );
+  if (!logOutput) {
+    spinner.fail("No commits found in the specified range.");
+    console.log("");
+    console.log(chalk33.gray(`  Range: ${fromRef}..${toRef}`));
+    console.log("");
+    process.exit(1);
+  }
+  const diffStat = await gitCommand(
+    ["diff", "--stat", `${fromRef}..${toRef}`],
+    cwd
+  );
+  const changedFiles = await gitCommand(
+    ["diff", "--name-only", `${fromRef}..${toRef}`],
+    cwd
+  );
+  spinner.succeed(`Found ${logOutput.split("\n").length} commits (${fromRef}..${toRef})`);
+  const truncatedLog = logOutput.slice(0, MAX_CONTEXT_BYTES);
+  const truncatedStat = (diffStat || "").slice(0, MAX_CONTEXT_BYTES / 2);
+  const truncatedFiles = (changedFiles || "").slice(0, MAX_CONTEXT_BYTES / 2);
+  const outputFormat = options.json ? "json" : options.format;
+  const systemPrompt = "You are a senior developer writing release notes for a React Native app that uses SwiftPatch for OTA updates. Generate a clear, professional changelog from the provided git history.\n\nRules:\n- Group changes by category: Features, Bug Fixes, Improvements, Breaking Changes\n- Only include Breaking Changes if there are actual breaking API or behavior changes\n- Omit empty categories\n- Write for end-users and fellow developers, not bots\n- Be concise: one line per change\n- Highlight any changes that affect native code (these CANNOT be delivered via OTA)\n" + (outputFormat === "json" ? '- Return valid JSON with structure: { "summary": "...", "categories": [{ "name": "...", "changes": ["..."] }], "nativeChanges": boolean, "otaSafe": boolean }' : outputFormat === "markdown" ? "- Use markdown formatting with ## headers" : "- Use plain text formatting, no markdown");
+  const userMessage = `Generate a changelog for these changes:
+
+## Commits
+${truncatedLog}
+
+## Changed Files
+${truncatedFiles}
+
+## Diff Stats
+${truncatedStat}`;
+  if (outputFormat === "json") {
+    const aiSpinner = ora28("Generating changelog with AI...").start();
+    try {
+      const result = await claudeChat(
+        [{ role: "user", content: userMessage }],
+        { system: systemPrompt, temperature: 0.3 }
+      );
+      aiSpinner.succeed("Changelog generated");
+      console.log("");
+      console.log(result);
+      console.log("");
+    } catch (error) {
+      aiSpinner.fail(`Failed: ${error.message}`);
+      process.exit(1);
+    }
+  } else {
+    console.log("");
+    process.stdout.write(chalk33.dim(""));
+    try {
+      await claudeStream(
+        [{ role: "user", content: userMessage }],
+        { system: systemPrompt, temperature: 0.3 }
+      );
+      console.log("");
+      console.log("");
+    } catch (error) {
+      console.log("");
+      logger.error(`Failed: ${error.message}`);
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/ai-review.ts
+init_esm_shims();
+import { Command as Command36 } from "commander";
+import chalk34 from "chalk";
+import ora29 from "ora";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var MAX_DIFF_BYTES = 15e3;
+var HIGH_RISK_PATTERNS = [
+  "android/",
+  "ios/",
+  "Podfile",
+  "build.gradle",
+  "AndroidManifest.xml",
+  "Info.plist",
+  "settings.gradle",
+  ".pbxproj",
+  "Podfile.lock"
+];
+var SENSITIVE_PATTERNS = [
+  "auth",
+  "login",
+  "token",
+  "payment",
+  "checkout",
+  "security",
+  "crypto",
+  "encrypt",
+  "password",
+  "secret",
+  "api-key",
+  "apiKey",
+  "credential"
+];
+async function gitCommand2(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync2("git", args, {
+      cwd,
+      maxBuffer: 1024 * 1024,
+      timeout: 15e3
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function analyzeChangesLocally(fromRef, toRef, cwd) {
+  const result = {
+    nativeFileChanges: [],
+    sensitiveFileChanges: [],
+    totalFilesChanged: 0,
+    linesAdded: 0,
+    linesRemoved: 0,
+    hasNativeChanges: false,
+    hasSensitiveChanges: false,
+    changedFiles: [],
+    diffExcerpt: ""
+  };
+  const filesOutput = await gitCommand2(
+    ["diff", "--name-only", `${fromRef}..${toRef}`],
+    cwd
+  );
+  if (!filesOutput) return result;
+  const files = filesOutput.split("\n").filter(Boolean);
+  result.changedFiles = files;
+  result.totalFilesChanged = files.length;
+  for (const file of files) {
+    const lower = file.toLowerCase();
+    if (HIGH_RISK_PATTERNS.some((p) => lower.includes(p.toLowerCase()))) {
+      result.nativeFileChanges.push(file);
+      result.hasNativeChanges = true;
+    }
+    if (SENSITIVE_PATTERNS.some((p) => lower.includes(p))) {
+      result.sensitiveFileChanges.push(file);
+      result.hasSensitiveChanges = true;
+    }
+  }
+  const statsOutput = await gitCommand2(
+    ["diff", "--shortstat", `${fromRef}..${toRef}`],
+    cwd
+  );
+  if (statsOutput) {
+    const addMatch = statsOutput.match(/(\d+) insertion/);
+    const delMatch = statsOutput.match(/(\d+) deletion/);
+    result.linesAdded = addMatch ? parseInt(addMatch[1], 10) : 0;
+    result.linesRemoved = delMatch ? parseInt(delMatch[1], 10) : 0;
+  }
+  const jsDiff = await gitCommand2(
+    [
+      "diff",
+      `${fromRef}..${toRef}`,
+      "--",
+      "*.ts",
+      "*.tsx",
+      "*.js",
+      "*.jsx",
+      ":!node_modules",
+      ":!*.lock",
+      ":!dist/",
+      ":!build/"
+    ],
+    cwd
+  );
+  if (jsDiff) {
+    result.diffExcerpt = jsDiff.slice(0, MAX_DIFF_BYTES);
+  }
+  return result;
+}
+var aiReviewCommand = new Command36("review").description("AI-powered safety review of changes before OTA deployment").option("-f, --from <ref>", "Start ref (tag, commit, or branch). Defaults to last tag.").option("-t, --to <ref>", "End ref", "HEAD").option("-y, --yes", "Skip consent prompt (for CI/CD)").option("--json", "Output as JSON").action(async (options) => {
+  const cwd = process.cwd();
+  const isGit = await gitCommand2(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (isGit !== "true") {
+    logger.error("Not a git repository. Run this from your project root.");
+    process.exit(1);
+  }
+  const consented = await requireConsent(
+    ["git-history", "git-diff"],
+    { yes: options.yes }
+  );
+  if (!consented) {
+    process.exit(0);
+  }
+  const spinner = ora29("Analyzing changes...").start();
+  let fromRef = options.from;
+  if (!fromRef) {
+    fromRef = await gitCommand2(["describe", "--tags", "--abbrev=0", "HEAD~1"], cwd);
+    if (!fromRef) {
+      fromRef = "HEAD~10";
+      spinner.text = "No tags found. Comparing against last 10 commits...";
+    }
+  }
+  const toRef = options.to;
+  let analysis;
+  try {
+    analysis = await analyzeChangesLocally(fromRef, toRef, cwd);
+  } catch (error) {
+    spinner.fail(`Analysis failed: ${error.message}`);
+    process.exit(1);
+  }
+  if (analysis.totalFilesChanged === 0) {
+    spinner.succeed("No changes found");
+    console.log("");
+    console.log(chalk34.gray(`  Range: ${fromRef}..${toRef}`));
+    console.log(chalk34.green("  Nothing to review \u2014 working tree is clean."));
+    console.log("");
+    return;
+  }
+  spinner.succeed(`Found ${analysis.totalFilesChanged} changed files (+${analysis.linesAdded} -${analysis.linesRemoved})`);
+  if (analysis.hasNativeChanges) {
+    console.log("");
+    logger.warning(chalk34.bold("Native file changes detected \u2014 these CANNOT be delivered via OTA:"));
+    for (const f of analysis.nativeFileChanges) {
+      console.log(`    ${chalk34.red("!")} ${f}`);
+    }
+  }
+  if (analysis.hasSensitiveChanges) {
+    console.log("");
+    logger.warning(chalk34.bold("Sensitive file changes detected \u2014 review carefully:"));
+    for (const f of analysis.sensitiveFileChanges) {
+      console.log(`    ${chalk34.yellow("!")} ${f}`);
+    }
+  }
+  const aiSpinner = ora29("Running AI safety review...").start();
+  try {
+    const systemPrompt = "You are SwiftPatch Review, an expert in React Native OTA update safety. Analyze the code diff and provide a safety assessment for shipping this as an OTA update.\n\nYour response MUST include:\n1. **OTA Safety Score** (1-10, where 10 is perfectly safe)\n2. **Verdict**: SAFE, CAUTION, or UNSAFE\n3. **Risk Summary**: 1-2 sentences about the overall risk\n4. **Issues Found**: List specific concerns (if any)\n5. **Recommendation**: Should this be shipped as OTA or requires app store release?\n\nRisk factors to check:\n- Native code changes (cannot be OTA updated)\n- Authentication/security logic changes\n- API endpoint changes (URL, headers, auth)\n- Error handling removal or weakening\n- Removal of safety checks or validation\n- Large structural refactors that may introduce regressions\n- Third-party SDK version changes\n\nBe concise and specific. Developers are your audience.";
+    const contextData = JSON.stringify({
+      range: `${fromRef}..${toRef}`,
+      totalFilesChanged: analysis.totalFilesChanged,
+      linesAdded: analysis.linesAdded,
+      linesRemoved: analysis.linesRemoved,
+      nativeFileChanges: analysis.nativeFileChanges,
+      sensitiveFileChanges: analysis.sensitiveFileChanges,
+      changedFiles: analysis.changedFiles.slice(0, 50)
+    }, null, 2);
+    const userMessage = `Review this OTA update for safety:
+
+## Change Summary
+${contextData}
+
+## Code Diff (JS/TS only)
+\`\`\`diff
+${analysis.diffExcerpt}
+\`\`\``;
+    const result = await claudeChat(
+      [{ role: "user", content: userMessage }],
+      { system: systemPrompt, temperature: 0.2 }
+    );
+    aiSpinner.succeed("Safety review complete");
+    if (options.json) {
+      console.log(JSON.stringify({
+        range: `${fromRef}..${toRef}`,
+        localAnalysis: {
+          totalFilesChanged: analysis.totalFilesChanged,
+          linesAdded: analysis.linesAdded,
+          linesRemoved: analysis.linesRemoved,
+          hasNativeChanges: analysis.hasNativeChanges,
+          hasSensitiveChanges: analysis.hasSensitiveChanges,
+          nativeFileChanges: analysis.nativeFileChanges,
+          sensitiveFileChanges: analysis.sensitiveFileChanges
+        },
+        aiReview: result
+      }, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(chalk34.bold("  AI Safety Review"));
+    console.log("");
+    for (const line of result.split("\n")) {
+      console.log(`  ${line}`);
+    }
+    console.log("");
+  } catch (error) {
+    aiSpinner.fail(`AI review failed: ${error.message}`);
+    console.log("");
+    console.log(chalk34.gray("  Local analysis above is still valid."));
+    console.log("");
+    process.exit(1);
+  }
+});
+
+// src/commands/ai.ts
+var aiCommand = new Command37("ai").description("AI-powered release intelligence");
+aiCommand.addCommand(aiDoctorCommand);
+aiCommand.addCommand(aiExplainCommand);
+aiCommand.addCommand(aiReviewCommand);
+aiCommand.command("ask").description("Ask AI about your releases, crashes, or deployment strategy").argument("<question>", "Your question").option("-o, --org <org-id>", "Organization ID").option("-a, --app <app-id>", "App ID for context").action(async (question, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  process.stdout.write(chalk35.dim("AI: "));
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 6e4);
+  try {
+    const response = await fetch(
+      `${api.getBaseUrl()}/orgs/${orgId}/ai/chat`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...api.getAuthHeaders()
+        },
+        body: JSON.stringify({
+          message: question,
+          context: {
+            page: "cli",
+            ...options.app ? { entityType: "app", entityId: options.app } : {}
+          }
+        }),
+        signal: controller.signal
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Request failed: ${response.status} ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") break;
+          process.stdout.write(data);
+        }
+      }
+    }
+    console.log("");
+    console.log("");
+  } catch (error) {
+    console.log("");
+    if (error.name === "AbortError") {
+      console.error(chalk35.red("AI request timed out after 60 seconds."));
+    } else {
+      console.error(chalk35.red(`Failed: ${error.message}`));
+    }
+    process.exit(1);
+  } finally {
+    clearTimeout(timeout);
+  }
+});
+aiCommand.command("risk-score").description("Get AI risk assessment for a release").requiredOption("-o, --org <org-id>", "Organization ID").requiredOption("-a, --app <app-id>", "App ID").requiredOption("-r, --release <release-id>", "Release ID").option("--json", "Output as JSON").action(async (options) => {
+  await requireAuth();
+  const orgId = options.org;
+  const spinner = ora30("Assessing release risk...").start();
+  try {
+    const assessment = await api.aiRiskAssessment(orgId, options.app, options.release);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(assessment, null, 2));
+      return;
+    }
+    const levelColors = {
+      LOW: chalk35.green,
+      MEDIUM: chalk35.yellow,
+      HIGH: chalk35.hex("#f97316"),
+      CRITICAL: chalk35.red
+    };
+    const colorFn = levelColors[assessment.level] || chalk35.white;
+    console.log("");
+    console.log(chalk35.bold("  Risk Assessment"));
+    console.log("");
+    console.log(`  Score:   ${colorFn(String(assessment.score) + "/100")}`);
+    console.log(`  Level:   ${colorFn(assessment.level)}`);
+    console.log("");
+    console.log(chalk35.bold("  Risk Factors:"));
+    for (const factor of assessment.factors) {
+      const bar = "\u2588".repeat(factor.impact) + "\u2591".repeat(10 - factor.impact);
+      console.log(`    ${bar} ${factor.factor}`);
+      console.log(`    ${chalk35.gray(factor.description)}`);
+    }
+    console.log("");
+    console.log(chalk35.bold("  Recommendation:"));
+    console.log(`    ${assessment.recommendation}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+aiCommand.command("crashes").description("List AI-grouped crash reports for an app").requiredOption("-o, --org <org-id>", "Organization ID").requiredOption("-a, --app <app-id>", "App ID").option("-s, --status <status>", "Filter by status (OPEN, RESOLVED, IGNORED)", "OPEN").option("-l, --limit <limit>", "Maximum number of results", "10").option("--json", "Output as JSON").action(async (options) => {
+  await requireAuth();
+  const spinner = ora30("Fetching crash groups...").start();
+  try {
+    const groups = await api.aiCrashGroups(options.org, options.app, {
+      status: options.status,
+      limit: parseInt(options.limit, 10)
+    });
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(groups, null, 2));
+      return;
+    }
+    if (groups.length === 0) {
+      console.log(chalk35.green("\n  No crash groups found. Your app is running smoothly!\n"));
+      return;
+    }
+    console.log("");
+    console.log(chalk35.bold(`  Crash Groups (${groups.length})`));
+    console.log("");
+    const severityColors = {
+      CRITICAL: chalk35.red,
+      HIGH: chalk35.hex("#f97316"),
+      MEDIUM: chalk35.yellow,
+      LOW: chalk35.blue
+    };
+    for (const group of groups) {
+      const colorFn = severityColors[group.severity] || chalk35.white;
+      console.log(`  ${colorFn(`[${group.severity}]`)} ${group.title}`);
+      console.log(`    ${chalk35.gray(`${group.occurrenceCount} occurrences \xB7 ${group.affectedDevices} devices \xB7 ${group.category}`)}`);
+      if (group.aiAnalysis) {
+        console.log(`    ${chalk35.cyan("AI:")} ${group.aiAnalysis.rootCause.slice(0, 100)}${group.aiAnalysis.rootCause.length > 100 ? "..." : ""}`);
+      }
+      console.log("");
+    }
+  } catch (error) {
+    spinner.fail(`Failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+aiCommand.command("insights").description("View AI-generated insights for an app").requiredOption("-o, --org <org-id>", "Organization ID").requiredOption("-a, --app <app-id>", "App ID").option("-s, --status <status>", "Filter by status (ACTIVE, ACKNOWLEDGED, DISMISSED)", "ACTIVE").option("--json", "Output as JSON").action(async (options) => {
+  await requireAuth();
+  const spinner = ora30("Fetching AI insights...").start();
+  try {
+    const insights = await api.aiInsights(options.org, options.app, {
+      status: options.status
+    });
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify(insights, null, 2));
+      return;
+    }
+    if (insights.length === 0) {
+      console.log(chalk35.green("\n  No active insights. All systems nominal!\n"));
+      return;
+    }
+    console.log("");
+    console.log(chalk35.bold(`  AI Insights (${insights.length})`));
+    console.log("");
+    const priorityColors = {
+      CRITICAL: chalk35.red,
+      HIGH: chalk35.hex("#f97316"),
+      MEDIUM: chalk35.yellow,
+      LOW: chalk35.blue,
+      INFO: chalk35.gray
+    };
+    for (const insight of insights) {
+      const colorFn = priorityColors[insight.priority] || chalk35.white;
+      console.log(`  ${colorFn(`[${insight.priority}]`)} ${insight.title}`);
+      console.log(`    ${chalk35.gray(insight.summary)}`);
+      if (insight.actionItems.length > 0) {
+        for (const item of insight.actionItems) {
+          console.log(`    ${chalk35.cyan("\u2192")} ${item}`);
+        }
+      }
+      console.log("");
+    }
+  } catch (error) {
+    spinner.fail(`Failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/config.ts
+init_esm_shims();
+init_config();
+init_auth();
+import { Command as Command38 } from "commander";
+import chalk36 from "chalk";
+var VALID_KEYS = [
+  "apiUrl",
+  "defaultOrg",
+  "defaultApp",
+  "defaultPlatform",
+  "defaultChannel",
+  "aiConsentScopes"
+];
+var SECRET_KEYS = ["claudeApiKey"];
+var ALL_KEYS = [...VALID_KEYS, ...SECRET_KEYS];
+function isSecretKey(key) {
+  return SECRET_KEYS.includes(key);
+}
+function maskSecret(value) {
+  if (value.length <= 8) return "****";
+  return value.slice(0, 7) + "..." + "*".repeat(8);
+}
+var configCommands = new Command38("config").description("CLI configuration");
+configCommands.command("set").description("Set a config value").argument("<key>", "Config key").argument("<value>", "Config value").action((key, value) => {
+  if (!ALL_KEYS.includes(key)) {
+    logger.error(`Invalid config key: ${key}`);
+    console.log("");
+    console.log("Valid keys: " + ALL_KEYS.map((k) => chalk36.cyan(k)).join(", "));
+    console.log("");
+    process.exit(1);
+  }
+  if (isSecretKey(key)) {
+    if (key === "claudeApiKey") {
+      if (!value.startsWith("sk-ant-") || value.length <= 20) {
+        logger.error('Invalid Claude API key format. Keys start with "sk-ant-"');
+        console.log("");
+        console.log("  Get a key at: " + chalk36.cyan("https://console.anthropic.com/settings/keys"));
+        console.log("");
+        process.exit(1);
+      }
+      auth.setClaudeApiKey(value);
+      logger.success(`Set ${chalk36.cyan(key)} = ${chalk36.gray(maskSecret(value))} (encrypted)`);
+    }
+    return;
+  }
+  config.set(key, value);
+  logger.success(`Set ${chalk36.cyan(key)} = ${chalk36.gray(value)}`);
+});
+configCommands.command("get").description("Get a config value").argument("<key>", "Config key").action((key) => {
+  if (isSecretKey(key)) {
+    if (key === "claudeApiKey") {
+      const value2 = auth.getClaudeApiKey();
+      if (!value2) {
+        logger.info(`${key} is not set`);
+      } else {
+        console.log(`${chalk36.cyan(key)} = ${maskSecret(value2)} (encrypted)`);
+      }
+    }
+    return;
+  }
+  const value = config.get(key);
+  if (value === void 0) {
+    logger.info(`${key} is not set`);
+  } else {
+    console.log(`${chalk36.cyan(key)} = ${value}`);
+  }
+});
+configCommands.command("delete").description("Delete a config value").argument("<key>", "Config key").action((key) => {
+  if (!ALL_KEYS.includes(key)) {
+    logger.error(`Invalid config key: ${key}`);
+    process.exit(1);
+  }
+  if (isSecretKey(key)) {
+    if (key === "claudeApiKey") {
+      auth.deleteClaudeApiKey();
+      logger.success(`Deleted ${chalk36.cyan(key)}`);
+    }
+    return;
+  }
+  config.delete(key);
+  logger.success(`Deleted ${chalk36.cyan(key)}`);
+});
+configCommands.command("list").description("List all config values").action(() => {
+  const all = config.getAll();
+  const plainKeys = Object.keys(all);
+  const hasClaudeKey = !!auth.getClaudeApiKey();
+  if (plainKeys.length === 0 && !hasClaudeKey) {
+    console.log("");
+    console.log(chalk36.gray("  No config values set."));
+    console.log("");
+    console.log("  Set a value with: " + chalk36.cyan("swiftpatch config set <key> <value>"));
+    console.log("");
+    return;
+  }
+  console.log("");
+  console.log(chalk36.bold("  CLI Configuration"));
+  console.log("");
+  plainKeys.forEach((key) => {
+    console.log(`  ${chalk36.cyan(key)} = ${all[key]}`);
+  });
+  if (hasClaudeKey) {
+    const key = auth.getClaudeApiKey();
+    console.log(`  ${chalk36.cyan("claudeApiKey")} = ${maskSecret(key)} ${chalk36.gray("(encrypted)")}`);
+  }
+  console.log("");
+  console.log(chalk36.gray(`  Config path: ${config.path}`));
+  console.log("");
+});
+
+// src/commands/publish-bundle.ts
+init_esm_shims();
+init_api();
+import { Command as Command39 } from "commander";
+import chalk37 from "chalk";
+import ora31 from "ora";
+import path9 from "path";
+import fs11 from "fs-extra";
+import os3 from "os";
+
+// src/lib/archive.ts
+init_esm_shims();
+import archiver from "archiver";
+import fs8 from "fs";
+import path6 from "path";
+function createZip(inputPath, outputPath) {
+  return new Promise((resolve, reject) => {
+    const zipPath = path6.join(outputPath, "build.zip");
+    const output = fs8.createWriteStream(zipPath);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    output.on("close", () => resolve());
+    archive.on("error", (err) => reject(err));
+    archive.pipe(output);
+    archive.directory(inputPath, "build");
+    archive.finalize();
+  });
+}
+
+// src/lib/artifacts.ts
+init_esm_shims();
+import fs9 from "fs-extra";
+import path7 from "path";
+async function keepArtifacts(contentRootPath, platform, variant) {
+  const artifactsDir = path7.join(process.cwd(), "swiftpatch-artifacts", platform, variant);
+  await fs9.ensureDir(artifactsDir);
+  const bundlesDir = path7.join(contentRootPath, "bundles");
+  const sourcemapsDir = path7.join(contentRootPath, "sourcemaps");
+  if (await fs9.pathExists(bundlesDir)) {
+    await copyDirRecursive(bundlesDir, path7.join(artifactsDir, "bundles"));
+  }
+  if (await fs9.pathExists(sourcemapsDir)) {
+    await copyDirRecursive(sourcemapsDir, path7.join(artifactsDir, "sourcemaps"));
+  }
+}
+async function copyDirRecursive(srcDir, destDir) {
+  await fs9.ensureDir(destDir);
+  const entries = await fs9.readdir(srcDir);
+  for (const entry of entries) {
+    const srcPath = path7.join(srcDir, entry);
+    const destPath = path7.join(destDir, entry);
+    const stat = await fs9.stat(srcPath);
+    if (stat.isDirectory()) {
+      await copyDirRecursive(srcPath, destPath);
+    } else {
+      await fs9.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+// src/lib/react-native-utils.ts
+init_esm_shims();
+import * as path8 from "path";
+import * as fs10 from "fs";
+import * as childProcess from "child_process";
+import { coerce, compare } from "semver";
+function findUpwardReactNativePackageJson(startDir = process.cwd()) {
+  let current = startDir;
+  while (current !== path8.parse(current).root) {
+    const candidate = path8.join(current, "node_modules", "react-native", "package.json");
+    if (fs10.existsSync(candidate)) return candidate;
+    current = path8.dirname(current);
+  }
+  return null;
+}
+function getReactNativeVersion() {
+  const rnPackageJsonPath = findUpwardReactNativePackageJson();
+  if (!rnPackageJsonPath) return null;
+  const rnPackageJson = JSON.parse(fs10.readFileSync(rnPackageJsonPath, "utf-8"));
+  return rnPackageJson.version;
+}
+function directoryExistsSync(dirname3) {
+  try {
+    return fs10.statSync(dirname3).isDirectory();
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  return false;
+}
+function getReactNativePackagePath() {
+  const rnPackageJsonPath = findUpwardReactNativePackageJson();
+  if (rnPackageJsonPath) return path8.dirname(rnPackageJsonPath);
+  const result = childProcess.spawnSync("node", [
+    "--print",
+    "require.resolve('react-native/package.json')"
+  ]);
+  const packagePath = path8.dirname(result.stdout.toString().trim());
+  if (result.status === 0 && directoryExistsSync(packagePath)) return packagePath;
+  return path8.join("node_modules", "react-native");
+}
+function resolvePackageDirFromCwd(packageName) {
+  const result = childProcess.spawnSync("node", [
+    "--print",
+    `require.resolve('${packageName}/package.json')`
+  ]);
+  if (result.status !== 0) return null;
+  const resolved = result.stdout.toString().trim();
+  if (!resolved) return null;
+  const packageDir = path8.dirname(resolved);
+  return directoryExistsSync(packageDir) ? packageDir : null;
+}
+function isValidPlatform(platform) {
+  return platform?.toLowerCase() === "android" || platform?.toLowerCase() === "ios";
+}
+function fileExists(filePath) {
+  try {
+    return fs10.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function getCliPath() {
+  return path8.join(getReactNativePackagePath(), "cli.js");
+}
+async function runReactNativeBundleCommand(bundleName, entryFile, outputFolder, platform, sourcemap, devMode) {
+  fs10.mkdirSync(path8.join(outputFolder, "bundles"), { recursive: true });
+  if (sourcemap) {
+    fs10.mkdirSync(path8.join(outputFolder, "sourcemaps"), { recursive: true });
+  }
+  const reactNativeBundleArgs = [
+    getCliPath(),
+    "bundle",
+    "--dev",
+    devMode,
+    "--assets-dest",
+    path8.join(outputFolder, "bundles"),
+    "--bundle-output",
+    path8.join(outputFolder, "bundles", bundleName),
+    "--entry-file",
+    entryFile,
+    "--platform",
+    platform,
+    ...sourcemap ? ["--sourcemap-output", path8.join(outputFolder, "sourcemaps", bundleName + ".map")] : []
+  ];
+  logger.info('Running "react-native bundle" command');
+  const reactNativeBundleProcess = childProcess.spawn("node", reactNativeBundleArgs);
+  return new Promise((resolve, reject) => {
+    reactNativeBundleProcess.stdout.on("data", (data) => {
+      console.log(data.toString().trim());
+    });
+    reactNativeBundleProcess.stderr.on("data", (data) => {
+      logger.error(data.toString().trim());
+    });
+    reactNativeBundleProcess.on("close", (exitCode, signal) => {
+      if (exitCode !== 0) {
+        reject(
+          new Error(`"react-native bundle" command failed (exitCode=${exitCode}, signal=${signal}).`)
+        );
+      }
+      resolve();
+    });
+  });
+}
+async function runHermesEmitBinaryCommand(bundleName, outputFolder, hermesLogs = false, hermescPath, sourcemap = false) {
+  const hermesArgs = [
+    ...sourcemap ? ["--output-source-map"] : [],
+    "--emit-binary",
+    "--out",
+    path8.join(outputFolder, bundleName + ".hbc"),
+    path8.join(outputFolder, "bundles", bundleName)
+  ];
+  logger.info("Converting JS bundle to Hermes bytecode");
+  const hermesCommand = await getHermesCommand();
+  logger.info(`Hermesc path: ${hermescPath || hermesCommand}`);
+  const hermesProcess = childProcess.spawn(hermescPath || hermesCommand, hermesArgs);
+  let logFile = null;
+  let isWarned = false;
+  if (hermesLogs) {
+    logFile = fs10.createWriteStream("output.log", { flags: "a" });
+  }
+  return new Promise((resolve, reject) => {
+    hermesProcess.stdout.on("data", (data) => {
+      logger.info(data.toString().trim());
+    });
+    hermesProcess.stderr.on("data", (data) => {
+      if (isWarned) {
+        if (hermesLogs && logFile) logFile.write(data.toString().trim());
+        return;
+      }
+      isWarned = true;
+      logger.warning("Hermes command executed with warnings. Use --hermes-logs for full logs.");
+    });
+    hermesProcess.on("close", (exitCode, signal) => {
+      if (hermesLogs && logFile) {
+        logger.success("Done writing logs in output.log file.");
+        logFile.end();
+      }
+      if (exitCode !== 0) {
+        reject(new Error(`"hermes" command failed (exitCode=${exitCode}, signal=${signal}).`));
+        return;
+      }
+      const source = path8.join(outputFolder, bundleName + ".hbc");
+      const destination = path8.join(outputFolder, "bundles", bundleName);
+      fs10.copyFile(source, destination, (err) => {
+        if (err) {
+          reject(new Error(`Copying Hermes output failed: ${err.message}`));
+          return;
+        }
+        fs10.unlink(source, (unlinkErr) => {
+          if (unlinkErr) {
+            reject(unlinkErr);
+            return;
+          }
+          resolve();
+        });
+      });
+    });
+  });
+}
+function getHermesOSBin() {
+  switch (process.platform) {
+    case "win32":
+      return "win64-bin";
+    case "darwin":
+      return "osx-bin";
+    default:
+      return "linux64-bin";
+  }
+}
+function getHermesOSExe() {
+  const versionObj = coerce(getReactNativeVersion());
+  if (!versionObj?.version) {
+    throw new Error("Unable to determine React Native version");
+  }
+  const react63orAbove = compare(versionObj.version, "0.63.0") !== -1;
+  const hermesExecutableName = react63orAbove ? "hermesc" : "hermes";
+  return process.platform === "win32" ? hermesExecutableName + ".exe" : hermesExecutableName;
+}
+async function getHermesCommand() {
+  const bundledHermesEngine = path8.join(
+    getReactNativePackagePath(),
+    "sdks",
+    "hermesc",
+    getHermesOSBin(),
+    getHermesOSExe()
+  );
+  if (fileExists(bundledHermesEngine)) return bundledHermesEngine;
+  const hermesEnginePackageDir = resolvePackageDirFromCwd("hermes-engine");
+  if (hermesEnginePackageDir) {
+    const hermesEngine2 = path8.join(hermesEnginePackageDir, getHermesOSBin(), getHermesOSExe());
+    if (fileExists(hermesEngine2)) return hermesEngine2;
+  }
+  const hermesEngine = path8.join("node_modules", "hermes-engine", getHermesOSBin(), getHermesOSExe());
+  if (fileExists(hermesEngine)) return hermesEngine;
+  const hermesCompilerPackageDir = resolvePackageDirFromCwd("hermes-compiler");
+  if (hermesCompilerPackageDir) {
+    const hermesCompiler2 = path8.join(hermesCompilerPackageDir, "hermesc", getHermesOSBin(), getHermesOSExe());
+    if (fileExists(hermesCompiler2)) return hermesCompiler2;
+  }
+  const hermesCompiler = path8.join("node_modules", "hermes-compiler", "hermesc", getHermesOSBin(), getHermesOSExe());
+  if (fileExists(hermesCompiler)) return hermesCompiler;
+  const hermesVmPackageDir = resolvePackageDirFromCwd("hermesvm");
+  if (hermesVmPackageDir) {
+    return path8.join(hermesVmPackageDir, getHermesOSBin(), "hermes");
+  }
+  return path8.join("node_modules", "hermesvm", getHermesOSBin(), "hermes");
+}
+
+// src/commands/publish-bundle.ts
+var publishBundleCommand = new Command39("publish-bundle").description("Bundle, compile Hermes, sign, and upload a JS bundle to SwiftPatch").requiredOption("-p, --platform <platform>", "Target platform (ios or android)").option("-a, --app <app-id>", "App ID or slug").option("-o, --org <org-id>", "Organization ID").option("-e, --entry-file <path>", "Entry file for React Native bundle", "index.js").option("-n, --release-note <note>", "Release notes", "").option("-k, --private-key <path>", "Path to RSA private key for bundle signing").option("--dev", "Create a development bundle", false).option("--sourcemap", "Generate sourcemaps", false).option("--hermes", "Compile to Hermes bytecode", false).option("--hermesc-path <path>", "Custom path to hermesc binary").option("--hermes-logs", "Output Hermes compilation logs to file", false).option("--keep-artifacts", "Save intermediate build artifacts for debugging", false).option("--ci-token <token>", "CI token for authentication (alternative to login)").action(async (options) => {
+  const platform = options.platform.toLowerCase();
+  if (!isValidPlatform(platform)) {
+    logger.error('Invalid platform. Must be "ios" or "android".');
+    process.exit(1);
+  }
+  const ciToken = options.ciToken || process.env.SWIFTPATCH_CI_TOKEN;
+  if (!ciToken) {
+    await requireAuth();
+  }
+  const orgId = ciToken ? void 0 : await resolveOrgId(options.org);
+  console.log("");
+  logger.info(chalk37.bold("SwiftPatch Publish Bundle"));
+  console.log("");
+  let appSlug = options.app;
+  let resolvedAppId = "";
+  if (!appSlug && !ciToken) {
+    const apps = await api.getApps(orgId);
+    if (apps.length === 0) {
+      logger.error("No apps found. Create one with: swiftpatch apps create");
+      process.exit(1);
+    }
+    if (apps.length === 1) {
+      appSlug = apps[0].slug || apps[0].id;
+      resolvedAppId = apps[0].id;
+      logger.info(`App: ${chalk37.cyan(apps[0].name)}`);
+    } else {
+      const inquirer24 = (await import("inquirer")).default;
+      const { selectedApp } = await inquirer24.prompt([
+        {
+          type: "list",
+          name: "selectedApp",
+          message: "Select app:",
+          choices: apps.map((app) => ({
+            name: `${app.name} (${app.platform})`,
+            value: app.slug || app.id
+          }))
+        }
+      ]);
+      appSlug = selectedApp;
+    }
+  }
+  const uploadPath = appSlug || resolvedAppId || "";
+  const entryFile = options.entryFile || "index.js";
+  const bundleName = platform === "ios" ? "main.jsbundle" : "index.android.bundle";
+  const contentRootPath = path9.join(os3.tmpdir(), `swiftpatch-publish-${Date.now()}`);
+  await fs11.ensureDir(contentRootPath);
+  try {
+    const spinner = ora31("Bundling JavaScript...").start();
+    try {
+      await runReactNativeBundleCommand(
+        bundleName,
+        entryFile,
+        contentRootPath,
+        platform,
+        options.sourcemap || false,
+        options.dev || false
+      );
+      spinner.succeed("JavaScript bundled");
+    } catch (error) {
+      spinner.fail(`Bundling failed: ${error.message}`);
+      process.exit(1);
+    }
+    if (options.keepArtifacts) {
+      await keepArtifacts(contentRootPath, platform, "normal");
+    }
+    if (options.hermes) {
+      const hermesSpinner = ora31("Compiling to Hermes bytecode...").start();
+      try {
+        await runHermesEmitBinaryCommand(
+          bundleName,
+          contentRootPath,
+          options.hermesLogs || false,
+          options.hermescPath,
+          options.sourcemap || false
+        );
+        hermesSpinner.succeed("Hermes bytecode compiled");
+      } catch (error) {
+        hermesSpinner.fail(`Hermes compilation failed: ${error.message}`);
+        process.exit(1);
+      }
+      if (options.keepArtifacts) {
+        await keepArtifacts(contentRootPath, platform, "hermes");
+      }
+    }
+    if (options.privateKey) {
+      const signSpinner = ora31("Signing bundle...").start();
+      try {
+        const bundlesDir2 = path9.join(contentRootPath, "bundles");
+        await signBundleDirectory(bundlesDir2, options.privateKey);
+        signSpinner.succeed("Bundle signed with JWT RS256");
+      } catch (error) {
+        signSpinner.fail(`Signing failed: ${error.message}`);
+        process.exit(1);
+      }
+    }
+    const zipSpinner = ora31("Creating ZIP archive...").start();
+    const bundlesDir = path9.join(contentRootPath, "bundles");
+    await createZip(bundlesDir, contentRootPath);
+    const zipPath = path9.join(contentRootPath, "build.zip");
+    if (!await fs11.pathExists(zipPath)) {
+      zipSpinner.fail("ZIP creation failed: build.zip not found");
+      process.exit(1);
+    }
+    const zipSize = (await fs11.stat(zipPath)).size;
+    zipSpinner.succeed(`ZIP archive created: ${chalk37.gray(formatBytes4(zipSize))}`);
+    const hashSpinner = ora31("Computing ZIP hash...").start();
+    const hash = calculateZipHash(zipPath);
+    if (!hash) {
+      hashSpinner.fail("Failed to compute ZIP hash");
+      process.exit(1);
+    }
+    hashSpinner.succeed(`ZIP hash: ${chalk37.gray(hash.slice(0, 16))}...`);
+    let bundleSignature;
+    if (options.privateKey) {
+      const bundlesDir2 = path9.join(contentRootPath, "bundles");
+      const sig = await readBundleSignature(bundlesDir2);
+      if (sig) bundleSignature = sig;
+    }
+    const urlSpinner = ora31("Requesting upload URL...").start();
+    try {
+      const { url } = await api.generateSignedUrl(
+        {
+          hash,
+          uploadPath,
+          platform,
+          releaseNote: options.releaseNote || "",
+          signature: bundleSignature
+        },
+        ciToken
+      );
+      urlSpinner.succeed("Upload URL received");
+      const uploadSpinner = ora31("Uploading bundle...").start();
+      await uploader.uploadZip(url, zipPath, (percent) => {
+        uploadSpinner.text = `Uploading bundle... ${percent}%`;
+      });
+      uploadSpinner.succeed("Bundle uploaded");
+      console.log("");
+      console.log(chalk37.green("  Bundle published successfully!"));
+      console.log("");
+      console.log(`  Hash:     ${chalk37.cyan(hash)}`);
+      console.log(`  Platform: ${chalk37.cyan(platform)}`);
+      console.log(`  Size:     ${chalk37.gray(formatBytes4(zipSize))}`);
+      if (options.hermes) {
+        console.log(`  Hermes:   ${chalk37.green("Yes")}`);
+      }
+      if (options.privateKey) {
+        console.log(`  Signed:   ${chalk37.green("Yes")}`);
+      }
+      console.log("");
+      console.log(
+        chalk37.gray("  Use this hash to create a release:")
+      );
+      console.log(
+        `  ${chalk37.cyan(`swiftpatch release-bundle --hash ${hash} --app-version <version>`)}`
+      );
+      console.log("");
+    } catch (error) {
+      urlSpinner.fail(`Upload failed: ${error.message}`);
+      process.exit(1);
+    }
+  } finally {
+    await fs11.remove(contentRootPath).catch(() => {
+    });
+  }
+});
+function formatBytes4(bytes) {
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + " KB";
+  return (bytes / 1024 / 1024).toFixed(1) + " MB";
+}
+
+// src/commands/release-bundle.ts
+init_esm_shims();
+init_api();
+import { Command as Command40 } from "commander";
+import chalk38 from "chalk";
+import ora32 from "ora";
+var releaseBundleCommand = new Command40("release-bundle").description("Promote a published bundle to a release (requires CI token)").requiredOption("--hash <hash>", "Bundle hash from publish-bundle output").requiredOption("--app-version <version>", "Target binary app version (semver)").option("--project-id <id>", "Project/App ID").option("-n, --release-note <note>", "Release notes", "").option("-m, --mandatory", "Mark as mandatory update", false).option("--paused", "Create release in paused state", false).option("--ci-token <token>", "CI token for authentication").action(async (options) => {
+  const ciToken = options.ciToken || process.env.SWIFTPATCH_CI_TOKEN;
+  if (!ciToken) {
+    logger.error("CI token required. Provide --ci-token or set SWIFTPATCH_CI_TOKEN env var.");
+    process.exit(1);
+  }
+  if (!options.projectId) {
+    logger.error("--project-id is required for release-bundle.");
+    process.exit(1);
+  }
+  console.log("");
+  logger.info(chalk38.bold("SwiftPatch Release Bundle"));
+  console.log("");
+  const spinner = ora32("Promoting bundle to release...").start();
+  try {
+    const result = await api.promoteBundle(
+      {
+        projectId: options.projectId,
+        hash: options.hash,
+        appVersion: options.appVersion,
+        releaseNote: options.releaseNote || "",
+        isMandatory: options.mandatory || false,
+        isPaused: options.paused || false
+      },
+      ciToken
+    );
+    spinner.succeed("Bundle promoted to release!");
+    console.log("");
+    console.log(chalk38.green("  Release created successfully!"));
+    console.log("");
+    console.log(`  Hash:        ${chalk38.cyan(options.hash.slice(0, 16))}...`);
+    console.log(`  App Version: ${chalk38.cyan(options.appVersion)}`);
+    console.log(`  Mandatory:   ${options.mandatory ? chalk38.yellow("Yes") : chalk38.gray("No")}`);
+    console.log(`  Paused:      ${options.paused ? chalk38.yellow("Yes") : chalk38.gray("No")}`);
+    if (result?.id) {
+      console.log(`  Release ID:  ${chalk38.gray(result.id)}`);
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Release failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/update-release.ts
+init_esm_shims();
+init_api();
+import { Command as Command41 } from "commander";
+import chalk39 from "chalk";
+import ora33 from "ora";
+var updateReleaseCommand = new Command41("update-release").description("Update an existing release by bundle hash (requires CI token)").requiredOption("--hash <hash>", "Bundle hash of the release to update").option("--project-id <id>", "Project/App ID").option("-n, --release-note <note>", "Updated release notes").option("-m, --mandatory", "Mark as mandatory update").option("--paused", "Pause the release").option("--rolled-back", "Mark release as rolled back").option("-r, --rollout <percent>", "Rollout percentage (1-100)").option("--ci-token <token>", "CI token for authentication").action(async (options) => {
+  const ciToken = options.ciToken || process.env.SWIFTPATCH_CI_TOKEN;
+  if (!ciToken) {
+    logger.error("CI token required. Provide --ci-token or set SWIFTPATCH_CI_TOKEN env var.");
+    process.exit(1);
+  }
+  if (!options.projectId) {
+    logger.error("--project-id is required for update-release.");
+    process.exit(1);
+  }
+  console.log("");
+  logger.info(chalk39.bold("SwiftPatch Update Release"));
+  console.log("");
+  const spinner = ora33("Updating release...").start();
+  try {
+    const params = {
+      projectId: options.projectId,
+      hash: options.hash
+    };
+    if (options.releaseNote !== void 0) params.releaseNote = options.releaseNote;
+    if (options.mandatory !== void 0) params.isMandatory = options.mandatory;
+    if (options.paused !== void 0) params.isPaused = options.paused;
+    if (options.rolledBack !== void 0) params.isRolledBack = options.rolledBack;
+    if (options.rollout !== void 0) params.rolloutPercent = parseInt(options.rollout, 10);
+    const result = await api.updateReleaseCli(params, ciToken);
+    spinner.succeed("Release updated!");
+    console.log("");
+    console.log(chalk39.green("  Release updated successfully!"));
+    console.log("");
+    console.log(`  Hash:     ${chalk39.cyan(options.hash.slice(0, 16))}...`);
+    if (options.releaseNote) {
+      console.log(`  Note:     ${chalk39.gray(options.releaseNote.slice(0, 60))}`);
+    }
+    if (options.mandatory !== void 0) {
+      console.log(`  Mandatory: ${options.mandatory ? chalk39.yellow("Yes") : chalk39.gray("No")}`);
+    }
+    if (options.paused !== void 0) {
+      console.log(`  Paused:    ${options.paused ? chalk39.yellow("Yes") : chalk39.gray("No")}`);
+    }
+    if (options.rolledBack !== void 0) {
+      console.log(`  Rolled Back: ${options.rolledBack ? chalk39.yellow("Yes") : chalk39.gray("No")}`);
+    }
+    if (options.rollout !== void 0) {
+      console.log(`  Rollout:   ${chalk39.cyan(options.rollout + "%")}`);
+    }
+    if (result?.id) {
+      console.log(`  Release ID: ${chalk39.gray(result.id)}`);
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Update failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/generate-key-pair.ts
+init_esm_shims();
+import { Command as Command42 } from "commander";
+import chalk40 from "chalk";
+import ora34 from "ora";
+import path10 from "path";
+var generateKeyPairCommand = new Command42("generate-key-pair").description("Generate RSA 2048-bit key pair for bundle signing").option("-o, --output <dir>", "Output directory for key files", ".").action(async (options) => {
+  console.log("");
+  logger.info(chalk40.bold("SwiftPatch Generate Key Pair"));
+  console.log("");
+  const outputDir = path10.resolve(options.output || ".");
+  const spinner = ora34("Generating RSA 2048-bit key pair...").start();
+  try {
+    const { publicKeyPath, privateKeyPath } = await generateKeyPair(outputDir);
+    spinner.succeed("Key pair generated!");
+    console.log("");
+    console.log(chalk40.green("  Key pair created successfully!"));
+    console.log("");
+    console.log(`  Public key:  ${chalk40.cyan(publicKeyPath)}`);
+    console.log(`  Private key: ${chalk40.cyan(privateKeyPath)}`);
+    console.log("");
+    console.log(chalk40.gray("  Usage:"));
+    console.log(chalk40.gray("  1. Upload the public key to your app settings in the SwiftPatch dashboard"));
+    console.log(chalk40.gray("  2. Use --private-key flag when publishing bundles:"));
+    console.log(`     ${chalk40.cyan(`swiftpatch publish-bundle --private-key ${privateKeyPath} -p ios`)}`);
+    console.log("");
+    console.log(chalk40.yellow("  Important: Keep your private key secure and never commit it to version control."));
+    console.log(chalk40.yellow("  Add it to .gitignore:"));
+    console.log(`     ${chalk40.gray('echo "swiftpatch-private.pem" >> .gitignore')}`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Key generation failed: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/deploy.ts
+init_esm_shims();
+init_api();
+import { Command as Command43 } from "commander";
+import chalk41 from "chalk";
+import inquirer21 from "inquirer";
+import ora35 from "ora";
+import fs12 from "fs-extra";
+import path11 from "path";
+var deployCommand = new Command43("deploy").description("Bundle, publish, and release in one step").option("-p, --platform <platform>", "Target platform (ios or android)").option("-a, --app <app-id>", "App ID or slug").option("-o, --org <org-id>", "Organization ID").option("--app-version <version>", "Target app version (semver)").option("-n, --release-note <note>", "Release notes").option("-m, --mandatory", "Mark as mandatory update").option("--paused", "Create release in paused state").option("--hermes", "Compile to Hermes bytecode").option("--ci-token <token>", "CI token for authentication").option("-e, --entry-file <path>", "Entry file (default: index.js)").option("--dev", "Dev bundle").option("--sourcemap", "Generate sourcemaps").option("-k, --private-key <path>", "Private key path for signing").option("-y, --yes", "Skip confirmations").action(async (options) => {
+  const ciToken = options.ciToken || process.env.SWIFTPATCH_CI_TOKEN;
+  if (!ciToken) {
+    await requireAuth();
+  }
+  const orgId = ciToken ? void 0 : await resolveOrgId(options.org);
+  let platform = options.platform;
+  if (!platform) {
+    const hasIos = await fs12.pathExists("./ios");
+    const hasAndroid = await fs12.pathExists("./android");
+    if (hasIos && !hasAndroid) {
+      platform = "ios";
+    } else if (hasAndroid && !hasIos) {
+      platform = "android";
+    } else {
+      const answers = await inquirer21.prompt([
+        {
+          type: "list",
+          name: "platform",
+          message: "Select platform:",
+          choices: ["ios", "android"]
+        }
+      ]);
+      platform = answers.platform;
+    }
+  }
+  let appVersion = options.appVersion;
+  if (!appVersion) {
+    try {
+      const pkg = await fs12.readJson("./package.json");
+      appVersion = pkg.version;
+    } catch {
+    }
+    if (!appVersion) {
+      const answers = await inquirer21.prompt([
+        {
+          type: "input",
+          name: "version",
+          message: "App version (semver):",
+          validate: (v) => /^\d+\.\d+\.\d+/.test(v) || "Must be valid semver (e.g., 1.0.0)"
+        }
+      ]);
+      appVersion = answers.version;
+    } else if (!options.yes) {
+      console.log(chalk41.gray(`  Detected version: ${appVersion}`));
+    }
+  }
+  const releaseNote = options.releaseNote || "";
+  let uploadPath = options.app || "";
+  if (!uploadPath && orgId) {
+    const apps = await api.getApps(orgId);
+    if (apps.length === 1) {
+      uploadPath = apps[0].slug || apps[0].id;
+      if (!options.yes) console.log(chalk41.gray(`  Using app: ${apps[0].name}`));
+    } else if (apps.length > 1) {
+      const { selectedApp } = await inquirer21.prompt([
+        {
+          type: "list",
+          name: "selectedApp",
+          message: "Select app:",
+          choices: apps.map((a) => ({ name: `${a.name} (${a.platform})`, value: a.slug || a.id }))
+        }
+      ]);
+      uploadPath = selectedApp;
+    }
+  }
+  console.log("");
+  console.log(chalk41.bold("  Deploy"));
+  console.log(chalk41.gray(`  Platform: ${platform} \xB7 Version: ${appVersion}`));
+  console.log("");
+  const bundleSpinner = ora35("Bundling JavaScript...").start();
+  try {
+    const entryFile = options.entryFile || "index.js";
+    const outputDir = path11.join(".swiftpatch-tmp", platform);
+    await fs12.ensureDir(outputDir);
+    const bundleName = platform === "ios" ? "main.jsbundle" : "index.android.bundle";
+    await runReactNativeBundleCommand(
+      bundleName,
+      entryFile,
+      outputDir,
+      platform,
+      options.sourcemap || false,
+      options.dev || false
+    );
+    if (options.hermes) {
+      bundleSpinner.text = "Compiling to Hermes bytecode...";
+    }
+    bundleSpinner.succeed("Bundle created");
+  } catch (error) {
+    bundleSpinner.fail(`Bundle failed: ${error.message}`);
+    process.exit(1);
+  }
+  const archiveSpinner = ora35("Creating archive...").start();
+  let zipPath;
+  let bundleHash;
+  try {
+    const outputDir = path11.join(".swiftpatch-tmp", platform);
+    const zipOutputDir = path11.join(".swiftpatch-tmp", "zip");
+    await fs12.ensureDir(zipOutputDir);
+    await createZip(outputDir, zipOutputDir);
+    zipPath = path11.join(zipOutputDir, "build.zip");
+    bundleHash = calculateZipHash(zipPath);
+    if (!bundleHash) throw new Error("Failed to compute bundle hash");
+    archiveSpinner.succeed(`Archive created (hash: ${bundleHash.slice(0, 12)}...)`);
+  } catch (error) {
+    archiveSpinner.fail(`Archive failed: ${error.message}`);
+    process.exit(1);
+  }
+  const uploadSpinner = ora35("Uploading bundle...").start();
+  try {
+    const { url } = await api.generateSignedUrl(
+      { hash: bundleHash, uploadPath, platform, releaseNote },
+      ciToken
+    );
+    await uploader.uploadZip(url, zipPath, (progress) => {
+      uploadSpinner.text = `Uploading bundle... ${progress}%`;
+    });
+    uploadSpinner.succeed("Bundle uploaded");
+  } catch (error) {
+    uploadSpinner.fail(`Upload failed: ${error.message}`);
+    process.exit(1);
+  }
+  if (!ciToken) {
+    console.log("");
+    logger.warning("Deploy requires a CI token to create the release.");
+    console.log(chalk41.gray("  Bundle was uploaded. Promote it manually:"));
+    console.log(chalk41.cyan(`  $ swiftpatch release-bundle --hash ${bundleHash} --app-version ${appVersion} --ci-token <token>`));
+    console.log("");
+  } else {
+    const releaseSpinner = ora35("Creating release...").start();
+    try {
+      await api.promoteBundle(
+        {
+          projectId: uploadPath,
+          hash: bundleHash,
+          appVersion,
+          releaseNote,
+          isMandatory: options.mandatory || false,
+          isPaused: options.paused || false
+        },
+        ciToken
+      );
+      releaseSpinner.succeed("Release created!");
+      console.log("");
+      console.log(chalk41.bold("  Deploy Complete"));
+      console.log(`  Hash:      ${chalk41.gray(bundleHash)}`);
+      console.log(`  Version:   ${chalk41.cyan(appVersion)}`);
+      console.log(`  Platform:  ${platform}`);
+      console.log(`  Mandatory: ${options.mandatory ? chalk41.yellow("Yes") : "No"}`);
+      console.log(`  Status:    ${options.paused ? chalk41.yellow("Paused") : chalk41.green("Released")}`);
+      console.log("");
+    } catch (error) {
+      releaseSpinner.fail(`Release failed: ${error.message}`);
+      process.exit(1);
+    }
+  }
+  await fs12.remove(".swiftpatch-tmp").catch(() => {
+  });
+});
+
+// src/commands/status.ts
+init_esm_shims();
+init_api();
+import { Command as Command44 } from "commander";
+import chalk42 from "chalk";
+import inquirer22 from "inquirer";
+import ora36 from "ora";
+var statusCommand = new Command44("status").description("Show app status at a glance").argument("[app-id]", "App ID").option("-o, --org <org-id>", "Organization ID").option("--json", "Output as JSON").action(async (appId, options) => {
+  await requireAuth();
+  const orgId = await resolveOrgId(options.org);
+  if (!appId) {
+    const apps = await api.getApps(orgId);
+    if (apps.length === 0) {
+      console.log("");
+      console.log(chalk42.gray("  No apps found. Create one with: swiftpatch apps create"));
+      console.log("");
+      return;
+    }
+    const { selectedApp } = await inquirer22.prompt([
+      {
+        type: "list",
+        name: "selectedApp",
+        message: "Select app:",
+        choices: apps.map((app) => ({ name: `${app.name} (${app.platform})`, value: app.id }))
+      }
+    ]);
+    appId = selectedApp;
+  }
+  const spinner = ora36("Fetching status...").start();
+  try {
+    const [app, releasesResult, channels, analytics] = await Promise.all([
+      api.getApp(orgId, appId),
+      api.getReleases(orgId, appId, { page: 1, limit: 5 }),
+      api.getChannels(orgId, appId),
+      api.getAnalytics(orgId, appId, { days: 7 }).catch(() => null)
+    ]);
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ app, releases: releasesResult.releases, channels, analytics }, null, 2));
+      return;
+    }
+    console.log("");
+    console.log(chalk42.bold(`  ${app.name}`));
+    console.log(chalk42.gray(`  ${app.slug} \xB7 ${app.platform} \xB7 ${app.signingEnabled ? "Signing enabled" : "No signing"}`));
+    console.log("");
+    if (app.stats) {
+      console.log(chalk42.bold("  Overview"));
+      console.log(`  Releases:       ${chalk42.cyan(String(app.stats.totalReleases))}`);
+      console.log(`  Total Installs: ${chalk42.cyan(String(app.stats.totalInstalls))}`);
+      console.log(`  Active Devices: ${chalk42.green(String(app.stats.activeDevices))}`);
+      console.log("");
+    }
+    if (analytics) {
+      console.log(chalk42.bold("  Last 7 Days"));
+      console.log(`  Updates:      ${chalk42.cyan(String(analytics.totalUpdates))}`);
+      console.log(`  Success Rate: ${analytics.successRate >= 95 ? chalk42.green(analytics.successRate + "%") : chalk42.yellow(analytics.successRate + "%")}`);
+      if (analytics.failedUpdates > 0) {
+        console.log(`  Failed:       ${chalk42.red(String(analytics.failedUpdates))}`);
+      }
+      console.log("");
+    }
+    const releases = releasesResult.releases;
+    if (releases.length > 0) {
+      console.log(chalk42.bold("  Recent Releases"));
+      for (const r of releases) {
+        const statusColor = r.status === "RELEASED" ? chalk42.green : r.status === "DISABLED" ? chalk42.red : r.status === "READY" ? chalk42.blue : chalk42.gray;
+        console.log(
+          `  ${statusColor("\u25CF")} v${r.version} (build ${r.buildNumber}) \xB7 ${r.platform} \xB7 ${statusColor(r.status)} \xB7 ${r.rolloutPercent}% rollout`
+        );
+      }
+      console.log("");
+    }
+    if (channels.length > 0) {
+      console.log(chalk42.bold("  Channels"));
+      console.log(`  ${channels.map((c) => chalk42.cyan(c.name)).join(", ")}`);
+      console.log("");
+    }
+    console.log(chalk42.gray(`  Deployment Key: ${app.deploymentKey}`));
+    console.log("");
+  } catch (error) {
+    spinner.fail(`Failed to fetch status: ${error.message}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/init.ts
+init_esm_shims();
+init_api();
+init_auth();
+init_config();
+import { Command as Command45 } from "commander";
+import chalk43 from "chalk";
+import inquirer23 from "inquirer";
+import ora37 from "ora";
+import fs13 from "fs-extra";
+import path12 from "path";
+var initCommand = new Command45("init").description("Initialize SwiftPatch in your React Native project").option("-y, --yes", "Accept defaults").action(async (options) => {
+  console.log("");
+  console.log(chalk43.bold("  SwiftPatch Setup"));
+  console.log("");
+  const hasPackageJson = await fs13.pathExists("./package.json");
+  if (!hasPackageJson) {
+    logger.error("No package.json found. Run this command in your React Native project root.");
+    process.exit(1);
+  }
+  const pkg = await fs13.readJson("./package.json");
+  const hasRN = pkg.dependencies?.["react-native"] || pkg.devDependencies?.["react-native"];
+  if (!hasRN) {
+    logger.warning("react-native not found in dependencies. Is this a React Native project?");
+    if (!options.yes) {
+      const { proceed } = await inquirer23.prompt([
+        { type: "confirm", name: "proceed", message: "Continue anyway?", default: false }
+      ]);
+      if (!proceed) return;
+    }
+  } else {
+    logger.success(`React Native project detected (${hasRN})`);
+  }
+  const hasSDK = pkg.dependencies?.["@swiftpatch/react-native"] || pkg.devDependencies?.["@swiftpatch/react-native"];
+  if (!hasSDK) {
+    logger.warning("@swiftpatch/react-native SDK not installed");
+    console.log(chalk43.gray("  Install with: npm install @swiftpatch/react-native"));
+    console.log("");
+  } else {
+    logger.success(`SwiftPatch SDK installed (${hasSDK})`);
+  }
+  if (!auth.isLoggedIn()) {
+    logger.warning("Not logged in");
+    console.log(chalk43.gray("  Run: swiftpatch login"));
+    console.log("");
+    process.exit(1);
+  }
+  logger.success("Authenticated");
+  const orgId = await resolveOrgId();
+  const hasIos = await fs13.pathExists("./ios");
+  const hasAndroid = await fs13.pathExists("./android");
+  const platforms = [];
+  if (hasIos) platforms.push("ios");
+  if (hasAndroid) platforms.push("android");
+  if (platforms.length > 0) {
+    logger.success(`Platforms detected: ${platforms.join(", ")}`);
+  }
+  const spinner = ora37("Fetching apps...").start();
+  const apps = await api.getApps(orgId);
+  spinner.stop();
+  let selectedApp;
+  if (apps.length > 0 && !options.yes) {
+    const { action } = await inquirer23.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "Link to an existing app or create a new one?",
+        choices: [
+          { name: "Link existing app", value: "link" },
+          { name: "Create new app", value: "create" }
+        ]
+      }
+    ]);
+    if (action === "link") {
+      const { appChoice } = await inquirer23.prompt([
+        {
+          type: "list",
+          name: "appChoice",
+          message: "Select app:",
+          choices: apps.map((a) => ({ name: `${a.name} (${a.platform})`, value: a }))
+        }
+      ]);
+      selectedApp = appChoice;
+    } else {
+      selectedApp = await createApp(orgId, pkg, platforms);
+    }
+  } else if (apps.length === 0) {
+    console.log(chalk43.gray("  No apps found. Creating one..."));
+    selectedApp = await createApp(orgId, pkg, platforms);
+  } else {
+    selectedApp = apps[0];
+  }
+  let defaultPlatform;
+  if (hasIos && !hasAndroid) defaultPlatform = "ios";
+  if (hasAndroid && !hasIos) defaultPlatform = "android";
+  const rcConfig = {
+    appId: selectedApp.id,
+    app: selectedApp.slug,
+    platform: defaultPlatform || (selectedApp.platform === "BOTH" ? void 0 : selectedApp.platform.toLowerCase()),
+    deploymentKey: selectedApp.deploymentKey
+  };
+  const rcPath = path12.resolve(".swiftpatchrc");
+  await fs13.writeJson(rcPath, rcConfig, { spaces: 2 });
+  logger.success("Created .swiftpatchrc");
+  config.set("defaultOrg", orgId);
+  config.set("defaultApp", selectedApp.id);
+  if (defaultPlatform) config.set("defaultPlatform", defaultPlatform);
+  logger.success("Saved defaults to CLI config");
+  console.log("");
+  console.log(chalk43.bold("  Setup Complete"));
+  console.log("");
+  console.log(`  App:            ${chalk43.cyan(selectedApp.name)}`);
+  console.log(`  Platform:       ${selectedApp.platform}`);
+  console.log(`  Deployment Key: ${chalk43.gray(selectedApp.deploymentKey)}`);
+  console.log(`  Config:         ${chalk43.gray(rcPath)}`);
+  console.log("");
+  console.log(chalk43.bold("  Next Steps"));
+  console.log(chalk43.gray("  1. Add the deployment key to your app (Info.plist / strings.xml)"));
+  console.log(chalk43.gray("  2. Wrap your app with <SwiftPatchProvider />"));
+  console.log(chalk43.gray("  3. Run: swiftpatch deploy -p ios --ci-token <token>"));
+  console.log("");
+});
+async function createApp(orgId, pkg, platforms) {
+  const { name } = await inquirer23.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "App name:",
+      default: pkg.name || path12.basename(process.cwd())
+    }
+  ]);
+  let platform;
+  if (platforms.length === 2) {
+    platform = "BOTH";
+  } else if (platforms.length === 1) {
+    platform = platforms[0].toUpperCase();
+  } else {
+    const { p } = await inquirer23.prompt([
+      {
+        type: "list",
+        name: "p",
+        message: "Platform:",
+        choices: [
+          { name: "iOS", value: "IOS" },
+          { name: "Android", value: "ANDROID" },
+          { name: "Both", value: "BOTH" }
+        ]
+      }
+    ]);
+    platform = p;
+  }
+  const createSpinner = ora37("Creating app...").start();
+  const app = await api.createApp(orgId, { name, platform });
+  createSpinner.succeed(`App created: ${app.name}`);
+  return app;
+}
+
+// src/commands/doctor.ts
+init_esm_shims();
+init_api();
+init_auth();
+init_config();
+import { Command as Command46 } from "commander";
+import chalk44 from "chalk";
+import fs14 from "fs-extra";
+var doctorCommand = new Command46("doctor").description("Diagnose your SwiftPatch setup").action(async () => {
+  console.log("");
+  console.log(chalk44.bold("  SwiftPatch Doctor"));
+  console.log("");
+  let issues = 0;
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  if (major >= 18) {
+    logger.success(`Node.js ${nodeVersion}`);
+  } else {
+    logger.error(`Node.js ${nodeVersion} \u2014 requires >= 18.0.0`);
+    issues++;
+  }
+  const hasPackageJson = await fs14.pathExists("./package.json");
+  if (hasPackageJson) {
+    const pkg = await fs14.readJson("./package.json");
+    const rnVersion = pkg.dependencies?.["react-native"] || pkg.devDependencies?.["react-native"];
+    if (rnVersion) {
+      logger.success(`React Native ${rnVersion}`);
+    } else {
+      logger.warning("react-native not found in dependencies");
+      issues++;
+    }
+    const sdkVersion = pkg.dependencies?.["@swiftpatch/react-native"] || pkg.devDependencies?.["@swiftpatch/react-native"];
+    if (sdkVersion) {
+      logger.success(`@swiftpatch/react-native ${sdkVersion}`);
+    } else {
+      logger.error("@swiftpatch/react-native SDK not installed");
+      console.log(chalk44.gray("    Fix: npm install @swiftpatch/react-native"));
+      issues++;
+    }
+  } else {
+    logger.warning("No package.json found (not in a project directory?)");
+  }
+  const hasIos = await fs14.pathExists("./ios");
+  const hasAndroid = await fs14.pathExists("./android");
+  if (hasIos || hasAndroid) {
+    const platforms = [hasIos && "iOS", hasAndroid && "Android"].filter(Boolean).join(", ");
+    logger.success(`Platforms: ${platforms}`);
+  } else if (hasPackageJson) {
+    logger.warning("No ios/ or android/ directories found");
+    issues++;
+  }
+  if (auth.isLoggedIn()) {
+    logger.success("Authenticated");
+    try {
+      const user = await api.getCurrentUser();
+      logger.success(`Connected as ${user.name} (${user.email})`);
+    } catch (error) {
+      logger.error(`API connection failed: ${error.message}`);
+      issues++;
+    }
+  } else {
+    logger.error("Not authenticated");
+    console.log(chalk44.gray("    Fix: swiftpatch login"));
+    issues++;
+  }
+  const customApiUrl = config.get("apiUrl");
+  if (customApiUrl) {
+    logger.info(`Custom API URL: ${customApiUrl}`);
+    if (customApiUrl.startsWith("http://") && !customApiUrl.includes("localhost")) {
+      logger.warning("API URL uses HTTP \u2014 consider HTTPS for production");
+      issues++;
+    }
+  } else {
+    logger.success("API URL: default (production)");
+  }
+  const defaultOrg = config.get("defaultOrg");
+  const defaultApp = config.get("defaultApp");
+  if (defaultOrg) {
+    logger.success(`Default org: ${defaultOrg}`);
+  } else {
+    logger.info("No default org set (will prompt each time)");
+  }
+  if (defaultApp) {
+    logger.success(`Default app: ${defaultApp}`);
+  } else {
+    logger.info("No default app set");
+  }
+  const hasRc = await fs14.pathExists("./.swiftpatchrc");
+  if (hasRc) {
+    try {
+      const rc = await fs14.readJson("./.swiftpatchrc");
+      logger.success(`.swiftpatchrc found (app: ${rc.app || rc.appId || "unknown"})`);
+    } catch {
+      logger.warning(".swiftpatchrc exists but is invalid JSON");
+      issues++;
+    }
+  } else {
+    logger.info("No .swiftpatchrc (run: swiftpatch init)");
+  }
+  if (hasPackageJson) {
+    try {
+      const pkg = await fs14.readJson("./package.json");
+      const rnVersion = pkg.dependencies?.["react-native"];
+      if (rnVersion) {
+        const cleanVersion = rnVersion.replace(/[\^~>=<]/g, "");
+        const [, minor] = cleanVersion.split(".");
+        if (parseInt(minor) >= 70) {
+          logger.success("Hermes likely enabled (RN 0.70+)");
+        } else {
+          logger.info("Hermes may need to be manually enabled");
+        }
+      }
+    } catch {
+    }
+  }
+  console.log("");
+  if (issues === 0) {
+    console.log(chalk44.green.bold("  All checks passed!"));
+  } else {
+    console.log(chalk44.yellow.bold(`  ${issues} issue${issues > 1 ? "s" : ""} found`));
+  }
+  console.log("");
+});
+
+// src/cli.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var version = "1.0.0";
+try {
+  const pkg = JSON.parse(readFileSync3(join2(__dirname2, "../package.json"), "utf-8"));
+  version = pkg.version;
+} catch {
+}
+var cli = new Command47();
+cli.name("swiftpatch").description(chalk45.bold("SwiftPatch CLI") + " - Ship React Native updates instantly").version(version, "-v, --version", "Output the current version").helpOption("-h, --help", "Display help for command").addHelpText("after", `
+${chalk45.bold("Quick Start:")}
+  $ swiftpatch init                  ${chalk45.gray("# Set up SwiftPatch in your project")}
+  $ swiftpatch deploy -p ios         ${chalk45.gray("# Bundle, upload, and release")}
+  $ swiftpatch status                ${chalk45.gray("# View app status at a glance")}
+
+${chalk45.bold("Examples:")}
+  ${chalk45.gray("# Login to SwiftPatch")}
+  $ swiftpatch login
+
+  ${chalk45.gray("# Publish a bundle")}
+  $ swiftpatch publish-bundle -p ios --hermes
+
+  ${chalk45.gray("# Promote a bundle to a release")}
+  $ swiftpatch release-bundle --hash <hash> --app-version 1.0.0 --ci-token <token>
+
+  ${chalk45.gray("# One-step deploy (bundle + upload + release)")}
+  $ swiftpatch deploy -p ios --ci-token <token>
+
+  ${chalk45.gray("# List all apps")}
+  $ swiftpatch apps list
+
+  ${chalk45.gray("# Update rollout percentage")}
+  $ swiftpatch releases rollout <release-id> --percent 50
+
+  ${chalk45.gray("# Manage CI tokens")}
+  $ swiftpatch ci-tokens create
+
+  ${chalk45.gray("# Diagnose setup issues")}
+  $ swiftpatch doctor
+
+${chalk45.bold("Documentation:")}
+  ${chalk45.cyan("https://docs.swiftpatch.io/cli")}
+`);
+cli.addCommand(initCommand);
+cli.addCommand(doctorCommand);
+cli.addCommand(statusCommand);
+cli.addCommand(loginCommand);
+cli.addCommand(logoutCommand);
+cli.addCommand(whoamiCommand);
+cli.addCommand(appsCommands);
+cli.addCommand(deployCommand);
+cli.addCommand(releaseCommand);
+cli.addCommand(publishBundleCommand);
+cli.addCommand(releaseBundleCommand);
+cli.addCommand(updateReleaseCommand);
+cli.addCommand(generateKeyPairCommand);
+cli.addCommand(releasesCommands);
+cli.addCommand(channelsCommands);
+cli.addCommand(ciTokensCommands);
+cli.addCommand(webhooksCommands);
+cli.addCommand(analyticsCommand);
+cli.addCommand(aiCommand);
+cli.addCommand(configCommands);
+cli.action(() => {
+  console.log("");
+  console.log(chalk45.bold.cyan("  SwiftPatch CLI"));
+  console.log(chalk45.gray(`     v${version}`));
+  console.log("");
+  console.log("  Run " + chalk45.cyan("swiftpatch --help") + " for usage information");
+  console.log("");
+});
+
+// src/utils/update-checker.ts
+init_esm_shims();
+function checkForUpdates() {
+  try {
+    import("update-notifier").then(({ default: updateNotifier }) => {
+      import("fs-extra").then(({ default: fs15 }) => {
+        import("url").then(({ fileURLToPath: fileURLToPath3 }) => {
+          import("path").then(({ dirname: dirname3, join: join3 }) => {
+            try {
+              const __dirname3 = dirname3(fileURLToPath3(import.meta.url));
+              const pkg = JSON.parse(
+                fs15.readFileSync(join3(__dirname3, "../../package.json"), "utf-8")
+              );
+              const notifier = updateNotifier({ pkg, updateCheckInterval: 1e3 * 60 * 60 * 24 });
+              notifier.notify();
+            } catch {
+            }
+          });
+        });
+      });
+    }).catch(() => {
+    });
+  } catch {
+  }
+}
+
+// src/utils/errors.ts
+init_esm_shims();
+import chalk46 from "chalk";
+var CLIError = class extends Error {
+  constructor(message, code, suggestion) {
+    super(message);
+    this.code = code;
+    this.suggestion = suggestion;
+    this.name = "CLIError";
+  }
+};
+function handleError(error) {
+  console.log("");
+  if (error instanceof CLIError) {
+    logger.error(error.message);
+    if (error.suggestion) {
+      console.log("");
+      console.log(chalk46.gray("Suggestion: ") + error.suggestion);
+    }
+  } else if (error instanceof Error) {
+    logger.error(error.message);
+    if (process.env.DEBUG) {
+      console.log("");
+      console.log(chalk46.gray(error.stack || ""));
+    }
+  } else {
+    logger.error("An unexpected error occurred");
+  }
+  console.log("");
+  console.log(chalk46.gray("For help, run: swiftpatch --help"));
+  console.log(chalk46.gray("Report issues: https://github.com/codewprincee/cli/issues"));
+  console.log("");
+}
+
+// src/index.ts
+async function main() {
+  try {
+    checkForUpdates();
+    await cli.parseAsync(process.argv);
+  } catch (error) {
+    handleError(error);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map