@polderlabs/bizar 5.0.2 → 5.2.0

package/bizar-dash/tests/voice-transcribe-worker.test.mjs

@@ -0,0 +1,343 @@
+/**
+ * tests/voice-transcribe-worker.test.mjs
+ *
+ * v5.2 — Tests for the background transcription worker.
+ *
+ * The worker is a singleton (in-memory queue + module-level broadcast
+ * hook). Every test calls `reset()` at the top to drop any leftover
+ * queue, then stubs `transcribe` and `broadcast` via the exported
+ * setters so the test never touches the network or the WebSocket.
+ *
+ * Coverage:
+ *   - FIFO ordering: notes are processed in the order they were enqueued,
+ *     verified by tracking which audio buffer each `transcribe()` call
+ *     sees.
+ *   - Error isolation: a throw from `transcribe` for note N does NOT
+ *     stop note N+1; the failing note's transcript stays null, the
+ *     next one is persisted.
+ *   - Broadcast on success: `broadcast({ type: 'voice:updated', ... })`
+ *     fires exactly once per successful transcription with the right
+ *     payload. Also: no broadcast on null transcript, no broadcast on
+ *     already-transcribed notes, broadcast throws don't corrupt state.
+ *   - Input guards: `enqueueTranscription` ignores bad ids.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+
+const TEST_VAULT = join(
+  tmpdir(),
+  `bizar-voice-worker-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+);
+
+const worker = await import('../src/server/workers/transcription-worker.mjs');
+const voiceStore = await import('../src/server/voice-store.mjs');
+
+/**
+ * Save a voice note with a stable, unique audio body. The body is
+ * overwritten to a deterministic string so tests can identify "which
+ * note is this" by audio contents alone (the worker reads the file
+ * from disk and passes the buffer to `transcribe()`).
+ */
+async function saveNoteWithAudioFile(label) {
+  const audioBuffer = Buffer.from(`audio-${label}-${'x'.repeat(64)}`);
+  const saved = await voiceStore.saveVoiceNote({
+    audioBuffer,
+    transcript: null,
+    durationSec: 1,
+    vaultPath: TEST_VAULT,
+  });
+  writeFileSync(saved.audioPath, audioBuffer);
+  return saved;
+}
+
+// ── Setup / teardown ────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  mkdirSync(TEST_VAULT, { recursive: true });
+  worker.reset();
+});
+
+afterEach(() => {
+  worker.reset();
+  try { rmSync(TEST_VAULT, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+// ── Input guards ────────────────────────────────────────────────────────────
+
+describe('enqueueTranscription input guards', () => {
+  it('ignores null / empty / non-string ids', () => {
+    worker.enqueueTranscription(null);
+    worker.enqueueTranscription('');
+    worker.enqueueTranscription(undefined);
+    worker.enqueueTranscription(42);
+    worker.enqueueTranscription({});
+    assert.strictEqual(worker.getQueueDepth(), 0);
+  });
+});
+
+// ── FIFO order ──────────────────────────────────────────────────────────────
+
+describe('FIFO order', () => {
+  it('invokes transcribe in enqueue-order, one at a time', async () => {
+    const a = await saveNoteWithAudioFile('a');
+    const b = await saveNoteWithAudioFile('b');
+    const c = await saveNoteWithAudioFile('c');
+
+    /** @type {Buffer[]} */
+    const seen = [];
+    /** @type {string[]} */
+    const concurrent = [];
+    let inFlight = 0;
+
+    worker.setTranscribe(async (buf) => {
+      seen.push(buf);
+      inFlight += 1;
+      if (inFlight > 1) concurrent.push('overlap');
+      // Yield to mimic real Whisper latency, then return.
+      await new Promise((r) => setImmediate(r));
+      inFlight -= 1;
+      return `text-${seen.length}`;
+    });
+
+    worker.enqueueTranscription(a.id);
+    worker.enqueueTranscription(b.id);
+    worker.enqueueTranscription(c.id);
+    await worker.drainQueue();
+
+    assert.strictEqual(seen.length, 3, 'all three notes should have been attempted');
+    assert.deepStrictEqual(concurrent, [], 'no two transcribes may run concurrently');
+
+    assert.strictEqual(
+      seen[0].toString('utf8'),
+      readFileSync(a.audioPath).toString('utf8'),
+      'first enqueue must be processed first',
+    );
+    assert.strictEqual(
+      seen[1].toString('utf8'),
+      readFileSync(b.audioPath).toString('utf8'),
+      'second enqueue must be processed second',
+    );
+    assert.strictEqual(
+      seen[2].toString('utf8'),
+      readFileSync(c.audioPath).toString('utf8'),
+      'third enqueue must be processed third',
+    );
+  });
+});
+
+// ── Error isolation ─────────────────────────────────────────────────────────
+
+describe('error isolation', () => {
+  it('a throwing transcription does not block the next item', async () => {
+    const a = await saveNoteWithAudioFile('ea');
+    const b = await saveNoteWithAudioFile('eb');
+    const c = await saveNoteWithAudioFile('ec');
+
+    const failedBody = readFileSync(a.audioPath).toString('utf8');
+    let calls = 0;
+    worker.setTranscribe(async (buf) => {
+      calls += 1;
+      if (buf.toString('utf8') === failedBody) {
+        throw new Error('synthetic-whisper-failure');
+      }
+      return `ok-${calls}`;
+    });
+
+    worker.enqueueTranscription(a.id);
+    worker.enqueueTranscription(b.id);
+    worker.enqueueTranscription(c.id);
+    await worker.drainQueue();
+
+    assert.strictEqual(calls, 3, 'all three notes must be attempted');
+
+    // The failing note retains null transcript.
+    assert.strictEqual(
+      voiceStore.getVoiceNote(a.id)?.transcript ?? null,
+      null,
+      'failing note keeps null transcript',
+    );
+    // The next two got transcripts.
+    assert.ok(voiceStore.getVoiceNote(b.id)?.transcript, 'b should be transcribed');
+    assert.ok(voiceStore.getVoiceNote(c.id)?.transcript, 'c should be transcribed');
+  });
+
+  it('null return from transcribe does not block the next item', async () => {
+    const a = await saveNoteWithAudioFile('null-a');
+    const b = await saveNoteWithAudioFile('null-b');
+
+    let n = 0;
+    worker.setTranscribe(async () => {
+      n += 1;
+      return n === 1 ? null : 'second-ok';
+    });
+
+    worker.enqueueTranscription(a.id);
+    worker.enqueueTranscription(b.id);
+    await worker.drainQueue();
+
+    assert.strictEqual(voiceStore.getVoiceNote(a.id)?.transcript ?? null, null);
+    assert.strictEqual(voiceStore.getVoiceNote(b.id)?.transcript, 'second-ok');
+  });
+});
+
+// ── Broadcast on success ────────────────────────────────────────────────────
+
+describe('broadcast on success', () => {
+  it('sends a voice:updated event with the new transcript', async () => {
+    const a = await saveNoteWithAudioFile('ba');
+
+    const broadcasts = [];
+    worker.setBroadcast((msg) => broadcasts.push(msg));
+
+    worker.setTranscribe(async () => 'hello world');
+    worker.enqueueTranscription(a.id);
+    await worker.drainQueue();
+
+    assert.strictEqual(broadcasts.length, 1);
+    assert.strictEqual(broadcasts[0].type, 'voice:updated');
+    assert.strictEqual(broadcasts[0].noteId, a.id);
+    assert.deepStrictEqual(broadcasts[0].patch, { transcript: 'hello world' });
+  });
+
+  it('does not broadcast when transcribe returns null', async () => {
+    const a = await saveNoteWithAudioFile('bb');
+
+    const broadcasts = [];
+    worker.setBroadcast((msg) => broadcasts.push(msg));
+
+    worker.setTranscribe(async () => null);
+    worker.enqueueTranscription(a.id);
+    await worker.drainQueue();
+
+    assert.strictEqual(broadcasts.length, 0);
+  });
+
+  it('does not broadcast when the note is already transcribed', async () => {
+    const a = await saveNoteWithAudioFile('bc');
+    voiceStore.updateVoiceNote(a.id, { transcript: 'pre-existing' });
+
+    const broadcasts = [];
+    worker.setBroadcast((msg) => broadcasts.push(msg));
+
+    let called = 0;
+    worker.setTranscribe(async () => {
+      called += 1;
+      return 'should-not-be-called';
+    });
+
+    worker.enqueueTranscription(a.id);
+    await worker.drainQueue();
+
+    assert.strictEqual(called, 0, 'transcribe must not be called for already-done notes');
+    assert.strictEqual(broadcasts.length, 0);
+    assert.strictEqual(
+      voiceStore.getVoiceNote(a.id)?.transcript,
+      'pre-existing',
+      'transcript must NOT be overwritten',
+    );
+  });
+
+  it('still persists the transcript even if the broadcast throws', async () => {
+    const a = await saveNoteWithAudioFile('bd');
+
+    worker.setBroadcast(() => {
+      throw new Error('spy-throws');
+    });
+
+    worker.setTranscribe(async () => 'persisted-text');
+    worker.enqueueTranscription(a.id);
+    await worker.drainQueue();
+
+    assert.strictEqual(voiceStore.getVoiceNote(a.id)?.transcript, 'persisted-text');
+  });
+});
+
+// ── processOne direct API ───────────────────────────────────────────────────
+
+describe('processOne', () => {
+  it('returns { skipped: "missing" } for unknown note id', async () => {
+    const result = await worker.processOne('does-not-exist');
+    assert.deepStrictEqual(result, { skipped: 'missing' });
+  });
+
+  it('returns { skipped: "already_transcribed" } if a transcript is set', async () => {
+    const a = await saveNoteWithAudioFile('pa');
+    voiceStore.updateVoiceNote(a.id, { transcript: 'done' });
+
+    let called = 0;
+    worker.setTranscribe(async () => {
+      called += 1;
+      return 'x';
+    });
+
+    const result = await worker.processOne(a.id);
+    assert.strictEqual(result.skipped, 'already_transcribed');
+    assert.strictEqual(called, 0);
+  });
+
+  it('returns { skipped: "audio_missing" } when the audio file is gone', async () => {
+    const a = await saveNoteWithAudioFile('pm');
+    // Wipe the audio file from disk.
+    rmSync(a.audioPath);
+
+    const result = await worker.processOne(a.id);
+    assert.strictEqual(result.skipped, 'audio_missing');
+  });
+});
+
+// ── drainQueue promise ─────────────────────────────────────────────────────
+
+describe('drainQueue', () => {
+  it('resolves immediately when the queue is already empty', async () => {
+    const start = Date.now();
+    await worker.drainQueue();
+    const elapsed = Date.now() - start;
+    assert.ok(elapsed < 50, `drainQueue() should resolve immediately when idle (took ${elapsed}ms)`);
+  });
+
+  it('resolves once all enqueued work has finished', async () => {
+    const a = await saveNoteWithAudioFile('da');
+    const b = await saveNoteWithAudioFile('db');
+
+    worker.setTranscribe(async () => 'ready');
+    worker.enqueueTranscription(a.id);
+    worker.enqueueTranscription(b.id);
+
+    await worker.drainQueue();
+
+    assert.strictEqual(worker.getQueueDepth(), 0);
+    assert.ok(voiceStore.getVoiceNote(a.id)?.transcript);
+    assert.ok(voiceStore.getVoiceNote(b.id)?.transcript);
+  });
+});
+
+// ── startTranscriptionWorker wiring ─────────────────────────────────────────
+
+describe('startTranscriptionWorker', () => {
+  it('installs the broadcast hook and starts a polling interval (verified by behaviour)', async () => {
+    const a = await saveNoteWithAudioFile('ws');
+
+    /** @type {Array<{type: string, noteId: string}>} */
+    const broadcasts = [];
+    worker.startTranscriptionWorker({
+      broadcast: (msg) => broadcasts.push(msg),
+    });
+
+    // After startTranscriptionWorker, enqueuing must route through the
+    // installed broadcast hook.
+    worker.setTranscribe(async () => 'broadcast-via-start');
+    worker.enqueueTranscription(a.id);
+    await worker.drainQueue();
+
+    assert.strictEqual(broadcasts.length, 1);
+    assert.strictEqual(broadcasts[0].type, 'voice:updated');
+    assert.strictEqual(broadcasts[0].noteId, a.id);
+
+    // Stop the interval so the test process can exit cleanly.
+    worker.reset();
+  });
+});

package/cli/bin.mjs

@@ -102,6 +102,7 @@ function showHelp() {
     memory <subcommand> Manage project memory (Bizar Memory Service)
     headroom <subcommand> Manage Headroom context compression
     minimax <subcommand>   Manage MiniMax Token Plan integration
+    tailscale <subcommand> Manage Tailscale integration (auth, serve, status)
     mod <subcommand>       Manage mods (install/upgrade/list via the dashboard API)
     usage                 Show compact usage analytics summary (24h rolling)
     doctor              Check the BizarHarness install for health issues
@@ -257,6 +258,19 @@ async function main() {
       break;
     }
 
+    case 'tailscale': {
+      const mod = await importCommand('tailscale');
+      if (!mod) {
+        console.error(chalk.red(`  ✗ Could not load tailscale command module`));
+        process.exit(EXIT_ERROR);
+        return;
+      }
+      dbg('loaded command module:', 'tailscale');
+      await mod.run(cmd, cmdArgs, isHelpRequest);
+      dbg('command returned:', cmd);
+      break;
+    }
+
     case 'headroom': {
       const mod = await importCommand('headroom');
       if (!mod) {

package/cli/commands/dash.mjs

@@ -127,7 +127,24 @@ export async function runDash(dashArgs) {
   }
 
   switch (sub) {
-    case 'start':
+    case 'start': {
+      // v5.2 — Auto-setup Tailscale serve if auth key is available
+      const usePort = subOpts.port || 4321;
+      if (process.env.TAILSCALE_AUTHKEY || process.env.BIZAR_TAILSCALE_AUTOSETUP === '1') {
+        try {
+          const { ensureTailscaleAuth, setupTailscaleServe } = await import('./tailscale.mjs');
+          const authResult = await ensureTailscaleAuth();
+          if (authResult.authenticated) {
+            const serveResult = await setupTailscaleServe({ dashboardPort: usePort });
+            if (serveResult.ok) {
+              console.log(chalk.green(`  ✓ Tailscale serve: ${serveResult.url}`));
+            }
+          }
+        } catch (err) {
+          // Non-fatal: Tailscale setup errors don't block dashboard start
+          console.log(chalk.dim(`  ⚠ Tailscale auto-setup skipped: ${err.message}`));
+        }
+      }
       if (subOpts.bg) {
         // Pass --port, --host, --bind through to the child process
         const bgArgs = ['start', ...(subOpts.subArgs || [])];
@@ -138,6 +155,7 @@ export async function runDash(dashArgs) {
         await dashModule.start(subOpts);
       }
       break;
+    }
     case 'stop':
       await dashModule.stop(subOpts);
       break;

package/cli/commands/service.mjs

@@ -22,6 +22,8 @@ function getBizarConfigDir() {
 
 export function showServiceHelp() {
   const bizarConfigDir = getBizarConfigDir();
+  const tsAuthkey = process.env.TAILSCALE_AUTHKEY ? '(set)' : '(not set)';
+  const tsAuto = process.env.BIZAR_TAILSCALE_AUTOSETUP === '1' ? 'enabled' : 'disabled';
   console.log(`
   bizar service — Manage the background service daemon
 
@@ -47,6 +49,11 @@ export function showServiceHelp() {
     ("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.
+
+  Tailscale Integration (v5.2):
+    TAILSCALE_AUTHKEY=${tsAuthkey}
+    BIZAR_TAILSCALE_AUTOSETUP=${tsAuto}
+    Run \`bizar tailscale --help\` for Tailscale management.
   `);
 }
 

package/cli/commands/tailscale.mjs

@@ -0,0 +1,251 @@
+/**
+ * cli/commands/tailscale.mjs
+ *
+ * v5.2 — Tailscale auth key integration for the dashboard.
+ *
+ * When TAILSCALE_AUTHKEY is set (or BIZAR_TAILSCALE_AUTOSETUP=1), the
+ * dashboard auto-configures `tailscale serve` on startup so the user
+ * doesn't need to run `sudo tailscale serve ...` manually.
+ */
+import { execFileSync, spawn } from 'node:child_process';
+import { existsSync, writeFileSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import chalk from 'chalk';
+
+const TS_AUTHKEY = process.env.TAILSCALE_AUTHKEY;
+const TS_STATE_DIR = process.env.TAILSCALE_STATE_DIR || join(homedir(), '.local', 'share', 'bizar', 'tailscale');
+const TS_SERVE_CONFIG = join(TS_STATE_DIR, 'serve.json');
+
+function ensureStateDir() {
+  const { mkdirSync } = require('node:fs');
+  try {
+    mkdirSync(TS_STATE_DIR, { recursive: true });
+  } catch { /* ignore */ }
+}
+
+/**
+ * Check if tailscale binary exists and is executable.
+ */
+export function isTailscaleInstalled() {
+  try {
+    execFileSync('tailscale', ['version'], { encoding: 'utf8', timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if already authenticated with Tailscale.
+ * Returns { authenticated, hostname, backendState }.
+ */
+export async function ensureTailscaleAuth() {
+  if (!isTailscaleInstalled()) {
+    return { authenticated: false, message: 'Tailscale not installed' };
+  }
+  try {
+    const result = execFileSync('tailscale', ['status', '--json'], { encoding: 'utf8', timeout: 5000 });
+    const status = JSON.parse(result);
+    return {
+      authenticated: !!status.Self?.Online,
+      hostname: (status.Self?.DNSName || '').split('.')[0],
+      backendState: status.BackendState || 'unknown',
+    };
+  } catch {
+    if (!TS_AUTHKEY) {
+      return { authenticated: false, message: 'No TAILSCALE_AUTHKEY env var set' };
+    }
+    // Authenticate with auth key
+    console.log(chalk.dim('  Authenticating with Tailscale...'));
+    try {
+      execFileSync('tailscale', ['up', '--authkey=' + TS_AUTHKEY, '--hostname=bizar-dash'], { encoding: 'utf8', timeout: 60000 });
+      return { authenticated: true, hostname: 'bizar-dash' };
+    } catch (err) {
+      return { authenticated: false, message: 'Auth failed: ' + (err.message || String(err)) };
+    }
+  }
+}
+
+/**
+ * Set up tailscale serve for the dashboard.
+ */
+export async function setupTailscaleServe({ dashboardPort = 4097, path = '/', https = 443 }) {
+  const authResult = await ensureTailscaleAuth();
+  if (!authResult.authenticated) {
+    console.error(chalk.red('  ✗ Tailscale not authenticated'));
+    return { ok: false, reason: 'not_authenticated' };
+  }
+
+  // Remove existing serve config
+  try {
+    execFileSync('tailscale', ['serve', '--https=443', 'off'], { encoding: 'utf8', timeout: 5000 });
+  } catch { /* ignore — might not have existing config */ }
+
+  // Set up new serve config
+  try {
+    execFileSync('tailscale', [
+      'serve', '--bg', `--https=${https}`, `--set-path=${path}`,
+      `http://localhost:${dashboardPort}`,
+    ], { encoding: 'utf8', timeout: 30000 });
+  } catch (err) {
+    return { ok: false, reason: 'serve_setup_failed', error: err.message };
+  }
+
+  // Get the public URL
+  try {
+    const statusResult = execFileSync('tailscale', ['status', '--json'], { encoding: 'utf8', timeout: 5000 });
+    const status = JSON.parse(statusResult);
+    const url = `https://${(status.Self?.DNSName || '').split('.')[0]}`;
+
+    // Save config
+    ensureStateDir();
+    writeFileSync(TS_SERVE_CONFIG, JSON.stringify({
+      url,
+      port: dashboardPort,
+      https,
+      path,
+      setAt: new Date().toISOString(),
+    }, null, 2));
+
+    return { ok: true, url };
+  } catch (err) {
+    return { ok: false, reason: 'status_check_failed', error: err.message };
+  }
+}
+
+/**
+ * Remove tailscale serve configuration.
+ */
+export function unsetupTailscaleServe() {
+  try {
+    execFileSync('tailscale', ['serve', 'reset'], { encoding: 'utf8', timeout: 10000 });
+    // Remove saved config
+    if (existsSync(TS_SERVE_CONFIG)) {
+      const { unlinkSync } = require('node:fs');
+      try { unlinkSync(TS_SERVE_CONFIG); } catch { /* ignore */ }
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Print the saved serve URL (if any).
+ */
+export function getServeUrl() {
+  try {
+    if (existsSync(TS_SERVE_CONFIG)) {
+      const cfg = JSON.parse(readFileSync(TS_SERVE_CONFIG, 'utf8'));
+      return cfg.url || null;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+export function showTailscaleStatus() {
+  if (!isTailscaleInstalled()) {
+    console.error(chalk.red('  ✗ tailscale not found or not installed'));
+    console.error('  Install: https://tailscale.com/download');
+    return;
+  }
+  try {
+    const result = execFileSync('tailscale', ['status'], { encoding: 'utf8', timeout: 5000 });
+    console.log(result);
+
+    // Also show serve URL if configured
+    const url = getServeUrl();
+    if (url) {
+      console.log(chalk.dim(`  Serve URL: ${url}`));
+    }
+  } catch (err) {
+    console.error(chalk.red('  ✗ Failed to get tailscale status'));
+    console.error('  ', err.message);
+  }
+}
+
+export function showTailscaleHelp() {
+  console.log(`
+  bizar tailscale — Manage Tailscale integration for the dashboard
+
+  Usage:
+    bizar tailscale status              Show Tailscale auth + serve status
+    bizar tailscale auth                Authenticate with auth key (from env TAILSCALE_AUTHKEY)
+    bizar tailscale serve               Set up tailscale serve for the dashboard
+    bizar tailscale unserve             Remove tailscale serve
+    bizar tailscale url                 Print the public dashboard URL
+
+  Env vars:
+    TAILSCALE_AUTHKEY                   Auth key for non-interactive auth
+    TAILSCALE_STATE_DIR                 Where to store Tailscale state (default ~/.local/share/bizar/tailscale)
+    BIZAR_TAILSCALE_AUTOSETUP=1        Auto-setup tailscale serve when running 'bizar dash start'
+
+  Examples:
+    TAILSCALE_AUTHKEY=tskey-... bizar tailscale auth
+    TAILSCALE_AUTHKEY=tskey-... bizar tailscale serve
+    bizar tailscale unserve
+  `);
+}
+
+/**
+ * Main entry point for the `bizar tailscale` CLI command.
+ */
+export async function run(name, args, isHelpRequest) {
+  if (isHelpRequest || args.length === 0 || args[0] === 'help') {
+    showTailscaleHelp();
+    return;
+  }
+
+  const sub = args[0];
+
+  switch (sub) {
+    case 'status': {
+      showTailscaleStatus();
+      break;
+    }
+    case 'auth': {
+      const result = await ensureTailscaleAuth();
+      if (result.authenticated) {
+        console.log(chalk.green(`  ✓ Authenticated as ${result.hostname}`));
+      } else {
+        console.error(chalk.red(`  ✗ Not authenticated: ${result.message}`));
+        if (!TS_AUTHKEY) {
+          console.error(chalk.dim('  Set TAILSCALE_AUTHKEY env var and try again'));
+        }
+      }
+      break;
+    }
+    case 'serve': {
+      const result = await setupTailscaleServe({ dashboardPort: 4321 });
+      if (result.ok) {
+        console.log(chalk.green(`  ✓ Tailscale serve: ${result.url}`));
+      } else {
+        console.error(chalk.red(`  ✗ Serve setup failed: ${result.reason}`));
+      }
+      break;
+    }
+    case 'unset': {
+      const result = unsetupTailscaleServe();
+      if (result.ok) {
+        console.log(chalk.green('  ✓ Tailscale serve removed'));
+      } else {
+        console.error(chalk.red(`  ✗ ${result.error}`));
+      }
+      break;
+    }
+    case 'url': {
+      const url = getServeUrl();
+      if (url) {
+        console.log(url);
+      } else {
+        console.error(chalk.red('  ✗ No serve URL configured'));
+      }
+      break;
+    }
+    default: {
+      console.error(chalk.red(`  ✗ Unknown subcommand: ${sub}`));
+      showTailscaleHelp();
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "5.0.2",
+  "version": "5.2.0",
   "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": {