steroids-api 0.2.7

package/src/routes/runners.ts

@@ -0,0 +1,357 @@
+/**
+ * Runners API routes
+ * Get runner status and current tasks
+ */
+
+import { Router, Request, Response } from 'express';
+import { openGlobalDatabase } from '../../../dist/runners/global-db.js';
+import { getDaemonActiveStatus, setDaemonActiveStatus } from '../../../dist/runners/global-db.js';
+import { cronStatus, cronInstall, cronUninstall } from '../../../dist/runners/cron.js';
+import { getLastWakeupTime, wakeup } from '../../../dist/runners/wakeup.js';
+import { listRunners, unregisterRunner } from '../../../dist/runners/daemon.js';
+
+const router = Router();
+
+interface RunnerInfo {
+  id: string;
+  status: string;
+  pid: number | null;
+  project_path: string | null;
+  project_name: string | null;
+  parallel_session_id: string | null;
+  current_task_id: string | null;
+  current_task_title: string | null;
+  started_at: string | null;
+  heartbeat_at: string;
+  section_id: string | null;
+}
+
+function stopAllRunnersNow(): number {
+  const runners = listRunners();
+  let stopped = 0;
+
+  for (const runner of runners) {
+    if (runner.pid) {
+      try {
+        process.kill(runner.pid, 'SIGTERM');
+        stopped += 1;
+      } catch {
+        // Runner already dead; still remove stale DB row.
+      }
+    }
+    unregisterRunner(runner.id);
+  }
+
+  return stopped;
+}
+
+/**
+ * GET /api/runners
+ * List all runners with their current tasks
+ */
+router.get('/runners', (_req: Request, res: Response) => {
+  try {
+    const { db, close } = openGlobalDatabase();
+    try {
+      const runners = db
+        .prepare(
+          `SELECT
+            r.id,
+            r.status,
+            r.pid,
+            r.project_path as raw_project_path,
+            COALESCE(ps.project_path, r.project_path) as project_path,
+            r.parallel_session_id,
+            r.current_task_id,
+            r.started_at,
+            r.heartbeat_at,
+            r.section_id,
+            COALESCE(p2.name, p.name) as project_name
+          FROM runners r
+          LEFT JOIN projects p ON r.project_path = p.path
+          LEFT JOIN parallel_sessions ps ON r.parallel_session_id = ps.id
+          LEFT JOIN projects p2 ON ps.project_path = p2.path
+          ORDER BY r.heartbeat_at DESC`
+        )
+        .all() as Array<{
+        id: string;
+        status: string;
+        pid: number | null;
+        raw_project_path: string | null;
+        project_path: string | null;
+        parallel_session_id: string | null;
+        current_task_id: string | null;
+        started_at: string | null;
+        heartbeat_at: string;
+        section_id: string | null;
+        project_name: string | null;
+      }>;
+
+      const runnersWithTasks: RunnerInfo[] = runners.map((runner) => ({
+        id: runner.id,
+        status: runner.status,
+        pid: runner.pid,
+        project_path: runner.project_path,
+        project_name: runner.project_name,
+        parallel_session_id: runner.parallel_session_id,
+        current_task_id: runner.current_task_id,
+        current_task_title: null,
+        started_at: runner.started_at,
+        heartbeat_at: runner.heartbeat_at,
+        section_id: runner.section_id,
+      }));
+
+      const activeCount = runners.filter(
+        (r) => r.status === 'running' || r.status === 'active'
+      ).length;
+
+      res.json({
+        success: true,
+        runners: runnersWithTasks,
+        count: runners.length,
+        active_count: activeCount,
+      });
+    } finally {
+      close();
+    }
+  } catch (error) {
+    console.error('Error listing runners:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to list runners',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+/**
+ * GET /api/runners/active-tasks
+ * List all tasks currently being worked on by runners
+ */
+router.get('/runners/active-tasks', (_req: Request, res: Response) => {
+  try {
+    const { db, close } = openGlobalDatabase();
+    try {
+      const activeTasks = db
+        .prepare(
+          `SELECT
+            r.id as runner_id,
+            r.status,
+            COALESCE(ps.project_path, r.project_path) as project_path,
+            r.current_task_id,
+            r.started_at,
+            COALESCE(p2.name, p.name) as project_name
+          FROM runners r
+          LEFT JOIN projects p ON r.project_path = p.path
+          LEFT JOIN parallel_sessions ps ON r.parallel_session_id = ps.id
+          LEFT JOIN projects p2 ON ps.project_path = p2.path
+          WHERE r.current_task_id IS NOT NULL
+          ORDER BY r.started_at DESC`
+        )
+        .all() as Array<{
+        runner_id: string;
+        status: string;
+        project_path: string;
+        current_task_id: string;
+        started_at: string | null;
+        project_name: string | null;
+      }>;
+
+      res.json({
+        success: true,
+        tasks: activeTasks,
+        count: activeTasks.length,
+      });
+    } finally {
+      close();
+    }
+  } catch (error) {
+    console.error('Error listing active tasks:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to list active tasks',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+/**
+ * GET /api/runners/cron
+ * Get cron status and last wakeup time
+ */
+router.get('/runners/cron', (_req: Request, res: Response) => {
+  try {
+    const status = cronStatus();
+    const isActive = getDaemonActiveStatus();
+    const lastWakeup = getLastWakeupTime();
+
+    res.json({
+      success: true,
+      cron: {
+        installed: status.installed && isActive,
+        entry: status.entry,
+        error: status.error,
+      },
+      last_wakeup_at: lastWakeup,
+    });
+  } catch (error) {
+    console.error('Error getting cron status:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to get cron status',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+/**
+ * POST /api/runners/cron/start
+ * Install cron job
+ */
+router.post('/runners/cron/start', async (_req: Request, res: Response) => {
+  try {
+    const status = cronStatus();
+    if (!status.installed) {
+      const installResult = cronInstall();
+      if (!installResult.success) {
+        res.status(400).json({
+          success: false,
+          error: installResult.message,
+          message: installResult.error,
+        });
+        return;
+      }
+    }
+    
+    setDaemonActiveStatus(true);
+
+    // Make "Start Steroids" feel immediate: run one wakeup cycle now.
+    const wakeupResults = await wakeup({ quiet: true });
+    const activated = wakeupResults.filter(
+      (item) => item.action === 'started' || item.action === 'restarted'
+    ).length;
+
+    res.json({
+      success: true,
+      message: `Daemon resumed. Immediate wakeup started/restarted ${activated} runner(s).`,
+      wakeup: wakeupResults,
+    });
+  } catch (error) {
+    console.error('Error installing cron:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to install cron',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+/**
+ * POST /api/runners/cron/stop
+ * Uninstall cron job
+ */
+router.post('/runners/cron/stop', (_req: Request, res: Response) => {
+  try {
+    setDaemonActiveStatus(false);
+    const stopped = stopAllRunnersNow();
+    res.json({
+      success: true,
+      message: `Daemon paused. Stopped ${stopped} active runner(s).`,
+      stopped,
+    });
+  } catch (error) {
+    console.error('Error uninstalling cron:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to uninstall cron',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+/**
+ * POST /api/runners/:runnerId/kill
+ * Kill a specific runner by ID
+ */
+router.post('/runners/:runnerId/kill', (req: Request, res: Response) => {
+  try {
+    const { runnerId } = req.params;
+    const runners = listRunners();
+    const runner = runners.find((r) => r.id === runnerId || r.id.startsWith(runnerId));
+
+    if (!runner) {
+      return res.status(404).json({
+        success: false,
+        error: 'Runner not found',
+      });
+    }
+
+    if (!runner.pid) {
+      return res.status(400).json({
+        success: false,
+        error: 'Runner has no PID (not running)',
+      });
+    }
+
+    try {
+      process.kill(runner.pid, 'SIGTERM');
+      res.json({
+        success: true,
+        message: `Runner ${runner.id.slice(0, 8)} killed`,
+        runner_id: runner.id,
+        pid: runner.pid,
+      });
+    } catch (killError) {
+      res.status(500).json({
+        success: false,
+        error: 'Failed to kill runner process',
+        message: killError instanceof Error ? killError.message : 'Unknown error',
+      });
+    }
+  } catch (error) {
+    console.error('Error killing runner:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to kill runner',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+/**
+ * POST /api/runners/wakeup/now
+ * Force immediate execution of the wakeup cycle
+ */
+router.post('/runners/wakeup/now', async (_req: Request, res: Response) => {
+  try {
+    const wakeupResults = await wakeup({ quiet: true });
+    
+    if (wakeupResults.length > 0 && wakeupResults[0].action === 'skipped' && wakeupResults[0].reason === 'Wakeup cycle already running') {
+      res.status(429).json({
+        success: false,
+        error: 'Too Many Requests',
+        message: 'A wakeup cycle is already running.',
+      });
+      return;
+    }
+    
+    const activated = wakeupResults.filter(
+      (item) => item.action === 'started' || item.action === 'restarted'
+    ).length;
+
+    res.json({
+      success: true,
+      message: `Immediate wakeup completed. Started/restarted ${activated} runner(s).`,
+      wakeup: wakeupResults,
+    });
+  } catch (error) {
+    console.error('Error forcing wakeup:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to force wakeup',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+export default router;

package/src/routes/skills.ts

@@ -0,0 +1,127 @@
+import { Router } from 'express';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const router = Router();
+interface SkillListing {
+  name: string;
+  type: 'pre-installed' | 'custom';
+  characterCount: number;
+}
+
+function readSkillLength(filePath: string): number {
+  if (!existsSync(filePath)) {
+    return 0;
+  }
+
+  const content = readFileSync(filePath, 'utf-8');
+  return content.length;
+}
+
+function getCustomSkillsDir(): string {
+  const dir = join(homedir(), '.steroids', 'skills');
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+function getPreinstalledSkillsDir(): string {
+  // Relative to API running from either root or dist
+  let currentDir = process.cwd();
+  let rootDir = currentDir;
+  while (currentDir !== '/') {
+    if (existsSync(join(currentDir, 'WebUI', 'src', 'assets', 'skills'))) {
+      rootDir = currentDir;
+      break;
+    }
+    currentDir = join(currentDir, '..');
+  }
+  return join(rootDir, 'WebUI', 'src', 'assets', 'skills');
+}
+
+router.get('/skills', (req, res) => {
+  const skills: SkillListing[] = [];
+
+  try {
+    const customDir = getCustomSkillsDir();
+    if (existsSync(customDir)) {
+      for (const file of readdirSync(customDir)) {
+        if (file.endsWith('.md')) {
+          const name = file.replace('.md', '');
+          skills.push({ name, type: 'custom', characterCount: readSkillLength(join(customDir, file)) });
+        }
+      }
+    }
+
+    const preinstalledDir = getPreinstalledSkillsDir();
+    if (existsSync(preinstalledDir)) {
+      for (const file of readdirSync(preinstalledDir)) {
+        if (file.endsWith('.md')) {
+          const name = file.replace('.md', '');
+          if (!skills.find(s => s.name === name)) {
+            skills.push({ name, type: 'pre-installed', characterCount: readSkillLength(join(preinstalledDir, file)) });
+          }
+        }
+      }
+    }
+    res.json({ success: true, data: skills });
+  } catch (err: any) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+router.get('/skills/:name', (req, res) => {
+  const name = req.params.name;
+  
+  try {
+    const customFile = join(getCustomSkillsDir(), `${name}.md`);
+    if (existsSync(customFile)) {
+      return res.json({ success: true, data: { name, content: readFileSync(customFile, 'utf-8'), type: 'custom' } });
+    }
+
+    const preinstalledFile = join(getPreinstalledSkillsDir(), `${name}.md`);
+    if (existsSync(preinstalledFile)) {
+      return res.json({ success: true, data: { name, content: readFileSync(preinstalledFile, 'utf-8'), type: 'pre-installed' } });
+    }
+
+    res.status(404).json({ success: false, error: 'Skill not found' });
+  } catch (err: any) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+router.delete('/skills/:name', (req, res) => {
+  const name = req.params.name;
+
+  try {
+    const filePath = join(getCustomSkillsDir(), `${name.replace('.md', '')}.md`);
+    if (!existsSync(filePath)) {
+      return res.status(404).json({ success: false, error: 'Custom skill not found' });
+    }
+    rmSync(filePath);
+    res.json({ success: true, message: 'Skill deleted successfully' });
+  } catch (err: any) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+router.post('/skills/:name', (req, res) => {
+  const name = req.params.name;
+  const { content } = req.body;
+  
+  if (!content) {
+    return res.status(400).json({ success: false, error: 'Content is required' });
+  }
+
+  try {
+    const filePath = join(getCustomSkillsDir(), `${name.replace('.md', '')}.md`);
+    writeFileSync(filePath, content, 'utf-8');
+    res.json({ success: true, message: 'Skill created/updated successfully' });
+  } catch (err: any) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+export default router;

package/src/routes/storage.ts

@@ -0,0 +1,108 @@
+/**
+ * Storage API routes
+ * Project storage breakdown and cleanup
+ */
+
+import { Router, Request, Response } from 'express';
+import {
+  validateProjectPath,
+  getCachedStorageBreakdown,
+  bustStorageCache,
+} from '../utils/storage-cache.js';
+import { cleanupInvocationLogs } from '../../../dist/cleanup/invocation-logs.js';
+import { cleanupTextLogs } from '../../../dist/cleanup/text-logs.js';
+import { cleanupBackups } from '../../../dist/cleanup/backups.js';
+import { formatBytes } from '../../../dist/cleanup/directory-size.js';
+
+const router = Router();
+
+/**
+ * GET /api/projects/storage
+ * Get storage breakdown for a project's .steroids/ directory
+ * Query: path (required) — absolute path to the project
+ */
+router.get('/projects/storage', async (req: Request, res: Response) => {
+  try {
+    const result = await validateProjectPath(req.query.path as string);
+    if (!result.valid) {
+      res.status(result.status).json({ success: false, error: result.error });
+      return;
+    }
+
+    const retention = parseRetentionDays(req.query.retention_days);
+    if (!retention.valid) {
+      res.status(400).json({ success: false, error: retention.error });
+      return;
+    }
+
+    const breakdown = await getCachedStorageBreakdown(
+      result.realPath, 
+      retention.days,
+      Math.max(retention.days, 30) // Match cleanupBackups floor
+    );
+    res.json(breakdown);
+  } catch (error) {
+    console.error('Error getting project storage:', error);
+    res.status(500).json({
+      success: false,
+      error: 'Failed to get storage breakdown',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+function parseRetentionDays(raw: unknown): { valid: true; days: number } | { valid: false; error: string } {
+  if (raw === undefined) return { valid: true, days: 7 };
+  if (typeof raw !== 'number' || !Number.isInteger(raw) || raw < 1 || raw > 365) {
+    return { valid: false, error: 'retention_days must be a positive integer (1-365)' };
+  }
+  return { valid: true, days: raw };
+}
+
+function runCleanup(projectPath: string, retentionDays: number) {
+  const invResult = cleanupInvocationLogs(projectPath, { retentionDays });
+  const textResult = cleanupTextLogs(projectPath, { retentionDays });
+  // Respect user retention but keep backups for at least 30 days by default
+  const backupResult = cleanupBackups(projectPath, { retentionDays: Math.max(retentionDays, 30) });
+  bustStorageCache(projectPath);
+  return {
+    ok: true as const,
+    deleted_files: invResult.deletedFiles + textResult.deletedFiles + backupResult.deletedFiles,
+    freed_bytes: invResult.freedBytes + textResult.freedBytes + backupResult.freedBytes,
+    freed_human: formatBytes(invResult.freedBytes + textResult.freedBytes + backupResult.freedBytes),
+  };
+}
+
+/**
+ * POST /api/projects/clear-logs
+ * Delete old invocation and text logs for a project
+ * Body: { path: string, retention_days?: number }
+ */
+router.post('/projects/clear-logs', async (req: Request, res: Response) => {
+  try {
+    const { path: rawPath, retention_days } = req.body;
+
+    const retention = parseRetentionDays(retention_days);
+    if (!retention.valid) {
+      res.status(400).json({ ok: false, error: retention.error });
+      return;
+    }
+
+    const validation = await validateProjectPath(rawPath);
+    if (!validation.valid) {
+      res.status(validation.status).json({ ok: false, error: validation.error });
+      return;
+    }
+
+    res.json(runCleanup(validation.realPath, retention.days));
+  } catch (error) {
+    console.error('Error clearing project logs:', error);
+    res.status(500).json({
+      ok: false,
+      error: 'Failed to clear logs',
+      message: error instanceof Error ? error.message : 'Unknown error',
+    });
+  }
+});
+
+export default router;