@everystack/cli 0.2.17 → 0.2.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/cli",
-  "version": "0.2.17",
+  "version": "0.2.18",
   "description": "CLI and OTA updates for Expo apps on everystack",
   "license": "AGPL-3.0-only",
   "publishConfig": {

package/src/cli/aws.ts

@@ -42,6 +42,35 @@ export async function uploadToS3(
   }));
 }
 
+export async function headS3(
+  region: string,
+  bucket: string,
+  key: string,
+): Promise<{ etag: string; size?: number } | null> {
+  const client = await getS3(region);
+  const { HeadObjectCommand } = await import('@aws-sdk/client-s3');
+  try {
+    const response = await client.send(new HeadObjectCommand({
+      Bucket: bucket,
+      Key: key,
+    }));
+    return {
+      etag: response.ETag || '',
+      size: response.ContentLength,
+    };
+  } catch (err: unknown) {
+    if (err && typeof err === 'object' && 'name' in err) {
+      const name = (err as { name: string }).name;
+      if (name === 'NotFound' || name === '404') return null;
+    }
+    if (err && typeof err === 'object' && '$metadata' in err) {
+      const meta = (err as { $metadata: { httpStatusCode?: number } }).$metadata;
+      if (meta?.httpStatusCode === 404) return null;
+    }
+    throw err;
+  }
+}
+
 export async function getFromS3(
   region: string,
   bucket: string,

package/src/cli/commands/update.ts

@@ -6,7 +6,7 @@ import { pipeline } from 'node:stream/promises';
 import { createWriteStream } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { resolveConfig, type CliConfig } from '../config.js';
-import { uploadToS3, invokeAction } from '../aws.js';
+import { uploadToS3, headS3, invokeAction } from '../aws.js';
 import { step, success, warn, fail, info } from '../output.js';
 import { exportApp } from '../utils/export.js';
 import { walkDirectory } from '../utils/walk.js';
@@ -186,7 +186,10 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
       const branchName = branch || channel;
       const storagePrefix = `releases/${branchName}/${runtimeVersion}/${groupId}/${platform}`;
 
-      // Upload each asset directly to S3 with content hashing
+      // Upload each asset directly to S3 with content hashing.
+      // Non-launch assets use a shared content-addressed store (assets/{hash}{ext})
+      // so identical files across releases are stored once. Launch assets (JS bundles)
+      // remain per-release for rollback isolation.
       const uploaded: Array<{
         path: string;
         s3Key: string;
@@ -199,12 +202,42 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
       }> = [];
 
       const UPLOAD_CONCURRENCY = 6;
+      let newAssets = 0;
+      let skippedAssets = 0;
       for (let i = 0; i < assets.length; i += UPLOAD_CONCURRENCY) {
         const batch = assets.slice(i, i + UPLOAD_CONCURRENCY);
         try {
           await Promise.all(batch.map(async (asset) => {
             const data = Buffer.from(asset.data, 'base64');
-            const s3Key = `${storagePrefix}/${asset.path}`;
+            const sha256 = crypto.createHash('sha256').update(data).digest('base64')
+              .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+            const md5 = crypto.createHash('md5').update(data).digest('hex');
+
+            // Launch assets → per-release path (changes every build, needs rollback isolation)
+            // Non-launch assets → shared content-addressed path (fonts, images — rarely change)
+            const s3Key = asset.isLaunchAsset
+              ? `${storagePrefix}/${asset.path}`
+              : `assets/${sha256}${asset.fileExtension}`;
+
+            // Skip upload if shared asset already exists
+            if (!asset.isLaunchAsset) {
+              const existing = await headS3(config.region, config.updatesBucket, s3Key);
+              if (existing) {
+                skippedAssets++;
+                uploaded.push({
+                  path: asset.path,
+                  s3Key,
+                  contentHash: sha256,
+                  filename: md5,
+                  mimeType: asset.contentType,
+                  fileExtension: asset.fileExtension,
+                  isLaunchAsset: asset.isLaunchAsset,
+                  sizeBytes: data.length,
+                });
+                return;
+              }
+            }
+
             await uploadToS3(
               config.region,
               config.updatesBucket,
@@ -212,9 +245,7 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
               data,
               asset.contentType,
             );
-            const sha256 = crypto.createHash('sha256').update(data).digest('base64')
-              .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-            const md5 = crypto.createHash('md5').update(data).digest('hex');
+            newAssets++;
             uploaded.push({
               path: asset.path,
               s3Key,
@@ -258,7 +289,11 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
           process.exit(1);
         }
         if (result?.groupId && !groupId) groupId = result.groupId;
-        success(`${platform}: ${uploaded.length} assets`);
+        if (skippedAssets > 0) {
+          success(`${platform}: ${newAssets} new, ${skippedAssets} unchanged (skipped)`);
+        } else {
+          success(`${platform}: ${uploaded.length} assets`);
+        }
       } catch (err: any) {
         fail(`Registration failed for ${platform}: ${err.message}`);
         info('Ensure your IAM user/role has lambda:InvokeFunction permission.');
@@ -345,11 +380,18 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
         step(`Uploading ${clientAssets.length} client assets...`);
         const UPLOAD_CONCURRENCY = 10;
         let uploaded = 0;
+        let skipped = 0;
 
         for (let i = 0; i < clientAssets.length; i += UPLOAD_CONCURRENCY) {
           const batch = clientAssets.slice(i, i + UPLOAD_CONCURRENCY);
           try {
             await Promise.all(batch.map(async (asset) => {
+              // Skip upload if asset already exists (content-hash filenames = identical content)
+              const existing = await headS3(config.region, config.clientBundlesBucket, asset.relativePath);
+              if (existing) {
+                skipped++;
+                return;
+              }
               const data = Buffer.from(asset.data, 'base64');
               await uploadToS3(
                 config.region,
@@ -367,7 +409,11 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
             process.exit(1);
           }
         }
-        success(`${uploaded}/${clientAssets.length} assets uploaded to s3://${config.clientBundlesBucket}/`);
+        if (skipped > 0) {
+          success(`${uploaded} new, ${skipped} unchanged (skipped)`);
+        } else {
+          success(`${uploaded}/${clientAssets.length} assets uploaded to s3://${config.clientBundlesBucket}/`);
+        }
       }
 
       // 4. Write release manifests directly to S3 (source of truth for SSR).

package/src/handler/publish.ts

@@ -304,20 +304,40 @@ export async function handlePublish(request: Request, options: UpdatesHandlerOpt
   const groupId = body.groupId || crypto.randomUUID();
   const storagePrefix = `releases/${branchName}/${body.runtimeVersion}/${groupId}/${body.platform}`;
 
-  // Upload assets to storage, building post-upload records
+  // Upload assets to storage, building post-upload records.
+  // Non-launch assets use a shared content-addressed store (assets/{hash}{ext})
+  // so identical files across releases are stored once. Launch assets (JS bundles)
+  // remain per-release for rollback isolation.
   const uploadedAssets: RegisterMobileAsset[] = [];
   for (const asset of body.assets) {
     const data = Buffer.from(asset.data, 'base64');
-    const s3Key = `${storagePrefix}/${asset.path}`;
-    await options.storage.put(s3Key, data, asset.contentType);
+    const isLaunch = asset.isLaunchAsset ?? false;
+    const contentHash = sha256Base64Url(data);
+    const ext = asset.fileExtension.startsWith('.') ? asset.fileExtension : `.${asset.fileExtension}`;
+
+    // Launch assets → per-release path; non-launch → shared content-addressed path
+    const s3Key = isLaunch
+      ? `${storagePrefix}/${asset.path}`
+      : `assets/${contentHash}${ext}`;
+
+    // Skip upload if shared asset already exists
+    if (!isLaunch) {
+      const exists = await options.storage.exists(s3Key);
+      if (!exists) {
+        await options.storage.put(s3Key, data, asset.contentType);
+      }
+    } else {
+      await options.storage.put(s3Key, data, asset.contentType);
+    }
+
     uploadedAssets.push({
       path: asset.path,
       s3Key,
-      contentHash: sha256Base64Url(data),
+      contentHash,
       filename: md5Hex(data),
       mimeType: asset.contentType,
       fileExtension: asset.fileExtension,
-      isLaunchAsset: asset.isLaunchAsset ?? false,
+      isLaunchAsset: isLaunch,
       sizeBytes: data.length,
     });
   }