orbital-command 0.1.0

package/dist/server/server/routes/workflow-routes.js

@@ -0,0 +1,185 @@
+import { Router } from 'express';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { parseCcHooks } from '../utils/cc-hooks-parser.js';
+export function createWorkflowRoutes({ workflowService, projectRoot }) {
+    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;
+            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;
+            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 = {};
+            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;
+            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;
+            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;
+            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) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/server/server/schema.js

@@ -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);
+`;

package/dist/server/server/services/batch-orchestrator.js

@@ -0,0 +1,253 @@
+import { launchInCategorizedTerminal, escapeForAnsiC, snapshotSessionPids, discoverNewSession, isSessionPidAlive } from '../utils/terminal-launcher.js';
+import { linkPidToDispatch, resolveDispatchEvent } from '../utils/dispatch-utils.js';
+import { getConfig } from '../config.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('batch');
+const VALID_MERGE_MODES = ['push', 'pr'];
+// ─── Orchestrator ───────────────────────────────────────────
+export class BatchOrchestrator {
+    db;
+    io;
+    sprintService;
+    scopeService;
+    engine;
+    constructor(db, io, sprintService, scopeService, engine) {
+        this.db = db;
+        this.io = io;
+        this.sprintService = sprintService;
+        this.scopeService = scopeService;
+        this.engine = engine;
+    }
+    /** Dispatch a batch — validates constraints and routes to column-specific handler */
+    async dispatch(batchId, mergeMode) {
+        const batch = this.sprintService.getById(batchId);
+        if (!batch)
+            return { ok: false, error: 'Batch not found' };
+        if (batch.group_type !== 'batch')
+            return { ok: false, error: 'Not a batch group' };
+        if (batch.status !== 'assembling')
+            return { ok: false, error: `Batch status is '${batch.status}', expected 'assembling'` };
+        if (batch.scope_ids.length === 0)
+            return { ok: false, error: 'Batch has no scopes' };
+        // W-4: One active batch per column
+        const existingActive = this.sprintService.findActiveBatchForColumn(batch.target_column);
+        if (existingActive && existingActive.id !== batchId) {
+            return { ok: false, error: `Column '${batch.target_column}' already has an active batch (ID: ${existingActive.id})` };
+        }
+        const command = this.engine.getBatchCommand(batch.target_column);
+        if (!command)
+            return { ok: false, error: `No dispatch command for column '${batch.target_column}'` };
+        // Mark batch as dispatched
+        this.sprintService.updateStatus(batchId, 'dispatched');
+        log.info('Batch dispatched', { id: batchId, target_column: batch.target_column, scope_ids: batch.scope_ids });
+        // Build scope IDs env var prefix (W-1: prepend to command, not process.env)
+        const scopeIdsStr = batch.scope_ids.join(',');
+        const mergeModeStr = VALID_MERGE_MODES.includes(mergeMode ?? '') ? mergeMode : 'push';
+        // Record DISPATCH event
+        const eventId = crypto.randomUUID();
+        const eventData = {
+            command,
+            batch_id: batchId,
+            scope_ids: batch.scope_ids,
+            target_column: batch.target_column,
+            batch: true,
+            resolved: null,
+        };
+        this.db.prepare(`INSERT INTO events (id, type, scope_id, session_id, agent, data, timestamp)
+       VALUES (?, 'DISPATCH', NULL, NULL, 'batch-orchestrator', ?, ?)`).run(eventId, JSON.stringify(eventData), new Date().toISOString());
+        this.io.emit('event:new', {
+            id: eventId, type: 'DISPATCH', scope_id: null,
+            session_id: null, agent: 'batch-orchestrator',
+            data: eventData, timestamp: new Date().toISOString(),
+        });
+        // Launch single CLI session with BATCH_SCOPE_IDS prepended to command
+        const escaped = escapeForAnsiC(command);
+        const fullCmd = `cd '${getConfig().projectRoot}' && BATCH_SCOPE_IDS='${scopeIdsStr}' MERGE_MODE='${mergeModeStr}' claude --dangerously-skip-permissions $'${escaped}'`;
+        const beforePids = snapshotSessionPids(getConfig().projectRoot);
+        try {
+            await launchInCategorizedTerminal(command, fullCmd);
+            // Store dispatch result timestamp
+            this.sprintService.updateDispatchResult(batchId, {
+                dispatched_at: new Date().toISOString(),
+            });
+            // Fire-and-forget: discover session PID and link to dispatch
+            discoverNewSession(getConfig().projectRoot, beforePids)
+                .then((session) => {
+                if (!session)
+                    return;
+                linkPidToDispatch(this.db, eventId, session.pid);
+                // Store PID on the batch for two-phase completion
+                const currentResult = this.sprintService.getById(batchId)?.dispatch_result ?? {};
+                this.sprintService.updateDispatchResult(batchId, {
+                    ...currentResult,
+                    dispatched_at: currentResult.dispatched_at ?? new Date().toISOString(),
+                });
+                // Store PID in event data for later liveness checking
+                const row = this.db.prepare('SELECT data FROM events WHERE id = ?').get(eventId);
+                if (row) {
+                    const data = JSON.parse(row.data);
+                    data.pid = session.pid;
+                    this.db.prepare('UPDATE events SET data = ? WHERE id = ?').run(JSON.stringify(data), eventId);
+                }
+            })
+                .catch(err => log.error('PID discovery failed', { error: err.message }));
+            return { ok: true };
+        }
+        catch (err) {
+            this.sprintService.updateStatus(batchId, 'failed');
+            resolveDispatchEvent(this.db, this.io, eventId, 'failed', String(err));
+            return { ok: false, error: `Failed to launch terminal: ${err}` };
+        }
+    }
+    /** Called when a scope reaches a new status — check if it satisfies a batch,
+     *  or remove the scope from the batch if its status diverged from the target. */
+    onScopeStatusChanged(scopeId, newStatus) {
+        // Find any active batch containing this scope
+        const match = this.sprintService.findActiveSprintForScope(scopeId);
+        if (!match)
+            return;
+        const batch = this.sprintService.getById(match.sprint_id);
+        if (!batch || batch.group_type !== 'batch')
+            return;
+        const expectedStatus = this.engine.getBatchTargetStatus(batch.target_column);
+        if (newStatus === expectedStatus || this.engine.isTerminalStatus(newStatus)) {
+            this.sprintService.updateScopeStatus(batch.id, scopeId, 'completed');
+            // Check if all scopes have transitioned
+            if (batch.status === 'dispatched') {
+                this.sprintService.updateStatus(batch.id, 'in_progress');
+            }
+        }
+        else if (newStatus !== batch.target_column) {
+            // Scope diverged from batch target — remove it from the batch
+            this.sprintService.forceRemoveScope(batch.id, scopeId);
+            // If batch is now empty, mark it as failed
+            const remaining = this.sprintService.getSprintScopes(batch.id);
+            if (remaining.length === 0 && batch.status !== 'assembling') {
+                this.sprintService.updateStatus(batch.id, 'failed');
+            }
+        }
+    }
+    /** Called when a dispatched session PID dies — second phase of two-phase completion.
+     *  Reverts un-transitioned scopes to their pre-dispatch status. */
+    onSessionPidDied(batchId) {
+        const batch = this.sprintService.getById(batchId);
+        if (!batch || batch.group_type !== 'batch')
+            return;
+        if (batch.status !== 'dispatched' && batch.status !== 'in_progress')
+            return;
+        const scopes = this.sprintService.getSprintScopes(batchId);
+        const allTransitioned = scopes.every((ss) => ss.dispatch_status === 'completed');
+        if (allTransitioned) {
+            this.sprintService.updateStatus(batchId, 'completed');
+        }
+        else {
+            const pending = scopes.filter((ss) => ss.dispatch_status !== 'completed').map((ss) => ss.scope_id);
+            this.sprintService.updateStatus(batchId, 'failed');
+            // Mark un-transitioned scopes as failed and revert their status
+            for (const scopeId of pending) {
+                this.sprintService.updateScopeStatus(batchId, scopeId, 'failed', 'Session exited before scope transitioned');
+                // Revert scope to pre-dispatch status (the batch's source column)
+                this.scopeService.updateStatus(scopeId, batch.target_column, 'rollback');
+            }
+        }
+    }
+    /**
+     * Resolve stale batches — catches batches stuck due to lost PIDs, Orbital downtime, or
+     * missing PID records. Unlike recoverActiveBatches (which focuses on PID polling),
+     * this also resolves batches where no PID was ever recorded.
+     */
+    resolveStaleBatches() {
+        const STALE_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
+        const active = this.db.prepare(`SELECT id FROM sprints WHERE group_type = 'batch' AND status IN ('dispatched', 'in_progress')`).all();
+        if (active.length > 0) {
+            log.debug('Checking stale batches', { activeCount: active.length });
+        }
+        let resolved = 0;
+        for (const { id } of active) {
+            const batch = this.sprintService.getById(id);
+            if (!batch)
+                continue;
+            const scopes = this.sprintService.getSprintScopes(id);
+            const expectedStatus = this.engine.getBatchTargetStatus(batch.target_column);
+            // Phase 1: auto-complete scopes that reached or passed target status
+            for (const ss of scopes) {
+                if (ss.dispatch_status === 'pending' || ss.dispatch_status === 'dispatched') {
+                    const scope = this.scopeService.getById(ss.scope_id);
+                    if (scope && (scope.status === expectedStatus || this.engine.isTerminalStatus(scope.status))) {
+                        this.sprintService.updateScopeStatus(id, ss.scope_id, 'completed');
+                    }
+                }
+            }
+            // Phase 2: check PID liveness (check both unresolved and resolved events —
+            // SESSION_END may have resolved the dispatch event before we get here)
+            const dispatchEvent = this.db.prepare(`SELECT data FROM events
+         WHERE type = 'DISPATCH' AND JSON_EXTRACT(data, '$.batch_id') = ?
+         ORDER BY timestamp DESC LIMIT 1`).get(id);
+            let pidDead = false;
+            if (dispatchEvent) {
+                const data = JSON.parse(dispatchEvent.data);
+                // If the dispatch event is already resolved, the session is definitely done
+                if (data.resolved != null) {
+                    pidDead = true;
+                }
+                else if (typeof data.pid === 'number') {
+                    pidDead = !isSessionPidAlive(data.pid);
+                }
+                else {
+                    // No PID recorded — check if batch is old enough to consider stale
+                    const dispatchedAt = batch.dispatched_at ? new Date(batch.dispatched_at).getTime() : 0;
+                    pidDead = Date.now() - dispatchedAt > STALE_THRESHOLD_MS;
+                }
+            }
+            else {
+                // No dispatch event at all — check age
+                const dispatchedAt = batch.dispatched_at ? new Date(batch.dispatched_at).getTime() : 0;
+                pidDead = Date.now() - dispatchedAt > STALE_THRESHOLD_MS;
+            }
+            if (pidDead) {
+                this.onSessionPidDied(id);
+                resolved++;
+            }
+        }
+        return resolved;
+    }
+    /** Recover active batches after server restart (W-3) */
+    async recoverActiveBatches() {
+        const active = this.db.prepare(`SELECT id FROM sprints WHERE group_type = 'batch' AND status IN ('dispatched', 'in_progress')`).all();
+        if (active.length > 0) {
+            log.debug('Recovering active batches', { count: active.length });
+        }
+        for (const { id } of active) {
+            const batch = this.sprintService.getById(id);
+            if (!batch)
+                continue;
+            const scopes = this.sprintService.getSprintScopes(id);
+            const expectedStatus = this.engine.getBatchTargetStatus(batch.target_column);
+            // Check if scopes reached or passed target status while server was down
+            for (const ss of scopes) {
+                if (ss.dispatch_status === 'pending' || ss.dispatch_status === 'dispatched') {
+                    const scope = this.scopeService.getById(ss.scope_id);
+                    if (scope && (scope.status === expectedStatus || this.engine.isTerminalStatus(scope.status))) {
+                        this.sprintService.updateScopeStatus(id, ss.scope_id, 'completed');
+                    }
+                }
+            }
+            // Check if dispatch PID is still alive (include resolved events —
+            // SESSION_END may have resolved the dispatch before server restart)
+            const dispatchEvent = this.db.prepare(`SELECT data FROM events
+         WHERE type = 'DISPATCH' AND JSON_EXTRACT(data, '$.batch_id') = ?
+         ORDER BY timestamp DESC LIMIT 1`).get(id);
+            if (dispatchEvent) {
+                const data = JSON.parse(dispatchEvent.data);
+                if (data.resolved != null) {
+                    // Dispatch already resolved — session is done
+                    this.onSessionPidDied(id);
+                }
+                else if (typeof data.pid === 'number' && !isSessionPidAlive(data.pid)) {
+                    // PID is dead — trigger two-phase completion check
+                    this.onSessionPidDied(id);
+                }
+            }
+        }
+    }
+}