@xopcai/xopc 0.0.368 → 0.0.370

package/dist/src/agent/mcp/index.js

@@ -1,12 +0,0 @@
-import { mcpToolPolicyId } from "./bundle-mcp-policy.js";
-import { loadMergedBundleMcpConfig } from "./bundle-mcp-config.js";
-import { loadEmbeddedMcpConfig } from "./embedded-mcp.js";
-import { McpAuthorizationRequiredError, isMcpAuthorizationError } from "./oauth/mcp-oauth-errors.js";
-import { McpOAuthStore, canonicalMcpServerUrl, mcpOAuthServerKey } from "./oauth/mcp-oauth-store.js";
-import { XopcMcpOAuthClientProvider } from "./oauth/mcp-oauth-provider.js";
-import { __testing, createSessionMcpRuntime, disposeAllSessionMcpRuntimes, disposeSessionMcpRuntime, getOrCreateSessionMcpRuntime, getSessionMcpRuntimeManager, retireSessionMcpRuntime, retireSessionMcpRuntimeForConversationId } from "./bundle-mcp-runtime.js";
-import "./bundle-mcp-tools.js";
-import { McpOAuthSession } from "./oauth/mcp-oauth-session.js";
-import { McpOAuthManager, getMcpOAuthManager } from "./oauth/mcp-oauth-manager.js";
-import "./oauth/index.js";
-export { McpAuthorizationRequiredError, McpOAuthManager, McpOAuthSession, McpOAuthStore, XopcMcpOAuthClientProvider, __testing, canonicalMcpServerUrl, createSessionMcpRuntime, disposeAllSessionMcpRuntimes, disposeSessionMcpRuntime, getMcpOAuthManager, getOrCreateSessionMcpRuntime, getSessionMcpRuntimeManager, isMcpAuthorizationError, loadEmbeddedMcpConfig, loadMergedBundleMcpConfig, mcpOAuthServerKey, mcpToolPolicyId, retireSessionMcpRuntime, retireSessionMcpRuntimeForConversationId };

package/dist/src/agent/mcp/mcp-config-shared.d.ts

@@ -1,8 +0,0 @@
-export declare function isMcpConfigRecord(value: unknown): value is Record<string, unknown>;
-export declare function toMcpStringRecord(value: unknown, options?: {
-    onDroppedEntry?: (key: string, value: unknown) => void;
-}): Record<string, string> | undefined;
-export declare function toMcpEnvRecord(value: unknown, options?: {
-    onDroppedEntry?: (key: string, value: unknown) => void;
-}): Record<string, string> | undefined;
-export declare function toMcpStringArray(value: unknown): string[] | undefined;

package/dist/src/agent/mcp/mcp-config-shared.js

@@ -1,39 +0,0 @@
-import { isDangerousHostEnvVarName } from "../../infra/host-env-security.js";
-//#region src/agent/mcp/mcp-config-shared.ts
-function isMcpConfigRecord(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function toMcpFilteredStringRecord(value, options) {
-	if (!isMcpConfigRecord(value)) return;
-	let droppedByKey = false;
-	const entries = Object.entries(value).map(([key, entry]) => {
-		if (options?.shouldDropKey?.(key)) {
-			droppedByKey = true;
-			options?.onDroppedEntry?.(key, entry);
-			return null;
-		}
-		if (typeof entry === "string") return [key, entry];
-		if (typeof entry === "number" || typeof entry === "boolean") return [key, String(entry)];
-		options?.onDroppedEntry?.(key, entry);
-		return null;
-	}).filter((entry) => entry !== null);
-	if (entries.length === 0 && droppedByKey && options?.preserveEmptyWhenKeysDropped) return {};
-	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
-}
-function toMcpStringRecord(value, options) {
-	return toMcpFilteredStringRecord(value, options);
-}
-function toMcpEnvRecord(value, options) {
-	return toMcpFilteredStringRecord(value, {
-		...options,
-		preserveEmptyWhenKeysDropped: true,
-		shouldDropKey: (key) => isDangerousHostEnvVarName(key)
-	});
-}
-function toMcpStringArray(value) {
-	if (!Array.isArray(value)) return;
-	const entries = value.filter((entry) => typeof entry === "string");
-	return entries.length > 0 ? entries : [];
-}
-//#endregion
-export { isMcpConfigRecord, toMcpEnvRecord, toMcpStringArray, toMcpStringRecord };

package/dist/src/agent/mcp/mcp-http.d.ts

@@ -1,23 +0,0 @@
-export type HttpMcpTransportType = "sse" | "streamable-http";
-export type HttpMcpServerLaunchConfig = {
-    transportType: HttpMcpTransportType;
-    url: string;
-    headers?: Record<string, string>;
-    auth?: {
-        type: "oauth";
-        clientId?: string;
-    };
-};
-export type HttpMcpServerLaunchResult = {
-    ok: true;
-    config: HttpMcpServerLaunchConfig;
-} | {
-    ok: false;
-    reason: string;
-};
-export declare function resolveHttpMcpServerLaunchConfig(raw: unknown, options?: {
-    transportType?: HttpMcpTransportType;
-    onDroppedHeader?: (key: string, value: unknown) => void;
-    onMalformedHeaders?: (value: unknown) => void;
-}): HttpMcpServerLaunchResult;
-export declare function describeHttpMcpServerLaunchConfig(config: HttpMcpServerLaunchConfig): string;

package/dist/src/agent/mcp/mcp-http.js

@@ -1,67 +0,0 @@
-import { redactSensitiveUrl, redactSensitiveUrlLikeString } from "../../utils/redact-sensitive-url.js";
-import { isMcpConfigRecord, toMcpStringRecord } from "./mcp-config-shared.js";
-//#region src/agent/mcp/mcp-http.ts
-function resolveHttpMcpServerLaunchConfig(raw, options) {
-	if (!isMcpConfigRecord(raw)) return {
-		ok: false,
-		reason: "server config must be an object"
-	};
-	if (typeof raw.url !== "string" || raw.url.trim().length === 0) return {
-		ok: false,
-		reason: "its url is missing"
-	};
-	const url = raw.url.trim();
-	let parsed;
-	try {
-		parsed = new URL(url);
-	} catch {
-		return {
-			ok: false,
-			reason: `its url is not a valid URL: ${redactSensitiveUrlLikeString(url)}`
-		};
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return {
-		ok: false,
-		reason: `only http and https URLs are supported, got ${parsed.protocol}`
-	};
-	let headers;
-	if (raw.headers !== void 0 && raw.headers !== null) if (!isMcpConfigRecord(raw.headers)) options?.onMalformedHeaders?.(raw.headers);
-	else headers = toMcpStringRecord(raw.headers, { onDroppedEntry: options?.onDroppedHeader });
-	let auth;
-	if (raw.auth !== void 0) {
-		if (!isMcpConfigRecord(raw.auth) || raw.auth.type !== "oauth") return {
-			ok: false,
-			reason: "its auth must be { \"type\": \"oauth\" }"
-		};
-		if (raw.auth.clientId !== void 0 && (typeof raw.auth.clientId !== "string" || !raw.auth.clientId.trim())) return {
-			ok: false,
-			reason: "its OAuth clientId must be a non-empty string"
-		};
-		if ((options?.transportType ?? "streamable-http") !== "streamable-http") return {
-			ok: false,
-			reason: "OAuth supports streamable HTTP only"
-		};
-		if (headers && Object.keys(headers).some((key) => key.toLowerCase() === "authorization")) return {
-			ok: false,
-			reason: "OAuth cannot be combined with a static Authorization header"
-		};
-		auth = {
-			type: "oauth",
-			...typeof raw.auth.clientId === "string" ? { clientId: raw.auth.clientId.trim() } : {}
-		};
-	}
-	return {
-		ok: true,
-		config: {
-			transportType: options?.transportType ?? "streamable-http",
-			url,
-			headers,
-			auth
-		}
-	};
-}
-function describeHttpMcpServerLaunchConfig(config) {
-	return redactSensitiveUrl(config.url);
-}
-//#endregion
-export { describeHttpMcpServerLaunchConfig, resolveHttpMcpServerLaunchConfig };

package/dist/src/agent/mcp/mcp-resource-id.d.ts

@@ -1,6 +0,0 @@
-export interface McpResourceIdentity {
-    serverId: string;
-    uri: string;
-}
-export declare function encodeMcpResourceId(identity: McpResourceIdentity): string;
-export declare function decodeMcpResourceId(sourceId: string): McpResourceIdentity | null;

package/dist/src/agent/mcp/mcp-resource-id.js

@@ -1,19 +0,0 @@
-//#region src/agent/mcp/mcp-resource-id.ts
-function encodeMcpResourceId(identity) {
-	return Buffer.from(JSON.stringify(identity), "utf8").toString("base64url");
-}
-function decodeMcpResourceId(sourceId) {
-	try {
-		const value = JSON.parse(Buffer.from(sourceId, "base64url").toString("utf8"));
-		if (typeof value.serverId !== "string" || !value.serverId.trim()) return null;
-		if (typeof value.uri !== "string" || !value.uri.trim()) return null;
-		return {
-			serverId: value.serverId,
-			uri: value.uri
-		};
-	} catch {
-		return null;
-	}
-}
-//#endregion
-export { decodeMcpResourceId, encodeMcpResourceId };

package/dist/src/agent/mcp/mcp-stdio-transport.d.ts

@@ -1,26 +0,0 @@
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
-export type XopcStdioServerParameters = {
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
-    stderr?: "pipe" | "overlapped" | "inherit" | "ignore";
-    pluginDataDir?: string;
-};
-export declare class XopcStdioClientTransport implements Transport {
-    private readonly serverParams;
-    onclose?: () => void;
-    onerror?: (error: Error) => void;
-    onmessage?: (message: JSONRPCMessage) => void;
-    private readonly readBuffer;
-    private readonly stderrStream;
-    private process?;
-    constructor(serverParams: XopcStdioServerParameters);
-    start(): Promise<void>;
-    get stderr(): import("node:stream").Readable;
-    get pid(): number;
-    private processReadBuffer;
-    close(): Promise<void>;
-    send(message: JSONRPCMessage): Promise<void>;
-}

package/dist/src/agent/mcp/mcp-stdio-transport.js

@@ -1,120 +0,0 @@
-import { terminateProcess } from "../../process/kill-tree.js";
-import { containedPath } from "../../extensions/agent-plugins/validation.js";
-import { spawn } from "node:child_process";
-import { mkdir } from "node:fs/promises";
-import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
-import process from "node:process";
-import { PassThrough } from "node:stream";
-import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
-//#region src/agent/mcp/mcp-stdio-transport.ts
-const CLOSE_TIMEOUT_MS = 2e3;
-function delay(ms) {
-	return new Promise((resolve) => {
-		setTimeout(resolve, ms).unref();
-	});
-}
-var XopcStdioClientTransport = class {
-	onclose;
-	onerror;
-	onmessage;
-	readBuffer = new ReadBuffer();
-	stderrStream = null;
-	process;
-	constructor(serverParams) {
-		this.serverParams = serverParams;
-		if (serverParams.stderr === "pipe" || serverParams.stderr === "overlapped") this.stderrStream = new PassThrough();
-	}
-	async start() {
-		if (this.process) throw new Error("XopcStdioClientTransport already started; Client.connect() starts transports automatically.");
-		if (this.serverParams.pluginDataDir) {
-			const data = this.serverParams.pluginDataDir;
-			await mkdir(data, {
-				recursive: true,
-				mode: 448
-			});
-			if (this.serverParams.cwd) containedPath(this.serverParams.cwd.startsWith(data) ? data : this.serverParams.env?.PLUGIN_ROOT ?? data, this.serverParams.cwd);
-		}
-		await new Promise((resolve, reject) => {
-			const baseEnv = {
-				...getDefaultEnvironment(),
-				...this.serverParams.env
-			};
-			const child = spawn(this.serverParams.command, this.serverParams.args ?? [], {
-				cwd: this.serverParams.cwd,
-				detached: process.platform !== "win32",
-				env: baseEnv,
-				shell: false,
-				stdio: [
-					"pipe",
-					"pipe",
-					this.serverParams.stderr ?? "inherit"
-				],
-				windowsHide: process.platform === "win32"
-			});
-			this.process = child;
-			child.on("error", (error) => {
-				reject(error);
-				this.onerror?.(error);
-			});
-			child.on("spawn", () => resolve());
-			child.on("close", () => {
-				this.process = void 0;
-				this.onclose?.();
-			});
-			child.stdin?.on("error", (error) => this.onerror?.(error));
-			child.stdout?.on("data", (chunk) => {
-				this.readBuffer.append(chunk);
-				this.processReadBuffer();
-			});
-			child.stdout?.on("error", (error) => this.onerror?.(error));
-			if (this.stderrStream && child.stderr) child.stderr.pipe(this.stderrStream);
-		});
-	}
-	get stderr() {
-		return this.stderrStream ?? this.process?.stderr ?? null;
-	}
-	get pid() {
-		return this.process?.pid ?? null;
-	}
-	processReadBuffer() {
-		while (true) try {
-			const message = this.readBuffer.readMessage();
-			if (message === null) break;
-			this.onmessage?.(message);
-		} catch (error) {
-			this.onerror?.(error instanceof Error ? error : new Error(String(error)));
-		}
-	}
-	async close() {
-		const processToClose = this.process;
-		this.process = void 0;
-		if (processToClose) {
-			const closePromise = new Promise((resolve) => {
-				processToClose.once("close", () => resolve());
-			});
-			try {
-				processToClose.stdin?.end();
-			} catch {}
-			await Promise.race([closePromise, delay(CLOSE_TIMEOUT_MS)]);
-			if (processToClose.exitCode === null && processToClose.pid) {
-				await terminateProcess(processToClose, {
-					tree: true,
-					detached: process.platform !== "win32"
-				});
-				await Promise.race([closePromise, delay(CLOSE_TIMEOUT_MS)]);
-			}
-		}
-		this.readBuffer.clear();
-	}
-	send(message) {
-		return new Promise((resolve) => {
-			const stdin = this.process?.stdin;
-			if (!stdin) throw new Error("Not connected");
-			const json = serializeMessage(message);
-			if (stdin.write(json)) resolve();
-			else stdin.once("drain", resolve);
-		});
-	}
-};
-//#endregion
-export { XopcStdioClientTransport };

package/dist/src/agent/mcp/mcp-stdio.d.ts

@@ -1,18 +0,0 @@
-type StdioMcpServerLaunchConfig = {
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
-};
-type StdioMcpServerLaunchResult = {
-    ok: true;
-    config: StdioMcpServerLaunchConfig;
-} | {
-    ok: false;
-    reason: string;
-};
-export declare function resolveStdioMcpServerLaunchConfig(raw: unknown, options?: {
-    onDroppedEnv?: (key: string, value: unknown) => void;
-}): StdioMcpServerLaunchResult;
-export declare function describeStdioMcpServerLaunchConfig(config: StdioMcpServerLaunchConfig): string;
-export type { StdioMcpServerLaunchConfig, StdioMcpServerLaunchResult };

package/dist/src/agent/mcp/mcp-stdio.js

@@ -1,35 +0,0 @@
-import { isMcpConfigRecord, toMcpEnvRecord, toMcpStringArray } from "./mcp-config-shared.js";
-//#region src/agent/mcp/mcp-stdio.ts
-function resolveStdioMcpServerLaunchConfig(raw, options) {
-	if (!isMcpConfigRecord(raw)) return {
-		ok: false,
-		reason: "server config must be an object"
-	};
-	if (typeof raw.command !== "string" || raw.command.trim().length === 0) {
-		if (typeof raw.url === "string" && raw.url.trim().length > 0) return {
-			ok: false,
-			reason: "not a stdio server (has url)"
-		};
-		return {
-			ok: false,
-			reason: "its command is missing"
-		};
-	}
-	const cwd = typeof raw.cwd === "string" && raw.cwd.trim().length > 0 ? raw.cwd : typeof raw.workingDirectory === "string" && raw.workingDirectory.trim().length > 0 ? raw.workingDirectory : void 0;
-	return {
-		ok: true,
-		config: {
-			command: raw.command,
-			args: toMcpStringArray(raw.args),
-			env: toMcpEnvRecord(raw.env, { onDroppedEntry: options?.onDroppedEnv }),
-			cwd
-		}
-	};
-}
-function describeStdioMcpServerLaunchConfig(config) {
-	const args = Array.isArray(config.args) && config.args.length > 0 ? ` ${config.args.join(" ")}` : "";
-	const cwd = config.cwd ? ` (cwd=${config.cwd})` : "";
-	return `${config.command}${args}${cwd}`;
-}
-//#endregion
-export { describeStdioMcpServerLaunchConfig, resolveStdioMcpServerLaunchConfig };

package/dist/src/agent/mcp/mcp-transport-config.d.ts

@@ -1,28 +0,0 @@
-import { type HttpMcpTransportType } from "./mcp-http.js";
-type ResolvedBaseMcpTransportConfig = {
-    description: string;
-    connectionTimeoutMs: number;
-    requestTimeoutMs: number;
-};
-export type ResolvedStdioMcpTransportConfig = ResolvedBaseMcpTransportConfig & {
-    kind: "stdio";
-    transportType: "stdio";
-    command: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
-};
-export type ResolvedHttpMcpTransportConfig = ResolvedBaseMcpTransportConfig & {
-    kind: "http";
-    transportType: HttpMcpTransportType;
-    url: string;
-    headers?: Record<string, string>;
-    auth?: {
-        type: "oauth";
-        clientId?: string;
-    };
-};
-export type ResolvedMcpTransportConfig = ResolvedStdioMcpTransportConfig | ResolvedHttpMcpTransportConfig;
-export declare const DEFAULT_MCP_REQUEST_TIMEOUT_MS: number;
-export declare function resolveMcpTransportConfig(serverName: string, rawServer: unknown): ResolvedMcpTransportConfig | null;
-export {};

package/dist/src/agent/mcp/mcp-transport-config.js

@@ -1,91 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { init_string_coerce, normalizeLowercaseStringOrEmpty } from "../../utils/string-coerce.js";
-import { resolveXopcMcpTransportAlias } from "../../config/mcp-config-normalize.js";
-import { sanitizeForLog } from "../../utils/sanitize-log.js";
-import { describeHttpMcpServerLaunchConfig, resolveHttpMcpServerLaunchConfig } from "./mcp-http.js";
-import { describeStdioMcpServerLaunchConfig, resolveStdioMcpServerLaunchConfig } from "./mcp-stdio.js";
-//#region src/agent/mcp/mcp-transport-config.ts
-init_logger();
-init_string_coerce();
-const log = createLogger("Mcp:Bundle");
-const DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
-const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 1800 * 1e3;
-function getConnectionTimeoutMs(rawServer) {
-	if (rawServer && typeof rawServer === "object" && typeof rawServer.connectionTimeoutMs === "number" && rawServer.connectionTimeoutMs > 0) return rawServer.connectionTimeoutMs;
-	return DEFAULT_CONNECTION_TIMEOUT_MS;
-}
-function getRequestTimeoutMs(rawServer) {
-	if (rawServer && typeof rawServer === "object" && typeof rawServer.requestTimeoutMs === "number" && rawServer.requestTimeoutMs > 0) return rawServer.requestTimeoutMs;
-	return DEFAULT_MCP_REQUEST_TIMEOUT_MS;
-}
-function getRequestedTransport(rawServer) {
-	if (!rawServer || typeof rawServer !== "object" || typeof rawServer.transport !== "string") return "";
-	return normalizeLowercaseStringOrEmpty(rawServer.transport);
-}
-function getRequestedTransportAlias(rawServer) {
-	if (!rawServer || typeof rawServer !== "object" || typeof rawServer.type !== "string") return "";
-	return resolveXopcMcpTransportAlias(rawServer.type) ?? "";
-}
-function resolveHttpTransportConfig(serverName, rawServer, transportType) {
-	const launch = resolveHttpMcpServerLaunchConfig(rawServer, {
-		transportType,
-		onDroppedHeader: (key) => {
-			log.warn({
-				phase: "agent.mcp_connect",
-				serverName,
-				header: key
-			}, `bundle-mcp: server "${serverName}": header "${key}" has an unsupported value type and was ignored`);
-		},
-		onMalformedHeaders: () => {
-			log.warn({
-				phase: "agent.mcp_connect",
-				serverName
-			}, `bundle-mcp: server "${serverName}": "headers" must be a JSON object; the value was ignored`);
-		}
-	});
-	if (!launch.ok) return null;
-	return {
-		kind: "http",
-		transportType: launch.config.transportType,
-		url: launch.config.url,
-		headers: launch.config.headers,
-		auth: launch.config.auth,
-		description: describeHttpMcpServerLaunchConfig(launch.config),
-		connectionTimeoutMs: getConnectionTimeoutMs(rawServer),
-		requestTimeoutMs: getRequestTimeoutMs(rawServer)
-	};
-}
-function resolveMcpTransportConfig(serverName, rawServer) {
-	const logServerName = sanitizeForLog(serverName);
-	const requestedTransport = getRequestedTransport(rawServer);
-	const requestedTransportAlias = requestedTransport ? "" : getRequestedTransportAlias(rawServer);
-	const effectiveTransport = requestedTransport || requestedTransportAlias;
-	const stdioLaunch = resolveStdioMcpServerLaunchConfig(rawServer, { onDroppedEnv: (key) => {
-		log.warn(`bundle-mcp: server "${logServerName}": env "${sanitizeForLog(key)}" is blocked for stdio startup safety and was ignored.`);
-	} });
-	if (stdioLaunch.ok) return {
-		kind: "stdio",
-		transportType: "stdio",
-		command: stdioLaunch.config.command,
-		args: stdioLaunch.config.args,
-		env: stdioLaunch.config.env,
-		cwd: stdioLaunch.config.cwd,
-		description: describeStdioMcpServerLaunchConfig(stdioLaunch.config),
-		connectionTimeoutMs: getConnectionTimeoutMs(rawServer),
-		requestTimeoutMs: getRequestTimeoutMs(rawServer)
-	};
-	if (effectiveTransport && effectiveTransport !== "sse" && effectiveTransport !== "streamable-http") {
-		log.warn(`bundle-mcp: skipped server "${logServerName}" because transport "${sanitizeForLog(effectiveTransport)}" is not supported.`);
-		return null;
-	}
-	const httpTransport = resolveHttpTransportConfig(serverName, rawServer, effectiveTransport === "sse" ? "sse" : "streamable-http");
-	if (httpTransport) return httpTransport;
-	const stdioReason = stdioLaunch.ok === false ? stdioLaunch.reason : "not a stdio server";
-	const httpLaunch = resolveHttpMcpServerLaunchConfig(rawServer);
-	const httpReason = httpLaunch.ok === false ? httpLaunch.reason : "not an HTTP MCP server";
-	log.warn(`bundle-mcp: skipped server "${logServerName}" because ${stdioReason} and ${httpReason}.`);
-	return null;
-}
-//#endregion
-export { DEFAULT_MCP_REQUEST_TIMEOUT_MS, resolveMcpTransportConfig };

package/dist/src/agent/mcp/mcp-transport.d.ts

@@ -1,17 +0,0 @@
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import type { Config } from "../../config/schema.js";
-import { McpOAuthStore } from "./oauth/mcp-oauth-store.js";
-export type ResolvedMcpTransport = {
-    transport: Transport;
-    description: string;
-    transportType: "stdio" | "sse" | "streamable-http";
-    connectionTimeoutMs: number;
-    requestTimeoutMs: number;
-    detachStderr?: () => void;
-};
-export type ResolveMcpTransportOptions = {
-    oauthProvider?: OAuthClientProvider;
-    oauthStore?: McpOAuthStore;
-};
-export declare function resolveMcpTransport(serverName: string, rawServer: unknown, config?: Config, options?: ResolveMcpTransportOptions): Promise<ResolvedMcpTransport | null>;

package/dist/src/agent/mcp/mcp-transport.js

@@ -1,141 +0,0 @@
-import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { init_string_coerce, normalizeOptionalString } from "../../utils/string-coerce.js";
-import { buildRuntimeEnvironment, resolveRuntimeCommand } from "../../runtime-tools/environment.js";
-import { XopcStdioClientTransport } from "./mcp-stdio-transport.js";
-import { resolveMcpTransportConfig } from "./mcp-transport-config.js";
-import { McpOAuthStore } from "./oauth/mcp-oauth-store.js";
-import { XopcMcpOAuthClientProvider } from "./oauth/mcp-oauth-provider.js";
-import { createPluginHttpFetch } from "./plugin-http-fetch.js";
-import { pluginOAuthScope } from "../../extensions/agent-plugins/plugin-oauth-scope.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { fetch } from "undici";
-//#region src/agent/mcp/mcp-transport.ts
-init_paths_state();
-init_logger();
-init_string_coerce();
-const log = createLogger("Mcp:Transport");
-function attachStderrLogging(serverName, transport) {
-	const stderr = transport.stderr;
-	if (!stderr || typeof stderr.on !== "function") return;
-	const onData = (chunk) => {
-		const message = normalizeOptionalString(typeof chunk === "string" ? chunk : String(chunk)) ?? "";
-		if (!message) return;
-		for (const line of message.split(/\r?\n/)) {
-			const trimmed = line.trim();
-			if (trimmed) log.debug(`bundle-mcp:${serverName}: ${trimmed}`);
-		}
-	};
-	stderr.on("data", onData);
-	return () => {
-		if (typeof stderr.off === "function") stderr.off("data", onData);
-		else if (typeof stderr.removeListener === "function") stderr.removeListener("data", onData);
-	};
-}
-const fetchWithUndici = async (url, init) => await fetch(url, init);
-function buildSseEventSourceFetch(headers) {
-	return (url, init) => {
-		const sdkHeaders = {};
-		if (init?.headers) if (init.headers instanceof Headers) init.headers.forEach((value, key) => {
-			sdkHeaders[key] = value;
-		});
-		else Object.assign(sdkHeaders, init.headers);
-		return fetchWithUndici(url, {
-			...init,
-			headers: {
-				...sdkHeaders,
-				...headers
-			}
-		});
-	};
-}
-function buildScopedHttpFetch(serverUrl, headers) {
-	return async (url, init) => {
-		const mergedHeaders = new Headers();
-		if (new URL(url).origin === serverUrl.origin) for (const [key, value] of Object.entries(headers)) mergedHeaders.set(key, value);
-		if (init?.headers) new Headers(init.headers).forEach((value, key) => mergedHeaders.set(key, value));
-		return fetchWithUndici(url, {
-			...init,
-			headers: mergedHeaders
-		});
-	};
-}
-async function resolveMcpTransport(serverName, rawServer, config, options = {}) {
-	const resolved = resolveMcpTransportConfig(serverName, rawServer);
-	if (!resolved) return null;
-	const plugin = rawServer && typeof rawServer === "object" ? rawServer.xopcPlugin : void 0;
-	if (resolved.kind === "stdio") {
-		const command = config ? await resolveRuntimeCommand({
-			command: resolved.command,
-			stateDir: resolveStateDir(),
-			config: config.runtimeTools,
-			allowProvision: true
-		}) : resolved.command;
-		const env = config ? (await buildRuntimeEnvironment({
-			stateDir: resolveStateDir(),
-			config: config.runtimeTools,
-			baseEnv: {
-				...getDefaultEnvironment(),
-				...resolved.env
-			}
-		})).env : resolved.env;
-		const transport = new XopcStdioClientTransport({
-			command,
-			args: resolved.args,
-			env,
-			cwd: resolved.cwd,
-			stderr: "pipe",
-			pluginDataDir: plugin?.dataDir
-		});
-		return {
-			transport,
-			description: command === resolved.command ? resolved.description : `${command}${resolved.args?.length ? ` ${resolved.args.join(" ")}` : ""}`,
-			transportType: "stdio",
-			connectionTimeoutMs: resolved.connectionTimeoutMs,
-			requestTimeoutMs: resolved.requestTimeoutMs,
-			detachStderr: attachStderrLogging(serverName, transport)
-		};
-	}
-	if (resolved.transportType === "streamable-http") {
-		const serverUrl = new URL(resolved.url);
-		const oauthEnabled = Boolean(resolved.auth);
-		let oauthProvider = options.oauthProvider;
-		if (resolved.auth && !oauthProvider) {
-			const store = options.oauthStore ?? new McpOAuthStore(pluginOAuthScope(rawServer));
-			if ((await store.load(serverUrl))?.tokens) oauthProvider = new XopcMcpOAuthClientProvider({
-				serverUrl,
-				clientId: resolved.auth.clientId,
-				store
-			});
-		}
-		return {
-			transport: new StreamableHTTPClientTransport(serverUrl, {
-				authProvider: oauthProvider,
-				requestInit: !plugin && !oauthEnabled && resolved.headers ? { headers: resolved.headers } : void 0,
-				fetch: plugin ? createPluginHttpFetch(serverUrl, resolved.headers ?? {}) : oauthEnabled ? buildScopedHttpFetch(serverUrl, resolved.headers ?? {}) : fetchWithUndici
-			}),
-			description: resolved.description,
-			transportType: "streamable-http",
-			connectionTimeoutMs: resolved.connectionTimeoutMs,
-			requestTimeoutMs: resolved.requestTimeoutMs
-		};
-	}
-	const headers = { ...resolved.headers };
-	const hasHeaders = Object.keys(headers).length > 0;
-	return {
-		transport: new SSEClientTransport(new URL(resolved.url), {
-			requestInit: !plugin && hasHeaders ? { headers } : void 0,
-			fetch: plugin ? createPluginHttpFetch(new URL(resolved.url), headers) : fetchWithUndici,
-			eventSourceInit: { fetch: plugin ? createPluginHttpFetch(new URL(resolved.url), headers) : buildSseEventSourceFetch(headers) }
-		}),
-		description: resolved.description,
-		transportType: "sse",
-		connectionTimeoutMs: resolved.connectionTimeoutMs,
-		requestTimeoutMs: resolved.requestTimeoutMs
-	};
-}
-//#endregion
-export { resolveMcpTransport };

package/dist/src/agent/mcp/oauth/index.d.ts

@@ -1,6 +0,0 @@
-export * from './mcp-oauth-errors.js';
-export * from './mcp-oauth-manager.js';
-export * from './mcp-oauth-provider.js';
-export * from './mcp-oauth-session.js';
-export * from './mcp-oauth-store.js';
-export type * from './mcp-oauth-types.js';