@pentoshi/clai 4.9.0 → 4.10.0

package/dist/session-runtime/host.js

@@ -0,0 +1,758 @@
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { chmod, rm } from "node:fs/promises";
+import { createServer } from "node:net";
+import { processIdentityTracker } from "../os/process-identity.js";
+import { processAlive } from "../os/process-tree.js";
+import { startPtyProcess } from "../interactive-session/transport-node-pty.js";
+import { RUNTIME_CHILD_ENV, RUNTIME_HOST_ENV, RUNTIME_SESSION_ENV, RUNTIME_SOCKET_ENV, RUNTIME_TOKEN_ENV, decodeRuntimeHostPayload, } from "./launch.js";
+import { isRuntimeSocketPath, runtimeSocketPath } from "./paths.js";
+import { JsonFrameChannel, readFirstFrame, sendFrame, } from "./protocol.js";
+import { TerminalReplayBuffer } from "./replay-buffer.js";
+import { createRuntimeToken, deleteRuntimeMetadata, reapStaleRuntimeLock, tryAcquireRuntimeLease, writeRuntimeMetadata, } from "./store.js";
+import { RUNTIME_PROTOCOL_VERSION, } from "./types.js";
+const CLIENT_BACKPRESSURE_BYTES = 1024 * 1024;
+const METADATA_DEBOUNCE_MS = 50;
+const FINAL_OUTPUT_DRAIN_MS = 3_000;
+const FORCE_STOP_MS = 8_000;
+const ATTACH_RESET = Buffer.from("\u001b[?1049h\u001b[2J\u001b[H", "utf8");
+function tokensEqual(candidate, expected) {
+    if (!/^[a-f0-9]{64}$/i.test(candidate) || !/^[a-f0-9]{64}$/i.test(expected)) {
+        return false;
+    }
+    return timingSafeEqual(Buffer.from(candidate, "hex"), Buffer.from(expected, "hex"));
+}
+function errorText(error) {
+    const value = error instanceof Error ? error.message : String(error);
+    return value.replace(/\s+/g, " ").trim().slice(0, 300) || "runtime host failed";
+}
+function authFrame(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const frame = value;
+    if (frame.version !== RUNTIME_PROTOCOL_VERSION ||
+        frame.type !== "auth" ||
+        !["probe", "client-control", "client-terminal", "child"].includes(String(frame.role)) ||
+        typeof frame.token !== "string") {
+        return undefined;
+    }
+    return frame;
+}
+function dimensionsOf(value) {
+    if (value.type !== "resize")
+        return undefined;
+    const columns = Math.floor(value.columns);
+    const rows = Math.floor(value.rows);
+    if (columns < 20 || columns > 1_000 || rows < 5 || rows > 500) {
+        return undefined;
+    }
+    return { columns, rows };
+}
+function clientFrame(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const frame = value;
+    if (frame.type === "ping" || frame.type === "detach") {
+        return frame;
+    }
+    if (frame.type === "resize" &&
+        typeof frame.columns === "number" &&
+        typeof frame.rows === "number") {
+        return frame;
+    }
+    return undefined;
+}
+function childFrame(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const frame = value;
+    if (frame.type === "minimise")
+        return frame;
+    if (frame.type === "exiting" &&
+        typeof frame.exitCode === "number" &&
+        Number.isSafeInteger(frame.exitCode)) {
+        return frame;
+    }
+    if (frame.type === "switch" &&
+        typeof frame.sessionId === "string" &&
+        typeof frame.closeCurrent === "boolean") {
+        return frame;
+    }
+    if (frame.type === "status" &&
+        typeof frame.sessionId === "string" &&
+        frame.sessionId.length <= 256 &&
+        typeof frame.cwd === "string" &&
+        frame.cwd.length <= 4096 &&
+        typeof frame.busy === "boolean" &&
+        (frame.title === undefined ||
+            (typeof frame.title === "string" && frame.title.length <= 256))) {
+        return frame;
+    }
+    return undefined;
+}
+function listen(server, path) {
+    return new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(path);
+    });
+}
+function closeServer(server) {
+    if (!server?.listening)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(finish, 1_000);
+        timer.unref?.();
+        server.close(finish);
+    });
+}
+export class SessionRuntimeHost {
+    payload;
+    token = createRuntimeToken();
+    replay = new TerminalReplayBuffer();
+    startedAt = new Date().toISOString();
+    sessionId;
+    cwd;
+    socketPath;
+    title;
+    busy = true;
+    attached = false;
+    phase = "starting";
+    error;
+    lease;
+    server;
+    connections = new Set();
+    transport;
+    client;
+    childSocket;
+    childChannel;
+    idleTimer;
+    forceTimer;
+    livenessTimer;
+    livenessMisses = 0;
+    expectedExitCode;
+    metadataTimer;
+    metadataDirty = false;
+    outputPausedFor;
+    outputDrainHandler;
+    metadataWrites = Promise.resolve();
+    inputWrites = Promise.resolve();
+    statusWrites = Promise.resolve();
+    closing = false;
+    cleaning = false;
+    exitOutcome;
+    resolveExit;
+    exitPromise = new Promise((resolve) => {
+        this.resolveExit = resolve;
+    });
+    signalHandlers = new Map();
+    constructor(payload) {
+        this.payload = payload;
+        this.sessionId = payload.sessionId;
+        this.cwd = payload.cwd;
+        this.socketPath = runtimeSocketPath(payload.sessionId);
+    }
+    async run() {
+        this.lease = await tryAcquireRuntimeLease(this.sessionId);
+        if (!this.lease && (await reapStaleRuntimeLock(this.sessionId))) {
+            this.lease = await tryAcquireRuntimeLease(this.sessionId);
+        }
+        if (!this.lease)
+            return;
+        try {
+            await this.startServer();
+            await this.writeMetadataNow();
+            this.installSignals();
+            await this.startChild();
+            this.phase = "running";
+            this.queueMetadata();
+            const outcome = await this.exitPromise;
+            this.exitOutcome = outcome;
+            await this.flushTerminalOutput();
+            this.sendToClient({
+                type: "exit",
+                exitCode: outcome.exitCode ?? 1,
+                ...(outcome.signal ? { signal: outcome.signal } : {}),
+            });
+            await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+        catch (error) {
+            this.phase = "failed";
+            this.error = errorText(error);
+            await this.writeMetadataNow().catch(() => undefined);
+            await new Promise((resolve) => setTimeout(resolve, 1_500));
+        }
+        finally {
+            await this.cleanup();
+        }
+    }
+    async startServer() {
+        if (process.platform !== "win32" && isRuntimeSocketPath(this.socketPath)) {
+            await rm(this.socketPath, { force: true }).catch(() => undefined);
+        }
+        const server = createServer((socket) => void this.accept(socket));
+        this.server = server;
+        await listen(server, this.socketPath);
+        if (process.platform !== "win32") {
+            await chmod(this.socketPath, 0o600).catch(() => undefined);
+        }
+    }
+    async startChild() {
+        const env = { ...process.env };
+        delete env[RUNTIME_HOST_ENV];
+        env[RUNTIME_CHILD_ENV] = "1";
+        env[RUNTIME_SOCKET_ENV] = this.socketPath;
+        env[RUNTIME_TOKEN_ENV] = this.token;
+        env[RUNTIME_SESSION_ENV] = this.sessionId;
+        const result = await startPtyProcess({
+            file: this.payload.launch.file,
+            args: this.payload.launch.args,
+            cwd: this.payload.cwd,
+            env,
+            dimensions: {
+                columns: this.payload.columns,
+                rows: this.payload.rows,
+            },
+        });
+        this.transport = result.transport;
+        this.transport.onOutput((event) => this.publishOutput(event.bytes));
+        this.transport.onExit((outcome) => {
+            if (this.exitOutcome)
+                return;
+            this.resolveExit?.(outcome);
+        });
+        this.armChildLiveness();
+    }
+    armChildLiveness() {
+        if (this.exitOutcome || !this.transport)
+            return;
+        this.livenessTimer = setTimeout(() => {
+            this.livenessTimer = undefined;
+            const transport = this.transport;
+            if (!transport || this.exitOutcome)
+                return;
+            const expected = transport.identity;
+            const comparison = expected
+                ? processIdentityTracker.compare(transport.pid, expected)
+                : processAlive(transport.pid)
+                    ? "unknown"
+                    : "gone";
+            const provenDead = comparison === "gone" || comparison === "mismatch";
+            this.livenessMisses = provenDead ? this.livenessMisses + 1 : 0;
+            if (this.livenessMisses >= 2) {
+                this.resolveExit?.({
+                    endedAt: Date.now(),
+                    exitCode: this.expectedExitCode ?? 1,
+                });
+                return;
+            }
+            this.armChildLiveness();
+        }, 500);
+        this.livenessTimer.unref?.();
+    }
+    async accept(socket) {
+        this.connections.add(socket);
+        socket.on("error", () => socket.destroy());
+        socket.once("close", () => this.connections.delete(socket));
+        socket.setNoDelay(true);
+        try {
+            const first = await readFirstFrame(socket);
+            const auth = authFrame(first.value);
+            if (!auth || !tokensEqual(auth.token, this.token)) {
+                sendFrame(socket, {
+                    version: RUNTIME_PROTOCOL_VERSION,
+                    type: "error",
+                    message: "authentication failed",
+                });
+                socket.end();
+                return;
+            }
+            if (auth.role === "probe") {
+                this.acknowledge(socket);
+                socket.end();
+                return;
+            }
+            if (auth.role === "client-control") {
+                this.acceptClientControl(socket, auth, first.rest);
+                return;
+            }
+            if (auth.role === "client-terminal") {
+                this.acceptClientTerminal(socket, auth, first.rest);
+                return;
+            }
+            this.acceptChild(socket, first.rest);
+        }
+        catch {
+            socket.destroy();
+        }
+    }
+    acknowledge(socket) {
+        sendFrame(socket, {
+            version: RUNTIME_PROTOCOL_VERSION,
+            type: "ack",
+            sessionId: this.sessionId,
+        });
+    }
+    acceptClientControl(socket, auth, rest) {
+        const clientId = auth.clientId?.trim();
+        if (!clientId || clientId.length > 128) {
+            socket.destroy();
+            return;
+        }
+        if (this.client) {
+            this.disconnectClient("taken-over");
+        }
+        const client = { id: clientId, control: socket };
+        this.client = client;
+        this.acknowledge(socket);
+        client.channel = new JsonFrameChannel(socket, (value) => this.handleClientFrame(client, value), () => socket.destroy(), rest);
+        socket.once("close", () => this.clientClosed(client, socket));
+    }
+    acceptClientTerminal(socket, auth, rest) {
+        const client = this.client;
+        if (!client || !auth.clientId || client.id !== auth.clientId) {
+            socket.destroy();
+            return;
+        }
+        if (client.terminal) {
+            this.releaseOutputBackpressure(client.terminal);
+            client.terminal.destroy();
+        }
+        client.terminal = socket;
+        this.attached = true;
+        this.cancelIdleTimer();
+        this.queueMetadata();
+        this.acknowledge(socket);
+        this.writeToTerminal(socket, ATTACH_RESET);
+        const replay = this.replay.snapshot();
+        if (replay.length > 0)
+            this.writeToTerminal(socket, replay);
+        if (rest.length > 0)
+            this.queueInput(rest);
+        socket.on("data", (bytes) => {
+            if (this.client === client && client.terminal === socket) {
+                this.queueInput(bytes);
+            }
+        });
+        socket.once("close", () => this.clientClosed(client, socket));
+        socket.resume();
+        void this.resize({
+            columns: this.payload.columns,
+            rows: this.payload.rows,
+        });
+    }
+    acceptChild(socket, rest) {
+        this.childChannel?.dispose();
+        this.childSocket?.destroy();
+        this.childSocket = socket;
+        this.acknowledge(socket);
+        this.childChannel = new JsonFrameChannel(socket, (value) => this.handleChildFrame(value), () => socket.destroy(), rest);
+        socket.once("close", () => {
+            if (this.childSocket !== socket)
+                return;
+            this.childChannel?.dispose();
+            this.childChannel = undefined;
+            this.childSocket = undefined;
+        });
+    }
+    handleClientFrame(client, value) {
+        if (this.client !== client)
+            return;
+        const frame = clientFrame(value);
+        if (!frame)
+            return;
+        if (frame.type === "ping") {
+            client.channel?.send({ type: "pong" });
+            return;
+        }
+        if (frame.type === "detach") {
+            this.disconnectClient("requested");
+            return;
+        }
+        const dimensions = dimensionsOf(frame);
+        if (dimensions)
+            void this.resize(dimensions);
+    }
+    handleChildFrame(value) {
+        const frame = childFrame(value);
+        if (!frame)
+            return;
+        if (frame.type === "minimise") {
+            this.disconnectClient("minimise");
+            return;
+        }
+        if (frame.type === "exiting") {
+            this.expectedExitCode = frame.exitCode;
+            return;
+        }
+        if (frame.type === "switch") {
+            const target = frame.sessionId.trim();
+            if (!target || target.length > 256)
+                return;
+            this.sendToClient({ type: "switch", sessionId: target });
+            this.closeClientSockets();
+            if (frame.closeCurrent) {
+                setTimeout(() => this.requestGracefulStop(), 80).unref?.();
+            }
+            return;
+        }
+        this.statusWrites = this.statusWrites
+            .then(() => this.applyStatus(frame))
+            .catch(() => undefined);
+    }
+    async applyStatus(frame) {
+        let changed = false;
+        const nextId = frame.sessionId.trim();
+        if (nextId && nextId !== this.sessionId && nextId.length <= 256) {
+            const previousId = this.sessionId;
+            await this.rebind(nextId);
+            changed ||= this.sessionId !== previousId;
+        }
+        const nextCwd = frame.cwd || this.cwd;
+        const nextTitle = frame.title?.trim() || undefined;
+        changed ||=
+            nextCwd !== this.cwd ||
+                nextTitle !== this.title ||
+                frame.busy !== this.busy;
+        if (!changed)
+            return;
+        this.cwd = nextCwd;
+        this.title = nextTitle;
+        this.busy = frame.busy;
+        this.queueMetadata();
+        this.scheduleIdleTimer();
+    }
+    async rebind(nextId) {
+        let nextLease = await tryAcquireRuntimeLease(nextId);
+        if (!nextLease && (await reapStaleRuntimeLock(nextId))) {
+            nextLease = await tryAcquireRuntimeLease(nextId);
+        }
+        if (!nextLease)
+            return;
+        const previousId = this.sessionId;
+        const previousLease = this.lease;
+        this.sessionId = nextId;
+        this.lease = nextLease;
+        await this.writeMetadataNow();
+        await deleteRuntimeMetadata(previousId);
+        await previousLease?.release();
+    }
+    publishOutput(bytes) {
+        this.replay.append(bytes);
+        const terminal = this.client?.terminal;
+        if (terminal)
+            this.writeToTerminal(terminal, bytes);
+    }
+    writeToTerminal(terminal, bytes) {
+        if (!terminal.writable || terminal.destroyed)
+            return;
+        const writable = terminal.write(bytes);
+        if (!writable ||
+            terminal.writableLength >= CLIENT_BACKPRESSURE_BYTES) {
+            this.applyOutputBackpressure(terminal);
+        }
+    }
+    applyOutputBackpressure(terminal) {
+        if (this.outputPausedFor === terminal)
+            return;
+        this.releaseOutputBackpressure();
+        this.outputPausedFor = terminal;
+        this.transport?.pauseOutput();
+        const drain = () => this.releaseOutputBackpressure(terminal);
+        this.outputDrainHandler = drain;
+        terminal.once("drain", drain);
+    }
+    releaseOutputBackpressure(terminal) {
+        if (!this.outputPausedFor)
+            return;
+        if (terminal && this.outputPausedFor !== terminal)
+            return;
+        if (this.outputDrainHandler) {
+            this.outputPausedFor.off("drain", this.outputDrainHandler);
+        }
+        this.outputPausedFor = undefined;
+        this.outputDrainHandler = undefined;
+        this.transport?.resumeOutput();
+    }
+    async flushTerminalOutput() {
+        const deadline = Date.now() + FINAL_OUTPUT_DRAIN_MS;
+        while (Date.now() < deadline) {
+            const paused = this.outputPausedFor;
+            if (paused) {
+                await new Promise((resolve) => {
+                    let settled = false;
+                    const finish = () => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        clearTimeout(timeout);
+                        paused.off("drain", finish);
+                        resolve();
+                    };
+                    const timeout = setTimeout(finish, Math.max(1, Math.min(100, deadline - Date.now())));
+                    timeout.unref?.();
+                    paused.once("drain", finish);
+                });
+                continue;
+            }
+            const remaining = Math.max(1, deadline - Date.now());
+            await Promise.race([
+                this.transport?.waitForOutputDrain?.() ?? Promise.resolve(),
+                new Promise((resolve) => {
+                    const timeout = setTimeout(resolve, remaining);
+                    timeout.unref?.();
+                }),
+            ]);
+            if (!this.outputPausedFor)
+                break;
+        }
+        this.releaseOutputBackpressure();
+        const terminal = this.client?.terminal;
+        if (!terminal ||
+            terminal.destroyed ||
+            terminal.writableEnded ||
+            !terminal.writable)
+            return;
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                resolve();
+            };
+            const timeout = setTimeout(finish, 1_000);
+            timeout.unref?.();
+            terminal.once("close", finish);
+            terminal.end(finish);
+        });
+    }
+    queueInput(bytes) {
+        const copy = Buffer.from(bytes);
+        this.inputWrites = this.inputWrites
+            .then(() => this.transport?.write(copy))
+            .catch(() => undefined);
+    }
+    async resize(dimensions) {
+        await this.transport?.resize?.(dimensions).catch(() => undefined);
+    }
+    clientClosed(client, socket) {
+        if (client.terminal === socket) {
+            client.terminal = undefined;
+            this.releaseOutputBackpressure(socket);
+            if (this.client === client) {
+                this.attached = false;
+                this.queueMetadata();
+                this.scheduleIdleTimer();
+            }
+        }
+        if (client.control === socket)
+            client.channel?.dispose();
+        if (this.client !== client)
+            return;
+        if (!client.control.destroyed || client.terminal)
+            return;
+        this.client = undefined;
+        this.attached = false;
+        this.queueMetadata();
+        this.scheduleIdleTimer();
+    }
+    sendToClient(frame) {
+        this.client?.channel?.send(frame);
+    }
+    disconnectClient(reason) {
+        this.sendToClient({
+            type: "detached",
+            reason,
+            sessionId: this.sessionId,
+        });
+        this.closeClientSockets();
+    }
+    closeClientSockets() {
+        const client = this.client;
+        if (!client)
+            return;
+        this.client = undefined;
+        this.attached = false;
+        this.releaseOutputBackpressure(client.terminal);
+        client.channel?.dispose();
+        client.control.end();
+        setTimeout(() => client.terminal?.end(), 50).unref?.();
+        setTimeout(() => {
+            client.terminal?.destroy();
+            client.control.destroy();
+        }, 250).unref?.();
+        this.queueMetadata();
+        this.scheduleIdleTimer();
+    }
+    scheduleIdleTimer() {
+        this.cancelIdleTimer();
+        if (this.closing || this.attached || this.busy)
+            return;
+        this.idleTimer = setTimeout(() => this.requestGracefulStop(), this.payload.idleTimeoutMs);
+        this.idleTimer.unref?.();
+    }
+    cancelIdleTimer() {
+        if (!this.idleTimer)
+            return;
+        clearTimeout(this.idleTimer);
+        this.idleTimer = undefined;
+    }
+    requestGracefulStop() {
+        if (this.closing)
+            return;
+        this.closing = true;
+        this.phase = "stopping";
+        this.cancelIdleTimer();
+        this.queueMetadata();
+        if (!this.childChannel?.send({ type: "shutdown" })) {
+            void this.transport?.requestTreeTermination("graceful");
+        }
+        this.forceTimer = setTimeout(() => {
+            void this.transport?.requestTreeTermination("forceful");
+        }, FORCE_STOP_MS);
+        this.forceTimer.unref?.();
+    }
+    metadataSnapshot() {
+        const now = new Date().toISOString();
+        const childPid = this.transport?.pid;
+        const childIdentity = this.transport?.identity;
+        return {
+            version: RUNTIME_PROTOCOL_VERSION,
+            sessionId: this.sessionId,
+            hostPid: process.pid,
+            ...(processIdentityTracker.capture(process.pid)
+                ? { hostIdentity: processIdentityTracker.capture(process.pid) }
+                : {}),
+            ...(childPid ? { childPid } : {}),
+            ...(childIdentity ? { childIdentity } : {}),
+            socketPath: this.socketPath,
+            token: this.token,
+            cwd: this.cwd,
+            ...(this.title ? { title: this.title } : {}),
+            startedAt: this.startedAt,
+            updatedAt: now,
+            phase: this.phase,
+            busy: this.busy,
+            attached: this.attached,
+            ...(this.error ? { error: this.error } : {}),
+        };
+    }
+    queueMetadata() {
+        if (this.cleaning || this.phase === "failed")
+            return;
+        this.metadataDirty = true;
+        if (this.metadataTimer)
+            return;
+        this.metadataTimer = setTimeout(() => {
+            this.metadataTimer = undefined;
+            this.flushQueuedMetadata();
+        }, METADATA_DEBOUNCE_MS);
+        this.metadataTimer.unref?.();
+    }
+    flushQueuedMetadata() {
+        if (!this.metadataDirty || this.phase === "failed")
+            return;
+        this.metadataDirty = false;
+        const snapshot = this.metadataSnapshot();
+        this.metadataWrites = this.metadataWrites
+            .then(() => writeRuntimeMetadata(snapshot))
+            .catch(() => undefined);
+    }
+    async writeMetadataNow() {
+        if (this.metadataTimer) {
+            clearTimeout(this.metadataTimer);
+            this.metadataTimer = undefined;
+        }
+        this.metadataDirty = false;
+        const snapshot = this.metadataSnapshot();
+        const write = this.metadataWrites
+            .catch(() => undefined)
+            .then(() => writeRuntimeMetadata(snapshot));
+        this.metadataWrites = write.catch(() => undefined);
+        await write;
+    }
+    installSignals() {
+        for (const signal of ["SIGINT", "SIGTERM"]) {
+            const handler = () => this.requestGracefulStop();
+            this.signalHandlers.set(signal, handler);
+            process.on(signal, handler);
+        }
+        if (process.platform !== "win32") {
+            const handler = () => undefined;
+            this.signalHandlers.set("SIGHUP", handler);
+            process.on("SIGHUP", handler);
+        }
+    }
+    removeSignals() {
+        for (const [signal, handler] of this.signalHandlers) {
+            process.off(signal, handler);
+        }
+        this.signalHandlers.clear();
+    }
+    async cleanup() {
+        if (this.cleaning)
+            return;
+        this.cleaning = true;
+        this.closing = true;
+        this.cancelIdleTimer();
+        if (this.metadataTimer)
+            clearTimeout(this.metadataTimer);
+        this.metadataTimer = undefined;
+        this.metadataDirty = false;
+        if (this.forceTimer)
+            clearTimeout(this.forceTimer);
+        if (this.livenessTimer)
+            clearTimeout(this.livenessTimer);
+        this.releaseOutputBackpressure();
+        this.removeSignals();
+        this.closeClientSockets();
+        this.childChannel?.dispose();
+        this.childSocket?.destroy();
+        for (const socket of this.connections)
+            socket.destroy();
+        this.connections.clear();
+        await closeServer(this.server);
+        if (!this.exitOutcome && this.transport) {
+            await this.transport.requestTreeTermination("forceful").catch(() => undefined);
+        }
+        await this.transport?.dispose().catch(() => undefined);
+        await this.metadataWrites.catch(() => undefined);
+        await deleteRuntimeMetadata(this.sessionId);
+        await this.lease?.release();
+        if (process.platform !== "win32" && isRuntimeSocketPath(this.socketPath)) {
+            await rm(this.socketPath, { force: true }).catch(() => undefined);
+        }
+    }
+}
+export async function runRuntimeHostFromEnvironment() {
+    const encoded = process.env[RUNTIME_HOST_ENV];
+    if (!encoded)
+        return false;
+    delete process.env[RUNTIME_HOST_ENV];
+    const payload = decodeRuntimeHostPayload(encoded);
+    if (!payload)
+        throw new Error("invalid session runtime host payload");
+    await new SessionRuntimeHost(payload).run();
+    return true;
+}
+export function runtimeHostClientId() {
+    return `${process.pid}-${randomUUID()}`;
+}
+//# sourceMappingURL=host.js.map