@nometria-ai/nom 0.2.9 → 0.3.1

package/src/commands/deploy.js

@@ -12,9 +12,20 @@ import { apiRequest, uploadFile } from '../lib/api.js';
 import { createTarball } from '../lib/tar.js';
 import { createSpinner } from '../lib/spinner.js';
 import { confirm } from '../lib/prompt.js';
+import { trackCommand } from '../lib/telemetry.js';
 import { login } from './login.js';
 import { init } from './init.js';
 
+const INSTANCE_COSTS = {
+  '2gb': { monthly: '$39', type: 't4g.small' },
+  '4gb': { monthly: '$49', type: 't4g.medium' },
+  '8gb': { monthly: '$79', type: 't4g.large' },
+  '16gb': { monthly: '$129', type: 't4g.xlarge' },
+};
+
+const HELP_URL = 'https://docs.nometria.com';
+const DASHBOARD_URL = 'https://nometria.com';
+
 export async function deploy(flags) {
   // Auto-login if not authenticated
   let apiKey = getApiKey();
@@ -39,6 +50,13 @@ export async function deploy(flags) {
   const envVars = resolveEnv(config.env);
   const appName = config.name || config.app_id;
   const isResync = !!config.app_id;
+  const isDryRun = flags['dry-run'] || flags.dryRun;
+
+  const telemetry = trackCommand('deploy', { framework: config.framework, platform: config.platform, isResync });
+
+  if (isDryRun) {
+    return dryRun(config, apiKey, appName);
+  }
 
   // Auto-detect services if not in config (so nometria.json includes it in tarball)
   if (!config.services) {
@@ -51,15 +69,26 @@ export async function deploy(flags) {
     }
   }
 
+  const instanceSize = config.instanceType || '4gb';
+  const cost = INSTANCE_COSTS[instanceSize];
+
   if (isResync) {
     console.log(`\n  Resyncing ${appName} on ${config.platform} (${config.region})\n`);
   } else {
-    console.log(`\n  Deploying ${appName} to ${config.platform} (${config.region})\n`);
+    console.log(`\n  Deploying ${appName} to ${config.platform} (${config.region})`);
+    if (cost) {
+      console.log(`  Instance: ${instanceSize} (${cost.type}) — ${cost.monthly}/mo`);
+    }
+    console.log();
   }
 
+  const totalSteps = config.build?.command ? 5 : 4;
+  let step = 0;
+  const stepLabel = (label) => `[${++step}/${totalSteps}] ${label}`;
+
   // Step 1: Build
   if (config.build?.command) {
-    const spinner = createSpinner('Building').start();
+    const spinner = createSpinner(stepLabel('Building')).start();
     try {
       execSync(config.build.command, {
         cwd: process.cwd(),
@@ -75,7 +104,7 @@ export async function deploy(flags) {
   }
 
   // Step 2: Create archive
-  const archiveSpinner = createSpinner('Creating archive').start();
+  const archiveSpinner = createSpinner(stepLabel('Creating archive')).start();
   let tarball;
   try {
     tarball = createTarball(process.cwd(), config.ignore);
@@ -85,8 +114,8 @@ export async function deploy(flags) {
     throw err;
   }
 
-  // Step 3: Upload to Supabase storage via Deno function
-  const uploadSpinner = createSpinner('Uploading').start();
+  // Step 3: Upload
+  const uploadSpinner = createSpinner(stepLabel('Uploading')).start();
   let uploadResult;
   try {
     uploadResult = await uploadFile(apiKey, tarball.buffer, `${appName}.tar.gz`);
@@ -96,8 +125,8 @@ export async function deploy(flags) {
     throw err;
   }
 
-  // Step 4: Trigger deploy via Deno function
-  const deploySpinner = createSpinner(isResync ? 'Resyncing' : 'Deploying').start();
+  // Step 4: Trigger deploy
+  const deploySpinner = createSpinner(stepLabel(isResync ? 'Resyncing' : 'Deploying')).start();
   let deployResult;
   try {
     deployResult = await apiRequest('/cli/deploy', {
@@ -118,13 +147,14 @@ export async function deploy(flags) {
     throw err;
   }
 
-  // Step 5: Poll for status via Deno function
+  // Step 5: Poll for status
   const deployId = deployResult.deploy_id || appName;
-  const dashboardUrl = `https://nometria.com/AppDetails?app_id=${deployId}`;
+  const dashboardUrl = `${DASHBOARD_URL}/AppDetails?app_id=${deployId}`;
   console.log(`\n  Dashboard:  ${dashboardUrl}`);
   console.log(`  You can close this terminal — check the dashboard for progress.\n`);
 
   let finalStatus;
+  let consecutiveErrors = 0;
   const pollStart = Date.now();
   const POLL_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
   while (true) {
@@ -134,37 +164,56 @@ export async function deploy(flags) {
         apiKey,
         body: { app_id: deployId },
       });
-      const deployStatus = statusResult.data?.deploymentStatus;
-      const instanceState = statusResult.data?.instanceState;
+      consecutiveErrors = 0; // reset on success
+
+      // statusResult may be unwrapped (top-level fields) or nested under .data
+      const deployStatus = statusResult.deploymentStatus || statusResult.data?.deploymentStatus;
+      const instanceState = statusResult.instanceState || statusResult.data?.instanceState;
       const topStatus = statusResult.status;
-      // Display status: prefer deploymentStatus (accurate), fall back to instanceState
       const st = deployStatus || instanceState || topStatus || 'unknown';
       deploySpinner.update(`${isResync ? 'Resyncing' : 'Deploying'} — ${st}`);
 
-      // Only trust deploymentStatus for completion — instanceState='running' just means
-      // EC2 booted, and topStatus='deployed' just means the record exists in DB.
-      // The sync script calls report_status("running") only after everything finishes.
       const isDone = deployStatus === 'completed' || deployStatus === 'running';
       if (isDone) {
         finalStatus = statusResult;
         deploySpinner.succeed(isResync ? 'Resynced successfully' : 'Deployed successfully');
+        telemetry.success({ instanceType: instanceSize });
         break;
       }
       if (deployStatus === 'failed' || st === 'failed') {
-        deploySpinner.fail(`${isResync ? 'Resync' : 'Deploy'} failed: ${statusResult.data?.errorMessage || 'unknown error'}`);
+        deploySpinner.fail(`${isResync ? 'Resync' : 'Deploy'} failed: ${statusResult.errorMessage || statusResult.data?.errorMessage || 'unknown error'}`);
+        console.error(`\n  View logs: nom logs`);
+        console.error(`  Dashboard: ${dashboardUrl}`);
+        console.error(`  Help: ${HELP_URL}/deploy/overview\n`);
         process.exit(1);
       }
 
-      // Timeout: if instance is running but status stuck at deploying, show URL and exit
+      // Timeout: if instance is running but status stuck at deploying, show URL and exit gracefully
       if (Date.now() - pollStart > POLL_TIMEOUT_MS && instanceState === 'running') {
         finalStatus = statusResult;
         deploySpinner.succeed('Deploy in progress — check dashboard for final status');
         break;
       }
-    } catch {
-      // Keep polling on transient errors
+    } catch (err) {
+      consecutiveErrors++;
+      if (consecutiveErrors >= 5) {
+        deploySpinner.fail(`Lost connection while polling (${consecutiveErrors} consecutive errors)`);
+        console.error(`\n  Last error: ${err.message}`);
+        console.error(`  Check status manually: nom status`);
+        console.error(`  Dashboard: ${dashboardUrl}`);
+        console.error(`  Help: ${HELP_URL}/deploy/overview\n`);
+        process.exit(1);
+      }
+      deploySpinner.update(`${isResync ? 'Resyncing' : 'Deploying'} — retrying (${consecutiveErrors}/5)...`);
     }
   }
+  if (!finalStatus) {
+    deploySpinner.fail('Timed out waiting for deployment');
+    console.error(`\n  The deploy may still be in progress. Check status:`);
+    console.error(`  nom status`);
+    console.error(`  Dashboard: ${dashboardUrl}\n`);
+    process.exit(1);
+  }
 
   // Step 6: Write app_id and migration_id back to nometria.json
   const updates = {};
@@ -175,12 +224,27 @@ export async function deploy(flags) {
   }
 
   // Step 7: Print result
-  const url = finalStatus.data?.deployUrl || finalStatus.url || `https://${deployId}.ownmy.app`;
+  const url = finalStatus.deployUrl || finalStatus.data?.deployUrl || finalStatus.url || `https://${deployId}.ownmy.app`;
+  const instanceInfo = finalStatus.instanceType || finalStatus.data?.instanceType || instanceSize;
   console.log(`
-  Live at:    ${url}
-  Dashboard:  https://nometria.com/AppDetails?app_id=${deployId}
+  ${isResync ? 'Resynced' : 'Deployed'} successfully!
+
+  URL:        ${url}
+  Instance:   ${instanceInfo}${cost ? ` (${cost.monthly}/mo)` : ''}
+  Dashboard:  ${dashboardUrl}
 `);
 
+  // First deploy — show next steps
+  if (!isResync) {
+    console.log(`  Next steps:`);
+    console.log(`    nom github connect     Connect GitHub for auto-deploy`);
+    console.log(`    nom domain add <url>   Add a custom domain`);
+    console.log(`    nom env set KEY=VAL    Set environment variables`);
+    console.log(`    nom logs -f            Watch live logs`);
+    console.log(`    nom scan               Run security scan`);
+    console.log();
+  }
+
   // Step 8: Auto-detect git repo and offer GitHub connection
   if (!flags.yes) {
     const hasGit = existsSync(join(process.cwd(), '.git'));
@@ -204,3 +268,71 @@ export async function deploy(flags) {
 function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
+
+async function dryRun(config, apiKey, appName) {
+  const instanceSize = config.instanceType || '4gb';
+  const cost = INSTANCE_COSTS[instanceSize];
+
+  console.log(`\n  Dry run for: ${appName}`);
+  console.log(`  ─────────────────────────────────\n`);
+
+  // 1. Config check
+  console.log(`  Config:     nometria.json`);
+  console.log(`  Framework:  ${config.framework || 'unknown'}`);
+  console.log(`  Platform:   ${config.platform || 'aws'} (${config.region || 'us-east-1'})`);
+  console.log(`  Instance:   ${instanceSize}${cost ? ` (${cost.type}) — ${cost.monthly}/mo` : ''}`);
+  console.log(`  App ID:     ${config.app_id || '(new — will be created)'}`);
+  console.log();
+
+  // 2. Auth check
+  console.log(`  Checking auth...`);
+  try {
+    const authResult = await apiRequest('/cli/auth', { body: { api_key: apiKey } });
+    console.log(`  Auth:       OK (${authResult.email || 'authenticated'})`);
+  } catch (err) {
+    console.log(`  Auth:       FAILED — ${err.message}`);
+    console.log(`              Get a key: https://nometria.com/settings/api-keys\n`);
+    process.exit(1);
+  }
+
+  // 3. Build check
+  if (config.build?.command) {
+    console.log(`  Testing build: ${config.build.command}`);
+    try {
+      execSync(config.build.command, {
+        cwd: process.cwd(),
+        stdio: 'pipe',
+        env: { ...process.env, NODE_ENV: 'production' },
+      });
+      console.log(`  Build:      PASSED`);
+    } catch (err) {
+      console.log(`  Build:      FAILED`);
+      console.error(`\n${err.stderr?.toString().slice(0, 500) || err.message}\n`);
+      process.exit(1);
+    }
+  } else {
+    console.log(`  Build:      (no build command)`);
+  }
+
+  // 4. Archive size estimate
+  try {
+    const tarball = createTarball(process.cwd(), config.ignore);
+    console.log(`  Archive:    ${tarball.sizeFormatted}`);
+  } catch {
+    console.log(`  Archive:    (could not estimate)`);
+  }
+
+  // 5. Status check
+  if (config.app_id) {
+    try {
+      const status = await apiRequest('/checkAwsStatus', { apiKey, body: { app_id: config.app_id } });
+      const state = status.instanceState || status.data?.instanceState || status.status || 'unknown';
+      console.log(`  Instance:   ${state}`);
+    } catch {
+      console.log(`  Instance:   (could not check)`);
+    }
+  }
+
+  console.log(`\n  Dry run complete. Ready to deploy.`);
+  console.log(`  Run: nom deploy\n`);
+}

package/src/commands/env.js

@@ -5,11 +5,20 @@
  *   set KEY=VALUE [KEY=VALUE ...]   Set environment variables
  *   list                            List variable names
  *   delete KEY [KEY ...]            Delete variables
+ *
+ * Scope flags:
+ *   --preview       Target preview/staging environment
+ *   --production    Target production environment (default)
  */
 import { readConfig } from '../lib/config.js';
 import { requireApiKey } from '../lib/auth.js';
 import { apiRequest } from '../lib/api.js';
 
+function getScope(flags) {
+  if (flags.preview) return 'preview';
+  return 'production'; // default
+}
+
 export async function env(flags, positionals) {
   const sub = positionals[0];
 
@@ -20,25 +29,47 @@ export async function env(flags, positionals) {
       return envList(flags);
     case 'delete':
       return envDelete(flags, positionals.slice(1));
+    case 'compare':
+      return envCompare(flags);
+    case 'validate':
+      return envValidate(flags);
     default:
       console.log(`
-  Usage: nom env <command>
+  Usage: nom env <command> [options]
 
   Commands:
     set KEY=VALUE [...]   Set environment variables
     list                  List variable names
     delete KEY [...]      Delete variables
+    compare               Compare preview vs production env vars
+    validate              Check if required env vars are set
+
+  Options:
+    --preview             Target preview/staging environment
+    --production          Target production environment (default)
 `);
   }
 }
 
+const SECRET_PATTERNS = [
+  /^sk[-_]/i, /^pk[-_]/i, /secret/i, /password/i, /token/i,
+  /api[-_]?key/i, /private[-_]?key/i, /^ghp_/, /^gho_/, /^nometria_sk_/,
+];
+
+function looksLikeSecret(key, value) {
+  if (SECRET_PATTERNS.some(p => p.test(key))) return true;
+  if (value && value.length > 20 && /^[A-Za-z0-9+/=_-]+$/.test(value)) return true;
+  return false;
+}
+
 async function envSet(flags, pairs) {
   const apiKey = requireApiKey();
   const config = readConfig();
   const appId = config.app_id || config.name;
+  const scope = getScope(flags);
 
   if (!pairs.length) {
-    console.error('\n  Usage: nom env set KEY=VALUE [KEY=VALUE ...]\n');
+    console.error('\n  Usage: nom env set KEY=VALUE [KEY=VALUE ...] [--preview|--production]\n');
     process.exit(1);
   }
 
@@ -51,12 +82,17 @@ async function envSet(flags, pairs) {
     }
     const key = pair.slice(0, eqIndex);
     const value = pair.slice(eqIndex + 1);
+
+    // Warn about secrets
+    if (looksLikeSecret(key, value)) {
+      console.log(`  Warning: "${key}" looks like a secret. Make sure it's not in nometria.json or git.`);
+    }
     vars[key] = value;
   }
 
   const result = await apiRequest('/cli/env', {
     apiKey,
-    body: { api_key: apiKey, app_id: appId, action: 'set', vars },
+    body: { api_key: apiKey, app_id: appId, action: 'set', vars, scope },
   });
 
   if (flags.json) {
@@ -65,17 +101,18 @@ async function envSet(flags, pairs) {
   }
 
   const keys = Object.keys(vars);
-  console.log(`\n  Set ${keys.length} variable${keys.length === 1 ? '' : 's'}: ${keys.join(', ')}\n`);
+  console.log(`\n  Set ${keys.length} variable${keys.length === 1 ? '' : 's'} (${scope}): ${keys.join(', ')}\n`);
 }
 
 async function envList(flags) {
   const apiKey = requireApiKey();
   const config = readConfig();
   const appId = config.app_id || config.name;
+  const scope = getScope(flags);
 
   const result = await apiRequest('/cli/env', {
     apiKey,
-    body: { api_key: apiKey, app_id: appId, action: 'list' },
+    body: { api_key: apiKey, app_id: appId, action: 'list', scope },
   });
 
   if (flags.json) {
@@ -85,11 +122,11 @@ async function envList(flags) {
 
   const vars = result.keys || result.vars || [];
   if (!vars.length) {
-    console.log('\n  No environment variables set.\n');
+    console.log(`\n  No environment variables set (${scope}).\n`);
     return;
   }
 
-  console.log('\n  Environment variables:\n');
+  console.log(`\n  Environment variables (${scope}):\n`);
   for (const name of vars) {
     console.log(`  ${name}`);
   }
@@ -100,15 +137,16 @@ async function envDelete(flags, keys) {
   const apiKey = requireApiKey();
   const config = readConfig();
   const appId = config.app_id || config.name;
+  const scope = getScope(flags);
 
   if (!keys.length) {
-    console.error('\n  Usage: nom env delete KEY [KEY ...]\n');
+    console.error('\n  Usage: nom env delete KEY [KEY ...] [--preview|--production]\n');
     process.exit(1);
   }
 
   const result = await apiRequest('/cli/env', {
     apiKey,
-    body: { api_key: apiKey, app_id: appId, action: 'delete', vars: keys },
+    body: { api_key: apiKey, app_id: appId, action: 'delete', vars: keys, scope },
   });
 
   if (flags.json) {
@@ -116,5 +154,116 @@ async function envDelete(flags, keys) {
     return;
   }
 
-  console.log(`\n  Deleted ${keys.length} variable${keys.length === 1 ? '' : 's'}: ${keys.join(', ')}\n`);
+  console.log(`\n  Deleted ${keys.length} variable${keys.length === 1 ? '' : 's'} (${scope}): ${keys.join(', ')}\n`);
+}
+
+async function envCompare(flags) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+
+  const [prodResult, prevResult] = await Promise.all([
+    apiRequest('/cli/env', { apiKey, body: { api_key: apiKey, app_id: appId, action: 'list', scope: 'production' } }),
+    apiRequest('/cli/env', { apiKey, body: { api_key: apiKey, app_id: appId, action: 'list', scope: 'preview' } }),
+  ]);
+
+  if (flags.json) {
+    console.log(JSON.stringify({ production: prodResult, preview: prevResult }, null, 2));
+    return;
+  }
+
+  const prodVars = new Set(prodResult.keys || prodResult.vars || []);
+  const prevVars = new Set(prevResult.keys || prevResult.vars || []);
+  const allKeys = new Set([...prodVars, ...prevVars]);
+
+  if (!allKeys.size) {
+    console.log('\n  No environment variables set in either environment.\n');
+    return;
+  }
+
+  console.log('\n  Environment variable comparison:\n');
+  console.log('  Key                        Production  Preview');
+  console.log('  ─────────────────────────  ──────────  ───────');
+  for (const key of [...allKeys].sort()) {
+    const inProd = prodVars.has(key) ? 'set' : '—';
+    const inPrev = prevVars.has(key) ? 'set' : '—';
+    const marker = inProd !== inPrev ? ' *' : '';
+    console.log(`  ${key.padEnd(27)} ${inProd.padEnd(12)}${inPrev}${marker}`);
+  }
+  console.log('\n  * = different between environments\n');
+}
+
+async function envValidate(flags) {
+  const apiKey = requireApiKey();
+  const config = readConfig();
+  const appId = config.app_id || config.name;
+  const scope = getScope(flags);
+
+  // Collect expected vars from local .env and nometria.json
+  const { existsSync, readFileSync } = await import('node:fs');
+  const { join } = await import('node:path');
+
+  const expectedKeys = new Set();
+
+  // From local .env
+  const envPath = join(process.cwd(), '.env');
+  if (existsSync(envPath)) {
+    const lines = readFileSync(envPath, 'utf8').split('\n');
+    for (const line of lines) {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+      if (match) expectedKeys.add(match[1]);
+    }
+  }
+
+  // From nometria.json env section
+  if (config.env && typeof config.env === 'object') {
+    for (const key of Object.keys(config.env)) {
+      expectedKeys.add(key);
+    }
+  }
+
+  if (!expectedKeys.size) {
+    console.log('\n  No expected environment variables found in .env or nometria.json.\n');
+    return;
+  }
+
+  // Get deployed vars
+  const result = await apiRequest('/cli/env', {
+    apiKey,
+    body: { api_key: apiKey, app_id: appId, action: 'list', scope },
+  });
+  const deployedKeys = new Set(result.keys || result.vars || []);
+
+  // Compare
+  const missing = [...expectedKeys].filter(k => !deployedKeys.has(k));
+  const extra = [...deployedKeys].filter(k => !expectedKeys.has(k));
+
+  console.log(`\n  Environment validation (${scope}):\n`);
+  console.log(`  Local vars:    ${expectedKeys.size}`);
+  console.log(`  Deployed vars: ${deployedKeys.size}`);
+
+  if (missing.length) {
+    console.log(`\n  Missing on ${scope} (${missing.length}):`);
+    for (const key of missing) {
+      console.log(`    - ${key}`);
+    }
+  }
+
+  if (extra.length) {
+    console.log(`\n  Extra on ${scope} (not in local .env):`);
+    for (const key of extra) {
+      console.log(`    + ${key}`);
+    }
+  }
+
+  if (!missing.length && !extra.length) {
+    console.log('\n  All environment variables match.');
+  }
+
+  console.log();
+
+  if (missing.length) {
+    console.log(`  Fix: nom env set ${missing.map(k => `${k}=<value>`).join(' ')}\n`);
+    process.exit(1);
+  }
 }

package/src/commands/init.js

@@ -2,8 +2,9 @@
  * nom init — Create nometria.json config interactively
  */
 import { writeFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
 import { join, basename } from 'node:path';
-import { detectFramework, detectPackageManager, detectServices } from '../lib/detect.js';
+import { detectFramework, detectPackageManager, detectServices, detectMonorepo } from '../lib/detect.js';
 import { configExists, CONFIG_FILE, VALID_PLATFORMS } from '../lib/config.js';
 import { ask, choose, confirm } from '../lib/prompt.js';
 
@@ -30,10 +31,42 @@ export async function init(flags) {
 
   console.log('\n  Setting up your project for deployment\n');
 
+  // Detect monorepo
+  const mono = detectMonorepo(dir);
+  if (mono.isMonorepo && mono.packages.length > 0 && !flags.yes) {
+    console.log(`  Monorepo detected (${mono.tool}). Deployable packages:`);
+    for (let i = 0; i < mono.packages.length; i++) {
+      console.log(`    ${i + 1}. ${mono.packages[i]}`);
+    }
+    console.log();
+  }
+
   // Detect framework and services
-  const detected = detectFramework(dir);
+  let detected = detectFramework(dir);
   const pkgManager = detectPackageManager(dir);
   const { services, docker_compose } = detectServices(dir);
+
+  // If detection is uncertain, warn and let user override
+  if (detected.uncertain && !flags.yes) {
+    console.log(`  Could not confidently detect framework (defaulting to "static").`);
+    const frameworks = ['static', 'vite', 'nextjs', 'remix', 'astro', 'sveltekit', 'nuxt', 'node'];
+    const choice = await choose('What framework is this project?', frameworks, 0);
+    if (choice !== 'static') {
+      detected = detectFramework(dir); // re-detect won't help, set manually
+      detected.framework = choice;
+      detected.uncertain = false;
+      if (['vite', 'astro', 'sveltekit'].includes(choice)) {
+        detected.build = { command: 'npm run build', output: choice === 'sveltekit' ? 'build' : 'dist' };
+      } else if (choice === 'nextjs') {
+        detected.build = { command: 'npm run build', output: '.next' };
+      } else if (choice === 'nuxt') {
+        detected.build = { command: 'npm run build', output: '.output' };
+      } else if (choice === 'remix') {
+        detected.build = { command: 'npm run build', output: 'build' };
+      }
+    }
+  }
+
   console.log(`  Detected: ${detected.framework} (${pkgManager})`);
   if (services.length > 0) {
     console.log(`  Services: ${services.map(s => `${s.name} (${s.type})`).join(', ')}`);
@@ -90,6 +123,21 @@ export async function init(flags) {
 
   console.log(`\n  Created ${CONFIG_FILE}`);
 
+  // Validate build if a build command exists
+  if (buildCmd && !flags.yes) {
+    const shouldValidate = await confirm('Test the build command now?', true);
+    if (shouldValidate) {
+      console.log(`\n  Running: ${buildCmd}`);
+      try {
+        execSync(buildCmd, { cwd: dir, stdio: 'inherit', env: { ...process.env, NODE_ENV: 'production' } });
+        console.log(`\n  Build passed.\n`);
+      } catch {
+        console.log(`\n  Build failed. Fix the errors above, then run: nom deploy`);
+        console.log(`  Help: https://docs.nometria.com/deploy/overview\n`);
+      }
+    }
+  }
+
   // Auto-generate AI tool configs
   const { setup } = await import('./setup.js');
   await setup({ yes: true });

package/src/commands/list.js

@@ -0,0 +1,51 @@
+/**
+ * nom list — List all your deployed apps.
+ */
+import { requireApiKey } from '../lib/auth.js';
+import { apiRequest } from '../lib/api.js';
+import { getCached, setCache } from '../lib/cache.js';
+
+export async function list(flags) {
+  const apiKey = requireApiKey();
+
+  // Check cache first (1 minute TTL), skip with --no-cache
+  const noCache = flags['no-cache'] || flags.noCache;
+  if (!noCache) {
+    const cached = getCached('list_apps');
+    if (cached) {
+      const migrations = cached.migrations || cached || [];
+      printApps(migrations, flags);
+      console.log('  (cached — use --no-cache to refresh)\n');
+      return;
+    }
+  }
+
+  const result = await apiRequest('/listUserMigrations', { apiKey, body: {} });
+  const migrations = result.migrations || result || [];
+  setCache('list_apps', result);
+
+  printApps(migrations, flags);
+}
+
+function printApps(migrations, flags) {
+  if (!migrations.length) {
+    console.log('\n  No apps found. Deploy your first app: nom deploy\n');
+    return;
+  }
+
+  console.log(`\n  Your apps (${migrations.length}):\n`);
+
+  if (flags.json) {
+    console.log(JSON.stringify(migrations, null, 2));
+    return;
+  }
+
+  for (const m of migrations) {
+    const status = m.delivery_type === 'hosting' ? (m.payment_status === 'paid' ? 'hosting' : 'unpaid') : m.delivery_type || 'download';
+    const platform = m.platform || '—';
+    const url = m.hosted_url || m.deploy_url || '—';
+    console.log(`  ${m.app_name || m.app_id}`);
+    console.log(`    Platform: ${platform}  Status: ${status}  URL: ${url}`);
+    console.log();
+  }
+}