@nervekit/orchestrator 0.1.0 → 0.2.0

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

@@ -1,814 +0,0 @@
-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