@bhooai/nexus-cli 2.0.6 → 2.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bhooai/nexus-cli",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "BhooAI Nexus v2 CLI — init, dev, build, test, scaffolding, plugins, queue, db.",
   "license": "MIT",
   "type": "module",

package/src/commands/add.ts

@@ -174,13 +174,18 @@ async function addFrontend(ctx: CommandContext): Promise<void> {
   const backendPort = (await lookupPort(projectRoot, backend)) ?? await ensurePort(projectRoot, backend);
   await writeFile(join(appDir, 'vite.config.ts'), `import { defineConfig } from 'vite';
 
+// Backend host the dev proxy targets. Override with NEXUS_BACKEND_HOST when
+// deploying to a VPS (or running the backend on another machine). Defaults to
+// localhost for local development.
+const backendHost = process.env.NEXUS_BACKEND_HOST ?? 'localhost';
+
 export default defineConfig({
   server: {
     port: ${port},
     proxy: {
-      '/api':     { target: 'http://localhost:${backendPort}', changeOrigin: true },
-      '/uploads': { target: 'http://localhost:${backendPort}', changeOrigin: true },
-      '/ws':      { target: 'ws://localhost:${backendPort}', ws: true },
+      '/api':     { target: \`http://\${backendHost}:${backendPort}\`, changeOrigin: true },
+      '/uploads': { target: \`http://\${backendHost}:${backendPort}\`, changeOrigin: true },
+      '/ws':      { target: \`ws://\${backendHost}:${backendPort}\`, ws: true },
     },
   },
 });

package/src/commands/dev.ts

@@ -31,10 +31,26 @@ export async function run(ctx: CommandContext): Promise<void> {
 
   const manager = new ServiceManager(specs, projectRoot);
 
+  // Start the supervisor control API before any service so the admin SPA can
+  // discover it (port persisted to supervisor.json; backend /admin/supervisor
+  // reports it). Failure is non-fatal — the console still works.
+  let controlPort = 0;
+  try {
+    controlPort = await manager.startControlApi();
+    console.log(`\x1b[36m[supervisor]\x1b[0m control API on http://127.0.0.1:${controlPort}`);
+  } catch (err) {
+    console.warn(`\x1b[33m[supervisor]\x1b[0m control API unavailable: ${(err as Error).message}`);
+  }
+
+  const teardown = () => {
+    manager.killAll();
+    manager.closeControlApi();
+  };
+
   if (isTty && !noPanel) {
     // Full-screen Nexus Console.
     console.log(`nexus dev — ${specs.length} service(s). Opening console...\n`);
-    await startDevPanel({ services: manager, onQuit: () => manager.killAll() });
+    await startDevPanel({ services: manager, onQuit: teardown });
     return;
   }
 
@@ -44,7 +60,7 @@ export async function run(ctx: CommandContext): Promise<void> {
   const shutdown = () => {
     if (shuttingDown) return;
     shuttingDown = true;
-    manager.killAll();
+    teardown();
     setTimeout(() => process.exit(0), 500);
   };
   process.on('SIGINT', shutdown);

package/src/commands/init.ts

@@ -211,6 +211,8 @@ NEXUS_SERVER_PORT=${vars.backendPort}
 NEXUS_FRONTEND_PORT=${vars.frontendPort}
 NEXUS_ADMIN_PORT=${vars.adminPort}
 AI_PORT=${vars.aiPort}
+# Set this to the backend host when deploying to a VPS (default: localhost)
+# NEXUS_BACKEND_HOST=
 
 # Database
 NEXUS_DB_URI=${vars.mongoUri}
@@ -223,6 +225,7 @@ NEXUS_AUTH_JWT_SECRET=${vars.jwtSecret}
 NEXUS_AI_PROVIDER=ollama
 NEXUS_AI_MODEL=llama3.1:8b
 OLLAMA_MODEL=llama3.1:8b
+OLLAMA_BASE_URL=http://localhost:11434
 ${vars.aiProviders.filter((p) => p !== 'ollama').map((p) => `# NEXUS_AI_${p.toUpperCase()}_API_KEY=`).join('\n')}
 
 # Storage (uncomment for S3)

package/src/devPanel.ts

@@ -66,6 +66,7 @@ const ARG_COMMANDS = new Set([
   'make:policy', 'make:resource', 'make:request', 'make:mail', 'make:room',
   'make:subgraph', 'make:seeder', 'make:migration', 'make:provider', 'make:plugin',
   'db:seed', 'db:migrate', 'db:rollback', 'queue:retry', 'add',
+  'sync', 'uninstall', 'pysetup',
 ]);
 
 interface CommandItem {
@@ -79,6 +80,8 @@ interface PanelState {
   tab: Tab;
   svcIndex: number;
   cmdIndex: number;
+  cmdScroll: number;
+  cmdFilter: string;
   featIndex: number;
   installed: Set<string>;
   featureMsg: string[];
@@ -103,6 +106,8 @@ export async function startDevPanel(opts: DevPanelOptions): Promise<void> {
     tab: 'services',
     svcIndex: 0,
     cmdIndex: 0,
+    cmdScroll: 0,
+    cmdFilter: '',
     featIndex: 0,
     installed,
     featureMsg: [],
@@ -208,6 +213,13 @@ function onKey(state: PanelState, str: string, key: KeyInfo, ctx: Ctx): void {
     return;
   }
   if (key.name === 'escape') {
+    if (state.tab === 'commands' && state.cmdFilter) {
+      state.cmdFilter = '';
+      state.cmdIndex = 0;
+      state.cmdScroll = 0;
+      ctx.redraw();
+      return;
+    }
     if (state.showHelp) { state.showHelp = false; ctx.redraw(); }
     else { state.confirmQuit = true; state.quitIndex = 0; ctx.redraw(); }
     return;
@@ -219,6 +231,31 @@ function onKey(state: PanelState, str: string, key: KeyInfo, ctx: Ctx): void {
   }
   if (state.showHelp) return;
 
+  // Type-to-filter in the Commands tab.
+  if (state.tab === 'commands' && str && !key.ctrl && !key.meta && str.length === 1 && str !== '?') {
+    state.cmdFilter += str;
+    const fp = filteredPalette(ctx.palette, state.cmdFilter);
+    state.cmdIndex = fp.findIndex((r) => r.kind === 'cmd');
+    if (state.cmdIndex < 0) state.cmdIndex = 0;
+    state.cmdScroll = 0;
+    const vh = commandsViewportHeight(state);
+    clampScroll(state, vh, fp.length);
+    ctx.redraw();
+    return;
+  }
+  // Backspace in commands tab = delete last filter char.
+  if (state.tab === 'commands' && key.name === 'backspace' && state.cmdFilter) {
+    state.cmdFilter = state.cmdFilter.slice(0, -1);
+    const fp = filteredPalette(ctx.palette, state.cmdFilter);
+    state.cmdIndex = Math.min(state.cmdIndex, fp.length - 1);
+    if (state.cmdIndex < 0) state.cmdIndex = 0;
+    state.cmdScroll = 0;
+    const vh = commandsViewportHeight(state);
+    clampScroll(state, vh, fp.length);
+    ctx.redraw();
+    return;
+  }
+
   switch (key.name) {
     case 'tab': {
       const idx = TABS.findIndex((t) => t.id === state.tab);
@@ -271,14 +308,18 @@ function onKey(state: PanelState, str: string, key: KeyInfo, ctx: Ctx): void {
 }
 
 function move(state: PanelState, dir: number, ctx: Ctx): void {
+  const fp = filteredPalette(ctx.palette, state.cmdFilter);
   switch (state.tab) {
     case 'services':
     case 'logs':
       state.svcIndex = clamp(state.svcIndex + dir, 0, Math.max(0, ctx.services.services.length - 1));
       break;
-    case 'commands':
-      state.cmdIndex = prevSelectable(ctx.palette, state.cmdIndex, dir);
+    case 'commands': {
+      state.cmdIndex = prevSelectable(fp, state.cmdIndex, dir);
+      const vh = commandsViewportHeight(state);
+      clampScroll(state, vh, fp.length);
       break;
+    }
     case 'features':
       state.featIndex = clamp(state.featIndex + dir, 0, FEATURES.length - 1);
       break;
@@ -317,7 +358,8 @@ async function activate(state: PanelState, ctx: Ctx): Promise<void> {
       break;
     }
     case 'commands': {
-      const row = ctx.palette[state.cmdIndex];
+      const fp = filteredPalette(ctx.palette, state.cmdFilter);
+      const row = fp[state.cmdIndex];
       if (row && row.kind === 'cmd') {
         if (row.cmd.needsArgs) state.argMode = { cmd: row.cmd, buffer: '' };
         else void runSelectedCommand(state, row.cmd, '', ctx);
@@ -484,6 +526,59 @@ function prevSelectable(list: PaletteRow[], current: number, dir: number): numbe
   return current;
 }
 
+/** Filter the palette by the user's type-to-filter buffer (case-insensitive). */
+function filteredPalette(palette: PaletteRow[], filter: string): PaletteRow[] {
+  if (!filter) return palette;
+  const q = filter.toLowerCase();
+  const result: PaletteRow[] = [];
+  let currentHeader: PaletteRow | null = null;
+  let headerHasMatch = false;
+  for (const row of palette) {
+    if (row.kind === 'header') {
+      if (currentHeader && headerHasMatch) result.push(currentHeader);
+      currentHeader = row;
+      headerHasMatch = false;
+      continue;
+    }
+    if (row.cmd.name.toLowerCase().includes(q) || row.cmd.desc.toLowerCase().includes(q)) {
+      headerHasMatch = true;
+      result.push(row);
+    }
+  }
+  if (currentHeader && headerHasMatch) result.push(currentHeader);
+  // Re-headers got pushed to the end; rebuild with headers in the right place.
+  const ordered: PaletteRow[] = [];
+  let pendingHeader: PaletteRow | null = null;
+  for (const row of palette) {
+    if (row.kind === 'header') {
+      pendingHeader = row;
+      continue;
+    }
+    if (row.cmd.name.toLowerCase().includes(q) || row.cmd.desc.toLowerCase().includes(q)) {
+      if (pendingHeader) { ordered.push(pendingHeader); pendingHeader = null; }
+      ordered.push(row);
+    }
+  }
+  return ordered;
+}
+
+/** Available rows for the command list given terminal height and output section. */
+function commandsViewportHeight(state: PanelState): number {
+  const H = output.rows || 24;
+  // Header (2) + filter line (1 if active) + output section (2 + up to 12 lines)
+  const outputH = state.commandOutput.length > 0 ? 2 + Math.min(state.commandOutput.length, 12) : 0;
+  const filterH = state.cmdFilter ? 2 : 0; // filter line + blank
+  return Math.max(H - 4 - filterH - outputH, 4);
+}
+
+/** Clamp cmdScroll so cmdIndex stays inside the viewport. */
+function clampScroll(state: PanelState, viewportH: number, listLen: number): void {
+  if (state.cmdIndex < state.cmdScroll) state.cmdScroll = state.cmdIndex;
+  if (state.cmdIndex >= state.cmdScroll + viewportH) state.cmdScroll = state.cmdIndex - viewportH + 1;
+  if (state.cmdScroll < 0) state.cmdScroll = 0;
+  if (state.cmdScroll > Math.max(0, listLen - viewportH)) state.cmdScroll = Math.max(0, listLen - viewportH);
+}
+
 // ---------------------------------------------------------------------------
 // Rendering
 // ---------------------------------------------------------------------------
@@ -629,21 +724,53 @@ function renderLogs(state: PanelState, services: ServiceManager, accent: string,
 }
 
 function renderCommands(state: PanelState, palette: PaletteRow[], accent: string, contentW: number): string[] {
-  const out = [`${ANSI.bold}${accent} COMMANDS${ANSI.reset}${ANSI.dim}  (Enter run · args inline)${ANSI.reset}`, ''];
-  const visible = palette.slice(0, 18);
-  visible.forEach((row) => {
+  const fp = filteredPalette(palette, state.cmdFilter);
+  const vh = commandsViewportHeight(state);
+  clampScroll(state, vh, fp.length);
+
+  const filterHint = state.cmdFilter
+    ? `${ANSI.dim}  (type to filter · Esc clears · Backspace deletes)${ANSI.reset}`
+    : `${ANSI.dim}  (Enter run · args inline · type to filter)${ANSI.reset}`;
+  const out = [`${ANSI.bold}${accent} COMMANDS${ANSI.reset}${filterHint}`, ''];
+
+  // Filter input line.
+  if (state.cmdFilter) {
+    out.push(` ${ANSI.cyan}Filter:${ANSI.reset} ${state.cmdFilter}█`);
+    out.push('');
+  }
+
+  // Scroll-up indicator.
+  if (state.cmdScroll > 0) {
+    out.push(` ${ANSI.dim}↑ ${state.cmdScroll} more above${ANSI.reset}`);
+  }
+
+  const start = state.cmdScroll;
+  const end = Math.min(start + vh, fp.length);
+  for (let i = start; i < end; i++) {
+    const row = fp[i]!;
     if (row.kind === 'header') {
       out.push(` ${ANSI.dim}${row.label.toUpperCase()}${ANSI.reset}`);
     } else {
-      const isSelected = palette.indexOf(row) === state.cmdIndex;
+      const isSelected = i === state.cmdIndex;
       const marker = isSelected ? `${ANSI.cyan}▶${ANSI.reset}` : ' ';
       const label = isSelected ? `${ANSI.bold}${row.cmd.name}${ANSI.reset}` : row.cmd.name;
-      const arg = row.cmd.needsArgs ? `${ANSI.dim} <name>${ANSI.reset}` : '';
+      const arg = row.cmd.needsArgs ? `${ANSI.dim} <args>${ANSI.reset}` : '';
       const desc = row.cmd.desc ? `${ANSI.dim}${row.cmd.desc}${ANSI.reset}` : '';
-      const head = ` ${marker} ${fitCell(label, 18)}${arg}`;
-      out.push(`${head} ${clipVisible(desc, Math.max(contentW - 22, 8))}`);
+      const head = ` ${marker} ${fitCell(label, 20)}${arg}`;
+      out.push(`${head} ${clipVisible(desc, Math.max(contentW - 24, 8))}`);
     }
-  });
+  }
+
+  // Scroll-down indicator.
+  if (end < fp.length) {
+    out.push(` ${ANSI.dim}↓ ${fp.length - end} more below${ANSI.reset}`);
+  }
+
+  // Empty filter result.
+  if (fp.length === 0) {
+    out.push(` ${ANSI.dim}No commands match "${state.cmdFilter}"${ANSI.reset}`);
+  }
+
   if (state.commandOutput.length > 0) {
     out.push('');
     out.push(`${ANSI.bold}${ANSI.yellow} OUTPUT${ANSI.reset}`);

package/src/devServiceManager.ts

@@ -5,8 +5,12 @@
  * crash-loop guard. Log output is captured into a per-service ring buffer so
  * the control panel can render live logs.
  */
-import { spawn, type ChildProcess } from 'node:child_process';
+import { spawn, spawnSync, type ChildProcess } from 'node:child_process';
 import type { Readable } from 'node:stream';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { createServer } from 'node:http';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { nextFreePort } from './util.js';
 import { readRegistry, writeRegistry, type PortRegistry } from './ports.js';
 
@@ -25,6 +29,7 @@ export interface ServiceSpec {
 export interface ManagedService extends ServiceSpec {
   status: ServiceStatus;
   pid: number | null;
+  startedAt?: number;
   restarts: number;
   lastExit: { code: number | null; signal: NodeJS.Signals | null } | null;
   /** Last log lines captured before crash (for inline display in the panel). */
@@ -33,7 +38,26 @@ export interface ManagedService extends ServiceSpec {
   child: ChildProcess | null;
 }
 
+/** Status view the control API reports to the admin (crashed → errored). */
+export interface ServiceStateView {
+  name: string;
+  status: 'stopped' | 'starting' | 'running' | 'errored';
+  pid?: number;
+  startedAt?: number;
+  lastExitCode?: number | null;
+}
+
+/** Structured cross-service log entry (powers the control API /logs/all). */
+export interface LogEntry {
+  service: string;
+  ts: number;
+  source: 'stdout' | 'stderr' | 'system';
+  level: 'info' | 'warn' | 'error';
+  line: string;
+}
+
 const MAX_LOG_LINES = 200;
+const MAX_ALL_LOGS = 2000;
 const CRASH_THRESHOLD = 5;
 const CRASH_WINDOW_MS = 30_000;
 
@@ -41,6 +65,10 @@ export class ServiceManager {
   readonly services: ManagedService[] = [];
   private crashTimes = new Map<string, number[]>();
   private projectRoot: string;
+  /** Aggregated structured log buffer across all services — powers /logs/all. */
+  private allLogs: LogEntry[] = [];
+  private controlServer?: ReturnType<typeof createServer>;
+  private boundControlPort = 0;
 
   constructor(specs: ServiceSpec[], projectRoot: string) {
     this.projectRoot = projectRoot;
@@ -103,9 +131,10 @@ export class ServiceManager {
     });
     svc.child = child;
     svc.pid = child.pid ?? null;
+    svc.startedAt = Date.now();
 
-    this.pipe(child.stdout, svc);
-    this.pipe(child.stderr, svc);
+    this.pipe(child.stdout, svc, 'stdout');
+    this.pipe(child.stderr, svc, 'stderr');
 
     child.once('spawn', () => {
       svc.status = 'running';
@@ -122,7 +151,7 @@ export class ServiceManager {
       if (/\bEADDRINUSE\b/i.test(recentLogs)) {
         const bump = await this.bumpPort(svc);
         if (bump) {
-          this.push(svc, `⚡ Port ${bump.oldPort} busy → bumped to ${bump.newPort}, restarting ${svc.name}`);
+          this.push(svc, `⚡ Port ${bump.oldPort} busy → bumped to ${bump.newPort}, restarting ${svc.name}`, 'system');
           svc.status = 'stopped';
           setTimeout(() => this.start(svc.name), 300);
           return;
@@ -134,12 +163,12 @@ export class ServiceManager {
       if (wasCrashed) {
         svc.status = 'crashed';
         svc.lastCrashLog = svc.logBuffer.slice(-8);
-        this.push(svc, `✗ ${svc.name} crashed repeatedly — press s to start again`);
+        this.push(svc, `✗ ${svc.name} crashed repeatedly — press s to start again`, 'system');
         return;
       }
       svc.status = 'stopped';
       if (svc.restarts > 0 && !this.explicitlyStopping) {
-        this.push(svc, `↻ ${svc.name} exited (${code ?? signal}) — restarting in 1s`);
+        this.push(svc, `↻ ${svc.name} exited (${code ?? signal}) — restarting in 1s`, 'system');
         setTimeout(() => this.start(svc.name), 1000);
       }
     });
@@ -150,13 +179,29 @@ export class ServiceManager {
   private killChild(svc: ManagedService, signal: NodeJS.Signals): void {
     this.explicitlyStopping = true;
     const child = svc.child;
+    const pid = svc.pid;
     if (!child) return;
+    // On Windows the service runs as a grandchild of a cmd.exe wrapper
+    // (spawn shell:true), so child.kill() only kills the shell and the real
+    // process survives to keep holding its port. Kill the whole tree first,
+    // synchronously, so the port is actually released before the wrapper exits.
+    if (process.platform === 'win32' && pid) {
+      try {
+        spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+      } catch { /* ignore */ }
+    }
     try {
       child.kill(signal);
     } catch { /* ignore */ }
     // Force-kill if it lingers.
     setTimeout(() => {
-      if (svc.child && svc.pid) {
+      if (process.platform === 'win32') {
+        if (pid) {
+          try {
+            spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+          } catch { /* ignore */ }
+        }
+      } else if (svc.child && svc.pid) {
         try { process.kill(svc.pid, 'SIGKILL'); } catch { /* ignore */ }
       }
     }, 3000);
@@ -165,20 +210,22 @@ export class ServiceManager {
     }, 3500);
   }
 
-  private pipe(stream: Readable | null, svc: ManagedService): void {
+  private pipe(stream: Readable | null, svc: ManagedService, source: 'stdout' | 'stderr'): void {
     if (!stream) return;
     stream.on('data', (chunk: Buffer) => {
       const text = chunk.toString();
-      this.push(svc, text);
+      this.push(svc, text, source);
     });
   }
 
-  private push(svc: ManagedService, text: string): void {
-    const lines = text.split('\n');
+  private push(svc: ManagedService, text: string, source: 'stdout' | 'stderr' | 'system' = 'stdout'): void {
+    const lines = text.split(/\r?\n/);
     for (const line of lines) {
       if (!line.trim()) continue;
       svc.logBuffer.push(line);
       if (svc.logBuffer.length > MAX_LOG_LINES) svc.logBuffer.shift();
+      this.allLogs.push({ service: svc.name, ts: Date.now(), source, level: detectLevel(line), line });
+      if (this.allLogs.length > MAX_ALL_LOGS) this.allLogs.shift();
     }
     this.onLog?.(svc.name);
   }
@@ -226,4 +273,156 @@ export class ServiceManager {
     if (!svc) return [];
     return svc.logBuffer.slice(-lines);
   }
+
+  // -------------------------------------------------------------------------
+  // HTTP control API (localhost only) — consumed by the admin SPA's Processes
+  // and Logs tabs. Binds 127.0.0.1:7474, auto-bumping upward when busy, and
+  // persists the real port to supervisor.json at the project root so the
+  // backend's /admin/supervisor can report it.
+  // -------------------------------------------------------------------------
+
+  /** The port the control API actually bound (0 until started). */
+  get controlEndpointPort(): number {
+    return this.boundControlPort;
+  }
+
+  /** Start the control API; resolves with the bound port. */
+  async startControlApi(preferredPort = 7474): Promise<number> {
+    const server = createServer((req, res) => this.handleControl(req, res));
+    const MAX_ATTEMPTS = 100;
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+      const port = preferredPort + attempt;
+      try {
+        await this.tryListen(server, port);
+        this.boundControlPort = port;
+        this.controlServer = server;
+        await this.writeSupervisorInfo();
+        return port;
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code !== 'EADDRINUSE') {
+          this.controlServer?.close();
+          throw err;
+        }
+      }
+    }
+    this.controlServer?.close();
+    throw new Error(`no free control port near ${preferredPort} (tried ${MAX_ATTEMPTS} ports)`);
+  }
+
+  /** Stop the control API (services keep running). */
+  closeControlApi(): void {
+    this.controlServer?.close();
+    this.controlServer = undefined;
+    this.boundControlPort = 0;
+  }
+
+  /** Report the services in the admin's expected shape. */
+  private controlStatus(): ServiceStateView[] {
+    return this.services.map((s) => ({
+      name: s.name,
+      status: s.status === 'crashed' ? 'errored' : s.status,
+      pid: s.pid ?? undefined,
+      startedAt: s.startedAt,
+      lastExitCode: s.lastExit?.code ?? null,
+    }));
+  }
+
+  private tryListen(server: ReturnType<typeof createServer>, port: number, host = '127.0.0.1'): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const onError = (err: NodeJS.ErrnoException) => {
+        server.removeListener('listening', onListening);
+        server.close();
+        reject(err);
+      };
+      const onListening = () => {
+        server.removeListener('error', onError);
+        resolve();
+      };
+      server.once('error', onError);
+      server.once('listening', onListening);
+      server.listen(port, host);
+    });
+  }
+
+  private async writeSupervisorInfo(): Promise<void> {
+    try {
+      await writeFile(
+        join(this.projectRoot, 'supervisor.json'),
+        JSON.stringify({
+          port: this.boundControlPort,
+          url: this.boundControlPort ? `http://127.0.0.1:${this.boundControlPort}` : undefined,
+          writtenAt: new Date().toISOString(),
+        }, null, 2) + '\n',
+        'utf8',
+      );
+    } catch { /* non-fatal — the admin falls back to the default port */ }
+  }
+
+  private handleControl(req: IncomingMessage, res: ServerResponse): void {
+    const url = new URL(req.url ?? '/', `http://127.0.0.1:${this.boundControlPort}`);
+    // Permissive CORS so the browser-based admin can call us directly.
+    res.setHeader('access-control-allow-origin', '*');
+    res.setHeader('access-control-allow-methods', 'GET,POST,OPTIONS');
+    res.setHeader('access-control-allow-headers', 'content-type, authorization');
+    if (req.method === 'OPTIONS') { res.statusCode = 204; res.end(); return; }
+    res.setHeader('content-type', 'application/json');
+    if (req.method === 'GET' && url.pathname === '/status') {
+      res.end(JSON.stringify({ services: this.controlStatus() }));
+      return;
+    }
+    if (req.method === 'POST' && url.pathname === '/start') {
+      const name = url.searchParams.get('name');
+      if (name) this.start(name);
+      res.end(JSON.stringify({ ok: !!name }));
+      return;
+    }
+    if (req.method === 'POST' && url.pathname === '/restart') {
+      const name = url.searchParams.get('name');
+      if (name) this.restart(name);
+      res.end(JSON.stringify({ ok: !!name }));
+      return;
+    }
+    if (req.method === 'POST' && url.pathname === '/stop') {
+      const name = url.searchParams.get('name');
+      if (name) this.stop(name);
+      res.end(JSON.stringify({ ok: !!name }));
+      return;
+    }
+    if (req.method === 'GET' && url.pathname === '/logs') {
+      const name = url.searchParams.get('name');
+      const svc = name ? this.get(name) : undefined;
+      res.end(JSON.stringify({ logs: svc?.logBuffer ?? [] }));
+      return;
+    }
+    if (req.method === 'GET' && url.pathname === '/logs/all') {
+      const service = url.searchParams.get('service') ?? '';
+      const level = url.searchParams.get('level') ?? '';
+      const q = url.searchParams.get('q') ?? '';
+      let entries = this.allLogs;
+      if (service) entries = entries.filter((e) => e.service === service);
+      if (level) entries = entries.filter((e) => e.level === level);
+      if (q) {
+        const lower = q.toLowerCase();
+        entries = entries.filter((e) => e.line.toLowerCase().includes(lower));
+      }
+      res.end(JSON.stringify({ logs: entries }));
+      return;
+    }
+    if (req.method === 'POST' && url.pathname === '/logs/clear') {
+      for (const svc of this.services) svc.logBuffer = [];
+      this.allLogs = [];
+      res.end(JSON.stringify({ ok: true }));
+      return;
+    }
+    res.statusCode = 404;
+    res.end(JSON.stringify({ error: 'not found' }));
+  }
+}
+
+/** Classify a log line's severity from its content. */
+function detectLevel(line: string): LogEntry['level'] {
+  const lower = line.toLowerCase();
+  if (/\berror\b/.test(lower) || /\bfatal\b/.test(lower) || /\bfail(ed|ure)?\b/.test(lower) || /\bexception\b/.test(lower)) return 'error';
+  if (/\bwarn(ing)?\b/.test(lower) || /\bunauthorized\b/.test(lower) || /\bforbidden\b/.test(lower)) return 'warn';
+  return 'info';
 }

package/src/index.ts

@@ -29,6 +29,25 @@ registerCommand({ name: 'queue:retry', description: queueCmd.description, usage:
 registerCommand(downCommand);
 registerCommand(upCommand);
 
+registerCommand({
+  name: 'sync',
+  description: 'Rewrite derived files (nexus.config, docker-compose, ports)',
+  usage: 'nexus sync [--check|--dry-run]',
+  run: async () => { console.log('sync: not yet implemented — track in P6'); },
+});
+registerCommand({
+  name: 'uninstall',
+  description: 'Remove project files (--purge deletes everything, --keep-db preserves Mongo)',
+  usage: 'nexus uninstall [--purge|--dry-run|--keep-db]',
+  run: async () => { console.log('uninstall: not yet implemented — track in P6'); },
+});
+registerCommand({
+  name: 'pysetup',
+  description: 'Set up Python AI server dependencies (venv + pip install)',
+  usage: 'nexus pysetup [pkgs...]',
+  run: async () => { console.log('pysetup: not yet implemented — track in P6'); },
+});
+
 registerMakeCommands(registerCommand);
 
 export async function run(cmd: string, argv: string[]): Promise<void> {

package/templates/base/apps/admin/package.json.ejs

@@ -8,6 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
+    "@bhooai/nexus-admin": "*",
     "@bhooai/nexus-safe-goto": "*",
     "react": "^18.3.1",
     "react-dom": "^18.3.1"