@nervekit/orchestrator 0.1.0

package/dist/domains/processes/process-manager.js

@@ -0,0 +1,814 @@
+import { mkdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { createId, } from "@nerve/shared";
+import { createProcessLogCursor, defaultProcessSupervisor, isActiveProcessStatus, ProcessLogService, ProcessReadinessService, ProcessRepository, } from "./index.js";
+import { UnconfiguredProcessLaunchConfigStore, } from "./process-launch-config.store.js";
+export class ProcessManager {
+    events;
+    index;
+    logger;
+    processes = new Map();
+    managed = new Map();
+    processRepository;
+    processLogs;
+    processReadiness = new ProcessReadinessService();
+    supervisor;
+    launchConfigs;
+    constructor(storage, events, index, logger, options = {}) {
+        this.events = events;
+        this.index = index;
+        this.logger = logger;
+        this.supervisor = options.supervisor ?? defaultProcessSupervisor;
+        this.launchConfigs =
+            options.launchConfigs ?? new UnconfiguredProcessLaunchConfigStore();
+        this.processRepository = new ProcessRepository(storage);
+        this.processLogs = new ProcessLogService(events);
+    }
+    async hydrate() {
+        for (const persisted of await this.processRepository.hydrate()) {
+            const wasActive = isActiveProcessStatus(persisted.status);
+            const record = wasActive
+                ? this.markHydratedRecordOrphaned(persisted)
+                : persisted;
+            await this.upsertProcess(record);
+            if (wasActive) {
+                await this.events.publish("process.orphaned", { process: record });
+                await this.logger?.warn("Process supervision lost after daemon restart", {
+                    processId: record.id,
+                    projectId: record.projectId,
+                    conversationId: record.conversationId,
+                    agentId: record.agentId,
+                    context: {
+                        pid: record.runtime?.childPid,
+                        processGroupId: record.runtime?.processGroupId,
+                        platform: record.runtime?.platform,
+                    },
+                });
+            }
+        }
+    }
+    listProcesses() {
+        return [...this.processes.values()].sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    }
+    getProcess(processId) {
+        const process = this.processes.get(processId);
+        if (!process)
+            throw new Error("Process not found.");
+        return process;
+    }
+    findProcessByName(name) {
+        return this.listProcesses().find((process) => process.name === name);
+    }
+    async startProcess(request) {
+        const now = new Date().toISOString();
+        const id = createId("proc");
+        const dir = this.processDir(id);
+        await mkdir(dir, { recursive: true, mode: 0o755 });
+        const envInfo = buildProcessEnvInfo(request.env);
+        if (envInfo) {
+            await this.launchConfigs.write(id, {
+                version: 1,
+                env: request.env,
+                createdAt: now,
+                updatedAt: now,
+            });
+        }
+        const readiness = this.processReadiness.buildReadiness(request);
+        const record = {
+            id,
+            name: request.name,
+            workerId: request.workerId,
+            projectId: request.projectId,
+            conversationId: request.conversationId,
+            agentId: request.agentId,
+            cwd: resolve(request.cwd),
+            command: request.command,
+            envInfo,
+            status: "starting",
+            readiness,
+            stdoutPath: join(dir, "stdout.log"),
+            stderrPath: join(dir, "stderr.log"),
+            logsPath: join(dir, "logs.jsonl"),
+            startedAt: now,
+            updatedAt: now,
+            restartedFromProcessId: request.restartedFromProcessId,
+        };
+        const readinessPattern = this.processReadiness.compilePattern(request.readyPattern);
+        await this.upsertProcess(record);
+        await this.events.publish("process.created", { process: record });
+        await this.logger?.info("Process created", {
+            processId: record.id,
+            projectId: record.projectId,
+            conversationId: record.conversationId,
+            agentId: record.agentId,
+            context: {
+                name: record.name,
+                cwd: record.cwd,
+                command: record.command,
+                envKeyCount: record.envInfo?.keys.length ?? 0,
+            },
+        });
+        const spawned = this.supervisor.spawn(request.command, {
+            cwd: record.cwd,
+            env: request.env,
+        });
+        const { child, runtime } = spawned;
+        await this.updateProcess(record.id, { runtime });
+        const closePromise = new Promise((resolveClose) => {
+            child.once("close", (exitCode, signal) => {
+                resolveClose({ exitCode, signal });
+            });
+        });
+        const managed = {
+            child,
+            ...createProcessLogCursor(await this.processLogs.latestLogSeq(record.logsPath)),
+            stopping: false,
+            finalized: false,
+            closePromise,
+            readinessPattern,
+        };
+        managed.finalizationPromise = closePromise
+            .then(({ exitCode, signal }) => this.markProcessExited(record.id, exitCode, signal))
+            .catch(async (error) => {
+            if (this.logger) {
+                await this.logger
+                    .error("Process finalization failed", {
+                    processId: record.id,
+                    projectId: record.projectId,
+                    conversationId: record.conversationId,
+                    agentId: record.agentId,
+                    error,
+                })
+                    .catch(() => undefined);
+            }
+            return undefined;
+        });
+        this.managed.set(record.id, managed);
+        child.stdout?.on("data", (chunk) => {
+            void this.captureOutput(record.id, "stdout", chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            void this.captureOutput(record.id, "stderr", chunk);
+        });
+        child.on("error", (error) => {
+            void this.markProcessError(record.id, error.message);
+        });
+        await this.updateProcess(record.id, { status: "running" });
+        await this.events.publish("process.started", {
+            process: this.getProcess(record.id),
+            pid: runtime.childPid,
+            runtime,
+        });
+        await this.logger?.info("Process started", {
+            processId: record.id,
+            projectId: record.projectId,
+            conversationId: record.conversationId,
+            agentId: record.agentId,
+            context: {
+                pid: runtime.childPid,
+                processGroupId: runtime.processGroupId,
+                platform: runtime.platform,
+            },
+        });
+        await this.waitForReadiness(record.id);
+        return this.getProcess(record.id);
+    }
+    async stopProcess(processId, request = {}) {
+        const record = this.getProcess(processId);
+        if (record.status === "orphaned") {
+            return this.cleanupOrphanedProcess(record.id, request);
+        }
+        const managed = this.managed.get(record.id);
+        if (!managed?.child || !isActiveProcessStatus(record.status))
+            return record;
+        const signal = request.signal ?? "SIGTERM";
+        managed.stopping = true;
+        const stopping = await this.updateProcess(record.id, {
+            status: "stopping",
+        });
+        await this.events.publish("process.stop_requested", {
+            processId: record.id,
+            signal,
+        });
+        await this.logger?.info("Process stop requested", {
+            processId: record.id,
+            projectId: record.projectId,
+            conversationId: record.conversationId,
+            agentId: record.agentId,
+            context: { signal },
+        });
+        void this.requestTermination(stopping, managed.child, signal, "stop requested");
+        const timeoutMs = request.timeoutMs ?? 5000;
+        const timeoutResult = Symbol("process-stop-timeout");
+        let timeout;
+        const finalized = await Promise.race([
+            managed.finalizationPromise ?? Promise.resolve(undefined),
+            new Promise((resolveTimeout) => {
+                timeout = setTimeout(() => resolveTimeout(timeoutResult), timeoutMs);
+            }),
+        ]).finally(() => {
+            if (timeout)
+                clearTimeout(timeout);
+        });
+        if (finalized !== timeoutResult) {
+            return finalized ?? this.getProcess(processId);
+        }
+        void this.requestTermination(this.processes.get(processId) ?? stopping, managed.child, "SIGKILL", `stop timed out after ${timeoutMs}ms`);
+        return this.forceFinalizeStoppedProcess(processId, "SIGKILL", `Process did not close within ${timeoutMs}ms after stop was requested.`);
+    }
+    async restartProcess(processId) {
+        const record = this.getProcess(processId);
+        const env = await this.envForRestart(record);
+        if (record.status === "orphaned") {
+            await this.cleanupOrphanedProcess(record.id, { timeoutMs: 5000 });
+        }
+        else if (isActiveProcessStatus(record.status)) {
+            await this.stopProcess(processId);
+        }
+        return this.startProcess({
+            name: record.name,
+            workerId: record.workerId,
+            projectId: record.projectId,
+            conversationId: record.conversationId,
+            agentId: record.agentId,
+            cwd: record.cwd,
+            command: record.command,
+            env,
+            readyOnUrl: record.readiness.readyOnUrl,
+            readyPattern: record.readiness.readyPattern,
+            readyTimeoutMs: record.readiness.timeoutMs,
+            restartedFromProcessId: record.id,
+        });
+    }
+    async removeProcess(processId) {
+        const record = this.getProcess(processId);
+        if (isActiveProcessStatus(record.status)) {
+            throw new Error("Stop the process before removing it.");
+        }
+        await this.launchConfigs.remove(record.id);
+        const managed = this.managed.get(record.id);
+        if (managed?.readinessTimer)
+            clearTimeout(managed.readinessTimer);
+        this.managed.delete(record.id);
+        this.processes.delete(record.id);
+        this.index.deleteProcess(record.id);
+        await this.processRepository.remove(record.id);
+        await this.events.publish("process.removed", { processId: record.id });
+        await this.logger?.info("Process removed", {
+            processId: record.id,
+            projectId: record.projectId,
+            conversationId: record.conversationId,
+            agentId: record.agentId,
+        });
+    }
+    async pruneProcesses() {
+        const removed = [];
+        for (const record of this.listProcesses()) {
+            if (isActiveProcessStatus(record.status))
+                continue;
+            try {
+                await this.removeProcess(record.id);
+                removed.push(record.id);
+            }
+            catch {
+                // Best-effort: skip processes that can't be removed right now.
+            }
+        }
+        return removed;
+    }
+    activeProcessesForConversations(conversationIds) {
+        const conversations = new Set(conversationIds);
+        if (conversations.size === 0)
+            return [];
+        return this.listProcesses().filter((record) => record.conversationId !== undefined &&
+            conversations.has(record.conversationId) &&
+            isActiveProcessStatus(record.status));
+    }
+    async removeInactiveProcessesForConversations(conversationIds) {
+        const conversations = new Set(conversationIds);
+        if (conversations.size === 0)
+            return [];
+        const removed = [];
+        for (const record of this.listProcesses()) {
+            if (!record.conversationId || !conversations.has(record.conversationId)) {
+                continue;
+            }
+            if (isActiveProcessStatus(record.status))
+                continue;
+            try {
+                await this.removeProcess(record.id);
+                removed.push(record.id);
+            }
+            catch {
+                // Best-effort: skip processes that can't be removed right now.
+            }
+        }
+        return removed;
+    }
+    async queryLogs(processId, query = {}) {
+        return this.processLogs.queryLogs(this.getProcess(processId), query);
+    }
+    async envForRestart(record) {
+        if (!record.envInfo?.persisted)
+            return undefined;
+        const config = await this.launchConfigs.read(record.id);
+        if (!config) {
+            throw new Error("Process was started with persisted env metadata, but launch env is missing; refusing to restart without env.");
+        }
+        const env = config.env;
+        const missingKeys = record.envInfo.keys.filter((key) => !env || !Object.hasOwn(env, key));
+        if (missingKeys.length > 0) {
+            throw new Error(`Process launch env is missing persisted keys (${missingKeys.join(", ")}); refusing to restart without env.`);
+        }
+        return env ? { ...env } : undefined;
+    }
+    async captureOutput(processId, stream, chunk) {
+        const record = this.processes.get(processId);
+        const managed = this.managed.get(processId);
+        if (!record || !managed)
+            return;
+        await this.processLogs.captureOutput(record, managed, stream, chunk, async (event) => this.checkReadiness(record.id, event));
+    }
+    async flushProcessOutputBuffers(processId) {
+        const record = this.processes.get(processId);
+        const managed = this.managed.get(processId);
+        if (!record || !managed)
+            return;
+        try {
+            await this.processLogs.flushOutputBuffers(record, managed, async (event) => this.checkReadiness(record.id, event));
+        }
+        catch (error) {
+            await this.logger
+                ?.warn("Process output flush failed", {
+                processId: record.id,
+                projectId: record.projectId,
+                conversationId: record.conversationId,
+                agentId: record.agentId,
+                error,
+            })
+                .catch(() => undefined);
+        }
+    }
+    async checkReadiness(processId, log) {
+        const record = this.processes.get(processId);
+        const managed = this.managed.get(processId);
+        if (!record || !managed || record.readiness.outcome !== "pending")
+            return;
+        const matched = this.processReadiness.match(record, managed.readinessPattern, log);
+        if (!matched)
+            return;
+        if (managed.readinessTimer)
+            clearTimeout(managed.readinessTimer);
+        const ready = await this.updateProcess(processId, {
+            status: "ready",
+            readiness: {
+                ...record.readiness,
+                outcome: "ready",
+                matched,
+                readyAt: new Date().toISOString(),
+            },
+        });
+        await this.events.publish("process.ready", { process: ready, matched });
+        await this.logger?.info("Process ready", {
+            processId: ready.id,
+            projectId: ready.projectId,
+            conversationId: ready.conversationId,
+            agentId: ready.agentId,
+            context: { matched },
+        });
+    }
+    async waitForReadiness(processId) {
+        const record = this.getProcess(processId);
+        if (record.readiness.outcome !== "pending")
+            return;
+        const managed = this.managed.get(processId);
+        const timeoutMs = record.readiness.timeoutMs ?? 3000;
+        if (!managed || timeoutMs <= 0)
+            return;
+        await new Promise((resolveWait) => {
+            let unsubscribe = () => undefined;
+            const resolveOnce = () => {
+                unsubscribe();
+                resolveWait();
+            };
+            managed.readinessTimer = setTimeout(() => {
+                void this.markReadinessTimeout(processId).finally(resolveOnce);
+            }, timeoutMs);
+            unsubscribe = this.events.subscribe((event) => {
+                if (event.type !== "process.ready" && event.type !== "process.exited")
+                    return;
+                const data = event.data;
+                if (data.process?.id !== processId)
+                    return;
+                resolveOnce();
+            });
+        });
+    }
+    async markReadinessTimeout(processId) {
+        const record = this.processes.get(processId);
+        if (!record || record.readiness.outcome !== "pending")
+            return;
+        const updated = await this.updateProcess(processId, {
+            readiness: { ...record.readiness, outcome: "timeout" },
+        });
+        await this.events.publish("process.ready_timeout", { process: updated });
+        await this.logger?.warn("Process readiness timed out", {
+            processId: updated.id,
+            projectId: updated.projectId,
+            conversationId: updated.conversationId,
+            agentId: updated.agentId,
+            context: { timeoutMs: updated.readiness.timeoutMs },
+        });
+    }
+    async requestTermination(record, child, signal, reason) {
+        try {
+            const result = await this.supervisor.terminate(child, signal);
+            if (!result.error)
+                return;
+            if (this.logger) {
+                await this.logger
+                    .warn("Process termination reported an error", {
+                    processId: record.id,
+                    projectId: record.projectId,
+                    conversationId: record.conversationId,
+                    agentId: record.agentId,
+                    context: {
+                        signal,
+                        reason,
+                        method: result.method,
+                        error: result.error,
+                    },
+                })
+                    .catch(() => undefined);
+            }
+        }
+        catch (error) {
+            if (this.logger) {
+                await this.logger
+                    .warn("Process termination failed", {
+                    processId: record.id,
+                    projectId: record.projectId,
+                    conversationId: record.conversationId,
+                    agentId: record.agentId,
+                    error,
+                    context: { signal, reason },
+                })
+                    .catch(() => undefined);
+            }
+        }
+    }
+    markHydratedRecordOrphaned(record) {
+        return {
+            ...record,
+            status: "orphaned",
+            error: this.orphanedHydrateMessage(record.runtime),
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    orphanedHydrateMessage(runtime) {
+        if (runtime?.childPid) {
+            return `Process supervision was lost after daemon restart. Use process_stop to attempt cleanup of PID ${runtime.childPid}.`;
+        }
+        if (runtime?.processGroupId) {
+            return `Process supervision was lost after daemon restart. Use process_stop to attempt cleanup of process group ${runtime.processGroupId}.`;
+        }
+        return "Process supervision was lost after daemon restart, and no PID metadata was captured.";
+    }
+    async cleanupOrphanedProcess(processId, request) {
+        const record = this.getProcess(processId);
+        if (record.status !== "orphaned")
+            return record;
+        const validationError = this.orphanCleanupValidationError(record.runtime);
+        if (validationError) {
+            await this.failOrphanCleanup(record, validationError);
+        }
+        const runtime = record.runtime;
+        const initialSignal = request.signal ?? "SIGTERM";
+        const timeoutMs = request.timeoutMs ?? 5000;
+        await this.events.publish("process.stop_requested", {
+            processId: record.id,
+            signal: initialSignal,
+            orphaned: true,
+        });
+        await this.logger?.info("Orphaned process cleanup requested", {
+            processId: record.id,
+            projectId: record.projectId,
+            conversationId: record.conversationId,
+            agentId: record.agentId,
+            context: this.runtimeLogContext(runtime, { signal: initialSignal }),
+        });
+        if (runtime.platform === "win32") {
+            const result = await this.terminateRuntimeForCleanup(record, runtime, "SIGKILL");
+            if (!result.attempted || result.error) {
+                await this.failOrphanCleanup(record, result.error ?? "Could not clean up orphaned process runtime target.", { method: result.method, signal: "SIGKILL" });
+            }
+            return this.finalizeOrphanCleanup(record.id, "SIGKILL", runtime, {
+                method: result.method,
+            });
+        }
+        const initialResult = await this.terminateRuntimeForCleanup(record, runtime, initialSignal);
+        if (!initialResult.attempted || initialResult.method === "none") {
+            await this.failOrphanCleanup(record, initialResult.error ??
+                "Could not signal orphaned process runtime target.", { method: initialResult.method, signal: initialSignal });
+        }
+        if (initialResult.error) {
+            await this.logger?.warn("Orphaned process cleanup signal reported an error", {
+                processId: record.id,
+                projectId: record.projectId,
+                conversationId: record.conversationId,
+                agentId: record.agentId,
+                context: this.runtimeLogContext(runtime, {
+                    signal: initialSignal,
+                    method: initialResult.method,
+                    error: initialResult.error,
+                }),
+            });
+        }
+        let finalSignal = initialSignal;
+        if (!(await this.waitForRuntimeTargetExit(runtime, timeoutMs))) {
+            finalSignal = "SIGKILL";
+            const killResult = await this.terminateRuntimeForCleanup(record, runtime, finalSignal);
+            if (!killResult.attempted || killResult.method === "none") {
+                await this.failOrphanCleanup(record, killResult.error ??
+                    "Could not force-kill orphaned process runtime target.", { method: killResult.method, signal: finalSignal });
+            }
+            if (killResult.error && (await this.isRuntimeTargetAlive(runtime))) {
+                await this.failOrphanCleanup(record, killResult.error, {
+                    method: killResult.method,
+                    signal: finalSignal,
+                });
+            }
+        }
+        return this.finalizeOrphanCleanup(record.id, finalSignal, runtime);
+    }
+    orphanCleanupValidationError(runtime) {
+        if (!runtime) {
+            return "Cannot clean up orphaned process because no PID metadata was captured.";
+        }
+        if (runtime.platform !== process.platform) {
+            return `Cannot clean up process spawned on ${runtime.platform} from ${process.platform}.`;
+        }
+        if (runtime.platform === "win32" && !runtime.childPid) {
+            return "Cannot clean up orphaned process because no child PID metadata was captured.";
+        }
+        if (runtime.platform !== "win32" &&
+            !runtime.processGroupId &&
+            !runtime.childPid) {
+            return "Cannot clean up orphaned process because no process-group or child PID metadata was captured.";
+        }
+        return undefined;
+    }
+    async terminateRuntimeForCleanup(record, runtime, signal) {
+        try {
+            return await this.supervisor.terminateRuntime(runtime, signal);
+        }
+        catch (error) {
+            await this.logger?.warn("Orphaned process cleanup termination threw", {
+                processId: record.id,
+                projectId: record.projectId,
+                conversationId: record.conversationId,
+                agentId: record.agentId,
+                error,
+                context: this.runtimeLogContext(runtime, { signal }),
+            });
+            return {
+                attempted: false,
+                method: "none",
+                error: this.errorMessage(error),
+            };
+        }
+    }
+    async waitForRuntimeTargetExit(runtime, timeoutMs) {
+        const deadline = Date.now() + Math.max(0, timeoutMs);
+        while (true) {
+            if (!(await this.isRuntimeTargetAlive(runtime)))
+                return true;
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                return false;
+            await delay(Math.min(50, remaining));
+        }
+    }
+    async isRuntimeTargetAlive(runtime) {
+        try {
+            return await this.supervisor.isRuntimeTargetAlive(runtime);
+        }
+        catch (error) {
+            await this.logger?.warn("Orphaned process liveness check failed", {
+                error,
+                context: this.runtimeLogContext(runtime),
+            });
+            return true;
+        }
+    }
+    async finalizeOrphanCleanup(processId, finalSignal, runtime, context = {}) {
+        const record = this.getProcess(processId);
+        if (record.status !== "orphaned")
+            return record;
+        const managed = this.managed.get(processId);
+        if (managed?.readinessTimer)
+            clearTimeout(managed.readinessTimer);
+        const readiness = record.readiness.outcome === "pending"
+            ? { ...record.readiness, outcome: "exited" }
+            : record.readiness;
+        const updated = await this.updateProcess(processId, {
+            status: "stopped",
+            readiness,
+            exitedAt: new Date().toISOString(),
+            exitCode: null,
+            signal: finalSignal,
+            error: undefined,
+        });
+        this.managed.delete(processId);
+        await this.events.publish("process.exited", { process: updated });
+        await this.events.publish("process.orphan_cleanup_succeeded", {
+            process: updated,
+            runtime,
+            signal: finalSignal,
+            ...context,
+        });
+        await this.logger?.info("Orphaned process cleanup completed", {
+            processId: updated.id,
+            projectId: updated.projectId,
+            conversationId: updated.conversationId,
+            agentId: updated.agentId,
+            context: this.runtimeLogContext(runtime, {
+                signal: finalSignal,
+                ...context,
+            }),
+        });
+        return updated;
+    }
+    async failOrphanCleanup(record, message, context = {}) {
+        const updated = await this.updateProcess(record.id, { error: message });
+        await this.events.publish("process.cleanup_failed", {
+            process: updated,
+            error: message,
+            orphaned: true,
+            ...context,
+        });
+        await this.logger?.warn("Orphaned process cleanup failed", {
+            processId: updated.id,
+            projectId: updated.projectId,
+            conversationId: updated.conversationId,
+            agentId: updated.agentId,
+            context: this.runtimeLogContext(updated.runtime, {
+                error: message,
+                ...context,
+            }),
+        });
+        throw new Error(message);
+    }
+    runtimeLogContext(runtime, extra = {}) {
+        return {
+            pid: runtime?.childPid,
+            processGroupId: runtime?.processGroupId,
+            platform: runtime?.platform,
+            detached: runtime?.detached,
+            shell: runtime?.shell,
+            spawnedAt: runtime?.spawnedAt,
+            ...extra,
+        };
+    }
+    errorMessage(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    async forceFinalizeStoppedProcess(processId, signal, reason) {
+        const record = this.getProcess(processId);
+        if (!isActiveProcessStatus(record.status))
+            return record;
+        const managed = this.managed.get(processId);
+        if (managed?.readinessTimer)
+            clearTimeout(managed.readinessTimer);
+        if (managed)
+            managed.finalized = true;
+        await this.flushProcessOutputBuffers(processId);
+        const freshRecord = this.processes.get(processId) ?? record;
+        const readiness = freshRecord.readiness.outcome === "pending"
+            ? { ...freshRecord.readiness, outcome: "exited" }
+            : freshRecord.readiness;
+        const updated = await this.updateProcess(processId, {
+            status: "stopped",
+            readiness,
+            exitedAt: new Date().toISOString(),
+            exitCode: null,
+            signal,
+        });
+        this.managed.delete(processId);
+        await this.events.publish("process.exited", { process: updated });
+        await this.logger?.warn("Process stop force-finalized", {
+            processId: updated.id,
+            projectId: updated.projectId,
+            conversationId: updated.conversationId,
+            agentId: updated.agentId,
+            context: { signal, reason },
+        });
+        return updated;
+    }
+    async markProcessExited(processId, exitCode, signal) {
+        const record = this.processes.get(processId);
+        const managed = this.managed.get(processId);
+        if (!record)
+            return undefined;
+        if (!isActiveProcessStatus(record.status))
+            return record;
+        if (managed?.finalized)
+            return record;
+        if (managed?.readinessTimer)
+            clearTimeout(managed.readinessTimer);
+        if (managed)
+            managed.finalized = true;
+        await this.flushProcessOutputBuffers(processId);
+        const freshRecord = this.processes.get(processId);
+        if (!freshRecord)
+            return undefined;
+        if (!isActiveProcessStatus(freshRecord.status))
+            return freshRecord;
+        const status = managed?.stopping
+            ? "stopped"
+            : exitCode === 0
+                ? "exited"
+                : "error";
+        const readiness = freshRecord.readiness.outcome === "pending"
+            ? { ...freshRecord.readiness, outcome: "exited" }
+            : freshRecord.readiness;
+        const updated = await this.updateProcess(processId, {
+            status,
+            readiness,
+            exitedAt: new Date().toISOString(),
+            exitCode,
+            signal,
+        });
+        this.managed.delete(processId);
+        await this.events.publish("process.exited", { process: updated });
+        await this.logger?.[status === "error" ? "error" : "info"]("Process exited", {
+            processId: updated.id,
+            projectId: updated.projectId,
+            conversationId: updated.conversationId,
+            agentId: updated.agentId,
+            context: { exitCode, signal, status },
+        });
+        return updated;
+    }
+    async markProcessError(processId, message) {
+        const record = this.processes.get(processId);
+        const managed = this.managed.get(processId);
+        if (!record || !isActiveProcessStatus(record.status))
+            return;
+        if (managed?.finalized)
+            return;
+        if (managed?.readinessTimer)
+            clearTimeout(managed.readinessTimer);
+        if (managed)
+            managed.finalized = true;
+        await this.flushProcessOutputBuffers(processId);
+        const freshRecord = this.processes.get(processId);
+        if (!freshRecord || !isActiveProcessStatus(freshRecord.status))
+            return;
+        const updated = await this.updateProcess(processId, {
+            status: "error",
+            error: message,
+        });
+        this.managed.delete(processId);
+        await this.events.publish("process.error", { process: updated, message });
+        await this.logger?.error("Process error", {
+            processId: updated.id,
+            projectId: updated.projectId,
+            conversationId: updated.conversationId,
+            agentId: updated.agentId,
+            context: { message },
+        });
+    }
+    async updateProcess(processId, patch) {
+        const current = this.getProcess(processId);
+        const updated = {
+            ...current,
+            ...patch,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.upsertProcess(updated);
+        return updated;
+    }
+    async upsertProcess(record) {
+        this.processes.set(record.id, record);
+        this.index.upsertProcess(record);
+        await this.writeProcess(record);
+    }
+    async writeProcess(record) {
+        await this.processRepository.write(record);
+    }
+    processDir(processId) {
+        return this.processRepository.processDir(processId);
+    }
+}
+function buildProcessEnvInfo(env) {
+    const keys = Object.keys(env ?? {})
+        .filter((key) => key.length > 0)
+        .sort();
+    if (keys.length === 0)
+        return undefined;
+    return { keys, persisted: true, redacted: true };
+}
+export { isActiveProcessStatus } from "./index.js";
+//# sourceMappingURL=process-manager.js.map