@everystack/cli 0.2.8 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/cli",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "CLI and OTA updates for Expo apps on everystack",
   "license": "AGPL-3.0-only",
   "publishConfig": {
@@ -41,6 +41,7 @@
     "lint": "tsc --noEmit"
   },
   "dependencies": {
+    "@aws-sdk/client-cloudfront": "3.1053.0",
     "@aws-sdk/client-cloudfront-keyvaluestore": "3.1053.0",
     "@aws-sdk/signature-v4a": "3.1048.0",
     "glob": "13.0.6",
@@ -50,7 +51,6 @@
   },
   "peerDependencies": {
     "@everystack/server": ">=0.1.0",
-    "@aws-sdk/client-cloudfront": "3.1053.0",
     "@aws-sdk/client-cloudwatch-logs": "3.1053.0",
     "@aws-sdk/client-lambda": "3.1053.0",
     "@aws-sdk/client-s3": "3.1053.0",
@@ -64,9 +64,6 @@
     "@everystack/server": {
       "optional": true
     },
-    "@aws-sdk/client-cloudfront": {
-      "optional": true
-    },
     "@aws-sdk/client-cloudwatch-logs": {
       "optional": true
     },
@@ -90,7 +87,6 @@
     }
   },
   "devDependencies": {
-    "@aws-sdk/client-cloudfront": "3.1053.0",
     "@aws-sdk/client-cloudwatch-logs": "3.1053.0",
     "@aws-sdk/client-lambda": "3.1053.0",
     "@aws-sdk/client-s3": "3.1053.0",

package/src/cli/aws.ts

@@ -94,19 +94,13 @@ export async function invokeAction(
 
 /**
  * Resolve the CloudWatch log group for a Lambda function.
- * Queries GetFunctionConfiguration for LoggingConfig.LogGroup, falling back to
- * the conventional `/aws/lambda/{functionName}` pattern if not set.
+ * Uses the conventional `/aws/lambda/{functionName}` naming — no IAM call needed.
  */
-export async function resolveLogGroup(
-  region: string,
+export function resolveLogGroup(
+  _region: string,
   functionName: string,
-): Promise<string> {
-  const client = await getLambda(region);
-  const { GetFunctionConfigurationCommand } = await import('@aws-sdk/client-lambda');
-  const config = await client.send(
-    new GetFunctionConfigurationCommand({ FunctionName: functionName })
-  );
-  return config.LoggingConfig?.LogGroup ?? `/aws/lambda/${functionName}`;
+): string {
+  return `/aws/lambda/${functionName}`;
 }
 
 /**

package/src/cli/commands/update.ts

@@ -8,7 +8,7 @@ import { spawn } from 'node:child_process';
 import { resolveConfig, type CliConfig } from '../config.js';
 import { uploadToS3, invokeAction } from '../aws.js';
 import { step, success, warn, fail, info } from '../output.js';
-import { exportApp, isDistStale } from '../utils/export.js';
+import { exportApp } from '../utils/export.js';
 import { walkDirectory } from '../utils/walk.js';
 
 export interface UpdateFlags {
@@ -27,13 +27,19 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
   // (e.g. OUTBOUND_HOST=localhost → LAN IP) to leak into the manifest.
   process.env.EVERYSTACK_UPDATE = '1';
 
-  // Set ENVIRONMENT before app.config.js evaluation so the manifest
+  // Resolve ENVIRONMENT before app.config.js evaluation so the manifest
   // snapshots the correct API URLs and feature flags for the target.
-  // --environment is explicit; --stage is NOT used as a fallback because
-  // SST stage names (dev, prod) don't match EAS profile names
-  // (development, production) and conflating them causes config failures.
+  // Priority: --environment flag > eas.json channel match > existing env.
   if (flags.environment) {
     process.env.ENVIRONMENT ||= flags.environment;
+  } else if (!process.env.ENVIRONMENT) {
+    // Derive ENVIRONMENT from eas.json by matching --channel to a build profile.
+    // EAS profiles define ENVIRONMENT in their env blocks (e.g. production → "production").
+    const channel = flags.channel || flags.branch || flags.stage || 'production';
+    const easEnv = resolveEasEnvironment(channel);
+    if (easEnv) {
+      process.env.ENVIRONMENT = easEnv;
+    }
   }
 
   // When --stage is provided, resolve deployed config early so HOST_URL
@@ -64,6 +70,21 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
   const appConfig = await loadAppConfig();
   const runtimeVersion = appConfig.runtimeVersion;
 
+  // Validate: SSR flags in the expo-router plugin config will crash native devices.
+  // The bundle is compiled with server rendering code paths that have no server at runtime.
+  const ssrFlags = getExpoRouterSsrFlags(appConfig);
+  if (ssrFlags.useServerRendering || ssrFlags.useServerDataLoaders) {
+    fail('Export contains server rendering flags that will crash native devices.');
+    info('expo-router plugin has unstable_useServerRendering or unstable_useServerDataLoaders enabled.');
+    info('Use SSR_ENABLED to opt in only for web server exports:');
+    info('');
+    info("  ['expo-router', {");
+    info('    unstable_useServerRendering: !!process.env.SSR_ENABLED,');
+    info('    unstable_useServerDataLoaders: !!process.env.SSR_ENABLED,');
+    info('  }]');
+    process.exit(1);
+  }
+
   if (!runtimeVersion) {
     fail('No runtimeVersion found in app.json/app.config.js');
     info('Add "runtimeVersion" to your app.json, e.g.:');
@@ -73,32 +94,26 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
   }
   success(`Runtime version: ${runtimeVersion}`);
 
-  // Export if needed
   const distDir = path.resolve('dist');
-  const distExists = await dirExists(distDir);
-  let shouldExport = flags.export === 'true' || !distExists;
-
-  // Check if dist/ is stale (source files newer than dist/)
-  if (!shouldExport && flags['skip-export'] !== 'true' && distExists) {
-    if (await isDistStale(distDir)) {
-      step('Source files changed since last export, re-exporting...');
-      shouldExport = true;
-    }
-  }
+  const needsMobile = platformFilter !== 'web';
 
-  if (shouldExport) {
+  // First export: mobile-safe bundles (no SSR_ENABLED).
+  // Always re-export — stale dist/ is the #1 cause of broken OTA pushes.
+  if (needsMobile) {
     step('Exporting app...');
     await exportApp();
     success('Export complete');
   }
 
   // Read metadata (mobile exports produce metadata.json; web-only exports don't)
-  const metadataPath = path.join(distDir, 'metadata.json');
   let metadata: any = null;
-  try {
-    metadata = JSON.parse(await fs.readFile(metadataPath, 'utf8'));
-  } catch {
-    // No metadata.json — web-only export
+  if (needsMobile) {
+    const metadataPath = path.join(distDir, 'metadata.json');
+    try {
+      metadata = JSON.parse(await fs.readFile(metadataPath, 'utf8'));
+    } catch {
+      // No metadata.json
+    }
   }
 
   // Determine platforms to publish
@@ -228,6 +243,16 @@ export async function updateCommand(flags: UpdateFlags & Record<string, string>)
 
   // Web publish — direct S3 upload + Lambda invoke (IAM auth)
   if (hasWeb) {
+    // Re-export with SSR_ENABLED for web server rendering.
+    // The first export produced mobile-safe bundles (already uploaded above).
+    // This second export enables SSR flags so the web bundle includes
+    // server rendering code paths and data loaders.
+    step('Exporting web bundle (SSR)...');
+    process.env.SSR_ENABLED = '1';
+    await exportApp();
+    delete process.env.SSR_ENABLED;
+    success('Web export complete');
+
     const serverDir = path.join(distDir, 'server');
     const clientDir = path.join(distDir, 'client');
     const routesJson = path.join(serverDir, '_expo', 'routes.json');
@@ -490,15 +515,6 @@ function mimeFromExt(ext: string): string {
   return map[ext] || 'application/octet-stream';
 }
 
-async function dirExists(dir: string): Promise<boolean> {
-  try {
-    const stat = await fs.stat(dir);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-}
-
 async function fileExists(filePath: string): Promise<boolean> {
   try {
     const stat = await fs.stat(filePath);
@@ -530,3 +546,61 @@ async function createArchive(sourceDir: string, archivePath: string): Promise<vo
   await pipeline(tar.stdout!, brotli, output);
   await tarExit;
 }
+
+/**
+ * Read eas.json and find ENVIRONMENT for a given channel.
+ * Matches --channel to a build profile's `channel` field, then reads
+ * ENVIRONMENT from that profile's env block. Falls back to profile name
+ * match (e.g. --channel production matches the "production" profile).
+ * @internal Exported for testing.
+ */
+export function resolveEasEnvironment(channel: string, cwd?: string): string | undefined {
+  try {
+    const easPath = path.resolve(cwd || process.cwd(), 'eas.json');
+    // Synchronous read — runs once before export, performance irrelevant.
+    const eas = JSON.parse(require('fs').readFileSync(easPath, 'utf8'));
+    const profiles = eas?.build;
+    if (!profiles || typeof profiles !== 'object') return undefined;
+
+    // First pass: match on explicit channel field
+    for (const [, profile] of Object.entries(profiles)) {
+      const p = profile as any;
+      if (p?.channel === channel && p?.env?.ENVIRONMENT) {
+        return p.env.ENVIRONMENT;
+      }
+    }
+
+    // Second pass: match on profile name (e.g. "production" profile for --channel production)
+    if (profiles[channel]?.env?.ENVIRONMENT) {
+      return profiles[channel].env.ENVIRONMENT;
+    }
+
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Extract expo-router SSR flags from the resolved app config.
+ * Checks the plugins array for the expo-router entry.
+ * @internal Exported for testing.
+ */
+export function getExpoRouterSsrFlags(appConfig: any): {
+  useServerRendering: boolean;
+  useServerDataLoaders: boolean;
+} {
+  const plugins: any[] = appConfig?.plugins || [];
+  for (const plugin of plugins) {
+    // Plugin can be a string or [name, options] tuple
+    const name = Array.isArray(plugin) ? plugin[0] : plugin;
+    const options = Array.isArray(plugin) ? plugin[1] : undefined;
+    if (name === 'expo-router' && options && typeof options === 'object') {
+      return {
+        useServerRendering: !!options.unstable_useServerRendering,
+        useServerDataLoaders: !!options.unstable_useServerDataLoaders,
+      };
+    }
+  }
+  return { useServerRendering: false, useServerDataLoaders: false };
+}

package/src/handler/assets.ts

@@ -1,10 +1,13 @@
 import type { UpdatesHandlerOptions } from './types';
 
+const debug = process.env.DEBUG_UPDATES === '1';
+
 export async function handleAssets(request: Request, options: UpdatesHandlerOptions): Promise<Response> {
   const url = new URL(request.url);
   const key = url.searchParams.get('key');
 
   if (!key) {
+    console.warn('[updates] asset request rejected: no key');
     return new Response(JSON.stringify({ error: 'No asset key provided.' }), {
       status: 400,
       headers: { 'content-type': 'application/json' },
@@ -15,6 +18,7 @@ export async function handleAssets(request: Request, options: UpdatesHandlerOpti
   // Lambda function URLs cap responses at 6 MB; Hermes bytecode bundles exceed that.
   if (options.storage.presignGet) {
     const presignedUrl = await options.storage.presignGet(key);
+    debug && console.log('[updates] asset redirect', { key });
     return new Response(null, {
       status: 302,
       headers: {
@@ -29,6 +33,7 @@ export async function handleAssets(request: Request, options: UpdatesHandlerOpti
   const result = await options.storage.get(key);
 
   if (!result) {
+    console.warn('[updates] asset not found', { key });
     return new Response(JSON.stringify({ error: `Asset "${key}" not found.` }), {
       status: 404,
       headers: { 'content-type': 'application/json' },

package/src/handler/index.ts

@@ -71,6 +71,7 @@ export function createUpdatesHandler(options: UpdatesHandlerOptions): (request:
       return handleEditChannel(request, options, channelName);
     }
 
+    console.warn('[updates] 404 unmatched route', { method: request.method, pathname });
     return new Response(JSON.stringify({ error: 'Not found' }), {
       status: 404,
       headers: { 'content-type': 'application/json' },

package/src/handler/manifest.ts

@@ -6,6 +6,8 @@ import { buildMultipartResponse } from './multipart';
 import { signRSASHA256, convertSHA256HashToUUID, convertToDictionaryItemsRepresentation } from './signing';
 import { jsonError } from './helpers';
 
+const debug = process.env.DEBUG_UPDATES === '1';
+
 export async function handleManifest(request: Request, options: UpdatesHandlerOptions): Promise<Response> {
   const headers = request.headers;
 
@@ -14,24 +16,46 @@ export async function handleManifest(request: Request, options: UpdatesHandlerOp
 
   const platform = headers.get('expo-platform');
   if (platform !== 'ios' && platform !== 'android') {
+    console.warn('[updates] manifest request rejected: unsupported platform', {
+      platform: headers.get('expo-platform'),
+    });
     return jsonError(400, 'Unsupported platform. Expected either ios or android.');
   }
 
   const runtimeVersion = headers.get('expo-runtime-version');
   if (!runtimeVersion) {
+    console.warn('[updates] manifest request rejected: no runtimeVersion');
     return jsonError(400, 'No runtimeVersion provided.');
   }
 
   const channelName = headers.get('expo-channel-name') || options.defaultChannel || 'production';
 
+  debug && console.log('[updates] manifest request', {
+    platform,
+    runtimeVersion,
+    channelName,
+    currentUpdateId: headers.get('expo-current-update-id'),
+    protocolVersion,
+    expectSignature: !!headers.get('expo-expect-signature'),
+  });
+
   // Try S3 flat-file manifest first (works without DB)
+  const s3Key = `${channelName}/${platform}/${runtimeVersion}/manifest.json`;
   const s3Manifest = await tryS3Manifest(options, channelName, platform, runtimeVersion);
   if (s3Manifest) {
+    debug && console.log('[updates] S3 manifest found', {
+      key: s3Key,
+      updateId: s3Manifest.id,
+      assetCount: s3Manifest.assets?.length,
+      hasLaunchAsset: !!s3Manifest.launchAsset,
+    });
     return buildManifestResponse(request, s3Manifest, options, protocolVersion);
   }
+  debug && console.log('[updates] S3 manifest not found', { key: s3Key });
 
   // Fall back to DB-based lookup (V2)
   if (!options.db) {
+    debug && console.log('[updates] no DB configured, returning 404');
     return jsonError(404, `No update found for ${channelName}/${platform}/${runtimeVersion}`);
   }
 
@@ -50,13 +74,16 @@ export async function handleManifest(request: Request, options: UpdatesHandlerOp
       .limit(1);
 
     if (!channel) {
+      console.warn('[updates] DB channel not found', { channelName });
       return jsonError(404, `Channel "${channelName}" not found.`);
     }
 
     const branchRef = (channel.data as Record<string, unknown>)?.branchRef as string;
     if (!branchRef) {
+      console.warn('[updates] DB channel has no branch mapping', { channelName });
       return jsonError(404, `Channel "${channelName}" has no branch mapping.`);
     }
+    debug && console.log('[updates] DB channel resolved', { channelName, branchRef });
 
     // Look up latest release (buildArtifact type='ota') via run branchRef
     const releaseResults = await options.db
@@ -74,9 +101,15 @@ export async function handleManifest(request: Request, options: UpdatesHandlerOp
       .limit(1);
 
     if (!releaseResults[0]) {
+      console.warn('[updates] DB release not found', { branchRef, runtimeVersion, platform });
       return jsonError(404, `No update found for runtime version: ${runtimeVersion}`);
     }
     release = releaseResults[0].release;
+    debug && console.log('[updates] DB release found', {
+      releaseId: release.id,
+      runId: release.runId,
+      updateId: (release.data as Record<string, unknown>)?.updateId,
+    });
 
     // Look up assets (buildArtifacts type='ota_asset') for this release's run
     assets = await options.db
@@ -86,8 +119,12 @@ export async function handleManifest(request: Request, options: UpdatesHandlerOp
         eq(buildArtifacts.type, 'ota_asset'),
         eq(buildArtifacts.runId, release.runId),
       ));
-  } catch {
+  } catch (err) {
     // DB unavailable or tables don't exist — not an error in V1
+    console.error('[updates] DB lookup error', {
+      error: err instanceof Error ? err.message : String(err),
+      channelName, platform, runtimeVersion,
+    });
     return jsonError(404, `No update found for ${channelName}/${platform}/${runtimeVersion}`);
   }
 
@@ -95,6 +132,7 @@ export async function handleManifest(request: Request, options: UpdatesHandlerOp
 
   // Handle rollback
   if (releaseData.isRollback) {
+    debug && console.log('[updates] response: rollback', { protocolVersion });
     if (protocolVersion === 0) {
       return jsonError(400, 'Rollbacks not supported on protocol version 0');
     }
@@ -106,6 +144,9 @@ export async function handleManifest(request: Request, options: UpdatesHandlerOp
   const updateId = releaseData.updateId as string;
   const releaseUUID = convertSHA256HashToUUID(updateId);
   if (currentUpdateId === releaseUUID && protocolVersion === 1) {
+    debug && console.log('[updates] response: noUpdateAvailable', {
+      currentUpdateId, releaseUUID,
+    });
     return buildNoUpdateAvailableResponse(request, options, protocolVersion);
   }
 
@@ -148,6 +189,13 @@ export async function handleManifest(request: Request, options: UpdatesHandlerOp
     },
   };
 
+  debug && console.log('[updates] response: manifest', {
+    updateId: releaseUUID,
+    assetCount: regularAssets.length,
+    hasLaunchAsset: !!launchAsset,
+    source: 'db',
+  });
+
   return buildManifestResponse(request, manifest, options, protocolVersion);
 }