badgr-cli 1.1.4 → 1.1.6

package/src/commands/down.js

@@ -1,6 +1,6 @@
-import { requireApiKey } from '../config.js';
+import { ensureLoggedInReady, withReauthRetry } from '../onboarding.js';
 import { findDeployment, removeDeployment, addReceipt, generateReceiptId } from '../store.js';
-import { terminateDeployment, listDeployments } from '../api.js';
+import { terminateDeployment, listDeployments, adminTerminateDeployment } from '../api.js';
 
 function formatRuntime(minutes) {
   if (minutes < 60) return `${minutes}m`;
@@ -12,8 +12,9 @@ function formatRuntime(minutes) {
 }
 
 export async function downCommand(config, args, chalk) {
-  const hasAll = args.includes('--all');
-  const hasYes = args.includes('--yes') || args.includes('-y');
+  const hasAll   = args.includes('--all');
+  const hasYes   = args.includes('--yes') || args.includes('-y');
+  const isAdmin  = args.includes('--admin');
 
   if (hasAll) {
     return _downAll(config, chalk, hasYes);
@@ -23,12 +24,43 @@ export async function downCommand(config, args, chalk) {
 
   if (!idOrName) {
     console.error(chalk.red('Usage: badgr down <deployment-id|name>'));
-    console.error(chalk.dim('       badgr down --all          stop everything'));
-    console.error(chalk.dim('       badgr down --all --yes    stop everything without confirmation'));
+    console.error(chalk.dim('       badgr down --all              stop everything in your own account'));
+    console.error(chalk.dim('       badgr down --all --yes        stop everything without confirmation'));
+    console.error(chalk.dim('       badgr down <id> --admin       admin-only: stop any account\'s deployment'));
     return;
   }
 
-  requireApiKey(config);
+  config = await ensureLoggedInReady(config, chalk);
+
+  // --admin bypasses per-user ownership (michaelhireitem@gmail.com only --
+  // see deployment_routes.py's DELETE /v1/admin/deployments/{id}) so a
+  // deployment found via `badgr status --admin` (owned by a different
+  // account) can actually be stopped. Local name lookup only applies to the
+  // caller's own deployments, so it's skipped here -- an admin shutdown
+  // always targets a real deployment_id from `badgr status --admin`.
+  if (isAdmin) {
+    process.stdout.write(chalk.dim(`  [admin] Stopping ${idOrName}...`));
+    try {
+      const refreshed = await withReauthRetry(config, chalk, cfg => adminTerminateDeployment(cfg, idOrName));
+      config = refreshed.config;
+      const dep = refreshed.result;
+      process.stdout.write('\n');
+      const teardownConfirmed = dep.teardown_ok === 'ok';
+      if (teardownConfirmed) {
+        console.log(chalk.green('\n✓ Stopped'));
+        console.log(chalk.green(`  Billing ended for ${dep.user_email || dep.user_id || 'owner'}\n`));
+      } else {
+        console.log(chalk.yellow('\n⚠ Stop requested but not confirmed'));
+        console.log(chalk.yellow(`  Resource may still be billing — retry \`badgr down ${idOrName} --admin\`\n`));
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      process.stdout.write('\n');
+      console.error(chalk.red(`\n  ✗ Could not stop deployment: ${err.message}\n`));
+      process.exitCode = 1;
+    }
+    return;
+  }
 
   const localDep     = findDeployment(idOrName);
   const deploymentId = localDep?.id ?? idOrName;
@@ -37,21 +69,29 @@ export async function downCommand(config, args, chalk) {
 
   let dep;
   try {
-    dep = await terminateDeployment(config, deploymentId);
+    const refreshed = await withReauthRetry(config, chalk, cfg => terminateDeployment(cfg, deploymentId));
+    config = refreshed.config;
+    dep = refreshed.result;
   } catch (err) {
     process.stdout.write('\n');
     console.error(chalk.red(`\n  ✗ Could not stop deployment: ${err.message}\n`));
+    process.exitCode = 1;
     return;
   }
 
   process.stdout.write('\n');
 
-  // Compute final cost from the deployment timestamps
+  // The backend owns billing truth. Its accrued value includes billable
+  // provisioning/startup and failed fallback attempts, while started_at
+  // alone cannot reconstruct those intervals.
   const stoppedAt   = dep.stopped_at  ?? (Date.now() / 1000);
   const startedAt   = dep.started_at  ?? stoppedAt;
   const runtimeMin  = Math.round((stoppedAt - startedAt) / 60);
   const runtimeHr   = (stoppedAt - startedAt) / 3600;
-  const finalCost   = (dep.cost_per_hour || 0) * runtimeHr;
+  const timestampCost = (dep.cost_per_hour || 0) * runtimeHr;
+  const finalCost   = dep.accrued_cost_usd == null
+    ? timestampCost
+    : Number(dep.accrued_cost_usd);
 
   // dep.teardown_ok reflects whether the provider resource was actually
   // confirmed gone (not just that the DELETE call didn't throw) — a 200
@@ -79,6 +119,7 @@ export async function downCommand(config, args, chalk) {
   } else {
     console.log(chalk.yellow('\n⚠ Stop requested but not confirmed'));
     console.log(chalk.yellow(`  Resource may still be billing — check \`badgr status\` and retry \`badgr down ${deploymentId}\`\n`));
+    process.exitCode = 1;
   }
   console.log(`  ${chalk.bold('Runtime:')}    ${formatRuntime(runtimeMin)}`);
   if (finalCost > 0) console.log(`  ${chalk.bold('Final cost:')} $${finalCost.toFixed(4)}`);
@@ -86,13 +127,16 @@ export async function downCommand(config, args, chalk) {
 }
 
 async function _downAll(config, chalk, skipConfirm) {
-  requireApiKey(config);
+  config = await ensureLoggedInReady(config, chalk);
 
   let result;
   try {
-    result = await listDeployments(config);
+    const refreshed = await withReauthRetry(config, chalk, cfg => listDeployments(cfg));
+    config = refreshed.config;
+    result = refreshed.result;
   } catch (err) {
     console.error(chalk.red(`\n  ✗ Could not fetch deployments: ${err.message}\n`));
+    process.exitCode = 1;
     return;
   }
 
@@ -129,12 +173,15 @@ async function _downAll(config, chalk, skipConfirm) {
 
   let stoppedCount = 0;
   let unconfirmedCount = 0;
+  let errorCount = 0;
   let totalCost = 0;
 
   for (const dep of active) {
     process.stdout.write(chalk.dim(`  Stopping ${dep.deployment_id}...`));
     try {
-      const stopped = await terminateDeployment(config, dep.deployment_id);
+      const refreshed = await withReauthRetry(config, chalk, cfg => terminateDeployment(cfg, dep.deployment_id));
+      config = refreshed.config;
+      const stopped = refreshed.result;
       const stoppedAt = stopped.stopped_at ?? (Date.now() / 1000);
       const startedAt = stopped.started_at ?? stoppedAt;
       const cost      = (stopped.cost_per_hour || 0) * (stoppedAt - startedAt) / 3600;
@@ -163,6 +210,7 @@ async function _downAll(config, chalk, skipConfirm) {
       });
     } catch (err) {
       process.stdout.write(chalk.red(` ✗ ${err.message}\n`));
+      errorCount++;
     }
   }
 
@@ -170,6 +218,13 @@ async function _downAll(config, chalk, skipConfirm) {
   if (unconfirmedCount > 0) {
     console.log(chalk.yellow(`  ${unconfirmedCount} deployment(s) not confirmed stopped — may still be billing, check \`badgr status\`\n`));
   }
+  if (errorCount > 0) {
+    console.log(chalk.red(`  ${errorCount} deployment(s) failed to stop — check \`badgr status\` and retry\n`));
+  }
   if (totalCost > 0) console.log(`  Estimated total: $${totalCost.toFixed(4)}`);
-  console.log(chalk.green('  Billing ended\n'));
+  if (unconfirmedCount > 0 || errorCount > 0) {
+    process.exitCode = 1;
+  } else {
+    console.log(chalk.green('  Billing ended\n'));
+  }
 }

package/src/commands/embed.js

@@ -10,7 +10,7 @@
  *   badgr embed BAAI/bge-large-en-v1.5 s3://bucket/corpus.jsonl
  */
 import { readFileSync, existsSync, statSync } from 'fs';
-import { requireApiKey } from '../config.js';
+import { ensureBadgrReady } from '../onboarding.js';
 import { addReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback } from '../fallback.js';
 import { monitorBatchJob, fmtRuntime } from '../batch.js';
@@ -90,7 +90,7 @@ export async function embedCommand(config, args, chalk) {
     return;
   }
 
-  requireApiKey(config);
+  config = await ensureBadgrReady(config, chalk);
 
   const resolved = resolveEmbedInput(input);
   if (resolved.error) {

package/src/commands/heartbeat.js

@@ -1,4 +1,4 @@
-import { requireApiKey } from '../config.js';
+import { ensureLoggedInReady, withReauthRetry } from '../onboarding.js';
 import { findDeployment } from '../store.js';
 import { heartbeatDeployment } from '../api.js';
 
@@ -20,13 +20,13 @@ export async function heartbeatCommand(config, args, chalk) {
     return;
   }
 
-  requireApiKey(config);
+  config = await ensureLoggedInReady(config, chalk);
 
   const localDep     = findDeployment(idOrName);
   const deploymentId = localDep?.id ?? idOrName;
 
   try {
-    const result = await heartbeatDeployment(config, deploymentId);
+    const { result } = await withReauthRetry(config, chalk, cfg => heartbeatDeployment(cfg, deploymentId));
     console.log(chalk.green(`  ✓ Heartbeat recorded for ${deploymentId}`));
     if (result.last_activity_at) {
       console.log(chalk.dim(`    last_activity_at: ${new Date(result.last_activity_at * 1000).toISOString()}`));

package/src/commands/job.js

@@ -1,5 +1,6 @@
 import { callApi } from '../api.js';
 import { requireApiKey } from '../config.js';
+import { ensureBadgrReady } from '../onboarding.js';
 
 /**
  * badgr job <agent> "<instruction>" --check "npm test"
@@ -115,9 +116,19 @@ export async function jobCommand(config, args, chalk) {
 export async function runJob(config, opts, chalk) {
   const { agent: agentName, instruction: instructionText, check } = opts;
 
-  // Require API key — jobs are tracked under the user account.
-  const apiKey = requireApiKey(config, chalk);
-  if (!apiKey) return;
+  // Just-in-time login — same flow badgr run/serve/comfyui trigger: if not
+  // logged in, opens a browser login link and blocks right here until it
+  // completes, then this function keeps running with the now-populated
+  // config — no separate `badgr login` step, and the job's own progress/
+  // logs print in this same terminal once auth resolves. A dry run only
+  // previews the plan and never provisions/spends, so it keeps the old
+  // fail-fast behavior instead of opening a browser (matches run.js).
+  if (opts.dryRun) {
+    requireApiKey(config, chalk);
+  } else {
+    config = await ensureBadgrReady(config, chalk);
+  }
+  const apiKey = config.apiKey;
 
   const provider = opts.provider ?? null;
   const model = opts.model ?? null;

package/src/commands/login.js

@@ -51,7 +51,10 @@ export async function loginCommand(chalk, saveConfigFn, args = []) {
         }
       }
 
-      const config = await ensureLoggedIn({ ...DEFAULTS }, chalk);
+      // Keep the configured API origin. Local development needs the browser
+      // to complete the session on localhost, not against the production
+      // backend's unrelated CLI-session store.
+      const config = await ensureLoggedIn({ ...DEFAULTS, baseUrl: existing.baseUrl }, chalk);
       console.log(chalk.dim(`  Run ${chalk.cyan('badgr run python train.py')} to launch your first job.\n`));
       return config;
     }

package/src/commands/logs.js

@@ -1,18 +1,16 @@
 import { findDeployment, listDeployments } from '../store.js';
-import { requireApiKey } from '../config.js';
+import { ensureLoggedInReady, withReauthRetry } from '../onboarding.js';
 import { getDeploymentLogs, callApi } from '../api.js';
+import { isMetaLogLine, isErrorLogLine } from '../deploymentLog.js';
 
 const TERMINAL_STATUSES = new Set(['succeeded', 'completed', 'failed', 'stopped', 'terminated']);
 const FOLLOW_POLL_MS = 3000;
 
-// Lines that carry structured metadata shown elsewhere (status bar in `badgr run`).
-const LOG_META_RE = /^\[dep-[^\]]+\] (status|gpu|region|endpoint|cost|receipt|provider_status|uptime)=/;
-
 export async function logsCommand(config, args, chalk) {
   const idOrName = args.find(a => !a.startsWith('--'));
   const follow   = args.includes('--follow') || args.includes('-f');
 
-  requireApiKey(config);
+  config = await ensureLoggedInReady(config, chalk);
 
   if (!idOrName) {
     const deps = listDeployments();
@@ -35,14 +33,17 @@ export async function logsCommand(config, args, chalk) {
   // Fetch and print initial batch of logs.
   const seen = new Set();
   try {
-    const data = await getDeploymentLogs(config, deploymentId);
+    const { config: refreshed, result: data } = await withReauthRetry(
+      config, chalk, cfg => getDeploymentLogs(cfg, deploymentId),
+    );
+    config = refreshed;
     const lines = data?.logs ?? [];
     if (lines.length === 0 && !follow) {
       console.log(chalk.dim('  No log lines available yet.\n'));
     } else {
       for (const line of lines) {
         seen.add(line);
-        if (!LOG_META_RE.test(line)) console.log(`  ${chalk.dim(line)}`);
+        if (!isMetaLogLine(line)) console.log(`  ${chalk.dim(line)}`);
       }
     }
   } catch (err) {
@@ -68,26 +69,42 @@ export async function logsCommand(config, args, chalk) {
 
     let status = null;
     try {
-      const dep = await callApi(`/deployments/${deploymentId}`, {
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-      });
+      const { config: refreshed, result: dep } = await withReauthRetry(
+        config, chalk,
+        cfg => callApi(`/deployments/${deploymentId}`, { apiKey: cfg.apiKey, baseUrl: cfg.baseUrl }),
+      );
+      config = refreshed;
       status = dep?.status ?? null;
-    } catch {
-      // network blip — keep following
+    } catch (err) {
+      // withReauthRetry already attempted exactly one bounded reauth for a
+      // 401/403 -- if it still failed, don't loop forever pretending to
+      // follow: fail visibly instead of looking silently hung.
+      if (err.httpStatus === 401 || err.httpStatus === 403) {
+        console.error(chalk.red(`\n  ✗ AUTH_FAILED: ${err.message}\n`));
+        process.exitCode = 1;
+        return;
+      }
+      // network blip -- keep following
     }
 
     try {
-      const data = await getDeploymentLogs(config, deploymentId);
+      const { config: refreshed, result: data } = await withReauthRetry(
+        config, chalk, cfg => getDeploymentLogs(cfg, deploymentId),
+      );
+      config = refreshed;
       for (const line of (data?.logs ?? [])) {
         if (seen.has(line)) continue;
         seen.add(line);
-        if (!LOG_META_RE.test(line)) {
-          const isErr = /^error\b/i.test(line) || /Error response from daemon/i.test(line);
-          console.log(`  ${isErr ? chalk.red(line) : chalk.dim(line)}`);
+        if (!isMetaLogLine(line)) {
+          console.log(`  ${isErrorLogLine(line) ? chalk.red(line) : chalk.dim(line)}`);
         }
       }
-    } catch {
+    } catch (err) {
+      if (err.httpStatus === 401 || err.httpStatus === 403) {
+        console.error(chalk.red(`\n  ✗ AUTH_FAILED: ${err.message}\n`));
+        process.exitCode = 1;
+        return;
+      }
       // logs endpoint temporarily unavailable
     }
 

package/src/commands/pull.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { spawnSync } from 'child_process';
-import { requireApiKey } from '../config.js';
+import { ensureLoggedInReady, withReauthRetry } from '../onboarding.js';
 import { downloadAndExtractArtifact } from '../artifactDownload.js';
 
 function runGit(args, options = {}) {
@@ -67,7 +67,7 @@ function findPatchFile(dir) {
 }
 
 export async function pullCommand(config, args, chalk) {
-  requireApiKey(config);
+  config = await ensureLoggedInReady(config, chalk);
   const { deploymentId, flags } = parsePullArgs(args);
   if (!deploymentId) {
     console.error(chalk.red('\n  Usage: badgr pull <deployment-id> [--diff-only|--branch|--yes]\n'));
@@ -84,7 +84,8 @@ export async function pullCommand(config, args, chalk) {
 
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `badgr-pull-${deploymentId}-`));
   try {
-    await downloadAndExtractArtifact(config, deploymentId, tmp);
+    const refreshed = await withReauthRetry(config, chalk, cfg => downloadAndExtractArtifact(cfg, deploymentId, tmp));
+    config = refreshed.config;
     const patchFile = findPatchFile(tmp);
     if (!patchFile) {
       // Not every run changes code — a test/eval command with --artifacts

package/src/commands/rerun.js

@@ -1,4 +1,4 @@
-import { requireApiKey } from '../config.js';
+import { ensureBadgrReady, withReauthRetry } from '../onboarding.js';
 import { findDeployment, addDeployment, addReceipt, generateReceiptId } from '../store.js';
 import { rerunDeployment } from '../api.js';
 
@@ -18,7 +18,7 @@ export async function rerunCommand(config, args, chalk) {
     return;
   }
 
-  requireApiKey(config);
+  config = await ensureBadgrReady(config, chalk);
 
   const localDep     = findDeployment(idOrName);
   const deploymentId = localDep?.id ?? idOrName;
@@ -27,7 +27,9 @@ export async function rerunCommand(config, args, chalk) {
 
   let dep;
   try {
-    dep = await rerunDeployment(config, deploymentId);
+    const refreshed = await withReauthRetry(config, chalk, cfg => rerunDeployment(cfg, deploymentId));
+    config = refreshed.config;
+    dep = refreshed.result;
   } catch (err) {
     process.stdout.write('\n');
     console.error(chalk.red(`\n  ✗ Could not rerun deployment: ${err.message}\n`));

package/src/commands/restart.js

@@ -1,4 +1,4 @@
-import { requireApiKey } from '../config.js';
+import { ensureBadgrReady, withReauthRetry } from '../onboarding.js';
 import { findDeployment, removeDeployment, addDeployment, addReceipt, generateReceiptId } from '../store.js';
 import { restartDeployment } from '../api.js';
 
@@ -17,7 +17,7 @@ export async function restartCommand(config, args, chalk) {
     return;
   }
 
-  requireApiKey(config);
+  config = await ensureBadgrReady(config, chalk);
 
   const localDep     = findDeployment(idOrName);
   const deploymentId = localDep?.id ?? idOrName;
@@ -26,7 +26,9 @@ export async function restartCommand(config, args, chalk) {
 
   let dep;
   try {
-    dep = await restartDeployment(config, deploymentId);
+    const refreshed = await withReauthRetry(config, chalk, cfg => restartDeployment(cfg, deploymentId));
+    config = refreshed.config;
+    dep = refreshed.result;
   } catch (err) {
     process.stdout.write('\n');
     console.error(chalk.red(`\n  ✗ Could not restart deployment: ${err.message}\n`));

package/src/commands/run.js

@@ -13,6 +13,7 @@ import { detectWorkload, workloadTypeLabel } from '../detect.js';
 import { ensureBadgrReady } from '../onboarding.js';
 import { VM_CLASSES, parseGbSize } from '../spec.js';
 import { parseEnvFlag } from '../envFlag.js';
+import { isMetaLogLine, isErrorLogLine, parseProviderStatusLine } from '../deploymentLog.js';
 
 function vmClassLine(sizeKey) {
   const vmClass = VM_CLASSES[sizeKey];
@@ -177,23 +178,6 @@ export function classifyFailure(finalStatus, exitCode) {
   return null;
 }
 
-// Lines the log stream never needs to print — we surface them in the status bar instead.
-const LOG_META_RE = /^\[dep-[^\]]+\] (status|gpu|region|cost|receipt|provider_status|uptime)=/;
-
-// Extract structured values from provider status lines so we can show them nicely.
-function parseProviderLine(line) {
-  const gpuUtil  = line.match(/\bgpu_util=([\d.]+)%/);
-  const cpuUtil  = line.match(/\bcpu_util=([\d.]+)%/);
-  const ssh      = line.match(/\bssh=(\S+)/);
-  const provSt   = line.match(/\bprovider_status=(\S+)/);
-  return {
-    gpuUtil:  gpuUtil  ? parseFloat(gpuUtil[1])  : null,
-    cpuUtil:  cpuUtil  ? parseFloat(cpuUtil[1])  : null,
-    ssh:      ssh      ? ssh[1]                  : null,
-    providerStatus: provSt ? provSt[1]           : null,
-  };
-}
-
 // Wait for status to leave 'starting'/'queued'/'provisioning'.
 // Returns the dep once it leaves startup states (or the last known state on timeout).
 async function waitForRunning(config, depId, chalk) {
@@ -354,7 +338,7 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
         const lines = logData?.logs ?? [];
 
         for (const line of lines) {
-          const parsed = parseProviderLine(line);
+          const parsed = parseProviderStatusLine(line);
           if (parsed.gpuUtil  !== null) gpuUtil = parsed.gpuUtil;
           if (parsed.cpuUtil  !== null) cpuUtil = parsed.cpuUtil;
 
@@ -367,12 +351,10 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
 
           if (seenContent.has(line)) continue;
           seenContent.add(line);
-          if (LOG_META_RE.test(line)) continue;
-          if (/\b(gpu_util|cpu_util|provider_status|uptime)=/.test(line)) continue;
+          if (isMetaLogLine(line)) continue;
 
-          const isErrorLine = /^error\b/i.test(line) || /Error response from daemon/i.test(line);
           stopTicker();
-          console.log(`  ${isErrorLine ? chalk.red(line) : chalk.dim(line)}`);
+          console.log(`  ${isErrorLogLine(line) ? chalk.red(line) : chalk.dim(line)}`);
           startTicker();
         }
       } catch {
@@ -1048,7 +1030,7 @@ export async function runCommand(config, args, chalk, opts = {}) {
 
   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`));
+    console.log(chalk.dim(`\n  Detached. Watch it from your terminal: badgr logs ${dep.deployment_id} --follow\n`));
     return;
   }
 

package/src/commands/sbatch.js

@@ -15,6 +15,7 @@
  */
 import { resolve } from 'path';
 import { requireApiKey } from '../config.js';
+import { ensureBadgrReady } from '../onboarding.js';
 import { loadSlurmScript, envForArrayTask, SlurmParseError } from '../slurm.js';
 import { addReceipt, updateReceipt, generateReceiptId, selectedComputeFromDeployment } from '../store.js';
 import { normalizeTier, callWithFallback } from '../fallback.js';
@@ -164,7 +165,7 @@ export async function sbatchCommand(config, args, chalk) {
     return;
   }
 
-  requireApiKey(config);
+  config = await ensureBadgrReady(config, chalk);
 
   const arrayJobId = isArray ? generateReceiptId() : null;