orbital-command 0.1.0

package/server/index.ts

@@ -0,0 +1,452 @@
+import express from 'express';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { getDatabase, closeDatabase } from './database.js';
+import { getConfig, resetConfig } from './config.js';
+import { ScopeCache } from './services/scope-cache.js';
+import { ScopeService } from './services/scope-service.js';
+import { EventService } from './services/event-service.js';
+import { GateService } from './services/gate-service.js';
+import { DeployService } from './services/deploy-service.js';
+import { SprintService } from './services/sprint-service.js';
+import { SprintOrchestrator } from './services/sprint-orchestrator.js';
+import { BatchOrchestrator } from './services/batch-orchestrator.js';
+import { ReadinessService } from './services/readiness-service.js';
+import { startScopeWatcher } from './watchers/scope-watcher.js';
+import { startEventWatcher } from './watchers/event-watcher.js';
+import { ensureDynamicProfiles } from './utils/terminal-launcher.js';
+import { syncClaudeSessionsToDB } from './services/claude-session-service.js';
+import { resolveStaleDispatches, resolveActiveDispatchesForScope, resolveDispatchesByPid, resolveDispatchesByDispatchId, linkPidToDispatch } from './utils/dispatch-utils.js';
+import { createScopeRoutes } from './routes/scope-routes.js';
+import { createDataRoutes } from './routes/data-routes.js';
+import { createDispatchRoutes } from './routes/dispatch-routes.js';
+import { createSprintRoutes } from './routes/sprint-routes.js';
+import { createWorkflowRoutes } from './routes/workflow-routes.js';
+import { createConfigRoutes } from './routes/config-routes.js';
+import { createGitRoutes } from './routes/git-routes.js';
+import { createVersionRoutes } from './routes/version-routes.js';
+import { WorkflowService } from './services/workflow-service.js';
+import { GitService } from './services/git-service.js';
+import { GitHubService } from './services/github-service.js';
+import { WorkflowEngine } from '../shared/workflow-engine.js';
+import defaultWorkflow from '../shared/default-workflow.json' with { type: 'json' };
+import type { WorkflowConfig } from '../shared/workflow-config.js';
+import { createLogger, setLogLevel } from './utils/logger.js';
+import type { LogLevel } from './utils/logger.js';
+
+import type http from 'http';
+import type Database from 'better-sqlite3';
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface ServerOverrides {
+  port?: number;
+  projectRoot?: string;
+}
+
+export interface ServerInstance {
+  app: express.Application;
+  io: Server;
+  db: Database.Database;
+  workflowEngine: WorkflowEngine;
+  httpServer: http.Server;
+  shutdown: () => Promise<void>;
+}
+
+// ─── Server Factory ─────────────────────────────────────────
+
+export async function startServer(overrides?: ServerOverrides): Promise<ServerInstance> {
+  // Apply project root override before config loads
+  if (overrides?.projectRoot) {
+    process.env.ORBITAL_PROJECT_ROOT = overrides.projectRoot;
+    resetConfig();
+  }
+
+  const config = getConfig();
+  const envLevel = process.env.ORBITAL_LOG_LEVEL;
+  if (envLevel && ['debug', 'info', 'warn', 'error'].includes(envLevel)) {
+    setLogLevel(envLevel as LogLevel);
+  } else {
+    setLogLevel(config.logLevel);
+  }
+  const log = createLogger('server');
+  const port = overrides?.port ?? config.serverPort;
+
+  const workflowEngine = new WorkflowEngine(defaultWorkflow as WorkflowConfig);
+
+  // Generate shell manifest for bash hooks (config-driven lifecycle)
+  const MANIFEST_PATH = path.join(config.configDir, 'workflow-manifest.sh');
+  if (!fs.existsSync(config.configDir)) fs.mkdirSync(config.configDir, { recursive: true });
+  fs.writeFileSync(MANIFEST_PATH, workflowEngine.generateShellManifest(), 'utf-8');
+
+  const ICEBOX_DIR = path.join(config.scopesDir, 'icebox');
+  // Resolve path to the bundled default workflow config.
+  const __selfDir2 = path.dirname(fileURLToPath(import.meta.url));
+  const DEFAULT_CONFIG_PATH = path.resolve(__selfDir2, '../shared/default-workflow.json');
+
+  // Ensure icebox directory exists for idea files
+  if (!fs.existsSync(ICEBOX_DIR)) fs.mkdirSync(ICEBOX_DIR, { recursive: true });
+
+  const app = express();
+  const httpServer = createServer(app);
+
+  const io = new Server(httpServer, {
+    cors: {
+      origin: (origin, callback) => {
+        // Allow all localhost origins (dev tool, not production)
+        if (!origin || origin.startsWith('http://localhost:')) {
+          callback(null, true);
+        } else {
+          callback(new Error('CORS not allowed'));
+        }
+      },
+      methods: ['GET', 'POST'],
+    },
+  });
+
+  // Middleware
+  app.use(express.json());
+
+  // Initialize database
+  const db = getDatabase();
+
+  // Initialize services
+  const scopeCache = new ScopeCache();
+  const scopeService = new ScopeService(scopeCache, io, config.scopesDir, workflowEngine);
+  const eventService = new EventService(db, io);
+  const gateService = new GateService(db, io);
+  const deployService = new DeployService(db, io);
+  const sprintService = new SprintService(db, io, scopeService);
+  const sprintOrchestrator = new SprintOrchestrator(db, io, sprintService, scopeService, workflowEngine);
+  const batchOrchestrator = new BatchOrchestrator(db, io, sprintService, scopeService, workflowEngine);
+  const readinessService = new ReadinessService(scopeService, gateService, workflowEngine, config.projectRoot);
+  const workflowService = new WorkflowService(config.configDir, workflowEngine, config.scopesDir, DEFAULT_CONFIG_PATH);
+  workflowService.setSocketServer(io);
+
+  // Ensure in-memory engine reflects the actual active config (may differ from bundled default
+  // if the user applied a custom preset)
+  workflowEngine.reload(workflowService.getActive());
+  const gitService = new GitService(config.projectRoot, scopeCache);
+  const githubService = new GitHubService(config.projectRoot);
+
+  // Wire active-group guard into scope service (blocks manual moves for scopes in active batches/sprints)
+  scopeService.setActiveGroupCheck((scopeId) => sprintService.getActiveGroupForScope(scopeId));
+
+  // ─── Event Wiring ──────────────────────────────────────────
+
+  function inferScopeStatus(
+    eventType: string,
+    scopeId: unknown,
+    data: Record<string, unknown>
+  ): void {
+    if (scopeId == null) return;
+    const id = Number(scopeId);
+    if (isNaN(id) || id <= 0) return;
+
+    // Don't infer status for icebox idea cards
+    const current = scopeService.getById(id);
+    if (current?.status === 'icebox') return;
+
+    const currentStatus = current?.status ?? '';
+    const result = workflowEngine.inferStatus(eventType, currentStatus, data);
+    if (result === null) return;
+
+    // Handle dispatch resolution (AGENT_COMPLETED with outcome)
+    if (typeof result === 'object' && 'dispatchResolution' in result) {
+      resolveActiveDispatchesForScope(
+        db, io, id,
+        result.resolution as 'completed' | 'failed',
+      );
+      return;
+    }
+
+    scopeService.updateStatus(id, result, 'event');
+  }
+
+  eventService.onIngest((eventType, scopeId, data) => {
+    // Handle SESSION_START: link PID to dispatch via dispatch_id env var
+    if (eventType === 'SESSION_START' && typeof data.dispatch_id === 'string' && typeof data.pid === 'number') {
+      linkPidToDispatch(db, data.dispatch_id, data.pid);
+      log.info('SESSION_START: linked PID to dispatch', { pid: data.pid, dispatch_id: data.dispatch_id });
+      return;
+    }
+
+    // Handle SESSION_END: resolve dispatches by dispatch_id (preferred) or PID (fallback)
+    if (eventType === 'SESSION_END') {
+      let count = 0;
+      if (typeof data.dispatch_id === 'string') {
+        count = resolveDispatchesByDispatchId(db, io, data.dispatch_id);
+        if (count > 0) {
+          log.info('SESSION_END: resolved dispatches', { count, dispatch_id: data.dispatch_id });
+        }
+      }
+      // PID fallback for old hooks without dispatch_id
+      if (count === 0 && typeof data.pid === 'number') {
+        count = resolveDispatchesByPid(db, io, data.pid);
+        if (count > 0) {
+          log.info('SESSION_END: resolved dispatches by PID fallback', { count, pid: data.pid });
+        }
+      }
+      // Immediately resolve any batches/sprints whose session just ended,
+      // rather than waiting for the next stale-check interval
+      if (count > 0) {
+        batchOrchestrator.resolveStaleBatches();
+      }
+      return;
+    }
+
+    inferScopeStatus(eventType, scopeId, data);
+  });
+
+  scopeService.onStatusChange((scopeId, newStatus) => {
+    if (newStatus === 'dev') {
+      sprintOrchestrator.onScopeReachedDev(scopeId);
+    }
+    // Batch orchestrator tracks all status transitions (dev, staging, production)
+    batchOrchestrator.onScopeStatusChanged(scopeId, newStatus);
+  });
+
+  scopeService.onStatusChange((scopeId, newStatus) => {
+    if (workflowEngine.isTerminalStatus(newStatus)) {
+      resolveActiveDispatchesForScope(db, io, scopeId, 'completed');
+    }
+  });
+
+  // ─── Routes ────────────────────────────────────────────────
+
+  app.get('/api/orbital/health', (_req, res) => {
+    res.json({ status: 'ok', uptime: process.uptime(), timestamp: new Date().toISOString() });
+  });
+
+  // Serve dynamic config to the frontend
+  app.get('/api/orbital/config', (_req, res) => {
+    res.json({
+      projectName: config.projectName,
+      categories: config.categories,
+      agents: config.agents,
+      serverPort: config.serverPort,
+      clientPort: config.clientPort,
+    });
+  });
+
+  app.use('/api/orbital', createScopeRoutes({ db, io, scopeService, readinessService, projectRoot: config.projectRoot, engine: workflowEngine }));
+  app.use('/api/orbital', createDataRoutes({ db, io, gateService, deployService, engine: workflowEngine, projectRoot: config.projectRoot, inferScopeStatus }));
+  app.use('/api/orbital', createDispatchRoutes({ db, io, scopeService, projectRoot: config.projectRoot, engine: workflowEngine }));
+  app.use('/api/orbital', createSprintRoutes({ sprintService, sprintOrchestrator, batchOrchestrator }));
+  app.use('/api/orbital', createWorkflowRoutes({ workflowService, projectRoot: config.projectRoot }));
+  app.use('/api/orbital', createConfigRoutes({ projectRoot: config.projectRoot, workflowService, io }));
+  app.use('/api/orbital', createGitRoutes({ gitService, githubService, engine: workflowEngine }));
+  app.use('/api/orbital', createVersionRoutes({ io }));
+
+  // ─── Static File Serving (production) ───────────────────────
+
+  // Resolve the Vite-built frontend dist directory (server/ → ../dist).
+  const __selfDir = path.dirname(fileURLToPath(import.meta.url));
+  const distDir = path.resolve(__selfDir, '../dist');
+  if (fs.existsSync(path.join(distDir, 'index.html'))) {
+    app.use(express.static(distDir));
+    app.get('*', (req, res, next) => {
+      if (req.path.startsWith('/api/') || req.path.startsWith('/socket.io')) return next();
+      res.sendFile(path.join(distDir, 'index.html'));
+    });
+  } else {
+    // Dev mode: redirect root to Vite dev server
+    app.get('/', (_req, res) => res.redirect(`http://localhost:${config.clientPort}`));
+  }
+
+  // ─── Socket.io ──────────────────────────────────────────────
+
+  io.on('connection', (socket) => {
+    log.debug('Client connected', { socketId: socket.id });
+
+    socket.on('disconnect', () => {
+      log.debug('Client disconnected', { socketId: socket.id });
+    });
+  });
+
+  // ─── Startup ───────────────────────────────────────────────
+
+  // References for graceful shutdown
+  let scopeWatcher: ReturnType<typeof startScopeWatcher>;
+  let eventWatcher: ReturnType<typeof startEventWatcher>;
+  let batchRecoveryInterval: ReturnType<typeof setInterval>;
+  let staleCleanupInterval: ReturnType<typeof setInterval>;
+  let sessionSyncInterval: ReturnType<typeof setInterval>;
+  let gitPollInterval: ReturnType<typeof setInterval>;
+
+  const actualPort = await new Promise<number>((resolve, reject) => {
+    let attempt = 0;
+    const maxAttempts = 10;
+
+    httpServer.on('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE' && attempt < maxAttempts) {
+        attempt++;
+        const nextPort = port + attempt;
+        log.warn('Port in use, trying next', { tried: port + attempt - 1, next: nextPort });
+        httpServer.listen(nextPort);
+      } else {
+        reject(new Error(`Failed to start server: ${err.message}`));
+      }
+    });
+
+    httpServer.on('listening', () => {
+      const addr = httpServer.address();
+      const listenPort = typeof addr === 'object' && addr ? addr.port : port;
+      resolve(listenPort);
+    });
+
+    httpServer.listen(port);
+  });
+
+  // ─── Post-listen initialization ────────────────────────────
+
+  // Sync scopes from filesystem on startup (populates in-memory cache)
+  const scopeCount = scopeService.syncFromFilesystem();
+
+  // Resolve stale dispatch events (terminal scopes + age-based)
+  const staleResolved = resolveStaleDispatches(db, io, scopeService, workflowEngine);
+  if (staleResolved > 0) {
+    log.info('Resolved stale dispatch events', { count: staleResolved });
+  }
+
+  // Write iTerm2 dispatch profiles (idempotent, fire-and-forget)
+  ensureDynamicProfiles(workflowEngine);
+
+  // Start file watchers
+  scopeWatcher = startScopeWatcher(config.scopesDir, scopeService);
+  eventWatcher = startEventWatcher(config.eventsDir, eventService);
+
+  // Recover any active sprints/batches from before server restart
+  sprintOrchestrator.recoverActiveSprints().catch(err => log.error('Sprint recovery failed', { error: err.message }));
+  batchOrchestrator.recoverActiveBatches().catch(err => log.error('Batch recovery failed', { error: err.message }));
+
+  // Resolve stale batches on startup (catches stuck dispatches from previous runs)
+  const staleBatchesResolved = batchOrchestrator.resolveStaleBatches();
+  if (staleBatchesResolved > 0) {
+    log.info('Resolved stale batches', { count: staleBatchesResolved });
+  }
+
+  // Poll active batch PIDs every 30s for two-phase completion (B-1)
+  batchRecoveryInterval = setInterval(() => {
+    batchOrchestrator.recoverActiveBatches().catch(err => log.error('Batch recovery failed', { error: err.message }));
+  }, 30_000);
+
+  // Periodic stale dispatch + batch cleanup (crash recovery — catches SIGKILL'd sessions)
+  staleCleanupInterval = setInterval(() => {
+    const count = resolveStaleDispatches(db, io, scopeService, workflowEngine);
+    if (count > 0) {
+      log.info('Periodic cleanup: resolved stale dispatches', { count });
+    }
+    const batchCount = batchOrchestrator.resolveStaleBatches();
+    if (batchCount > 0) {
+      log.info('Periodic cleanup: resolved stale batches', { count: batchCount });
+    }
+  }, 30_000);
+
+  // Sync frontmatter-derived sessions into DB (non-blocking)
+  syncClaudeSessionsToDB(db, scopeService).then((count) => {
+    log.info('Synced frontmatter sessions', { count });
+
+    // Purge legacy pattern-matched rows (no action = old regex system)
+    const purged = db.prepare(
+      "DELETE FROM sessions WHERE action IS NULL AND id LIKE 'claude-%'"
+    ).run();
+    if (purged.changes > 0) {
+      log.info('Purged legacy pattern-matched session rows', { count: purged.changes });
+    }
+  }).catch(err => log.error('Session sync failed', { error: err.message }));
+
+  // Re-sync every 5 minutes so new sessions appear without restart
+  sessionSyncInterval = setInterval(() => {
+    syncClaudeSessionsToDB(db, scopeService)
+      .then((count) => {
+        if (count > 0) io.emit('session:updated', { type: 'resync', count });
+      })
+      .catch(err => log.error('Session resync failed', { error: err.message }));
+  }, 5 * 60 * 1000);
+
+  // Poll git status every 10s — emit socket event on change
+  let lastGitHash = '';
+  gitPollInterval = setInterval(async () => {
+    try {
+      const hash = await gitService.getStatusHash();
+      if (lastGitHash && hash !== lastGitHash) {
+        gitService.clearCache();
+        io.emit('git:status:changed');
+      }
+      lastGitHash = hash;
+    } catch { /* ok */ }
+  }, 10_000);
+
+  // eslint-disable-next-line no-console
+  console.log(`
+╔══════════════════════════════════════════════════════╗
+║         Orbital Command                              ║
+║         ${config.projectName.padEnd(42)} ║
+║                                                      ║
+║  >>> Open: http://localhost:${actualPort} <<<                 ║
+║                                                      ║
+╠══════════════════════════════════════════════════════╣
+║  Scopes:    ${String(scopeCount).padEnd(3)} loaded from filesystem          ║
+║  API:       http://localhost:${actualPort}/api/orbital/*       ║
+║  Socket.io: ws://localhost:${actualPort}                      ║
+╚══════════════════════════════════════════════════════╝
+`);
+
+  // ─── Graceful Shutdown ─────────────────────────────────────
+
+  let shuttingDown = false;
+  function shutdown(): Promise<void> {
+    if (shuttingDown) return Promise.resolve();
+    shuttingDown = true;
+    log.info('Shutting down');
+    scopeWatcher.close();
+    eventWatcher.close();
+    clearInterval(batchRecoveryInterval);
+    clearInterval(staleCleanupInterval);
+    clearInterval(sessionSyncInterval);
+    clearInterval(gitPollInterval);
+
+    return new Promise<void>((resolve) => {
+      const forceTimeout = setTimeout(() => {
+        closeDatabase();
+        resolve();
+      }, 2000);
+
+      io.close(() => {
+        clearTimeout(forceTimeout);
+        closeDatabase();
+        resolve();
+      });
+    });
+  }
+
+  return { app, io, db, workflowEngine, httpServer, shutdown };
+}
+
+// ─── Direct Execution (backward compat: tsx watch server/index.ts) ───
+
+const isDirectRun = process.argv[1] && (
+  process.argv[1].endsWith('server/index.ts') ||
+  process.argv[1].endsWith('server/index.js') ||
+  process.argv[1].endsWith('server')
+);
+
+if (isDirectRun) {
+  startServer().then(({ shutdown }) => {
+    process.on('SIGINT', async () => {
+      await shutdown();
+      process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+      await shutdown();
+      process.exit(0);
+    });
+  }).catch((err) => {
+    createLogger('server').error('Failed to start server', { error: err.message });
+    process.exit(1);
+  });
+}