orbital-command 0.1.0

package/server/routes/sprint-routes.ts

@@ -0,0 +1,142 @@
+import { Router } from 'express';
+import type { SprintService, SprintStatus, GroupTargetColumn, GroupType } from '../services/sprint-service.js';
+import type { SprintOrchestrator } from '../services/sprint-orchestrator.js';
+import type { BatchOrchestrator } from '../services/batch-orchestrator.js';
+
+interface SprintRouteDeps {
+  sprintService: SprintService;
+  sprintOrchestrator: SprintOrchestrator;
+  batchOrchestrator: BatchOrchestrator;
+}
+
+export function createSprintRoutes({ sprintService, sprintOrchestrator, batchOrchestrator }: SprintRouteDeps): Router {
+  const router = Router();
+
+  router.post('/sprints', (req, res) => {
+    const { name, target_column, group_type } = req.body as {
+      name?: string; target_column?: GroupTargetColumn; group_type?: GroupType;
+    };
+    if (!name || !name.trim()) {
+      res.status(400).json({ error: 'name is required' });
+      return;
+    }
+    const sprint = sprintService.create(name.trim(), { target_column, group_type });
+    res.status(201).json(sprint);
+  });
+
+  router.get('/sprints', (req, res) => {
+    const status = req.query.status as string | undefined;
+    const targetColumn = req.query.target_column as string | undefined;
+    const sprints = sprintService.getAll(
+      status as SprintStatus | undefined,
+      targetColumn as GroupTargetColumn | undefined,
+    );
+    res.json(sprints);
+  });
+
+  router.get('/sprints/:id', (req, res) => {
+    const sprint = sprintService.getById(Number(req.params.id));
+    if (!sprint) {
+      res.status(404).json({ error: 'Sprint not found' });
+      return;
+    }
+    res.json(sprint);
+  });
+
+  router.patch('/sprints/:id', (req, res) => {
+    const { name } = req.body as { name?: string };
+    if (!name || !name.trim()) {
+      res.status(400).json({ error: 'name is required' });
+      return;
+    }
+    const renamed = sprintService.rename(Number(req.params.id), name.trim());
+    if (!renamed) {
+      res.status(400).json({ error: 'Sprint not found or not in assembling state' });
+      return;
+    }
+    res.json({ ok: true });
+  });
+
+  router.delete('/sprints/:id', (req, res) => {
+    const deleted = sprintService.delete(Number(req.params.id));
+    if (!deleted) {
+      res.status(400).json({ error: 'Cannot delete sprint (must be assembling)' });
+      return;
+    }
+    res.json({ ok: true });
+  });
+
+  router.post('/sprints/:id/scopes', (req, res) => {
+    const { scope_ids } = req.body as { scope_ids?: number[] };
+    if (!Array.isArray(scope_ids) || scope_ids.length === 0) {
+      res.status(400).json({ error: 'scope_ids must be a non-empty array' });
+      return;
+    }
+    const result = sprintService.addScopes(Number(req.params.id), scope_ids);
+    if (!result) {
+      res.status(400).json({ error: 'Sprint not found or not in assembling state' });
+      return;
+    }
+    res.json(result);
+  });
+
+  router.delete('/sprints/:id/scopes', (req, res) => {
+    const { scope_ids } = req.body as { scope_ids?: number[] };
+    if (!Array.isArray(scope_ids) || scope_ids.length === 0) {
+      res.status(400).json({ error: 'scope_ids must be a non-empty array' });
+      return;
+    }
+    const removed = sprintService.removeScopes(Number(req.params.id), scope_ids);
+    if (!removed) {
+      res.status(400).json({ error: 'Sprint not found or not in assembling state' });
+      return;
+    }
+    res.json({ ok: true });
+  });
+
+  router.post('/sprints/:id/dispatch', async (req, res) => {
+    const id = Number(req.params.id);
+    const sprint = sprintService.getById(id);
+    if (!sprint) {
+      res.status(404).json({ error: 'Sprint not found' });
+      return;
+    }
+
+    if (sprint.group_type === 'batch') {
+      const { mergeMode } = req.body as { mergeMode?: string };
+      const result = await batchOrchestrator.dispatch(id, mergeMode);
+      if (!result.ok) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      res.json({ ok: true });
+    } else {
+      const result = await sprintOrchestrator.startSprint(id);
+      if (!result.ok) {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      res.json({ ok: true, layers: result.layers });
+    }
+  });
+
+  router.post('/sprints/:id/cancel', (req, res) => {
+    const cancelled = sprintOrchestrator.cancelSprint(Number(req.params.id));
+    if (!cancelled) {
+      res.status(400).json({ error: 'Sprint not found or cannot be cancelled' });
+      return;
+    }
+    res.json({ ok: true });
+  });
+
+  router.get('/sprints/:id/graph', (req, res) => {
+    const graph = sprintOrchestrator.getExecutionGraph(Number(req.params.id));
+    if (!graph) {
+      res.status(404).json({ error: 'Sprint not found' });
+      return;
+    }
+    res.json(graph);
+  });
+
+  return router;
+}

package/server/routes/version-routes.ts

@@ -0,0 +1,156 @@
+import { Router } from 'express';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import type { Server } from 'socket.io';
+import { createLogger } from '../utils/logger.js';
+
+const log = createLogger('version');
+
+const execFileAsync = promisify(execFile);
+
+interface VersionRouteDeps {
+  io: Server;
+}
+
+/** Resolve the root directory of the orbital-command package itself. */
+function getOrbitalRoot(): string {
+  const __selfDir = path.dirname(fileURLToPath(import.meta.url));
+  // Walk up until we find package.json (handles both dev and compiled paths)
+  let dir = __selfDir;
+  for (let i = 0; i < 6; i++) {
+    if (fs.existsSync(path.join(dir, 'package.json'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  // Fallback: assume dev layout (server/routes/ → 2 levels up)
+  return path.resolve(__selfDir, '../..');
+}
+
+async function git(args: string[], cwd: string, timeoutMs = 15_000): Promise<string> {
+  const { stdout } = await execFileAsync('git', args, { cwd, timeout: timeoutMs });
+  return stdout.trim();
+}
+
+export function createVersionRoutes({ io }: VersionRouteDeps): Router {
+  const router = Router();
+  const orbitalRoot = getOrbitalRoot();
+
+  // GET /version — current version info
+  router.get('/version', async (_req, res) => {
+    try {
+      const pkgPath = path.join(orbitalRoot, 'package.json');
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+
+      let commitSha = 'unknown';
+      let branch = 'unknown';
+      try {
+        commitSha = await git(['rev-parse', '--short', 'HEAD'], orbitalRoot);
+        branch = await git(['rev-parse', '--abbrev-ref', 'HEAD'], orbitalRoot);
+      } catch {
+        // Not a git repo (installed via npm) — version only
+      }
+
+      res.json({
+        version: pkg.version,
+        commitSha,
+        branch,
+      });
+    } catch (err) {
+      log.error('Version route error', { error: (err as Error).message });
+      res.status(500).json({ error: `Failed to read version: ${(err as Error).message}` });
+    }
+  });
+
+  // GET /version/check — fetch from remote and compare SHAs
+  router.get('/version/check', async (_req, res) => {
+    try {
+      const branch = await git(['rev-parse', '--abbrev-ref', 'HEAD'], orbitalRoot);
+      await git(['fetch', 'origin', branch, '--quiet'], orbitalRoot);
+
+      const localSha = await git(['rev-parse', 'HEAD'], orbitalRoot);
+      const remoteSha = await git(['rev-parse', `origin/${branch}`], orbitalRoot);
+
+      let behindCount = 0;
+      if (localSha !== remoteSha) {
+        const countStr = await git(
+          ['rev-list', '--count', `HEAD..origin/${branch}`],
+          orbitalRoot,
+        );
+        behindCount = parseInt(countStr, 10) || 0;
+      }
+
+      res.json({
+        updateAvailable: behindCount > 0,
+        behindCount,
+        localSha: localSha.slice(0, 7),
+        remoteSha: remoteSha.slice(0, 7),
+        branch,
+      });
+    } catch (err) {
+      log.error('Version route error', { error: (err as Error).message });
+      res.status(500).json({ error: `Failed to check for updates: ${(err as Error).message}` });
+    }
+  });
+
+  // POST /version/update — git pull + npm install
+  router.post('/version/update', async (req, res) => {
+    if (req.headers['x-orbital-action'] !== 'update') {
+      res.status(403).json({ error: 'Missing required X-Orbital-Action header' });
+      return;
+    }
+
+    let stage = 'guard';
+    try {
+      // Guard: refuse if working tree is dirty
+      const status = await git(['status', '--porcelain'], orbitalRoot);
+      if (status.length > 0) {
+        res.status(409).json({
+          error: 'Working tree has uncommitted changes. Commit or stash before updating.',
+          dirty: true,
+        });
+        return;
+      }
+
+      stage = 'pulling';
+      io.emit('version:updating', { stage });
+
+      await git(['pull', '--ff-only'], orbitalRoot);
+
+      stage = 'installing';
+      io.emit('version:updating', { stage });
+
+      await execFileAsync('npm', ['install'], {
+        cwd: orbitalRoot,
+        timeout: 120_000,
+      });
+
+      io.emit('version:updated', { success: true });
+
+      // Read updated version
+      const pkg = JSON.parse(fs.readFileSync(path.join(orbitalRoot, 'package.json'), 'utf-8'));
+      const commitSha = await git(['rev-parse', '--short', 'HEAD'], orbitalRoot);
+
+      res.json({
+        success: true,
+        version: pkg.version,
+        commitSha,
+        message: 'Update complete. Restart the server to apply changes.',
+      });
+    } catch (err) {
+      log.error('Version route error', { error: (err as Error).message });
+      const recovery = stage === 'installing'
+        ? ' Git pull succeeded — run `npm install` manually to finish.'
+        : stage === 'pulling'
+          ? ' No files were changed — safe to retry.'
+          : '';
+      io.emit('version:updated', { success: false, error: (err as Error).message });
+      res.status(500).json({ error: `Update failed at stage "${stage}": ${(err as Error).message}.${recovery}` });
+    }
+  });
+
+  return router;
+}

package/server/routes/workflow-routes.ts

@@ -0,0 +1,198 @@
+import { Router } from 'express';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import type { WorkflowConfig } from '../../shared/workflow-config.js';
+import type { WorkflowService } from '../services/workflow-service.js';
+import { parseCcHooks } from '../utils/cc-hooks-parser.js';
+
+interface WorkflowRouteDeps {
+  workflowService: WorkflowService;
+  projectRoot: string;
+}
+
+export function createWorkflowRoutes({ workflowService, projectRoot }: WorkflowRouteDeps): Router {
+  const router = Router();
+
+  // GET /workflow — returns active config
+  router.get('/workflow', (_req, res) => {
+    try {
+      res.json({ success: true, data: workflowService.getActive() });
+    } catch (err) {
+      res.status(500).json({ success: false, error: errMsg(err) });
+    }
+  });
+
+  // PUT /workflow — validate and update active config
+  router.put('/workflow', (req, res) => {
+    try {
+      const config = req.body as WorkflowConfig;
+      const result = workflowService.updateActive(config);
+      if (!result.valid) {
+        res.status(400).json({ success: false, error: 'Validation failed', data: result });
+        return;
+      }
+      res.json({ success: true, data: result });
+    } catch (err) {
+      res.status(500).json({ success: false, error: errMsg(err) });
+    }
+  });
+
+  // GET /workflow/presets — list all presets
+  router.get('/workflow/presets', (_req, res) => {
+    try {
+      res.json({ success: true, data: workflowService.listPresets() });
+    } catch (err) {
+      res.status(500).json({ success: false, error: errMsg(err) });
+    }
+  });
+
+  // POST /workflow/presets — save current config as named preset
+  router.post('/workflow/presets', (req, res) => {
+    try {
+      const { name } = req.body as { name: string };
+      if (!name) {
+        res.status(400).json({ success: false, error: 'name is required' });
+        return;
+      }
+      workflowService.savePreset(name);
+      res.json({ success: true });
+    } catch (err) {
+      const msg = errMsg(err);
+      const status = msg.includes('Cannot overwrite') || msg.includes('must be') ? 400 : 500;
+      res.status(status).json({ success: false, error: msg });
+    }
+  });
+
+  // GET /workflow/presets/:name — get specific preset
+  router.get('/workflow/presets/:name', (req, res) => {
+    try {
+      const config = workflowService.getPreset(req.params.name);
+      res.json({ success: true, data: config });
+    } catch (err) {
+      const msg = errMsg(err);
+      const status = msg.includes('not found') ? 404 : 500;
+      res.status(status).json({ success: false, error: msg });
+    }
+  });
+
+  // DELETE /workflow/presets/:name — delete preset
+  router.delete('/workflow/presets/:name', (req, res) => {
+    try {
+      workflowService.deletePreset(req.params.name);
+      res.json({ success: true });
+    } catch (err) {
+      const msg = errMsg(err);
+      const status = msg.includes('Cannot delete') ? 400 : msg.includes('not found') ? 404 : 500;
+      res.status(status).json({ success: false, error: msg });
+    }
+  });
+
+  // GET /workflow/hooks — returns all hooks with edge mapping
+  router.get('/workflow/hooks', (_req, res) => {
+    try {
+      const engine = workflowService.getEngine();
+      const hooks = engine.getAllHooks();
+      const edgeHookMap: Record<string, string[]> = {};
+      for (const edge of engine.getAllEdges()) {
+        if (edge.hooks && edge.hooks.length > 0) {
+          edgeHookMap[`${edge.from}:${edge.to}`] = edge.hooks;
+        }
+      }
+      res.json({ success: true, data: { hooks, edgeHookMap } });
+    } catch (err) {
+      res.status(500).json({ success: false, error: errMsg(err) });
+    }
+  });
+
+  // POST /workflow/preview — dry-run migration preview
+  router.post('/workflow/preview', (req, res) => {
+    try {
+      const config = req.body as WorkflowConfig;
+      const plan = workflowService.previewMigration(config);
+      res.json({ success: true, data: plan });
+    } catch (err) {
+      res.status(500).json({ success: false, error: errMsg(err) });
+    }
+  });
+
+  // GET /workflow/hooks/:id/source — read hook source file
+  router.get('/workflow/hooks/:id/source', async (req, res) => {
+    try {
+      const hookId = req.params.id;
+      const engine = workflowService.getEngine();
+      const hook = engine.getAllHooks().find((h) => h.id === hookId);
+      if (!hook) {
+        res.status(404).json({ success: false, error: `Hook '${hookId}' not found` });
+        return;
+      }
+      if (hook.target.includes('..')) {
+        res.status(400).json({ success: false, error: 'Invalid hook target path' });
+        return;
+      }
+      const filePath = path.resolve(projectRoot, hook.target);
+      const content = await readFile(filePath, 'utf-8');
+      const lineCount = content.split('\n').length;
+      res.json({ success: true, data: { hookId, filePath: hook.target, content, lineCount } });
+    } catch (err) {
+      const msg = errMsg(err);
+      const status = msg.includes('ENOENT') ? 404 : 500;
+      res.status(status).json({ success: false, error: msg });
+    }
+  });
+
+  // GET /workflow/claude-hooks — returns all Claude Code hooks from settings.local.json
+  router.get('/workflow/claude-hooks', (_req, res) => {
+    try {
+      const settingsPath = path.resolve(projectRoot, '.claude/settings.local.json');
+      const data = parseCcHooks(settingsPath);
+      res.json({ success: true, data });
+    } catch (err) {
+      res.status(500).json({ success: false, error: errMsg(err) });
+    }
+  });
+
+  // GET /workflow/hooks/source — read any hook source file by path
+  router.get('/workflow/hooks/source', async (req, res) => {
+    try {
+      const hookPath = req.query.path as string | undefined;
+      if (!hookPath) {
+        res.status(400).json({ success: false, error: 'path query parameter is required' });
+        return;
+      }
+      if (hookPath.includes('..')) {
+        res.status(400).json({ success: false, error: 'Invalid path: directory traversal not allowed' });
+        return;
+      }
+      const filePath = path.resolve(projectRoot, hookPath);
+      const content = await readFile(filePath, 'utf-8');
+      const lineCount = content.split('\n').length;
+      res.json({ success: true, data: { filePath: hookPath, content, lineCount } });
+    } catch (err) {
+      const msg = errMsg(err);
+      const status = msg.includes('ENOENT') ? 404 : 500;
+      res.status(status).json({ success: false, error: msg });
+    }
+  });
+
+  // POST /workflow/apply — apply new config with orphan mappings
+  router.post('/workflow/apply', (req, res) => {
+    try {
+      const { config, orphanMappings } = req.body as {
+        config: WorkflowConfig;
+        orphanMappings: Record<string, string>;
+      };
+      const plan = workflowService.applyMigration(config, orphanMappings ?? {});
+      res.json({ success: true, data: plan });
+    } catch (err) {
+      const msg = errMsg(err);
+      const status = msg.includes('Missing orphan') || msg.includes('Validation failed') || msg.includes('not a valid') ? 400 : 500;
+      res.status(status).json({ success: false, error: msg });
+    }
+  });
+
+  return router;
+}
+
+function errMsg(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}

package/server/schema.ts

@@ -0,0 +1,90 @@
+export const SCHEMA_DDL = `
+-- Events from hooks/watchers
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  scope_id INTEGER,
+  session_id TEXT,
+  agent TEXT,
+  data TEXT DEFAULT '{}',
+  timestamp TEXT NOT NULL,
+  processed INTEGER DEFAULT 0
+);
+
+-- Quality gate results per scope
+CREATE TABLE IF NOT EXISTS quality_gates (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  scope_id INTEGER,
+  gate_name TEXT NOT NULL,
+  status TEXT NOT NULL,
+  details TEXT,
+  duration_ms INTEGER,
+  run_at TEXT NOT NULL,
+  commit_sha TEXT
+);
+
+-- Deployment tracking
+CREATE TABLE IF NOT EXISTS deployments (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  environment TEXT NOT NULL,
+  status TEXT NOT NULL,
+  commit_sha TEXT,
+  branch TEXT,
+  pr_number INTEGER,
+  health_check_url TEXT,
+  started_at TEXT,
+  completed_at TEXT,
+  details TEXT DEFAULT '{}'
+);
+
+-- Session history
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  scope_id INTEGER,
+  claude_session_id TEXT,
+  action TEXT,
+  started_at TEXT,
+  ended_at TEXT,
+  handoff_file TEXT,
+  summary TEXT,
+  discoveries TEXT DEFAULT '[]',
+  next_steps TEXT DEFAULT '[]',
+  progress_pct INTEGER
+);
+
+-- Sprint containers for batching scope dispatch
+CREATE TABLE IF NOT EXISTS sprints (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'assembling',
+  concurrency_cap INTEGER NOT NULL DEFAULT 5,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  dispatched_at TEXT,
+  completed_at TEXT,
+  dispatch_meta TEXT DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS sprint_scopes (
+  sprint_id INTEGER NOT NULL,
+  scope_id INTEGER NOT NULL,
+  layer INTEGER,
+  dispatch_status TEXT NOT NULL DEFAULT 'pending',
+  dispatched_at TEXT,
+  completed_at TEXT,
+  error TEXT,
+  PRIMARY KEY (sprint_id, scope_id),
+  FOREIGN KEY (sprint_id) REFERENCES sprints(id) ON DELETE CASCADE
+);
+
+-- Indexes for common queries
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
+CREATE INDEX IF NOT EXISTS idx_events_scope_id ON events(scope_id);
+CREATE INDEX IF NOT EXISTS idx_gates_scope_id ON quality_gates(scope_id);
+CREATE INDEX IF NOT EXISTS idx_gates_run_at ON quality_gates(run_at);
+CREATE INDEX IF NOT EXISTS idx_deployments_env ON deployments(environment);
+CREATE INDEX IF NOT EXISTS idx_sessions_scope ON sessions(scope_id);
+CREATE INDEX IF NOT EXISTS idx_sprints_status ON sprints(status);
+CREATE INDEX IF NOT EXISTS idx_sprint_scopes_sprint ON sprint_scopes(sprint_id);
+`;