daycare-cli 0.0.0-canary.f57680e

package/dist/engine/processes/processes.js

@@ -0,0 +1,710 @@
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { createId } from "@paralleldrive/cuid2";
+import { resolveWorkspacePath } from "../permissions.js";
+import { sandboxAllowedDomainsResolve } from "../../sandbox/sandboxAllowedDomainsResolve.js";
+import { sandboxAllowedDomainsValidate } from "../../sandbox/sandboxAllowedDomainsValidate.js";
+import { sandboxCanWrite } from "../../sandbox/sandboxCanWrite.js";
+import { sandboxFilesystemPolicyBuild } from "../../sandbox/sandboxFilesystemPolicyBuild.js";
+import { envNormalize } from "../../util/envNormalize.js";
+import { AsyncLock } from "../../util/lock.js";
+import { sandboxHomeRedefine } from "../../sandbox/sandboxHomeRedefine.js";
+import { atomicWrite } from "../../util/atomicWrite.js";
+import { processBootTimeRead } from "./processBootTimeRead.js";
+import { resolveEngineSocketPath } from "../ipc/socket.js";
+const RECORD_VERSION = 2;
+const MONITOR_INTERVAL_MS = 2_000;
+const PROCESS_STOP_TIMEOUT_MS = 8_000;
+const PROCESS_STOP_POLL_MS = 200;
+const RESTART_BACKOFF_BASE_MS = 2_000;
+const RESTART_BACKOFF_MAX_MS = 60_000;
+const RESTART_STABLE_UPTIME_MS = 30_000;
+const nodeRequire = createRequire(import.meta.url);
+const sandboxCliPath = nodeRequire.resolve("@anthropic-ai/sandbox-runtime/dist/cli.js");
+const SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP", "SIGKILL"];
+/**
+ * Manages durable sandboxed background processes persisted on disk.
+ * Expects: all state writes happen through this facade to keep pid/status files in sync.
+ */
+export class Processes {
+    baseDir;
+    recordsDir;
+    lock = new AsyncLock();
+    logger;
+    bootTimeProvider;
+    socketPath;
+    records = new Map();
+    children = new Map();
+    currentBootTimeMs = null;
+    currentBootTimeKnown = false;
+    monitorHandle = null;
+    constructor(baseDir, logger, options = {}) {
+        this.baseDir = path.resolve(baseDir);
+        this.recordsDir = path.join(this.baseDir, "processes");
+        this.logger = logger;
+        this.bootTimeProvider = options.bootTimeProvider ?? processBootTimeRead;
+        this.socketPath = resolveEngineSocketPath(options.socketPath);
+    }
+    async load() {
+        await fs.mkdir(this.recordsDir, { recursive: true });
+        this.currentBootTimeMs = await this.bootTimeProvider();
+        this.currentBootTimeKnown = true;
+        await this.lock.inLock(async () => {
+            this.records.clear();
+            const entries = await fs.readdir(this.recordsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const recordPath = this.recordPath(entry.name);
+                const record = await readRecord(recordPath);
+                if (!record) {
+                    continue;
+                }
+                this.clearStalePidForBootMismatch(record);
+                this.records.set(record.id, record);
+            }
+            await this.refreshRecordStatusLocked();
+        });
+        this.startMonitor();
+    }
+    unload() {
+        if (!this.monitorHandle) {
+            return;
+        }
+        // Interval cleanup is required to avoid keeping timers alive after runtime shutdown.
+        clearInterval(this.monitorHandle);
+        this.monitorHandle = null;
+    }
+    async create(input, permissions) {
+        return this.lock.inLock(async () => {
+            const now = Date.now();
+            const workingDir = permissions.workingDir;
+            if (!workingDir) {
+                throw new Error("Workspace is not configured.");
+            }
+            const command = input.command.trim();
+            if (!command) {
+                throw new Error("Command is required.");
+            }
+            if (input.cwd && !path.isAbsolute(input.cwd)) {
+                throw new Error("Path must be absolute.");
+            }
+            if (input.home && !path.isAbsolute(input.home)) {
+                throw new Error("Path must be absolute.");
+            }
+            const cwd = input.cwd
+                ? resolveWorkspacePath(workingDir, input.cwd)
+                : workingDir;
+            const home = input.home
+                ? await sandboxCanWrite(permissions, input.home)
+                : null;
+            const allowedDomains = sandboxAllowedDomainsResolve(input.allowedDomains, input.packageManagers);
+            const domainIssues = sandboxAllowedDomainsValidate(allowedDomains, permissions.network);
+            if (domainIssues.length > 0) {
+                throw new Error(domainIssues.join(" "));
+            }
+            const envInput = envNormalize(input.env) ?? {};
+            const id = createId();
+            const recordDir = this.processDir(id);
+            const settingsPath = path.join(recordDir, "sandbox.json");
+            const logPath = path.join(recordDir, "process.log");
+            const bootTimeMs = await this.resolveCurrentBootTimeMsLocked();
+            await fs.mkdir(recordDir, { recursive: true });
+            const record = {
+                version: RECORD_VERSION,
+                id,
+                name: (input.name?.trim() || id).slice(0, 80),
+                command,
+                cwd,
+                home,
+                env: envInput,
+                packageManagers: [...(input.packageManagers ?? [])],
+                allowedDomains,
+                allowLocalBinding: input.allowLocalBinding === true,
+                permissions: clonePermissions(permissions),
+                owner: input.owner ? ownerNormalize(input.owner) : null,
+                keepAlive: input.keepAlive ?? false,
+                desiredState: "running",
+                status: "stopped",
+                pid: null,
+                bootTimeMs,
+                restartCount: 0,
+                restartFailureCount: 0,
+                nextRestartAt: null,
+                createdAt: now,
+                updatedAt: now,
+                lastStartedAt: null,
+                lastExitedAt: null,
+                settingsPath,
+                logPath
+            };
+            await this.startRecordLocked(record, { incrementRestart: false });
+            this.records.set(record.id, record);
+            await this.writeRecordLocked(record);
+            return toProcessInfo(record);
+        });
+    }
+    async listByOwner(owner) {
+        return this.lock.inLock(async () => {
+            const normalizedOwner = ownerNormalize(owner);
+            await this.refreshRecordStatusLocked();
+            return Array.from(this.records.values())
+                .filter((record) => ownerIs(record.owner, normalizedOwner))
+                .sort((a, b) => a.createdAt - b.createdAt)
+                .map((record) => toProcessInfo(record));
+        });
+    }
+    async list() {
+        return this.lock.inLock(async () => {
+            await this.refreshRecordStatusLocked();
+            return Array.from(this.records.values())
+                .sort((a, b) => a.createdAt - b.createdAt)
+                .map((record) => toProcessInfo(record));
+        });
+    }
+    async get(processId) {
+        return this.lock.inLock(async () => {
+            await this.refreshRecordStatusLocked();
+            const record = this.records.get(processId);
+            if (!record) {
+                throw new Error(`Unknown process id: ${processId}`);
+            }
+            return toProcessInfo(record);
+        });
+    }
+    async stop(processId, signal = "SIGTERM") {
+        return this.lock.inLock(async () => {
+            const record = this.records.get(processId);
+            if (!record) {
+                throw new Error(`Unknown process id: ${processId}`);
+            }
+            record.desiredState = "stopped";
+            await this.stopRecordLocked(record, signal);
+            await this.writeRecordLocked(record);
+            return toProcessInfo(record);
+        });
+    }
+    async remove(processId, signal = "SIGTERM") {
+        await this.lock.inLock(async () => {
+            const record = this.records.get(processId);
+            if (!record) {
+                throw new Error(`Unknown process id: ${processId}`);
+            }
+            await this.removeRecordLocked(record, signal);
+        });
+    }
+    async removeByOwner(owner, signal = "SIGTERM") {
+        return this.lock.inLock(async () => {
+            const normalizedOwner = ownerNormalize(owner);
+            const records = Array.from(this.records.values()).filter((record) => ownerIs(record.owner, normalizedOwner));
+            for (const record of records) {
+                await this.removeRecordLocked(record, signal);
+            }
+            return records.length;
+        });
+    }
+    async stopAll(signal = "SIGTERM") {
+        return this.lock.inLock(async () => {
+            const results = [];
+            for (const record of this.records.values()) {
+                record.desiredState = "stopped";
+                await this.stopRecordLocked(record, signal);
+                await this.writeRecordLocked(record);
+                results.push(toProcessInfo(record));
+            }
+            return results;
+        });
+    }
+    startMonitor() {
+        if (this.monitorHandle) {
+            return;
+        }
+        this.monitorHandle = setInterval(() => {
+            void this.lock.inLock(async () => {
+                await this.refreshRecordStatusLocked();
+            }).catch((error) => {
+                this.logger.warn({ error }, "error: Process monitor tick failed");
+            });
+        }, MONITOR_INTERVAL_MS);
+        this.monitorHandle.unref();
+    }
+    async refreshRecordStatusLocked() {
+        for (const record of this.records.values()) {
+            const running = record.pid !== null && isProcessRunning(record.pid);
+            if (running) {
+                const now = Date.now();
+                if (record.desiredState === "stopped") {
+                    await this.stopRecordLocked(record, "SIGTERM");
+                    await this.writeRecordLocked(record);
+                    continue;
+                }
+                if (record.restartFailureCount > 0 &&
+                    record.lastStartedAt !== null &&
+                    now - record.lastStartedAt >= RESTART_STABLE_UPTIME_MS) {
+                    record.restartFailureCount = 0;
+                    record.nextRestartAt = null;
+                    record.updatedAt = now;
+                    await this.writeRecordLocked(record);
+                }
+                if (record.status !== "running") {
+                    record.status = "running";
+                    record.updatedAt = now;
+                    await this.writeRecordLocked(record);
+                }
+                continue;
+            }
+            if (record.pid !== null) {
+                record.pid = null;
+                record.lastExitedAt = Date.now();
+            }
+            if (record.desiredState === "running") {
+                if (record.keepAlive) {
+                    await this.restartRecordWithBackoffLocked(record);
+                    continue;
+                }
+                if (record.status !== "exited") {
+                    record.status = "exited";
+                    record.updatedAt = Date.now();
+                    await this.writeRecordLocked(record);
+                }
+                continue;
+            }
+            if (record.status !== "stopped") {
+                record.status = "stopped";
+                record.restartFailureCount = 0;
+                record.nextRestartAt = null;
+                record.updatedAt = Date.now();
+                await this.writeRecordLocked(record);
+            }
+        }
+    }
+    async restartRecordWithBackoffLocked(record) {
+        const now = Date.now();
+        if (record.status !== "exited") {
+            record.status = "exited";
+            record.updatedAt = now;
+            await this.writeRecordLocked(record);
+        }
+        if (record.nextRestartAt === null) {
+            scheduleRestart(record, now);
+            await this.writeRecordLocked(record);
+            return;
+        }
+        if (now < record.nextRestartAt) {
+            return;
+        }
+        try {
+            await this.startRecordLocked(record, { incrementRestart: true });
+            record.nextRestartAt = null;
+            await this.writeRecordLocked(record);
+        }
+        catch (error) {
+            this.logger.warn({ error, processId: record.id, restartFailureCount: record.restartFailureCount + 1 }, "error: Process restart failed; backoff applied");
+            const failedAt = Date.now();
+            record.pid = null;
+            record.status = "exited";
+            record.lastExitedAt = failedAt;
+            scheduleRestart(record, failedAt);
+            await this.writeRecordLocked(record);
+        }
+    }
+    async removeRecordLocked(record, signal) {
+        record.desiredState = "stopped";
+        await this.stopRecordLocked(record, signal);
+        this.records.delete(record.id);
+        this.children.delete(record.id);
+        await fs.rm(this.processDir(record.id), { recursive: true, force: true });
+        this.logger.info({ processId: record.id, signal }, "remove: Process removed");
+    }
+    async startRecordLocked(record, options) {
+        const sandboxConfig = buildSandboxConfig(record.allowedDomains, record.permissions, this.socketPath, record.allowLocalBinding);
+        await atomicWrite(record.settingsPath, JSON.stringify(sandboxConfig));
+        const baseEnv = { ...process.env, ...record.env };
+        const envResult = await sandboxHomeRedefine({ env: baseEnv, home: record.home ?? undefined });
+        await fs.mkdir(path.dirname(record.logPath), { recursive: true });
+        const logHandle = await fs.open(record.logPath, "a");
+        const spawnResult = await spawnProcess({
+            command: process.execPath,
+            args: [sandboxCliPath, "--settings", record.settingsPath, "-c", record.command],
+            cwd: record.cwd,
+            env: envResult.env,
+            logFd: logHandle.fd
+        }).finally(async () => {
+            await logHandle.close();
+        });
+        const child = spawnResult.child;
+        const pid = child.pid;
+        if (!pid) {
+            throw new Error("Failed to capture process pid.");
+        }
+        child.unref();
+        this.children.set(record.id, child);
+        this.attachChildListeners(record.id, child);
+        const now = Date.now();
+        record.bootTimeMs = await this.resolveCurrentBootTimeMsLocked();
+        record.pid = pid;
+        record.status = "running";
+        record.lastStartedAt = now;
+        record.updatedAt = now;
+        if (options.incrementRestart) {
+            record.restartCount += 1;
+        }
+        this.logger.info({
+            processId: record.id,
+            pid: record.pid,
+            keepAlive: record.keepAlive,
+            cwd: record.cwd
+        }, "start: Process started");
+    }
+    attachChildListeners(processId, child) {
+        child.on("exit", () => {
+            void this.lock.inLock(async () => {
+                const record = this.records.get(processId);
+                if (!record) {
+                    return;
+                }
+                if (record.pid !== child.pid) {
+                    return;
+                }
+                this.children.delete(processId);
+                record.pid = null;
+                record.lastExitedAt = Date.now();
+                if (record.desiredState === "stopped") {
+                    record.status = "stopped";
+                }
+                else {
+                    record.status = "exited";
+                }
+                record.updatedAt = Date.now();
+                await this.writeRecordLocked(record);
+            }).catch((error) => {
+                this.logger.warn({ error, processId }, "error: Process exit handler failed");
+            });
+        });
+    }
+    async stopRecordLocked(record, signal) {
+        const pid = record.pid;
+        if (pid !== null) {
+            killProcessTree(pid, signal);
+            await waitForStop(pid, PROCESS_STOP_TIMEOUT_MS);
+        }
+        const now = Date.now();
+        record.pid = null;
+        record.status = "stopped";
+        record.nextRestartAt = null;
+        record.restartFailureCount = 0;
+        record.lastExitedAt = now;
+        record.updatedAt = now;
+        this.children.delete(record.id);
+        this.logger.info({ processId: record.id, signal }, "stop: Process stopped");
+    }
+    async writeRecordLocked(record) {
+        await fs.mkdir(path.dirname(this.recordPath(record.id)), { recursive: true });
+        const serialized = JSON.stringify(record, null, 2);
+        await atomicWrite(this.recordPath(record.id), serialized);
+    }
+    processDir(processId) {
+        return path.join(this.recordsDir, processId);
+    }
+    recordPath(processId) {
+        return path.join(this.processDir(processId), "record.json");
+    }
+    async resolveCurrentBootTimeMsLocked() {
+        if (this.currentBootTimeKnown) {
+            return this.currentBootTimeMs;
+        }
+        this.currentBootTimeMs = await this.bootTimeProvider();
+        this.currentBootTimeKnown = true;
+        return this.currentBootTimeMs;
+    }
+    clearStalePidForBootMismatch(record) {
+        if (record.pid === null ||
+            record.bootTimeMs === null ||
+            this.currentBootTimeMs === null ||
+            record.bootTimeMs === this.currentBootTimeMs) {
+            if (record.bootTimeMs === null && this.currentBootTimeMs !== null) {
+                record.bootTimeMs = this.currentBootTimeMs;
+            }
+            return;
+        }
+        this.logger.info({
+            processId: record.id,
+            pid: record.pid,
+            recordBootTimeMs: record.bootTimeMs,
+            currentBootTimeMs: this.currentBootTimeMs
+        }, "event: Process pid cleared after boot mismatch detection");
+        record.pid = null;
+        record.bootTimeMs = this.currentBootTimeMs;
+        // Force refresh loop to persist a normalized terminal status.
+        record.status = "running";
+        record.lastExitedAt = Date.now();
+        record.updatedAt = Date.now();
+        record.nextRestartAt = null;
+        this.children.delete(record.id);
+    }
+}
+function buildSandboxConfig(allowedDomains, permissions, socketPath, allowLocalBinding) {
+    return {
+        filesystem: sandboxFilesystemPolicyBuild({ permissions }),
+        network: {
+            allowedDomains,
+            deniedDomains: [],
+            ...(allowLocalBinding ? { allowLocalBinding: true } : {})
+        },
+        ...(permissions.events ? { allowUnixSockets: [socketPath] } : {}),
+        enableWeakerNestedSandbox: true
+    };
+}
+function toProcessInfo(record) {
+    return {
+        id: record.id,
+        name: record.name,
+        command: record.command,
+        cwd: record.cwd,
+        home: record.home,
+        pid: record.pid,
+        keepAlive: record.keepAlive,
+        desiredState: record.desiredState,
+        status: record.status,
+        restartCount: record.restartCount,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        lastStartedAt: record.lastStartedAt,
+        lastExitedAt: record.lastExitedAt,
+        logPath: record.logPath
+    };
+}
+async function readRecord(recordPath) {
+    try {
+        const raw = await fs.readFile(recordPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== RECORD_VERSION) {
+            return null;
+        }
+        if (!parsed.id ||
+            !parsed.command ||
+            !parsed.cwd ||
+            !parsed.settingsPath ||
+            !parsed.logPath ||
+            !parsed.name) {
+            return null;
+        }
+        const permissions = parsePermissions(parsed.permissions);
+        if (!permissions) {
+            return null;
+        }
+        const keepAlive = parsed.keepAlive === true;
+        const desiredState = parsed.desiredState === "stopped" ? "stopped" : "running";
+        const status = parsed.status === "running" || parsed.status === "stopped" || parsed.status === "exited"
+            ? parsed.status
+            : "stopped";
+        const packageManagers = Array.isArray(parsed.packageManagers)
+            ? parsed.packageManagers.filter(isPackageManager)
+            : [];
+        const allowedDomains = Array.isArray(parsed.allowedDomains)
+            ? parsed.allowedDomains.filter((entry) => typeof entry === "string")
+            : [];
+        const env = parsed.env && typeof parsed.env === "object"
+            ? Object.fromEntries(Object.entries(parsed.env)
+                .filter(([key, value]) => key.trim().length > 0 && typeof value === "string")
+                .map(([key, value]) => [key.trim(), value]))
+            : {};
+        const owner = parseOwner(parsed.owner);
+        return {
+            version: RECORD_VERSION,
+            id: parsed.id,
+            name: parsed.name,
+            command: parsed.command,
+            cwd: parsed.cwd,
+            home: typeof parsed.home === "string" ? parsed.home : null,
+            env,
+            packageManagers,
+            allowedDomains,
+            allowLocalBinding: parsed.allowLocalBinding === true,
+            permissions,
+            owner,
+            keepAlive,
+            desiredState,
+            status,
+            pid: typeof parsed.pid === "number" ? parsed.pid : null,
+            bootTimeMs: typeof parsed.bootTimeMs === "number" ? parsed.bootTimeMs : null,
+            restartCount: typeof parsed.restartCount === "number" ? parsed.restartCount : 0,
+            restartFailureCount: typeof parsed.restartFailureCount === "number" ? parsed.restartFailureCount : 0,
+            nextRestartAt: typeof parsed.nextRestartAt === "number" ? parsed.nextRestartAt : null,
+            createdAt: typeof parsed.createdAt === "number" ? parsed.createdAt : Date.now(),
+            updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
+            lastStartedAt: typeof parsed.lastStartedAt === "number" ? parsed.lastStartedAt : null,
+            lastExitedAt: typeof parsed.lastExitedAt === "number" ? parsed.lastExitedAt : null,
+            settingsPath: parsed.settingsPath,
+            logPath: parsed.logPath
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+function parsePermissions(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const candidate = value;
+    if (typeof candidate.workingDir !== "string" ||
+        !Array.isArray(candidate.writeDirs) ||
+        !Array.isArray(candidate.readDirs) ||
+        typeof candidate.network !== "boolean" ||
+        typeof candidate.events !== "boolean") {
+        return null;
+    }
+    const writeDirs = candidate.writeDirs.filter((entry) => typeof entry === "string");
+    const readDirs = candidate.readDirs.filter((entry) => typeof entry === "string");
+    return {
+        workingDir: candidate.workingDir,
+        writeDirs,
+        readDirs,
+        network: candidate.network,
+        events: candidate.events
+    };
+}
+function clonePermissions(permissions) {
+    return {
+        workingDir: permissions.workingDir,
+        writeDirs: [...permissions.writeDirs],
+        readDirs: [...permissions.readDirs],
+        network: permissions.network,
+        events: permissions.events
+    };
+}
+function ownerNormalize(owner) {
+    const id = owner.id.trim();
+    if (!id) {
+        throw new Error("Process owner id is required.");
+    }
+    return { type: owner.type, id };
+}
+function ownerIs(candidate, owner) {
+    if (!candidate) {
+        return false;
+    }
+    return candidate.type === owner.type && candidate.id === owner.id;
+}
+function parseOwner(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const candidate = value;
+    if (candidate.type !== "plugin" || typeof candidate.id !== "string") {
+        return null;
+    }
+    const id = candidate.id.trim();
+    if (!id) {
+        return null;
+    }
+    return { type: "plugin", id };
+}
+function isPackageManager(value) {
+    return (value === "dart" ||
+        value === "dotnet" ||
+        value === "go" ||
+        value === "java" ||
+        value === "node" ||
+        value === "php" ||
+        value === "python" ||
+        value === "ruby" ||
+        value === "rust");
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function killProcessTree(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+        return;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ESRCH" && code !== "EPERM") {
+            throw error;
+        }
+    }
+    try {
+        process.kill(pid, signal);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ESRCH") {
+            throw error;
+        }
+    }
+}
+async function waitForStop(pid, timeoutMs) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        if (!isProcessRunning(pid)) {
+            return;
+        }
+        await sleep(PROCESS_STOP_POLL_MS);
+    }
+    if (isProcessRunning(pid)) {
+        killProcessTree(pid, "SIGKILL");
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function spawnProcess(options) {
+    const child = spawn(options.command, options.args, {
+        cwd: options.cwd,
+        env: options.env,
+        detached: true,
+        stdio: ["ignore", options.logFd, options.logFd]
+    });
+    return new Promise((resolve, reject) => {
+        child.once("error", (error) => {
+            reject(error);
+        });
+        child.once("spawn", () => {
+            resolve({ child });
+        });
+    });
+}
+function scheduleRestart(record, now) {
+    const uptimeMs = resolveUptimeMs(record, now);
+    if (uptimeMs >= RESTART_STABLE_UPTIME_MS) {
+        record.restartFailureCount = 0;
+    }
+    record.restartFailureCount += 1;
+    const delayMs = restartBackoffMs(record.restartFailureCount);
+    record.nextRestartAt = now + delayMs;
+    record.updatedAt = now;
+}
+function resolveUptimeMs(record, now) {
+    const startedAt = record.lastStartedAt;
+    if (startedAt === null) {
+        return 0;
+    }
+    const exitedAt = record.lastExitedAt ?? now;
+    if (exitedAt < startedAt) {
+        return 0;
+    }
+    return exitedAt - startedAt;
+}
+function restartBackoffMs(restartFailureCount) {
+    const exponent = Math.max(0, restartFailureCount - 1);
+    const delay = RESTART_BACKOFF_BASE_MS * 2 ** exponent;
+    return Math.min(delay, RESTART_BACKOFF_MAX_MS);
+}
+//# sourceMappingURL=processes.js.map