@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/terminal/socket.js

@@ -0,0 +1,159 @@
+import { WebSocket, WebSocketServer } from "ws";
+import { loadProjects } from "../projects/index.js";
+import { MAX_BUFFER, state, size, send, broadcast, flow, } from "./session-state.js";
+import { accessAllowed, protectLanSockets } from "../access/index.js";
+export function attachTerminalServer(server, handlers = { allowed: accessAllowed, projects: loadProjects }) {
+    if (state.servers.has(server))
+        return;
+    state.servers.add(server);
+    const sockets = new WebSocketServer({
+        noServer: true,
+        maxPayload: 64 * 1024,
+        perMessageDeflate: false,
+    });
+    const alive = new WeakSet();
+    const unprotect = protectLanSockets(server, sockets, handlers.allowed);
+    const heartbeat = setInterval(() => {
+        for (const client of sockets.clients) {
+            if (!alive.has(client)) {
+                client.terminate();
+                continue;
+            }
+            alive.delete(client);
+            client.ping();
+        }
+    }, 30000);
+    heartbeat.unref();
+    let disposed = false;
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        clearInterval(heartbeat);
+        unprotect();
+        for (const client of sockets.clients)
+            client.terminate();
+        sockets.close();
+        state.servers.delete(server);
+        server.off("close", dispose);
+        server.off("upgrade", upgrade);
+    };
+    const upgrade = (req, socket, head) => {
+        if (socket.writableEnded || socket.destroyed)
+            return;
+        let url;
+        try {
+            url = new URL(req.url ?? "/", "http://localhost");
+        }
+        catch {
+            socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+            return;
+        }
+        if (url.pathname !== "/api/terminal/socket")
+            return; // Leave Vite HMR alone.
+        if (!handlers.allowed(req, true, url.searchParams.get("token") ?? undefined)) {
+            socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+            return;
+        }
+        const session = state.sessions.get(url.searchParams.get("session") ?? "");
+        if (!session) {
+            socket.end("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+            return;
+        }
+        void handlers
+            .projects()
+            .then((projects) => {
+            if (!projects.some((project) => project.id === session.info.projectId) ||
+                session.disposed) {
+                socket.end("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+                return;
+            }
+            sockets.handleUpgrade(req, socket, head, (client) => {
+                sockets.emit("connection", client, req);
+                alive.add(client);
+                client.on("pong", () => alive.add(client));
+                client.on("error", () => client.terminate());
+                connectTerminalPeer(session, client);
+            });
+        })
+            .catch(() => socket.destroy());
+    };
+    server.on("upgrade", upgrade);
+    server.once("close", dispose);
+    return dispose;
+}
+function screenSnapshot(session, client) {
+    session.screen.write("", () => {
+        if (session.disposed || client.readyState !== WebSocket.OPEN)
+            return;
+        send(client, {
+            type: "snapshot",
+            session: { ...session.info },
+            data: session.serialize.serialize() + session.mouseEncoding.serialize(),
+        });
+        session.clients.add(client);
+    });
+}
+export function connectTerminalPeer(session, client) {
+    client.on("close", () => {
+        session.clients.delete(client);
+        session.pending.delete(client);
+        flow(session);
+    });
+    screenSnapshot(session, client);
+    client.on("message", (raw, binary) => {
+        try {
+            if (binary)
+                throw new Error("Ожидается JSON");
+            const message = JSON.parse(raw.toString());
+            if (message.type === "input") {
+                if (session.info.status !== "running" ||
+                    typeof message.data !== "string" ||
+                    message.data.length > 32768 ||
+                    (message.encoding !== undefined && message.encoding !== "binary") ||
+                    (message.encoding === "binary" && /[^\x00-\xff]/.test(message.data))) {
+                    throw new Error("Ввод недоступен");
+                }
+                session.pty.write(message.encoding === "binary" ? Buffer.from(message.data, "latin1") : message.data);
+            }
+            else if (message.type === "ack") {
+                if (!Number.isInteger(message.length) || message.length < 1 || message.length > MAX_BUFFER)
+                    throw new Error("Некорректное подтверждение вывода");
+                session.pending.set(client, Math.max(0, (session.pending.get(client) ?? 0) - message.length));
+                flow(session);
+            }
+            else if (message.type === "resize") {
+                const dimensions = size(message.cols, message.rows);
+                // Wait for output queued before this resize to be parsed first.
+                session.screen.write("", () => {
+                    if (session.disposed)
+                        return;
+                    session.screen.resize(dimensions.cols, dimensions.rows);
+                    try {
+                        if (session.info.status === "running")
+                            session.pty.resize(dimensions.cols, dimensions.rows);
+                    }
+                    catch {
+                        return; /* The process may have just exited. */
+                    }
+                    Object.assign(session.info, dimensions);
+                    broadcast(session, { type: "status", session: { ...session.info } });
+                });
+            }
+            else
+                throw new Error("Неизвестное сообщение");
+        }
+        catch (error) {
+            send(client, {
+                type: "error",
+                message: error instanceof Error ? error.message : "Ошибка терминала",
+            });
+        }
+    });
+}
+export function subscribeTerminalPeer(projectId, sessionId, client) {
+    const session = state.sessions.get(sessionId);
+    if (!session || session.disposed || session.info.projectId !== projectId)
+        throw new Error("Терминал не найден");
+    connectTerminalPeer(session, client);
+}

package/packages/server/modules/terminal/terminal-activity.js

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+import { os } from "../../../core/modules/os/index.js";
+export const readTerminalProcesses = () => os.processes.snapshot();
+export function terminalActivity(info, processes) {
+    if (info.status === "exited")
+        return { state: "idle", processes: [], confirmation: "" };
+    const family = new Set([info.pid]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const row of processes ?? [])
+            if (family.has(row.parent) && !family.has(row.pid)) {
+                family.add(row.pid);
+                changed = true;
+            }
+    }
+    const rows = (processes ?? []).filter((row) => family.has(row.pid) && row.state !== "Z");
+    const root = rows.find((row) => row.pid === info.pid);
+    // Git's bin\bash.exe starts the real shell as a child of the same name. That chain is the
+    // shell itself, not a command running in it.
+    const launcher = new Set([info.pid]);
+    if (os.platform === "win32" && root)
+        for (let found = true; found;) {
+            found = false;
+            for (const row of rows)
+                if (!launcher.has(row.pid) && launcher.has(row.parent) && row.name === root.name) {
+                    launcher.add(row.pid);
+                    found = true;
+                }
+        }
+    const children = rows.filter((row) => !launcher.has(row.pid));
+    const shell = root &&
+        ["bash", "sh", "zsh", "fish", "dash", "ksh", "powershell", "pwsh", "cmd"].includes(root.name);
+    const state = !root
+        ? "unknown"
+        : children.length || info.commandId || info.program !== "shell" || !shell || root.state === "R"
+            ? "busy"
+            : (root.foreground === null || root.foreground === root.group) && root.state === "S"
+                ? "idle"
+                : "unknown";
+    const work = children.length ? children : root ? [root] : [];
+    const confirmation = createHash("sha256")
+        .update(JSON.stringify({
+        id: info.id,
+        state,
+        processes: rows
+            .map((row) => [row.pid, row.started, row.name])
+            .sort((a, b) => Number(a[0]) - Number(b[0])),
+    }))
+        .digest("hex");
+    return {
+        state,
+        processes: state === "idle" ? [] : work.map((row) => ({ pid: row.pid, name: row.name })),
+        confirmation,
+    };
+}

package/packages/server/modules/terminal/terminal-file.js

@@ -0,0 +1,32 @@
+import { os } from "../../../core/modules/os/index.js";
+import { HttpError } from "../http/index.js";
+import { containerToHost, resolveTerminalPath } from "./link-files.js";
+import { state } from "./session-state.js";
+/** Resolves a path printed in a terminal against the project, container or shell directory. */
+export async function resolveTerminalFile(project, id, path) {
+    const session = state.sessions.get(id);
+    if (!session || session.info.projectId !== project.id)
+        throw new HttpError(404, "Терминал не найден");
+    if (session.info.docker)
+        throw new HttpError(409, "Пути Docker-терминала не сопоставлены с файлами хоста");
+    const workspace = session.info.devcontainer?.workspace;
+    if (workspace)
+        return resolveTerminalPath(containerToHost(path, workspace, project.path), project.path, project.path);
+    const resolve = async () => {
+        const cwd = session.info.status === "running"
+            ? await os.processes.workingDirectories(session.info.pid, project.path)
+            : project.path;
+        return resolveTerminalPath(path, project.path, cwd);
+    };
+    try {
+        return await resolve();
+    }
+    catch (error) {
+        // A reading of the shell's directory is occasionally missed on a busy Windows machine (seen
+        // once in 80 runs, correct moments later); asking again settles it.
+        if (os.platform !== "win32" || error.status !== 404)
+            throw error;
+        await new Promise((done) => setTimeout(done, 400));
+        return resolve();
+    }
+}

package/packages/server/modules/terminal/terminal-mouse.js

@@ -0,0 +1,29 @@
+/** SerializeAddon saves tracking but omits the mouse report encoding. */
+export function trackMouseEncoding(terminal) {
+    let encoding = "default";
+    for (const final of ["h", "l"]) {
+        terminal.parser.registerCsiHandler({ prefix: "?", final }, (params) => {
+            for (const param of params) {
+                if (param === 1006 || param === 1016)
+                    encoding = final === "l" ? "default" : param === 1006 ? "sgr" : "pixels";
+            }
+            return false; // Let xterm apply the same modes normally.
+        });
+    }
+    terminal.parser.registerEscHandler({ final: "c" }, () => {
+        encoding = "default";
+        return false;
+    });
+    // Also discover the mode of sessions retained across a Vite server reload.
+    // DECRQM uses public parser/onData APIs and does not change the screen.
+    const probe = terminal.onData((data) => {
+        if (data === "\x1b[?1006;1$y")
+            encoding = "sgr";
+        if (data === "\x1b[?1016;1$y")
+            encoding = "pixels";
+    });
+    terminal.write("\x1b[?1006$p\x1b[?1016$p", () => probe.dispose());
+    return {
+        serialize: () => encoding === "sgr" ? "\x1b[?1006h" : encoding === "pixels" ? "\x1b[?1016h" : "",
+    };
+}

package/packages/server/modules/terminal/terminal.js

@@ -0,0 +1,308 @@
+import { environmentPorts, stopEnvironmentContainerSync, environmentLaunch, stopEnvironmentContainer, } from "../environments/index.js";
+import { readTerminalProcesses, terminalActivity } from "./terminal-activity.js";
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import { os, bashShellLaunch } from "../../../core/modules/os/index.js";
+import { terminateProcessTree } from "./terminate.js";
+import { saveDroppedFile } from "./drop-files.js";
+import { scenarioDirectory } from "./scenario-folder.js";
+import { HttpError } from "../http/index.js";
+import { devcontainerLaunch } from "../devcontainer/index.js";
+import { spawn } from "node-pty";
+import headless from "@xterm/headless";
+import serialization from "@xterm/addon-serialize";
+import { trackMouseEncoding } from "./terminal-mouse.js";
+import { MAX_SESSIONS, state, size, broadcast, flow, terminalSessionsChanged, } from "./session-state.js";
+const { Terminal } = headless;
+const { SerializeAddon } = serialization;
+export function listTerminalSessions(projectId) {
+    const processes = readTerminalProcesses();
+    return [...state.sessions.values()]
+        .filter((session) => projectId === undefined || session.info.projectId === projectId)
+        .map((session) => ({
+        ...session.info,
+        activity: terminalActivity(session.info, processes),
+    }));
+}
+export function renameTerminalSession(projectId, id, title) {
+    const session = state.sessions.get(id);
+    if (!session || session.info.projectId !== projectId)
+        throw new Error("Терминал не найден");
+    session.info.customTitle = title;
+    broadcast(session, { type: "status", session: { ...session.info } });
+    return { ...session.info };
+}
+export function terminalSessionSnapshot(projectId, id) {
+    const session = state.sessions.get(id);
+    if (!session || session.info.projectId !== projectId)
+        return;
+    return {
+        ...session.info,
+        activity: terminalActivity(session.info, readTerminalProcesses()),
+    };
+}
+/** Текст экрана и прокрутки сессии: последние `lines` непустых строк (без ANSI-разметки). */
+export function terminalSessionText(projectId, id, lines = 200) {
+    const session = state.sessions.get(id);
+    if (!session || session.info.projectId !== projectId)
+        throw new Error("Терминал не найден");
+    const buffer = session.screen.buffer.active;
+    const rows = [];
+    for (let index = 0; index < buffer.length; index++) {
+        const line = buffer.getLine(index);
+        if (!line)
+            continue;
+        const text = line.translateToString(true);
+        // A wrapped row continues the previous logical line.
+        if (line.isWrapped && rows.length)
+            rows[rows.length - 1] += text;
+        else
+            rows.push(text);
+    }
+    while (rows.length && !rows[rows.length - 1].trim())
+        rows.pop();
+    const limit = Math.max(1, Math.min(2000, Math.floor(lines) || 200));
+    return {
+        text: rows.slice(-limit).join("\n"),
+        totalLines: rows.length,
+        truncated: rows.length > limit,
+    };
+}
+function terminate(session, immediate = false) {
+    if (session.info.status !== "running")
+        return;
+    if (session.info.docker?.kind === "environment") {
+        const { context, containerId } = session.info.docker;
+        if (immediate)
+            stopEnvironmentContainerSync(context, containerId);
+        else
+            void stopEnvironmentContainer(context, containerId, true);
+    }
+    terminateProcessTree(session.pty, immediate);
+}
+export function stopTerminalSession(projectId, id) {
+    const session = state.sessions.get(id);
+    if (!session || session.info.projectId !== projectId)
+        throw new Error("Терминал не найден");
+    if (session.info.status === "exited" || session.info.stopRequested)
+        return;
+    session.info.stopRequested = true;
+    broadcast(session, { type: "status", session: { ...session.info } });
+    terminate(session);
+}
+export async function uploadTerminalFile(projectId, id, req, name) {
+    const session = state.sessions.get(id);
+    if (!session || session.info.projectId !== projectId)
+        throw new HttpError(404, "Терминал не найден");
+    if (session.info.docker || session.info.devcontainer)
+        throw new HttpError(409, "Загрузка файлов в Docker-терминал не поддерживается");
+    const available = () => !session.disposed && session.info.status === "running" && !session.info.stopRequested;
+    if (!available())
+        throw new HttpError(409, "Терминал больше не принимает файлы");
+    return saveDroppedFile(req, name, available, (directory) => {
+        (session.droppedDirectories ??= new Set()).add(directory);
+    });
+}
+export function closeTerminalSession(projectId, id) {
+    const session = state.sessions.get(id);
+    if (!session || session.info.projectId !== projectId)
+        throw new Error("Терминал не найден");
+    terminate(session);
+    session.disposed = true;
+    session.controlExitSubscription?.dispose();
+    for (const client of session.clients)
+        client.close(1000, "Session closed");
+    session.clients.clear();
+    session.screen.dispose();
+    state.sessions.delete(id);
+    terminalSessionsChanged(projectId);
+    for (const directory of session.droppedDirectories ?? [])
+        rmSync(directory, { recursive: true, force: true });
+}
+export function closeProjectTerminals(projectId) {
+    for (const session of listTerminalSessions(projectId))
+        closeTerminalSession(projectId, session.id);
+}
+/**
+ * Programs come from the agent registry through this lookup, which composition sets at startup:
+ * importing the registry here would close a module cycle through events and processes.
+ */
+let findProgram = () => undefined;
+/** Wires terminal programs to the agent registry; called by the composition, not by modules. */
+export function configureTerminalPrograms(lookup) {
+    findProgram = lookup;
+}
+/** The descriptor of a registered agent's terminal; looked up per call, as the registry fills late. */
+function agentTerminal(program) {
+    const terminal = findProgram(program);
+    if (!terminal)
+        throw new Error("Неизвестная программа");
+    return terminal;
+}
+export function createTerminalSession(project, input, observer, replacingId, launch) {
+    const previous = replacingId ? state.sessions.get(replacingId) : undefined;
+    if (replacingId && (!previous || previous.info.projectId !== project.id))
+        throw new Error("Терминал не найден");
+    if (previous && previous.info.status !== "exited")
+        throw new Error("Сначала завершите сессию");
+    if (!previous && state.sessions.size >= MAX_SESSIONS)
+        throw new Error("Лимит терминалов: закройте ненужные сессии");
+    const program = (input.program ?? "shell");
+    // `shell` is built in; every other program comes from the agent registry, which fills at startup.
+    const terminal = program === "shell" ? undefined : agentTerminal(program);
+    const command = input.commandId === undefined
+        ? undefined
+        : project.commands.find((item) => item.id === input.commandId);
+    if (input.commandId !== undefined && !command)
+        throw new Error("Команда не найдена");
+    // The scenario's folder applies to a run on this machine; Docker and Dev Container runs use their own workdir.
+    const folder = command?.cwd && !launch && !project.environment
+        ? scenarioDirectory(project.path, command.cwd)
+        : project.path;
+    const dimensions = size(input.cols ?? previous?.info.cols ?? 80, input.rows ?? previous?.info.rows ?? 24);
+    const env = Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined));
+    delete env.CI;
+    delete env.FORCE_COLOR;
+    delete env.NO_COLOR;
+    if (launch?.docker) {
+        for (const key of Object.keys(env))
+            if (/^DOCKER_(HOST|CONTEXT|TLS_VERIFY|CERT_PATH|API_VERSION)$/.test(key))
+                delete env[key];
+    }
+    env.TERM = "xterm-256color";
+    env.COLORTERM = "truecolor";
+    // An agent's CLI may install under another name than its program; its descriptor says which.
+    const shell = command
+        ? { kind: "command", command: command.cmd }
+        : program === "shell"
+            ? { kind: "interactive" }
+            : { kind: "program", executable: terminal.executable };
+    // A config the user trusted in its current form replaces the restricted environment.
+    const trusted = launch ? undefined : devcontainerLaunch(project, shell);
+    if (trusted)
+        launch = trusted;
+    else if (project.environment) {
+        if (launch)
+            throw new HttpError(403, "В изолированном проекте запрещены произвольные Docker/Compose-действия");
+        const invocation = bashShellLaunch(shell, true);
+        launch = environmentLaunch(project, [invocation.file, ...invocation.args]);
+        for (const key of Object.keys(env))
+            if (/^DOCKER_(HOST|CONTEXT|TLS_VERIFY|CERT_PATH|API_VERSION)$/.test(key))
+                delete env[key];
+    }
+    const screen = new Terminal({ ...dimensions, scrollback: 5000, allowProposedApi: true });
+    const serialize = new SerializeAddon();
+    screen.loadAddon(serialize);
+    const mouseEncoding = trackMouseEncoding(screen);
+    let child;
+    try {
+        const invocation = launch ?? os.shellLaunch(shell);
+        const command = os.tools.ptyCommand(invocation.file, invocation.args);
+        child = spawn(command.file, command.args, {
+            name: "xterm-256color",
+            ...dimensions,
+            cwd: folder,
+            env,
+        });
+        os.processes.trackConsole(child.pid);
+    }
+    catch (error) {
+        screen.dispose();
+        throw error;
+    }
+    const session = {
+        info: {
+            id: randomUUID(),
+            projectId: project.id,
+            program,
+            docker: launch?.docker,
+            devcontainer: launch?.workspace ? { workspace: launch.workspace } : undefined,
+            commandId: command?.id,
+            customTitle: previous?.info.customTitle,
+            title: launch?.title ?? command?.name ?? (program === "shell" ? "Shell" : terminal.title),
+            pid: child.pid,
+            ...dimensions,
+            status: "running",
+            exitCode: null,
+            startedAt: new Date().toISOString(),
+        },
+        pty: child,
+        screen,
+        serialize,
+        mouseEncoding,
+        clients: new Set(),
+        pending: new Map(),
+        queued: 0,
+        paused: false,
+        disposed: false,
+    };
+    state.sessions.set(session.info.id, session);
+    if (project.environment?.ports.length && launch?.docker) {
+        const docker = launch.docker;
+        void (async () => {
+            for (let attempt = 0; attempt < 40 && !session.disposed && session.info.status === "running"; attempt++) {
+                try {
+                    const ports = await environmentPorts(docker.context, docker.containerId);
+                    if (ports.length) {
+                        session.info.ports = ports;
+                        broadcast(session, { type: "status", session: { ...session.info } });
+                        return;
+                    }
+                }
+                catch {
+                    /* Docker client is still starting. */
+                }
+                await new Promise((done) => setTimeout(done, 250));
+            }
+        })();
+    }
+    // Parse before publishing, so reconnect snapshots and subsequent output form
+    // one ordered stream, including alternate screen and cursor state.
+    child.onData((data) => {
+        if (session.disposed)
+            return;
+        observer?.output(data);
+        session.queued += data.length;
+        flow(session);
+        screen.write(data, () => {
+            session.queued -= data.length;
+            if (!session.disposed)
+                broadcast(session, { type: "output", data });
+        });
+    });
+    child.onExit(({ exitCode }) => {
+        os.processes.untrackConsole(child.pid);
+        session.info.status = "exited";
+        session.info.exitCode = exitCode;
+        observer?.exit(exitCode);
+        if (!session.disposed)
+            screen.write("", () => broadcast(session, { type: "status", session: { ...session.info } }));
+    });
+    if (!state.hooksBound) {
+        state.hooksBound = true;
+        const stopAll = () => {
+            for (const item of state.sessions.values())
+                terminate(item, true);
+        };
+        process.on("exit", stopAll);
+        process.on("SIGINT", () => {
+            stopAll();
+            process.exit(0);
+        });
+        process.on("SIGTERM", () => {
+            stopAll();
+            process.exit(0);
+        });
+    }
+    if (previous) {
+        const ordered = [...state.sessions.entries()]
+            .filter(([id]) => id !== session.info.id)
+            .map(([id, item]) => id === previous.info.id ? [session.info.id, session] : [id, item]);
+        closeTerminalSession(project.id, previous.info.id);
+        state.sessions.clear();
+        for (const [id, item] of ordered)
+            state.sessions.set(id, item);
+    }
+    terminalSessionsChanged(project.id);
+    return { ...session.info };
+}

package/packages/server/modules/terminal/terminate.js

@@ -0,0 +1,68 @@
+import { os } from "../../../core/modules/os/index.js";
+// Only the POSIX branch below uses these: it must list the family before the shell exits.
+const descendants = (pid) => os.processes.descendantsSync(pid);
+/** Ends a PTY and everything its shell started: SIGTERM first, SIGKILL after a grace period. */
+export function terminateProcessTree(pty, immediate) {
+    if (os.platform === "win32") {
+        // pty.kill() is not used here: node-pty's version attaches to the console of that pid and
+        // kills everything listed, which hits unrelated programs once the pid has been reused.
+        // Ending the tree closes the pseudo console on its own.
+        const killRoot = () => os.tools.killAgentTree(pty.pid);
+        // While the process exits there is no time to look around: the root tree is all we can end.
+        if (immediate)
+            return killRoot();
+        // MSYS programs are not Win32 children of their shell; the tracked console lists them, but
+        // only a young listing is trusted: an old one could name pids that have been reused.
+        const rows = os.processes.recent(2500) ?? [];
+        const family = new Set([pty.pid]);
+        for (let grew = true; grew;) {
+            grew = false;
+            for (const row of rows)
+                if (family.has(row.parent) && !family.has(row.pid))
+                    grew = !!family.add(row.pid);
+        }
+        for (const pid of family)
+            if (pid !== pty.pid)
+                os.tools.killAgentTree(pid);
+        killRoot();
+        return;
+    }
+    const family = descendants(pty.pid);
+    for (const entry of family.reverse()) {
+        try {
+            os.processes.signal(entry.pid, immediate ? "SIGKILL" : "SIGTERM");
+        }
+        catch {
+            /* Already exited. */
+        }
+    }
+    try {
+        pty.kill(immediate ? "SIGKILL" : "SIGTERM");
+    }
+    catch {
+        /* Already exited. */
+    }
+    if (immediate)
+        return;
+    const timer = setTimeout(async () => {
+        for (const entry of family) {
+            try {
+                if ((await os.processes.identity(entry.pid)) === entry.started) {
+                    for (const child of descendants(entry.pid).reverse()) {
+                        try {
+                            os.processes.signal(child.pid, "SIGKILL");
+                        }
+                        catch {
+                            /* Already exited. */
+                        }
+                    }
+                    os.processes.signal(entry.pid, "SIGKILL");
+                }
+            }
+            catch {
+                /* Already exited; never kill a reused pid. */
+            }
+        }
+    }, 1500);
+    timer.unref();
+}