@polderlabs/bizar 4.5.1 → 4.7.0

package/cli/commands/minimax.mjs

@@ -0,0 +1,265 @@
+/**
+ * cli/commands/minimax.mjs
+ *
+ * MiniMax Token Plan integration CLI.
+ * v4.5.0+ — status, remains, test, config, clear, reset-onboarding.
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const HOME = homedir();
+const BIZAR_HOME = join(HOME, '.config', 'bizar');
+
+// ── Dashboard connection ────────────────────────────────────────────────────────
+
+function readDashboardConn() {
+  const portFile = join(BIZAR_HOME, 'dashboard.port');
+  const authFile = join(BIZAR_HOME, 'dashboard-secret');
+  let port = 4321;
+  let secret = '';
+  try {
+    if (existsSync(portFile)) {
+      const parsed = parseInt(readFileSync(portFile, 'utf8').trim(), 10);
+      if (Number.isFinite(parsed) && parsed > 0) port = parsed;
+    }
+  } catch { /* ignore */ }
+  try {
+    if (existsSync(authFile)) secret = readFileSync(authFile, 'utf8').trim();
+  } catch { /* ignore */ }
+  return { port, secret };
+}
+
+async function minimaxApi(path, opts = {}) {
+  const { port, secret } = readDashboardConn();
+  const url = `http://127.0.0.1:${port}${path}`;
+  const headers = { 'content-type': 'application/json', accept: 'application/json' };
+  if (secret) headers.authorization = `Basic ${Buffer.from(`opencode:${secret}`).toString('base64')}`;
+  const method = (opts.method || 'GET').toUpperCase();
+  try {
+    const resp = await fetch(url, { method, headers, body: opts.body ? JSON.stringify(opts.body) : undefined });
+    const text = await resp.text();
+    let data = null;
+    try { data = text ? JSON.parse(text) : null; } catch { /* ignore */ }
+    if (!resp.ok) {
+      return { ok: false, error: `http_${resp.status}`, message: data?.message || data?.error || resp.statusText, status: resp.status };
+    }
+    return { ok: true, status: resp.status, data };
+  } catch (err) {
+    return { ok: false, error: 'network_error', message: err && err.message ? err.message : String(err) };
+  }
+}
+
+// ── Help ───────────────────────────────────────────────────────────────────────
+
+export function showMinimaxHelp() {
+  console.log(`
+  bizar minimax — Manage the MiniMax Token Plan integration
+
+  Usage:
+    bizar minimax status              Show whether the Subscription Key is configured
+                                       and where it was resolved from (auth.json,
+                                       opencode.json, env var, or none).
+    bizar minimax remains              Fetch the live 5-hour + weekly remaining
+                                       quota per model. Shows reset times.
+    bizar minimax test                 Smoke-test the key with a one-shot chat
+                                       completion. Prints the usage block.
+    bizar minimax config <key>         Save a new Subscription Key to
+                                       ~/.local/share/opencode/auth.json. The
+                                       key never leaves this machine.
+    bizar minimax clear                Remove the Subscription Key from
+                                       opencode's auth.json.
+    bizar minimax reset-onboarding    Re-trigger the first-run wizard. Use
+                                       this if the key was changed outside the
+                                       dashboard and you want to re-enter it.
+
+  Flags:
+    --base-url <url>    Override the Token Plan host (default: https://www.minimax.io)
+    --chat-url  <url>    Override the chat-completions host (default: https://api.minimax.io/v1)
+    --yes                 Skip the confirmation prompt on 'clear' and 'reset-onboarding'
+  `);
+}
+
+// ── Subcommand handlers ─────────────────────────────────────────────────────────
+
+async function runMinimaxCommand(minimaxArgs) {
+  const sub = minimaxArgs[0];
+  const flags = minimaxArgs.slice(1).filter((a) => a.startsWith('-'));
+  const positional = minimaxArgs.slice(1).filter((a) => !a.startsWith('-'));
+  const yes = flags.includes('--yes') || flags.includes('-y');
+
+  if (!sub || sub === '--help' || sub === '-h' || flags.includes('--help') || flags.includes('-h')) {
+    showMinimaxHelp();
+    return;
+  }
+
+  if (sub === 'status') {
+    const r = await minimaxApi('/api/minimax/status');
+    if (!r.ok) {
+      console.error(chalk.red(`  ✗ ${r.message || r.error}`));
+      process.exit(1);
+    }
+    const s = r.data;
+    console.log('');
+    console.log(chalk.bold('  MiniMax Token Plan status'));
+    console.log('');
+    console.log(`    ${chalk.dim('configured:')}    ${s.configured ? chalk.green('yes') : chalk.red('no')}`);
+    console.log(`    ${chalk.dim('key source:')}    ${chalk.cyan(s.source)}`);
+    if (s.apiKeyHint) console.log(`    ${chalk.dim('key hint:')}      ${s.apiKeyHint}`);
+    console.log(`    ${chalk.dim('group id:')}     ${s.groupId}`);
+    console.log(`    ${chalk.dim('token host:')}   ${s.tokenBaseUrl}`);
+    console.log(`    ${chalk.dim('chat host:')}    ${s.chatBaseUrl}`);
+    console.log(`    ${chalk.dim('key format:')}   ${s.keyPatternValid === true ? chalk.green('ok') : s.keyPatternValid === false ? chalk.red('unexpected prefix') : chalk.dim('n/a')}`);
+    console.log('');
+    if (s.cache) {
+      console.log(`    ${chalk.dim('cached:')}         ${new Date(s.cache.fetchedAt).toLocaleString()} (${s.cache.modelCount} models)`);
+    } else {
+      console.log(`    ${chalk.dim('cached:')}         none yet — run \`bizar minimax remains\` to populate`);
+    }
+    return;
+  }
+
+  if (sub === 'remains') {
+    const r = await minimaxApi('/api/minimax/remains');
+    if (!r.ok) {
+      console.error(chalk.red(`  ✗ ${r.message || r.error}`));
+      process.exit(1);
+    }
+    if (!r.data?.ok) {
+      console.error(chalk.red(`  ✗ ${r.data?.message || r.data?.error || 'unknown'}`));
+      process.exit(1);
+    }
+    const data = r.data;
+    console.log('');
+    console.log(chalk.bold(`  MiniMax Token Plan quota  (${new Date(data.fetchedAt).toLocaleString()})`));
+    if (data.apiKeyHint) console.log(chalk.dim(`  Key: ${data.apiKeyHint} · source: ${data.keySource} · group: ${data.groupId}`));
+    console.log('');
+    for (const m of data.models || []) {
+      const five = m.current_interval_remaining_percent;
+      const week = m.current_weekly_remaining_percent;
+      const fiveBar = '█'.repeat(Math.round(five / 5)) + '░'.repeat(20 - Math.round(five / 5));
+      const weekBar = '█'.repeat(Math.round(week / 5)) + '░'.repeat(20 - Math.round(week / 5));
+      const fiveColor = five >= 75 ? chalk.green : five >= 25 ? chalk.yellow : chalk.red;
+      const weekColor = week >= 75 ? chalk.green : week >= 25 ? chalk.yellow : chalk.red;
+      console.log(`    ${chalk.bold(m.model_name)}`);
+      console.log(`      ${chalk.dim('5h:')}    ${fiveColor(five + '%'.padStart(4))} ${fiveBar}  resets in ${m.intervalResetInHuman}`);
+      console.log(`      ${chalk.dim('week:')}  ${weekColor(week + '%'.padStart(4))} ${weekBar}  resets in ${m.weeklyResetInHuman}`);
+      console.log('');
+    }
+    return;
+  }
+
+  if (sub === 'test') {
+    const prompt = positional[0] || 'Reply with the single word: pong';
+    const r = await minimaxApi('/api/minimax/test', {
+      method: 'POST',
+      body: { prompt, model: 'MiniMax-M3', maxTokens: 32 },
+    });
+    if (!r.ok) {
+      console.error(chalk.red(`  ✗ ${r.message || r.error}`));
+      process.exit(1);
+    }
+    const data = r.data;
+    if (!data?.ok) {
+      console.error(chalk.red(`  ✗ ${data?.message || data?.error || 'unknown'}`));
+      process.exit(1);
+    }
+    console.log('');
+    console.log(chalk.green('  ✓ Key works'));
+    console.log(`    ${chalk.dim('model:')}     ${data.model}`);
+    console.log(`    ${chalk.dim('finish:')}    ${data.finishReason}`);
+    if (data.content) console.log(`    ${chalk.dim('content:')}    ${JSON.stringify(data.content.slice(0, 80))}${data.content.length > 80 ? '…' : ''}`);
+    if (data.usage) {
+      console.log(`    ${chalk.dim('usage:')}      total=${data.usage.total_tokens} prompt=${data.usage.prompt_tokens} completion=${data.usage.completion_tokens}`);
+    }
+    return;
+  }
+
+  if (sub === 'config' || sub === 'set') {
+    const key = positional[0];
+    if (!key) {
+      console.error(chalk.red('  ✗ Missing key. Usage: bizar minimax config <sk-cp-…>'));
+      process.exit(1);
+    }
+    if (!/^sk-(cp|ant|or)-[A-Za-z0-9_-]{20,}$/.test(key)) {
+      console.error(chalk.red('  ✗ Key does not look like a MiniMax key (expected sk-cp-…, sk-ant-…, or sk-or-… prefix)'));
+      process.exit(1);
+    }
+    console.log(chalk.dim('  Saving to opencode auth.json…'));
+    const r = await minimaxApi('/api/minimax/onboarding/save-key', {
+      method: 'POST',
+      body: { key, groupId: 'default' },
+    });
+    if (!r.ok) {
+      console.error(chalk.red(`  ✗ ${r.message || r.error}`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`  ✓ Saved to ${r.data?.path}`));
+    console.log(`    ${chalk.dim('key hint:')} ${r.data?.apiKeyHint}`);
+    return;
+  }
+
+  if (sub === 'clear' || sub === 'remove') {
+    if (!yes) {
+      console.log(chalk.yellow(`  ⚠ This will remove the MiniMax Subscription Key from opencode's auth.json.`));
+      console.log(chalk.dim('  Continue? [y/N]'));
+      const buf = [];
+      process.stdin.setEncoding('utf8');
+      process.stdin.on('data', (c) => { buf.push(c); if (c.includes('\n')) process.stdin.pause(); });
+      await new Promise((resolve) => process.stdin.once('close', resolve));
+      const answer = buf.join('').trim().toLowerCase();
+      if (answer !== 'y' && answer !== 'yes') {
+        console.log(chalk.dim('  Cancelled.'));
+        return;
+      }
+    }
+    const authFile = join(HOME, '.local', 'share', 'opencode', 'auth.json');
+    let auth = {};
+    try {
+      if (existsSync(authFile)) auth = JSON.parse(readFileSync(authFile, 'utf8'));
+    } catch { /* ignore */ }
+    if (auth.minimax) {
+      delete auth.minimax;
+      writeFileSync(authFile, JSON.stringify(auth, null, 2) + '\n', 'utf8');
+      console.log(chalk.green('  ✓ MiniMax key removed from auth.json'));
+    } else {
+      console.log(chalk.dim('  No MiniMax key was configured.'));
+    }
+    return;
+  }
+
+  if (sub === 'reset-onboarding' || sub === 'reset') {
+    if (!yes) {
+      console.log(chalk.yellow('  ⚠ This will re-trigger the first-run MiniMax onboarding wizard.'));
+      console.log(chalk.dim('  Continue? [y/N]'));
+      const buf = [];
+      process.stdin.setEncoding('utf8');
+      process.stdin.on('data', (c) => { buf.push(c); if (c.includes('\n')) process.stdin.pause(); });
+      await new Promise((resolve) => process.stdin.once('close', resolve));
+      const answer = buf.join('').trim().toLowerCase();
+      if (answer !== 'y' && answer !== 'yes') {
+        console.log(chalk.dim('  Cancelled.'));
+        return;
+      }
+    }
+    const r = await minimaxApi('/api/minimax/onboarding', {
+      method: 'POST',
+      body: { dismissedAt: null },
+    });
+    if (!r.ok) {
+      console.error(chalk.red(`  ✗ ${r.message || r.error}`));
+      process.exit(1);
+    }
+    console.log(chalk.green('  ✓ Onboarding wizard will show on next dashboard load'));
+    return;
+  }
+
+  console.error(chalk.red(`  ✗ Unknown minimax subcommand: ${sub}`));
+  showMinimaxHelp();
+  process.exit(1);
+}
+
+export async function run(name, args, isHelpRequest) {
+  await runMinimaxCommand(args);
+}

package/cli/commands/mod.mjs

@@ -0,0 +1,185 @@
+/**
+ * cli/commands/mod.mjs
+ *
+ * Mod manager CLI — talks to the running dashboard's HTTP API.
+ * v3.20.5+ — install, upgrade, list, registry.
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const HOME = homedir();
+const BIZAR_HOME = join(HOME, '.config', 'bizar');
+
+// ── Config dir helper ──────────────────────────────────────────────────────────
+
+function getBizarConfigDir() {
+  if (process.platform === 'win32') {
+    return process.env.APPDATA
+      ? join(process.env.APPDATA, 'bizar')
+      : join(homedir(), '.config', 'bizar');
+  }
+  return process.env.XDG_CONFIG_HOME
+    ? join(process.env.XDG_CONFIG_HOME, 'bizar')
+    : join(homedir(), '.config', 'bizar');
+}
+
+// ── Help ───────────────────────────────────────────────────────────────────────
+
+export function showModHelp() {
+  console.log(`
+  bizar mod — Manage mods (via the dashboard's HTTP API)
+
+  Usage:
+    bizar mod upgrade <id> [--backup]   Upgrade an installed mod to the latest version
+    bizar mod install <id>              Install a mod from the registry
+    bizar mod list                       List installed mods
+    bizar mod registry                  Show registry URL + available mods
+
+  Description:
+    Subcommands call the running dashboard's HTTP API. If no dashboard is
+    reachable, you'll be told to run \`bizar dash start\` first.
+
+    \`bizar mod upgrade <id>\` will:
+      1. Snapshot the existing version of the mod
+      2. Optionally back up the folder (--backup)
+      3. Remove the existing copy (and its opencode-config instructions)
+      4. Install the latest version from the registry
+      5. Re-install the new mod's instruction files into opencode config
+      6. Print from-version → to-version
+  `);
+}
+
+// ── API helpers ────────────────────────────────────────────────────────────────
+
+async function postJson(baseUrl, path, body) {
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body || {}),
+  });
+  const text = await res.text();
+  let json = null;
+  try { json = text ? JSON.parse(text) : null; } catch { /* keep raw */ }
+  if (!res.ok) {
+    const msg = json?.message || json?.error || text || `HTTP ${res.status}`;
+    throw new Error(`${path} failed: ${msg}`);
+  }
+  return json;
+}
+
+async function getJson(baseUrl, path) {
+  const res = await fetch(`${baseUrl}${path}`);
+  const text = await res.text();
+  let json = null;
+  try { json = text ? JSON.parse(text) : null; } catch { /* keep raw */ }
+  if (!res.ok) {
+    const msg = json?.message || json?.error || text || `HTTP ${res.status}`;
+    throw new Error(`${path} failed: ${msg}`);
+  }
+  return json;
+}
+
+// ── Command runner ────────────────────────────────────────────────────────────
+
+export async function runModCommand(modArgs) {
+  const sub = modArgs[0];
+  const positional = modArgs.slice(1).filter((a) => !a.startsWith('-'));
+  const flags = modArgs.slice(1).filter((a) => a.startsWith('-'));
+
+  if (!sub || sub === '--help' || sub === '-h' || flags.includes('--help') || flags.includes('-h')) {
+    showModHelp();
+    return;
+  }
+
+  // Read dashboard port from the port file the dashboard writes on start.
+  const portFile = join(getBizarConfigDir(), 'dashboard.port');
+  let port = null;
+  try {
+    port = parseInt(readFileSync(portFile, 'utf8').trim(), 10);
+    if (!Number.isFinite(port) || port <= 0) port = null;
+  } catch {
+    port = null;
+  }
+  if (!port) {
+    console.error(chalk.red('  ✗ Dashboard is not running (no port file at ' + portFile + ').'));
+    console.error(chalk.dim('  Start it first: `bizar dash start --bg`'));
+    process.exit(1);
+  }
+  const baseUrl = `http://127.0.0.1:${port}`;
+
+  if (sub === 'install') {
+    const id = positional[0];
+    if (!id) {
+      console.error(chalk.red('  ✗ Missing mod id. Usage: bizar mod install <id>'));
+      process.exit(1);
+    }
+    try {
+      const m = await postJson(baseUrl, '/api/mods', { id });
+      console.log(chalk.green(`  ✓ Installed "${m.id}" v${m.version}`));
+    } catch (err) {
+      console.error(chalk.red(`  ✗ ${err.message}`));
+      process.exit(1);
+    }
+  } else if (sub === 'upgrade') {
+    const id = positional[0];
+    if (!id) {
+      console.error(chalk.red('  ✗ Missing mod id. Usage: bizar mod upgrade <id> [--backup]'));
+      process.exit(1);
+    }
+    const backup = flags.includes('--backup') || flags.includes('-b');
+    try {
+      const r = await postJson(baseUrl, `/api/mods/${encodeURIComponent(id)}/upgrade`, { backup });
+      const note = r.backupPath ? chalk.dim(` (backup: ${r.backupPath})`) : '';
+      console.log(chalk.green(`  ✓ Upgraded "${id}" v${r.from} → v${r.to}`) + note);
+    } catch (err) {
+      console.error(chalk.red(`  ✗ ${err.message}`));
+      process.exit(1);
+    }
+  } else if (sub === 'list') {
+    try {
+      const r = await getJson(baseUrl, '/api/mods');
+      const mods = r.mods || [];
+      if (mods.length === 0) {
+        console.log(chalk.dim('  (no mods installed)'));
+        return;
+      }
+      for (const m of mods) {
+        const state = m.enabled ? chalk.green('enabled ') : chalk.yellow('disabled');
+        console.log(`  ${m.id.padEnd(20)} v${m.version.padEnd(10)} ${state}  ${m.name || ''}`);
+      }
+    } catch (err) {
+      console.error(chalk.red(`  ✗ ${err.message}`));
+      process.exit(1);
+    }
+  } else if (sub === 'registry') {
+    try {
+      const r = await getJson(baseUrl, '/api/mods/registry');
+      console.log(chalk.dim(`  Source: ${r.registry?.source || '(unknown)'}`));
+      console.log(chalk.dim(`  Updated: ${r.registry?.updatedAt || '(unknown)'}`));
+      console.log('');
+      const mods = r.mods || [];
+      if (mods.length === 0) {
+        console.log(chalk.dim('  (no mods in registry)'));
+        return;
+      }
+      for (const m of mods) {
+        const installed = m.installed ? chalk.green(`installed v${m.installedVersion || '?'}`) : chalk.dim('not installed');
+        const upgrade = m.upgradeAvailable ? chalk.yellow(` ↑ v${m.upgradeAvailable} available`) : '';
+        console.log(`  ${m.id.padEnd(20)} v${(m.latest || '?').padEnd(10)} ${installed}${upgrade}  ${m.name || ''}`);
+      }
+    } catch (err) {
+      console.error(chalk.red(`  ✗ ${err.message}`));
+      process.exit(1);
+    }
+  } else {
+    console.error(chalk.red(`  ✗ Unknown mod subcommand: ${sub}`));
+    showModHelp();
+    process.exit(1);
+  }
+}
+
+export async function run(name, args, isHelpRequest) {
+  await runModCommand(args);
+}

package/cli/commands/service.mjs

@@ -0,0 +1,65 @@
+/**
+ * cli/commands/service.mjs
+ *
+ * Service command dispatcher — delegates to ../service.mjs.
+ * The service subcommand help text needs bizarConfigDir(), which we inline here
+ * (service.mjs owns its own bizarConfigDir for internal use).
+ */
+import chalk from 'chalk';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+function getBizarConfigDir() {
+  if (process.platform === 'win32') {
+    return process.env.APPDATA
+      ? join(process.env.APPDATA, 'bizar')
+      : join(homedir(), '.config', 'bizar');
+  }
+  return process.env.XDG_CONFIG_HOME
+    ? join(process.env.XDG_CONFIG_HOME, 'bizar')
+    : join(homedir(), '.config', 'bizar');
+}
+
+export function showServiceHelp() {
+  const bizarConfigDir = getBizarConfigDir();
+  console.log(`
+  bizar service — Manage the background service daemon
+
+  Usage:
+    bizar service start            Start the service in background
+    bizar service stop             Stop the running service
+    bizar service status           Show whether the service is running
+    bizar service logs             Tail the service log
+    bizar service follow           Follow the service log until Ctrl-C
+    bizar service install          Register with systemd / launchd / scheduled task
+    bizar service install --force  Re-install even when the unit matches
+    bizar service uninstall        Remove the OS-level autostart
+    bizar service uninstall --force  Force-uninstall even when nothing is registered
+
+  Description:
+    The service watches per-project schedules (cron / interval / once)
+    and runs them at the right time. It logs to
+    ${bizarConfigDir}/service.log and writes its PID to
+    ${bizarConfigDir}/service.pid.
+
+    install registers the daemon under the OS init system — systemd user
+    unit on Linux, launchd LaunchAgent on macOS, scheduled task
+    ("BizarDashboardService", ONSTART, HIGHEST) on Windows. After
+    install, a normal user does not need to run \`bizar service start\`
+    for the dashboard background process — the OS does it at login.
+  `);
+}
+
+export async function runServiceCommand(sub) {
+  const { runService } = await import('../service.mjs');
+  await runService(sub || 'status', process.argv.slice(2));
+}
+
+export async function run(name, args, isHelpRequest) {
+  if (isHelpRequest) {
+    showServiceHelp();
+    return;
+  }
+  const { runService } = await import('../service.mjs');
+  await runService(args[0] || 'status', args.slice(1));
+}

package/cli/commands/usage.mjs

@@ -0,0 +1,109 @@
+/**
+ * cli/commands/usage.mjs
+ *
+ * Usage analytics CLI — fetches from the running dashboard.
+ * v4.6.0+ — compact usage summary from the JSONL store.
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const HOME = homedir();
+const BIZAR_HOME = join(HOME, '.config', 'bizar');
+
+// ── Dashboard connection ────────────────────────────────────────────────────────
+
+function readDashboardConn() {
+  const portFile = join(BIZAR_HOME, 'dashboard.port');
+  const authFile = join(BIZAR_HOME, 'dashboard-secret');
+  let port = 4321;
+  let secret = '';
+  try {
+    if (existsSync(portFile)) {
+      const parsed = parseInt(readFileSync(portFile, 'utf8').trim(), 10);
+      if (Number.isFinite(parsed) && parsed > 0) port = parsed;
+    }
+  } catch { /* ignore */ }
+  try {
+    if (existsSync(authFile)) secret = readFileSync(authFile, 'utf8').trim();
+  } catch { /* ignore */ }
+  return { port, secret };
+}
+
+// ── Help ───────────────────────────────────────────────────────────────────────
+
+export function showUsageHelp() {
+  console.log(`
+  bizar usage — Show compact usage analytics summary
+
+  Usage:
+    bizar usage [24h|7d|30d]   Show summary for the given range (default: 24h)
+
+  Examples:
+    bizar usage
+    bizar usage 7d
+    bizar usage 30d
+  `);
+}
+
+// ── Command runner ─────────────────────────────────────────────────────────────
+
+async function runUsageCommand(args, wantJson = false) {
+  const range = (args[0] && ['24h', '7d', '30d'].includes(args[0])) ? args[0] : '24h';
+  const { port, secret } = readDashboardConn();
+  const url = `http://127.0.0.1:${port}/api/usage?range=${range}`;
+  const headers = { accept: 'application/json' };
+  if (secret) headers.authorization = `Basic ${Buffer.from(`opencode:${secret}`).toString('base64')}`;
+  try {
+    const resp = await fetch(url, { method: 'GET', headers });
+    const text = await resp.text();
+    let data = null;
+    try { data = text ? JSON.parse(text) : null; } catch { /* ignore */ }
+    if (!resp.ok || !data) {
+      console.error(chalk.red(`  ✗ Failed to load usage data: ${data?.message ?? resp.statusText}`));
+      process.exit(1);
+    }
+    if (wantJson) {
+      process.stdout.write(JSON.stringify(data) + '\n');
+      return;
+    }
+    const t = data.totals;
+    console.log('');
+    console.log(chalk.bold(`  Usage summary — ${range} (from JSONL store)`));
+    console.log('');
+    console.log(`    ${chalk.dim('Requests:')}   ${t.requests.toLocaleString()}  (${t.errors} errors)`);
+    console.log(`    ${chalk.dim('Tokens:')}     ${t.totalTokens.toLocaleString()} total  (${t.promptTokens.toLocaleString()} prompt · ${t.completionTokens.toLocaleString()} completion)`);
+    console.log(`    ${chalk.dim('Cached:')}     ${t.cachedTokens.toLocaleString()} tokens`);
+    console.log(`    ${chalk.dim('Reasoning:')}  ${t.reasoningTokens.toLocaleString()} tokens`);
+    console.log(`    ${chalk.dim('Avg latency:')} ${t.avgLatencyMs}ms  (p95: ${t.p95LatencyMs}ms)`);
+    if (t.costEstimate > 0) {
+      console.log(`    ${chalk.dim('Est. cost:')}   $${t.costEstimate.toFixed(4)} USD`);
+    }
+    console.log('');
+    if (data.daily && data.daily.length > 0) {
+      console.log(chalk.dim(`  ${chalk.bold('Daily breakdown')}`));
+      for (const day of data.daily.slice(-7)) {
+        const barLen = Math.round((day.totalTokens / Math.max(...data.daily.map(d => d.totalTokens))) * 20);
+        const bar = '█'.repeat(barLen) + '░'.repeat(20 - barLen);
+        console.log(`    ${day.date}  ${bar}  ${day.totalTokens.toLocaleString()} tok  ${day.requests} req`);
+      }
+    }
+    if (data.perModel && data.perModel.length > 0) {
+      console.log('');
+      console.log(chalk.dim(`  ${chalk.bold('Per model')}`));
+      for (const m of data.perModel.slice(0, 8)) {
+        console.log(`    ${m.modelId.padEnd(24)} ${String(m.requests).padStart(6)} req  ${String(m.totalTokens).padStart(8)} tok`);
+      }
+    }
+    console.log('');
+  } catch (err) {
+    console.error(chalk.red(`  ✗ Network error: ${err && err.message ? err.message : String(err)}`));
+    console.error(chalk.dim('    Is the dashboard running? Run `bizar dash start` first.'));
+    process.exit(1);
+  }
+}
+
+export async function run(name, args, isHelpRequest) {
+  await runUsageCommand(args, false);
+}