@pasko70/pibo 2.5.2 → 3.0.1

package/dist/previews/manager.js

@@ -0,0 +1,644 @@
+import { execFile, spawn, spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { basename } from "node:path";
+import { promisify } from "node:util";
+import { sanitizePreviewServerSettings } from "../core/preview-server-settings.js";
+import { loadPreviewConfig } from "./config.js";
+import { findPreviewTargetProcess, isPreviewTargetProcessCurrent, previewProcessStartTicks, probePreviewTarget, } from "./network.js";
+import { previewExposureState } from "./store.js";
+const execFileAsync = promisify(execFile);
+const DEFAULT_STARTUP_TIMEOUT_MS = 15_000;
+const DEFAULT_POLL_INTERVAL_MS = 100;
+const PREVIEW_OWNER_ENV = "PIBO_PREVIEW_OWNER_TOKEN";
+const PREVIEW_COMMAND_ENV = "PIBO_PREVIEW_START_COMMAND";
+export function validatePreviewStartCommand(value) {
+    const command = value.replace(/\r\n/g, "\n").trim();
+    if (!command)
+        throw new Error("Preview start command is required");
+    if (command.includes("\0"))
+        throw new Error("Preview start command cannot contain NUL bytes");
+    if (command.length > 8_192)
+        throw new Error("Preview start command is too long");
+    return command;
+}
+export async function startManagedPreview(store, id, options = {}) {
+    const controller = options.controller ?? createDefaultPreviewProcessController();
+    const settings = options.settings ?? (() => {
+        const previewConfig = loadPreviewConfig();
+        return sanitizePreviewServerSettings({
+            maxRunningServers: previewConfig.maxRunningServers,
+            autoStopMinutes: previewConfig.autoStopMinutes,
+        });
+    })();
+    const now = options.now?.() ?? new Date();
+    await reconcileManagedPreviews(store, { ...options, controller, settings, now: () => now });
+    let current = store.requireExposure(id);
+    if (current.managementMode !== "managed" || !current.startCommand)
+        throw new Error(`Preview "${id}" has no managed start command`);
+    const startCommand = current.startCommand;
+    if (current.serverState === "running" && await managedPreviewIsOnline(current, controller, now))
+        return current;
+    if (current.serverState === "starting")
+        return current;
+    if (current.serverState === "running") {
+        await stopManagedPreview(store, id, { ...options, controller, settings });
+        current = store.requireExposure(id);
+    }
+    const stopAt = new Date(Math.min(now.getTime() + settings.autoStopMinutes * 60_000, Date.parse(current.expiresAt))).toISOString();
+    const launchInput = {
+        previewId: current.id,
+        command: startCommand,
+        workspace: current.workspace,
+        port: current.targetPort,
+    };
+    const preparedManager = controller.createIdentity(launchInput);
+    const reservation = store.reserveManagedServerStart(id, settings.maxRunningServers, now.toISOString(), stopAt, preparedManager);
+    if (!reservation.reserved)
+        return reservation.exposure;
+    const generation = reservation.exposure.serverGeneration;
+    if (!generation)
+        throw new Error(`Preview "${id}" did not retain its start generation`);
+    const durableManager = managerIdentity(reservation.exposure);
+    if (!durableManager || !sameManagerOwner(durableManager, preparedManager)) {
+        throw new Error(`Preview "${id}" did not durably retain its manager identity`);
+    }
+    let manager = durableManager;
+    try {
+        if (await probePreviewTarget(current.targetPort, { timeoutMs: 150 })) {
+            throw new Error(`Preview port ${current.targetPort} is already occupied`);
+        }
+        manager = await controller.launch(launchInput, durableManager);
+        if (!sameManagerOwner(manager, durableManager)) {
+            throw new Error("Preview controller changed its durable owner identity during launch");
+        }
+        const assigned = store.markManagedServerManager(id, generation, manager);
+        if (!managedGenerationMatches(assigned, generation, manager) || assigned.serverState !== "starting") {
+            if (await stopManagedOwner(controller, manager)) {
+                const latest = store.requireExposure(id);
+                if (managedGenerationMatches(latest, generation, manager)) {
+                    return store.markManagedServerStopped(id, { expectedGeneration: generation });
+                }
+            }
+            return store.requireExposure(id);
+        }
+        const target = await waitForManagedTarget(current, manager, controller, {
+            startupTimeoutMs: options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
+            pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+        });
+        const running = store.markManagedServerRunning(id, generation, {
+            targetHost: target.host,
+            targetProcessId: target.process?.pid,
+            targetProcessStartTicks: target.process?.startTicks,
+            manager,
+        });
+        if (!managedGenerationMatches(running, generation, manager) || running.serverState !== "running") {
+            if (await stopManagedOwner(controller, manager)) {
+                const latest = store.requireExposure(id);
+                if (managedGenerationMatches(latest, generation, manager)) {
+                    return store.markManagedServerStopped(id, { expectedGeneration: generation });
+                }
+            }
+        }
+        return running;
+    }
+    catch (error) {
+        const stopped = await stopManagedOwner(controller, manager);
+        const latest = store.requireExposure(id);
+        if (!managedGenerationMatches(latest, generation, durableManager))
+            return latest;
+        if (stopped) {
+            store.markManagedServerStopped(id, {
+                stoppedAt: (options.now?.() ?? new Date()).toISOString(),
+                error: managedPreviewError(error),
+                expectedGeneration: generation,
+            });
+        }
+        throw error;
+    }
+}
+export async function stopManagedPreview(store, id, options = {}) {
+    const controller = options.controller ?? createDefaultPreviewProcessController();
+    const exposure = store.requireExposure(id);
+    if (exposure.managementMode !== "managed")
+        throw new Error(`Preview "${id}" is not managed by Pibo`);
+    if (!["starting", "running", "stopping", "error"].includes(exposure.serverState ?? ""))
+        return exposure;
+    const identity = managerIdentity(exposure);
+    if (!identity || !exposure.serverGeneration) {
+        if (exposure.serverState === "error" && !identity && !exposure.serverGeneration) {
+            return store.markManagedServerStopped(id);
+        }
+        throw new Error(`Preview "${id}" has no durable managed owner identity`);
+    }
+    const wasStarting = exposure.serverState === "starting";
+    const launchMayStillPublish = !exposure.targetProcessId &&
+        (exposure.serverState === "starting" || exposure.serverState === "stopping");
+    if (exposure.serverState !== "stopping")
+        store.markManagedServerStopping(id, exposure.serverGeneration);
+    await controller.stop(identity);
+    if (await controller.isRunning(identity)) {
+        throw new Error(`Preview "${id}" exact owner cleanup is incomplete`);
+    }
+    if (wasStarting || launchMayStillPublish)
+        return store.requireExposure(id);
+    return store.markManagedServerStopped(id, { expectedGeneration: exposure.serverGeneration });
+}
+async function stopManagedPreviewForReconcile(controller, identity, previewId) {
+    try {
+        await controller.stop(identity);
+        return !await controller.isRunning(identity);
+    }
+    catch (error) {
+        console.error(`Preview server reconciliation could not stop ${previewId}: ${managedPreviewError(error)}`);
+        return false;
+    }
+}
+export async function reconcileManagedPreviews(store, options = {}) {
+    const controller = options.controller ?? createDefaultPreviewProcessController();
+    const now = options.now?.() ?? new Date();
+    const startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+    for (const exposure of store.listManagedServerCandidates()) {
+        const identity = managerIdentity(exposure);
+        const expired = previewExposureState(exposure, now) !== "active";
+        const leaseEnded = Boolean(exposure.serverStopAt && Date.parse(exposure.serverStopAt) <= now.getTime());
+        const startupTimedOut = (exposure.serverState === "starting" ||
+            (exposure.serverState === "stopping" && !exposure.targetProcessId)) &&
+            Boolean(exposure.serverStartedAt) &&
+            now.getTime() - Date.parse(exposure.serverStartedAt) > startupTimeoutMs + 5_000;
+        if (expired || leaseEnded || startupTimedOut) {
+            if (identity && exposure.serverGeneration && exposure.serverState !== "stopping") {
+                store.markManagedServerStopping(exposure.id, exposure.serverGeneration);
+            }
+            if (identity && !await stopManagedPreviewForReconcile(controller, identity, exposure.id))
+                continue;
+            if (exposure.serverState === "starting" && !startupTimedOut)
+                continue;
+            store.markManagedServerStopped(exposure.id, {
+                stoppedAt: now.toISOString(),
+                error: startupTimedOut ? "Managed Preview server startup timed out" : undefined,
+                expectedGeneration: exposure.serverGeneration,
+            });
+            continue;
+        }
+        if (exposure.serverState === "stopping") {
+            if (identity &&
+                await stopManagedPreviewForReconcile(controller, identity, exposure.id) &&
+                exposure.targetProcessId) {
+                store.markManagedServerStopped(exposure.id, {
+                    stoppedAt: now.toISOString(),
+                    expectedGeneration: exposure.serverGeneration,
+                });
+            }
+            continue;
+        }
+        if (exposure.serverState === "error" && identity) {
+            if (!await stopManagedPreviewForReconcile(controller, identity, exposure.id))
+                continue;
+            store.markManagedServerStopped(exposure.id, {
+                stoppedAt: now.toISOString(),
+                error: exposure.serverError,
+                expectedGeneration: exposure.serverGeneration,
+            });
+            continue;
+        }
+        if (!identity) {
+            const startedAt = exposure.serverStartedAt ? Date.parse(exposure.serverStartedAt) : 0;
+            if (!startedAt) {
+                store.markManagedServerStopped(exposure.id, {
+                    stoppedAt: now.toISOString(),
+                    error: "Managed Preview server did not retain a process identity",
+                    expectedGeneration: exposure.serverGeneration,
+                });
+            }
+            continue;
+        }
+        const ownerRunning = await controller.isRunning(identity);
+        const managerRunning = await exactManagerIsRunning(controller, identity);
+        if (exposure.serverState !== "starting" && (!ownerRunning || !managerRunning)) {
+            if (exposure.serverGeneration) {
+                store.markManagedServerStopping(exposure.id, exposure.serverGeneration);
+            }
+            if (!await stopManagedPreviewForReconcile(controller, identity, exposure.id))
+                continue;
+            store.markManagedServerStopped(exposure.id, {
+                stoppedAt: now.toISOString(),
+                expectedGeneration: exposure.serverGeneration,
+            });
+            continue;
+        }
+        if (exposure.serverState === "running") {
+            const targetCurrent = isPreviewTargetProcessCurrent(exposure, { cacheMs: 0 });
+            const targetReachable = targetCurrent && Boolean(await probePreviewTarget(exposure.targetPort, { timeoutMs: 500 }));
+            if (!targetReachable) {
+                if (!await stopManagedPreviewForReconcile(controller, identity, exposure.id))
+                    continue;
+                store.markManagedServerStopped(exposure.id, {
+                    stoppedAt: now.toISOString(),
+                    error: "Managed Preview listener no longer matches its pinned process",
+                    expectedGeneration: exposure.serverGeneration,
+                });
+            }
+        }
+    }
+}
+export async function managedPreviewIsOnline(exposure, controller = createDefaultPreviewProcessController(), now = new Date()) {
+    if (previewExposureState(exposure, now) !== "active")
+        return false;
+    if (exposure.managementMode !== "managed" || exposure.serverState !== "running")
+        return false;
+    const identity = managerIdentity(exposure);
+    if (!identity || !await exactManagerIsRunning(controller, identity))
+        return false;
+    if (!isPreviewTargetProcessCurrent(exposure, { cacheMs: 0 }))
+        return false;
+    return Boolean(await probePreviewTarget(exposure.targetPort, { timeoutMs: 500 }));
+}
+export function managerIdentity(exposure) {
+    if (!exposure.managerKind || !exposure.managerId)
+        return undefined;
+    return {
+        kind: exposure.managerKind,
+        id: exposure.managerId,
+        pid: exposure.managerPid,
+        processStartTicks: exposure.managerProcessStartTicks,
+    };
+}
+export function createDefaultPreviewProcessController() {
+    const preferSystemd = systemdAvailable();
+    const controllerFor = (identity) => identity.kind === "systemd"
+        ? systemdPreviewProcessController
+        : detachedPreviewProcessController;
+    return {
+        createIdentity(input) {
+            return preferSystemd
+                ? systemdPreviewProcessController.createIdentity(input)
+                : detachedPreviewProcessController.createIdentity(input);
+        },
+        async launch(input, identity) {
+            return preferSystemd
+                ? systemdPreviewProcessController.launch(input, identity)
+                : detachedPreviewProcessController.launch(input, identity);
+        },
+        isRunning(identity) {
+            return controllerFor(identity).isRunning(identity);
+        },
+        isManagerRunning(identity) {
+            const controller = controllerFor(identity);
+            return controller.isManagerRunning?.(identity) ?? controller.isRunning(identity);
+        },
+        ownsTarget(identity, targetPid) {
+            return controllerFor(identity).ownsTarget(identity, targetPid);
+        },
+        stop(identity) {
+            return controllerFor(identity).stop(identity);
+        },
+    };
+}
+const systemdPreviewProcessController = {
+    createIdentity(input) {
+        if (process.platform !== "linux") {
+            throw new Error("Managed Preview process ownership requires Linux process identity support");
+        }
+        return {
+            kind: "systemd",
+            id: `pibo-preview-${input.previewId.replace(/^pv-/, "").slice(0, 18)}-${randomBytes(12).toString("hex")}.service`,
+        };
+    },
+    async launch(input, identity) {
+        if (process.platform !== "linux") {
+            throw new Error("Managed Preview process ownership requires Linux process identity support");
+        }
+        if (identity.kind !== "systemd")
+            throw new Error("Preview systemd owner identity is invalid");
+        const unit = identity.id;
+        const shell = previewShell();
+        const args = [
+            "--quiet",
+            `--unit=${unit}`,
+            "--collect",
+            "--service-type=exec",
+            `--working-directory=${input.workspace}`,
+            "--property=KillMode=control-group",
+            "--property=TimeoutStopSec=5s",
+            ...systemdEnvironment(input.port),
+            "--",
+            shell.command,
+            ...shell.args(input.command),
+        ];
+        await execFileAsync("systemd-run", args, { timeout: 10_000, windowsHide: true });
+        return identity;
+    },
+    async isRunning(identity) {
+        try {
+            const { stdout } = await execFileAsync("systemctl", ["show", "--property=ActiveState", "--value", identity.id], { timeout: 5_000 });
+            return ["active", "activating", "reloading"].includes(stdout.trim());
+        }
+        catch {
+            return false;
+        }
+    },
+    async isManagerRunning(identity) {
+        return this.isRunning(identity);
+    },
+    async ownsTarget(identity, targetPid) {
+        try {
+            return readFileSync(`/proc/${targetPid}/cgroup`, "utf8").includes(`/${identity.id}`);
+        }
+        catch {
+            return false;
+        }
+    },
+    async stop(identity) {
+        try {
+            await execFileAsync("systemctl", ["stop", identity.id], { timeout: 10_000, windowsHide: true });
+        }
+        catch (error) {
+            if (await this.isRunning(identity))
+                throw error;
+        }
+    },
+};
+const detachedPreviewProcessController = {
+    createIdentity(input) {
+        if (process.platform !== "linux") {
+            throw new Error("Managed Preview process ownership requires Linux process identity support");
+        }
+        return {
+            kind: "process",
+            id: `pibo-preview-${input.previewId.replace(/^pv-/, "").slice(0, 18)}-${randomBytes(24).toString("base64url")}`,
+        };
+    },
+    async launch(input, identity) {
+        if (process.platform !== "linux") {
+            throw new Error("Managed Preview process ownership requires Linux process identity support");
+        }
+        if (identity.kind !== "process")
+            throw new Error("Preview process owner identity is invalid");
+        const child = spawn(process.execPath, [fileURLToPath(new URL("./process-supervisor.js", import.meta.url))], {
+            cwd: input.workspace,
+            env: {
+                ...previewEnvironment(input.port, identity.id),
+                [PREVIEW_COMMAND_ENV]: input.command,
+            },
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        if (!child.pid)
+            throw new Error("Preview server process did not provide a pid");
+        const processStartTicks = previewProcessStartTicks(child.pid);
+        if (process.platform === "linux" && !processStartTicks) {
+            try {
+                process.kill(-child.pid, "SIGKILL");
+            }
+            catch { }
+            throw new Error("Preview server process could not be pinned");
+        }
+        child.unref();
+        return {
+            ...identity,
+            pid: child.pid,
+            processStartTicks,
+        };
+    },
+    async isRunning(identity) {
+        return process.platform === "linux" && ownedLinuxProcesses(identity).length > 0;
+    },
+    async isManagerRunning(identity) {
+        return process.platform === "linux" && exactLinuxManagerIsRunning(identity);
+    },
+    async ownsTarget(identity, targetPid) {
+        if (process.platform !== "linux")
+            return false;
+        if (processOwnerToken(targetPid) === identity.id)
+            return true;
+        const targetGroup = await processGroupId(targetPid);
+        return targetGroup !== undefined && ownedLinuxProcesses(identity).some((owned) => owned.processGroupId === targetGroup);
+    },
+    async stop(identity) {
+        if (process.platform !== "linux") {
+            throw new Error("Refusing to signal a managed Preview process without verifiable Linux ownership");
+        }
+        const ownGroup = await processGroupId(process.pid);
+        const tracked = new Map();
+        const scan = () => {
+            const current = ownedLinuxProcesses(identity);
+            for (const owned of current)
+                tracked.set(owned.pid, owned);
+            return current;
+        };
+        const initial = scan();
+        const groups = verifiedOwnedProcessGroups(identity, initial);
+        if (ownGroup && groups.has(ownGroup))
+            throw new Error("Refusing to stop the current Pibo process group");
+        for (const group of groups) {
+            try {
+                process.kill(-group, "SIGTERM");
+            }
+            catch (error) {
+                if (!missingProcess(error))
+                    throw error;
+            }
+        }
+        for (let attempt = 0; attempt < 20 && exactTrackedProcessesRemain(tracked, scan()); attempt += 1)
+            await delay(100);
+        let remaining = scan();
+        if (exactTrackedProcessesRemain(tracked, remaining)) {
+            for (const group of verifiedOwnedProcessGroups(identity, remaining)) {
+                try {
+                    process.kill(-group, "SIGKILL");
+                }
+                catch (error) {
+                    if (!missingProcess(error))
+                        throw error;
+                }
+            }
+            for (const owned of tracked.values()) {
+                if (previewProcessStartTicks(owned.pid) !== owned.processStartTicks)
+                    continue;
+                try {
+                    process.kill(owned.pid, "SIGKILL");
+                }
+                catch (error) {
+                    if (!missingProcess(error))
+                        throw error;
+                }
+            }
+        }
+        for (let attempt = 0; attempt < 20 && exactTrackedProcessesRemain(tracked, scan()); attempt += 1)
+            await delay(100);
+        remaining = scan();
+        if (exactTrackedProcessesRemain(tracked, remaining))
+            throw new Error("Managed Preview exact process group did not terminate");
+    },
+};
+async function waitForManagedTarget(exposure, manager, controller, options) {
+    const deadline = Date.now() + options.startupTimeoutMs;
+    while (Date.now() < deadline) {
+        if (!await exactManagerIsRunning(controller, manager))
+            throw new Error("Managed Preview command exited before opening its port");
+        const target = await probePreviewTarget(exposure.targetPort, { timeoutMs: Math.min(250, options.pollIntervalMs) });
+        if (target) {
+            const process = findPreviewTargetProcess(target.host, exposure.targetPort);
+            if (globalThis.process.platform === "linux" && !process) {
+                throw new Error(`Preview port ${exposure.targetPort} is not bound exclusively to ${target.host}`);
+            }
+            if (process && !await controller.ownsTarget(manager, process.pid)) {
+                throw new Error(`Preview port ${exposure.targetPort} is owned by a different process`);
+            }
+            return { host: target.host, process };
+        }
+        await delay(options.pollIntervalMs);
+    }
+    throw new Error(`Managed Preview command did not open loopback port ${exposure.targetPort} within ${options.startupTimeoutMs}ms`);
+}
+function systemdAvailable() {
+    if (process.env.NODE_ENV === "test" || process.platform !== "linux" || !existsSync("/run/systemd/system"))
+        return false;
+    try {
+        return spawnSync("systemd-run", ["--version"], { stdio: "ignore", timeout: 2_000 }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function previewShell() {
+    if (process.platform === "win32")
+        return { command: process.env.ComSpec ?? "cmd.exe", args: (command) => ["/d", "/s", "/c", command] };
+    const command = process.env.SHELL && existsSync(process.env.SHELL) ? process.env.SHELL : existsSync("/bin/bash") ? "/bin/bash" : "/bin/sh";
+    return { command, args: (value) => basename(command).includes("bash") ? ["-lc", value] : ["-c", value] };
+}
+function previewEnvironment(port, ownerToken) {
+    const environment = {};
+    for (const key of ["PATH", "HOME", "USER", "LOGNAME", "SHELL", "LANG", "LC_ALL", "TMPDIR", "TEMP", "TMP"]) {
+        if (process.env[key] !== undefined)
+            environment[key] = process.env[key];
+    }
+    environment.PIBO_PREVIEW_HOST = "127.0.0.1";
+    environment.PIBO_PREVIEW_PORT = String(port);
+    environment.HOST = "127.0.0.1";
+    environment.PORT = String(port);
+    if (ownerToken)
+        environment[PREVIEW_OWNER_ENV] = ownerToken;
+    return environment;
+}
+function systemdEnvironment(port) {
+    return Object.entries(previewEnvironment(port)).flatMap(([key, value]) => value === undefined ? [] : [`--setenv=${key}=${value}`]);
+}
+async function processGroupId(pid) {
+    try {
+        const { stdout } = await execFileAsync("ps", ["-o", "pgid=", "-p", String(pid)], { timeout: 5_000 });
+        const value = Number.parseInt(stdout.trim(), 10);
+        return Number.isInteger(value) && value > 0 ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function processOwnerToken(pid) {
+    if (process.platform !== "linux")
+        return undefined;
+    try {
+        const prefix = `${PREVIEW_OWNER_ENV}=`;
+        return readFileSync(`/proc/${pid}/environ`, "utf8")
+            .split("\0")
+            .find((entry) => entry.startsWith(prefix))
+            ?.slice(prefix.length);
+    }
+    catch {
+        return undefined;
+    }
+}
+function ownedLinuxProcesses(identity) {
+    if (process.platform !== "linux" || identity.kind !== "process")
+        return [];
+    let entries;
+    try {
+        entries = readdirSync("/proc");
+    }
+    catch {
+        return [];
+    }
+    const owned = [];
+    for (const entry of entries) {
+        if (!/^\d+$/.test(entry))
+            continue;
+        const pid = Number(entry);
+        if (processOwnerToken(pid) !== identity.id)
+            continue;
+        try {
+            const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+            const commandEnd = stat.lastIndexOf(") ");
+            if (commandEnd < 0)
+                continue;
+            const fields = stat.slice(commandEnd + 2).trim().split(/\s+/);
+            const processGroupId = Number.parseInt(fields[2] ?? "", 10);
+            const processStartTicks = fields[19];
+            if (Number.isInteger(processGroupId) && processGroupId > 0 && processStartTicks) {
+                owned.push({ pid, processGroupId, processStartTicks });
+            }
+        }
+        catch { }
+    }
+    return owned;
+}
+function exactTrackedProcessesRemain(tracked, current) {
+    if (current.length > 0)
+        return true;
+    for (const owned of tracked.values()) {
+        if (previewProcessStartTicks(owned.pid) === owned.processStartTicks)
+            return true;
+    }
+    return false;
+}
+function verifiedOwnedProcessGroups(identity, candidates) {
+    const groups = new Set();
+    for (const owned of candidates) {
+        if (previewProcessStartTicks(owned.pid) !== owned.processStartTicks)
+            continue;
+        if (processOwnerToken(owned.pid) !== identity.id)
+            continue;
+        groups.add(owned.processGroupId);
+    }
+    return groups;
+}
+function exactLinuxManagerIsRunning(identity) {
+    if (process.platform !== "linux" ||
+        identity.kind !== "process" ||
+        !identity.pid ||
+        !identity.processStartTicks)
+        return false;
+    return previewProcessStartTicks(identity.pid) === identity.processStartTicks &&
+        processOwnerToken(identity.pid) === identity.id;
+}
+function exactManagerIsRunning(controller, identity) {
+    return controller.isManagerRunning?.(identity) ?? controller.isRunning(identity);
+}
+function sameManagerOwner(first, second) {
+    return first.kind === second.kind && first.id === second.id;
+}
+function managedGenerationMatches(exposure, generation, manager) {
+    const current = managerIdentity(exposure);
+    return exposure.serverGeneration === generation && Boolean(current && sameManagerOwner(current, manager));
+}
+async function stopManagedOwner(controller, identity) {
+    try {
+        await controller.stop(identity);
+        return !await controller.isRunning(identity);
+    }
+    catch {
+        return false;
+    }
+}
+function missingProcess(error) {
+    return error instanceof Error && "code" in error && error.code === "ESRCH";
+}
+function managedPreviewError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 500);
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}