steroids-api 0.2.7

package/src/routes/credit-alerts.ts

@@ -0,0 +1,73 @@
+/**
+ * Credit Alerts API routes — credit exhaustion incidents for dashboard notifications.
+ */
+import { Router, Request, Response } from 'express';
+import Database from 'better-sqlite3';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { openSqliteForRead } from '../utils/sqlite.js';
+import { getRegisteredProjects } from '../../../dist/runners/projects.js';
+
+export const creditAlertRoutes = Router();
+
+interface IncidentRow { id: string; runner_id: string | null; details: string | null; created_at: string }
+
+function openProjectDb(path: string, readonly: boolean): Database.Database | null {
+  const dbPath = join(path, '.steroids', 'steroids.db');
+  if (!existsSync(dbPath)) return null;
+  try { return readonly ? openSqliteForRead(dbPath) : new Database(dbPath); } catch { return null; }
+}
+
+function parseRow(row: IncidentRow) {
+  let provider = '', model = '', role = '', message = '';
+  if (row.details) {
+    try { const d = JSON.parse(row.details); provider = d.provider ?? ''; model = d.model ?? ''; role = d.role ?? ''; message = d.message ?? ''; } catch { /* malformed */ }
+  }
+  return { id: row.id, provider, model, role, message, runnerId: row.runner_id, createdAt: row.created_at };
+}
+
+const ALERT_SQL = `SELECT id, runner_id, details, created_at FROM incidents
+  WHERE failure_mode = 'credit_exhaustion' AND resolved_at IS NULL ORDER BY created_at DESC`;
+
+const DISMISS_SQL = `UPDATE incidents SET resolved_at = datetime('now'), resolution = ?
+  WHERE id = ? AND resolved_at IS NULL AND failure_mode = 'credit_exhaustion'`;
+
+const RETRY_SQL = `UPDATE incidents SET resolved_at = datetime('now'), resolution = 'retry'
+  WHERE id = ? AND resolved_at IS NULL AND failure_mode = 'credit_exhaustion'`;
+
+function resolveIncident(req: Request, res: Response, sql: string, params: unknown[]) {
+  const projectPath = req.body?.project as string | undefined;
+  if (!projectPath) { res.status(400).json({ error: 'Missing body param: project' }); return; }
+  const db = openProjectDb(projectPath, false);
+  if (!db) { res.status(404).json({ error: 'Project database not found' }); return; }
+  try {
+    const r = db.prepare(sql).run(...params);
+    if (r.changes === 0) { res.status(404).json({ error: 'Incident not found or already resolved' }); return; }
+    res.json({ ok: true });
+  } catch { res.status(500).json({ error: 'Failed to update alert' }); } finally { db.close(); }
+}
+
+/** GET / — list active credit exhaustion incidents. project query param is optional. */
+creditAlertRoutes.get('/', (req: Request, res: Response) => {
+  const project = req.query.project as string | undefined;
+  const paths = project ? [project] : getRegisteredProjects(false).map((p: { path: string }) => p.path);
+  const alerts: ReturnType<typeof parseRow>[] = [];
+  for (const p of paths) {
+    const db = openProjectDb(p, true);
+    if (!db) continue;
+    try { (db.prepare(ALERT_SQL).all() as IncidentRow[]).forEach((r) => alerts.push(parseRow(r))); } catch { /* best-effort */ } finally { db.close(); }
+  }
+  alerts.sort((a, b) => (b.createdAt > a.createdAt ? 1 : b.createdAt < a.createdAt ? -1 : 0));
+  res.json({ alerts });
+});
+
+/** POST /:id/dismiss — resolve a credit alert. Body: optional {resolution}, defaults "dismissed". */
+creditAlertRoutes.post('/:id/dismiss', (req: Request, res: Response) => {
+  const resolution = (req.body?.resolution as string) || 'dismissed';
+  resolveIncident(req, res, DISMISS_SQL, [resolution, req.params.id]);
+});
+
+/** POST /:id/retry — resolve with retry signal. Body: {project} only. */
+creditAlertRoutes.post('/:id/retry', (req: Request, res: Response) => {
+  resolveIncident(req, res, RETRY_SQL, [req.params.id]);
+});

package/src/routes/health.ts

@@ -0,0 +1,219 @@
+/**
+ * Health API routes
+ * Exposes stuck-task detection health summary for the dashboard/monitor.
+ */
+
+import { Router, Request, Response } from 'express';
+import Database from 'better-sqlite3';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadConfig } from '../../../dist/config/loader.js';
+import {
+  detectStuckTasks,
+  type StuckTaskDetectionConfig,
+  type StuckTaskDetectionReport,
+} from '../../../dist/health/stuck-task-detector.js';
+import { getGlobalDbPath } from '../../../dist/runners/global-db.js';
+import { openSqliteForRead } from '../utils/sqlite.js';
+
+const router = Router();
+
+function openProjectDatabaseReadonly(projectPath: string): Database.Database | null {
+  const dbPath = join(projectPath, '.steroids', 'steroids.db');
+  if (!existsSync(dbPath)) return null;
+  try {
+    return openSqliteForRead(dbPath);
+  } catch {
+    return null;
+  }
+}
+
+function openGlobalDatabaseReadonlyOrMemory(): { db: Database.Database; close: () => void } {
+  const dbPath = getGlobalDbPath();
+  if (existsSync(dbPath)) {
+    const db = openSqliteForRead(dbPath);
+    return { db, close: () => db.close() };
+  }
+
+  // No global DB yet; use an in-memory DB with an empty runners table.
+  const db = new Database(':memory:');
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS runners (
+      id TEXT PRIMARY KEY,
+      status TEXT NOT NULL DEFAULT 'idle',
+      pid INTEGER,
+      project_path TEXT,
+      current_task_id TEXT,
+      started_at TEXT,
+      heartbeat_at TEXT NOT NULL DEFAULT (datetime('now')),
+      section_id TEXT
+    );
+  `);
+  return { db, close: () => db.close() };
+}
+
+function parseBoolean(value: unknown): boolean | undefined {
+  if (value === undefined) return undefined;
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  return undefined;
+}
+
+function isLikelySchemaError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  return /no such table|no such column|has no column|syntax error/i.test(error.message);
+}
+
+function fallbackStuckTaskReport(): StuckTaskDetectionReport {
+  return {
+    timestamp: new Date(),
+    orphanedTasks: [],
+    hangingInvocations: [],
+    zombieRunners: [],
+    deadRunners: [],
+    dbInconsistencies: [],
+  };
+}
+
+type HealthStatus = 'healthy' | 'degraded' | 'unhealthy';
+
+function computeStatus(args: {
+  orphanedTasks: number;
+  hangingInvocations: number;
+  zombieRunners: number;
+  deadRunners: number;
+  activeIncidents: number;
+}): HealthStatus {
+  if (args.deadRunners > 0 || args.zombieRunners > 0) return 'unhealthy';
+  if (args.hangingInvocations > 0 || args.orphanedTasks > 0 || args.activeIncidents > 0) return 'degraded';
+  return 'healthy';
+}
+
+/**
+ * GET /api/health
+ * Query params:
+ *   - project: string (required) - project path
+ *   - includeSignals: boolean (optional) - include raw signal arrays (default: false)
+ */
+router.get('/health', (req: Request, res: Response) => {
+  const projectPath = req.query.project as string | undefined;
+  if (!projectPath) {
+    res.status(400).json({
+      success: false,
+      error: 'Project path required (query param: project)',
+    });
+    return;
+  }
+
+  const includeSignals = parseBoolean(req.query.includeSignals) ?? false;
+
+  const projectDb = openProjectDatabaseReadonly(projectPath);
+  if (!projectDb) {
+    res.status(404).json({
+      success: false,
+      error: 'Project database not found at .steroids/steroids.db',
+      project: projectPath,
+    });
+    return;
+  }
+
+  const { db: globalDb, close: closeGlobal } = openGlobalDatabaseReadonlyOrMemory();
+
+  try {
+    const cfg = loadConfig(projectPath);
+    const detectionConfig: StuckTaskDetectionConfig = {
+      orphanedTaskTimeoutSec: cfg.health?.orphanedTaskTimeout,
+      maxCoderDurationSec: cfg.health?.maxCoderDuration,
+      maxReviewerDurationSec: cfg.health?.maxReviewerDuration,
+      runnerHeartbeatTimeoutSec: cfg.health?.runnerHeartbeatTimeout,
+      invocationStalenessSec: cfg.health?.invocationStaleness,
+    };
+
+    let report: StuckTaskDetectionReport;
+    try {
+      report = detectStuckTasks({
+        projectPath,
+        projectDb,
+        globalDb,
+        config: detectionConfig,
+      });
+    } catch (error) {
+      if (!isLikelySchemaError(error)) {
+        throw error;
+      }
+      if (process.env.NODE_ENV !== 'test') {
+        console.warn('Falling back to minimal health signals due to missing schema:', error);
+      }
+      report = fallbackStuckTaskReport();
+    }
+
+    // Incident counts (best-effort: table might not exist)
+    let activeIncidents = 0;
+    let recentIncidents = 0;
+    try {
+      const rowActive = projectDb
+        .prepare(`SELECT COUNT(*) as count FROM incidents WHERE resolved_at IS NULL`)
+        .get() as { count: number } | undefined;
+      const rowRecent = projectDb
+        .prepare(`SELECT COUNT(*) as count FROM incidents WHERE detected_at >= datetime('now', '-24 hours')`)
+        .get() as { count: number } | undefined;
+      activeIncidents = rowActive?.count ?? 0;
+      recentIncidents = rowRecent?.count ?? 0;
+    } catch {
+      // ignore
+    }
+
+    const orphanedTasks = report.orphanedTasks.length;
+    const hangingInvocations = report.hangingInvocations.length;
+    const zombieRunners = report.zombieRunners.length;
+    const deadRunners = report.deadRunners.length;
+
+    const health = {
+      status: computeStatus({
+        orphanedTasks,
+        hangingInvocations,
+        zombieRunners,
+        deadRunners,
+        activeIncidents,
+      }),
+      lastCheck: new Date().toISOString(),
+      checks: [
+        { type: 'orphaned_tasks', healthy: orphanedTasks === 0, found: orphanedTasks },
+        { type: 'hanging_invocations', healthy: hangingInvocations === 0, found: hangingInvocations },
+        { type: 'zombie_runners', healthy: zombieRunners === 0, found: zombieRunners },
+        { type: 'dead_runners', healthy: deadRunners === 0, found: deadRunners },
+      ],
+      activeIncidents,
+      recentIncidents,
+      ...(includeSignals
+        ? {
+            signals: {
+              orphanedTasks: report.orphanedTasks,
+              hangingInvocations: report.hangingInvocations,
+              zombieRunners: report.zombieRunners,
+              deadRunners: report.deadRunners,
+              dbInconsistencies: report.dbInconsistencies,
+            },
+          }
+        : {}),
+    };
+
+    res.json({
+      success: true,
+      project: projectPath,
+      health,
+    });
+  } catch (error) {
+    console.error('Error computing health status:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to compute health status',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  } finally {
+    projectDb.close();
+    closeGlobal();
+  }
+});
+
+export default router;

package/src/routes/incidents.ts

@@ -0,0 +1,131 @@
+/**
+ * Incidents API routes
+ * Exposes stuck-task incident history for dashboard/monitor.
+ */
+
+import { Router, Request, Response } from 'express';
+import Database from 'better-sqlite3';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { openSqliteForRead } from '../utils/sqlite.js';
+
+const router = Router();
+
+interface IncidentRow {
+  id: string;
+  task_id: string | null;
+  runner_id: string | null;
+  failure_mode: string;
+  detected_at: string;
+  resolved_at: string | null;
+  resolution: string | null;
+  details: string | null;
+  created_at: string;
+  task_title?: string | null;
+}
+
+function openProjectDatabaseReadonly(projectPath: string): Database.Database | null {
+  const dbPath = join(projectPath, '.steroids', 'steroids.db');
+  if (!existsSync(dbPath)) return null;
+  try {
+    return openSqliteForRead(dbPath);
+  } catch {
+    return null;
+  }
+}
+
+function parsePositiveInt(value: unknown, fallback: number): number {
+  if (value === undefined) return fallback;
+  const n = parseInt(String(value), 10);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return n;
+}
+
+function parseBoolean(value: unknown): boolean | undefined {
+  if (value === undefined) return undefined;
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  return undefined;
+}
+
+/**
+ * GET /api/incidents
+ * Query params:
+ *   - project: string (required) - project path
+ *   - limit: number (optional, default 50, max 200)
+ *   - task: string (optional) - filter by task ID prefix
+ *   - unresolved: boolean (optional) - true => resolved_at IS NULL, false => resolved_at IS NOT NULL
+ */
+router.get('/incidents', (req: Request, res: Response) => {
+  const projectPath = req.query.project as string | undefined;
+  if (!projectPath) {
+    res.status(400).json({
+      success: false,
+      error: 'Project path required (query param: project)',
+    });
+    return;
+  }
+
+  const limit = Math.min(parsePositiveInt(req.query.limit, 50), 200);
+  const taskPrefix = (req.query.task as string | undefined)?.trim();
+  const unresolved = parseBoolean(req.query.unresolved);
+
+  const db = openProjectDatabaseReadonly(projectPath);
+  if (!db) {
+    res.status(404).json({
+      success: false,
+      error: 'Project database not found at .steroids/steroids.db',
+      project: projectPath,
+    });
+    return;
+  }
+
+  try {
+    // Best-effort: incidents table may not exist (migrations disabled).
+    let incidents: IncidentRow[] = [];
+    try {
+      const where: string[] = [];
+      const params: Array<string | number> = [];
+
+      if (taskPrefix) {
+        where.push('i.task_id LIKE ?');
+        params.push(`${taskPrefix}%`);
+      }
+      if (unresolved === true) where.push('i.resolved_at IS NULL');
+      if (unresolved === false) where.push('i.resolved_at IS NOT NULL');
+
+      const whereSql = where.length ? `WHERE ${where.join(' AND ')}` : '';
+      const sql = `
+        SELECT
+          i.id, i.task_id, i.runner_id, i.failure_mode, i.detected_at, i.resolved_at, i.resolution, i.details, i.created_at,
+          t.title as task_title
+        FROM incidents i
+        LEFT JOIN tasks t ON t.id = i.task_id
+        ${whereSql}
+        ORDER BY i.detected_at DESC
+        LIMIT ?
+      `;
+      incidents = db.prepare(sql).all(...params, limit) as IncidentRow[];
+    } catch {
+      incidents = [];
+    }
+
+    res.json({
+      success: true,
+      project: projectPath,
+      total: incidents.length,
+      incidents,
+    });
+  } catch (error) {
+    console.error('Error listing incidents:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to list incidents',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  } finally {
+    db.close();
+  }
+});
+
+export default router;