nexus-prime 6.5.0 → 6.6.0

package/dist/cli/install-wizard.js

@@ -364,17 +364,40 @@ export async function cliSetup(opts = []) {
     if (cleanup.staleLockfilesRemoved + cleanup.staleDaemonsKilled > 0) {
         log(`  ${c('↺', 'dim')} Cleaned ${cleanup.staleLockfilesRemoved} lockfiles, stopped ${cleanup.staleDaemonsKilled} stale daemons`);
     }
-    // Step 1 — detect + configure IDEs
+    // Step 1 — detect + configure IDEs (per-IDE animated checklist)
     const totalSteps = options.licenseKey ? 5 : 4;
     step(1, totalSteps, 'Detecting IDEs…');
+    // Emit install.step event helper (best-effort; daemon may not be running yet)
+    const emitInstallStep = (stepN, total, label, status, detail) => {
+        try {
+            import('../engines/event-bus.js').then(({ nexusEventBus }) => {
+                nexusEventBus.emit('install.step', { step: stepN, total, label, status, detail });
+            }).catch(() => { });
+        }
+        catch { /* non-fatal */ }
+    };
     const result = await runInstallWizard({ dryRun, verbose: false });
-    if (result.configured.length > 0) {
-        log(`  ${c('✓', 'green')} Configured: ${c(result.configured.join(', '), 'cyan')}`);
-    }
-    if (result.skipped.length > 0) {
-        log(`  ${c('✓', 'green')} Already set up: ${c(result.skipped.join(', '), 'dim')}`);
+    const allIDEs = [...result.configured, ...result.skipped, ...result.errors.map(e => e.ide)];
+    if (allIDEs.length > 0) {
+        for (const ide of allIDEs) {
+            const isConfigured = result.configured.includes(ide);
+            const isSkipped = result.skipped.includes(ide);
+            const errEntry = result.errors.find(e => e.ide === ide);
+            if (isConfigured) {
+                await withSpinner(`${ide} · configuring`, Promise.resolve());
+                emitInstallStep(1, totalSteps, ide, 'ok', 'MCP config written');
+            }
+            else if (isSkipped) {
+                log(`  ${c('─', 'dim')} ${c(ide, 'dim')} already set up`);
+                emitInstallStep(1, totalSteps, ide, 'skip', 'already configured');
+            }
+            else if (errEntry) {
+                log(`  ${c('✗', 'yellow')} ${c(ide, 'yellow')} · ${errEntry.reason}`);
+                emitInstallStep(1, totalSteps, ide, 'fail', errEntry.reason);
+            }
+        }
     }
-    if (result.configured.length === 0 && result.skipped.length === 0) {
+    else {
         log(`  ${c('—', 'dim')} No IDEs auto-detected. Run: nexus-prime setup <ide>`);
     }
     // Step 2 — MCP configs confirmed

package/dist/cli/watch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Nexus Prime — `nexus-prime watch`
+ * Tail live SSE events from the running daemon in a colored terminal feed.
+ */
+export interface WatchOptions {
+    port?: number;
+    all?: boolean;
+    filter?: string;
+}
+export declare function runWatch(opts?: WatchOptions): Promise<void>;

package/dist/cli/watch.js

@@ -0,0 +1,117 @@
+/**
+ * Nexus Prime — `nexus-prime watch`
+ * Tail live SSE events from the running daemon in a colored terminal feed.
+ */
+import * as http from 'http';
+const ANSI = {
+    cyan: '\x1b[36m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    magenta: '\x1b[35m',
+    red: '\x1b[31m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+    reset: '\x1b[0m',
+};
+const isTTY = process.stdout.isTTY === true && !process.env.NO_COLOR;
+const c = (s, k) => isTTY ? `${ANSI[k]}${s}${ANSI.reset}` : s;
+const DEFAULT_FILTER = /^(mcp\.|tokens\.|planner\.|phantom\.|license\.|install\.|orchestrator\.run)/;
+function colorForType(type) {
+    if (type.startsWith('mcp.'))
+        return 'cyan';
+    if (type.startsWith('tokens.'))
+        return 'yellow';
+    if (type.startsWith('license.'))
+        return 'magenta';
+    if (type.startsWith('phantom.'))
+        return 'green';
+    if (type.startsWith('install.'))
+        return 'green';
+    if (type.includes('error') || type.includes('fail') || type.includes('bad'))
+        return 'red';
+    return 'dim';
+}
+export async function runWatch(opts = {}) {
+    const port = opts.port ?? Number(process.env.NEXUS_DASHBOARD_PORT ?? 3377);
+    const filterRe = opts.all
+        ? null
+        : opts.filter
+            ? new RegExp(opts.filter)
+            : DEFAULT_FILTER;
+    console.log(c('◆ Nexus Prime · Live Event Tail', 'cyan'));
+    console.log(c(`  Stream: http://localhost:${port}/dashboard/events`, 'dim'));
+    console.log(c(`  Filter: ${filterRe ? filterRe.source : 'all events'}`, 'dim'));
+    console.log(c('  Press Ctrl-C to exit\n', 'dim'));
+    let buf = '';
+    const req = http.get({ hostname: 'localhost', port, path: '/dashboard/events', headers: { Accept: 'text/event-stream' } }, (res) => {
+        if (res.statusCode !== 200) {
+            console.error(c(`  ✗ Daemon not reachable (HTTP ${res.statusCode}). Start: nexus-prime daemon`, 'red'));
+            process.exit(1);
+        }
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+            buf += chunk;
+            const lines = buf.split('\n');
+            buf = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                try {
+                    const evt = JSON.parse(line.slice(6));
+                    const type = evt.type ?? evt.t ?? '';
+                    if (filterRe && !filterRe.test(type))
+                        continue;
+                    const payload = evt.payload ?? evt.data ?? evt.p ?? {};
+                    const summary = summarize(type, payload);
+                    const ts = new Date().toTimeString().slice(0, 8);
+                    process.stdout.write(`${c(ts, 'dim')} ${c(type.padEnd(36), colorForType(type))} ${summary}\n`);
+                }
+                catch { /* malformed JSON — skip */ }
+            }
+        });
+        res.on('error', (err) => {
+            console.error(c(`  Stream error: ${err.message}`, 'red'));
+            process.exit(1);
+        });
+        res.on('close', () => {
+            console.log(c('\n  Stream closed.', 'dim'));
+            process.exit(0);
+        });
+    });
+    req.on('error', (err) => {
+        console.error(c(`  ✗ Cannot connect to daemon on port ${port}: ${err.message}`, 'red'));
+        console.error(c('    Start daemon: nexus-prime daemon', 'dim'));
+        process.exit(1);
+    });
+    process.on('SIGINT', () => {
+        req.destroy();
+        console.log(c('\n  Bye.', 'dim'));
+        process.exit(0);
+    });
+}
+function summarize(type, payload) {
+    switch (type) {
+        case 'mcp.call.start':
+            return `→ ${payload.toolName ?? 'tool'}`;
+        case 'mcp.call.complete':
+            return payload.error
+                ? c(`✗ ${payload.toolName ?? 'tool'} · ${String(payload.error).slice(0, 60)}`, 'red')
+                : c(`✓ ${payload.toolName ?? 'tool'} · ${payload.durationMs ?? 0}ms`, 'green');
+        case 'tokens.optimized':
+            return `saved ${payload.savings ?? 0} · ${payload.pct ?? 0}% · src:${payload.source ?? 'unknown'}`;
+        case 'planner.stage':
+            return `${payload.stage ?? ''} · ${payload.status ?? ''}`;
+        case 'orchestrator.run.start':
+            return String(payload.goal ?? '').slice(0, 80);
+        case 'orchestrator.run.complete':
+            return `done · ${payload.durationMs ?? ''}ms`;
+        case 'license.tierChanged':
+            return `${payload.from ?? '?'} → ${String(payload.to ?? '?').toUpperCase()}`;
+        case 'license.upgradeNudge':
+            return String(payload.message ?? '').slice(0, 80);
+        case 'install.step':
+            return `[${payload.status ?? ''}] ${payload.label ?? ''} (${payload.step ?? '?'}/${payload.total ?? '?'})`;
+        default:
+            return String(payload.message ?? payload.summary ?? payload.goal ?? '').slice(0, 80);
+    }
+}

package/dist/cli.js

@@ -1894,6 +1894,20 @@ program
         timeoutMs: opts.timeout ? Number(opts.timeout) : undefined,
     });
 });
+program
+    .command('watch')
+    .description('Tail live SSE events from the running daemon in a colored terminal feed')
+    .option('--port <port>', 'Dashboard port (default: 3377 or $NEXUS_DASHBOARD_PORT)')
+    .option('--all', 'Show all event types (default: mcp, tokens, planner, license, install)')
+    .option('--filter <regex>', 'Custom event type filter (regex string)')
+    .action(async (opts) => {
+    const { runWatch } = await import('./cli/watch.js');
+    await runWatch({
+        port: opts.port ? Number(opts.port) : undefined,
+        all: opts.all,
+        filter: opts.filter,
+    });
+});
 // Default: running `nexus-prime` with no subcommand runs `setup auto`
 if (process.argv.length === 2) {
     process.argv.push('setup', 'auto');

package/dist/daemon/client.js

@@ -1,5 +1,20 @@
 import { spawn } from 'child_process';
+import { readFileSync } from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function readCliPkgVersion() {
+    for (const rel of ['../../package.json', '../package.json']) {
+        try {
+            const parsed = JSON.parse(readFileSync(path.join(__dirname, rel), 'utf8'));
+            if (parsed.version)
+                return parsed.version;
+        }
+        catch { /* try next */ }
+    }
+    return 'unknown';
+}
 import { acquireDaemonLock, getDaemonLockPath, isProcessAlive, readDaemonLock, removeDaemonLock, } from './lock.js';
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -99,7 +114,15 @@ export async function ensureDaemonReady(workspace, options = {}) {
     const timeoutMs = options.timeoutMs ?? 15_000;
     const existing = acquireDaemonLock(workspace);
     if (existing.status === 'running') {
-        return waitForDaemonReady(workspace, timeoutMs);
+        const currentVersion = readCliPkgVersion();
+        const daemonVersion = existing.record.pkgVersion;
+        if (currentVersion !== 'unknown' && daemonVersion && daemonVersion !== currentVersion) {
+            // Version mismatch — stop the stale daemon before spawning the new one
+            await stopDaemon(workspace).catch(() => { });
+        }
+        else {
+            return waitForDaemonReady(workspace, timeoutMs);
+        }
     }
     removeDaemonLock(existing.lockPath, { pid: existing.record.pid });
     if (options.spawnIfMissing === false) {

package/dist/daemon/lock.d.ts

@@ -16,6 +16,8 @@ export interface DaemonLockRecord {
     stateRoot: string;
     workspaceRoot: string;
     repoRoot: string;
+    /** Package version of the daemon process that wrote this lock. */
+    pkgVersion?: string;
 }
 export interface AcquireDaemonLockResult {
     status: 'acquired' | 'running';

package/dist/daemon/server.d.ts

@@ -14,6 +14,7 @@ export declare class NexusDaemonServer {
     private heartbeatTimer;
     private stopping;
     constructor(workspace: WorkspaceContext);
+    private installProcessErrorHandlers;
     start(): Promise<{
         started: boolean;
         record: DaemonLockRecord;

package/dist/daemon/server.js

@@ -1,6 +1,23 @@
 import http from 'http';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
 import { randomBytes, randomUUID } from 'crypto';
 import { URL } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function readDaemonPkgVersion() {
+    for (const rel of ['../../package.json', '../package.json']) {
+        try {
+            const parsed = JSON.parse(readFileSync(path.join(__dirname, rel), 'utf8'));
+            if (parsed.version)
+                return parsed.version;
+        }
+        catch { /* try next */ }
+    }
+    return 'unknown';
+}
+const DAEMON_PKG_VERSION = readDaemonPkgVersion();
 import { createNexusPrime } from '../index.js';
 import { MCPAdapter } from '../agents/adapters/mcp.js';
 import { nexusEventBus } from '../engines/event-bus.js';
@@ -89,9 +106,48 @@ export class NexusDaemonServer {
         this.httpServer = http.createServer((req, res) => {
             void this.handleRequest(req, res);
         });
-        this.cleanupTimer = setInterval(() => this.pruneState(), 60_000);
+        this.cleanupTimer = setInterval(() => {
+            try {
+                this.pruneState();
+            }
+            catch (err) {
+                // Never let cleanup crash the daemon.
+                console.error('[nexus-daemon] pruneState failed:', err?.message ?? err);
+            }
+        }, 60_000);
         this.cleanupTimer.unref?.();
     }
+    installProcessErrorHandlers() {
+        // Prevent a single unhandled rejection / uncaught throw from killing the
+        // daemon.  Engines like orchestrator + SSE + synapse emit fire-and-forget
+        // promises; without this the first background throw takes the whole
+        // control plane down and orchestration starts "failing" silently for the
+        // client.
+        process.on('uncaughtException', (err) => {
+            try {
+                console.error('[nexus-daemon] uncaughtException:', err?.stack ?? err?.message ?? err);
+                nexusEventBus.emit('nexus.daemon.error', {
+                    kind: 'uncaughtException',
+                    message: err?.message ?? String(err),
+                    stack: err?.stack ?? null,
+                });
+            }
+            catch { /* last-resort logging — swallow */ }
+        });
+        process.on('unhandledRejection', (reason) => {
+            try {
+                const message = reason?.message ?? String(reason);
+                const stack = reason?.stack ?? null;
+                console.error('[nexus-daemon] unhandledRejection:', stack ?? message);
+                nexusEventBus.emit('nexus.daemon.error', {
+                    kind: 'unhandledRejection',
+                    message,
+                    stack,
+                });
+            }
+            catch { /* last-resort logging — swallow */ }
+        });
+    }
     async start() {
         const lock = acquireDaemonLock(this.workspace, {
             token: this.authToken,
@@ -146,6 +202,7 @@ export class NexusDaemonServer {
             port,
             token: this.authToken,
             heartbeatAt: Date.now(),
+            pkgVersion: DAEMON_PKG_VERSION,
         });
         // Heartbeat: keep lockfile fresh so stale-lock detection (30 s TTL) works
         // correctly after a SIGKILL.  The interval is intentionally unref'd so it
@@ -165,6 +222,7 @@ export class NexusDaemonServer {
         }, HEARTBEAT_INTERVAL_MS);
         this.heartbeatTimer.unref?.();
         this.installSignalHandlers();
+        this.installProcessErrorHandlers();
         return {
             started: true,
             record: this.lockRecord,

package/dist/dashboard/app/styles/runtime.css

@@ -228,3 +228,116 @@
   align-self: center;
   white-space: nowrap;
 }
+
+/* ── MCP Live Activity Strip ─────────────────────────────────────────────────── */
+.rt-mcp-strip {
+  min-height: 0;
+}
+
+.rt-mcp-strip-inner {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  padding: 2px 0;
+}
+
+.rt-mcp-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  border-radius: 20px;
+  padding: 3px 10px 3px 7px;
+  font: 11px var(--font-mono, ui-monospace, monospace);
+  animation: rt-pill-in 0.15s ease;
+  white-space: nowrap;
+}
+
+.rt-mcp-active {
+  background: oklch(87% 0.19 152 / 8%);
+  border: 1px solid oklch(87% 0.19 152 / 28%);
+  color: var(--accent);
+}
+
+.rt-mcp-long {
+  background: oklch(85% 0.18 80 / 8%);
+  border: 1px solid oklch(85% 0.18 80 / 35%);
+  color: var(--warn);
+}
+
+.rt-mcp-done {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  color: var(--text-muted);
+  opacity: 0.75;
+}
+
+.rt-mcp-err {
+  background: oklch(65% 0.22 25 / 8%);
+  border: 1px solid oklch(65% 0.22 25 / 25%);
+  color: var(--bad, #ef4444);
+  opacity: 0.85;
+}
+
+.rt-mcp-tool { letter-spacing: 0.01em; }
+.rt-mcp-elapsed { opacity: 0.65; font-size: 10px; }
+
+.rt-mcp-badge {
+  font-size: 10px;
+  padding: 1px 5px;
+  border-radius: 8px;
+  margin-left: 3px;
+}
+
+.rt-mcp-badge-ok  { background: oklch(87% 0.19 152 / 12%); color: var(--ok, #22c55e); }
+.rt-mcp-badge-err { background: oklch(65% 0.22 25 / 12%); color: var(--bad, #ef4444); }
+
+/* ── Toast system ─────────────────────────────────────────────────────────────── */
+.rt-toast-container {
+  position: fixed;
+  bottom: 24px;
+  right: 24px;
+  display: flex;
+  flex-direction: column-reverse;
+  gap: 8px;
+  z-index: 9999;
+  pointer-events: none;
+}
+
+.rt-toast {
+  padding: 10px 16px;
+  border-radius: 8px;
+  font: 13px ui-sans-serif, system-ui, sans-serif;
+  max-width: 360px;
+  box-shadow: 0 4px 16px oklch(0% 0 0 / 40%);
+  animation: rt-toast-in 0.2s ease;
+  pointer-events: auto;
+  transition: opacity 0.4s;
+}
+
+.rt-toast-info    { background: var(--surface); border: 1px solid var(--accent); color: var(--text); }
+.rt-toast-warn    { background: var(--surface); border: 1px solid var(--warn);   color: var(--warn); }
+.rt-toast-bad     { background: var(--surface); border: 1px solid var(--bad, #ef4444); color: var(--bad, #ef4444); }
+
+.rt-toast-fade { opacity: 0; }
+
+@keyframes rt-toast-in {
+  from { opacity: 0; transform: translateY(8px); }
+  to   { opacity: 1; transform: none; }
+}
+
+/* ── Upgrade nudge bar ───────────────────────────────────────────────────────── */
+.rt-upgrade-bar {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  background: oklch(85% 0.18 80 / 8%);
+  border: 1px solid oklch(85% 0.18 80 / 30%);
+  border-radius: 8px;
+  padding: 10px 14px;
+  margin-bottom: 14px;
+  font-size: 13px;
+}
+
+.rt-upgrade-msg  { flex: 1; color: var(--warn); }
+.rt-upgrade-btn  { padding: 4px 12px; border-radius: 6px; background: var(--warn); color: #000; font-weight: 600; font-size: 12px; text-decoration: none; }
+.rt-upgrade-dismiss { background: none; border: none; cursor: pointer; color: var(--text-muted); font-size: 14px; padding: 0 4px; }