@harness-control/runner 0.1.0

package/dist/mcp/McpAttachmentClient.js

@@ -0,0 +1,345 @@
+import { createHash, createHmac, randomUUID } from "node:crypto";
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { redactHeaders, redactValue } from "./redaction.js";
+export class McpToolPolicyError extends Error {
+    attachmentName;
+    toolName;
+    constructor(attachmentName, toolName, message) {
+        super(message);
+        this.attachmentName = attachmentName;
+        this.toolName = toolName;
+        this.name = "McpToolPolicyError";
+    }
+}
+export class McpAttachmentExpiredError extends Error {
+    attachmentName;
+    constructor(attachmentName) {
+        super(`MCP attachment "${attachmentName}" has expired.`);
+        this.attachmentName = attachmentName;
+        this.name = "McpAttachmentExpiredError";
+    }
+}
+export class McpProofBindingError extends Error {
+    attachmentName;
+    constructor(attachmentName, message) {
+        super(message);
+        this.attachmentName = attachmentName;
+        this.name = "McpProofBindingError";
+    }
+}
+export class McpAttachmentClient {
+    attachment;
+    allowedTools;
+    deniedTools;
+    eventSink;
+    sdkFactory;
+    now;
+    proofContext;
+    proofSigner;
+    hasProofSigner;
+    client;
+    connected = false;
+    constructor(attachment, options = {}) {
+        this.attachment = attachment;
+        this.allowedTools = attachment.allowed_tools ? new Set(attachment.allowed_tools) : undefined;
+        this.deniedTools = new Set(attachment.denied_tools ?? []);
+        this.eventSink = options.eventSink;
+        this.sdkFactory = options.sdkFactory ?? defaultMcpSdkFactory;
+        this.now = options.now ?? (() => new Date());
+        this.proofContext = options.proofContext;
+        this.proofSigner = options.proofSigner ?? missingProofSigner;
+        this.hasProofSigner = options.proofSigner !== undefined;
+    }
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        this.assertNotExpired();
+        this.assertProofBindingConfigured();
+        if (this.attachment.transport !== "streamable_http") {
+            throw new Error(`Unsupported MCP attachment transport: ${this.attachment.transport}`);
+        }
+        await this.emitEvent("runtime.warning", {
+            event: "mcp.attachment.connecting",
+            attachment: this.attachment.name,
+            transport: this.attachment.transport,
+            url: this.attachment.url,
+            headers: redactHeaders(this.attachment.headers),
+        });
+        const client = this.sdkFactory.createClient();
+        const transport = this.sdkFactory.createStreamableHttpTransport(this.attachment, {
+            fetch: this.createProofFetch(),
+        });
+        await client.connect(transport);
+        this.client = client;
+        this.connected = true;
+        await this.emitEvent("runtime.warning", {
+            event: "mcp.attachment.connected",
+            attachment: this.attachment.name,
+        });
+    }
+    async listTools() {
+        this.assertNotExpired();
+        const client = this.requireConnectedClient();
+        const result = await client.listTools();
+        const tools = result.tools.filter((tool) => this.isToolAllowed(tool.name));
+        await this.emitEvent("runtime.warning", {
+            event: "mcp.tools.discovered",
+            attachment: this.attachment.name,
+            total_tools: result.tools.length,
+            allowed_tools: tools.map((tool) => tool.name),
+        });
+        return tools.map(toMcpToolDescriptor);
+    }
+    async callTool(name, arguments_ = {}) {
+        this.assertNotExpired();
+        await this.assertToolAllowed(name);
+        const client = this.requireConnectedClient();
+        await this.emitEvent("mcp_tool.started", {
+            attachment: this.attachment.name,
+            tool_name: name,
+            arguments: redactValue(arguments_),
+        });
+        try {
+            const sdkResult = await client.callTool({ name, arguments: arguments_ });
+            const result = toMcpToolCallResult(sdkResult);
+            await this.emitEvent("mcp_tool.completed", {
+                attachment: this.attachment.name,
+                tool_name: name,
+                result: redactValue(result),
+            });
+            return result;
+        }
+        catch (error) {
+            await this.emitEvent("runtime.error", {
+                event: "mcp.tool.failed",
+                attachment: this.attachment.name,
+                tool_name: name,
+                error: redactError(error),
+            });
+            throw error;
+        }
+    }
+    async close() {
+        const client = this.client;
+        this.client = undefined;
+        this.connected = false;
+        if (client) {
+            await client.close();
+            await this.emitEvent("runtime.warning", {
+                event: "mcp.attachment.closed",
+                attachment: this.attachment.name,
+            });
+        }
+    }
+    isToolAllowed(toolName) {
+        if (this.deniedTools.has(toolName)) {
+            return false;
+        }
+        return this.allowedTools ? this.allowedTools.has(toolName) : true;
+    }
+    async assertToolAllowed(toolName) {
+        if (this.isToolAllowed(toolName)) {
+            return;
+        }
+        await this.emitEvent("runtime.error", {
+            event: "mcp.tool.denied",
+            attachment: this.attachment.name,
+            tool_name: toolName,
+        });
+        throw new McpToolPolicyError(this.attachment.name, toolName, `MCP tool "${toolName}" is not allowed for attachment "${this.attachment.name}".`);
+    }
+    requireConnectedClient() {
+        if (!this.client) {
+            throw new Error(`MCP attachment "${this.attachment.name}" is not connected.`);
+        }
+        return this.client;
+    }
+    async emitEvent(event_type, data) {
+        if (!this.eventSink) {
+            return;
+        }
+        await this.eventSink({ event_type, data });
+    }
+    assertNotExpired() {
+        if (!this.attachment.expires_at) {
+            return;
+        }
+        const expiresAt = Date.parse(this.attachment.expires_at);
+        if (Number.isNaN(expiresAt) || expiresAt > this.now().getTime()) {
+            return;
+        }
+        void this.close();
+        throw new McpAttachmentExpiredError(this.attachment.name);
+    }
+    assertProofBindingConfigured() {
+        if (this.attachment.proof_of_possession.scheme !== "runner_signed_request") {
+            throw new McpProofBindingError(this.attachment.name, `Unsupported MCP proof scheme: ${this.attachment.proof_of_possession.scheme}`);
+        }
+        if (!this.proofContext) {
+            throw new McpProofBindingError(this.attachment.name, `MCP attachment "${this.attachment.name}" requires runner proof context.`);
+        }
+        if (!this.hasProofSigner) {
+            throw new McpProofBindingError(this.attachment.name, `MCP attachment "${this.attachment.name}" requires a runner proof signer.`);
+        }
+    }
+    createProofFetch() {
+        const attachment = this.attachment;
+        const proofContext = this.proofContext;
+        if (!proofContext) {
+            throw new McpProofBindingError(attachment.name, `MCP attachment "${attachment.name}" requires runner proof context.`);
+        }
+        return async (input, init) => {
+            const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+            const url = requestUrl(input);
+            const bodyHash = hashRequestBody(init?.body);
+            const timestamp = this.now().toISOString();
+            const nonce = randomUUID();
+            const signingInput = {
+                key_id: attachment.proof_of_possession.key_id,
+                method: method.toUpperCase(),
+                url,
+                body_hash: bodyHash,
+                lease_id: attachment.lease_id,
+                session_id: proofContext.session_id,
+                host_id: proofContext.host_id,
+                provider_instance_id: proofContext.provider_instance_id,
+                workspace_id: proofContext.workspace_id,
+                server_id: proofContext.server_id ?? attachment.name,
+                ...(proofContext.turn_id ? { turn_id: proofContext.turn_id } : {}),
+                timestamp,
+                nonce,
+            };
+            const signature = this.proofSigner(signingInput);
+            const headers = new Headers(init?.headers);
+            headers.set("x-hcp-proof-key-id", signingInput.key_id);
+            headers.set("x-hcp-lease-id", signingInput.lease_id);
+            headers.set("x-hcp-session-id", signingInput.session_id);
+            headers.set("x-hcp-host-id", signingInput.host_id);
+            headers.set("x-hcp-provider-instance-id", signingInput.provider_instance_id);
+            headers.set("x-hcp-workspace-id", signingInput.workspace_id);
+            headers.set("x-hcp-mcp-server-id", signingInput.server_id);
+            headers.set("x-hcp-proof-timestamp", signingInput.timestamp);
+            headers.set("x-hcp-proof-nonce", signingInput.nonce);
+            headers.set("x-hcp-proof-body-sha256", signingInput.body_hash);
+            headers.set("x-hcp-proof-signature", signature);
+            if (signingInput.turn_id) {
+                headers.set("x-hcp-turn-id", signingInput.turn_id);
+            }
+            for (const requiredHeader of attachment.proof_of_possession.required_headers) {
+                if (!headers.has(requiredHeader)) {
+                    throw new McpProofBindingError(attachment.name, `Required MCP proof header '${requiredHeader}' was not produced.`);
+                }
+            }
+            return fetch(input, {
+                ...init,
+                headers,
+            });
+        };
+    }
+}
+const defaultMcpSdkFactory = {
+    createClient() {
+        return new Client({ name: "hcp-runner", version: "0.0.0" });
+    },
+    createStreamableHttpTransport(attachment, options) {
+        return new StreamableHTTPClientTransport(new URL(attachment.url), {
+            requestInit: { headers: attachment.headers },
+            fetch: options.fetch,
+        });
+    },
+};
+function missingProofSigner() {
+    throw new Error("MCP proof signer is not configured.");
+}
+export function createDevelopmentHmacProofSigner(secret) {
+    return (input) => defaultProofSigner(input, secret);
+}
+function defaultProofSigner(input, secret) {
+    return `hmac-sha256:${createHmac("sha256", secret).update(canonicalProofString(input)).digest("base64url")}`;
+}
+function canonicalProofString(input) {
+    return [
+        input.method,
+        input.url,
+        input.body_hash,
+        input.lease_id,
+        input.session_id,
+        input.host_id,
+        input.provider_instance_id,
+        input.workspace_id,
+        input.server_id,
+        input.turn_id ?? "",
+        input.timestamp,
+        input.nonce,
+    ].join("\n");
+}
+function requestUrl(input) {
+    if (typeof input === "string") {
+        return input;
+    }
+    if (input instanceof URL) {
+        return input.toString();
+    }
+    return input.url;
+}
+function hashRequestBody(body) {
+    if (body === undefined || body === null) {
+        return sha256("");
+    }
+    if (typeof body === "string") {
+        return sha256(body);
+    }
+    if (body instanceof URLSearchParams) {
+        return sha256(body.toString());
+    }
+    if (body instanceof ArrayBuffer) {
+        return sha256(Buffer.from(body));
+    }
+    if (ArrayBuffer.isView(body)) {
+        return sha256(Buffer.from(body.buffer, body.byteOffset, body.byteLength));
+    }
+    return sha256("[streaming-body]");
+}
+function sha256(value) {
+    return `sha256:${createHash("sha256").update(value).digest("base64url")}`;
+}
+function toMcpToolDescriptor(tool) {
+    return {
+        name: tool.name,
+        ...(tool.description ? { description: tool.description } : {}),
+        input_schema: tool.inputSchema,
+        ...(tool.outputSchema ? { output_schema: tool.outputSchema } : {}),
+    };
+}
+function toMcpToolCallResult(result) {
+    const converted = {
+        is_error: Boolean(result.isError),
+    };
+    if ("content" in result && Array.isArray(result.content)) {
+        converted.content = result.content;
+    }
+    else if ("toolResult" in result) {
+        converted.content = [result.toolResult];
+    }
+    if ("structuredContent" in result && isRecord(result.structuredContent)) {
+        converted.structured_content = result.structuredContent;
+    }
+    return converted;
+}
+function redactError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: redactValue(error.message),
+        };
+    }
+    return {
+        message: redactValue(String(error)),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=McpAttachmentClient.js.map

package/dist/mcp/McpProxyServer.d.ts

@@ -0,0 +1,18 @@
+import type { HarnessAdapterMcpServer } from "../harnesses/adapters.js";
+import type { McpAttachmentClient, McpToolDescriptor } from "./McpAttachmentClient.js";
+export type McpProxyUpstream = Pick<McpAttachmentClient, "connect" | "listTools" | "callTool" | "close">;
+export type McpProxyServerOptions = {
+    attachment: Pick<HarnessAdapterMcpServer, "name" | "allowed_tools" | "denied_tools">;
+    upstream: McpProxyUpstream;
+    host?: "127.0.0.1" | "localhost";
+    port?: number;
+};
+export declare class McpProxyServer {
+    #private;
+    constructor(options: McpProxyServerOptions);
+    get adapterAttachment(): HarnessAdapterMcpServer | undefined;
+    connect(): Promise<void>;
+    listTools(): Promise<McpToolDescriptor[]>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=McpProxyServer.d.ts.map

package/dist/mcp/McpProxyServer.js

@@ -0,0 +1,188 @@
+import { createServer } from "node:http";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+export class McpProxyServer {
+    #attachment;
+    #upstream;
+    #host;
+    #port;
+    #httpServer;
+    #adapterAttachment;
+    constructor(options) {
+        this.#attachment = options.attachment;
+        this.#upstream = options.upstream;
+        this.#host = options.host ?? "127.0.0.1";
+        this.#port = options.port ?? 0;
+    }
+    get adapterAttachment() {
+        return this.#adapterAttachment;
+    }
+    async connect() {
+        if (this.#httpServer) {
+            return;
+        }
+        await this.#upstream.connect();
+        const httpServer = createServer((request, response) => {
+            this.#handleRequest(request, response).catch((error) => {
+                writeJsonRpcError(response, 500, "mcp_proxy_error", error instanceof Error ? error.message : "MCP proxy request failed.");
+            });
+        });
+        let boundPort;
+        try {
+            boundPort = await listen(httpServer, this.#host, this.#port);
+        }
+        catch (error) {
+            try {
+                await this.#upstream.close();
+            }
+            catch (cleanupError) {
+                throw new Error(`${errorMessage(error, "MCP proxy listen failed.")}; upstream cleanup failed: ${errorMessage(cleanupError, "MCP proxy upstream close failed.")}`);
+            }
+            throw error;
+        }
+        this.#httpServer = httpServer;
+        this.#adapterAttachment = {
+            name: this.#attachment.name,
+            transport: "streamable_http",
+            url: `http://${this.#host}:${boundPort}/mcp`,
+            headers: {},
+            ...(this.#attachment.allowed_tools ? { allowed_tools: this.#attachment.allowed_tools } : {}),
+            ...(this.#attachment.denied_tools ? { denied_tools: this.#attachment.denied_tools } : {}),
+        };
+    }
+    async listTools() {
+        return await this.#upstream.listTools();
+    }
+    async close() {
+        const httpServer = this.#httpServer;
+        this.#httpServer = undefined;
+        this.#adapterAttachment = undefined;
+        const errors = [];
+        if (httpServer) {
+            try {
+                await closeHttpServer(httpServer);
+            }
+            catch (error) {
+                errors.push(errorMessage(error, "MCP proxy HTTP close failed."));
+            }
+        }
+        try {
+            await this.#upstream.close();
+        }
+        catch (error) {
+            errors.push(errorMessage(error, "MCP proxy upstream close failed."));
+        }
+        if (errors.length > 0) {
+            throw new Error(errors.join("; "));
+        }
+    }
+    async #handleRequest(request, response) {
+        if (request.url !== "/mcp") {
+            writeJsonRpcError(response, 404, "mcp_proxy_not_found", "MCP proxy only serves /mcp.");
+            return;
+        }
+        const parsedBody = request.method === "POST" ? await readJsonBody(request) : undefined;
+        const server = createProxySdkServer(this.#attachment.name, this.#upstream);
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined,
+        });
+        await server.connect(transport);
+        response.on("close", () => {
+            transport.close().catch(() => undefined);
+            server.close().catch(() => undefined);
+        });
+        await transport.handleRequest(request, response, parsedBody);
+    }
+}
+function createProxySdkServer(attachmentName, upstream) {
+    const server = new Server({ name: `hcp-mcp-proxy-${attachmentName}`, version: "0.0.0" }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = await upstream.listTools();
+        return {
+            tools: tools.map(toSdkTool),
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const result = await upstream.callTool(request.params.name, request.params.arguments ?? {});
+        return toSdkToolCallResult(result);
+    });
+    return server;
+}
+function toSdkTool(tool) {
+    return {
+        name: tool.name,
+        ...(tool.description ? { description: tool.description } : {}),
+        inputSchema: tool.input_schema,
+        ...(tool.output_schema ? { outputSchema: tool.output_schema } : {}),
+    };
+}
+function toSdkToolCallResult(result) {
+    return {
+        content: (result.content ?? []),
+        ...(result.structured_content ? { structuredContent: result.structured_content } : {}),
+        ...(result.is_error ? { isError: true } : {}),
+    };
+}
+async function listen(server, host, port) {
+    return await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            const address = server.address();
+            if (typeof address === "object" && address !== null) {
+                resolve(address.port);
+                return;
+            }
+            reject(new Error("MCP proxy server did not expose a TCP port."));
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, host);
+    });
+}
+async function closeHttpServer(server) {
+    await new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const rawBody = Buffer.concat(chunks).toString("utf8");
+    return rawBody.length === 0 ? undefined : JSON.parse(rawBody);
+}
+function writeJsonRpcError(response, statusCode, code, message) {
+    if (response.headersSent) {
+        response.end();
+        return;
+    }
+    response.writeHead(statusCode, { "content-type": "application/json" });
+    response.end(JSON.stringify({
+        jsonrpc: "2.0",
+        error: {
+            code,
+            message,
+        },
+        id: null,
+    }));
+}
+function errorMessage(error, fallback) {
+    return error instanceof Error ? error.message : fallback;
+}
+//# sourceMappingURL=McpProxyServer.js.map

package/dist/mcp/McpStdioProfileClient.d.ts

@@ -0,0 +1,19 @@
+import { type McpToolCallArguments, type McpToolCallResult, type McpToolDescriptor } from "./McpAttachmentClient.js";
+export type McpStdioProfileClientOptions = {
+    name: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+    allowedTools?: string[];
+    deniedTools?: string[];
+};
+export declare class McpStdioProfileClient {
+    #private;
+    constructor(options: McpStdioProfileClientOptions);
+    connect(): Promise<void>;
+    listTools(): Promise<McpToolDescriptor[]>;
+    callTool(name: string, arguments_?: McpToolCallArguments): Promise<McpToolCallResult>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=McpStdioProfileClient.d.ts.map

package/dist/mcp/McpStdioProfileClient.js

@@ -0,0 +1,91 @@
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { getDefaultEnvironment, StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { Readable } from "node:stream";
+import { McpToolPolicyError } from "./McpAttachmentClient.js";
+import { redactValue } from "./redaction.js";
+export class McpStdioProfileClient {
+    #options;
+    #allowedTools;
+    #deniedTools;
+    #client;
+    constructor(options) {
+        this.#options = options;
+        this.#allowedTools = options.allowedTools ? new Set(options.allowedTools) : undefined;
+        this.#deniedTools = new Set(options.deniedTools ?? []);
+    }
+    async connect() {
+        if (this.#client)
+            return;
+        const client = new Client({ name: "hcp-runner", version: "0.0.0" });
+        const transport = new StdioClientTransport({
+            command: this.#options.command,
+            args: this.#options.args,
+            cwd: this.#options.cwd,
+            env: { ...getDefaultEnvironment(), ...this.#options.env },
+            stderr: "pipe",
+        });
+        let stderr = "";
+        if (transport.stderr instanceof Readable) {
+            transport.stderr.on("data", (chunk) => {
+                stderr = `${stderr}${chunk.toString("utf8")}`.slice(-16_384);
+            });
+        }
+        try {
+            await client.connect(transport);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "MCP stdio connection failed.";
+            const redacted = redactValue(stderr.trim());
+            throw new Error(`${message}${typeof redacted === "string" && redacted ? `: ${redacted}` : ""}`);
+        }
+        this.#client = client;
+    }
+    async listTools() {
+        const client = this.#requireClient();
+        const result = await client.listTools();
+        return result.tools.filter((tool) => this.#isAllowed(tool.name)).map(toDescriptor);
+    }
+    async callTool(name, arguments_ = {}) {
+        if (!this.#isAllowed(name)) {
+            throw new McpToolPolicyError(this.#options.name, name, `MCP tool "${name}" is not allowed for runner profile attachment "${this.#options.name}".`);
+        }
+        const result = await this.#requireClient().callTool({ name, arguments: arguments_ });
+        const content = Array.isArray(result.content) ? result.content : [];
+        const structuredContent = isRecord(result.structuredContent)
+            ? result.structuredContent
+            : undefined;
+        return {
+            content,
+            ...(structuredContent ? { structured_content: structuredContent } : {}),
+            is_error: result.isError === true,
+        };
+    }
+    async close() {
+        const client = this.#client;
+        this.#client = undefined;
+        if (client)
+            await client.close();
+    }
+    #isAllowed(toolName) {
+        if (this.#deniedTools.has(toolName))
+            return false;
+        return this.#allowedTools ? this.#allowedTools.has(toolName) : true;
+    }
+    #requireClient() {
+        if (!this.#client)
+            throw new Error(`Runner MCP profile '${this.#options.name}' is not connected.`);
+        return this.#client;
+    }
+}
+function toDescriptor(tool) {
+    return {
+        name: tool.name,
+        ...(tool.description ? { description: tool.description } : {}),
+        input_schema: tool.inputSchema,
+        ...(tool.outputSchema ? { output_schema: tool.outputSchema } : {}),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=McpStdioProfileClient.js.map

package/dist/mcp/index.d.ts

@@ -0,0 +1,5 @@
+export { McpAttachmentClient, McpAttachmentExpiredError, McpToolPolicyError, createDevelopmentHmacProofSigner, type McpAttachmentClientOptions, type McpAttachmentEvent, type McpAttachmentEventSink, type McpToolDescriptor, type McpToolCallArguments, type McpToolCallResult, } from "./McpAttachmentClient.js";
+export { McpProxyServer, type McpProxyServerOptions, type McpProxyUpstream } from "./McpProxyServer.js";
+export { McpStdioProfileClient, type McpStdioProfileClientOptions } from "./McpStdioProfileClient.js";
+export { redactHeaders, redactValue } from "./redaction.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -0,0 +1,5 @@
+export { McpAttachmentClient, McpAttachmentExpiredError, McpToolPolicyError, createDevelopmentHmacProofSigner, } from "./McpAttachmentClient.js";
+export { McpProxyServer } from "./McpProxyServer.js";
+export { McpStdioProfileClient } from "./McpStdioProfileClient.js";
+export { redactHeaders, redactValue } from "./redaction.js";
+//# sourceMappingURL=index.js.map

package/dist/mcp/redaction.d.ts

@@ -0,0 +1,3 @@
+export declare function redactHeaders(headers: Record<string, string> | undefined): Record<string, string> | undefined;
+export declare function redactValue(value: unknown): unknown;
+//# sourceMappingURL=redaction.d.ts.map