pulse-updates 1.0.0

package/scripts/create-pulse-resources-ios.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+# create-pulse-resources-ios.sh
+# Xcode build phase script for generating Pulse Updates embedded resources
+# Based on expo-updates create-updates-resources-ios.sh
+
+set -eo pipefail
+
+# Skip in debug mode unless FORCE_BUNDLING is set
+if [[ "$CONFIGURATION" == *Debug* ]]; then
+  if [[ "$FORCE_BUNDLING" ]]; then
+    echo "[PulseUpdates] FORCE_BUNDLING enabled; generating embedded manifest."
+  else
+    echo "[PulseUpdates] Debug build; skipping embedded manifest generation."
+    echo "[PulseUpdates] Set FORCE_BUNDLING=1 to generate in debug mode."
+    exit 0
+  fi
+fi
+
+if [[ "$SKIP_BUNDLING" ]]; then
+  echo "[PulseUpdates] SKIP_BUNDLING enabled; skipping embedded manifest generation."
+  exit 0
+fi
+
+PULSE_UPDATES_PACKAGE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+
+# Destination for the embedded resources
+DEST="${CONFIGURATION_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
+
+# Project root - try to find it
+if [ -n "$PROJECT_ROOT" ]; then
+  PROJECT_ROOT="$PROJECT_ROOT"
+elif [ -d "$PROJECT_DIR/../.." ] && [ -f "$PROJECT_DIR/../../package.json" ]; then
+  PROJECT_ROOT="$PROJECT_DIR/../.."
+elif [ -d "$PROJECT_DIR/.." ] && [ -f "$PROJECT_DIR/../package.json" ]; then
+  PROJECT_ROOT="$PROJECT_DIR/.."
+else
+  echo "[PulseUpdates] Could not determine PROJECT_ROOT. Set it manually."
+  exit 1
+fi
+
+cd "$PROJECT_ROOT" || exit 1
+PROJECT_ROOT="$(pwd -P)"
+
+echo "[PulseUpdates] Project root: $PROJECT_ROOT"
+echo "[PulseUpdates] Destination: $DEST"
+
+# Find the bundle and assets
+BUNDLE_PATH="$DEST/main.jsbundle"
+ASSETS_PATH="$DEST/assets"
+
+if [ ! -f "$BUNDLE_PATH" ]; then
+  echo "[PulseUpdates] Bundle not found at $BUNDLE_PATH"
+  echo "[PulseUpdates] Make sure react-native bundle runs before this script."
+  exit 1
+fi
+
+# Get runtime version from Info.plist or environment
+if [ -n "$MARKETING_VERSION" ]; then
+  RUNTIME_VERSION="$MARKETING_VERSION"
+elif [ -n "$CURRENT_PROJECT_VERSION" ]; then
+  RUNTIME_VERSION="$CURRENT_PROJECT_VERSION"
+else
+  # Try to read from Info.plist
+  PLIST_PATH="$INFOPLIST_FILE"
+  if [ -f "$PLIST_PATH" ]; then
+    RUNTIME_VERSION=$(/usr/libexec/PlistBuddy -c "Print :CFBundleShortVersionString" "$PLIST_PATH" 2>/dev/null || echo "")
+  fi
+fi
+
+if [ -z "$RUNTIME_VERSION" ]; then
+  echo "[PulseUpdates] Could not determine runtime version"
+  exit 1
+fi
+
+echo "[PulseUpdates] Runtime version: $RUNTIME_VERSION"
+
+# Create pulse directory in destination
+PULSE_DIR="$DEST/pulse"
+mkdir -p "$PULSE_DIR"
+
+# Find node - try common locations
+NODE_BIN=""
+if command -v node &> /dev/null; then
+  NODE_BIN="node"
+elif [ -x "$HOME/.nvm/versions/node/$(cat $HOME/.nvmrc 2>/dev/null)/bin/node" ]; then
+  NODE_BIN="$HOME/.nvm/versions/node/$(cat $HOME/.nvmrc)/bin/node"
+elif [ -x "/usr/local/bin/node" ]; then
+  NODE_BIN="/usr/local/bin/node"
+elif [ -x "/opt/homebrew/bin/node" ]; then
+  NODE_BIN="/opt/homebrew/bin/node"
+fi
+
+if [ -z "$NODE_BIN" ]; then
+  echo "[PulseUpdates] Node.js not found"
+  exit 1
+fi
+
+echo "[PulseUpdates] Using Node.js: $NODE_BIN"
+
+# Run the generate-embedded-manifest.mjs script
+"$NODE_BIN" "$PULSE_UPDATES_PACKAGE_DIR/scripts/generate-embedded-manifest.mjs" \
+  --bundle "$BUNDLE_PATH" \
+  --assets "$ASSETS_PATH" \
+  --out "$DEST" \
+  --platform ios \
+  --runtime-version "$RUNTIME_VERSION"
+
+if [ $? -eq 0 ]; then
+  echo "[PulseUpdates] Embedded manifest generated successfully"
+  echo "[PulseUpdates] Output: $PULSE_DIR/embedded-manifest.json"
+else
+  echo "[PulseUpdates] Failed to generate embedded manifest"
+  exit 1
+fi

package/scripts/generate-embedded-manifest.mjs

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+/**
+ * Generate embedded manifest for Pulse Updates
+ * Compatible with Expo Updates format for asset resolution
+ */
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+
+function sha256HexFile(filePath) {
+  const hash = crypto.createHash('sha256');
+  const stream = fs.createReadStream(filePath);
+  return new Promise((resolve, reject) => {
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('error', reject);
+    stream.on('end', () => resolve(hash.digest('hex')));
+  });
+}
+
+function md5HexFile(filePath) {
+  const hash = crypto.createHash('md5');
+  const stream = fs.createReadStream(filePath);
+  return new Promise((resolve, reject) => {
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('error', reject);
+    stream.on('end', () => resolve(hash.digest('hex')));
+  });
+}
+
+function getAssetType(ext) {
+  const types = {
+    '.png': 'png',
+    '.jpg': 'jpg',
+    '.jpeg': 'jpg',
+    '.gif': 'gif',
+    '.webp': 'webp',
+    '.svg': 'svg',
+    '.ttf': 'ttf',
+    '.otf': 'otf',
+    '.woff': 'woff',
+    '.woff2': 'woff2',
+    '.mp3': 'mp3',
+    '.mp4': 'mp4',
+    '.wav': 'wav',
+    '.json': 'json',
+    '.js': 'js',
+  };
+  return types[ext.toLowerCase()] || 'unknown';
+}
+
+function mimeTypeForExtension(ext) {
+  const mimeTypes = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.json': 'application/json',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.wav': 'audio/wav',
+  };
+  return mimeTypes[ext.toLowerCase()] || 'application/octet-stream';
+}
+
+/**
+ * Parse asset filename to extract name and scale
+ * e.g., "logo@2x.png" -> { name: "logo", scale: 2, ext: ".png" }
+ * e.g., "icon.png" -> { name: "icon", scale: 1, ext: ".png" }
+ */
+function parseAssetFilename(filename) {
+  const ext = path.extname(filename);
+  const basename = path.basename(filename, ext);
+
+  // Check for scale suffix like @2x, @3x
+  const scaleMatch = basename.match(/^(.+)@(\d+(?:\.\d+)?)x$/);
+  if (scaleMatch) {
+    return {
+      name: scaleMatch[1],
+      scale: parseFloat(scaleMatch[2]),
+      ext,
+    };
+  }
+
+  return {
+    name: basename,
+    scale: 1,
+    ext,
+  };
+}
+
+/**
+ * Get iOS bundle directory path (like Expo's nsBundleDir)
+ * Replaces .. with _ as React Native CLI does
+ */
+function getIosBundleDir(relativePath) {
+  const dir = path.dirname(relativePath);
+  if (dir === '.' || dir === '') return '';
+  // Replace .. with _ as react-native-cli does
+  return dir.replace(/\.\.\//g, '_').replace(/\\/g, '/');
+}
+
+/**
+ * Get iOS bundle filename (like Expo's nsBundleFilename)
+ */
+function getIosBundleFilename(name, scale) {
+  if (scale === 1) {
+    return name;
+  }
+  // For @2x, @3x etc
+  return `${name}@${scale}x`;
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (let i = 0; i < args.length; i += 2) {
+    const key = args[i];
+    const value = args[i + 1];
+    if (!key || !key.startsWith('--')) continue;
+    result[key.slice(2)] = value;
+  }
+  return result;
+}
+
+async function collectAssets(assetsDir) {
+  if (!assetsDir || !fs.existsSync(assetsDir)) return [];
+
+  const results = [];
+  const stack = [''];
+
+  while (stack.length) {
+    const rel = stack.pop();
+    const abs = path.join(assetsDir, rel);
+    const entries = fs.readdirSync(abs, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryRel = path.join(rel || '', entry.name);
+      const entryAbs = path.join(assetsDir, entryRel);
+      if (entry.isDirectory()) {
+        stack.push(entryRel);
+      } else if (entry.isFile()) {
+        results.push({ rel: entryRel, abs: entryAbs });
+      }
+    }
+  }
+
+  return results;
+}
+
+async function main() {
+  const args = parseArgs();
+  const bundlePath = args.bundle;
+  const assetsDir = args.assets;
+  const outDir = args.out;
+  const platform = args.platform || 'ios';
+  const assetPrefix = Object.prototype.hasOwnProperty.call(args, 'asset-prefix')
+    ? args['asset-prefix']
+    : platform === 'android'
+      ? ''
+      : 'assets';
+  const runtimeVersion =
+    args['runtime-version'] ||
+    process.env.PULSE_RUNTIME_VERSION ||
+    process.env.MARKETING_VERSION ||
+    process.env.CURRENT_PROJECT_VERSION ||
+    'unknown';
+
+  if (!bundlePath || !outDir) {
+    console.error('Usage: generate-embedded-manifest.js --bundle <path> --out <dir> [--assets <dir>] [--platform ios|android] [--runtime-version <version>]');
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(bundlePath)) {
+    console.error(`Bundle not found: ${bundlePath}`);
+    process.exit(1);
+  }
+
+  console.log(`[PulseUpdates] Generating embedded manifest...`);
+  console.log(`[PulseUpdates] Bundle: ${bundlePath}`);
+  console.log(`[PulseUpdates] Assets: ${assetsDir || 'none'}`);
+  console.log(`[PulseUpdates] Platform: ${platform}`);
+  console.log(`[PulseUpdates] Runtime version: ${runtimeVersion}`);
+
+  const bundleHash = await sha256HexFile(bundlePath);
+  const assets = [];
+  const assetFiles = await collectAssets(assetsDir);
+
+  for (const asset of assetFiles) {
+    const hash = await sha256HexFile(asset.abs);
+    // MD5 hash is what expo-asset uses to look up assets via getLocalAssetUri(hash, type)
+    const md5Hash = await md5HexFile(asset.abs);
+    const relative = asset.rel.split(path.sep).join('/');
+    // Use MD5 hash as key - this is how expo-asset looks up assets (same as publish.mjs)
+    const key = md5Hash;
+    const ext = path.extname(asset.rel);
+    const { name, scale } = parseAssetFilename(path.basename(asset.rel));
+    const type = getAssetType(ext);
+
+    // Base asset info (common to both platforms)
+    const assetInfo = {
+      // PulseUpdates fields
+      key, // MD5 hash - matches expo-asset lookup
+      hash, // SHA256 hash - for integrity verification
+      contentType: mimeTypeForExtension(ext),
+      // Expo-compatible fields
+      name,
+      type,
+      scale,
+      packagerHash: md5Hash, // MD5 hash that Metro/expo-asset uses
+      subdirectory: path.dirname(relative) || '',
+      // Keep the path for debugging
+      assetPath: assetPrefix ? path.posix.join(assetPrefix, relative) : relative,
+    };
+
+    // Platform-specific fields
+    if (platform === 'ios') {
+      assetInfo.nsBundleDir = getIosBundleDir(relative);
+      assetInfo.nsBundleFilename = getIosBundleFilename(name, scale);
+    } else if (platform === 'android') {
+      // Android uses drawable/raw folders
+      const isDrawable = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'].includes(type);
+      assetInfo.resourcesFolder = isDrawable ? 'drawable' : 'raw';
+      assetInfo.resourcesFilename = getAndroidResourceIdentifier(relative, name);
+    }
+
+    assets.push(assetInfo);
+  }
+
+  const updateId = `embedded:${runtimeVersion}-${bundleHash.substring(0, 12)}`;
+  const manifest = {
+    // Pulse Updates fields
+    updateId,
+    runtimeVersion,
+    createdAt: new Date().toISOString(),
+    bundle: {
+      hash: bundleHash,
+      url: 'embedded',
+      contentType: 'application/javascript',
+    },
+    assets,
+    // Expo-compatible fields
+    id: updateId,
+    commitTime: Date.now(),
+  };
+
+  const pulseDir = path.join(outDir, 'pulse');
+  fs.mkdirSync(pulseDir, { recursive: true });
+
+  // Write full manifest
+  fs.writeFileSync(
+    path.join(pulseDir, 'embedded-manifest.json'),
+    JSON.stringify(manifest, null, 2)
+  );
+
+  // Write assets map for quick lookup (hash -> key)
+  const assetsMap = Object.fromEntries(assets.map((asset) => [asset.hash, asset.key]));
+  fs.writeFileSync(
+    path.join(pulseDir, 'embedded-assets.json'),
+    JSON.stringify(assetsMap)
+  );
+
+  // Write iOS-specific lookup (nsBundleFilename -> hash) for fast embedded asset resolution
+  if (platform === 'ios') {
+    const iosBundleLookup = {};
+    for (const asset of assets) {
+      const lookupKey = asset.nsBundleDir
+        ? `${asset.nsBundleDir}/${asset.nsBundleFilename}`
+        : asset.nsBundleFilename;
+      iosBundleLookup[lookupKey] = {
+        hash: asset.hash,
+        type: asset.type,
+        scale: asset.scale,
+      };
+    }
+    fs.writeFileSync(
+      path.join(pulseDir, 'embedded-ios-lookup.json'),
+      JSON.stringify(iosBundleLookup)
+    );
+  }
+
+  console.log(`[PulseUpdates] Generated manifest with ${assets.length} assets`);
+  console.log(`[PulseUpdates] Update ID: ${updateId}`);
+  console.log(`[PulseUpdates] Bundle hash: ${bundleHash}`);
+}
+
+/**
+ * Get Android resource identifier (like Expo does)
+ * Converts path to valid Android resource name
+ */
+function getAndroidResourceIdentifier(relativePath, name) {
+  const folderPath = path.dirname(relativePath);
+  return (folderPath + '/' + name)
+    .toLowerCase()
+    .replace(/\//g, '_')
+    .replace(/([^a-z0-9_])/g, '')
+    .replace(/^assets_/, '');
+}
+
+main().catch((error) => {
+  console.error('[PulseUpdates] Error:', error.message);
+  process.exit(1);
+});

package/scripts/manifest-check.js

@@ -0,0 +1,67 @@
+import crypto from 'node:crypto';
+
+function canonicalize(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalize).join(',')}]`;
+  }
+  if (value && typeof value === 'object') {
+    const keys = Object.keys(value).sort();
+    const parts = keys.map((key) => `"${escapeJson(key)}":${canonicalize(value[key])}`);
+    return `{${parts.join(',')}}`;
+  }
+  if (value === null || value === undefined) return 'null';
+  if (typeof value === 'string') return `"${escapeJson(value)}"`;
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  return String(value);
+}
+
+function escapeJson(input) {
+  return JSON.stringify(input).slice(1, -1);
+}
+
+const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+
+const manifest = {
+  updateId: 'test-update',
+  runtimeVersion: '1.0.0',
+  createdAt: new Date().toISOString(),
+  bundle: {
+    hash: crypto.createHash('sha256').update('bundle').digest('hex'),
+    url: 'https://example.com/bundle',
+    contentType: 'application/javascript',
+  },
+  assets: [
+    {
+      hash: crypto.createHash('sha256').update('asset').digest('hex'),
+      url: 'https://example.com/asset',
+      contentType: 'image/png',
+    },
+  ],
+  metadata: {
+    channel: 'production',
+  },
+};
+
+const canonical = canonicalize(manifest);
+const signature = crypto.sign(null, Buffer.from(canonical), privateKey).toString('base64');
+
+const signedManifest = {
+  ...manifest,
+  signature: {
+    alg: 'ed25519',
+    keyId: 'test-key',
+    sig: signature,
+  },
+};
+
+const { signature: _sig, ...unsignedManifest } = signedManifest;
+const verifyCanonical = canonicalize(unsignedManifest);
+const ok = crypto.verify(
+  null,
+  Buffer.from(verifyCanonical),
+  publicKey,
+  Buffer.from(signature, 'base64')
+);
+
+console.log('Manifest signature valid:', ok);
+console.log('Runtime version ok:', signedManifest.runtimeVersion === '1.0.0');