@everystack/cli 0.2.9 → 0.2.11

package/package.json

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

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,28 @@ 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.
+  // Export mobile platforms only — web static pre-rendering can hang when
+  // OUTBOUND_HOST points to a real server (open HTTP handles prevent exit).
+  if (needsMobile) {
     step('Exporting app...');
-    await exportApp();
+    await exportApp('ios,android');
     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 +245,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('web');
+    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 +517,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 +548,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/cli/utils/export.ts

@@ -2,8 +2,9 @@ import { execSync } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
 
-export async function exportApp(): Promise<void> {
-  execSync('npx expo export --output-dir dist', {
+export async function exportApp(platform?: string): Promise<void> {
+  const platformFlag = platform ? ` --platform ${platform}` : '';
+  execSync(`npx expo export --output-dir dist${platformFlag}`, {
     stdio: 'inherit',
     env: { ...process.env },
   });