@bhooai/nexus-cli 0.1.5 → 2.0.1

package/src/commands/dev.ts

@@ -1,200 +1,163 @@
-import { ServiceSpec, Supervisor } from '../supervisor.js';
-import { loadConfigAuto } from '../../../nexus-core/src/index.js';
-import { configChangedSinceSync, syncConfig } from '../config-sync.js';
-import { isPortFree } from '../util.js';
-
-const COLORS = {
-  backend: '\x1b[32m',
-  frontend: '\x1b[36m',
-  'ai-server': '\x1b[33m',
-  admin: '\x1b[35m',
-  'node-agent': '\x1b[34m',
-};
+/**
+ * nexus dev — start the dev services:
+ *   every apps/backend-* (tsx watch), frontend(s) (vite), admin (vite), ai-server (python).
+ *
+ * Sub-process supervision with log prefixing, auto-restart, and clean shutdown
+ * on Ctrl+C.
+ */
+import { spawn, type ChildProcess } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import type { CommandContext } from '../dispatcher.js';
+import { ensurePort } from '../ports.js';
+
+interface Service {
+  name: string;
+  cmd: string;
+  args: string[];
+  cwd: string;
+  color: string;
+  enabled: boolean;
+  port: number;
+}
 
-const BOLD = '\x1b[1m';
-const DIM = '\x1b[2m';
+const COLORS = ['\x1b[36m', '\x1b[33m', '\x1b[35m', '\x1b[32m', '\x1b[34m', '\x1b[31m', '\x1b[37m', '\x1b[90m'];
 const RESET = '\x1b[0m';
 
-/** `nexus dev` - start the four terminals under the supervisor. */
-export async function dev(args: string[] = []): Promise<number> {  const cfg = await loadConfigAuto({ root: process.cwd() });
-  const onlyIdx = args.indexOf('--only');
-  const only = onlyIdx >= 0 ? args[onlyIdx + 1]?.split(',') : undefined;
-  const cpIdx = args.indexOf('--control-port');
-  const controlPort = cpIdx >= 0 && Number.isFinite(Number(args[cpIdx + 1])) ? Number(args[cpIdx + 1]) : 7474;
-
-  // Runtime port auto-allocation: a second project (master + slave) can run on
-  // the same machine side-by-side. Any configured port that is already taken is
-  // bumped to the next free one and threaded through NEXUS_* env, which both
-  // the backend loader and the Vite dev servers honour (config < env).
-  const serverPort = await nextFreePort(cfg.server.host, cfg.server.port);
-  const frontendPort = await nextFreePort('127.0.0.1', cfg.frontend.port);
-  const adminPort = await nextFreePort('127.0.0.1', cfg.admin.port);
-  const aiServerPort = await nextFreePort('127.0.0.1', Number(aiPort(cfg.ai.serverUrl)));
-  const lbPort = await nextFreePort('127.0.0.1', cfg.cluster.lbPort);
-  const agentPort = await nextFreePort('127.0.0.1', cfg.cluster.nodeAgentPort);
-
-  // If the config changed since the last sync, rewrite every derived artifact
-  // (Dockerfile, docker.*, serve-all.mjs, admin pkg, project DB) before booting
-  // so the whole stack runs on the new values.
-  if (!args.includes('--no-sync')) {
-    if (configChangedSinceSync(process.cwd(), cfg)) {
-      process.stdout.write(`\n  ${BOLD}Config changed - re-syncing derived artifacts...${RESET}\n`);
-      const report = await syncConfig(process.cwd(), cfg);
-      const changed = report.files.filter((f) => f.status === 'updated').map((f) => f.file);
-      process.stdout.write(
-        `  ${DIM}updated: ${changed.length > 0 ? changed.join(', ') : 'none'}  |  db: ${report.db}${RESET}\n`,
-      );
-    }
+export async function run(ctx: CommandContext): Promise<void> {
+  const only = (ctx.args.flags.only as string)?.split(',').map((s) => s.trim()) ?? null;
+  const projectRoot = process.cwd();
+
+  // Discover backends, frontends, admin, ai-server under apps/
+  const appsDir = join(projectRoot, 'apps');
+  const appEntries = existsSync(appsDir) ? await readdir(appsDir, { withFileTypes: true }) : [];
+  const backends  = appEntries.filter((e) => e.isDirectory() && e.name.startsWith('backend')).map((e) => e.name);
+  const frontends = appEntries.filter((e) => e.isDirectory() && e.name.startsWith('frontend')).map((e) => e.name);
+  const admins    = appEntries.filter((e) => e.isDirectory() && e.name.startsWith('admin')).map((e) => e.name);
+  const aiServers = appEntries.filter((e) => e.isDirectory() && e.name === 'ai-server').map((e) => e.name);
+
+  const services: Service[] = [];
+  let colorIdx = 0;
+
+  for (const b of backends) {
+    const mainPath = join(appsDir, b, 'src', 'main.ts');
+    if (!existsSync(mainPath)) continue;
+    const port = await ensurePort(projectRoot, b);
+    services.push({
+      name: b,
+      cmd: 'npx',
+      args: ['tsx', 'watch', 'src/main.ts'],
+      cwd: join(appsDir, b),
+      color: COLORS[colorIdx++ % COLORS.length]!,
+      enabled: !only || only.includes(b),
+      port: port,
+    });
   }
-
-  // Env override for a port that was bumped away from the configured value.
-  // Only set when different, so the configured port is used verbatim otherwise.
-  const portEnv = (actual: number, configured: number, key: string): Record<string, string> =>
-    actual !== configured ? { [key]: String(actual) } : {};
-
-  const all: ServiceSpec[] = [
-    {
-      name: 'backend',
-      command: ['tsx', 'watch', 'apps/backend/src/main.ts'],
-      cwd: '',
-      color: COLORS.backend,
-      env: {
-        ...portEnv(serverPort, cfg.server.port, 'NEXUS_SERVER_PORT'),
-        ...portEnv(lbPort, cfg.cluster.lbPort, 'NEXUS_CLUSTER_LBPORT'),
-        ...portEnv(agentPort, cfg.cluster.nodeAgentPort, 'NEXUS_CLUSTER_NODEAGENTPORT'),
-      },
-    },
-    {
-      name: 'frontend',
-      command: ['vite', '--port', String(frontendPort), '--host', cfg.frontend.host],
-      cwd: 'apps/frontend',
-      color: COLORS.frontend,
-      optional: true,
-      env: {
-        ...portEnv(serverPort, cfg.server.port, 'NEXUS_SERVER_PORT'),
-        ...portEnv(frontendPort, cfg.frontend.port, 'NEXUS_FRONTEND_PORT'),
-      },
-    },
-    {
-      name: 'ai-server',
-      command: ['python', 'main.py'],
-      cwd: 'apps/ai-server',
-      color: COLORS['ai-server'],
-      optional: true,
-      env: { AI_PORT: String(aiServerPort) },
-    },
-    {
-      name: 'admin',
-      command: ['vite', '--port', String(adminPort), '--host', cfg.admin.host],
-      cwd: 'apps/admin',
-      color: COLORS.admin,
-      optional: true,
-      env: {
-        ...portEnv(serverPort, cfg.server.port, 'NEXUS_SERVER_PORT'),
-        ...portEnv(adminPort, cfg.admin.port, 'NEXUS_ADMIN_PORT'),
-      },
-    },
-  ];
-
-  // Slave/node mode: auto-start a node agent (agent-only — it advertises the dev
-  // supervisor's backend as its role service instead of spawning a second one).
-  // The master can then link this node via its agent URL right after `npm run dev`.
-  // Invoked through `node node_modules/bhooai-nexus/bin/nexus.js` so it resolves
-  // even when the `nexus` bin shim isn't linked into the project's .bin.
-  if (cfg.cluster.role) {
-    all.push({
-      name: 'node-agent',
-      command: ['node', 'node_modules/bhooai-nexus/bin/nexus.js', 'node', 'serve', `--role=${cfg.cluster.role}`, `--port=${agentPort}`, '--no-service'],
-      cwd: '',
-      color: COLORS['node-agent'],
-      env: {
-        ...portEnv(serverPort, cfg.server.port, 'NEXUS_SERVER_PORT'),
-        ...portEnv(agentPort, cfg.cluster.nodeAgentPort, 'NEXUS_CLUSTER_NODEAGENTPORT'),
-      },
+  for (const f of frontends) {
+    if (!existsSync(join(appsDir, f, 'package.json'))) continue;
+    const port = await ensurePort(projectRoot, f);
+    services.push({
+      name: f,
+      cmd: 'npx',
+      args: ['vite', '--port', String(port), '--strictPort'],
+      cwd: join(appsDir, f),
+      color: COLORS[colorIdx++ % COLORS.length]!,
+      enabled: !only || only.includes(f),
+      port,
     });
   }
-
-  // Drop services the config disables (unless an explicit --only pins them).
-  const enabled = all.filter((s) => {
-    if (only) return only.includes(s.name);
-    if (s.name === 'frontend') return cfg.frontend.enabled;
-    if (s.name === 'admin') return cfg.admin.enabled;
-    return true;
-  });
-  const services = enabled;
-
-  // Startup banner - show host:port for every service about to start.
-  process.stdout.write(`\n${BOLD}  *  BhooAI Nexus${RESET} - ${services.map((s) => s.name).join(', ')}\n\n`);
-  process.stdout.write(`  ${DIM}Service          Host           Port${RESET}\n`);
-  process.stdout.write(`  ${DIM}-----------      ---------      ----${RESET}\n`);
-
-  for (const s of services) {
-    let host = '';
-    let port = '';
-    switch (s.name) {
-      case 'backend':
-        host = cfg.server.host;
-        port = String(serverPort);
-        break;
-      case 'frontend':
-        host = cfg.frontend.host;
-        port = String(frontendPort);
-        break;
-      case 'admin':
-        host = cfg.admin.host;
-        port = String(adminPort);
-        break;
-      case 'ai-server':
-        host = '0.0.0.0';
-        port = String(aiServerPort);
-        break;
-      case 'node-agent':
-        host = cfg.cluster.nodeAgentHost;
-        port = String(agentPort);
-        break;
-    }
-    const padName = s.name.padEnd(15);
-    const padHost = host.padEnd(16);
-    process.stdout.write(`  ${s.color}${padName}${RESET}${padHost}${port}\n`);
+  for (const a of admins) {
+    if (!existsSync(join(appsDir, a, 'package.json'))) continue;
+    const port = await ensurePort(projectRoot, a);
+    services.push({
+      name: a,
+      cmd: 'npx',
+      args: ['vite', '--port', String(port), '--strictPort'],
+      cwd: join(appsDir, a),
+      color: COLORS[colorIdx++ % COLORS.length]!,
+      enabled: !only || only.includes(a),
+      port,
+    });
+  }
+  for (const ai of aiServers) {
+    const mainPy = join(appsDir, ai, 'main.py');
+    if (!existsSync(mainPy)) continue;
+    const port = await ensurePort(projectRoot, ai);
+    services.push({
+      name: ai,
+      cmd: 'python',
+      args: ['main.py'],
+      cwd: join(appsDir, ai),
+      color: COLORS[colorIdx++ % COLORS.length]!,
+      enabled: !only || only.includes(ai),
+      port,
+    });
   }
-  process.stdout.write(`\n`);
 
-  const supervisor = new Supervisor(services, process.cwd(), controlPort);
-  await supervisor.start();
+  const active = services.filter((s) => s.enabled);
+  if (active.length === 0) {
+    console.log('No services to start. Check that apps/* exist.');
+    return;
+  }
 
-  // After services spawn, print quick-start URLs.
-  setTimeout(() => {
-    process.stdout.write(`\n  ${BOLD}Visit:${RESET}\n`);
-    process.stdout.write(`  http://localhost:${frontendPort}  (frontend)\n`);
-    process.stdout.write(`  http://localhost:${adminPort}  (admin)\n`);
-    process.stdout.write(`  http://localhost:${serverPort}/health  (backend)\n`);
-    if (cfg.cluster.role) {
-      process.stdout.write(`\n  ${BOLD}Node agent${RESET} — link this from the master:\n`);
-      process.stdout.write(`  http://${cfg.cluster.nodeAgentHost}:${agentPort}  (agent)  ·  role: ${cfg.cluster.role}\n`);
+  console.log(`nexus dev — starting ${active.length} service(s)\n`);
+  for (const s of active) {
+    console.log(`  ${s.color}[${s.name}]${RESET} → :${s.port}`);
+  }
+  console.log('');
+
+  const procs: ChildProcess[] = [];
+  let shuttingDown = false;
+
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log('\nShutting down...');
+    for (const p of procs) {
+      try {
+        p.kill('SIGTERM');
+      } catch { /* ignore */ }
     }
-    process.stdout.write(`\n`);
-  }, 2000);
-
-  // Keep the process alive; supervisor handles SIGINT/SIGTERM.
-  return 0;
-}
+    setTimeout(() => process.exit(0), 500);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  for (const svc of active) {
+    const child = spawn(svc.cmd, svc.args, {
+      cwd: svc.cwd,
+      stdio: ['inherit', 'pipe', 'pipe'],
+      env: { ...process.env, FORCE_COLOR: '1', NEXUS_PORT: String(svc.port) },
+      shell: true,
+    });
 
-/** First free port at or above `port` on `host` (fails fast, caps at +100). */
-async function nextFreePort(host: string, port: number): Promise<number> {
-  const base = Number(port);
-  if (await isPortFree(host, base)) return base;
-  for (let i = 1; i <= 100; i++) {
-    if (await isPortFree(host, base + i)) return base + i;
+    const prefix = `${svc.color}[${svc.name}]${RESET}`;
+    child.stdout?.on('data', (chunk: Buffer) => {
+      const lines = chunk.toString().split('\n');
+      for (const line of lines) {
+        if (line.trim()) process.stdout.write(`${prefix} ${line}\n`);
+      }
+    });
+    child.stderr?.on('data', (chunk: Buffer) => {
+      const lines = chunk.toString().split('\n');
+      for (const line of lines) {
+        if (line.trim()) process.stderr.write(`${prefix} ${line}\n`);
+      }
+    });
+    child.on('exit', (code, signal) => {
+      if (shuttingDown) return;
+      console.log(`${prefix} exited (${code ?? signal}). Restarting in 1s...`);
+      setTimeout(() => {
+        if (!shuttingDown) {
+          procs.push(spawn(svc.cmd, svc.args, { cwd: svc.cwd, stdio: 'inherit', env: process.env, shell: true }));
+        }
+      }, 1000);
+    });
+    procs.push(child);
   }
-  return base;
 }
 
-/** Port parsed from the configured AI server URL (defaults 8000). */
-function aiPort(serverUrl: string): string {
-  try {
-    const port = new URL(serverUrl).port;
-    return port || '80';
-  } catch {
-    return '8000';
-  }
-}
+export const description = 'Start dev services (all apps under ./apps)';
+export const usage = 'nexus dev [--only backend,frontend]';