@polderlabs/bizar 4.7.0 → 4.7.2

package/cli/bin.mjs

@@ -136,7 +136,12 @@ function showHelp() {
 async function importCommand(name) {
   try {
     return await import(`./commands/${name}.mjs`);
-  } catch {
+  } catch (err) {
+    console.error(chalk.red(`  ✗ Failed to load command module '${name}': ${err && err.message ? err.message : String(err)}`));
+    if (err && err.stack) {
+      const lines = err.stack.split('\n').slice(0, 3);
+      console.error(chalk.dim(lines.join('\n')));
+    }
     return null;
   }
 }
@@ -184,61 +189,131 @@ async function main() {
     }
   }
 
+  // `bizar help` — explicit help alias
+  if (cmd === 'help') {
+    showHelp();
+    process.exit(EXIT_OK);
+    return;
+  }
+
   // Dispatch to command modules
   switch (cmd) {
     case 'install':
     case 'update': {
       const mod = await importCommand('install');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load install command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'install');
       await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
       break;
     }
 
     case 'service': {
       const mod = await importCommand('service');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load service command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'service');
       await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
       break;
     }
 
     case 'dash':
     case 'dashboard': {
       const mod = await importCommand('dash');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load dash command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'dash');
       await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
       break;
     }
 
     case 'minimax': {
       const mod = await importCommand('minimax');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load minimax command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'minimax');
       await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
       break;
     }
 
     case 'headroom': {
       const mod = await importCommand('headroom');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load headroom command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'headroom');
       await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
       break;
     }
 
     case 'mod': {
       const mod = await importCommand('mod');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load mod command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'mod');
       await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
       break;
     }
 
     case 'artifact': {
       const mod = await importCommand('artifact');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load artifact command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'artifact');
       await mod.runArtifact(cmdArgs, { wantJson });
+      dbg('command returned:', cmd);
       break;
     }
 
     case 'memory': {
       const mod = await importCommand('memory');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load memory command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'memory');
       await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
       break;
     }
 
     case 'usage': {
       const mod = await importCommand('usage');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load usage command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'usage');
       await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
       break;
     }
 
@@ -253,11 +328,19 @@ async function main() {
     case 'repair':
     case 'heads-up':
     case 'bg':
+    case 'digest':
     case 'browser-harness-up':
     case 'providers':
     case 'plan': {
       const mod = await importCommand('util');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load util command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'util');
       const found = await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
       if (!found) {
         console.error(chalk.red(`  ✗ Unknown command: ${cmd}`));
         showHelp();
@@ -277,7 +360,18 @@ async function main() {
 // ── Run ───────────────────────────────────────────────────────────────────────
 
 const thisFile = fileURLToPath(import.meta.url);
-const isMainModule = process.argv[1] === thisFile;
+// Resolve symlinks: when invoked via a symlink (e.g. /home/drb0rk/.local/bin/bizar),
+// process.argv[1] is the symlink path, but import.meta.url is the resolved target.
+// Compare via realpath so main() runs regardless of how the script is invoked.
+const { realpathSync } = await import('node:fs');
+const resolvedArgv = (() => {
+  try {
+    return realpathSync(process.argv[1]);
+  } catch {
+    return process.argv[1];
+  }
+})();
+const isMainModule = resolvedArgv === thisFile;
 if (isMainModule) {
   await main().catch((err) => {
     console.error(chalk.red(`bizar: ${err && err.message ? err.message : String(err)}`));

package/cli/commands/minimax.mjs

@@ -100,6 +100,11 @@ async function runMinimaxCommand(minimaxArgs) {
       console.error(chalk.red(`  ✗ ${r.message || r.error}`));
       process.exit(1);
     }
+    if (!r.data) {
+      console.error(chalk.red('  ✗ Dashboard returned no data. Is the dashboard running?'));
+      console.error(chalk.dim(`    Tried: http://127.0.0.1:4321/api/minimax/status`));
+      process.exit(1);
+    }
     const s = r.data;
     console.log('');
     console.log(chalk.bold('  MiniMax Token Plan status'));
@@ -126,6 +131,11 @@ async function runMinimaxCommand(minimaxArgs) {
       console.error(chalk.red(`  ✗ ${r.message || r.error}`));
       process.exit(1);
     }
+    if (!r.data) {
+      console.error(chalk.red('  ✗ Dashboard returned no data. Is the dashboard running?'));
+      console.error(chalk.dim(`    Tried: http://127.0.0.1:4321/api/minimax/remains`));
+      process.exit(1);
+    }
     if (!r.data?.ok) {
       console.error(chalk.red(`  ✗ ${r.data?.message || r.data?.error || 'unknown'}`));
       process.exit(1);
@@ -160,6 +170,11 @@ async function runMinimaxCommand(minimaxArgs) {
       console.error(chalk.red(`  ✗ ${r.message || r.error}`));
       process.exit(1);
     }
+    if (!r.data) {
+      console.error(chalk.red('  ✗ Dashboard returned no data. Is the dashboard running?'));
+      console.error(chalk.dim(`    Tried: http://127.0.0.1:4321/api/minimax/test`));
+      process.exit(1);
+    }
     const data = r.data;
     if (!data?.ok) {
       console.error(chalk.red(`  ✗ ${data?.message || data?.error || 'unknown'}`));
@@ -195,6 +210,11 @@ async function runMinimaxCommand(minimaxArgs) {
       console.error(chalk.red(`  ✗ ${r.message || r.error}`));
       process.exit(1);
     }
+    if (!r.data) {
+      console.error(chalk.red('  ✗ Dashboard returned no data. Is the dashboard running?'));
+      console.error(chalk.dim(`    Tried: http://127.0.0.1:4321/api/minimax/onboarding/save-key`));
+      process.exit(1);
+    }
     console.log(chalk.green(`  ✓ Saved to ${r.data?.path}`));
     console.log(`    ${chalk.dim('key hint:')} ${r.data?.apiKeyHint}`);
     return;

package/cli/commands/util.mjs

@@ -3,7 +3,8 @@
  *
  * Miscellaneous utility commands:
  *   audit, init, export, test-gate, dev-link, dev-unlink,
- *   doctor, repair, heads-up, bg, browser-harness-up, providers detect
+ *   doctor, repair, heads-up, bg, browser-harness-up, providers detect,
+ *   backup, restore
  */
 import chalk from 'chalk';
 import { existsSync, readFileSync } from 'node:fs';
@@ -130,6 +131,51 @@ export function showRepairHelp() {
   `);
 }
 
+export function showBackupHelp() {
+  console.log(`
+  bizar backup — Backup BizarHarness state
+
+  Usage:
+    bizar backup [label]        Create a new backup (with optional label)
+    bizar backup list           List available backups
+    bizar backup verify <path>  Verify a backup's integrity
+    bizar backup delete <path>  Delete a backup
+
+  Description:
+    Backs up config (~/.config/bizar/, ~/.config/opencode/), memory,
+    usage logs, and optionally project-level state (.bizar/, skills/).
+    Backups are stored under ~/.local/share/bizar/backups/.
+
+  Examples:
+    bizar backup
+    bizar backup "before-upgrade"
+    bizar backup list
+    bizar backup verify ~/.local/share/bizar/backups/bizar-2025-07-05-120000
+  `);
+}
+
+export function showRestoreHelp() {
+  console.log(`
+  bizar restore — Restore BizarHarness from a backup
+
+  Usage:
+    bizar restore <path>                Restore from a backup
+    bizar restore <path> --dry-run      Preview restore without modifying files
+    bizar restore <path> --overwrite    Replace existing files (default: merge)
+    bizar restore <path> --skip         Keep existing files, don't overwrite
+
+  Description:
+    Restores files from a backup directory. Default strategy is 'merge'
+    (newer files from backup overlay existing files). Use --overwrite to
+    replace everything, or --skip to leave existing files untouched.
+
+  Examples:
+    bizar restore ~/.local/share/bizar/backups/bizar-2025-07-05-120000
+    bizar restore ~/.local/share/bizar/backups/bizar-2025-07-05-120000 --dry-run
+    bizar restore ~/.local/share/bizar/backups/bizar-2025-07-05-120000 --overwrite
+  `);
+}
+
 // ── Test gate ──────────────────────────────────────────────────────────────────
 
 export async function runTestGate() {
@@ -245,6 +291,102 @@ export async function run(name, args, isHelpRequest) {
       }
       break;
 
+    case 'backup': {
+      if (isHelpRequest || args.length === 0) {
+        showBackupHelp();
+        break;
+      }
+      const sub = args[0];
+      if (sub === 'list') {
+        const { listBackups } = await import('../../bizar-dash/src/server/backup-store.mjs');
+        const backups = await listBackups();
+        if (backups.length === 0) {
+          console.log('  No backups found.');
+        } else {
+          for (const b of backups) {
+            console.log(`  ${b.path}`);
+            console.log(`    Created: ${b.createdAt}`);
+            console.log(`    Size: ${b.sizeFormatted}`);
+            if (b.manifest?.label) console.log(`    Label: ${b.manifest.label}`);
+            console.log('');
+          }
+        }
+        break;
+      }
+      if (sub === 'verify') {
+        const path = args[1];
+        if (!path) { console.error('  Usage: bizar backup verify <path>'); process.exit(1); }
+        const { verifyBackup } = await import('../../bizar-dash/src/server/backup-store.mjs');
+        const result = await verifyBackup({ backupPath: path });
+        if (result.ok) {
+          console.log(chalk.green('  ✓ Backup is valid'));
+        } else {
+          console.error(chalk.red('  ✗ Backup has issues:'));
+          for (const issue of result.issues) console.error(`    - ${issue}`);
+          process.exit(1);
+        }
+        break;
+      }
+      if (sub === 'delete') {
+        const path = args[1];
+        if (!path) { console.error('  Usage: bizar backup delete <path>'); process.exit(1); }
+        const { deleteBackup } = await import('../../bizar-dash/src/server/backup-store.mjs');
+        const result = await deleteBackup({ backupPath: path });
+        if (result.ok) {
+          console.log(chalk.green('  ✓ Backup deleted'));
+        } else {
+          console.error(chalk.red(`  ✗ Delete failed: ${result.error}`));
+          process.exit(1);
+        }
+        break;
+      }
+      // Default: create backup
+      const label = sub || null;
+      const { createBackup } = await import('../../bizar-dash/src/server/backup-store.mjs');
+      const result = await createBackup({ label });
+      if (result.ok) {
+        console.log(chalk.green('  ✓ Backup created'));
+        console.log(`  Path: ${result.path}`);
+        console.log(`  Size: ${result.sizeBytes > 0 ? `${(result.sizeBytes / 1024).toFixed(1)} KB` : '0 B'}`);
+        console.log(`  Duration: ${result.durationMs}ms`);
+      } else {
+        console.error(chalk.red('  ✗ Backup failed'));
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'restore': {
+      if (isHelpRequest) {
+        showRestoreHelp();
+        break;
+      }
+      const path = args[0];
+      if (!path) { showRestoreHelp(); process.exit(1); }
+      const dryRun = args.includes('--dry-run');
+      const conflictStrategy = args.includes('--overwrite') ? 'overwrite' : args.includes('--skip') ? 'skip' : 'merge';
+      const { restoreBackup } = await import('../../bizar-dash/src/server/backup-store.mjs');
+      const result = await restoreBackup({ backupPath: path, dryRun, conflictStrategy });
+      if (dryRun) {
+        console.log('  Dry-run mode — no files were modified.');
+      }
+      if (result.restored.length > 0) {
+        console.log(`  Restored: ${result.restored.join(', ')}`);
+      }
+      if (result.skipped.length > 0) {
+        console.log(`  Skipped: ${result.skipped.join(', ')}`);
+      }
+      if (result.errors.length > 0) {
+        console.error(chalk.red('  Errors:'));
+        for (const e of result.errors) console.error(`    - ${e}`);
+        process.exit(1);
+      }
+      if (result.ok) {
+        console.log(chalk.green(`  ✓ Restore complete`));
+      }
+      break;
+    }
+
     case 'heads-up':
       if (isHelpRequest) {
         console.log('  heads-up <subcommand>   Manage pre-push / pre-release heads-ups (list/check/archive)');
@@ -263,6 +405,17 @@ export async function run(name, args, isHelpRequest) {
       }
       break;
 
+    case 'digest':
+      // v4.8.0 — Weekly digest management
+      if (isHelpRequest) {
+        const { showDigestHelp } = await import('../digest.mjs');
+        showDigestHelp();
+      } else {
+        const { runDigest } = await import('../digest.mjs');
+        await runDigest(args[0], args.slice(1));
+      }
+      break;
+
     case 'browser-harness-up': {
       const { execFileSync } = await import('node:child_process');
       const sub = args[0] || 'start';

package/cli/digest.mjs

@@ -0,0 +1,149 @@
+/**
+ * cli/digest.mjs
+ *
+ * v4.8.0 — `bizar digest` CLI subcommand.
+ *
+ * Usage:
+ *   bizar digest                  Show latest digest
+ *   bizar digest list             List all digests
+ *   bizar digest generate [--days N]  Generate now (default 7 days)
+ *   bizar digest view <path>      View a specific digest
+ *   bizar digest delete <path>    Delete a specific digest
+ */
+import chalk from 'chalk';
+import { readFileSync, existsSync } from 'node:fs';
+
+function showDigestHelp() {
+  console.log(`
+  bizar digest — Manage weekly digests
+
+  Usage:
+    bizar digest                     Show the latest digest
+    bizar digest list                List all digests
+    bizar digest generate [--days N] Generate a digest now (default 7 days)
+    bizar digest view <path>         View a specific digest
+    bizar digest delete <path>       Delete a specific digest
+    bizar digest --help              Show this help
+  `);
+}
+
+export async function runDigest(subcommand, args) {
+  const { generateAndSave, listDigests, getDigest, deleteDigest } = await import(
+    '../bizar-dash/src/server/digest-store.mjs'
+  );
+
+  switch (subcommand) {
+    case undefined:
+    case null:
+    case '': {
+      // Show latest digest
+      const digests = await listDigests({ limit: 1 });
+      if (digests.length === 0) {
+        console.log(chalk.yellow('  No digests yet. Run `bizar digest generate` to create one.'));
+        return;
+      }
+      const latest = digests[0];
+      const digest = await getDigest(latest.path);
+      if (!digest) {
+        console.log(chalk.red(`  ✗ Digest not found at ${latest.path}`));
+        return;
+      }
+      console.log(digest.content);
+      break;
+    }
+
+    case 'list': {
+      const digests = await listDigests({ limit: 50 });
+      if (digests.length === 0) {
+        console.log(chalk.yellow('  No digests yet.'));
+        return;
+      }
+      console.log(chalk.bold(`  ${digests.length} digest(s):\n`));
+      for (const d of digests) {
+        const date = new Date(d.createdAt).toLocaleDateString();
+        const size = (d.sizeBytes / 1024).toFixed(1);
+        console.log(`  ${chalk.cyan(d.filename)}`);
+        console.log(`    Path: ${d.path}`);
+        console.log(`    Created: ${date}  (${size} KB)`);
+        console.log();
+      }
+      break;
+    }
+
+    case 'generate': {
+      const daysIdx = args.indexOf('--days');
+      const days = daysIdx >= 0 ? parseInt(args[daysIdx + 1], 10) || 7 : 7;
+      const dryRun = args.includes('--dry-run');
+      const now = new Date();
+      const weekEnd = now.toISOString().slice(0, 10);
+      const weekStart = new Date(now.getTime() - days * 24 * 60 * 60 * 1000)
+        .toISOString()
+        .slice(0, 10);
+
+      console.log(chalk.bold(`  Generating digest for ${weekStart} → ${weekEnd}...`));
+      if (dryRun) console.log(chalk.yellow('  (dry run — will not save)'));
+
+      const result = await generateAndSave({
+        weekStart,
+        weekEnd,
+        projectRoot: process.cwd(),
+        dryRun,
+      });
+
+      if (result.dryRun) {
+        console.log('\n' + result.markdown);
+      } else {
+        console.log(chalk.green(`  ✓ Digest saved:`));
+        for (const p of result.saveResult.paths) {
+          console.log(`    ${p}`);
+        }
+        console.log(chalk.green(`  Sections: ${Object.keys(result.sections).filter(k => Array.isArray(result.sections[k]) ? result.sections[k].length > 0 : result.sections[k] !== null).length}/7 populated`));
+      }
+      break;
+    }
+
+    case 'view': {
+      const path = args[0];
+      if (!path) {
+        console.log(chalk.red('  ✗ Usage: bizar digest view <path>'));
+        process.exit(1);
+      }
+      if (!existsSync(path)) {
+        console.log(chalk.red(`  ✗ File not found: ${path}`));
+        process.exit(1);
+      }
+      const digest = await getDigest(path);
+      if (!digest) {
+        console.log(chalk.red(`  ✗ Could not read digest at ${path}`));
+        process.exit(1);
+      }
+      console.log(digest.content);
+      break;
+    }
+
+    case 'delete': {
+      const path = args[0];
+      if (!path) {
+        console.log(chalk.red('  ✗ Usage: bizar digest delete <path>'));
+        process.exit(1);
+      }
+      const result = await deleteDigest(path);
+      if (result.ok) {
+        console.log(chalk.green(`  ✓ Deleted ${path}`));
+      } else {
+        console.log(chalk.red(`  ✗ Delete failed: ${result.error || 'unknown'}`));
+        process.exit(1);
+      }
+      break;
+    }
+
+    default:
+      if (subcommand === '--help' || subcommand === '-h') {
+        showDigestHelp();
+      } else {
+        console.log(chalk.red(`  ✗ Unknown digest subcommand: ${subcommand}`));
+        showDigestHelp();
+        process.exit(1);
+      }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "4.7.0",
+  "version": "4.7.2",
   "description": "Norse-pantheon multi-agent system for opencode — 13 agents across 4 cost tiers with cost-aware routing, plans, and a configurable agent harness. v4 ships as a single npm package bundling the dashboard server, opencode plugin, and typed SDK.",
   "type": "module",
   "bin": {