@sentropic/h2a-runtime 0.91.0 → 0.92.0

package/dist/native-terminal/replay-buffer.js

@@ -0,0 +1,84 @@
+export const NATIVE_TERMINAL_MAX_REPLAY_CHUNKS_PER_SESSION = 65_536;
+// Leaves 8 MiB of the 32 MiB protocol frame for the response envelope and
+// bounded identities, while charging the actual JSON-escaped chunk encoding.
+export const NATIVE_TERMINAL_MAX_REPLAY_WIRE_BYTES_PER_SESSION = 24 * 1024 * 1024;
+export class TerminalReplayBuffer {
+    #maxBytes;
+    #maxChunks;
+    #maxWireBytes;
+    #chunks = [];
+    #head = 0;
+    #bytes = 0;
+    #wireBytes = 0;
+    #latestSeq = 0;
+    constructor(maxBytes, limits = {}) {
+        if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
+            throw new RangeError("maxBytes must be a positive safe integer");
+        }
+        const maxChunks = limits.maxChunks ?? NATIVE_TERMINAL_MAX_REPLAY_CHUNKS_PER_SESSION;
+        const maxWireBytes = limits.maxWireBytes ??
+            NATIVE_TERMINAL_MAX_REPLAY_WIRE_BYTES_PER_SESSION;
+        if (!Number.isSafeInteger(maxChunks) || maxChunks <= 0) {
+            throw new RangeError("maxChunks must be a positive safe integer");
+        }
+        if (!Number.isSafeInteger(maxWireBytes) || maxWireBytes <= 0) {
+            throw new RangeError("maxWireBytes must be a positive safe integer");
+        }
+        this.#maxBytes = maxBytes;
+        this.#maxChunks = maxChunks;
+        this.#maxWireBytes = maxWireBytes;
+    }
+    get latestSeq() {
+        return this.#latestSeq;
+    }
+    append(data) {
+        if (data.length === 0) {
+            throw new RangeError("terminal output chunks must not be empty");
+        }
+        const chunk = Object.freeze({ seq: ++this.#latestSeq, data });
+        const entry = Object.freeze({
+            chunk,
+            bytes: Buffer.byteLength(data, "utf8"),
+            // One byte reserves either the array comma or a conservative bracket.
+            wireBytes: Buffer.byteLength(JSON.stringify(chunk), "utf8") + 1,
+        });
+        this.#chunks.push(entry);
+        this.#bytes += entry.bytes;
+        this.#wireBytes += entry.wireBytes;
+        while ((this.#bytes > this.#maxBytes ||
+            this.#wireBytes > this.#maxWireBytes ||
+            this.#chunks.length - this.#head > this.#maxChunks) &&
+            this.#head < this.#chunks.length) {
+            const evicted = this.#chunks[this.#head++];
+            if (evicted) {
+                this.#bytes -= evicted.bytes;
+                this.#wireBytes -= evicted.wireBytes;
+            }
+        }
+        if (this.#head >= 1_024 && this.#head * 2 >= this.#chunks.length) {
+            this.#chunks.splice(0, this.#head);
+            this.#head = 0;
+        }
+        return chunk;
+    }
+    readAfter(afterSeq) {
+        if (!Number.isSafeInteger(afterSeq) ||
+            afterSeq < 0 ||
+            afterSeq > this.#latestSeq) {
+            throw new RangeError("afterSeq must identify this buffer's history");
+        }
+        const oldestAvailable = this.#chunks[this.#head]?.chunk.seq ?? this.#latestSeq + 1;
+        const gap = afterSeq < oldestAvailable - 1
+            ? Object.freeze({ fromSeq: afterSeq + 1, toSeq: oldestAvailable - 1 })
+            : null;
+        return Object.freeze({
+            chunks: this.#chunks
+                .slice(this.#head)
+                .filter(({ chunk }) => chunk.seq > afterSeq)
+                .map(({ chunk }) => chunk),
+            gap,
+            latestSeq: this.#latestSeq,
+        });
+    }
+}
+//# sourceMappingURL=replay-buffer.js.map

package/dist/native-terminal/replay-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-buffer.js","sourceRoot":"","sources":["../../src/native-terminal/replay-buffer.ts"],"names":[],"mappings":"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"}

package/dist/native-terminal/server.d.ts

@@ -0,0 +1,13 @@
+import { NativeTerminalHost } from "./host.js";
+export type NativeTerminalHostServer = Readonly<{
+    socketPath: string;
+    close(options?: {
+        stopSessions?: boolean;
+        signal?: string;
+    }): Promise<void>;
+}>;
+export declare function startNativeTerminalHostServer(options: {
+    socketPath: string;
+    host: NativeTerminalHost;
+}): Promise<NativeTerminalHostServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/native-terminal/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/native-terminal/server.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,kBAAkB,EAGnB,MAAM,WAAW,CAAC;AAwhBnB,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAAC;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7E,CAAC,CAAC;AAEH,wBAAsB,6BAA6B,CAAC,OAAO,EAAE;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,kBAAkB,CAAC;CAC1B,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAuGpC"}

package/dist/native-terminal/server.js

@@ -0,0 +1,555 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, link, lstat, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { createConnection, createServer } from "node:net";
+import { basename, dirname, isAbsolute, join } from "node:path";
+import { NativeTerminalHost, } from "./host.js";
+import { NATIVE_TERMINAL_MAX_FRAME_BYTES, NATIVE_TERMINAL_MAX_CONNECTIONS, NATIVE_TERMINAL_MAX_ERROR_MESSAGE_CHARS, NATIVE_TERMINAL_MAX_IDENTIFIER_CHARS, NATIVE_TERMINAL_MAX_PENDING_RESPONSE_BYTES_PER_CONNECTION, NATIVE_TERMINAL_MAX_PENDING_RESPONSE_BYTES_TOTAL, NATIVE_TERMINAL_MAX_PENDING_RESPONSES_PER_CONNECTION, NATIVE_TERMINAL_PROTOCOL_VERSION, isNativeTerminalStopSignal, isRecord, parseNativeTerminalRequest, } from "./protocol.js";
+import { assertPrivateNativeTerminalSocketDirectory, inspectPrivateNativeTerminalSocket, sameNativeTerminalSocket, } from "./socket-path.js";
+const SOCKET_PUBLICATION_LOCK_TIMEOUT_MS = 5_000;
+const SOCKET_PUBLICATION_LOCK_RETRY_MS = 25;
+const SOCKET_PUBLICATION_LOCK_ID_FILE = ".h2a-native-terminal.lock-id";
+function requiredRecord(value, label) {
+    if (!isRecord(value))
+        throw new TypeError(`${label} must be an object`);
+    return value;
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new TypeError(`${label} must be a non-empty string`);
+    }
+    return value;
+}
+function requiredIdentifier(value, label) {
+    const identifier = requiredString(value, label);
+    if (identifier.length > NATIVE_TERMINAL_MAX_IDENTIFIER_CHARS) {
+        throw new TypeError(`${label} must contain at most ${NATIVE_TERMINAL_MAX_IDENTIFIER_CHARS} characters`);
+    }
+    return identifier;
+}
+function requiredInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new TypeError(`${label} must be a positive safe integer`);
+    }
+    return value;
+}
+function sessionId(params) {
+    return requiredIdentifier(requiredRecord(params, "params").id, "session id");
+}
+function controllerLease(value) {
+    const lease = requiredRecord(value, "controller lease");
+    if (lease.role !== "controller")
+        throw new TypeError("invalid controller lease role");
+    return {
+        role: "controller",
+        id: requiredIdentifier(lease.id, "controller lease session id"),
+        generation: requiredIdentifier(lease.generation, "controller lease generation"),
+        incarnation: requiredIdentifier(lease.incarnation, "controller lease incarnation"),
+        controllerId: requiredIdentifier(lease.controllerId, "controller lease id"),
+        epoch: requiredInteger(lease.epoch, "controller lease epoch"),
+    };
+}
+function sameLease(left, right) {
+    return left.id === right.id
+        && left.generation === right.generation
+        && left.incarnation === right.incarnation
+        && left.controllerId === right.controllerId
+        && left.epoch === right.epoch;
+}
+function ownedLease(context, params) {
+    const lease = controllerLease(requiredRecord(params, "params").lease);
+    const owned = context.leases.get(lease.id);
+    if (!owned || !sameLease(owned, lease)) {
+        throw new Error("controller lease is not owned by this connection");
+    }
+    return lease;
+}
+function createOptions(params) {
+    const options = requiredRecord(params, "create params");
+    if (!Array.isArray(options.args) || !options.args.every((arg) => typeof arg === "string")) {
+        throw new TypeError("terminal args must be an array of strings");
+    }
+    const environment = requiredRecord(options.env, "terminal env");
+    if (!Object.values(environment).every((value) => typeof value === "string")) {
+        throw new TypeError("terminal env values must be strings");
+    }
+    return {
+        id: requiredIdentifier(options.id, "terminal session id"),
+        command: requiredString(options.command, "terminal command"),
+        args: options.args,
+        cwd: requiredString(options.cwd, "terminal cwd"),
+        env: environment,
+        cols: requiredInteger(options.cols, "terminal cols"),
+        rows: requiredInteger(options.rows, "terminal rows"),
+    };
+}
+function releaseConnectionLeases(host, context) {
+    for (const lease of context.leases.values()) {
+        try {
+            host.releaseController(lease);
+        }
+        catch {
+            // Exit/stop already fences the lease. Disconnect cleanup is idempotent.
+        }
+    }
+    context.leases.clear();
+}
+function dispatch(host, context, request) {
+    const params = request.params;
+    switch (request.operation) {
+        case "ping":
+            return {
+                generation: host.generation,
+                hostPid: process.pid,
+                protocolVersion: NATIVE_TERMINAL_PROTOCOL_VERSION,
+            };
+        case "create":
+            return host.create(createOptions(params));
+        case "list":
+            return host.list();
+        case "state":
+            return host.state(sessionId(params));
+        case "read-output": {
+            const record = requiredRecord(params, "params");
+            const afterSeq = record.afterSeq;
+            if (!Number.isSafeInteger(afterSeq) || afterSeq < 0) {
+                throw new TypeError("afterSeq must be a non-negative safe integer");
+            }
+            return host.readOutput(requiredIdentifier(record.id, "session id"), afterSeq);
+        }
+        case "attach-observer":
+            return host.attachObserver(sessionId(params));
+        case "acquire-controller": {
+            const record = requiredRecord(params, "params");
+            const lease = host.acquireController(requiredIdentifier(record.id, "session id"), requiredIdentifier(record.controllerId, "controller id"));
+            context.leases.set(lease.id, lease);
+            return lease;
+        }
+        case "release-controller": {
+            const lease = ownedLease(context, params);
+            const result = host.releaseController(lease);
+            context.leases.delete(lease.id);
+            return result;
+        }
+        case "write": {
+            const record = requiredRecord(params, "params");
+            const lease = ownedLease(context, record);
+            host.write(lease, requiredString(record.data, "terminal input"));
+            return null;
+        }
+        case "resize": {
+            const record = requiredRecord(params, "params");
+            const lease = ownedLease(context, record);
+            host.resize(lease, requiredInteger(record.cols, "terminal cols"), requiredInteger(record.rows, "terminal rows"));
+            return null;
+        }
+        case "stop": {
+            const record = requiredRecord(params, "params");
+            const lease = ownedLease(context, record);
+            if (record.signal !== undefined &&
+                !isNativeTerminalStopSignal(record.signal)) {
+                throw new TypeError("terminal stop signal must be SIGHUP, SIGINT, SIGTERM or SIGKILL");
+            }
+            return host.stop(lease, record.signal);
+        }
+    }
+}
+function responseFrame(response) {
+    const frame = `${JSON.stringify(response)}\n`;
+    if (Buffer.byteLength(frame) > NATIVE_TERMINAL_MAX_FRAME_BYTES) {
+        throw new RangeError("terminal response exceeds the frame limit");
+    }
+    return frame;
+}
+function safeResponseId(value) {
+    return typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= NATIVE_TERMINAL_MAX_IDENTIFIER_CHARS
+        ? value
+        : "invalid";
+}
+function boundedErrorMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.length === 0)
+        return "terminal operation failed";
+    return message.slice(0, NATIVE_TERMINAL_MAX_ERROR_MESSAGE_CHARS);
+}
+function writeResponse(context, response) {
+    let frame;
+    try {
+        frame = responseFrame(response);
+    }
+    catch {
+        context.socket.destroy();
+        return false;
+    }
+    const bytes = Buffer.byteLength(frame);
+    if (context.socket.destroyed ||
+        context.pendingResponses >=
+            NATIVE_TERMINAL_MAX_PENDING_RESPONSES_PER_CONNECTION ||
+        context.pendingResponseBytes + bytes >
+            NATIVE_TERMINAL_MAX_PENDING_RESPONSE_BYTES_PER_CONNECTION ||
+        context.responseBudget.pendingBytes + bytes >
+            NATIVE_TERMINAL_MAX_PENDING_RESPONSE_BYTES_TOTAL) {
+        context.socket.destroy();
+        return false;
+    }
+    context.pendingResponses += 1;
+    context.pendingResponseBytes += bytes;
+    context.responseBudget.pendingBytes += bytes;
+    try {
+        context.socket.write(frame, (error) => {
+            releasePendingResponse(context, bytes);
+            if (error)
+                context.socket.destroy();
+        });
+        return true;
+    }
+    catch {
+        releasePendingResponse(context, bytes);
+        context.socket.destroy();
+        return false;
+    }
+}
+function releasePendingResponse(context, bytes) {
+    if (context.pendingResponses <= 0)
+        return;
+    context.pendingResponses -= 1;
+    const released = Math.min(bytes, context.pendingResponseBytes);
+    context.pendingResponseBytes -= released;
+    context.responseBudget.pendingBytes = Math.max(0, context.responseBudget.pendingBytes - released);
+}
+function releaseAllPendingResponses(context) {
+    context.responseBudget.pendingBytes = Math.max(0, context.responseBudget.pendingBytes - context.pendingResponseBytes);
+    context.pendingResponseBytes = 0;
+    context.pendingResponses = 0;
+}
+function writeError(context, id, code, error) {
+    const response = {
+        version: NATIVE_TERMINAL_PROTOCOL_VERSION,
+        id: safeResponseId(id),
+        ok: false,
+        error: {
+            code,
+            message: boundedErrorMessage(error),
+        },
+    };
+    return writeResponse(context, response);
+}
+function consumeFrames(host, context, chunk) {
+    context.buffer += chunk;
+    for (;;) {
+        const newline = context.buffer.indexOf("\n");
+        if (newline < 0)
+            break;
+        const line = context.buffer.slice(0, newline);
+        context.buffer = context.buffer.slice(newline + 1);
+        if (line.length === 0)
+            continue;
+        if (Buffer.byteLength(line) > NATIVE_TERMINAL_MAX_FRAME_BYTES) {
+            writeError(context, "invalid", "invalid-request", new Error("terminal request exceeds the frame limit"));
+            context.socket.destroy();
+            return;
+        }
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch (error) {
+            if (!writeError(context, "invalid", "invalid-request", error))
+                return;
+            continue;
+        }
+        let request;
+        try {
+            request = parseNativeTerminalRequest(raw);
+        }
+        catch (error) {
+            const id = isRecord(raw) ? raw.id : "invalid";
+            if (!writeError(context, id, "invalid-request", error))
+                return;
+            continue;
+        }
+        try {
+            const response = {
+                version: NATIVE_TERMINAL_PROTOCOL_VERSION,
+                id: request.id,
+                ok: true,
+                result: dispatch(host, context, request),
+            };
+            if (!writeResponse(context, response))
+                return;
+        }
+        catch (error) {
+            if (!writeError(context, request.id, "operation-failed", error))
+                return;
+        }
+    }
+    if (Buffer.byteLength(context.buffer) > NATIVE_TERMINAL_MAX_FRAME_BYTES) {
+        writeError(context, "invalid", "invalid-request", new Error("terminal request exceeds the frame limit"));
+        context.socket.destroy();
+    }
+}
+async function socketAcceptsConnections(socketPath) {
+    return new Promise((resolve) => {
+        const socket = createConnection(socketPath);
+        socket.once("connect", () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once("error", () => resolve(false));
+    });
+}
+async function socketPublicationLockSecret(socketPath) {
+    if (process.platform !== "linux" || process.getuid === undefined) {
+        throw new Error("native terminal socket publication requires Linux abstract Unix sockets");
+    }
+    const directory = dirname(socketPath);
+    const identityPath = join(directory, SOCKET_PUBLICATION_LOCK_ID_FILE);
+    const temporaryPath = join(directory, `.${SOCKET_PUBLICATION_LOCK_ID_FILE}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporaryPath, `${randomUUID()}\n`, {
+            flag: "wx",
+            mode: 0o600,
+        });
+        await chmod(temporaryPath, 0o600);
+        try {
+            await link(temporaryPath, identityPath);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+    finally {
+        try {
+            await unlink(temporaryPath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    const identity = await lstat(identityPath);
+    if (!identity.isFile()
+        || identity.isSymbolicLink()
+        || identity.uid !== process.getuid()
+        || (identity.mode & 0o777) !== 0o600) {
+        throw new Error(`terminal socket publication lock identity is not a private owned file: ${identityPath}`);
+    }
+    const secret = (await readFile(identityPath, "utf8")).trim();
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(secret)) {
+        throw new Error(`terminal socket publication lock identity is malformed: ${identityPath}`);
+    }
+    return secret;
+}
+async function acquireSocketPublicationLock(socketPath) {
+    const secret = await socketPublicationLockSecret(socketPath);
+    const address = `\0h2a-terminal-lock-${createHash("sha256")
+        .update(`${process.getuid?.() ?? "unknown"}:${socketPath}:${secret}`)
+        .digest("hex")}`;
+    const deadline = Date.now() + SOCKET_PUBLICATION_LOCK_TIMEOUT_MS;
+    for (;;) {
+        const lock = createServer();
+        try {
+            await new Promise((resolve, reject) => {
+                lock.once("error", reject);
+                lock.listen(address, () => {
+                    lock.removeListener("error", reject);
+                    resolve();
+                });
+            });
+            return lock;
+        }
+        catch (error) {
+            if (error.code !== "EADDRINUSE"
+                || Date.now() >= deadline) {
+                throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, SOCKET_PUBLICATION_LOCK_RETRY_MS));
+        }
+    }
+}
+async function withSocketPublicationLock(socketPath, operation) {
+    const lock = await acquireSocketPublicationLock(socketPath);
+    try {
+        return await operation();
+    }
+    finally {
+        await new Promise((resolve, reject) => {
+            lock.close((error) => error ? reject(error) : resolve());
+        });
+    }
+}
+async function removeStaleSocket(socketPath) {
+    for (;;) {
+        let stale;
+        try {
+            stale = await inspectPrivateNativeTerminalSocket(socketPath);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        if (await socketAcceptsConnections(socketPath)) {
+            throw new Error(`terminal host socket is already active: ${socketPath}`);
+        }
+        try {
+            const current = await inspectPrivateNativeTerminalSocket(socketPath);
+            if (sameNativeTerminalSocket(stale, current)) {
+                await unlink(socketPath);
+                return;
+            }
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+    }
+}
+async function ensurePrivateSocketDirectory(socketPath) {
+    const directory = dirname(socketPath);
+    try {
+        await assertPrivateNativeTerminalSocketDirectory(socketPath);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        await chmod(directory, 0o700);
+        await assertPrivateNativeTerminalSocketDirectory(socketPath);
+    }
+}
+function stagingSocketPath(socketPath) {
+    const directory = dirname(socketPath);
+    const stem = basename(socketPath).slice(0, 24).replace(/[^A-Za-z0-9_.-]/g, "_");
+    return join(directory, `.${stem}.${process.pid}.${randomUUID().slice(0, 8)}.sock`);
+}
+async function publishSocket(stagedPath, socketPath) {
+    const staged = await inspectPrivateNativeTerminalSocket(stagedPath);
+    for (let attempt = 0; attempt < 200; attempt += 1) {
+        try {
+            await link(stagedPath, socketPath);
+            const published = await inspectPrivateNativeTerminalSocket(socketPath);
+            if (!sameNativeTerminalSocket(staged, published)) {
+                throw new Error("terminal host published socket identity does not match its staged socket");
+            }
+            await unlink(stagedPath);
+            return published;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            await removeStaleSocket(socketPath);
+        }
+    }
+    throw new Error("terminal host socket publication retry limit exceeded");
+}
+export async function startNativeTerminalHostServer(options) {
+    if (!isAbsolute(options.socketPath))
+        throw new Error("terminal host socket path must be absolute");
+    await ensurePrivateSocketDirectory(options.socketPath);
+    const sockets = new Set();
+    const responseBudget = { pendingBytes: 0 };
+    const server = createServer((socket) => {
+        if (sockets.size >= NATIVE_TERMINAL_MAX_CONNECTIONS) {
+            socket.destroy();
+            return;
+        }
+        const context = {
+            socket,
+            leases: new Map(),
+            responseBudget,
+            buffer: "",
+            pendingResponseBytes: 0,
+            pendingResponses: 0,
+        };
+        sockets.add(socket);
+        socket.setEncoding("utf8");
+        socket.setNoDelay(true);
+        socket.on("error", () => {
+            // Per-connection transport failures are contained to this client.
+        });
+        socket.on("data", (chunk) => {
+            try {
+                consumeFrames(options.host, context, chunk);
+            }
+            catch {
+                socket.destroy();
+            }
+        });
+        socket.on("close", () => {
+            releaseAllPendingResponses(context);
+            releaseConnectionLeases(options.host, context);
+            sockets.delete(socket);
+        });
+    });
+    const stagedPath = stagingSocketPath(options.socketPath);
+    let ownedSocket;
+    try {
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(stagedPath, () => {
+                server.removeListener("error", reject);
+                resolve();
+            });
+        });
+        await chmod(stagedPath, 0o600);
+        ownedSocket = await withSocketPublicationLock(options.socketPath, () => publishSocket(stagedPath, options.socketPath));
+    }
+    catch (error) {
+        await new Promise((resolve) => server.close(() => resolve()));
+        try {
+            await unlink(stagedPath);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== "ENOENT") {
+                throw cleanupError;
+            }
+        }
+        throw error;
+    }
+    let closing;
+    return Object.freeze({
+        socketPath: options.socketPath,
+        close(closeOptions = {}) {
+            closing ??= (async () => {
+                let stopError;
+                if (closeOptions.stopSessions) {
+                    try {
+                        const signal = closeOptions.signal ?? "SIGTERM";
+                        if (!isNativeTerminalStopSignal(signal)) {
+                            throw new TypeError("invalid terminal host shutdown signal");
+                        }
+                        options.host.stopAll(signal);
+                    }
+                    catch (error) {
+                        stopError = error;
+                    }
+                }
+                for (const socket of sockets)
+                    socket.destroy();
+                await new Promise((resolve, reject) => {
+                    server.close((error) => error ? reject(error) : resolve());
+                });
+                await withSocketPublicationLock(options.socketPath, async () => {
+                    try {
+                        const current = await inspectPrivateNativeTerminalSocket(options.socketPath);
+                        if (sameNativeTerminalSocket(current, ownedSocket)) {
+                            await unlink(options.socketPath);
+                        }
+                    }
+                    catch (error) {
+                        if (error.code !== "ENOENT")
+                            throw error;
+                    }
+                });
+                if (stopError !== undefined)
+                    throw stopError;
+            })();
+            return closing;
+        },
+    });
+}
+//# sourceMappingURL=server.js.map