@hamp10/agentforge 0.1.0 → 0.2.0

package/src/supervisor.js

@@ -0,0 +1,128 @@
+/**
+ * Supervisor: spawns the worker process and restarts it on crash.
+ *
+ * Usage modes (controlled by bin/agentforge.js):
+ *   agentforge start              — foreground supervisor (Ctrl+C stops everything)
+ *   agentforge start --detach     — background supervisor (shell returns immediately)
+ *   agentforge start --no-daemon  — raw worker, no supervision (internal use only)
+ *
+ * The supervisor re-execs this same binary with --no-daemon so the actual
+ * worker code path is unchanged — only the lifecycle wrapper is new.
+ */
+
+import { spawn } from 'child_process';
+import { mkdirSync, writeFileSync, readFileSync, unlinkSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+
+const BACKOFF_MS    = [1000, 2000, 5000, 15000, 30000];
+const CRASH_WINDOW  = 10_000; // process lived < 10s → count as crash
+const CONFIG_DIR    = path.join(homedir(), '.agentforge');
+const PID_FILE      = path.join(CONFIG_DIR, 'supervisor.pid');
+const WORKER_PID_FILE = path.join(CONFIG_DIR, 'worker.pid');
+
+function writePid(file, pid) {
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, String(pid));
+  } catch {}
+}
+
+function removePid(file) {
+  try { unlinkSync(file); } catch {}
+}
+
+/**
+ * Run the supervisor in the foreground. Blocks until a clean exit (code 0).
+ * @param {string[]} innerArgv  argv to pass to the worker process (must include --no-daemon)
+ */
+export async function runSupervisor(innerArgv) {
+  writePid(PID_FILE, process.pid);
+
+  process.on('SIGTERM', () => {
+    console.log('[supervisor] Received SIGTERM — shutting down');
+    removePid(PID_FILE);
+    process.exit(0);
+  });
+
+  let consecutiveCrashes = 0;
+
+  while (true) {
+    const startTime = Date.now();
+
+    const child = spawn(process.execPath, [process.argv[1], ...innerArgv], {
+      stdio: 'inherit',
+      detached: false,
+      env: { ...process.env, AGENTFORGE_SKIP_UPDATE: '1' },
+    });
+
+    writePid(WORKER_PID_FILE, child.pid);
+
+    const exitCode = await new Promise(resolve => {
+      child.on('exit', resolve);
+      child.on('error', () => resolve(1));
+    });
+
+    removePid(WORKER_PID_FILE);
+
+    // Clean exit (0) = user Ctrl+C or graceful shutdown — stop supervising
+    if (exitCode === 0) {
+      removePid(PID_FILE);
+      process.exit(0);
+    }
+
+    const elapsed = Date.now() - startTime;
+    if (elapsed < CRASH_WINDOW) {
+      consecutiveCrashes++;
+    } else {
+      consecutiveCrashes = 0; // ran long enough — reset crash counter
+    }
+
+    const backoff = BACKOFF_MS[Math.min(consecutiveCrashes - 1, BACKOFF_MS.length - 1)] ?? BACKOFF_MS[0];
+    console.log(`\n[supervisor] Worker exited (code ${exitCode ?? 'null'}), crash #${consecutiveCrashes} — restarting in ${backoff}ms...`);
+    await new Promise(r => setTimeout(r, backoff));
+    console.log('[supervisor] Restarting worker...\n');
+  }
+}
+
+/**
+ * Detach: spawn this binary as a background supervisor, then return control
+ * to the shell immediately. The background process runs runSupervisor().
+ * @param {string[]} supervisorArgv  argv for the background supervisor (without --detach)
+ */
+export function detachSupervisor(supervisorArgv) {
+  const logFile = path.join(CONFIG_DIR, 'worker.log');
+  mkdirSync(CONFIG_DIR, { recursive: true });
+
+  const child = spawn(process.execPath, [process.argv[1], ...supervisorArgv], {
+    detached: true,
+    stdio: ['ignore', 'ignore', 'ignore'],
+    env: { ...process.env, AGENTFORGE_SKIP_UPDATE: '1' },
+  });
+
+  child.unref();
+
+  writePid(PID_FILE, child.pid);
+  console.log(`✅ AgentForge worker started in background (PID ${child.pid})`);
+  console.log(`   Logs: ${logFile}`);
+  console.log(`   Stop: agentforge stop`);
+}
+
+/**
+ * Stop a running background supervisor by sending SIGTERM to the PID in the pid file.
+ */
+export function stopSupervisor() {
+  if (!existsSync(PID_FILE)) {
+    console.log('No running supervisor found.');
+    return;
+  }
+  try {
+    const pid = parseInt(readFileSync(PID_FILE, 'utf8'));
+    process.kill(pid, 'SIGTERM');
+    removePid(PID_FILE);
+    console.log(`Stopped supervisor (PID ${pid})`);
+  } catch (e) {
+    console.log('Supervisor not running or already stopped.');
+    removePid(PID_FILE);
+  }
+}