vibecarbon 0.1.0

package/src/status.js

@@ -0,0 +1,981 @@
+/**
+ * Vibecarbon Status Command
+ * Shows project and deployment status (read-only, non-interactive)
+ *
+ * Usage:
+ *   vibecarbon status                    # Show all status info
+ *   vibecarbon status -env prod          # Show specific environment
+ *   vibecarbon status -json              # Machine-readable output
+ *
+ * Local-dev checks are context-sensitive: skipped when stdout is not a
+ * TTY OR when `-json` is set (CI / scripting paths don't want them),
+ * and skipped when run outside a project directory (registry-only mode).
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import * as p from '@clack/prompts';
+import { renderHelp } from './lib/cli/help.js';
+import { parseFlags } from './lib/cli/parse-flags.js';
+import { c, printBanner } from './lib/colors.js';
+import { runCommand } from './lib/command.js';
+import { cleanStaleProjects, loadGlobalRegistry, loadProjectConfig } from './lib/config.js';
+import { HetznerProvider } from './lib/providers/hetzner.js';
+import { VERSION } from './lib/version.js';
+
+/** @type {import('./lib/cli/parse-flags.js').CommandSpec & { summary?: string, description?: string, examples?: Array<{ command: string, description?: string }> }} */
+const SPEC = {
+  name: 'status',
+  summary: 'Show project & deployment status',
+  description: [
+    'Read-only summary of project + environment health.',
+    '',
+    'MODES',
+    '  Run from outside a project:  Shows summary of all registered projects',
+    '  Run from inside a project:   Shows detailed environment status',
+    '',
+    'ENVIRONMENT VARIABLES',
+    '  HETZNER_API_TOKEN      Enables live server status checks',
+  ].join('\n'),
+  flags: [
+    { name: 'h', boolean: true, description: 'Show this help' },
+    { name: 'v', boolean: true, description: 'Show version' },
+    { name: 'env', value: '<name>', description: 'Show only a specific environment' },
+    { name: 'json', boolean: true, description: 'Machine-readable JSON output' },
+  ],
+  examples: [
+    { command: 'vibecarbon status', description: 'Show full project status' },
+    { command: 'vibecarbon status -env prod', description: 'Show only production' },
+    { command: 'vibecarbon status -json', description: 'JSON output for CI / scripting' },
+  ],
+};
+
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+
+function formatRelativeTime(isoDate) {
+  if (!isoDate) return '';
+  const now = Date.now();
+  const then = new Date(isoDate).getTime();
+  const diffMs = now - then;
+
+  if (diffMs < 0) return 'in the future';
+
+  const seconds = Math.floor(diffMs / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+  const months = Math.floor(days / 30);
+
+  if (months > 0) return `${months} month${months === 1 ? '' : 's'} ago`;
+  if (weeks > 0) return `${weeks} week${weeks === 1 ? '' : 's'} ago`;
+  if (days > 0) return `${days} day${days === 1 ? '' : 's'} ago`;
+  if (hours > 0) return `${hours} hour${hours === 1 ? '' : 's'} ago`;
+  if (minutes > 0) return `${minutes} minute${minutes === 1 ? '' : 's'} ago`;
+  return 'just now';
+}
+
+function getBranchName(envName) {
+  return envName === 'prod' ? 'main' : envName;
+}
+
+// ============================================================================
+// HEALTH CHECK FUNCTIONS
+// ============================================================================
+
+async function checkHttpEndpoint(url, timeout = 2000) {
+  const start = Date.now();
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(url, { method: 'GET', signal: controller.signal });
+    clearTimeout(timeoutId);
+    const latencyMs = Date.now() - start;
+
+    let data = null;
+    try {
+      data = await response.json();
+    } catch {
+      // Not JSON, that's fine
+    }
+
+    return {
+      ok: response.status >= 200 && response.status < 400,
+      status: response.status,
+      latencyMs,
+      data,
+    };
+  } catch (error) {
+    const latencyMs = Date.now() - start;
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    const isTimeout = message.includes('abort');
+    return {
+      ok: false,
+      status: null,
+      latencyMs,
+      error: isTimeout ? `timeout after ${timeout}ms` : message,
+    };
+  }
+}
+
+// Note: execSync calls below use only hardcoded commands (no user input),
+// matching the pattern in deploy.js and destroy.js throughout this codebase.
+
+async function checkDockerContainers(projectName) {
+  const services = [
+    {
+      name: 'PostgreSQL',
+      container: 'db',
+      healthUrl: 'http://localhost:8000/rest/v1/',
+      acceptCodes: [200, 401],
+    },
+    {
+      name: 'Kong Gateway',
+      container: 'kong',
+      healthUrl: 'http://localhost:8000/',
+      acceptCodes: [404],
+    },
+    {
+      name: 'Auth (GoTrue)',
+      container: 'auth',
+      healthUrl: 'http://localhost:8000/auth/v1/health',
+      acceptCodes: [200, 401],
+    },
+    {
+      name: 'REST (PostgREST)',
+      container: 'rest',
+      healthUrl: 'http://localhost:8000/rest/v1/',
+      acceptCodes: [200, 401],
+    },
+    {
+      name: 'Realtime',
+      container: 'realtime',
+      healthUrl: 'http://localhost:8000/realtime/v1/',
+      acceptCodes: [200, 401, 403, 426],
+    },
+    {
+      name: 'Storage',
+      container: 'storage',
+      healthUrl: 'http://localhost:8000/storage/v1/status',
+      acceptCodes: [200, 401],
+    },
+    {
+      name: 'Studio',
+      container: 'studio',
+      healthUrl: 'http://studio.localhost/',
+      acceptCodes: [200, 307],
+    },
+    {
+      name: 'Meta',
+      container: 'meta',
+      healthUrl: 'http://localhost:8000/pg/',
+      acceptCodes: [200, 401],
+    },
+  ];
+
+  // Get list of running containers
+  let runningContainers = new Set();
+  try {
+    const output =
+      runCommand(['docker', 'ps', '--format', '{{.Names}}'], {
+        silent: true,
+        encoding: 'utf-8',
+        timeout: 5000,
+        ignoreError: true,
+      }) || '';
+    const prefix = projectName ? `${projectName}-` : null;
+    runningContainers = new Set(
+      output
+        .split('\n')
+        .map((name) => name.trim())
+        .filter(Boolean)
+        .filter((name) => !prefix || name.startsWith(prefix))
+        .map((name) => (prefix ? name.slice(prefix.length) : name.replace(/^[^-]+-/, ''))),
+    );
+  } catch {
+    return [];
+  }
+
+  if (runningContainers.size === 0) return [];
+
+  // Check port offset from env
+  let portOffset = 0;
+  try {
+    const envFiles = ['.env.local', '.env'];
+    for (const file of envFiles) {
+      if (existsSync(file)) {
+        const content = readFileSync(file, 'utf-8');
+        const match = content.match(/^DEV_PORT_OFFSET=["']?(\d+)["']?/m);
+        if (match) {
+          portOffset = Number.parseInt(match[1], 10);
+        }
+        break;
+      }
+    }
+  } catch {
+    // Use defaults
+  }
+
+  // Adjust ports if offset
+  if (portOffset > 0) {
+    for (const svc of services) {
+      svc.healthUrl = svc.healthUrl.replace(':8000', `:${8000 + portOffset}`);
+    }
+  }
+
+  // Only check services whose containers are running
+  const activeServices = services.filter((svc) => runningContainers.has(svc.container));
+
+  const results = await Promise.allSettled(
+    activeServices.map(async (svc) => {
+      const start = Date.now();
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 2000);
+        const response = await fetch(svc.healthUrl, { method: 'GET', signal: controller.signal });
+        clearTimeout(timeoutId);
+        const latencyMs = Date.now() - start;
+        const isHealthy = svc.acceptCodes
+          ? svc.acceptCodes.includes(response.status)
+          : response.status >= 200 && response.status < 400;
+
+        return {
+          name: svc.name,
+          container: svc.container,
+          health: isHealthy ? 'healthy' : 'unhealthy',
+          latencyMs,
+        };
+      } catch {
+        return {
+          name: svc.name,
+          container: svc.container,
+          health: 'unhealthy',
+          latencyMs: Date.now() - start,
+        };
+      }
+    }),
+  );
+
+  return results.map((r) =>
+    r.status === 'fulfilled'
+      ? r.value
+      : { name: '?', container: '?', health: 'unknown', latencyMs: 0 },
+  );
+}
+
+function getPortConfig() {
+  const defaults = { vite: 5173, api: 3000 };
+  try {
+    const envFiles = ['.env.local', '.env'];
+    for (const file of envFiles) {
+      if (existsSync(file)) {
+        const content = readFileSync(file, 'utf-8');
+        const getEnvValue = (key) => {
+          const match = content.match(new RegExp(`^${key}=["']?([^"'\\n]+)["']?`, 'm'));
+          return match ? match[1] : null;
+        };
+
+        const portOffset = Number.parseInt(getEnvValue('DEV_PORT_OFFSET') || '0', 10);
+        const vitePort = getEnvValue('DEV_VITE_PORT') || String(5173 + portOffset);
+        const apiPort = getEnvValue('DEV_API_PORT') || String(3000 + portOffset);
+
+        return { vite: Number.parseInt(vitePort, 10), api: Number.parseInt(apiPort, 10) };
+      }
+    }
+  } catch {
+    // Fall through to defaults
+  }
+  return defaults;
+}
+
+async function checkLocalDev(projectName) {
+  const ports = getPortConfig();
+
+  const [apiCheck, viteCheck, dockerServices] = await Promise.allSettled([
+    checkHttpEndpoint(`http://localhost:${ports.api}/api/health`, 2000),
+    checkHttpEndpoint(`http://localhost:${ports.vite}`, 2000),
+    checkDockerContainers(projectName),
+  ]);
+
+  const api =
+    apiCheck.status === 'fulfilled' ? apiCheck.value : { ok: false, error: 'check failed' };
+  const vite =
+    viteCheck.status === 'fulfilled' ? viteCheck.value : { ok: false, error: 'check failed' };
+  const docker = dockerServices.status === 'fulfilled' ? dockerServices.value : [];
+
+  return {
+    api: { running: api.ok, latencyMs: api.latencyMs, port: ports.api, data: api.data },
+    vite: { running: vite.ok, port: ports.vite },
+    docker,
+  };
+}
+
+async function checkRemoteHealth(domain) {
+  const url = `https://${domain}/api/health`;
+  const result = await checkHttpEndpoint(url, 5000);
+  return {
+    url,
+    ok: result.ok,
+    status: result.status,
+    latencyMs: result.latencyMs,
+    data: result.data,
+    error: result.error,
+  };
+}
+
+async function getServerInfo(serverId) {
+  const apiToken = process.env.HETZNER_API_TOKEN;
+  if (!apiToken) return null;
+
+  try {
+    const response = await fetch(`https://api.hetzner.cloud/v1/servers/${serverId}`, {
+      headers: { Authorization: `Bearer ${apiToken}` },
+      signal: AbortSignal.timeout(5000),
+    });
+
+    if (!response.ok) return null;
+
+    const { server } = await response.json();
+    return {
+      status: server.status,
+      serverType: server.server_type?.name || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function checkGitSync(envName, envConfig) {
+  const deployedCommit = envConfig.deployedCommit;
+  if (!deployedCommit) {
+    return { branch: getBranchName(envName), current: null, deployed: null, commitsAhead: null };
+  }
+
+  const branch = getBranchName(envName);
+
+  try {
+    const current = runCommand(['git', 'rev-parse', 'HEAD'], {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    let commitsAhead = null;
+    try {
+      const count = runCommand(['git', 'rev-list', '--count', `${deployedCommit}..HEAD`], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      commitsAhead = Number.parseInt(count, 10);
+    } catch {
+      // Deployed commit might not be in local history
+    }
+
+    let deployedMessage = null;
+    try {
+      deployedMessage = runCommand(['git', 'log', '--format=%s', '-1', deployedCommit], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+    } catch {
+      // Commit might not be locally available
+    }
+
+    let currentMessage = null;
+    try {
+      currentMessage = runCommand(['git', 'log', '--format=%s', '-1', 'HEAD'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+    } catch {
+      // Ignore
+    }
+
+    return {
+      branch,
+      current: { sha: current, message: currentMessage },
+      deployed: { sha: deployedCommit, message: deployedMessage },
+      commitsAhead,
+    };
+  } catch {
+    return {
+      branch,
+      current: null,
+      deployed: { sha: deployedCommit, message: null },
+      commitsAhead: null,
+    };
+  }
+}
+
+/**
+ * Calculate monthly cost for a single environment.
+ * Includes servers, floating IP, CSI volumes, and S3 storage.
+ */
+function calculateEnvCost(envConfig) {
+  const { INFRA_COSTS, VOLUME_SIZES, SERVER_TYPES } = HetznerProvider;
+  let cost = 0;
+
+  // Floating IP
+  if (envConfig.floatingIp) {
+    cost += INFRA_COSTS.floatingIp;
+  }
+
+  // Servers
+  const servers = envConfig.servers || [];
+  for (const server of servers) {
+    const serverType = server.serverType || server.type || 'cpx11';
+    const spec = SERVER_TYPES[serverType];
+    if (spec) {
+      const priceMatch = spec.price.match(/[\d.]+/);
+      if (priceMatch) cost += Number.parseFloat(priceMatch[0]);
+    }
+  }
+
+  // CSI Volumes (base supabase PVCs are always provisioned)
+  if (servers.length > 0) {
+    let volumeGb = VOLUME_SIZES.base;
+    const services = envConfig.services || {};
+    if (envConfig.observability || services.observability) volumeGb += VOLUME_SIZES.observability;
+    if (services.n8n) volumeGb += VOLUME_SIZES.n8n;
+    if (services.metabase) volumeGb += VOLUME_SIZES.metabase;
+    if (services.redis) volumeGb += VOLUME_SIZES.redis;
+    cost += volumeGb * INFRA_COSTS.volumePerGb;
+  }
+
+  // S3 Object Storage
+  if (envConfig.s3) {
+    cost += INFRA_COSTS.s3MinBucket;
+  }
+
+  return cost;
+}
+
+function calculateMonthlyCost(environments) {
+  let total = 0;
+  for (const [, envConfig] of Object.entries(environments)) {
+    total += calculateEnvCost(envConfig);
+  }
+  return total > 0 ? `\u20AC${total.toFixed(2)}/mo` : null;
+}
+
+// ============================================================================
+// RENDERING FUNCTIONS
+// ============================================================================
+
+function renderLocalDev(data) {
+  const lines = [];
+
+  // API server
+  const apiStatus = data.api.running
+    ? `${c.success('\u25cf')} ${c.success('Running')}  ${c.dim(`${data.api.latencyMs}ms`)}`
+    : `${c.dim('\u25cb')} ${c.dim('Stopped')}`;
+  const apiLabel = `API Server (port ${data.api.port})`;
+  lines.push(`${c.dim(apiLabel.padEnd(30))}${apiStatus}`);
+
+  // Vite dev server
+  const viteStatus = data.vite.running
+    ? `${c.success('\u25cf')} ${c.success('Running')}`
+    : `${c.dim('\u25cb')} ${c.dim('Stopped')}`;
+  const viteLabel = `Vite Dev Server (port ${data.vite.port})`;
+  lines.push(`${c.dim(viteLabel.padEnd(30))}${viteStatus}`);
+
+  // Docker services
+  if (data.docker.length > 0) {
+    const healthyCount = data.docker.filter((s) => s.health === 'healthy').length;
+    const total = data.docker.length;
+    const dockerSummary =
+      healthyCount === total
+        ? c.success(`\u25cf ${healthyCount}/${total} healthy`)
+        : c.warning(`\u25cf ${healthyCount}/${total} healthy`);
+    lines.push(`${c.dim('Docker Services'.padEnd(30))}${dockerSummary}`);
+
+    for (const svc of data.docker) {
+      const icon =
+        svc.health === 'healthy'
+          ? c.success('\u25cf')
+          : svc.health === 'unhealthy'
+            ? c.error('\u25cf')
+            : c.dim('\u25cb');
+      const status = svc.health === 'healthy' ? c.dim('healthy') : c.error(svc.health);
+      const latency = svc.latencyMs ? c.dim(`${svc.latencyMs}ms`) : '';
+      lines.push(`  ${c.dim(svc.name.padEnd(28))}${icon} ${status}  ${latency}`);
+    }
+  } else {
+    lines.push(`${c.dim('Docker Services'.padEnd(30))}${c.dim('not running')}`);
+  }
+
+  p.note(lines.join('\n'), 'Local Development');
+}
+
+function renderEnvironment(envName, envConfig, checks) {
+  const lines = [];
+
+  // Provider
+  const providerName =
+    envConfig.provider === 'hetzner' ? 'Hetzner Cloud' : envConfig.provider || 'unknown';
+  lines.push(`${c.dim('Provider')}       ${providerName}`);
+
+  // Region
+  if (envConfig.region) {
+    const regionDesc = HetznerProvider.REGIONS[envConfig.region] || '';
+    const regionDisplay = regionDesc
+      ? `${envConfig.region} ${c.dim(`(${regionDesc})`)}`
+      : envConfig.region;
+    lines.push(`${c.dim('Region')}         ${regionDisplay}`);
+  }
+
+  // Domain
+  if (envConfig.domain) {
+    lines.push(`${c.dim('Domain')}         ${c.info(envConfig.domain)}`);
+  }
+
+  // Floating IP
+  if (envConfig.floatingIp) {
+    lines.push(`${c.dim('Floating IP')}    ${envConfig.floatingIp}`);
+  }
+
+  // S3 Bucket
+  if (envConfig.s3?.bucket) {
+    const s3Region = envConfig.s3.region ? ` ${c.dim(`(${envConfig.s3.region})`)}` : '';
+    lines.push(`${c.dim('S3 Bucket')}      ${envConfig.s3.bucket}${s3Region}`);
+  }
+
+  // Deployed date
+  if (envConfig.deployedAt) {
+    const relative = formatRelativeTime(envConfig.deployedAt);
+    const dateStr = new Date(envConfig.deployedAt)
+      .toISOString()
+      .replace('T', ' ')
+      .replace(/\.\d+Z/, ' UTC');
+    lines.push(`${c.dim('Deployed')}       ${dateStr} ${c.dim(`(${relative})`)}`);
+  }
+
+  // HA
+  if (envConfig.ha) {
+    const failoverRegion = envConfig.secondaryRegion || envConfig.failoverRegion;
+    const haDisplay = failoverRegion
+      ? `${c.success('Enabled')} ${c.dim(`(failover: ${failoverRegion})`)}`
+      : c.success('Enabled');
+    lines.push(`${c.dim('HA')}             ${haDisplay}`);
+  }
+
+  // Servers
+  const servers = envConfig.servers || [];
+  if (servers.length > 0) {
+    lines.push('');
+    lines.push(c.bold('Servers'));
+    for (const server of servers) {
+      const serverInfo = checks.serverInfo?.[server.id];
+      const configType = server.serverType || server.type || null;
+      let statusStr;
+      if (serverInfo) {
+        const icon = serverInfo.status === 'running' ? c.success('\u25cf') : c.error('\u25cf');
+        const typeLabel = serverInfo.serverType || configType || '';
+        statusStr = `${icon} ${serverInfo.status === 'running' ? c.success('running') : c.error(serverInfo.status)}  ${c.dim(typeLabel)}`;
+      } else if (configType) {
+        statusStr = c.dim(configType);
+      } else {
+        statusStr = c.dim('\u2013');
+      }
+      lines.push(
+        `  ${c.info((server.name || '').padEnd(16))} ${(server.ip || '').padEnd(15)} ${statusStr}`,
+      );
+    }
+  }
+
+  // Remote health
+  if (envConfig.domain && checks.remoteHealth) {
+    lines.push('');
+    lines.push(c.bold('Health'));
+    lines.push(`  ${c.dim(checks.remoteHealth.url)}`);
+    if (checks.remoteHealth.ok) {
+      const data = checks.remoteHealth.data;
+      let details = '';
+      if (data && typeof data === 'object') {
+        const parts = [];
+        if (data.database) parts.push(`db: ${data.database}`);
+        if (data.supabase) parts.push(`supabase: ${data.supabase}`);
+        if (data.status) parts.push(data.status);
+        if (parts.length > 0) details = c.dim(`  (${parts.join(', ')})`);
+      }
+      lines.push(
+        `  ${c.success('\u25cf')} ${c.success('healthy')}  ${c.dim(`${checks.remoteHealth.latencyMs}ms`)}${details}`,
+      );
+    } else {
+      const errMsg = checks.remoteHealth.error || `HTTP ${checks.remoteHealth.status}`;
+      lines.push(`  ${c.error('\u25cf')} ${c.error('unhealthy')}  ${c.dim(`(${errMsg})`)}`);
+    }
+  }
+
+  // Services
+  const enabledServices = [];
+  if (envConfig.observability) enabledServices.push('observability');
+  if (envConfig.n8n) enabledServices.push('n8n');
+  if (envConfig.metabase) enabledServices.push('metabase');
+  if (envConfig.ha) enabledServices.push('ha');
+  if (envConfig.cicd) enabledServices.push('cicd');
+  if (envConfig.services) {
+    for (const [key, val] of Object.entries(envConfig.services)) {
+      if (val && !enabledServices.includes(key)) enabledServices.push(key);
+    }
+  }
+  if (enabledServices.length > 0) {
+    lines.push(
+      `${c.dim('Services')}       ${enabledServices.map((s) => c.info(s)).join(c.dim(', '))}`,
+    );
+  }
+
+  // Cost estimate
+  if (servers.length > 0) {
+    const cost = calculateEnvCost(envConfig);
+    if (cost > 0) {
+      lines.push(`${c.dim('Est. Cost')}      ${c.boldYellow(`\u20AC${cost.toFixed(2)}/mo`)}`);
+    }
+  }
+
+  // Git sync
+  if (checks.gitSync) {
+    lines.push('');
+    lines.push(c.bold('Git Sync'));
+    const gs = checks.gitSync;
+    if (gs.deployed?.sha) {
+      const shortSha = gs.deployed.sha.substring(0, 7);
+      const msg = gs.deployed.message ? ` ${c.dim(`"${gs.deployed.message}"`)}` : '';
+      lines.push(`  ${c.dim('Deployed')}   ${c.boldCyan(shortSha)}${msg}`);
+    } else {
+      lines.push(`  ${c.dim('No deployed commit recorded (redeploy to enable tracking)')}`);
+    }
+    if (gs.current?.sha && gs.deployed?.sha) {
+      const shortSha = gs.current.sha.substring(0, 7);
+      const msg = gs.current.message ? ` ${c.dim(`"${gs.current.message}"`)}` : '';
+      const ahead =
+        gs.commitsAhead !== null && gs.commitsAhead > 0
+          ? c.warning(` (+${gs.commitsAhead} commit${gs.commitsAhead === 1 ? '' : 's'} ahead)`)
+          : gs.commitsAhead === 0
+            ? c.success(' (up to date)')
+            : '';
+      lines.push(`  ${c.dim('Current')}    ${c.boldCyan(shortSha)}${msg}${ahead}`);
+    }
+  }
+
+  p.note(lines.join('\n'), `Environment: ${envName}`);
+}
+
+function renderSummary(allData) {
+  const lines = [];
+
+  // Environments
+  const envCount = Object.keys(allData.environments || {}).length;
+  const unhealthyCount = Object.values(allData.environments || {}).filter(
+    (e) => e.checks?.remoteHealth && !e.checks.remoteHealth.ok,
+  ).length;
+
+  if (envCount > 0) {
+    const envStr = `${envCount} deployed`;
+    const unhealthyStr =
+      unhealthyCount > 0
+        ? `, ${c.error(`${unhealthyCount} unhealthy`)}`
+        : `, ${c.success('0 unhealthy')}`;
+    lines.push(`${c.dim('Environments')}   ${envStr}${unhealthyStr}`);
+  } else {
+    lines.push(`${c.dim('Environments')}   ${c.dim('none deployed')}`);
+  }
+
+  // Local dev
+  if (allData.localDev) {
+    const ld = allData.localDev;
+    const parts = [];
+    if (ld.api.running) parts.push('API');
+    if (ld.vite.running) parts.push('Vite');
+    const dockerHealthy = ld.docker.filter((s) => s.health === 'healthy').length;
+    if (ld.docker.length > 0) parts.push(`Docker ${dockerHealthy}/${ld.docker.length}`);
+
+    if (
+      parts.length > 0 &&
+      ld.api.running &&
+      ld.vite.running &&
+      dockerHealthy === ld.docker.length &&
+      ld.docker.length > 0
+    ) {
+      lines.push(`${c.dim('Local Dev')}      ${c.success('All services running')}`);
+    } else if (parts.length > 0) {
+      lines.push(`${c.dim('Local Dev')}      ${parts.join(', ')}`);
+    } else {
+      lines.push(`${c.dim('Local Dev')}      ${c.dim('not running')}`);
+    }
+  }
+
+  // Total cost
+  const totalCost = calculateMonthlyCost(
+    Object.fromEntries(Object.entries(allData.environments || {}).map(([k, v]) => [k, v.config])),
+  );
+  if (totalCost) {
+    lines.push(`${c.dim('Est. Total')}     ${c.boldYellow(totalCost)}`);
+  }
+
+  p.note(lines.join('\n'), 'Summary');
+}
+
+// ============================================================================
+// GLOBAL STATUS (outside a project directory)
+// ============================================================================
+
+async function showGlobalStatus(args) {
+  cleanStaleProjects();
+  const registry = loadGlobalRegistry();
+
+  if (args.json) {
+    // Enrich each project with config data
+    const enriched = registry.projects.map((entry) => {
+      const config = loadProjectConfig(entry.path);
+      const envNames = config?.environments ? Object.keys(config.environments) : [];
+      return { ...entry, environments: envNames };
+    });
+    console.log(JSON.stringify({ mode: 'global', projects: enriched }, null, 2));
+    return;
+  }
+
+  printBanner();
+  p.intro(`${c.bold('vibecarbon status')} ${c.dim(`v${VERSION}`)}`);
+
+  if (registry.projects.length === 0) {
+    p.log.info('No registered projects.');
+    p.log.info(`Get started: ${c.info('vibecarbon create my-app')}`);
+    return;
+  }
+
+  p.log.info(
+    `${registry.projects.length} registered project${registry.projects.length === 1 ? '' : 's'}`,
+  );
+
+  for (const entry of registry.projects) {
+    const config = loadProjectConfig(entry.path);
+    const envNames = config?.environments ? Object.keys(config.environments) : [];
+    const envDisplay = envNames.length > 0 ? envNames.join(', ') : c.dim('none');
+
+    console.log('');
+    console.log(`  ${c.bold(entry.name)}`);
+    console.log(`    Path          ${c.dim(entry.path)}`);
+    console.log(`    Environments  ${envDisplay}`);
+    if (entry.updatedAt) {
+      console.log(`    Last updated  ${formatRelativeTime(entry.updatedAt)}`);
+    }
+  }
+
+  console.log('');
+  p.log.info(
+    `${c.dim('Run')} ${c.info('vibecarbon status')} ${c.dim('from inside a project for detailed info.')}`,
+  );
+}
+
+// ============================================================================
+// MAIN
+// ============================================================================
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { values, errors } = parseFlags(argv, SPEC);
+
+  if (errors.length > 0) {
+    for (const e of errors) {
+      process.stderr.write(`${c.error('✗')} ${e}\n`);
+    }
+    process.stderr.write(`Run ${c.info('vibecarbon status -h')} for usage.\n`);
+    process.exit(1);
+  }
+
+  if (values.h) {
+    process.stdout.write(renderHelp(SPEC));
+    process.exit(0);
+  }
+
+  if (values.v) {
+    console.log(`vibecarbon-status v${VERSION}`);
+    process.exit(0);
+  }
+
+  // Translate to legacy args shape so the rest of main() doesn't need
+  // to change. `noLocal` is now context-sensitive: skip local-dev checks
+  // when output is JSON (the consumer is a script, not a human) or when
+  // stdout isn't a TTY (CI / piped). Operators who want explicit local
+  // checks can still get them by running on a TTY without `-json`.
+  const args = {
+    env: /** @type {string|null} */ (values.env),
+    json: !!values.json,
+    noLocal: !!values.json || !process.stdout.isTTY,
+  };
+
+  let cwd;
+  try {
+    cwd = process.cwd();
+  } catch {
+    if (args.json) {
+      console.log(JSON.stringify({ error: 'Current working directory does not exist' }));
+    } else {
+      console.error(`\n${c.error('Error:')} Current working directory does not exist.`);
+    }
+    process.exit(1);
+  }
+
+  const projectConfig = loadProjectConfig(cwd);
+  if (!projectConfig) {
+    await showGlobalStatus(args);
+    return;
+  }
+
+  const environments = projectConfig.environments || {};
+
+  // Filter to specific environment if requested
+  let envEntries = Object.entries(environments);
+  if (args.env) {
+    const filtered = envEntries.filter(([name]) => name === args.env);
+    if (filtered.length === 0) {
+      if (args.json) {
+        console.log(JSON.stringify({ error: `Environment '${args.env}' not found` }));
+      } else {
+        printBanner();
+        p.intro(`${c.bold('vibecarbon status')} ${c.dim(`v${VERSION}`)}`);
+        p.log.error(`Environment '${args.env}' not found`);
+        if (envEntries.length > 0) {
+          p.log.info(`Available environments: ${envEntries.map(([n]) => n).join(', ')}`);
+        }
+      }
+      process.exit(1);
+    }
+    envEntries = filtered;
+  }
+
+  // Gather all data in parallel
+  const allData = {
+    projectName: projectConfig.projectName,
+    localDev: null,
+    environments: {},
+  };
+
+  // Local dev check (skipped in JSON / non-TTY contexts — see args above).
+  const localDevPromise = args.noLocal
+    ? Promise.resolve(null)
+    : checkLocalDev(projectConfig.projectName);
+
+  // Environment checks in parallel
+  const envChecksPromise = Promise.allSettled(
+    envEntries.map(async ([envName, envConfig]) => {
+      const checks = {};
+
+      // Remote health check
+      if (envConfig.domain) {
+        checks.remoteHealth = await checkRemoteHealth(envConfig.domain);
+      }
+
+      // Server info from Hetzner API
+      const servers = envConfig.servers || [];
+      if (servers.length > 0 && process.env.HETZNER_API_TOKEN) {
+        const serverInfoResults = await Promise.allSettled(servers.map((s) => getServerInfo(s.id)));
+        checks.serverInfo = {};
+        servers.forEach((s, i) => {
+          const result = serverInfoResults[i];
+          if (result.status === 'fulfilled' && result.value) {
+            checks.serverInfo[s.id] = result.value;
+          }
+        });
+      }
+
+      // Git sync
+      checks.gitSync = checkGitSync(envName, envConfig);
+
+      return { envName, config: envConfig, checks };
+    }),
+  );
+
+  const [localDevResult, envChecksResults] = await Promise.all([localDevPromise, envChecksPromise]);
+
+  allData.localDev = localDevResult;
+
+  for (const result of envChecksResults) {
+    if (result.status === 'fulfilled') {
+      const { envName, config, checks } = result.value;
+      allData.environments[envName] = { config, checks };
+    }
+  }
+
+  // Output
+  if (args.json) {
+    console.log(JSON.stringify(allData, null, 2));
+    process.exit(0);
+  }
+
+  // Rendered output
+  printBanner();
+  p.intro(`${c.bold('vibecarbon status')} ${c.dim(`v${VERSION}`)}`);
+  p.log.info(`Project: ${c.bold(projectConfig.projectName)}`);
+
+  // Operator-IP access (H-2). One-line summary: how many CIDRs are in the
+  // allowlist. We don't auto-detect here — status is a passive read of
+  // local files and HTTP probes; firing api.ipify.org on every status
+  // call would be surprising. Pointer to `vibecarbon access` is enough.
+  const cidrs = projectConfig.operatorCidrs ?? [];
+  if (cidrs.length === 0) {
+    p.log.warn(
+      `Access: no operator CIDRs configured — run ${c.info('vibecarbon access add <cidr>')} or set ALLOWED_SSH_IPS before deploy.`,
+    );
+  } else {
+    p.log.info(
+      `Access: ${cidrs.length} CIDR${cidrs.length === 1 ? '' : 's'} in allowlist — see ${c.info('vibecarbon access')} for details.`,
+    );
+  }
+
+  // Local dev
+  if (allData.localDev) {
+    renderLocalDev(allData.localDev);
+  }
+
+  // Environments
+  for (const [envName, envData] of Object.entries(allData.environments)) {
+    renderEnvironment(envName, envData.config, envData.checks);
+  }
+
+  if (envEntries.length === 0 && !args.env) {
+    p.log.info(
+      `${c.dim('No environments deployed yet. Run')} ${c.info('vibecarbon deploy')} ${c.dim('to get started.')}`,
+    );
+  }
+
+  // Summary
+  renderSummary(allData);
+  p.outro(c.dim(`Status as of ${new Date().toISOString()}`));
+}
+
+// ============================================================================
+// RUN FUNCTION (called by CLI entry point)
+// ============================================================================
+
+export async function run(args) {
+  const originalArgv = process.argv;
+  process.argv = ['node', 'status', ...args];
+  try {
+    await main();
+  } finally {
+    process.argv = originalArgv;
+  }
+}
+
+// ============================================================================
+// EXPORTS FOR TESTING
+// ============================================================================
+
+export {
+  calculateEnvCost,
+  calculateMonthlyCost,
+  checkDockerContainers,
+  checkGitSync,
+  checkHttpEndpoint,
+  checkLocalDev,
+  checkRemoteHealth,
+  formatRelativeTime,
+  getBranchName,
+  getServerInfo,
+  main,
+  SPEC,
+  showGlobalStatus,
+  VERSION,
+};