pulse-updates 1.0.0

package/scripts/publish.mjs

@@ -0,0 +1,902 @@
+#!/usr/bin/env node
+/**
+ * Pulse Updates CLI - Publish command
+ * Creates JS bundle with Hermes and uploads to server
+ */
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { execSync, spawnSync } from 'child_process';
+
+const VERSION = '1.0.1';
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+};
+
+function log(message, color = '') {
+  console.log(`${color}${message}${colors.reset}`);
+}
+
+function logStep(step, message) {
+  log(`[${step}] ${message}`, colors.cyan);
+}
+
+function logSuccess(message) {
+  log(`✓ ${message}`, colors.green);
+}
+
+function logError(message) {
+  log(`✗ ${message}`, colors.red);
+}
+
+function logWarning(message) {
+  log(`⚠ ${message}`, colors.yellow);
+}
+
+/**
+ * Calculate SHA-256 hash of a file (for integrity verification)
+ */
+async function hashFileSHA256(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('error', reject);
+    stream.on('end', () => resolve(hash.digest('hex')));
+  });
+}
+
+/**
+ * Calculate MD5 hash of a file (for asset key - matches Metro/expo format)
+ */
+async function hashFileMD5(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('md5');
+    const stream = fs.createReadStream(filePath);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('error', reject);
+    stream.on('end', () => resolve(hash.digest('hex')));
+  });
+}
+
+/**
+ * Get MIME type from file extension
+ */
+function getMimeType(ext) {
+  const mimeTypes = {
+    '.js': 'application/javascript',
+    '.hbc': 'application/octet-stream',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.wav': 'audio/wav',
+    '.riv': 'application/octet-stream',
+  };
+  return mimeTypes[ext.toLowerCase()] || 'application/octet-stream';
+}
+
+/**
+ * Find Hermes compiler
+ */
+function findHermesc(platform) {
+  const possiblePaths = [
+    // iOS paths
+    'ios/Pods/hermes-engine/destroot/bin/hermesc',
+    'node_modules/react-native/sdks/hermesc/osx-bin/hermesc',
+    'node_modules/react-native/sdks/hermesc/linux64-bin/hermesc',
+    // Android paths
+    'node_modules/react-native/ReactAndroid/hermes-engine/build/hermes/bin/hermesc',
+  ];
+
+  for (const p of possiblePaths) {
+    const fullPath = path.resolve(p);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+
+  // Try to find via which
+  try {
+    return execSync('which hermesc', { encoding: 'utf8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create JS bundle using Metro
+ */
+function createBundle(platform, bundleDir, entryFile = 'index.ts') {
+  const bundleOutput = path.join(bundleDir, platform, 'index.bundle');
+  const assetsDir = path.join(bundleDir, platform, 'assets');
+
+  // Clean and create directories
+  fs.rmSync(path.join(bundleDir, platform), { recursive: true, force: true });
+  fs.mkdirSync(path.join(bundleDir, platform), { recursive: true });
+  fs.mkdirSync(assetsDir, { recursive: true });
+
+  log(`  Creating ${platform} bundle...`, colors.dim);
+
+  const cmd = [
+    'npx react-native bundle',
+    `--platform ${platform}`,
+    '--dev false',
+    `--entry-file ${entryFile}`,
+    `--bundle-output ${bundleOutput}`,
+    `--assets-dest ${assetsDir}`,
+    '--minify true',
+  ].join(' ');
+
+  execSync(cmd, { stdio: 'inherit' });
+
+  return bundleOutput;
+}
+
+/**
+ * Compile bundle with Hermes
+ */
+function compileWithHermes(bundlePath, platform) {
+  const hermesc = findHermesc(platform);
+  if (!hermesc) {
+    logWarning('Hermes compiler not found, using plain JS bundle');
+    return bundlePath;
+  }
+
+  const hbcPath = bundlePath.replace('.bundle', '.hbc');
+
+  log(`  Compiling with Hermes...`, colors.dim);
+
+  try {
+    // Use spawnSync with larger buffer to avoid ENOBUFS error
+    const result = spawnSync(hermesc, ['-emit-binary', '-out', hbcPath, bundlePath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      maxBuffer: 100 * 1024 * 1024, // 100MB buffer
+      encoding: 'utf8',
+    });
+
+    if (result.error) {
+      throw result.error;
+    }
+
+    if (result.status !== 0) {
+      const stderr = result.stderr || '';
+      throw new Error(`Hermes exited with code ${result.status}: ${stderr.slice(0, 500)}`);
+    }
+
+    // Remove the plain JS bundle, keep only HBC
+    fs.unlinkSync(bundlePath);
+    // Rename .hbc to .bundle for compatibility
+    const finalPath = bundlePath;
+    fs.renameSync(hbcPath, finalPath);
+    return finalPath;
+  } catch (error) {
+    logWarning(`Hermes compilation failed: ${error.message}`);
+    return bundlePath;
+  }
+}
+
+/**
+ * Collect all assets from the bundle directory
+ */
+async function collectAssets(bundleDir, platform) {
+  const assets = [];
+  const platformDir = path.join(bundleDir, platform);
+  const assetsDir = path.join(platformDir, 'assets');
+  const bundlePath = path.join(platformDir, 'index.bundle');
+
+  if (!fs.existsSync(bundlePath)) {
+    throw new Error(`Bundle not found: ${bundlePath}`);
+  }
+
+  // Add launch asset (JS bundle)
+  const bundleHash = await hashFileSHA256(bundlePath);
+  const bundleStats = fs.statSync(bundlePath);
+
+  assets.push({
+    path: bundlePath,
+    key: 'bundle.js',
+    hash: bundleHash,
+    contentType: 'application/javascript',
+    fileExtension: '.js',
+    fileSize: bundleStats.size,
+    isLaunchAsset: true,
+  });
+
+  // Collect all asset files recursively
+  if (fs.existsSync(assetsDir)) {
+    const assetFiles = collectFilesRecursively(assetsDir);
+
+    for (const filePath of assetFiles) {
+      const relativePath = path.relative(assetsDir, filePath);
+      // SHA256 for integrity verification
+      const hash = await hashFileSHA256(filePath);
+      // MD5 for the key - this is how Metro/expo-asset looks up assets
+      const md5Hash = await hashFileMD5(filePath);
+      const stats = fs.statSync(filePath);
+      const ext = path.extname(filePath);
+
+      // Use MD5 hash as key (like expo-updates does)
+      // expo-asset's getLocalAssetUri(hash, type) looks up by Metro's MD5 hash
+      const key = md5Hash;
+
+      assets.push({
+        path: filePath,
+        key,
+        hash,
+        contentType: getMimeType(ext),
+        fileExtension: ext,
+        fileSize: stats.size,
+        isLaunchAsset: false,
+        // Keep the path for reference (useful for debugging)
+        assetPath: `assets/${relativePath}`,
+      });
+    }
+  }
+
+  return assets;
+}
+
+/**
+ * Recursively collect all files in a directory
+ */
+function collectFilesRecursively(dir) {
+  const files = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectFilesRecursively(fullPath));
+    } else if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Upload a file to a presigned URL
+ */
+async function uploadToPresignedUrl(filePath, uploadUrl, contentType) {
+  const fileBuffer = fs.readFileSync(filePath);
+
+  const response = await fetch(uploadUrl, {
+    method: 'PUT',
+    headers: {
+      'Content-Type': contentType,
+      'Content-Length': fileBuffer.length.toString(),
+    },
+    body: fileBuffer,
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Upload failed: ${response.status} ${text}`);
+  }
+}
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {
+    command: args[0],
+    options: {},
+  };
+
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith('--')) {
+        result.options[key] = nextArg;
+        i++;
+      } else {
+        result.options[key] = true;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Find Info.plist and return its path and content
+ */
+function findInfoPlist() {
+  const possiblePaths = [
+    'ios/App/Info.plist',
+    'ios/*/Info.plist',
+  ];
+
+  for (const pattern of possiblePaths) {
+    if (pattern.includes('*')) {
+      const baseDir = pattern.split('*')[0];
+      if (fs.existsSync(baseDir)) {
+        const dirs = fs.readdirSync(baseDir, { withFileTypes: true })
+          .filter(d => d.isDirectory() && !d.name.startsWith('.') && d.name !== 'Pods')
+          .map(d => d.name);
+        for (const dir of dirs) {
+          const plistPath = path.join(baseDir, dir, 'Info.plist');
+          if (fs.existsSync(plistPath)) {
+            try {
+              return {
+                path: plistPath,
+                content: fs.readFileSync(plistPath, 'utf8'),
+              };
+            } catch {}
+          }
+        }
+      }
+    } else if (fs.existsSync(pattern)) {
+      try {
+        return {
+          path: pattern,
+          content: fs.readFileSync(pattern, 'utf8'),
+        };
+      } catch {}
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Resolve Xcode build variable from project.pbxproj
+ */
+function resolveXcodeBuildVariable(variableName) {
+  const possiblePbxprojPaths = [
+    'ios/*.xcodeproj/project.pbxproj',
+  ];
+
+  for (const pattern of possiblePbxprojPaths) {
+    if (pattern.includes('*')) {
+      const baseDir = pattern.split('*')[0];
+      if (fs.existsSync(baseDir)) {
+        const dirs = fs.readdirSync(baseDir, { withFileTypes: true })
+          .filter(d => d.isDirectory() && d.name.endsWith('.xcodeproj'))
+          .map(d => d.name);
+        for (const dir of dirs) {
+          const pbxprojPath = path.join(baseDir, dir, 'project.pbxproj');
+          if (fs.existsSync(pbxprojPath)) {
+            try {
+              const content = fs.readFileSync(pbxprojPath, 'utf8');
+              // Match: MARKETING_VERSION = 1.2.4;
+              const regex = new RegExp(`${variableName}\\s*=\\s*([^;]+);`);
+              const match = content.match(regex);
+              if (match) {
+                return match[1].trim();
+              }
+            } catch {}
+          }
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Read iOS version from Info.plist
+ */
+function readIOSVersion() {
+  const plist = findInfoPlist();
+  if (!plist) return null;
+
+  const match = plist.content.match(/<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/);
+  if (!match) return null;
+
+  let version = match[1];
+
+  // Resolve Xcode build variable if present
+  if (version.startsWith('$(') && version.endsWith(')')) {
+    const varName = version.slice(2, -1);
+    const resolvedVersion = resolveXcodeBuildVariable(varName);
+    if (resolvedVersion) {
+      return resolvedVersion;
+    }
+  }
+
+  return version;
+}
+
+/**
+ * Read PulseUpdatesURL from iOS Info.plist
+ */
+function readIOSPulseUpdatesURL() {
+  const plist = findInfoPlist();
+  if (!plist) return null;
+
+  const match = plist.content.match(/<key>PulseUpdatesURL<\/key>\s*<string>([^<]+)<\/string>/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Find AndroidManifest.xml and return its content
+ */
+function findAndroidManifest() {
+  const possiblePaths = [
+    'android/app/src/main/AndroidManifest.xml',
+  ];
+
+  for (const manifestPath of possiblePaths) {
+    if (fs.existsSync(manifestPath)) {
+      try {
+        return {
+          path: manifestPath,
+          content: fs.readFileSync(manifestPath, 'utf8'),
+        };
+      } catch {}
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Read Android version from build.gradle
+ */
+function readAndroidVersion() {
+  const gradlePath = 'android/app/build.gradle';
+  const gradleKtsPath = 'android/app/build.gradle.kts';
+
+  const filePath = fs.existsSync(gradlePath) ? gradlePath :
+                   fs.existsSync(gradleKtsPath) ? gradleKtsPath : null;
+
+  if (!filePath) return null;
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    // Match versionName "1.2.3" or versionName = "1.2.3"
+    const match = content.match(/versionName\s*[=]?\s*["']([^"']+)["']/);
+    if (match) {
+      return match[1];
+    }
+  } catch {}
+
+  return null;
+}
+
+/**
+ * Read PulseUpdatesURL from Android AndroidManifest.xml
+ */
+function readAndroidPulseUpdatesURL() {
+  const manifest = findAndroidManifest();
+  if (!manifest) return null;
+
+  // Match: <meta-data android:name="PulseUpdatesURL" android:value="..." />
+  const match = manifest.content.match(/<meta-data\s+android:name="PulseUpdatesURL"\s+android:value="([^"]+)"/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Auto-detect runtime version from native config
+ */
+function detectRuntimeVersion(platform) {
+  if (platform === 'ios') {
+    return readIOSVersion();
+  } else if (platform === 'android') {
+    return readAndroidVersion();
+  }
+  return null;
+}
+
+/**
+ * Extract base API URL from full manifest URL
+ * e.g., "https://pulse.lyramusic.app/pulse/manifest/lyra" -> "https://pulse.lyramusic.app"
+ */
+function extractApiUrlFromManifestUrl(manifestUrl) {
+  if (!manifestUrl) return null;
+
+  try {
+    const url = new URL(manifestUrl);
+    // Return origin (protocol + host)
+    return url.origin;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read PulseUpdatesURL from native config based on platform
+ */
+function readPulseUpdatesURL(platform) {
+  if (platform === 'ios') {
+    return readIOSPulseUpdatesURL();
+  } else if (platform === 'android') {
+    return readAndroidPulseUpdatesURL();
+  }
+  return null;
+}
+
+/**
+ * Auto-detect API URL from native config
+ */
+function detectApiUrl(platform) {
+  const manifestUrl = readPulseUpdatesURL(platform);
+  if (manifestUrl) {
+    const apiUrl = extractApiUrlFromManifestUrl(manifestUrl);
+    if (apiUrl) {
+      return apiUrl;
+    }
+  }
+  return null;
+}
+
+/**
+ * Load configuration from native files, pulse.config.json, or environment
+ * Priority (highest to lowest):
+ * 1. Command line options
+ * 2. Environment variables
+ * 3. pulse.config.json
+ * 4. Native files (Info.plist / AndroidManifest.xml)
+ */
+function loadConfig(options) {
+  const configPath = path.join(process.cwd(), 'pulse.config.json');
+  let fileConfig = {};
+
+  if (fs.existsSync(configPath)) {
+    fileConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  }
+
+  const platform = options.platform || fileConfig.platform;
+
+  // Auto-detect runtime version if not specified
+  let runtimeVersion = options['runtime-version'] ||
+    process.env.PULSE_RUNTIME_VERSION ||
+    fileConfig.runtimeVersion;
+
+  if (!runtimeVersion && platform) {
+    runtimeVersion = detectRuntimeVersion(platform);
+    if (runtimeVersion) {
+      log(`  Auto-detected runtime version: ${runtimeVersion}`, colors.dim);
+    }
+  }
+
+  // Auto-detect API URL from native config if not specified
+  let apiUrl = options['api-url'] || process.env.PULSE_API_URL || fileConfig.apiUrl;
+
+  if (!apiUrl && platform) {
+    apiUrl = detectApiUrl(platform);
+    if (apiUrl) {
+      log(`  Auto-detected API URL from native config: ${apiUrl}`, colors.dim);
+    }
+  }
+
+  return {
+    apiUrl,
+    apiKey: options['api-key'] || process.env.PULSE_API_KEY || fileConfig.apiKey,
+    runtimeVersion,
+    platform,
+    channel: options.channel || fileConfig.channel || 'production',
+    bundleDir: options['bundle-dir'] || fileConfig.bundleDir || './dist',
+    entryFile: options['entry-file'] || fileConfig.entryFile || 'index.ts',
+    skipBundle: options['skip-bundle'] || false,
+    build: options.build || process.env.PULSE_BUILD || fileConfig.build || null,
+    message: options.message || fileConfig.message || null,
+  };
+}
+
+/**
+ * Main publish command
+ */
+async function publish(options) {
+  const config = loadConfig(options);
+
+  // Validate required config
+  if (!config.apiUrl) {
+    throw new Error('API URL is required. Set --api-url, PULSE_API_URL env, or apiUrl in pulse.config.json');
+  }
+  if (!config.apiKey) {
+    throw new Error('API key is required. Set --api-key, PULSE_API_KEY env, or apiKey in pulse.config.json');
+  }
+  if (!config.platform) {
+    throw new Error('Platform is required. Set --platform (ios or android)');
+  }
+  if (!config.runtimeVersion) {
+    throw new Error('Runtime version is required. Set --runtime-version');
+  }
+
+  const bundleDir = path.resolve(config.bundleDir);
+
+  log(`\n${colors.bright}Pulse Updates - Publish${colors.reset}\n`);
+  log(`Platform: ${config.platform}`);
+  log(`Runtime Version: ${config.runtimeVersion}`);
+  log(`Channel: ${config.channel}`);
+  if (config.build) {
+    log(`Build: ${config.build}`);
+  }
+  log(`Bundle Dir: ${bundleDir}\n`);
+
+  // Step 1: Create bundle (unless skipped)
+  if (!config.skipBundle) {
+    logStep('1/6', 'Creating bundle...');
+    const bundlePath = createBundle(config.platform, bundleDir, config.entryFile);
+    logSuccess(`Bundle created: ${bundlePath}`);
+
+    // Step 2: Compile with Hermes
+    logStep('2/6', 'Compiling with Hermes...');
+    compileWithHermes(bundlePath, config.platform);
+    logSuccess('Hermes compilation complete');
+  } else {
+    logStep('1/6', 'Skipping bundle creation (--skip-bundle)');
+    logStep('2/6', 'Skipping Hermes compilation');
+  }
+
+  // Step 3: Collect assets and calculate hashes
+  logStep('3/6', 'Collecting assets and calculating hashes...');
+  const assets = await collectAssets(bundleDir, config.platform);
+  logSuccess(`Found ${assets.length} assets (1 bundle, ${assets.length - 1} assets)`);
+
+  // Step 4: Create release
+  logStep('4/6', 'Creating release...');
+
+  // Build metadata object
+  const metadata = {};
+  if (config.build) {
+    metadata.build = config.build;
+  }
+  if (config.message) {
+    metadata.message = config.message;
+  }
+
+  const createResponse = await fetch(`${config.apiUrl}/api/releases`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-API-Key': config.apiKey,
+    },
+    body: JSON.stringify({
+      runtimeVersion: config.runtimeVersion,
+      platform: config.platform,
+      channel: config.channel,
+      metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+    }),
+  });
+
+  if (!createResponse.ok) {
+    const text = await createResponse.text();
+    let errorMsg = createResponse.statusText;
+    try {
+      const error = JSON.parse(text);
+      errorMsg = error.error || error.message || errorMsg;
+    } catch {
+      errorMsg = text || errorMsg;
+    }
+    throw new Error(`Failed to create release: ${errorMsg} (${createResponse.status})`);
+  }
+
+  const responseText = await createResponse.text();
+  let release;
+  try {
+    release = JSON.parse(responseText);
+  } catch {
+    throw new Error(`Invalid JSON response from server: ${responseText.slice(0, 200)}`);
+  }
+  logSuccess(`Created release: ${release.id}`);
+
+  // Step 5: Check which assets already exist and upload missing ones
+  logStep('5/6', 'Checking and uploading assets...');
+  const checkResponse = await fetch(`${config.apiUrl}/api/releases/${release.id}/assets/check`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-API-Key': config.apiKey,
+    },
+    body: JSON.stringify({
+      assets: assets.map((a) => ({
+        hash: a.hash,
+        key: a.key,
+        contentType: a.contentType,
+        fileExtension: a.fileExtension,
+        fileSize: a.fileSize,
+        isLaunchAsset: a.isLaunchAsset,
+      })),
+    }),
+  });
+
+  if (!checkResponse.ok) {
+    const error = await checkResponse.json();
+    throw new Error(`Failed to check assets: ${error.error || checkResponse.statusText}`);
+  }
+
+  const checkResult = await checkResponse.json();
+  const existingCount = checkResult.existing.length;
+  const missingCount = checkResult.missing.length;
+
+  if (existingCount > 0) {
+    log(`  ${existingCount} assets already exist (skipped)`, colors.dim);
+  }
+
+  // Upload missing assets
+  if (missingCount > 0) {
+    log(`  Uploading ${missingCount} assets...`, colors.dim);
+
+    let uploaded = 0;
+    const concurrencyLimit = 10;
+
+    for (let i = 0; i < checkResult.missing.length; i += concurrencyLimit) {
+      const batch = checkResult.missing.slice(i, i + concurrencyLimit);
+      await Promise.all(
+        batch.map(async (missingAsset) => {
+          const asset = assets.find((a) => a.hash === missingAsset.hash);
+          if (!asset) {
+            throw new Error(`Asset not found for hash: ${missingAsset.hash}`);
+          }
+          await uploadToPresignedUrl(asset.path, missingAsset.uploadUrl, asset.contentType);
+          uploaded++;
+          process.stdout.write(`\r  Uploaded ${uploaded}/${missingCount}`);
+        })
+      );
+    }
+    console.log();
+
+    // Confirm uploads
+    const confirmResponse = await fetch(`${config.apiUrl}/api/releases/${release.id}/assets/confirm`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': config.apiKey,
+      },
+      body: JSON.stringify({
+        assets: checkResult.missing.map((m) => {
+          const asset = assets.find((a) => a.hash === m.hash);
+          return {
+            hash: m.hash,
+            key: m.key,
+            contentType: asset.contentType,
+            fileExtension: asset.fileExtension,
+            fileSize: asset.fileSize,
+            isLaunchAsset: asset.isLaunchAsset,
+          };
+        }),
+      }),
+    });
+
+    if (!confirmResponse.ok) {
+      const error = await confirmResponse.json();
+      throw new Error(`Failed to confirm uploads: ${error.error || confirmResponse.statusText}`);
+    }
+  }
+
+  logSuccess(`${missingCount} uploaded, ${existingCount} skipped`);
+
+  // Step 6: Finalize release
+  logStep('6/6', 'Finalizing release...');
+  const finalizeResponse = await fetch(`${config.apiUrl}/api/releases/${release.id}/finalize`, {
+    method: 'POST',
+    headers: {
+      'X-API-Key': config.apiKey,
+    },
+  });
+
+  if (!finalizeResponse.ok) {
+    const error = await finalizeResponse.json();
+    throw new Error(`Failed to finalize release: ${error.error || finalizeResponse.statusText}`);
+  }
+
+  const finalResult = await finalizeResponse.json();
+
+  log(`\n${colors.bright}${colors.green}✓ Published successfully!${colors.reset}\n`);
+  log(`Release ID: ${finalResult.id}`);
+  log(`Manifest URL: ${finalResult.manifestUrl}`);
+  log(`Total assets: ${finalResult.assetCount}`);
+  log(`Uploaded: ${missingCount}`);
+  log(`Skipped: ${existingCount}`);
+
+  const bundleAsset = assets.find((a) => a.isLaunchAsset);
+  if (bundleAsset) {
+    log(`Bundle hash: ${bundleAsset.hash}`);
+  }
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${colors.bright}Pulse Updates CLI v${VERSION}${colors.reset}
+
+${colors.cyan}Usage:${colors.reset}
+  pulse-updates publish [options]
+
+${colors.cyan}Commands:${colors.reset}
+  publish     Create bundle and publish update to server
+
+${colors.cyan}Options:${colors.reset}
+  --api-url <url>         API server URL (auto-detected from native config)
+  --api-key <key>         API key for authentication
+  --platform <platform>   Platform (ios or android)
+  --runtime-version <v>   Runtime version (auto-detected from native config)
+  --channel <channel>     Release channel (default: production)
+  --bundle-dir <dir>      Output directory (default: ./dist)
+  --entry-file <file>     Entry file (default: index.ts)
+  --skip-bundle           Skip bundle creation (use existing)
+  --build <number>        Build number (shown in version, e.g., 1.0.0.42)
+  --message <msg>         Release message/notes
+
+${colors.cyan}Configuration:${colors.reset}
+  Options can be set via (in priority order):
+  1. Command line options
+  2. Environment variables: PULSE_API_URL, PULSE_API_KEY, PULSE_RUNTIME_VERSION
+  3. Config file: pulse.config.json in project root
+  4. Native files: Info.plist (iOS) or AndroidManifest.xml (Android)
+
+${colors.cyan}Auto-detection:${colors.reset}
+  The following values can be auto-detected from native config files:
+  - apiUrl: Extracted from PulseUpdatesURL in Info.plist/AndroidManifest.xml
+  - runtimeVersion: From CFBundleShortVersionString (iOS) or versionName (Android)
+
+${colors.cyan}Example:${colors.reset}
+  # Minimal command (apiUrl and runtimeVersion auto-detected):
+  pulse-updates publish --platform ios --api-key your-api-key
+
+  # Or with all options explicit:
+  pulse-updates publish --platform ios --api-url https://pulse.example.com --api-key your-key --runtime-version 1.0.0
+
+${colors.cyan}Config file example (pulse.config.json):${colors.reset}
+  {
+    "apiKey": "your-api-key",
+    "bundleDir": "./dist"
+  }
+`);
+}
+
+// Main entry point
+async function main() {
+  const { command, options } = parseArgs();
+
+  try {
+    switch (command) {
+      case 'publish':
+        await publish(options);
+        break;
+      case 'help':
+      case '--help':
+      case '-h':
+      case undefined:
+        showHelp();
+        break;
+      case 'version':
+      case '--version':
+      case '-v':
+        console.log(`pulse-updates v${VERSION}`);
+        break;
+      default:
+        logError(`Unknown command: ${command}`);
+        showHelp();
+        process.exit(1);
+    }
+  } catch (error) {
+    logError(error.message);
+    if (options.verbose) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+main();