@polderlabs/bizar 5.1.0 → 5.3.0

package/bizar-dash/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -1 +1 @@
-{"version":"4.1.9","results":[[":tests/lib/utils.test.ts",{"duration":28.89169000000004,"failed":false}],[":tests/components/Button.test.tsx",{"duration":117.69011,"failed":false}],[":tests/components/Card.test.tsx",{"duration":30.92253400000004,"failed":false}],[":tests/hooks/useModal.test.tsx",{"duration":119.64900699999998,"failed":false}],[":tests/components/Toast.test.tsx",{"duration":159.04681100000005,"failed":false}],[":tests/components/Modal.test.tsx",{"duration":150.9410469999999,"failed":false}],[":tests/lib/i18n.test.ts",{"duration":3.2969249999999874,"failed":false}],[":tests/components/StatusBadge.test.tsx",{"duration":41.157249999999976,"failed":false}],[":tests/hooks/useToast.test.tsx",{"duration":104.85745599999996,"failed":false}],[":tests/components/Spinner.test.tsx",{"duration":70.16560200000004,"failed":false}],[":tests/backup-restore.test.tsx",{"duration":179.13565300000005,"failed":false}],[":tests/a11y.test.tsx",{"duration":715.4879470000001,"failed":false}],[":tests/lib/search-fuzzy.test.ts",{"duration":7.532295999999974,"failed":false}],[":tests/components/settings-search.test.tsx",{"duration":712.275263,"failed":false}],[":tests/memory-graph-view.test.tsx",{"duration":59.40099399999997,"failed":false}],[":tests/components/workspace-selector.test.tsx",{"duration":113.71114899999998,"failed":false}],[":tests/components/screenshot-ocr.test.tsx",{"duration":51.13657699999999,"failed":false}],[":tests/voice-recorder.test.tsx",{"duration":128.61647900000003,"failed":false}],[":tests/autosave.test.tsx",{"duration":251.98326499999996,"failed":false}],[":tests/settings-layout.test.tsx",{"duration":201.76037699999995,"failed":false}],[":tests/settings-nav.test.tsx",{"duration":228.42296299999998,"failed":false}],[":tests/components/doctor-panel.test.tsx",{"duration":67.53857800000003,"failed":false}],[":tests/chat-composer.test.tsx",{"duration":189.9785320000001,"failed":false}],[":tests/settings-mode-wiring.test.tsx",{"duration":205.661208,"failed":false}],[":tests/minimax-bar.test.ts",{"duration":0,"failed":true}],[":tests/minimax-bar.test.tsx",{"duration":30.342043999999987,"failed":false}]]}
+{"version":"4.1.9","results":[[":tests/lib/utils.test.ts",{"duration":20.318142999999964,"failed":false}],[":tests/components/Button.test.tsx",{"duration":97.09901500000001,"failed":false}],[":tests/components/Card.test.tsx",{"duration":25.56895700000001,"failed":false}],[":tests/hooks/useModal.test.tsx",{"duration":156.274812,"failed":false}],[":tests/components/Toast.test.tsx",{"duration":170.42815400000006,"failed":false}],[":tests/components/Modal.test.tsx",{"duration":189.45819300000005,"failed":false}],[":tests/lib/i18n.test.ts",{"duration":4.330512999999996,"failed":false}],[":tests/components/StatusBadge.test.tsx",{"duration":25.465268000000037,"failed":false}],[":tests/hooks/useToast.test.tsx",{"duration":124.75983200000007,"failed":false}],[":tests/components/Spinner.test.tsx",{"duration":56.78095799999994,"failed":false}],[":tests/backup-restore.test.tsx",{"duration":203.898414,"failed":false}],[":tests/a11y.test.tsx",{"duration":896.8848140000001,"failed":false}],[":tests/lib/search-fuzzy.test.ts",{"duration":6.686229000000026,"failed":false}],[":tests/components/settings-search.test.tsx",{"duration":722.1675959999999,"failed":false}],[":tests/memory-graph-view.test.tsx",{"duration":40.353496000000064,"failed":false}],[":tests/components/workspace-selector.test.tsx",{"duration":143.099331,"failed":false}],[":tests/components/screenshot-ocr.test.tsx",{"duration":30.485972000000004,"failed":false}],[":tests/voice-recorder.test.tsx",{"duration":139.93698299999994,"failed":false}],[":tests/autosave.test.tsx",{"duration":268.4993979999999,"failed":false}],[":tests/settings-layout.test.tsx",{"duration":246.68477299999995,"failed":false}],[":tests/settings-nav.test.tsx",{"duration":330.9125980000001,"failed":false}],[":tests/components/doctor-panel.test.tsx",{"duration":82.28221499999995,"failed":false}],[":tests/chat-composer.test.tsx",{"duration":279.32558600000004,"failed":false}],[":tests/settings-mode-wiring.test.tsx",{"duration":283.47341000000006,"failed":false}],[":tests/minimax-bar.test.ts",{"duration":0,"failed":true}],[":tests/minimax-bar.test.tsx",{"duration":23.41428499999995,"failed":false}],[":tests/components/plugin-permissions.test.tsx",{"duration":127.94786099999999,"failed":false}],[":tests/eval-web-ui.test.tsx",{"duration":147.663952,"failed":false}],[":tests/components/marketplace-plugin-card.test.tsx",{"duration":175.07474200000001,"failed":false}],[":tests/a11y/components.test.tsx",{"duration":128.34057200000007,"failed":false}],[":tests/a11y/forms.test.tsx",{"duration":86.17374700000005,"failed":true}],[":tests/a11y/navigation.test.tsx",{"duration":136.026924,"failed":true}]]}

package/bizar-dash/src/server/api.mjs

@@ -181,6 +181,10 @@ export async function createApiRouter({
   // v5.0.0 — Screenshot OCR routes. Accepts images, extracts text.
   const { createOcrRouter } = await import('./routes/ocr.mjs');
   router.use(await createOcrRouter({ projectRoot }));
+  // v5.2 — Tailscale auth key integration. Registered before misc.mjs so
+  // /tailscale/* routes here take precedence over any overlapping misc routes.
+  const { createTailscaleRouter } = await import('./routes/tailscale.mjs');
+  router.use(createTailscaleRouter({}));
   router.use(createMiscRouter({ state, broadcast }));
 
   // /api/auth/* must be reachable WITHOUT the bearer token so a fresh

package/bizar-dash/src/server/eval-store.mjs

@@ -22,6 +22,10 @@ const STORE_HOME = process.env.BIZAR_STORE_HOME
   : join(homedir(), '.local', 'share', 'bizar');
 const EVAL_DIR = join(STORE_HOME, 'eval');
 const INDEX_FILE = join(EVAL_DIR, '.index.json');
+const CONFIG_DIR = process.env.BIZAR_EVAL_CONFIG_DIR
+  ? process.env.BIZAR_EVAL_CONFIG_DIR
+  : join(homedir(), '.config', 'bizar');
+const SCHEDULES_FILE = join(CONFIG_DIR, 'eval-schedules.json');
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -210,6 +214,57 @@ export function buildRunId() {
   return `run_${ts}_${rand}`;
 }
 
+// ── Eval schedules ───────────────────────────────────────────────────────────
+
+function loadSchedules() {
+  return safeReadJSON(SCHEDULES_FILE, []);
+}
+
+function saveSchedulesIndex(schedules) {
+  ensureDir(join(homedir(), '.config', 'bizar'));
+  atomicWriteJson(SCHEDULES_FILE, schedules);
+}
+
+/**
+ * Register a new eval schedule.
+ *
+ * @param {{ name: string, suitePath: string, cron: string, agent?: string }} opts
+ * @returns {{ id: string, name: string, suitePath: string, cron: string, agent: string }}
+ */
+export function registerEvalSchedule({ name, suitePath, cron, agent = 'thor' }) {
+  const schedules = loadSchedules();
+  const id = `eval_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+  const schedule = { id, name, suitePath, cron, agent };
+  schedules.push(schedule);
+  saveSchedulesIndex(schedules);
+  return schedule;
+}
+
+/**
+ * List all eval schedules.
+ *
+ * @returns {Array<{ id: string, name: string, suitePath: string, cron: string, agent: string }>}
+ */
+export function listEvalSchedules() {
+  return loadSchedules();
+}
+
+/**
+ * Delete an eval schedule by id.
+ *
+ * @param {string} id
+ * @returns {{ ok: boolean }}
+ */
+export function deleteEvalSchedule(id) {
+  if (!id) return { ok: false };
+  const schedules = loadSchedules();
+  const idx = schedules.findIndex((s) => s.id === id);
+  if (idx < 0) return { ok: false };
+  schedules.splice(idx, 1);
+  saveSchedulesIndex(schedules);
+  return { ok: true };
+}
+
 // ── Test reset ────────────────────────────────────────────────────────────────
 
 /**

package/bizar-dash/src/server/eval.mjs

@@ -358,6 +358,69 @@ export async function runFixtureById(
   return runFixture(fixture, { llmCall, timeoutMs, toolCalls });
 }
 
+// ── CSV export ────────────────────────────────────────────────────────────────
+
+/**
+ * Convert an array of EvalResult to CSV format.
+ *
+ * @param {object[]} results
+ * @returns {string}
+ */
+export function toCSV(results) {
+  const headers = [
+    'fixture_id',
+    'name',
+    'agent',
+    'ok',
+    'pass_count',
+    'fail_count',
+    'latency_ms',
+    'tokens',
+    'timestamp',
+  ];
+  const rows = results.map((r) => [
+    r.fixtureId,
+    r.name || '',
+    r.agent || '',
+    r.ok ? '1' : '0',
+    r.checks?.filter((c) => c.pass).length || 0,
+    r.checks?.filter((c) => !c.pass).length || 0,
+    r.latencyMs || 0,
+    r.usage?.total_tokens || 0,
+    r.timestamp || '',
+  ]);
+
+  return [headers, ...rows]
+    .map((row) =>
+      row
+        .map((cell) => {
+          const s = String(cell);
+          return s.includes(',') || s.includes('"') || s.includes('\n')
+            ? `"${s.replace(/"/g, '""')}"`
+            : s;
+        })
+        .join(',')
+    )
+    .join('\n');
+}
+
+/**
+ * Run a suite and return both the run result and CSV export.
+ *
+ * @param {string} suitePath
+ * @param {{ llmCall?: Function, concurrency?: number, timeoutMs?: number }} opts
+ * @returns {Promise<{ run: object, csv: string }>}
+ */
+export async function runSuiteAndExport(suitePath, opts) {
+  const run = await runSuite(suitePath, opts);
+  return {
+    run,
+    csv: toCSV(run.results),
+  };
+}
+
+// ── Fixture loading ─────────────────────────────────────────────────────────
+
 /**
  * Load all JSON fixtures from a directory.
  *

package/bizar-dash/src/server/plugins/permission-audit.mjs

@@ -0,0 +1,109 @@
+/**
+ * src/server/plugins/permission-audit.mjs
+ *
+ * v5.3.0 — Audit log for plugin permission uses.
+ *
+ * Every call to `safeInvoke` (and every successful run after the
+ * permission check) emits one entry here. The audit log is in-memory
+ * (bounded to 1000 entries — older entries are evicted FIFO) because
+ * it is meant for live UI ("who invoked what on which plugin in the
+ * last hour") and for incident triage, not for permanent record
+ * keeping. For long-term storage, extend this module with a sink that
+ * writes to disk or to a structured-log aggregator.
+ *
+ * Why a separate module?
+ *   - `sandbox.mjs` stays focused on the execution boundary.
+ *   - `routes/plugins.mjs` and any future admin UI can read the log
+ *     without importing the entire sandbox.
+ *   - Tests can `clearPermissionAuditLog()` between cases.
+ */
+import * as logger from '../logger.mjs';
+
+/** Bounded ring buffer of audit entries; trimmed at 1000. */
+const auditLog = [];
+
+/** Hard cap to bound memory; oldest entries fall off. */
+const MAX_AUDIT_ENTRIES = 1000;
+
+/**
+ * @typedef {{
+ *   timestamp: string,
+ *   pluginId: string,
+ *   method: string,
+ *   permission: string,
+ *   allowed: boolean
+ * }} PermissionAuditEntry
+ */
+
+/**
+ * Record a permission use (allowed or denied) for one method call.
+ *
+ * @param {string} pluginId    plugin identifier (matches `loaded.id` or
+ *                             `installed.id`)
+ * @param {string} method      method name invoked
+ * @param {string} permission  comma-joined permission names that the
+ *                             method was checked against; pass `'none'`
+ *                             if no permissions were required
+ * @param {boolean} allowed    true if the call was allowed, false if it
+ *                             was rejected with permission_denied
+ */
+export function logPermissionUse(pluginId, method, permission, allowed) {
+  const entry = {
+    timestamp: new Date().toISOString(),
+    pluginId: pluginId || 'unknown',
+    method: method || '',
+    permission: permission || 'none',
+    allowed: !!allowed,
+  };
+  auditLog.push(entry);
+  // FIFO eviction — keep memory bounded without losing the most recent
+  // activity, which is what the UI typically wants.
+  while (auditLog.length > MAX_AUDIT_ENTRIES) {
+    auditLog.shift();
+  }
+  logger.info('plugin.permission.use', {
+    module: 'plugin-audit',
+    pluginId: entry.pluginId,
+    method: entry.method,
+    permission: entry.permission,
+    allowed: entry.allowed,
+  });
+}
+
+/**
+ * Read recent audit entries, optionally filtered by plugin.
+ * Returns newest-first so the UI can render a live list directly.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.pluginId]  if set, only entries for this plugin
+ * @param {number} [opts.limit=50]  max entries to return
+ * @returns {PermissionAuditEntry[]}
+ */
+export function getPermissionAuditLog({ pluginId, limit = 50 } = {}) {
+  let entries = auditLog;
+  if (pluginId) {
+    entries = entries.filter((e) => e.pluginId === pluginId);
+  }
+  // `slice(-limit)` gives the last `limit` entries in chronological order;
+  // reversing once gives newest-first for the API consumer.
+  return entries.slice(-limit).reverse();
+}
+
+/**
+ * Wipe all audit entries. Used by tests in `beforeEach` so cases are
+ * isolated. Not exposed via any HTTP route — admin tools that want to
+ * reset the buffer should not exist (the audit log is read-only).
+ */
+export function clearPermissionAuditLog() {
+  auditLog.length = 0;
+}
+
+/**
+ * Test/internal: expose the current entry count so routes can detect
+ * when the buffer was emptied by an outside test runner. Not exported
+ * in the public surface; consumers should treat the audit log as
+ * opaque.
+ */
+export function _permissionAuditLength() {
+  return auditLog.length;
+}

package/bizar-dash/src/server/plugins/sandbox.mjs

@@ -33,6 +33,7 @@ import { readFileSync, statSync } from 'node:fs';
 import { resolve as pathResolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import * as logger from '../logger.mjs';
+import { logPermissionUse } from './permission-audit.mjs';
 
 /** Default timeout for both script compile + async method execution. */
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -380,7 +381,20 @@ function safeStringify(value) {
  * @param {number} [opts.timeoutMs]
  * @param {number} [opts.memoryLimitMb]
  * @param {typeof globalThis.fetch} [opts.fetchImpl]
- * @returns {Promise<Record<string, Function>>}
+ * @param {Array<{ name: string, permissions?: string[] }>} [opts.methodSpecs]
+ *     Per-method permission declarations from `plugin.json`'s
+ *     `exports` array. Each entry is `{ name, permissions }`; used by
+ *     `safeInvoke` to enforce method-level permission checks before
+ *     invoking. Optional — a plugin loaded without this field gets no
+ *     method-level gating (legacy behaviour).
+ * @returns {Promise<{
+ *   exports: Record<string, Function>,
+ *   permissions: Set<string>,
+ *   invalidPermissions: string[],
+ *   memoryLimitMb: number,
+ *   api: object,
+ *   methodSpecs: Array<{ name: string, permissions?: string[] }>
+ * }>}
  */
 export async function loadPlugin(opts) {
   const {
@@ -393,6 +407,7 @@ export async function loadPlugin(opts) {
     timeoutMs = DEFAULT_TIMEOUT_MS,
     memoryLimitMb = DEFAULT_MEMORY_LIMIT_MB,
     fetchImpl,
+    methodSpecs = [],
   } = opts;
 
   if (!mainFile || typeof mainFile !== 'string') {
@@ -494,24 +509,79 @@ export async function loadPlugin(opts) {
     invalidPermissions: invalid,
     memoryLimitMb,
     api,
+    methodSpecs: Array.isArray(methodSpecs) ? methodSpecs : [],
+    // Stash the plugin id on the loaded object so safeInvoke can
+    // write it to the audit log without callers having to thread it
+    // through as a separate argument (compatible with the v5.0
+    // invocation shape).
+    pluginId,
   };
 }
 
+/**
+ * v5.3.0 helper — normalise whatever shape `loaded.permissions` was
+ * stored as into a plain array. `loadPlugin` uses a `Set` internally,
+ * but tests may pass an `Array`, and `loaded.permissions` may also be
+ * missing entirely (older callers). Always returns an array of strings.
+ *
+ * @param {unknown} perms
+ * @returns {string[]}
+ */
+function permissionsAsArray(perms) {
+  if (!perms) return [];
+  if (perms instanceof Set) return [...perms];
+  if (Array.isArray(perms)) return perms.filter((p) => typeof p === 'string');
+  return [];
+}
+
 /**
  * Invoke a method on a loaded plugin inside a sandbox timeout race.
  * Returns `{ ok: true, result }` on success, `{ ok: false, error }`
  * on any throw (including permission errors, timeouts, plugin bugs).
  *
+ * v5.3.0 — method-level permission enforcement: when `loaded.methodSpecs`
+ * is populated (from plugin.json's `exports` array), `safeInvoke` checks
+ * the called method's declared permissions against the plugin's granted
+ * permissions BEFORE running. A denial is recorded in the audit log
+ * (`permission-audit.mjs`) and returned with `code: 'permission_denied'`
+ * and a `missing` array listing the ungranted permissions.
+ *
  * @param {object} loaded  return value of loadPlugin()
  * @param {string} method  method name on the plugin's exports
  * @param {unknown[]} args
  * @param {number} [timeoutMs]
- * @returns {Promise<{ ok: true, result: unknown } | { ok: false, error: string, code?: string }>}
+ * @returns {Promise<{ ok: true, result: unknown } | { ok: false, error: string, code?: string, missing?: string[] }>}
  */
 export async function safeInvoke(loaded, method, args = [], timeoutMs = DEFAULT_TIMEOUT_MS) {
   if (!loaded || typeof loaded !== 'object') {
     return { ok: false, error: 'plugin not loaded', code: 'not_loaded' };
   }
+
+  // v5.3.0 — method-level permission enforcement. Uses
+  // `loaded.methodSpecs` (a copy of plugin.json's `exports` array, each
+  // entry shaped `{ name, permissions?: string[] }`). When the plugin
+  // declares no method-level permissions, we skip the check entirely
+  // (backward compatibility for plugins loaded without a manifest).
+  const pluginId = loaded.pluginId || loaded.id || 'unknown';
+  const methodSpecs = Array.isArray(loaded.methodSpecs) ? loaded.methodSpecs : [];
+  const methodSpec = methodSpecs.find((s) => s && s.name === method);
+  if (methodSpec) {
+    const required = Array.isArray(methodSpec.permissions) ? methodSpec.permissions : [];
+    const grantedArr = permissionsAsArray(loaded.permissions);
+    const missing = required.filter((p) => !grantedArr.includes(p));
+    if (missing.length > 0) {
+      logPermissionUse(pluginId, method, missing.join(','), false);
+      return {
+        ok: false,
+        error: `Method "${method}" requires permissions: ${missing.join(', ')}`,
+        code: 'permission_denied',
+        missing,
+      };
+    }
+    // Allowed — log the granted set (or 'none' if no perms required).
+    logPermissionUse(pluginId, method, required.join(',') || 'none', true);
+  }
+
   const fn = loaded.exports && loaded.exports[method];
   if (typeof fn !== 'function') {
     return {
@@ -586,6 +656,9 @@ export async function loadAndInvoke(opts) {
       pluginRoot: opts.pluginRoot,
       timeoutMs: opts.timeoutMs,
       fetchImpl: opts.fetchImpl,
+      // v5.3.0 — wire method-level permissions through from the manifest
+      // so safeInvoke can enforce them.
+      methodSpecs: Array.isArray(manifest.exports) ? manifest.exports : [],
     });
   } catch (err) {
     return {
@@ -652,4 +725,5 @@ export const __testing = {
   DEFAULT_MEMORY_LIMIT_MB,
   ALLOWED_GLOBALS,
   KNOWN_PERMS,
+  permissionsAsArray,
 };

package/bizar-dash/src/server/plugins/store.mjs

@@ -628,6 +628,10 @@ export async function invokePlugin(pluginId, method, args = [], opts = {}) {
       pluginRoot: pluginDir,
       timeoutMs: opts.timeoutMs,
       fetchImpl: opts.fetchImpl,
+      // v5.3.0 — pass method-level permission declarations through to
+      // the sandbox so `safeInvoke` can enforce them. Manifest defaults
+      // to an empty array (readManifest normalises missing exports).
+      methodSpecs: Array.isArray(manifest.exports) ? manifest.exports : [],
     });
   } catch (err) {
     return { ok: false, error: err.message, code: err.code || 'load_error' };

package/bizar-dash/src/server/routes/eval.mjs

@@ -14,8 +14,8 @@
  * via the state for custom providers.
  */
 import { Router } from 'express';
-import { loadFixtures, runFixture, runSuite } from '../eval.mjs';
-import { saveRun, listRuns, getRun, compareRuns, buildRunId } from '../eval-store.mjs';
+import { loadFixtures, runFixture, runSuite, toCSV } from '../eval.mjs';
+import { saveRun, listRuns, getRun, compareRuns, buildRunId, registerEvalSchedule, listEvalSchedules, deleteEvalSchedule } from '../eval-store.mjs';
 import { chatCompletion } from '../minimax.mjs';
 import { wrap } from './_shared.mjs';
 
@@ -45,6 +45,19 @@ export function createEvalRouter({ state, broadcast }) {
     res.json(run);
   }));
 
+  // GET /api/eval/runs/:id/export.csv — download run results as CSV
+  router.get('/eval/runs/:id/export.csv', wrap(async (req, res) => {
+    const run = await getRun(req.params.id);
+    if (!run) {
+      res.status(404).json({ error: 'not_found', message: `run ${req.params.id} not found` });
+      return;
+    }
+    const csv = toCSV(run.results || []);
+    res.set('Content-Type', 'text/csv; charset=utf-8');
+    res.set('Content-Disposition', `attachment; filename="eval-${req.params.id}.csv"`);
+    res.send(csv);
+  }));
+
   // GET /api/eval/fixtures — list fixtures in a suite path
   router.get('/eval/fixtures', wrap(async (req, res) => {
     const { path: suitePath } = req.query;
@@ -143,5 +156,32 @@ export function createEvalRouter({ state, broadcast }) {
     res.json(diff);
   }));
 
+  // GET /api/eval/schedules — list all eval schedules
+  router.get('/eval/schedules', wrap(async (req, res) => {
+    const schedules = await listEvalSchedules();
+    res.json({ schedules });
+  }));
+
+  // POST /api/eval/schedules — create a new eval schedule
+  router.post('/eval/schedules', wrap(async (req, res) => {
+    const { name, suitePath, cron, agent } = req.body || {};
+    if (!name || !suitePath || !cron) {
+      res.status(400).json({ error: 'bad_request', message: 'name, suitePath, and cron are required' });
+      return;
+    }
+    const schedule = await registerEvalSchedule({ name, suitePath, cron, agent });
+    res.status(201).json(schedule);
+  }));
+
+  // DELETE /api/eval/schedules/:id — delete an eval schedule
+  router.delete('/eval/schedules/:id', wrap(async (req, res) => {
+    const result = await deleteEvalSchedule(req.params.id);
+    if (!result.ok) {
+      res.status(404).json({ error: 'not_found', message: `schedule ${req.params.id} not found` });
+      return;
+    }
+    res.json({ ok: true });
+  }));
+
   return router;
 }

package/bizar-dash/src/server/routes/plugins.mjs

@@ -29,6 +29,7 @@ import { withSpan, setCommonAttributes } from '../otel.mjs';
 import { recordTrace } from '../metrics.mjs';
 import * as registry from '../plugins/registry.mjs';
 import * as store from '../plugins/store.mjs';
+import { getPermissionAuditLog } from '../plugins/permission-audit.mjs';
 
 /**
  * @returns {import('express').Router}
@@ -134,10 +135,18 @@ export function createPluginsRouter() {
       userAgent: _req.headers?.['user-agent'],
     });
     const installed = store.listInstalled();
-    span.setAttribute('plugin.installed.count', installed.length);
-    res.json({ plugins: installed });
+    const enhanced = installed.map(p => ({
+      ...p,
+      permissions: p.permissions || [],
+      config: p.config || {},
+      methodCount: p.methodCount || 0,
+      invocations: p.invocations || 0,
+      lastInvokedAt: p.lastInvokedAt || null,
+    }));
+    span.setAttribute('plugin.installed.count', enhanced.length);
+    res.json({ plugins: enhanced });
     recordTrace('plugin.installed.list', {
-      count_bucket: installed.length === 0 ? '0' : installed.length < 10 ? '1-9' : '10+',
+      count_bucket: enhanced.length === 0 ? '0' : enhanced.length < 10 ? '1-9' : '10+',
     });
   })));
 
@@ -307,21 +316,60 @@ export function createPluginsRouter() {
     }
     // Distinguish "this is a plugin bug" (500) from "this is a usage
     // error" (400/404) so the client can decide whether to retry.
+    // v5.3.0 — `permission_denied` returns HTTP 403 (Forbidden) since
+    // the request is well-formed but the caller is not authorised to
+    // invoke the method. All other usage errors stay at 400.
     const usageCodes = new Set([
       'not_installed',
       'no_such_method',
       'bad_manifest',
-      'permission_denied',
       'corrupt_install',
     ]);
-    const status = usageCodes.has(result.code) ? 400 : 500;
+    let status;
+    if (result.code === 'permission_denied') {
+      status = 403;
+    } else if (usageCodes.has(result.code)) {
+      status = 400;
+    } else {
+      status = 500;
+    }
     span.setAttribute('plugin.invoke.error_code', result.code || 'unknown');
-    res.status(status).json(result);
+    if (result.code === 'permission_denied') {
+      span.setAttribute('plugin.invoke.permission_missing',
+        (result.missing || []).join(','));
+    }
+    res.status(status).json({
+      error: result.code || 'plugin_error',
+      message: result.error,
+      ...(result.code === 'permission_denied'
+        ? { missing: result.missing }
+        : {}),
+      ...(result.permission ? { permission: result.permission } : {}),
+    });
     recordTrace('plugin.invoke', {
-      outcome: 'error',
+      outcome: result.code === 'permission_denied' ? 'permission_denied' : 'error',
       code: result.code || 'unknown',
     });
   })));
 
+  // ── GET /api/plugins/:id/audit ─────────────────────────────────────────
+  // v5.3.0 — return the in-memory permission audit log for one plugin
+  // (newest-first). Bounded to 50 entries by default; pass `?limit=N`
+  // to fetch up to the buffer's full capacity. The route is read-only
+  // — admin tools should not clear the log from here.
+  router.get('/plugins/:id/audit', wrap(withSpan('plugin.audit.get', async (span, req, res) => {
+    setCommonAttributes(span, {
+      ip: req.ip || req.socket?.remoteAddress,
+      userAgent: req.headers?.['user-agent'],
+    });
+    span.setAttribute('plugin.id', req.params.id || '');
+    const limit = Number.isFinite(Number(req.query?.limit))
+      ? Math.max(1, Math.min(1000, Number(req.query.limit)))
+      : 50;
+    const audit = getPermissionAuditLog({ pluginId: req.params.id, limit });
+    res.json({ audit });
+    recordTrace('plugin.audit.get', { count: audit.length });
+  })));
+
   return router;
 }

package/bizar-dash/src/server/routes/tailscale.mjs

@@ -0,0 +1,46 @@
+/**
+ * src/server/routes/tailscale.mjs
+ *
+ * v5.2 — Tailscale auth key integration endpoints.
+ *
+ * Endpoints:
+ *   GET  /api/tailscale/status   — tailscale state (installed, authenticated, serve config)
+ *   POST /api/tailscale/setup    — authenticate + set up tailscale serve
+ *   POST /api/tailscale/unserve — remove tailscale serve
+ */
+import { Router } from 'express';
+import { tailscaleStore } from '../tailscale-store.mjs';
+import { wrap } from './_shared.mjs';
+
+/**
+ * @param {object} _deps
+ * @returns {import('express').Router}
+ */
+export function createTailscaleRouter(_deps) {
+  const router = Router();
+
+  // GET /api/tailscale/status
+  router.get('/status', wrap(async (_req, res) => {
+    res.json(await tailscaleStore.status());
+  }));
+
+  // POST /api/tailscale/setup — authenticate + enable serve
+  // Body: { authKey?: string, port?: number, https?: boolean, hostname?: string }
+  router.post('/setup', wrap(async (req, res) => {
+    const { authKey, port = 4321, https = true, hostname = '' } = req.body || {};
+    // If authKey is provided, set it in env for tailscale-store to pick up
+    if (authKey) {
+      process.env.TAILSCALE_AUTHKEY = authKey;
+    }
+    // delegates to tailscaleStore.enable() which runs `tailscale serve ...`
+    const result = await tailscaleStore.enable({ port, https, hostname });
+    res.json(result);
+  }));
+
+  // POST /api/tailscale/unserve — remove tailscale serve
+  router.post('/unserve', wrap(async (_req, res) => {
+    res.json(await tailscaleStore.disable());
+  }));
+
+  return router;
+}