tide-commander 0.52.0

package/dist/src/packages/server/claude/runner.js

@@ -0,0 +1,310 @@
+/**
+ * Claude Code Process Runner
+ * Spawns and manages Claude Code CLI processes with streaming output
+ */
+import { ClaudeBackend } from './backend.js';
+import { createLogger } from '../utils/logger.js';
+import { isProcessRunning } from '../data/index.js';
+import { RunnerInternalEventBus } from './runner/internal-events.js';
+import { RunnerStdoutPipeline } from './runner/stdout-pipeline.js';
+import { RunnerProcessLifecycle } from './runner/process-lifecycle.js';
+import { RunnerRestartPolicy } from './runner/restart-policy.js';
+import { RunnerWatchdog } from './runner/watchdog.js';
+import { RunnerRecoveryStore } from './runner/recovery-store.js';
+import { RunnerResourceMonitor } from './runner/resource-monitor.js';
+const log = createLogger('Runner');
+const PERSIST_INTERVAL = 10000;
+const WATCHDOG_INTERVAL = 5000;
+export class ClaudeRunner {
+    backend;
+    callbacks;
+    activeProcesses = new Map();
+    lastStderr = new Map();
+    activityCallbacks = new Map();
+    autoRestartEnabled = true;
+    persistTimer = null;
+    watchdogTimer = null;
+    bus;
+    stdoutPipeline;
+    lifecycle;
+    restartPolicy;
+    watchdog;
+    recoveryStore;
+    resourceMonitor;
+    constructor(callbacks, backend) {
+        this.backend = backend ?? new ClaudeBackend();
+        this.callbacks = callbacks;
+        this.bus = new RunnerInternalEventBus();
+        this.stdoutPipeline = new RunnerStdoutPipeline({
+            backend: this.backend,
+            callbacks: this.callbacks,
+            bus: this.bus,
+        });
+        this.recoveryStore = new RunnerRecoveryStore({
+            backend: this.backend,
+            activeProcesses: this.activeProcesses,
+            run: (request) => this.run(request),
+        });
+        this.lifecycle = new RunnerProcessLifecycle({
+            backend: this.backend,
+            callbacks: this.callbacks,
+            activeProcesses: this.activeProcesses,
+            lastStderr: this.lastStderr,
+            activityCallbacks: this.activityCallbacks,
+            bus: this.bus,
+            stdoutPipeline: this.stdoutPipeline,
+            recoveryStore: this.recoveryStore,
+            onDisableAutoRestart: () => {
+                this.autoRestartEnabled = false;
+            },
+        });
+        this.restartPolicy = new RunnerRestartPolicy({
+            callbacks: this.callbacks,
+            activeProcesses: this.activeProcesses,
+            getAutoRestartEnabled: () => this.autoRestartEnabled,
+            run: (request) => this.run(request),
+        });
+        this.watchdog = new RunnerWatchdog({
+            activeProcesses: this.activeProcesses,
+            lastStderr: this.lastStderr,
+            bus: this.bus,
+        });
+        this.resourceMonitor = new RunnerResourceMonitor({
+            activeProcesses: this.activeProcesses,
+        });
+        this.wireInternalEvents();
+        this.persistTimer = setInterval(() => {
+            this.recoveryStore.persistRunningProcesses();
+        }, PERSIST_INTERVAL);
+        this.watchdogTimer = setInterval(() => {
+            this.watchdog.runWatchdog();
+        }, WATCHDOG_INTERVAL);
+        this.recoveryStore.recoverOrphanedProcesses();
+        log.log('🛡️ Runner initialized with auto-restart and watchdog enabled');
+    }
+    wireInternalEvents() {
+        this.bus.on('runner.activity', ({ agentId, timestamp }) => {
+            const activeProcess = this.activeProcesses.get(agentId);
+            if (activeProcess) {
+                activeProcess.lastActivityTime = timestamp;
+            }
+            const callbacks = this.activityCallbacks.get(agentId);
+            if (!callbacks || callbacks.length === 0) {
+                return;
+            }
+            for (const callback of callbacks) {
+                try {
+                    callback();
+                }
+                catch (err) {
+                    log.error(`Activity callback error for ${agentId}:`, err);
+                }
+            }
+            this.activityCallbacks.delete(agentId);
+        });
+        this.bus.on('runner.session_id', ({ agentId, sessionId }) => {
+            const activeProcess = this.activeProcesses.get(agentId);
+            if (!activeProcess) {
+                return;
+            }
+            activeProcess.sessionId = sessionId;
+            if (activeProcess.lastRequest && !activeProcess.lastRequest.sessionId) {
+                activeProcess.lastRequest.sessionId = sessionId;
+            }
+        });
+        this.bus.on('runner.process_spawned', ({ agentId, pid }) => {
+            log.log(`🚀 [SPAWN] Agent ${agentId}: Process started with pid ${pid}`);
+        });
+        this.bus.on('runner.process_spawn_error', ({ agentId, error }) => {
+            log.error(`❌ [SPAWN ERROR] Agent ${agentId}: Failed to spawn process: ${error.message}`);
+            this.activeProcesses.delete(agentId);
+            this.callbacks.onError(agentId, error.message);
+        });
+        this.bus.on('runner.watchdog_missing_process', ({ agentId, activeProcess }) => {
+            this.restartPolicy.maybeAutoRestart(agentId, activeProcess, null, null);
+        });
+        this.bus.on('runner.process_closed', ({ agentId, pid, code, signal }) => {
+            const wasTracked = this.activeProcesses.has(agentId);
+            const trackedProcess = this.activeProcesses.get(agentId);
+            const runtime = trackedProcess ? Date.now() - trackedProcess.startTime : 0;
+            const deathInfo = {
+                agentId,
+                pid,
+                exitCode: code,
+                signal,
+                runtime,
+                wasTracked,
+                timestamp: Date.now(),
+                stderr: this.lastStderr.get(agentId),
+            };
+            this.activeProcesses.delete(agentId);
+            this.lastStderr.delete(agentId);
+            if (signal) {
+                if (signal === 'SIGINT') {
+                    log.log(`🛑 [EXIT] Agent ${agentId}: Process terminated by SIGINT (user interrupt), pid was ${pid}, runtime ${(runtime / 1000).toFixed(1)}s`);
+                }
+                else if (signal === 'SIGTERM') {
+                    log.log(`🛑 [EXIT] Agent ${agentId}: Process terminated by SIGTERM (stop request), pid was ${pid}, runtime ${(runtime / 1000).toFixed(1)}s`);
+                }
+                else if (signal === 'SIGKILL') {
+                    log.log(`🛑 [EXIT] Agent ${agentId}: Process force-killed by SIGKILL, pid was ${pid}, runtime ${(runtime / 1000).toFixed(1)}s`);
+                    this.watchdog.recordDeath(deathInfo);
+                }
+                else {
+                    log.log(`⚠️ [EXIT] Agent ${agentId}: Process killed by signal ${signal}, pid was ${pid}, runtime ${(runtime / 1000).toFixed(1)}s`);
+                    this.watchdog.recordDeath(deathInfo);
+                }
+            }
+            else if (code === 0) {
+                log.log(`✅ [EXIT] Agent ${agentId}: Process completed successfully (exit code 0), pid was ${pid}, runtime ${(runtime / 1000).toFixed(1)}s`);
+            }
+            else {
+                log.error(`❌ [EXIT] Agent ${agentId}: Process exited with error code ${code}, pid was ${pid}, runtime ${(runtime / 1000).toFixed(1)}s${!wasTracked ? ' (unexpected - was not being tracked)' : ''}`);
+                this.watchdog.recordDeath(deathInfo);
+            }
+            if (!wasTracked && (signal === 'SIGINT' || signal === 'SIGTERM')) {
+                log.log(`⏭️ [EXIT] Agent ${agentId}: Skipping onComplete - process was explicitly stopped (signal=${signal})`);
+            }
+            else {
+                this.callbacks.onComplete(agentId, code === 0);
+            }
+            if (trackedProcess && code !== 0 && signal !== 'SIGINT' && signal !== 'SIGTERM') {
+                this.restartPolicy.maybeAutoRestart(agentId, trackedProcess, code, signal);
+            }
+        });
+    }
+    supportsStdin() {
+        return this.backend.requiresStdinInput();
+    }
+    setAutoRestart(enabled) {
+        this.autoRestartEnabled = enabled;
+        log.log(`🔄 Auto-restart ${enabled ? 'enabled' : 'disabled'}`);
+    }
+    getDeathHistory() {
+        return this.watchdog.getDeathHistory();
+    }
+    getActiveProcessesState() {
+        const now = Date.now();
+        return Array.from(this.activeProcesses.entries()).map(([agentId, proc]) => ({
+            agentId,
+            pid: proc.process.pid,
+            runtimeSec: (now - proc.startTime) / 1000,
+            lastActivitySec: proc.lastActivityTime ? (now - proc.lastActivityTime) / 1000 : -1,
+            hasError: !!proc.lastError,
+            stdinWritable: !!(proc.process.stdin && proc.process.stdin.writable),
+        }));
+    }
+    logProcessDiagnostics() {
+        const state = this.getActiveProcessesState();
+        const count = state.length;
+        if (count === 0) {
+            log.log('📊 [DIAGNOSTICS] No active processes');
+            return;
+        }
+        log.log(`📊 [DIAGNOSTICS] ${count} active process(es):`);
+        for (const proc of state) {
+            const errorStr = proc.hasError ? ' ❌ERROR' : '';
+            const stdinStr = proc.stdinWritable ? ' ✅stdin' : ' ❌stdin';
+            log.log(`   ${proc.agentId.slice(0, 8)}: PID=${proc.pid} runtime=${proc.runtimeSec.toFixed(1)}s activity=${proc.lastActivitySec >= 0 ? `${proc.lastActivitySec.toFixed(1)}s` : 'none'}${stdinStr}${errorStr}`);
+        }
+    }
+    async run(request) {
+        await this.lifecycle.run(request);
+    }
+    sendMessage(agentId, message) {
+        const activeProcess = this.activeProcesses.get(agentId);
+        if (!activeProcess) {
+            log.error(`❌ [SEND_MESSAGE] No active process for agent ${agentId}`);
+            return false;
+        }
+        const stdin = activeProcess.process.stdin;
+        if (!stdin) {
+            log.error(`❌ [SEND_MESSAGE] stdin is null for agent ${agentId}`);
+            return false;
+        }
+        if (!stdin.writable) {
+            log.error(`❌ [SEND_MESSAGE] stdin is not writable for agent ${agentId} (destroyed: ${stdin.destroyed}, closed: ${stdin.closed})`);
+            return false;
+        }
+        const stdinInput = this.backend.formatStdinInput(message);
+        const messageLen = message.length;
+        stdin.write(stdinInput + '\n', 'utf8', (err) => {
+            if (err) {
+                log.error(`❌ [SEND_MESSAGE] Failed to write ${messageLen} chars to stdin for ${agentId}: ${err.message}`);
+                activeProcess.lastError = {
+                    type: 'stdin_write_error',
+                    message: err.message,
+                    timestamp: Date.now(),
+                };
+            }
+            else {
+                log.log(`✅ [SEND_MESSAGE] Successfully wrote ${messageLen} chars to ${agentId}`);
+            }
+        });
+        return true;
+    }
+    interrupt(agentId) {
+        return this.lifecycle.interrupt(agentId);
+    }
+    getActiveProcessCount() {
+        return this.activeProcesses.size;
+    }
+    async stop(agentId) {
+        await this.lifecycle.stop(agentId);
+    }
+    async stopAll(killProcesses = true) {
+        if (this.persistTimer) {
+            clearInterval(this.persistTimer);
+            this.persistTimer = null;
+        }
+        if (this.watchdogTimer) {
+            clearInterval(this.watchdogTimer);
+            this.watchdogTimer = null;
+        }
+        await this.lifecycle.stopAll(killProcesses);
+    }
+    isRunning(agentId) {
+        const activeProcess = this.activeProcesses.get(agentId);
+        if (!activeProcess) {
+            return false;
+        }
+        const pid = activeProcess.process.pid;
+        if (!pid) {
+            this.activeProcesses.delete(agentId);
+            return false;
+        }
+        const actuallyRunning = isProcessRunning(pid);
+        if (!actuallyRunning) {
+            this.activeProcesses.delete(agentId);
+            this.lastStderr.delete(agentId);
+            return false;
+        }
+        return true;
+    }
+    getSessionId(agentId) {
+        return this.activeProcesses.get(agentId)?.sessionId;
+    }
+    hasRecentActivity(agentId, withinMs) {
+        const activeProcess = this.activeProcesses.get(agentId);
+        if (!activeProcess) {
+            return false;
+        }
+        const lastActivity = activeProcess.lastActivityTime || activeProcess.startTime;
+        return Date.now() - lastActivity < withinMs;
+    }
+    onNextActivity(agentId, callback) {
+        if (!this.activityCallbacks.has(agentId)) {
+            this.activityCallbacks.set(agentId, []);
+        }
+        this.activityCallbacks.get(agentId).push(callback);
+    }
+    clearActivityCallbacks(agentId) {
+        this.activityCallbacks.delete(agentId);
+    }
+    getProcessMemoryMB(agentId) {
+        return this.resourceMonitor.getProcessMemoryMB(agentId);
+    }
+    getAllProcessMemory() {
+        return this.resourceMonitor.getAllProcessMemory();
+    }
+}