badgr-cli 1.0.0

package/src/commands/down.js

@@ -0,0 +1,55 @@
+import { requireApiKey } from '../config.js';
+import { findDeployment, removeDeployment, addReceipt, generateReceiptId } from '../store.js';
+import { terminateDeployment } from '../api.js';
+
+export async function downCommand(config, args, chalk) {
+  const idOrName = args.find(a => !a.startsWith('--'));
+
+  if (!idOrName) {
+    console.error(chalk.red('Usage: badgr down <deployment-id|name>'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  const localDep = findDeployment(idOrName);
+
+  // Resolve the deployment ID to send to the backend
+  const deploymentId = localDep?.id ?? idOrName;
+
+  console.log(chalk.dim(`  Terminating ${deploymentId}...`));
+
+  let dep;
+  try {
+    dep = await terminateDeployment(config, deploymentId);
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Terminate failed: ${err.message}\n`));
+    return;
+  }
+
+  const rcptId = generateReceiptId();
+  addReceipt({
+    receiptId:    rcptId,
+    action:       'badgr down',
+    deploymentId: dep.deployment_id,
+    name:         dep.name,
+    provider:     dep.provider,
+    gpu:          dep.gpu_type,
+    latencyMs:    0,
+    status:       'terminated',
+    createdAt:    new Date().toISOString(),
+  });
+
+  // Remove from local store
+  removeDeployment(idOrName);
+
+  console.log(chalk.green(`\n✓ Deployment stopped: ${dep.name}\n`));
+  console.log(`  ${chalk.bold('ID:')}        ${dep.deployment_id}`);
+  console.log(`  ${chalk.bold('Provider:')} ${dep.provider}`);
+  console.log(`  ${chalk.bold('GPU:')}       ${dep.gpu_type} × ${dep.gpu_count}`);
+  if (dep.started_at) {
+    const uptime = Math.round((Date.now() / 1000 - dep.started_at) / 60);
+    console.log(`  ${chalk.bold('Uptime:')}    ${uptime} min`);
+  }
+  console.log(`\n  ${chalk.bold('Receipt ID:')} ${chalk.dim(rcptId)}\n`);
+}

package/src/commands/login.js

@@ -0,0 +1,20 @@
+import { input } from '@inquirer/prompts';
+
+export async function loginCommand(chalk, saveConfigFn) {
+  console.log(chalk.bold('\n🔑  GPU.AI Login\n'));
+
+  const apiKey = await input({
+    message: 'Enter your GPU.AI API key:',
+    validate: v => v.trim() ? true : 'API key is required',
+  });
+
+  const baseUrl = await input({
+    message: 'API base URL:',
+    default: 'https://api.gpu.ai/v1',
+  });
+
+  const config = saveConfigFn({ apiKey: apiKey.trim(), baseUrl: baseUrl.trim() });
+  console.log(chalk.green('\n✓ Logged in — config saved to ~/.gpu/config.json\n'));
+  console.log(chalk.dim(`  Base URL: ${config.baseUrl}\n`));
+  return config;
+}

package/src/commands/logs.js

@@ -0,0 +1,49 @@
+import { findDeployment, listDeployments } from '../store.js';
+import { requireApiKey } from '../config.js';
+import { getDeploymentLogs } from '../api.js';
+
+export async function logsCommand(config, args, chalk) {
+  const idOrName = args.find(a => !a.startsWith('--'));
+  const follow   = args.includes('--follow') || args.includes('-f');
+
+  requireApiKey(config);
+
+  if (!idOrName) {
+    const deps = listDeployments();
+    if (deps.length === 0) {
+      console.log(chalk.dim('\n  No active deployments. Run `badgr status` first.\n'));
+      return;
+    }
+    console.log(chalk.bold('\n📋 Active deployments:\n'));
+    deps.forEach(d => console.log(`  ${chalk.cyan(d.name)}  (${d.id})`));
+    console.log(chalk.dim('\n  Usage: badgr logs <name|id> [--follow]\n'));
+    return;
+  }
+
+  // Resolve local name → deployment ID
+  const localDep = findDeployment(idOrName);
+  const deploymentId = localDep?.id ?? idOrName;
+
+  console.log(chalk.bold(`\n📋 Logs: ${localDep?.name ?? deploymentId}\n`));
+
+  try {
+    const data = await getDeploymentLogs(config, deploymentId);
+    const lines = data?.logs ?? [];
+    if (lines.length === 0) {
+      console.log(chalk.dim('  No log lines available yet.\n'));
+    } else {
+      lines.forEach(l => console.log(`  ${chalk.dim(l)}`));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`  Could not fetch logs: ${err.message}`));
+    if (localDep) {
+      console.log(chalk.dim(`\n  Provider: ${localDep.provider}  GPU: ${localDep.gpu}  Type: ${localDep.type}`));
+      console.log(chalk.dim(`  Endpoint: ${localDep.endpointUrl}`));
+    }
+  }
+
+  if (follow) {
+    console.log(chalk.yellow('\n  --follow: live log streaming not yet supported. Poll with `badgr logs`.\n'));
+  }
+  console.log();
+}

package/src/commands/models.js

@@ -0,0 +1,39 @@
+import { listModels } from '../api.js';
+import { listAll } from '../router.js';
+
+export async function modelsCommand(config, chalk) {
+  const gpus = listAll();
+
+  console.log(chalk.bold('\n📦 GPU Options (cheapest first)\n'));
+  console.log(
+    `  ${'ID'.padEnd(14)}  ${'Name'.padEnd(24)}  ${'VRAM'.padEnd(8)}  Rate/hr`
+  );
+  console.log(`  ${'─'.repeat(58)}`);
+  gpus.forEach(g => {
+    console.log(
+      `  ${chalk.cyan(g.id.padEnd(14))}  ${g.name.padEnd(24)}  ${`${g.vramGb}GB`.padEnd(8)}  $${g.ratePerHour.toFixed(2)}`
+    );
+  });
+
+  console.log(chalk.bold('\n🤖 LLM Models\n'));
+  if (!config.apiKey) {
+    console.log(chalk.dim('  Run `gpu login` to see available models.\n'));
+    return;
+  }
+
+  try {
+    const data = await listModels(config);
+    const models = data.data ?? data.models ?? [];
+    if (models.length === 0) {
+      console.log(chalk.dim('  No models returned.\n'));
+      return;
+    }
+    models.forEach(m => {
+      const id = typeof m === 'string' ? m : m.id;
+      console.log(`  ${chalk.cyan(id)}`);
+    });
+    console.log();
+  } catch (err) {
+    console.log(chalk.yellow(`  Could not fetch models: ${err.message}\n`));
+  }
+}

package/src/commands/receipts.js

@@ -0,0 +1,82 @@
+import { listReceipts as localReceipts } from '../store.js';
+import { listReceipts as apiReceipts, getReceipt as apiGetReceipt } from '../api.js';
+
+function fmtMs(ms) {
+  return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
+}
+
+function printReceipt(r, chalk) {
+  const id     = r.receiptId ?? r.request_id ?? r.id ?? '—';
+  const ts     = r.createdAt ?? r.created_at ?? '—';
+  const cost   = r.route?.ratePerHour ?? r.cost_usd ?? 0;
+  const prov   = r.route?.provider ?? r.provider ?? r.model_provider ?? '—';
+  const lat    = r.latencyMs ?? r.latency_ms;
+  const action = r.action ?? r.endpoint ?? '—';
+
+  console.log(`  ${chalk.cyan(id)}`);
+  console.log(`    ${chalk.bold('action:')}   ${action}`);
+  console.log(`    ${chalk.bold('provider:')} ${prov}`);
+  if (lat !== undefined) console.log(`    ${chalk.bold('latency:')}  ${fmtMs(lat)}`);
+  if (cost) console.log(`    ${chalk.bold('cost:')}     $${typeof cost === 'number' ? cost.toFixed(4) : cost}/hr`);
+  if (r.retries !== undefined) console.log(`    ${chalk.bold('retries:')}  ${r.retries}`);
+  if (r.status) console.log(`    ${chalk.bold('status:')}   ${r.status}`);
+  console.log(`    ${chalk.dim(ts)}`);
+  console.log();
+}
+
+export async function receiptsCommand(config, args, chalk) {
+  // If first arg looks like a receipt/deployment ID, fetch that single receipt
+  const firstArg = args[0];
+  const isSingleLookup = firstArg && !/^\d+$/.test(firstArg);
+
+  if (isSingleLookup) {
+    console.log(chalk.bold(`\n🧾 Receipt: ${firstArg}\n`));
+    if (!config.apiKey) {
+      console.log(chalk.dim('  Run `badgr login` to look up receipts from the API.\n'));
+      return;
+    }
+    try {
+      const r = await apiGetReceipt(config, firstArg);
+      printReceipt(r, chalk);
+    } catch (err) {
+      console.log(chalk.yellow(`  Receipt not found: ${err.message}\n`));
+    }
+    return;
+  }
+
+  const limit = parseInt(firstArg ?? '10', 10);
+
+  console.log(chalk.bold('\n🧾 Receipts\n'));
+
+  // ── Local CLI action receipts (badgr run / badgr down) ─────────────────
+  const local = localReceipts(limit);
+  if (local.length > 0) {
+    console.log(chalk.bold('  CLI Actions\n'));
+    local.forEach(r => printReceipt(r, chalk));
+  }
+
+  // ── Backend receipts (GET /v1/receipts) ────────────────────────────────
+  if (!config.apiKey) {
+    console.log(chalk.dim('  Run `badgr login` to see inference receipts from the API.\n'));
+    return;
+  }
+
+  console.log(chalk.bold('  API Receipts\n'));
+  try {
+    const data = await apiReceipts(config, { limit });
+    const rows = data?.data ?? data?.receipts ?? [];
+
+    if (rows.length === 0) {
+      console.log(chalk.dim('  No receipts found.\n'));
+      return;
+    }
+
+    rows.forEach(r => printReceipt(r, chalk));
+
+    if (data?.has_more) {
+      console.log(chalk.dim(`  … more available. badgr receipts ${limit * 2}\n`));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`  Could not fetch API receipts: ${err.message}\n`));
+  }
+}

package/src/commands/run.js

@@ -0,0 +1,162 @@
+import { requireApiKey } from '../config.js';
+import { callApi } from '../api.js';
+import { addReceipt, generateReceiptId } from '../store.js';
+
+/**
+ * badgr run python train.py --gpu A100           # attached (default)
+ * badgr run --image my/image:latest --gpu L40S --detach
+ *
+ * Attaches by default: polls status + streams logs until the job finishes,
+ * then exits with the job's exit code. Pass --detach to return immediately.
+ */
+export function parseRunArgs(args) {
+  const flags = {};
+  const positional = [];
+  let i = 0;
+  while (i < args.length) {
+    if (args[i] === '--gpu')            { flags.gpu = args[++i]; i++; continue; }
+    if (args[i] === '--image')          { flags.image = args[++i]; i++; continue; }
+    if (args[i] === '--count')          { flags.count = parseInt(args[++i], 10); i++; continue; }
+    if (args[i] === '--region')         { flags.region = args[++i]; i++; continue; }
+    if (args[i] === '--max-price')      { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
+    if (args[i] === '--name')           { flags.name = args[++i]; i++; continue; }
+    if (args[i] === '--detach')         { flags.detach = true; i++; continue; }
+    positional.push(args[i++]);
+  }
+  return { flags, positional };
+}
+
+// Poll /v1/deployments/:id until terminal status, streaming new log lines.
+async function attachToJob(config, depId, chalk) {
+  const TERMINAL = new Set(['stopped', 'failed', 'completed']);
+  const POLL_MS  = 4000;
+  let seenLines  = 0;
+  let lastStatus = '';
+
+  while (true) {
+    await new Promise(r => setTimeout(r, POLL_MS));
+
+    // Fetch status
+    let dep;
+    try {
+      dep = await callApi(`/deployments/${depId}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+    } catch {
+      // transient network error — keep trying
+      continue;
+    }
+
+    const status = dep.status;
+    if (status !== lastStatus) {
+      if (status === 'running' && lastStatus === 'provisioning') {
+        console.log(chalk.dim('  [running]'));
+      }
+      lastStatus = status;
+    }
+
+    // Stream any new log lines
+    try {
+      const logData = await callApi(`/deployments/${depId}/logs`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+      const lines = logData?.logs ?? [];
+      for (let i = seenLines; i < lines.length; i++) {
+        console.log(`  ${chalk.dim(lines[i])}`);
+      }
+      seenLines = lines.length;
+    } catch {
+      // logs not ready yet
+    }
+
+    if (TERMINAL.has(status)) {
+      return status;
+    }
+  }
+}
+
+export async function runCommand(config, args, chalk) {
+  const { flags, positional } = parseRunArgs(args);
+
+  if (positional.length === 0 && !flags.image) {
+    console.error(chalk.red('Usage: badgr run <command...> --gpu <type>'));
+    console.error(chalk.red('       badgr run --image my/image:latest --gpu A100'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  const command = positional.length > 0 ? positional : undefined;
+  const gpu     = flags.gpu || 'RTX_4090';
+  const image   = flags.image || (command ? 'python:3.11-slim' : undefined);
+  const detach  = flags.detach || false;
+
+  console.log(chalk.bold('\n⚡ Running GPU job\n'));
+  if (command) console.log(`  ${chalk.bold('Command:')}  ${command.join(' ')}`);
+  if (image)   console.log(`  ${chalk.bold('Image:')}    ${image}`);
+  console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
+  if (detach)  console.log(`  ${chalk.dim('(detached — returns immediately)')}`);
+  console.log();
+  console.log(chalk.dim('  Routing own GPUs → Vast/RunPod/Salad overflow...'));
+
+  let dep;
+  try {
+    dep = await callApi('/run', {
+      method: 'POST',
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      body: {
+        command,
+        image,
+        gpu: gpu.toUpperCase().replace('-', '_'),
+        gpu_count: flags.count || 1,
+        region: flags.region || 'US',
+        max_price_per_hour: flags.maxPrice,
+        name: flags.name,
+      },
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Job failed to start: ${err.message}\n`));
+    process.exit(1);
+  }
+
+  const rcptId = dep.receipt_id || generateReceiptId();
+  addReceipt({
+    receiptId:    rcptId,
+    action:       'badgr run',
+    deploymentId: dep.deployment_id,
+    provider:     dep.provider,
+    gpu:          dep.gpu_type,
+    status:       dep.status,
+    createdAt:    new Date().toISOString(),
+  });
+
+  console.log(chalk.bold(`\n  Job ID:    ${chalk.cyan(dep.deployment_id)}`));
+  console.log(`  ${chalk.bold('Provider:')} ${dep.provider}`);
+  console.log(`  ${chalk.bold('GPU:')}      ${dep.gpu_type} × ${dep.gpu_count}`);
+  if (dep.cost_per_hour > 0) console.log(`  ${chalk.bold('Rate:')}     $${dep.cost_per_hour.toFixed(2)}/hr`);
+  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
+
+  if (detach) {
+    console.log(`\n  ${chalk.bold('Logs:')}     ${dep.logs_url || `badgr logs ${dep.deployment_id}`}`);
+    console.log(chalk.dim(`\n  Detached. Track progress: badgr logs ${dep.deployment_id}\n`));
+    return;
+  }
+
+  // ── Attached mode: stream logs until job completes ───────────────────────
+  console.log(chalk.dim('\n  ── Attaching (Ctrl+C to detach) ──────────────────────────────\n'));
+
+  const finalStatus = await attachToJob(config, dep.deployment_id, chalk);
+
+  console.log();
+
+  if (finalStatus === 'failed') {
+    console.error(chalk.red(`\n  ✗ Job failed (${dep.deployment_id})\n`));
+    console.error(chalk.dim(`  Logs: badgr logs ${dep.deployment_id}\n`));
+    process.exit(1);
+  } else {
+    console.log(chalk.green(`\n  ✓ Job complete (${finalStatus})\n`));
+  }
+}

package/src/commands/serve.js

@@ -0,0 +1,160 @@
+import { requireApiKey } from '../config.js';
+import { callApi } from '../api.js';
+import { addDeployment, addReceipt, generateReceiptId } from '../store.js';
+
+/**
+ * badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
+ *
+ * Provisions a persistent vLLM endpoint, health-checks it before printing
+ * "Endpoint ready", and returns an OpenAI-compatible base URL.
+ * Stop billing with `badgr down <id>`.
+ */
+export function parseServeArgs(args) {
+  const flags = {};
+  const positional = [];
+  let i = 0;
+  while (i < args.length) {
+    if (args[i] === '--gpu')        { flags.gpu = args[++i]; i++; continue; }
+    if (args[i] === '--count')      { flags.count = parseInt(args[++i], 10); i++; continue; }
+    if (args[i] === '--region')     { flags.region = args[++i]; i++; continue; }
+    if (args[i] === '--max-price')  { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
+    if (args[i] === '--name')       { flags.name = args[++i]; i++; continue; }
+    if (args[i] === '--no-wait')    { flags.noWait = true; i++; continue; }
+    positional.push(args[i++]);
+  }
+  const model = positional[0] || null;
+  return { model, flags };
+}
+
+// Poll GET <endpointUrl>/models until it returns 200 or timeout expires.
+// Returns true if healthy, false if timed out.
+async function waitForEndpoint(endpointUrl, timeoutMs = 5 * 60 * 1000, chalk) {
+  const deadline = Date.now() + timeoutMs;
+  const modelsUrl = `${endpointUrl}/models`;
+  let attempt = 0;
+
+  while (Date.now() < deadline) {
+    attempt++;
+    try {
+      const res = await fetch(modelsUrl, { signal: AbortSignal.timeout(8000) });
+      if (res.ok) return true;
+    } catch {
+      // network not up yet — keep polling
+    }
+    const elapsed = Math.round((Date.now() - (deadline - timeoutMs)) / 1000);
+    process.stdout.write(
+      `\r  ${chalk.dim(`Waiting for endpoint… ${elapsed}s (attempt ${attempt})`)}   `
+    );
+    await new Promise(r => setTimeout(r, 8000));
+  }
+  process.stdout.write('\n');
+  return false;
+}
+
+export async function serveCommand(config, args, chalk) {
+  const { model, flags } = parseServeArgs(args);
+
+  if (!model) {
+    console.error(chalk.red('Usage: badgr serve <model> --gpu <type>'));
+    console.error(chalk.red('       badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  const gpu = flags.gpu || 'L40S';
+
+  console.log(chalk.bold('\n🚀 Serving model\n'));
+  console.log(`  ${chalk.bold('Model:')}  ${model}`);
+  console.log(`  ${chalk.bold('GPU:')}    ${gpu}`);
+  console.log();
+  console.log(chalk.dim('  Provisioning vLLM endpoint (own GPUs → overflow providers)...'));
+
+  let dep;
+  try {
+    dep = await callApi('/serve', {
+      method: 'POST',
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      body: {
+        model,
+        gpu: gpu.toUpperCase().replace('-', '_'),
+        gpu_count: flags.count || 1,
+        region: flags.region || 'US',
+        max_price_per_hour: flags.maxPrice,
+        name: flags.name,
+      },
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Serve failed: ${err.message}\n`));
+    return;
+  }
+
+  // Mirror to local store so badgr down/status/receipts work offline
+  addDeployment({
+    id:          dep.deployment_id,
+    name:        dep.name,
+    type:        'endpoint',
+    model:       dep.model || model,
+    gpu:         dep.gpu_type,
+    count:       dep.gpu_count,
+    provider:    dep.provider,
+    status:      dep.status,
+    endpointUrl: dep.endpoint_url || dep.openai_base_url,
+    receiptId:   dep.receipt_id,
+    createdAt:   new Date().toISOString(),
+    costPerHour: dep.cost_per_hour || 0,
+  });
+
+  const rcptId = dep.receipt_id || generateReceiptId();
+  addReceipt({
+    receiptId:    rcptId,
+    action:       'badgr serve',
+    deploymentId: dep.deployment_id,
+    provider:     dep.provider,
+    gpu:          dep.gpu_type,
+    status:       dep.status,
+    createdAt:    new Date().toISOString(),
+  });
+
+  const endpointUrl = dep.endpoint_url || dep.openai_base_url || config.baseUrl;
+
+  // ── Health check before declaring "ready" ─────────────────────────────────
+  let endpointReady = false;
+
+  if (flags.noWait) {
+    console.log(chalk.yellow('\n⏳ Endpoint provisioning (skipped health check — use --no-wait)\n'));
+  } else {
+    console.log(chalk.dim('\n  Health-checking endpoint (up to 5 min)...'));
+    endpointReady = await waitForEndpoint(endpointUrl, 5 * 60 * 1000, chalk);
+    process.stdout.write('\n');
+  }
+
+  // ── Print result ──────────────────────────────────────────────────────────
+  if (endpointReady) {
+    console.log(chalk.green('✓ Endpoint ready\n'));
+  } else {
+    console.log(chalk.yellow('⏳ Endpoint starting\n'));
+    console.log(chalk.dim(`  Not yet responding. Check status:`));
+    console.log(chalk.dim(`    badgr status`));
+    console.log(chalk.dim(`    curl ${endpointUrl}/models`));
+    console.log();
+  }
+
+  console.log(`  ${chalk.bold('Deployment:')} ${chalk.cyan(dep.deployment_id)}`);
+  console.log(`  ${chalk.bold('Model:')}      ${dep.model || model}`);
+  console.log(`  ${chalk.bold('GPU:')}        ${dep.gpu_type} × ${dep.gpu_count}`);
+  console.log(`  ${chalk.bold('Provider:')}   ${dep.provider}`);
+  console.log(`  ${chalk.bold('Endpoint:')}   ${chalk.cyan(endpointUrl)}`);
+  if (dep.cost_per_hour > 0) console.log(`  ${chalk.bold('Rate:')}       $${dep.cost_per_hour.toFixed(2)}/hr`);
+  console.log(`\n  ${chalk.bold('Receipt:')}    ${chalk.dim(rcptId)}`);
+
+  if (endpointReady) {
+    console.log(`\n  ${chalk.bold('Use with OpenAI SDK:')}`);
+    console.log(chalk.dim(`    from openai import OpenAI`));
+    console.log(chalk.dim(`    client = OpenAI(api_key="${config.apiKey?.slice(0, 8) || 'sk-...'}...", base_url="${endpointUrl}")`));
+    console.log(chalk.dim(`    resp = client.chat.completions.create(model="${dep.model || model}", messages=[...])`));
+  }
+
+  console.log(`\n  ${chalk.dim(`Stop billing: badgr down ${dep.deployment_id}`)}\n`);
+}

package/src/commands/shell.js

@@ -0,0 +1,21 @@
+import { findCheapest, findById } from '../router.js';
+import { requireApiKey } from '../config.js';
+
+export async function shellCommand(config, args, chalk) {
+  const gpuFlag = args.indexOf('--gpu');
+  const gpuId = gpuFlag !== -1 ? args[gpuFlag + 1] : null;
+
+  requireApiKey(config);
+
+  const gpu = gpuId ? findById(gpuId) : findCheapest({ tag: 'dev' });
+
+  console.log(chalk.bold('\n💻 GPU Shell\n'));
+  if (gpu) {
+    console.log(`  ${chalk.bold('GPU:')}  ${gpu.name}  ${chalk.dim(`$${gpu.ratePerHour}/hr`)}\n`);
+  }
+
+  // Real implementation: provision an instance, then SSH/exec into it
+  console.log(chalk.dim('  Provisioning instance...'));
+  console.log(chalk.yellow('\n  GPU shell requires a running deployment.'));
+  console.log(chalk.dim('  First deploy with `gpu deploy <script.py>`, then connect with `gpu shell`.\n'));
+}

package/src/commands/status.js

@@ -0,0 +1,97 @@
+import { listDeployments as localDeployments } from '../store.js';
+import { listDeployments as apiDeployments } from '../api.js';
+
+export async function statusCommand(config, args, chalk) {
+  console.log(chalk.bold('\n📊 GPU Status\n'));
+
+  let deployments = [];
+
+  // ── Live data from the backend ────────────────────────────────────────────
+  if (config.apiKey) {
+    try {
+      const data = await apiDeployments(config);
+      deployments = data?.deployments ?? [];
+    } catch (err) {
+      console.log(chalk.yellow(`  Could not reach API: ${err.message}. Showing local state.\n`));
+      deployments = localDeployments().map(d => ({
+        deployment_id: d.id,
+        name: d.name,
+        workload_type: d.type,
+        gpu_type: d.gpu,
+        gpu_count: d.count,
+        provider: d.provider,
+        status: d.status,
+        cost_per_hour: d.costPerHour,
+        endpoint_url: d.endpointUrl,
+        model: d.model,
+      }));
+    }
+  } else {
+    deployments = localDeployments().map(d => ({
+      deployment_id: d.id,
+      name: d.name,
+      workload_type: d.type,
+      gpu_type: d.gpu,
+      gpu_count: d.count,
+      provider: d.provider,
+      status: d.status,
+      cost_per_hour: d.costPerHour,
+      endpoint_url: d.endpointUrl,
+      model: d.model,
+    }));
+  }
+
+  if (deployments.length === 0) {
+    console.log(chalk.dim('  No active deployments.'));
+    console.log(chalk.dim('  Run `badgr serve <model> --gpu L40S` to provision one.\n'));
+    return;
+  }
+
+  const cols = { name: 16, type: 9, gpu: 11, provider: 12, status: 14, rate: 9 };
+
+  const header =
+    'Name'.padEnd(cols.name) +
+    'Type'.padEnd(cols.type) +
+    'GPU'.padEnd(cols.gpu) +
+    'Provider'.padEnd(cols.provider) +
+    'Status'.padEnd(cols.status) +
+    'Rate/hr';
+  console.log('  ' + chalk.bold(header));
+  console.log('  ' + '─'.repeat(Object.values(cols).reduce((a, b) => a + b, 0) + 8));
+
+  deployments.forEach(d => {
+    const statusColor = d.status === 'running'
+      ? chalk.green(d.status.padEnd(cols.status))
+      : d.status === 'provisioning'
+        ? chalk.yellow(d.status.padEnd(cols.status))
+        : chalk.dim(d.status.padEnd(cols.status));
+    const rate = d.cost_per_hour > 0 ? `$${d.cost_per_hour.toFixed(2)}` : 'own-host';
+    const name = (d.name || d.deployment_id || '').slice(0, cols.name - 1);
+    const provider = (d.provider || '—').padEnd(cols.provider);
+    const gpu = (d.gpu_type || '—').slice(0, cols.gpu - 1).padEnd(cols.gpu);
+    console.log(
+      '  ' +
+      name.padEnd(cols.name) +
+      (d.workload_type || '—').padEnd(cols.type) +
+      gpu +
+      provider +
+      statusColor +
+      rate
+    );
+  });
+
+  console.log();
+
+  // Show endpoint URLs for running endpoint deployments
+  const endpoints = deployments.filter(d => d.workload_type === 'endpoint' && d.status === 'running');
+  if (endpoints.length > 0) {
+    console.log(chalk.bold('  Endpoints\n'));
+    endpoints.forEach(d => {
+      const url = d.endpoint_url || config.baseUrl;
+      console.log(`  ${chalk.cyan(d.name || d.deployment_id)}`);
+      console.log(`    ${chalk.dim('URL:')}    ${url}`);
+      if (d.model) console.log(`    ${chalk.dim('model:')} ${d.model}`);
+    });
+    console.log();
+  }
+}