@everystack/cli 0.1.0

package/src/cli/index.ts

@@ -0,0 +1,178 @@
+#!/usr/bin/env tsx
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { updateCommand } from './commands/update.js';
+import { certsCommand } from './commands/certs.js';
+import { channelsCommand } from './commands/channels.js';
+import { branchesCommand } from './commands/branches.js';
+import { dbMigrateCommand, dbSeedCommand, dbResetCommand, dbPsqlCommand } from './commands/db.js';
+import { consoleCommand } from './commands/console.js';
+import { cachePurgeCommand } from './commands/cache.js';
+import { diagCommand } from './commands/diag.js';
+import { analyzeSSRCommand } from './commands/analyze.js';
+import { logsErrorsCommand, logsTailCommand, logsQueryCommand } from './commands/logs.js';
+import { fail } from './output.js';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function parseFlags(args: string[]): Record<string, string> {
+  const flags: Record<string, string> = {};
+  for (let i = 0; i < args.length; i++) {
+    // Handle both --flag and -flag
+    if (args[i].startsWith('--')) {
+      const key = args[i].slice(2);
+      const value = args[i + 1] && !args[i + 1].startsWith('-') ? args[++i] : 'true';
+      flags[key] = value;
+    } else if (args[i].startsWith('-') && args[i].length > 1) {
+      const key = args[i].slice(1);
+      const value = args[i + 1] && !args[i + 1].startsWith('-') ? args[++i] : 'true';
+      flags[key] = value;
+    }
+  }
+  return flags;
+}
+
+/**
+ * Auto-detect HOST_URL from SST outputs.
+ * SST writes .sst/outputs.json after every deploy with { routerUrl, apiUrl, ... }.
+ * If HOST_URL isn't already set, use the routerUrl from the last deploy.
+ */
+async function loadSstOutputs(): Promise<void> {
+  if (process.env.HOST_URL) return;
+
+  const outputsPath = path.resolve('.sst', 'outputs.json');
+  try {
+    const raw = await fs.readFile(outputsPath, 'utf8');
+    const outputs = JSON.parse(raw);
+    if (outputs.routerUrl) {
+      process.env.HOST_URL = outputs.routerUrl;
+    }
+  } catch {
+    // No .sst/outputs.json — user must set HOST_URL manually or use app.config.js defaults
+  }
+}
+
+async function main() {
+  if (!command || command === '--help' || command === '-h') {
+    printHelp();
+    process.exit(0);
+  }
+
+  const flags = parseFlags(args.slice(1));
+
+  // Auto-detect deployed URL from SST outputs
+  await loadSstOutputs();
+
+  switch (command) {
+    case 'update':
+      await updateCommand(flags);
+      break;
+    case 'certs:generate':
+      await certsCommand('generate', flags);
+      break;
+    case 'certs:configure':
+      await certsCommand('configure', flags);
+      break;
+    case 'channels':
+      await channelsCommand(args[1], flags);
+      break;
+    case 'branches':
+      await branchesCommand(args[1], flags);
+      break;
+    case 'db:migrate':
+      await dbMigrateCommand(flags);
+      break;
+    case 'db:seed':
+      await dbSeedCommand(flags);
+      break;
+    case 'db:reset':
+      await dbResetCommand(flags);
+      break;
+    case 'db:psql':
+      await dbPsqlCommand(flags);
+      break;
+    case 'console':
+      await consoleCommand(flags);
+      break;
+    case 'cache:purge':
+      await cachePurgeCommand(flags);
+      break;
+    case 'diag': {
+      // Positional URL: first arg after 'diag' that doesn't start with '--'
+      const diagUrl = args[1] && !args[1].startsWith('--') ? args[1] : undefined;
+      await diagCommand(diagUrl, flags);
+      break;
+    }
+    case 'analyze:ssr': {
+      const positional = args[1] && !args[1].startsWith('--') ? args[1] : undefined;
+      await analyzeSSRCommand(positional, flags);
+      break;
+    }
+    case 'logs:errors':
+      await logsErrorsCommand(flags);
+      break;
+    case 'logs:tail':
+      await logsTailCommand(flags);
+      break;
+    case 'logs:query':
+      await logsQueryCommand(flags);
+      break;
+    default:
+      fail(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+function printHelp() {
+  console.log(`
+everystack - CLI for Expo apps on everystack
+
+Usage:
+  everystack update            --branch <name> --message <msg> [--platform ios|android|web|all] [--stage <name>]
+  everystack update            --channel <name> --message <msg> [--platform ios|android|web|all] [--stage <name>]
+  everystack db:migrate        [--stage <name>]  Run database migrations on deployed Lambda
+  everystack db:seed           [--stage <name>]  Seed database on deployed Lambda (dev only)
+  everystack db:reset          [--stage <name>]  Drop all schemas + re-run migrations (dev only)
+  everystack db:psql           [--stage <name>] -c <command>  Execute SQL query via Lambda (private RDS)
+  everystack console           --stage <name>    Interactive REPL on deployed Lambda
+  everystack certs:generate    [--output ./certs]
+  everystack certs:configure   [--input ./certs] [--keyid main]
+  everystack cache:purge       [--stage <name>]                  Bust all cached content (global epoch)
+  everystack cache:purge       [--stage <name>] --origin api     Bust API origin cache (api|media|web)
+  everystack cache:purge       [--stage <name>] --path "/api/posts"  Bust specific path cache
+  everystack diag              [url] [--path /about] [--channel <name>] [--stage <name>]  Diagnose page freshness
+  everystack diag              [url] --hydration  Analyze SSR hydration issues (fetches full HTML)
+  everystack analyze:ssr       [--app ./app]      Scan app code for SSR anti-patterns
+  everystack logs:errors       [--stage <name>] [--limit 20] [--level error|fatal] [--source <name>]
+  everystack logs:tail         [--stage <name>] [--filter <pattern>] [--since 5m]
+  everystack logs:query        [--stage <name>] [--level <level>] [--source <name>] [--traceId <id>] [--search <text>]
+  everystack branches list
+  everystack branches create   --name <name>
+  everystack branches delete   --name <name>
+  everystack channels list
+  everystack channels create   --name <name> [--branch <name>]
+  everystack channels edit     --name <name> --branch <name>
+
+Stage resolution:
+  --stage <name>  Discover AWS resources for the given stage by querying AWS APIs.
+                  Uses SST naming convention: {app}-{stage}-{Resource}-{hash}.
+                  Results are cached in .sst/outputs.{stage}.json for 24 hours.
+
+  Without --stage, reads .sst/outputs.json (written by the last \`sst deploy\`).
+
+Auth:
+  All commands use AWS IAM credentials (default credential chain).
+  Mobile publishes also accept EVERYSTACK_TOKEN env var.
+
+Options:
+  --help, -h    Show this help message
+`);
+}
+
+main().catch((err) => {
+  fail(err.message || String(err));
+  process.exit(1);
+});

package/src/cli/output.ts

@@ -0,0 +1,25 @@
+/**
+ * Structured CLI output helpers.
+ *
+ * No spinner library — step markers work in CI/CD and terminals alike.
+ */
+
+export function step(msg: string): void {
+  console.log(`  > ${msg}`);
+}
+
+export function success(msg: string): void {
+  console.log(`  \u2713 ${msg}`);
+}
+
+export function warn(msg: string): void {
+  console.log(`  ! ${msg}`);
+}
+
+export function fail(msg: string): void {
+  console.error(`  \u2717 ${msg}`);
+}
+
+export function info(msg: string): void {
+  console.log(`  ${msg}`);
+}

package/src/cli/ssr-analyzer.ts

@@ -0,0 +1,445 @@
+/**
+ * ssr-analyzer — static analysis for SSR code patterns.
+ *
+ * Scans app code for common SSR anti-patterns:
+ *   - useEffect that immediately refetches data (silent re-renders)
+ *   - Date rendering without timeZone: 'UTC'
+ *   - Number() coercions (symptom of aggregate type mismatches)
+ *   - Relative time rendering in loader functions
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { glob } from 'glob';
+
+interface SSRIssue {
+  type: 'immediate-refetch' | 'missing-timezone' | 'aggregate-coercion' | 'relative-time-ssr' | 'browser-only-api';
+  severity: 'error' | 'warning' | 'info';
+  message: string;
+  file: string;
+  line?: number;
+  snippet?: string;
+  fix?: string;
+}
+
+interface SSRAnalysis {
+  issues: SSRIssue[];
+  stats: {
+    totalFiles: number;
+    loaderFiles: number;
+    immediateRefetches: number;
+    missingTimezones: number;
+    aggregateCoercions: number;
+    relativeTimeInSSR: number;
+    browserOnlyAPIs: number;
+  };
+}
+
+/**
+ * Analyze app directory for SSR patterns.
+ */
+export async function analyzeSSRPatterns(appDir: string): Promise<SSRAnalysis> {
+  const issues: SSRIssue[] = [];
+  const stats = {
+    totalFiles: 0,
+    loaderFiles: 0,
+    immediateRefetches: 0,
+    missingTimezones: 0,
+    aggregateCoercions: 0,
+    relativeTimeInSSR: 0,
+    browserOnlyAPIs: 0,
+  };
+
+  // Find all TypeScript/JavaScript files in app directory
+  const files = await glob('**/*.{ts,tsx,js,jsx}', {
+    cwd: appDir,
+    absolute: true,
+    ignore: ['**/node_modules/**', '**/.expo/**', '**/dist/**', '**/__tests__/**'],
+  });
+
+  stats.totalFiles = files.length;
+
+  for (const file of files) {
+    const content = await fs.readFile(file, 'utf-8');
+    const relPath = path.relative(appDir, file);
+
+    // Check if file exports a loader (SSR function)
+    const hasLoader = /export\s+(?:async\s+)?function\s+loader\s*\(/.test(content);
+    if (hasLoader) {
+      stats.loaderFiles++;
+    }
+
+    // 1. Detect immediate refetch pattern
+    const immediateRefetchIssues = detectImmediateRefetch(content, relPath, hasLoader);
+    issues.push(...immediateRefetchIssues);
+    stats.immediateRefetches += immediateRefetchIssues.length;
+
+    // 2. Detect date rendering without timezone
+    const timezoneIssues = detectMissingTimezone(content, relPath, hasLoader);
+    issues.push(...timezoneIssues);
+    stats.missingTimezones += timezoneIssues.length;
+
+    // 3. Detect Number() coercions (symptom of type issues)
+    const coercionIssues = detectAggregateCoercions(content, relPath);
+    issues.push(...coercionIssues);
+    stats.aggregateCoercions += coercionIssues.length;
+
+    // 4. Detect relative time rendering in loader functions
+    if (hasLoader) {
+      const relativeTimeIssues = detectRelativeTimeInSSR(content, relPath);
+      issues.push(...relativeTimeIssues);
+      stats.relativeTimeInSSR += relativeTimeIssues.length;
+    }
+
+    // 5. Detect browser-only API usage without proper hydration guards
+    const browserAPIIssues = detectBrowserOnlyAPIs(content, relPath);
+    issues.push(...browserAPIIssues);
+    stats.browserOnlyAPIs += browserAPIIssues.length;
+  }
+
+  return { issues, stats };
+}
+
+/**
+ * Detect useEffect that immediately fetches after SSR.
+ */
+function detectImmediateRefetch(content: string, file: string, hasLoader: boolean): SSRIssue[] {
+  const issues: SSRIssue[] = [];
+
+  // Pattern: useEffect(() => { fetchSomething() }, [dependency])
+  // This is only a problem if the page has a loader
+  if (!hasLoader) return issues;
+
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Look for useEffect with immediate function call
+    if (/useEffect\s*\(\s*\(\s*\)\s*=>/.test(line)) {
+      // Check if next few lines contain a fetch/api call
+      const nextLines = lines.slice(i, Math.min(i + 10, lines.length)).join('\n');
+      if (/(?:fetch|api\.from|fetchProfile|fetchPost|fetchData)\s*\(/.test(nextLines)) {
+        // Check if there's a comment explaining why (e.g., "for real-time updates")
+        const hasExplanation = /\/\/.*(?:real-time|updates|subscribe|listen)/.test(nextLines);
+
+        issues.push({
+          type: 'immediate-refetch',
+          severity: hasExplanation ? 'info' : 'warning',
+          message: hasExplanation
+            ? 'useEffect fetches immediately (explained in comment)'
+            : 'useEffect fetches immediately after SSR, defeating caching benefit',
+          file,
+          line: i + 1,
+          snippet: line.trim(),
+          fix: hasExplanation
+            ? undefined
+            : 'Check if loader data is fresh before refetching, or document why immediate fetch is needed',
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Detect date rendering without timeZone: 'UTC'.
+ */
+function detectMissingTimezone(content: string, file: string, hasLoader: boolean): SSRIssue[] {
+  const issues: SSRIssue[] = [];
+
+  // Only flag this for files with loaders (SSR pages)
+  if (!hasLoader) return issues;
+
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Look for toLocaleDateString or toLocaleTimeString
+    if (/\.toLocale(?:Date|Time)String\s*\(/.test(line)) {
+      // Check if this call includes timeZone option
+      const hasTimezone = /timeZone\s*:\s*['"]UTC['"]/.test(line);
+
+      if (!hasTimezone) {
+        issues.push({
+          type: 'missing-timezone',
+          severity: 'warning',
+          message: 'Date formatting without timeZone: \'UTC\' may cause SSR/client mismatch',
+          file,
+          line: i + 1,
+          snippet: line.trim(),
+          fix: 'Add timeZone: \'UTC\' to the options object',
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Detect Number() coercions on loader data (symptom of aggregate type issue).
+ */
+function detectAggregateCoercions(content: string, file: string): SSRIssue[] {
+  const issues: SSRIssue[] = [];
+
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Look for Number(loaderData.something) or Number(data.count)
+    const match = /Number\s*\(\s*(?:loaderData|data)\.(\w+)\s*\)/.exec(line);
+    if (match) {
+      const field = match[1];
+      // Common aggregate fields
+      if (/(?:count|total|sum|avg|min|max)/.test(field.toLowerCase())) {
+        issues.push({
+          type: 'aggregate-coercion',
+          severity: 'info',
+          message: `Number() coercion on '${field}' suggests SQL aggregate returns string`,
+          file,
+          line: i + 1,
+          snippet: line.trim(),
+          fix: 'Consider handling aggregate type coercion at the API/handler level',
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Detect relative time rendering in loader functions.
+ */
+function detectRelativeTimeInSSR(content: string, file: string): SSRIssue[] {
+  const issues: SSRIssue[] = [];
+
+  // Extract loader function body
+  const loaderMatch = /export\s+(?:async\s+)?function\s+loader\s*\([^)]*\)\s*[^{]*\{([\s\S]+?)\n\}/.exec(content);
+  if (!loaderMatch) return issues;
+
+  const loaderBody = loaderMatch[1];
+  const lines = loaderBody.split('\n');
+
+  // Look for patterns like "ago", "just now", "minutes", etc. in return statements
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (/(?:ago|just now|moment ago|time(?:Ago|Since))/.test(line)) {
+      // Find line number in full file
+      const fullLines = content.split('\n');
+      const lineIndex = fullLines.findIndex((l, idx) =>
+        idx > content.indexOf('function loader') &&
+        l.includes(line.trim())
+      );
+
+      issues.push({
+        type: 'relative-time-ssr',
+        severity: 'error',
+        message: 'Relative time rendering detected in loader (will be stale in CDN cache)',
+        file,
+        line: lineIndex >= 0 ? lineIndex + 1 : undefined,
+        snippet: line.trim(),
+        fix: 'Return absolute timestamp from loader, format as relative time on client only',
+      });
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Detect browser-only API usage without proper hydration guards.
+ *
+ * Patterns that cause hydration mismatches:
+ * - typeof document/window checks that return different results on SSR vs client
+ * - ReactDOM.createPortal without useEffect guard
+ * - Direct window/document access without guards
+ */
+function detectBrowserOnlyAPIs(content: string, file: string): SSRIssue[] {
+  const issues: SSRIssue[] = [];
+  const lines = content.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Pattern 1: typeof document/window checks that return early
+    // Example: if (typeof document === 'undefined') return null;
+    if (/(?:typeof\s+(?:document|window)\s*[!=]=\s*['"]undefined['"]|typeof\s+(?:document|window)\s*===\s*['"]undefined['"])/.test(line)) {
+      // Check if this is inside a component (has 'return' in surrounding context)
+      const prevLines = lines.slice(Math.max(0, i - 10), i).join('\n');
+      const nextLines = lines.slice(i, Math.min(i + 10, lines.length)).join('\n');
+      const context = prevLines + '\n' + line + '\n' + nextLines;
+
+      // Check if this is a component render function (has JSX return or ReactDOM)
+      const isInRenderPath = /(?:return\s+(?:<|ReactDOM|null)|const\s+\w+\s*=\s*\(\s*\)\s*=>)/.test(context);
+
+      if (isInRenderPath) {
+        // Check if there's a useEffect or useState to defer rendering
+        const hasHydrationGuard = /(?:useEffect|useState|useMounted)\s*\(/.test(prevLines);
+
+        if (!hasHydrationGuard) {
+          issues.push({
+            type: 'browser-only-api',
+            severity: 'error',
+            message: 'Browser API check without hydration guard causes SSR mismatch',
+            file,
+            line: i + 1,
+            snippet: line.trim(),
+            fix: 'Use useState + useEffect to defer rendering until after hydration. See: https://react.dev/reference/react-dom/client/hydrateRoot#handling-different-client-and-server-content',
+          });
+        }
+      }
+    }
+
+    // Pattern 2: ReactDOM.createPortal without useEffect guard
+    if (/ReactDOM\.createPortal\s*\(/.test(line)) {
+      const prevLines = lines.slice(Math.max(0, i - 15), i).join('\n');
+      const hasHydrationGuard = /(?:useEffect|useState.*setMounted|useMounted)\s*\(/.test(prevLines);
+      const hasEarlyReturn = /if\s*\([^)]*\)\s*return\s+null/.test(prevLines);
+
+      if (!hasHydrationGuard || !hasEarlyReturn) {
+        issues.push({
+          type: 'browser-only-api',
+          severity: 'error',
+          message: 'ReactDOM.createPortal without hydration guard causes SSR mismatch',
+          file,
+          line: i + 1,
+          snippet: line.trim(),
+          fix: 'Use useState + useEffect to defer portal rendering until after hydration',
+        });
+      }
+    }
+
+    // Pattern 3: Direct window/document access (without typeof guard)
+    // But exclude common safe patterns like typeof window !== 'undefined'
+    const directAccessMatch = /(?:^|[^a-zA-Z_])(?:window|document)\./.exec(line);
+    if (directAccessMatch && !/typeof\s+(?:window|document)/.test(line)) {
+      // Check if this line is inside a useEffect or browser-only conditional
+      const prevLines = lines.slice(Math.max(0, i - 5), i).join('\n');
+      const isGuarded = /(?:useEffect|if\s*\(\s*(?:typeof\s+)?(?:window|document)|Platform\.OS\s*===\s*['"]web['"])/.test(prevLines);
+
+      if (!isGuarded && !line.trim().startsWith('//')) {
+        issues.push({
+          type: 'browser-only-api',
+          severity: 'warning',
+          message: 'Direct browser API access may fail during SSR',
+          file,
+          line: i + 1,
+          snippet: line.trim(),
+          fix: 'Guard with typeof check or move into useEffect',
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Generate a report from SSR analysis.
+ */
+export function generateSSRReport(analysis: SSRAnalysis): string {
+  const lines: string[] = [];
+
+  lines.push('  SSR Code Analysis');
+  lines.push('  ' + '='.repeat(58));
+  lines.push('');
+  lines.push(`  Files scanned:     ${analysis.stats.totalFiles}`);
+  lines.push(`  SSR pages (loader): ${analysis.stats.loaderFiles}`);
+  lines.push('');
+
+  if (analysis.issues.length === 0) {
+    lines.push('  ✓  No SSR anti-patterns detected');
+    return lines.join('\n');
+  }
+
+  // Group issues by type
+  const grouped = {
+    'browser-only-api': analysis.issues.filter(i => i.type === 'browser-only-api'),
+    'immediate-refetch': analysis.issues.filter(i => i.type === 'immediate-refetch'),
+    'missing-timezone': analysis.issues.filter(i => i.type === 'missing-timezone'),
+    'aggregate-coercion': analysis.issues.filter(i => i.type === 'aggregate-coercion'),
+    'relative-time-ssr': analysis.issues.filter(i => i.type === 'relative-time-ssr'),
+  };
+
+  if (grouped['browser-only-api'].length > 0) {
+    lines.push(`  ✗  Browser-Only API Mismatches (${grouped['browser-only-api'].length}):`);
+    lines.push('     Components access browser APIs without hydration guards (causes React error #418)');
+    lines.push('');
+    for (const issue of grouped['browser-only-api']) {
+      lines.push(`     ${issue.file}:${issue.line}`);
+      if (issue.snippet) {
+        lines.push(`       ${issue.snippet.substring(0, 70)}...`);
+      }
+      if (issue.fix) {
+        lines.push(`       Fix: ${issue.fix.substring(0, 70)}...`);
+      }
+    }
+    lines.push('');
+  }
+
+  if (grouped['immediate-refetch'].length > 0) {
+    lines.push(`  ⚠  Immediate Re-fetches (${grouped['immediate-refetch'].length}):`);
+    lines.push('     Pages that fetch immediately after SSR, defeating cache benefits');
+    lines.push('');
+    for (const issue of grouped['immediate-refetch'].slice(0, 5)) {
+      lines.push(`     ${issue.file}:${issue.line}`);
+      if (issue.snippet) {
+        lines.push(`       ${issue.snippet.substring(0, 60)}...`);
+      }
+    }
+    if (grouped['immediate-refetch'].length > 5) {
+      lines.push(`     ... and ${grouped['immediate-refetch'].length - 5} more`);
+    }
+    lines.push('');
+  }
+
+  if (grouped['missing-timezone'].length > 0) {
+    lines.push(`  ⚠  Missing Timezone (${grouped['missing-timezone'].length}):`);
+    lines.push('     Date formatting without timeZone: \'UTC\' may cause hydration mismatches');
+    lines.push('');
+    for (const issue of grouped['missing-timezone'].slice(0, 5)) {
+      lines.push(`     ${issue.file}:${issue.line}`);
+      if (issue.snippet) {
+        lines.push(`       ${issue.snippet.substring(0, 60)}...`);
+      }
+    }
+    if (grouped['missing-timezone'].length > 5) {
+      lines.push(`     ... and ${grouped['missing-timezone'].length - 5} more`);
+    }
+    lines.push('');
+  }
+
+  if (grouped['aggregate-coercion'].length > 0) {
+    lines.push(`  ℹ  Aggregate Coercions (${grouped['aggregate-coercion'].length}):`);
+    lines.push('     Number() coercions suggest SQL aggregates return strings');
+    lines.push('');
+    for (const issue of grouped['aggregate-coercion'].slice(0, 3)) {
+      lines.push(`     ${issue.file}:${issue.line}`);
+      if (issue.snippet) {
+        lines.push(`       ${issue.snippet.substring(0, 60)}...`);
+      }
+    }
+    if (grouped['aggregate-coercion'].length > 3) {
+      lines.push(`     ... and ${grouped['aggregate-coercion'].length - 3} more`);
+    }
+    lines.push('');
+  }
+
+  if (grouped['relative-time-ssr'].length > 0) {
+    lines.push(`  ✗  Relative Time in SSR (${grouped['relative-time-ssr'].length}):`);
+    lines.push('     Loader functions render relative time (will be stale in cache)');
+    lines.push('');
+    for (const issue of grouped['relative-time-ssr']) {
+      lines.push(`     ${issue.file}:${issue.line || '?'}`);
+      if (issue.snippet) {
+        lines.push(`       ${issue.snippet.substring(0, 60)}...`);
+      }
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}

package/src/cli/utils/export.ts

@@ -0,0 +1,8 @@
+import { execSync } from 'child_process';
+
+export async function exportApp(): Promise<void> {
+  execSync('npx expo export --output-dir dist', {
+    stdio: 'inherit',
+    env: { ...process.env },
+  });
+}

package/src/cli/utils/table.ts

@@ -0,0 +1,39 @@
+/**
+ * Minimal ASCII table formatter for REPL output.
+ * Zero dependencies. Renders arrays of flat objects as bordered tables,
+ * falls back to pretty-printed JSON for everything else.
+ */
+
+export function formatResult(value: unknown): string {
+  if (value === undefined || value === null) return 'null';
+  if (Array.isArray(value) && value.length === 0) return '[]';
+  if (Array.isArray(value) && isFlat(value[0])) {
+    return formatTable(value as Record<string, unknown>[]);
+  }
+  return JSON.stringify(value, null, 2);
+}
+
+function isFlat(obj: unknown): obj is Record<string, unknown> {
+  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) return false;
+  return Object.values(obj).every(v => v === null || typeof v !== 'object');
+}
+
+function formatTable(rows: Record<string, unknown>[]): string {
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map(k =>
+    Math.max(k.length, ...rows.map(r => String(r[k] ?? 'null').length))
+  );
+
+  const top = '┌' + widths.map(w => '─'.repeat(w + 2)).join('┬') + '┐';
+  const sep = '├' + widths.map(w => '─'.repeat(w + 2)).join('┼') + '┤';
+  const bot = '└' + widths.map(w => '─'.repeat(w + 2)).join('┴') + '┘';
+  const row = (cells: string[]) =>
+    '│' + cells.map((c, i) => ' ' + c.padEnd(widths[i]) + ' ').join('│') + '│';
+
+  const lines = [top, row(keys), sep];
+  for (const r of rows) {
+    lines.push(row(keys.map(k => String(r[k] ?? 'null'))));
+  }
+  lines.push(bot);
+  return lines.join('\n');
+}