@zktx.io/sui-mcp 0.5.0

package/dist/runtime/shared/authenticatedFetch.js

@@ -0,0 +1,127 @@
+import { Agent, request as httpRequest } from "node:http";
+import { connect } from "node:net";
+import { randomBytes } from "node:crypto";
+import { Readable } from "node:stream";
+import { MAX_JSON_BODY_BYTES } from "../../review-server/http.js";
+import { IDENTITY_CHALLENGE_HEADER, IDENTITY_PATH, IDENTITY_TIMEOUT_MS, INTERNAL_MCP_PATH, SERVER_INSTANCE_HEADER, verifyServerIdentity } from "./control.js";
+// Proof and authenticated request use the same TCP socket. A closed socket is never
+// transparently replaced: no credential or UI permission can reach a new listener.
+async function authenticatedChannel(port, control, signal) {
+    signal?.throwIfAborted();
+    const socket = connect({ host: "127.0.0.1", port });
+    const agent = new Agent({ keepAlive: true, maxSockets: 1 });
+    agent.createConnection = (() => socket);
+    const close = () => { agent.destroy(); socket.destroy(); };
+    const abort = () => socket.destroy(new Error("Local server connection aborted."));
+    const timer = setTimeout(() => socket.destroy(new Error("Local server identity timed out.")), IDENTITY_TIMEOUT_MS);
+    signal?.addEventListener("abort", abort, { once: true });
+    try {
+        await new Promise((resolve, reject) => { socket.once("connect", resolve); socket.once("error", reject); });
+        const challenge = randomBytes(32).toString("base64url");
+        const identity = await new Promise((resolve, reject) => {
+            const request = httpRequest({ host: "127.0.0.1", port, path: IDENTITY_PATH, method: "GET", agent,
+                headers: { Host: `127.0.0.1:${port}`, [IDENTITY_CHALLENGE_HEADER]: challenge, Connection: "keep-alive" }
+            }, (response) => {
+                if (response.socket !== socket || response.statusCode !== 200 ||
+                    response.headers["content-type"] !== "application/json; charset=utf-8" ||
+                    response.headers["cache-control"] !== "no-store") {
+                    response.destroy();
+                    reject(new Error("Incompatible local server response."));
+                    return;
+                }
+                const chunks = [];
+                let size = 0;
+                response.on("data", (chunk) => {
+                    size += chunk.length;
+                    if (size > MAX_JSON_BODY_BYTES)
+                        response.destroy(new Error("Local server identity is too large."));
+                    else
+                        chunks.push(chunk);
+                });
+                response.once("error", reject);
+                response.once("end", () => {
+                    try {
+                        resolve(verifyServerIdentity(JSON.parse(Buffer.concat(chunks).toString("utf8")), control, challenge));
+                    }
+                    catch {
+                        reject(new Error("Local server authentication or compatibility check failed."));
+                    }
+                });
+            });
+            request.once("error", reject);
+            request.end();
+        });
+        return { agent, socket, identity, close };
+    }
+    catch (error) {
+        close();
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
+    }
+}
+export async function probeAuthenticatedServer(port, control) {
+    const channel = await authenticatedChannel(port, control);
+    try {
+        return channel.identity;
+    }
+    finally {
+        channel.close();
+    }
+}
+export function createAuthenticatedFetch(port, control, expectedInstanceId) {
+    return async (input, init) => {
+        const url = new URL(input);
+        if (url.origin !== `http://127.0.0.1:${port}` || url.pathname !== INTERNAL_MCP_PATH || url.search !== "") {
+            throw new Error("Only the internal MCP endpoint is allowed.");
+        }
+        const channel = await authenticatedChannel(port, control, init?.signal ?? undefined);
+        if (expectedInstanceId !== undefined && channel.identity.instanceId !== expectedInstanceId) {
+            channel.close();
+            throw new Error("Shared server changed before dispatch. The operation was not sent.");
+        }
+        const headers = new Headers(init?.headers);
+        headers.set("host", url.host);
+        headers.set("authorization", `Bearer ${control.key}`);
+        headers.set(SERVER_INSTANCE_HEADER, channel.identity.instanceId);
+        headers.set("connection", "close");
+        const body = init?.body;
+        if (body !== undefined && body !== null && typeof body !== "string") {
+            channel.close();
+            throw new Error("Invalid internal MCP body.");
+        }
+        if (typeof body === "string")
+            headers.set("content-length", String(Buffer.byteLength(body)));
+        return new Promise((resolve, reject) => {
+            const request = httpRequest({ host: "127.0.0.1", port, path: INTERNAL_MCP_PATH,
+                method: init?.method ?? "GET", headers: Object.fromEntries(headers), agent: channel.agent,
+                ...(init?.signal ? { signal: init.signal } : {})
+            }, (response) => {
+                if (response.socket !== channel.socket) {
+                    channel.close();
+                    reject(new Error("Local server socket changed."));
+                    return;
+                }
+                const responseHeaders = new Headers();
+                for (const [name, value] of Object.entries(response.headers)) {
+                    if (value !== undefined)
+                        responseHeaders.set(name, Array.isArray(value) ? value.join(", ") : value);
+                }
+                response.once("close", channel.close);
+                const status = response.statusCode ?? 500;
+                if ([204, 205, 304].includes(status)) {
+                    response.resume();
+                    resolve(new Response(null, { status, headers: responseHeaders }));
+                }
+                else
+                    resolve(new Response(Readable.toWeb(response), { status, headers: responseHeaders }));
+            });
+            request.once("socket", (socket) => { if (socket !== channel.socket || socket.destroyed)
+                request.destroy(new Error("Authenticated socket unavailable.")); });
+            request.once("error", (error) => { channel.close(); reject(error); });
+            request.end(body);
+        });
+    };
+}

package/dist/runtime/shared/control.js

@@ -0,0 +1,93 @@
+import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { link, lstat, mkdir, readFile, realpath, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { z } from "zod";
+// Version 7 uses the Sui MCP resource, metadata and response-field identities.
+// Clients must not attach to an owner that serves the previous package contract.
+export const INTERNAL_API_VERSION = 7;
+export const IDENTITY_PATH = "/__runtime/identity";
+export const INTERNAL_MCP_PATH = "/__runtime/mcp";
+export const IDENTITY_CHALLENGE_HEADER = "x-sui-mcp-identity-challenge";
+export const SERVER_INSTANCE_HEADER = "x-sui-mcp-server-instance";
+// The existing review-server identity probe allows one second for a local response.
+export const IDENTITY_TIMEOUT_MS = 1000;
+const secretSchema = z.string().regex(/^[A-Za-z0-9_-]{43}$/);
+export const serverIdentitySchema = z.object({
+    service: z.literal("sui-mcp"),
+    role: z.literal("shared-server"),
+    apiVersion: z.literal(INTERNAL_API_VERSION),
+    databaseId: z.string().regex(/^[0-9a-f]{64}$/),
+    configurationId: z.string().regex(/^[0-9a-f]{64}$/),
+    instanceId: z.string().uuid(),
+    pid: z.number().int().positive(),
+    challenge: secretSchema,
+    proof: secretSchema
+}).strict();
+export async function loadControlIdentity(databasePath, configuration) {
+    await mkdir(dirname(databasePath), { recursive: true, mode: 0o700 });
+    const directory = await realpath(dirname(databasePath));
+    const path = join(directory, "runtime-control.key");
+    const temporary = join(directory, `.runtime-control-${randomUUID()}.tmp`);
+    await writeFile(temporary, randomBytes(32).toString("base64url"), { flag: "wx", mode: 0o600 });
+    try {
+        try {
+            await link(temporary, path);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+    finally {
+        await unlink(temporary);
+    }
+    const stat = await lstat(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || (process.platform !== "win32" &&
+        ((stat.mode & 0o077) !== 0 || (process.getuid !== undefined && stat.uid !== process.getuid())))) {
+        throw new Error("The runtime control key must be a private file owned by the current OS user.");
+    }
+    return {
+        key: secretSchema.parse(await readFile(path, "utf8")),
+        databaseId: createHash("sha256").update(join(directory, basename(databasePath))).digest("hex"),
+        configurationId: createHash("sha256").update(JSON.stringify(configuration)).digest("hex")
+    };
+}
+function identityPayload(identity) {
+    return JSON.stringify([identity.service, identity.role, identity.apiVersion, identity.databaseId,
+        identity.configurationId, identity.instanceId, identity.pid, identity.challenge]);
+}
+export function createServerIdentity(control, instanceId, challenge) {
+    secretSchema.parse(challenge);
+    const identity = { service: "sui-mcp", role: "shared-server", apiVersion: INTERNAL_API_VERSION,
+        databaseId: control.databaseId, configurationId: control.configurationId,
+        instanceId, pid: process.pid, challenge };
+    return { ...identity, proof: createHmac("sha256", control.key).update(identityPayload(identity)).digest("base64url") };
+}
+export function verifyServerIdentity(input, control, challenge) {
+    const identity = serverIdentitySchema.parse(input);
+    if (identity.databaseId !== control.databaseId || identity.configurationId !== control.configurationId ||
+        identity.challenge !== challenge)
+        throw new Error("Local server identity does not match this runtime.");
+    const expected = createHmac("sha256", control.key).update(identityPayload(identity)).digest();
+    const actual = Buffer.from(identity.proof, "base64url");
+    if (expected.length !== actual.length || !timingSafeEqual(expected, actual)) {
+        throw new Error("Local server authentication failed.");
+    }
+    return identity;
+}
+export function singleHeader(request, name) {
+    const values = request.headersDistinct[name];
+    return values?.length === 1 ? values[0] : undefined;
+}
+export function validInternalRequest(request, port) {
+    return singleHeader(request, "host") === `127.0.0.1:${port}` &&
+        request.headers.origin === undefined && request.headers.cookie === undefined;
+}
+export function validControlAuthorization(request, control, instanceId) {
+    const authorization = singleHeader(request, "authorization");
+    if (authorization === undefined || singleHeader(request, SERVER_INSTANCE_HEADER) !== instanceId)
+        return false;
+    const expected = Buffer.from(`Bearer ${control.key}`);
+    const actual = Buffer.from(authorization);
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}

package/dist/runtime/shared/dataAccess.js

@@ -0,0 +1,66 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+// An asynchronous read may finish after import/reset. Its original generation
+// remains attached to the continuation and cannot read or write the replacement DB.
+export class RuntimeDataAccess {
+    context = new AsyncLocalStorage();
+    generation = 0;
+    initializing = true;
+    closed = false;
+    run(work) {
+        if (this.closed)
+            throw new Error("Shared server is closed.");
+        return this.context.run({ generation: this.generation }, work);
+    }
+    ready() { this.initializing = false; }
+    bind(work) {
+        this.assertCurrent();
+        const generation = this.generation;
+        return (value) => this.context.run({ generation }, () => { this.assertCurrent(); work(value); });
+    }
+    assertCurrent = () => {
+        const context = this.context.getStore();
+        if (this.closed || (context === undefined ? !this.initializing : context.generation !== this.generation)) {
+            throw new Error("Shared data changed or its server stopped; stale access is refused.");
+        }
+    };
+    dataReplaced() {
+        this.assertCurrent();
+        this.generation += 1;
+        const active = this.context.getStore();
+        if (active !== undefined)
+            active.generation = this.generation;
+    }
+    close() { this.closed = true; }
+    guardDatabase = (database) => {
+        const guard = this.assertCurrent;
+        return new Proxy(database, {
+            get(target, property) {
+                if (property === "prepare")
+                    return (sql) => {
+                        guard();
+                        const statement = target.prepare(sql);
+                        return new Proxy(statement, {
+                            get(stmt, key) {
+                                const value = Reflect.get(stmt, key, stmt);
+                                return typeof value === "function" ? (...args) => {
+                                    guard();
+                                    return Reflect.apply(value, stmt, args);
+                                } : value;
+                            }
+                        });
+                    };
+                if (property === "transaction")
+                    return (work) => {
+                        guard();
+                        return target.transaction((...args) => { guard(); return work(...args); });
+                    };
+                const value = Reflect.get(target, property, target);
+                return typeof value === "function" ? (...args) => {
+                    if (property !== "close")
+                        guard();
+                    return Reflect.apply(value, target, args);
+                } : value;
+            }
+        });
+    };
+}

package/dist/runtime/shared/mcpHttp.js

@@ -0,0 +1,84 @@
+import { CARD_TOOLS } from "../../mcp-ui/contracts.js";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isJSONRPCRequest } from "@modelcontextprotocol/sdk/types.js";
+import { MAX_JSON_BODY_BYTES, sendJson } from "../../review-server/http.js";
+export function createInternalMcpHandler(createServer) {
+    const sessions = new Map();
+    const connections = new Set();
+    return {
+        async handle(request, response) {
+            // This product has no unsolicited server requests. POST returns JSON, and
+            // clients do not create a reconnecting SSE channel or replay requests.
+            if (request.method === "GET") {
+                response.setHeader("Allow", "POST, DELETE");
+                sendJson(response, 405, { error: "method_not_allowed" });
+                return;
+            }
+            const sessionId = request.headers["mcp-session-id"];
+            if (sessionId !== undefined && typeof sessionId !== "string") {
+                sendJson(response, 400, { error: "invalid_session" });
+                return;
+            }
+            if (sessionId !== undefined) {
+                const session = sessions.get(sessionId);
+                if (!session) {
+                    sendJson(response, 404, { error: "mcp_session_unavailable" });
+                    return;
+                }
+                await session.transport.handleRequest(request, response);
+                return;
+            }
+            if (request.method !== "POST") {
+                sendJson(response, 400, { error: "mcp_initialize_required" });
+                return;
+            }
+            const server = createServer();
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: randomUUID,
+                enableJsonResponse: true,
+                onsessioninitialized: (id) => { sessions.set(id, { server, transport }); },
+                onsessionclosed: (id) => { sessions.delete(id); connections.delete(server); }
+            });
+            connections.add(server);
+            try {
+                const connection = {
+                    start: () => transport.start(),
+                    send: (message, options) => transport.send(message, options),
+                    close: () => transport.close()
+                };
+                transport.onmessage = (message, extra) => {
+                    // Preserve ordinary stdio MCP input contracts. The existing HTTP/UI
+                    // body limit applies to card calls, including their JSON-RPC envelope.
+                    if (isJSONRPCRequest(message) && message.method === "tools/call" &&
+                        Object.values(CARD_TOOLS).some((name) => name === message.params?.name) &&
+                        Buffer.byteLength(JSON.stringify(message)) > MAX_JSON_BODY_BYTES) {
+                        void transport.send({ jsonrpc: "2.0", id: message.id, error: { code: -32600, message: "Card request exceeds the JSON body limit." } });
+                        return;
+                    }
+                    connection.onmessage?.(message, extra);
+                };
+                transport.onerror = (error) => connection.onerror?.(error);
+                transport.onclose = () => connection.onclose?.();
+                await server.connect(connection);
+                await transport.handleRequest(request, response);
+                if (transport.sessionId === undefined) {
+                    connections.delete(server);
+                    await server.close();
+                }
+            }
+            catch (error) {
+                if (transport.sessionId !== undefined)
+                    sessions.delete(transport.sessionId);
+                connections.delete(server);
+                await server.close();
+                throw error;
+            }
+        },
+        async close() {
+            await Promise.all([...connections].map((server) => server.close()));
+            connections.clear();
+            sessions.clear();
+        }
+    };
+}

package/dist/runtime/shared/ownerLease.js

@@ -0,0 +1,50 @@
+import Database from "better-sqlite3";
+import { existsSync, lstatSync, mkdirSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+export class DataDirectoryOwnedError extends Error {
+    code = "DATA_DIRECTORY_OWNED";
+}
+/** An OS-released ownership lock, separate from the product database. No
+ * business transaction is held while waiting for a wallet or network reply. */
+export function acquireDataDirectoryOwner(databasePath) {
+    const directory = dirname(databasePath);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const directoryStat = statSync(directory);
+    if (!directoryStat.isDirectory() || (process.platform !== "win32" && ((directoryStat.mode & 0o077) !== 0 ||
+        (process.getuid !== undefined && directoryStat.uid !== process.getuid())))) {
+        throw new Error("The runtime data directory must be private to the current OS user.");
+    }
+    const filename = join(directory, "runtime-owner.sqlite");
+    if (existsSync(filename)) {
+        const stat = lstatSync(filename);
+        if (!stat.isFile() || stat.isSymbolicLink() || (process.platform !== "win32" &&
+            ((stat.mode & 0o077) !== 0 || (process.getuid !== undefined && stat.uid !== process.getuid())))) {
+            throw new Error("Runtime ownership file is not private to this OS user.");
+        }
+    }
+    const mask = process.umask(0o077);
+    let lock;
+    try {
+        lock = new Database(filename, { timeout: 0 });
+    }
+    finally {
+        process.umask(mask);
+    }
+    try {
+        // A second owner is refused immediately, including one using another port.
+        // SQLite retains the EXCLUSIVE lock after commit until this handle closes.
+        lock.pragma("locking_mode=EXCLUSIVE");
+        lock.exec("BEGIN EXCLUSIVE");
+        lock.exec("CREATE TABLE IF NOT EXISTS owner_lock (singleton INTEGER PRIMARY KEY CHECK (singleton=1))");
+        lock.exec("COMMIT");
+    }
+    catch (error) {
+        lock.close();
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "SQLITE_BUSY") {
+            throw new DataDirectoryOwnedError("This data directory already has a runtime owner. Use the same port for its clients, or a different data directory.");
+        }
+        throw new Error("The runtime data directory could not be locked.");
+    }
+    return { close: () => { if (lock.open)
+            lock.close(); } };
+}

package/dist/runtime/shared/server.js

@@ -0,0 +1,98 @@
+import { createServer } from "node:http";
+import { randomUUID } from "node:crypto";
+import { HttpError, sendJson } from "../../review-server/http.js";
+import { createServerIdentity, IDENTITY_CHALLENGE_HEADER, IDENTITY_PATH, INTERNAL_MCP_PATH, singleHeader, validControlAuthorization, validInternalRequest } from "./control.js";
+export async function startSharedServer(input) {
+    const instanceId = randomUUID();
+    let port = input.port;
+    let application;
+    let stopping = false;
+    const server = createServer((request, response) => {
+        response.setHeader("cache-control", "no-store");
+        void (async () => {
+            try {
+                if (stopping) {
+                    sendJson(response, 503, { error: "runtime_stopping" });
+                    return;
+                }
+                if (request.url === IDENTITY_PATH || request.url === INTERNAL_MCP_PATH) {
+                    if (!validInternalRequest(request, port)) {
+                        sendJson(response, 403, { error: "invalid_request_origin" });
+                        return;
+                    }
+                    if (request.url === IDENTITY_PATH) {
+                        if (request.method !== "GET" || request.headers.authorization !== undefined) {
+                            sendJson(response, 400, { error: "invalid_identity_request" });
+                            return;
+                        }
+                        const challenge = singleHeader(request, IDENTITY_CHALLENGE_HEADER);
+                        if (challenge === undefined || !/^[A-Za-z0-9_-]{43}$/.test(challenge)) {
+                            sendJson(response, 400, { error: "invalid_identity_challenge" });
+                            return;
+                        }
+                        sendJson(response, 200, createServerIdentity(input.control, instanceId, challenge));
+                        return;
+                    }
+                    if (!validControlAuthorization(request, input.control, instanceId)) {
+                        sendJson(response, 401, { error: "control_authentication_required" });
+                        return;
+                    }
+                    await (await application).handleMcp(request, response);
+                    return;
+                }
+                await (await application).handleHttp(request, response);
+            }
+            catch (error) {
+                if (error instanceof HttpError) {
+                    if (!response.headersSent)
+                        sendJson(response, error.status, { error: error.code });
+                    return;
+                }
+                input.onError(error);
+                if (!response.headersSent)
+                    sendJson(response, 503, { error: "runtime_unavailable" });
+                else
+                    response.destroy();
+            }
+        })();
+    });
+    await new Promise((resolve, reject) => {
+        const failed = (error) => { server.off("listening", listening); reject(error); };
+        const listening = () => { server.off("error", failed); resolve(); };
+        server.once("error", failed);
+        server.once("listening", listening);
+        server.listen(port, "127.0.0.1");
+    });
+    port = server.address().port;
+    // Only the process that owns the port opens SQLite or initializes services.
+    application = Promise.resolve().then(() => input.createApplication(instanceId));
+    const closeListener = async () => {
+        if (!server.listening)
+            return;
+        const closed = new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+        server.closeAllConnections();
+        await closed;
+    };
+    try {
+        await application;
+    }
+    catch (error) {
+        stopping = true;
+        await closeListener();
+        throw error;
+    }
+    return {
+        host: "127.0.0.1", port, instanceId,
+        async close() {
+            if (stopping)
+                return;
+            stopping = true;
+            try {
+                await (await application).close();
+            }
+            finally {
+                await closeListener();
+            }
+        }
+    };
+}

package/dist/runtime/shared/stdio.js

@@ -0,0 +1,113 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { CallToolRequestSchema, CallToolResultSchema, CompleteRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourceTemplatesRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { SERVER_INSTRUCTIONS, SERVER_NAME, SERVER_VERSION } from "../../mcp/serverInfo.js";
+import { createAuthenticatedFetch, probeAuthenticatedServer } from "./authenticatedFetch.js";
+import { INTERNAL_MCP_PATH } from "./control.js";
+// The SDK owns request IDs, initialization, cancellation and response parsing.
+// This proxy has no domain services or writable stores. A new request may open a
+// new MCP session after ownership changes; an already dispatched call is never replayed.
+export async function startSharedStdio(input) {
+    const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, {
+        capabilities: { tools: {}, resources: {}, prompts: {}, completions: {} }, instructions: SERVER_INSTRUCTIONS
+    });
+    let connection;
+    let connecting;
+    let closed = false;
+    const lifetime = new AbortController();
+    function waiting(work, signal) {
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
+        return new Promise((resolve, reject) => {
+            const abort = () => reject(new Error("MCP connection was closed or cancelled."));
+            signal.addEventListener("abort", abort, { once: true });
+            void work.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+        });
+    }
+    async function owner(signal) {
+        if (closed)
+            throw new Error("MCP connection is closed.");
+        signal = signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal;
+        const [control] = await waiting(Promise.all([input.control, input.ready]), signal);
+        if (connecting)
+            return connecting;
+        const identity = await probeAuthenticatedServer(input.port, control);
+        signal?.throwIfAborted();
+        if (connection?.instanceId === identity.instanceId)
+            return connection.client;
+        if (connecting)
+            return connecting;
+        const open = (async () => {
+            await connection?.client.close();
+            connection = undefined;
+            if (closed)
+                throw new Error("MCP connection is closed.");
+            const clientInfo = server.getClientVersion();
+            if (!clientInfo)
+                throw new Error("MCP client initialization is required.");
+            const client = new Client(clientInfo, { capabilities: server.getClientCapabilities() ?? {} });
+            const http = new StreamableHTTPClientTransport(new URL(`http://127.0.0.1:${input.port}${INTERNAL_MCP_PATH}`), {
+                fetch: createAuthenticatedFetch(input.port, control, identity.instanceId)
+            });
+            const transport = {
+                start: () => http.start(), send: (message, options) => http.send(message, options),
+                setProtocolVersion: (version) => http.setProtocolVersion(version),
+                close: async () => { try {
+                    await http.terminateSession();
+                }
+                catch { /* The prior owner may already be gone. */ } await http.close(); }
+            };
+            http.onmessage = (message) => { if (http.sessionId !== undefined)
+                transport.sessionId = http.sessionId; transport.onmessage?.(message); };
+            http.onerror = (error) => transport.onerror?.(error);
+            http.onclose = () => transport.onclose?.();
+            try {
+                await client.connect(transport, signal === undefined ? undefined : { signal });
+                if (closed) {
+                    await client.close();
+                    throw new Error("MCP connection is closed.");
+                }
+                connection = { instanceId: identity.instanceId, client };
+                return client;
+            }
+            catch (error) {
+                await client.close();
+                throw error;
+            }
+        })();
+        connecting = open;
+        try {
+            return await open;
+        }
+        finally {
+            if (connecting === open)
+                connecting = undefined;
+        }
+    }
+    server.setRequestHandler(ListToolsRequestSchema, async (request, extra) => (await owner(extra.signal)).listTools(request.params, { signal: extra.signal }));
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => (await owner(extra.signal)).callTool(request.params, CallToolResultSchema, { signal: extra.signal }));
+    server.setRequestHandler(ListResourcesRequestSchema, async (request, extra) => (await owner(extra.signal)).listResources(request.params, { signal: extra.signal }));
+    server.setRequestHandler(ListResourceTemplatesRequestSchema, async (request, extra) => (await owner(extra.signal)).listResourceTemplates(request.params, { signal: extra.signal }));
+    server.setRequestHandler(ReadResourceRequestSchema, async (request, extra) => (await owner(extra.signal)).readResource(request.params, { signal: extra.signal }));
+    server.setRequestHandler(ListPromptsRequestSchema, async (request, extra) => (await owner(extra.signal)).listPrompts(request.params, { signal: extra.signal }));
+    server.setRequestHandler(GetPromptRequestSchema, async (request, extra) => (await owner(extra.signal)).getPrompt(request.params, { signal: extra.signal }));
+    server.setRequestHandler(CompleteRequestSchema, async (request, extra) => (await owner(extra.signal)).complete(request.params, { signal: extra.signal }));
+    server.onerror = input.onError;
+    await server.connect(input.stdio);
+    return {
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            lifetime.abort();
+            await server.close();
+            try {
+                await connecting;
+            }
+            catch { /* Initialization was cancelled with the stdio connection. */ }
+            await connection?.client.close();
+            connection = undefined;
+        }
+    };
+}