@alfe.ai/mcp-bundler 0.0.1

package/dist/index.js

@@ -0,0 +1,454 @@
+//#region src/tool-naming.ts
+/**
+* Tool name sanitization and collision handling.
+*
+* OpenClaw constraint: tool names must match `[A-Za-z0-9_-]` and be ≤64 chars.
+* Pattern mirrored from `openclaw/src/agents/pi-bundle-mcp-names.ts`.
+*
+* Strategy: prefix every tool with its server name (`{server}__{tool}`),
+* sanitize disallowed chars to `_`, truncate, then suffix-disambiguate
+* (`-2`, `-3`, ...) on collision.
+*/
+const DISALLOWED = /[^A-Za-z0-9_-]/g;
+const MAX_LEN = 64;
+const SEPARATOR = "__";
+function sanitizeNameSegment(value) {
+	return value.replace(DISALLOWED, "_");
+}
+function buildNamespacedToolName(server, tool) {
+	const base = `${sanitizeNameSegment(server)}${SEPARATOR}${sanitizeNameSegment(tool)}`;
+	if (base.length <= MAX_LEN) return base;
+	const reservedForServer = sanitizeNameSegment(server).length + 2;
+	const toolBudget = Math.max(1, MAX_LEN - reservedForServer);
+	return `${sanitizeNameSegment(server)}${SEPARATOR}${sanitizeNameSegment(tool).slice(0, toolBudget)}`;
+}
+/**
+* Disambiguate a candidate name against an existing set by appending `-2`, `-3`, etc.
+* Mutates nothing; returns the chosen name. Caller is responsible for inserting it
+* into the set.
+*/
+function disambiguateAgainst(candidate, taken) {
+	if (!taken.has(candidate)) return candidate;
+	for (let i = 2; i < 1e3; i += 1) {
+		const suffix = `-${i.toString()}`;
+		const room = MAX_LEN - suffix.length;
+		const next = `${candidate.length > room ? candidate.slice(0, room) : candidate}${suffix}`;
+		if (!taken.has(next)) return next;
+	}
+	return `${candidate.slice(0, MAX_LEN - 6)}-x${(taken.size % 1e3).toString().padStart(3, "0")}`;
+}
+//#endregion
+//#region src/connection.ts
+/** Env keys OpenClaw rejects from stdio MCP env blocks. Filter them out before spawning. */
+const STDIO_ENV_DENYLIST = new Set([
+	"NODE_OPTIONS",
+	"PYTHONSTARTUP",
+	"PYTHONPATH",
+	"PERL5OPT",
+	"RUBYOPT",
+	"SHELLOPTS",
+	"PS4"
+]);
+function sanitizeStdioEnv(env) {
+	if (!env) return {};
+	const safe = {};
+	for (const [k, v] of Object.entries(env)) {
+		if (STDIO_ENV_DENYLIST.has(k)) continue;
+		safe[k] = v;
+	}
+	return safe;
+}
+/**
+* One Connection per MCP server. Owns lifecycle (lazy-spawn, close, refresh-lock).
+* Refresh-lock pattern adapted from AIWerk `index.ts:219-250` — prevents
+* reconnect + `notifications/tools/list_changed` race.
+*/
+var Connection = class {
+	name;
+	config;
+	deps;
+	logger;
+	client;
+	tools = [];
+	connectInFlight;
+	refreshInFlight = false;
+	refreshQueued = false;
+	lastUsedAt = Date.now();
+	constructor(params) {
+		this.name = params.name;
+		this.config = params.config;
+		this.deps = params.deps;
+		this.logger = params.logger;
+	}
+	/** Returns the most recent known tool list. May be empty if the server hasn't connected yet. */
+	snapshotTools() {
+		return this.tools;
+	}
+	/** Whether an MCP child process / remote connection has been established. */
+	isConnected() {
+		return this.client !== void 0;
+	}
+	/** Idle timestamp for reaping. */
+	idleSinceMs() {
+		return Date.now() - this.lastUsedAt;
+	}
+	/**
+	* Lazy connect + tool discovery. Safe to call concurrently; in-flight
+	* connects coalesce.
+	*/
+	async ensureConnected() {
+		if (this.client) return;
+		if (this.connectInFlight) return this.connectInFlight;
+		this.connectInFlight = this.connectAndDiscover().finally(() => {
+			this.connectInFlight = void 0;
+		});
+		return this.connectInFlight;
+	}
+	async connectAndDiscover() {
+		const safeConfig = "command" in this.config ? {
+			...this.config,
+			env: sanitizeStdioEnv(this.config.env)
+		} : this.config;
+		this.logger?.debug(`[mcp-bundler] connecting server "${this.name}"`);
+		const client = await this.deps.connect(safeConfig);
+		try {
+			const advertised = await client.listTools();
+			this.client = client;
+			this.tools = advertised.map((t) => ({
+				prefixed: buildNamespacedToolName(this.name, t.name),
+				server: this.name,
+				original: t.name,
+				label: (t.description ?? t.name).slice(0, 80),
+				description: t.description ?? "",
+				parameters: t.inputSchema
+			}));
+			this.lastUsedAt = Date.now();
+			this.logger?.info(`[mcp-bundler] server "${this.name}" connected, ${this.tools.length.toString()} tool(s)`);
+		} catch (err) {
+			await client.close().catch(() => void 0);
+			throw err;
+		}
+	}
+	/**
+	* Re-discover tools. Used on reconnect or `tools/list_changed` notification.
+	* Refresh-lock collapses concurrent refreshes; if one is in flight, the next
+	* is queued (max 1 queued, since N>1 queued provides no extra freshness).
+	*/
+	async refresh() {
+		if (!this.client) return this.ensureConnected();
+		if (this.refreshInFlight) {
+			this.refreshQueued = true;
+			return;
+		}
+		this.refreshInFlight = true;
+		try {
+			this.tools = (await this.client.listTools()).map((t) => ({
+				prefixed: buildNamespacedToolName(this.name, t.name),
+				server: this.name,
+				original: t.name,
+				label: (t.description ?? t.name).slice(0, 80),
+				description: t.description ?? "",
+				parameters: t.inputSchema
+			}));
+			this.logger?.debug(`[mcp-bundler] server "${this.name}" refreshed, ${this.tools.length.toString()} tool(s)`);
+		} finally {
+			this.refreshInFlight = false;
+			if (this.refreshQueued) {
+				this.refreshQueued = false;
+				this.refresh().catch((err) => {
+					this.logger?.warn(`[mcp-bundler] queued refresh for "${this.name}" failed`, { err: err instanceof Error ? err.message : String(err) });
+				});
+			}
+		}
+	}
+	async callTool(originalName, args, signal) {
+		await this.ensureConnected();
+		if (!this.client) throw new Error(`server "${this.name}" failed to connect`);
+		this.lastUsedAt = Date.now();
+		return this.client.callTool(originalName, args, signal ? { signal } : void 0);
+	}
+	/**
+	* Close the underlying transport. Idempotent. If a connect is in flight
+	* (warmup racing with reconcile-removal), wait for it to settle and then
+	* close the client it produced — otherwise the child process is orphaned.
+	*/
+	async close() {
+		if (this.connectInFlight) await this.connectInFlight.catch(() => void 0);
+		const c = this.client;
+		this.client = void 0;
+		this.tools = [];
+		if (c) await c.close().catch((err) => {
+			this.logger?.warn(`[mcp-bundler] close error for "${this.name}"`, { err: err instanceof Error ? err.message : String(err) });
+		});
+	}
+	/**
+	* Stable hash of the config for diff detection in `reconcile`.
+	* Two configs with the same hash are equivalent (no restart needed).
+	*/
+	configFingerprint() {
+		return JSON.stringify(this.config);
+	}
+};
+/**
+* Build the production `connect` factory using the official MCP SDK.
+* Kept in a separate function so tests can substitute a mock without
+* pulling the SDK into the test bundle.
+*/
+async function defaultConnect(server) {
+	const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+	const client = new Client({
+		name: "alfe-mcp-bundler",
+		version: "0.0.0"
+	}, {});
+	if ("command" in server) {
+		const stdio = server;
+		const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+		const transport = new StdioClientTransport({
+			command: stdio.command,
+			args: stdio.args ?? [],
+			env: { ...sanitizeStdioEnv(stdio.env) },
+			cwd: stdio.cwd
+		});
+		await client.connect(transport);
+	} else {
+		const remote = server;
+		if (remote.transport === "streamable-http") {
+			const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+			const transport = new StreamableHTTPClientTransport(new URL(remote.url), { requestInit: { headers: remote.headers ?? {} } });
+			await client.connect(transport);
+		} else {
+			const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
+			const transport = new SSEClientTransport(new URL(remote.url), { requestInit: { headers: remote.headers ?? {} } });
+			await client.connect(transport);
+		}
+	}
+	return {
+		async listTools() {
+			return (await client.listTools()).tools.map((t) => ({
+				name: t.name,
+				description: t.description,
+				inputSchema: t.inputSchema
+			}));
+		},
+		async callTool(name, args, opts) {
+			return await client.callTool({
+				name,
+				arguments: args
+			}, void 0, opts);
+		},
+		async close() {
+			await client.close();
+		}
+	};
+}
+//#endregion
+//#region src/bundler.ts
+const DEFAULT_IDLE_TTL_MS = 600 * 1e3;
+const DEFAULT_IDLE_SWEEP_INTERVAL_MS = 60 * 1e3;
+/**
+* Provider-agnostic MCP server bundler. Holds N MCP server connections,
+* exposes a unified namespaced tool catalog, and routes calls to the right
+* server.
+*
+* Designed to be embedded in any host (OpenClaw plugin, AI proxy, Lambda).
+* Public surface is intentionally synchronous where the host needs sync
+* (snapshot, listTools), async only where I/O is unavoidable.
+*/
+var McpBundler = class {
+	logger;
+	connections = /* @__PURE__ */ new Map();
+	idleTtlMs;
+	idleSweepIntervalMs;
+	idleSweepTimer;
+	deps;
+	disposed = false;
+	reconcileLatch = Promise.resolve();
+	constructor(opts = {}, deps) {
+		this.logger = opts.logger;
+		this.idleTtlMs = opts.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
+		this.idleSweepIntervalMs = opts.idleSweepIntervalMs ?? DEFAULT_IDLE_SWEEP_INTERVAL_MS;
+		this.deps = deps ?? { connect: defaultConnect };
+		if (this.idleTtlMs > 0) this.startIdleSweep();
+	}
+	/**
+	* Diff `desired` against current connections, spawn newcomers, dispose
+	* removals, hot-restart on config change. Pull-based — call whenever the
+	* host's config snapshot may have changed. Cheap if no diff.
+	*
+	* Lazy: newly-added servers are NOT eagerly connected; they connect on the
+	* first `callTool()` (or first `listTools()` after `forceDiscover()`).
+	* This avoids paying spawn cost for servers the agent never uses.
+	*/
+	async reconcile(desired) {
+		if (this.disposed) throw new Error("McpBundler: disposed");
+		const slot = this.reconcileLatch.then(async () => this.doReconcile(desired));
+		this.reconcileLatch = slot.catch(() => void 0);
+		return slot;
+	}
+	async doReconcile(desired) {
+		if (this.disposed) throw new Error("McpBundler: disposed");
+		const desiredNames = new Set(Object.keys(desired));
+		const currentNames = new Set(this.connections.keys());
+		const added = [];
+		const removed = [];
+		const changed = [];
+		const unchanged = [];
+		for (const name of currentNames) if (!desiredNames.has(name)) {
+			const conn = this.connections.get(name);
+			this.connections.delete(name);
+			if (conn) await conn.close();
+			removed.push(name);
+		}
+		for (const [name, config] of Object.entries(desired)) {
+			const existing = this.connections.get(name);
+			if (!existing) {
+				this.connections.set(name, new Connection({
+					name,
+					config,
+					deps: this.deps,
+					logger: this.logger
+				}));
+				added.push(name);
+				continue;
+			}
+			const nextFingerprint = JSON.stringify(config);
+			if (existing.configFingerprint() !== nextFingerprint) {
+				await existing.close();
+				this.connections.set(name, new Connection({
+					name,
+					config,
+					deps: this.deps,
+					logger: this.logger
+				}));
+				changed.push(name);
+			} else unchanged.push(name);
+		}
+		if (added.length || removed.length || changed.length) this.logger?.info("[mcp-bundler] reconciled", {
+			added: added.length,
+			removed: removed.length,
+			changed: changed.length,
+			unchanged: unchanged.length
+		});
+		return {
+			added,
+			removed,
+			changed,
+			unchanged
+		};
+	}
+	/**
+	* Synchronous snapshot of all currently-known tools across connected servers.
+	* Servers that have not connected yet contribute nothing. Intended for use
+	* inside OpenClaw's plugin tool factory which must be sync.
+	*
+	* Tool names are namespaced and disambiguated (suffix `-2`, `-3` on collision)
+	* so cross-server name clashes never produce duplicate registrations.
+	*/
+	listTools() {
+		const seen = /* @__PURE__ */ new Set();
+		const out = [];
+		for (const conn of this.connections.values()) for (const tool of conn.snapshotTools()) {
+			const finalName = disambiguateAgainst(tool.prefixed, seen);
+			seen.add(finalName);
+			out.push(finalName === tool.prefixed ? tool : {
+				...tool,
+				prefixed: finalName
+			});
+		}
+		return out;
+	}
+	/**
+	* Eagerly connect to every configured server and discover tools. Used by
+	* hosts that want a hot list rather than the lazy default. Errors are
+	* swallowed per-server (logged), so one bad server doesn't fail the batch.
+	*/
+	async warmup() {
+		if (this.disposed) return;
+		await Promise.allSettled(Array.from(this.connections.values()).map(async (conn) => {
+			try {
+				await conn.ensureConnected();
+			} catch (err) {
+				this.logger?.warn(`[mcp-bundler] warmup failed for "${conn.name}"`, { err: err instanceof Error ? err.message : String(err) });
+			}
+		}));
+	}
+	/**
+	* Invoke a tool by its namespaced name. Routes to the originating server.
+	* Errors are returned as `{ isError: true, content: [...] }` so a failing
+	* tool doesn't crash the host.
+	*/
+	async callTool(prefixed, args, signal) {
+		if (this.disposed) return {
+			isError: true,
+			content: [{
+				type: "text",
+				text: "mcp-bundler disposed"
+			}]
+		};
+		const route = this.routeToolName(prefixed);
+		if (!route) return {
+			isError: true,
+			content: [{
+				type: "text",
+				text: `unknown tool: ${prefixed}`
+			}]
+		};
+		try {
+			return await route.connection.callTool(route.original, args, signal);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			this.logger?.error(`[mcp-bundler] tool call failed for "${prefixed}"`, { err: msg });
+			return {
+				isError: true,
+				content: [{
+					type: "text",
+					text: `tool ${prefixed} failed: ${msg}`
+				}]
+			};
+		}
+	}
+	/**
+	* Resolve a namespaced tool name back to its server connection and original
+	* tool name. Returns undefined if the tool is not currently advertised.
+	*/
+	routeToolName(prefixed) {
+		for (const conn of this.connections.values()) for (const tool of conn.snapshotTools()) if (tool.prefixed === prefixed) return {
+			connection: conn,
+			original: tool.original
+		};
+	}
+	/**
+	* Tear down all connections and stop background tasks. Idempotent.
+	* Call from `registerRuntimeLifecycle({ cleanup })` in the host plugin.
+	*/
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		if (this.idleSweepTimer) {
+			clearInterval(this.idleSweepTimer);
+			this.idleSweepTimer = void 0;
+		}
+		await Promise.allSettled(Array.from(this.connections.values()).map((c) => c.close()));
+		this.connections.clear();
+	}
+	startIdleSweep() {
+		this.idleSweepTimer = setInterval(() => {
+			this.sweepIdle().catch((err) => {
+				this.logger?.warn("[mcp-bundler] idle sweep error", { err: err instanceof Error ? err.message : String(err) });
+			});
+		}, this.idleSweepIntervalMs);
+		if (typeof this.idleSweepTimer === "object" && "unref" in this.idleSweepTimer) this.idleSweepTimer.unref();
+	}
+	async sweepIdle() {
+		if (this.idleTtlMs <= 0) return;
+		const targets = [];
+		for (const conn of this.connections.values()) if (conn.isConnected() && conn.idleSinceMs() > this.idleTtlMs) targets.push(conn);
+		if (targets.length === 0) return;
+		this.logger?.debug(`[mcp-bundler] reaping ${targets.length.toString()} idle server(s)`);
+		await Promise.allSettled(targets.map((c) => c.close()));
+	}
+};
+//#endregion
+export { Connection, McpBundler, STDIO_ENV_DENYLIST, buildNamespacedToolName, defaultConnect, disambiguateAgainst, sanitizeNameSegment, sanitizeStdioEnv };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/tool-naming.ts","../src/connection.ts","../src/bundler.ts"],"sourcesContent":["/**\n * Tool name sanitization and collision handling.\n *\n * OpenClaw constraint: tool names must match `[A-Za-z0-9_-]` and be ≤64 chars.\n * Pattern mirrored from `openclaw/src/agents/pi-bundle-mcp-names.ts`.\n *\n * Strategy: prefix every tool with its server name (`{server}__{tool}`),\n * sanitize disallowed chars to `_`, truncate, then suffix-disambiguate\n * (`-2`, `-3`, ...) on collision.\n */\n\nconst DISALLOWED = /[^A-Za-z0-9_-]/g;\nconst MAX_LEN = 64;\nconst SEPARATOR = '__';\n\nexport function sanitizeNameSegment(value: string): string {\n  return value.replace(DISALLOWED, '_');\n}\n\nexport function buildNamespacedToolName(server: string, tool: string): string {\n  const base = `${sanitizeNameSegment(server)}${SEPARATOR}${sanitizeNameSegment(tool)}`;\n  if (base.length <= MAX_LEN) return base;\n  // Truncate from the tool side first to keep the server prefix intact.\n  const reservedForServer = sanitizeNameSegment(server).length + SEPARATOR.length;\n  const toolBudget = Math.max(1, MAX_LEN - reservedForServer);\n  return `${sanitizeNameSegment(server)}${SEPARATOR}${sanitizeNameSegment(tool).slice(0, toolBudget)}`;\n}\n\n/**\n * Disambiguate a candidate name against an existing set by appending `-2`, `-3`, etc.\n * Mutates nothing; returns the chosen name. Caller is responsible for inserting it\n * into the set.\n */\nexport function disambiguateAgainst(candidate: string, taken: ReadonlySet<string>): string {\n  if (!taken.has(candidate)) return candidate;\n  for (let i = 2; i < 1000; i += 1) {\n    const suffix = `-${i.toString()}`;\n    const room = MAX_LEN - suffix.length;\n    const trimmed = candidate.length > room ? candidate.slice(0, room) : candidate;\n    const next = `${trimmed}${suffix}`;\n    if (!taken.has(next)) return next;\n  }\n  // Pathological: 998 collisions. Fall back to a deterministic-ish hash.\n  return `${candidate.slice(0, MAX_LEN - 6)}-x${(taken.size % 1000).toString().padStart(3, '0')}`;\n}\n","import type { Logger, McpServerConfig, McpToolDescriptor, McpToolCallResult, StdioServerConfig } from './types.js';\nimport { buildNamespacedToolName } from './tool-naming.js';\n\n/** Env keys OpenClaw rejects from stdio MCP env blocks. Filter them out before spawning. */\nexport const STDIO_ENV_DENYLIST = new Set([\n  'NODE_OPTIONS',\n  'PYTHONSTARTUP',\n  'PYTHONPATH',\n  'PERL5OPT',\n  'RUBYOPT',\n  'SHELLOPTS',\n  'PS4',\n]);\n\nexport function sanitizeStdioEnv(env: Record<string, string> | undefined): Record<string, string> {\n  if (!env) return {};\n  const safe: Record<string, string> = {};\n  for (const [k, v] of Object.entries(env)) {\n    if (STDIO_ENV_DENYLIST.has(k)) continue;\n    safe[k] = v;\n  }\n  return safe;\n}\n\nexport interface ConnectionDeps {\n  /**\n   * Factory for an MCP Client connected to the given config. Injected so tests\n   * can mock without spawning real processes. In production this wraps\n   * `@modelcontextprotocol/sdk/client`.\n   */\n  connect: (server: McpServerConfig) => Promise<McpClientHandle>;\n}\n\n/**\n * Minimal interface our connection layer needs from an MCP client. Mirrors\n * the @modelcontextprotocol/sdk Client surface but kept narrow so we can\n * mock cleanly in tests.\n */\nexport interface McpClientHandle {\n  listTools(): Promise<{ name: string; description?: string; inputSchema: Record<string, unknown> }[]>;\n  callTool(name: string, args: unknown, opts?: { signal?: AbortSignal }): Promise<McpToolCallResult>;\n  close(): Promise<void>;\n}\n\n/**\n * One Connection per MCP server. Owns lifecycle (lazy-spawn, close, refresh-lock).\n * Refresh-lock pattern adapted from AIWerk `index.ts:219-250` — prevents\n * reconnect + `notifications/tools/list_changed` race.\n */\nexport class Connection {\n  readonly name: string;\n  readonly config: McpServerConfig;\n  private readonly deps: ConnectionDeps;\n  private readonly logger: Logger | undefined;\n\n  private client: McpClientHandle | undefined;\n  private tools: McpToolDescriptor[] = [];\n  private connectInFlight: Promise<void> | undefined;\n  private refreshInFlight = false;\n  private refreshQueued = false;\n  private lastUsedAt = Date.now();\n\n  constructor(params: { name: string; config: McpServerConfig; deps: ConnectionDeps; logger?: Logger }) {\n    this.name = params.name;\n    this.config = params.config;\n    this.deps = params.deps;\n    this.logger = params.logger;\n  }\n\n  /** Returns the most recent known tool list. May be empty if the server hasn't connected yet. */\n  snapshotTools(): McpToolDescriptor[] {\n    return this.tools;\n  }\n\n  /** Whether an MCP child process / remote connection has been established. */\n  isConnected(): boolean {\n    return this.client !== undefined;\n  }\n\n  /** Idle timestamp for reaping. */\n  idleSinceMs(): number {\n    return Date.now() - this.lastUsedAt;\n  }\n\n  /**\n   * Lazy connect + tool discovery. Safe to call concurrently; in-flight\n   * connects coalesce.\n   */\n  async ensureConnected(): Promise<void> {\n    if (this.client) return;\n    if (this.connectInFlight) return this.connectInFlight;\n    this.connectInFlight = this.connectAndDiscover().finally(() => {\n      this.connectInFlight = undefined;\n    });\n    return this.connectInFlight;\n  }\n\n  private async connectAndDiscover(): Promise<void> {\n    const safeConfig = 'command' in this.config\n      ? ({ ...this.config, env: sanitizeStdioEnv(this.config.env) } satisfies StdioServerConfig)\n      : this.config;\n    this.logger?.debug(`[mcp-bundler] connecting server \"${this.name}\"`);\n    const client = await this.deps.connect(safeConfig);\n    try {\n      const advertised = await client.listTools();\n      this.client = client;\n      this.tools = advertised.map((t) => ({\n        prefixed: buildNamespacedToolName(this.name, t.name),\n        server: this.name,\n        original: t.name,\n        label: (t.description ?? t.name).slice(0, 80),\n        description: t.description ?? '',\n        parameters: t.inputSchema,\n      }));\n      this.lastUsedAt = Date.now();\n      this.logger?.info(`[mcp-bundler] server \"${this.name}\" connected, ${this.tools.length.toString()} tool(s)`);\n    } catch (err) {\n      await client.close().catch(() => undefined);\n      throw err;\n    }\n  }\n\n  /**\n   * Re-discover tools. Used on reconnect or `tools/list_changed` notification.\n   * Refresh-lock collapses concurrent refreshes; if one is in flight, the next\n   * is queued (max 1 queued, since N>1 queued provides no extra freshness).\n   */\n  async refresh(): Promise<void> {\n    if (!this.client) return this.ensureConnected();\n    if (this.refreshInFlight) {\n      this.refreshQueued = true;\n      return;\n    }\n    this.refreshInFlight = true;\n    try {\n      const advertised = await this.client.listTools();\n      this.tools = advertised.map((t) => ({\n        prefixed: buildNamespacedToolName(this.name, t.name),\n        server: this.name,\n        original: t.name,\n        label: (t.description ?? t.name).slice(0, 80),\n        description: t.description ?? '',\n        parameters: t.inputSchema,\n      }));\n      this.logger?.debug(`[mcp-bundler] server \"${this.name}\" refreshed, ${this.tools.length.toString()} tool(s)`);\n    } finally {\n      this.refreshInFlight = false;\n      if (this.refreshQueued) {\n        this.refreshQueued = false;\n        // Trigger one more refresh; do not await so caller isn't blocked on cascading refreshes.\n        void this.refresh().catch((err: unknown) => {\n          this.logger?.warn(`[mcp-bundler] queued refresh for \"${this.name}\" failed`, { err: err instanceof Error ? err.message : String(err) });\n        });\n      }\n    }\n  }\n\n  async callTool(originalName: string, args: unknown, signal?: AbortSignal): Promise<McpToolCallResult> {\n    await this.ensureConnected();\n    if (!this.client) throw new Error(`server \"${this.name}\" failed to connect`);\n    this.lastUsedAt = Date.now();\n    return this.client.callTool(originalName, args, signal ? { signal } : undefined);\n  }\n\n  /**\n   * Close the underlying transport. Idempotent. If a connect is in flight\n   * (warmup racing with reconcile-removal), wait for it to settle and then\n   * close the client it produced — otherwise the child process is orphaned.\n   */\n  async close(): Promise<void> {\n    if (this.connectInFlight) {\n      await this.connectInFlight.catch(() => undefined);\n    }\n    const c = this.client;\n    this.client = undefined;\n    this.tools = [];\n    if (c) await c.close().catch((err: unknown) => {\n      this.logger?.warn(`[mcp-bundler] close error for \"${this.name}\"`, { err: err instanceof Error ? err.message : String(err) });\n    });\n  }\n\n  /**\n   * Stable hash of the config for diff detection in `reconcile`.\n   * Two configs with the same hash are equivalent (no restart needed).\n   */\n  configFingerprint(): string {\n    return JSON.stringify(this.config);\n  }\n}\n\n/**\n * Build the production `connect` factory using the official MCP SDK.\n * Kept in a separate function so tests can substitute a mock without\n * pulling the SDK into the test bundle.\n */\nexport async function defaultConnect(server: McpServerConfig): Promise<McpClientHandle> {\n  const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');\n  const client = new Client({ name: 'alfe-mcp-bundler', version: '0.0.0' }, {});\n\n  if ('command' in server) {\n    const stdio = server;\n    const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');\n    const transport = new StdioClientTransport({\n      command: stdio.command,\n      args: stdio.args ?? [],\n      env: { ...sanitizeStdioEnv(stdio.env) } as Record<string, string>,\n      cwd: stdio.cwd,\n    });\n    await client.connect(transport);\n  } else {\n    const remote = server;\n    if (remote.transport === 'streamable-http') {\n      const { StreamableHTTPClientTransport } = await import('@modelcontextprotocol/sdk/client/streamableHttp.js');\n      const transport = new StreamableHTTPClientTransport(new URL(remote.url), {\n        requestInit: { headers: remote.headers ?? {} },\n      });\n      await client.connect(transport);\n    } else {\n      // SSE is deprecated in newer MCP SDK in favor of streamable-http, but\n      // some servers still only support SSE — keep transport for back-compat.\n      /* eslint-disable @typescript-eslint/no-deprecated */\n      const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js');\n      const transport = new SSEClientTransport(new URL(remote.url), {\n        requestInit: { headers: remote.headers ?? {} },\n      });\n      /* eslint-enable @typescript-eslint/no-deprecated */\n      await client.connect(transport);\n    }\n  }\n\n  return {\n    async listTools() {\n      const result = await client.listTools();\n      return result.tools.map((t) => ({\n        name: t.name,\n        description: t.description,\n        inputSchema: t.inputSchema as Record<string, unknown>,\n      }));\n    },\n    async callTool(name, args, opts) {\n      return (await client.callTool({ name, arguments: args as Record<string, unknown> | undefined }, undefined, opts)) as McpToolCallResult;\n    },\n    async close() {\n      await client.close();\n    },\n  };\n}\n","import { Connection, defaultConnect, type ConnectionDeps } from './connection.js';\nimport { disambiguateAgainst } from './tool-naming.js';\nimport type {\n  BundlerOptions,\n  Logger,\n  McpServerConfig,\n  McpToolCallResult,\n  McpToolDescriptor,\n  ReconcileDiff,\n} from './types.js';\n\nconst DEFAULT_IDLE_TTL_MS = 10 * 60 * 1000;\nconst DEFAULT_IDLE_SWEEP_INTERVAL_MS = 60 * 1000;\n\n/**\n * Provider-agnostic MCP server bundler. Holds N MCP server connections,\n * exposes a unified namespaced tool catalog, and routes calls to the right\n * server.\n *\n * Designed to be embedded in any host (OpenClaw plugin, AI proxy, Lambda).\n * Public surface is intentionally synchronous where the host needs sync\n * (snapshot, listTools), async only where I/O is unavoidable.\n */\nexport class McpBundler {\n  private readonly logger: Logger | undefined;\n  private readonly connections = new Map<string, Connection>();\n  private readonly idleTtlMs: number;\n  private readonly idleSweepIntervalMs: number;\n  private idleSweepTimer: ReturnType<typeof setInterval> | undefined;\n  private readonly deps: ConnectionDeps;\n  private disposed = false;\n  // Serialize reconcile() so concurrent callers (multiple plugin tool factory\n  // ticks within the same ms) don't interleave and orphan Connections, leaking\n  // child processes. Acquired via a chain-of-promises latch.\n  private reconcileLatch: Promise<unknown> = Promise.resolve();\n\n  constructor(opts: BundlerOptions = {}, deps?: ConnectionDeps) {\n    this.logger = opts.logger;\n    this.idleTtlMs = opts.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;\n    this.idleSweepIntervalMs = opts.idleSweepIntervalMs ?? DEFAULT_IDLE_SWEEP_INTERVAL_MS;\n    this.deps = deps ?? { connect: defaultConnect };\n    if (this.idleTtlMs > 0) this.startIdleSweep();\n  }\n\n  /**\n   * Diff `desired` against current connections, spawn newcomers, dispose\n   * removals, hot-restart on config change. Pull-based — call whenever the\n   * host's config snapshot may have changed. Cheap if no diff.\n   *\n   * Lazy: newly-added servers are NOT eagerly connected; they connect on the\n   * first `callTool()` (or first `listTools()` after `forceDiscover()`).\n   * This avoids paying spawn cost for servers the agent never uses.\n   */\n  async reconcile(desired: Record<string, McpServerConfig>): Promise<ReconcileDiff> {\n    if (this.disposed) throw new Error('McpBundler: disposed');\n    // Serialize reconciles. Caller awaits its slot; in-flight reconciles run\n    // in declaration order. Errors don't poison the latch — `.catch` swallows\n    // for chaining, the actual error rejects the awaited slot.\n    const slot = this.reconcileLatch.then(async () => this.doReconcile(desired));\n    this.reconcileLatch = slot.catch(() => undefined);\n    return slot;\n  }\n\n  private async doReconcile(desired: Record<string, McpServerConfig>): Promise<ReconcileDiff> {\n    if (this.disposed) throw new Error('McpBundler: disposed');\n    const desiredNames = new Set(Object.keys(desired));\n    const currentNames = new Set(this.connections.keys());\n\n    const added: string[] = [];\n    const removed: string[] = [];\n    const changed: string[] = [];\n    const unchanged: string[] = [];\n\n    // Removals: dispose connections no longer in desired set.\n    for (const name of currentNames) {\n      if (!desiredNames.has(name)) {\n        const conn = this.connections.get(name);\n        this.connections.delete(name);\n        if (conn) await conn.close();\n        removed.push(name);\n      }\n    }\n\n    // Additions and changes.\n    for (const [name, config] of Object.entries(desired)) {\n      const existing = this.connections.get(name);\n      if (!existing) {\n        this.connections.set(name, new Connection({ name, config, deps: this.deps, logger: this.logger }));\n        added.push(name);\n        continue;\n      }\n      const nextFingerprint = JSON.stringify(config);\n      if (existing.configFingerprint() !== nextFingerprint) {\n        // Config changed — close old, replace with fresh (lazy reconnect).\n        await existing.close();\n        this.connections.set(name, new Connection({ name, config, deps: this.deps, logger: this.logger }));\n        changed.push(name);\n      } else {\n        unchanged.push(name);\n      }\n    }\n\n    if (added.length || removed.length || changed.length) {\n      this.logger?.info('[mcp-bundler] reconciled', {\n        added: added.length,\n        removed: removed.length,\n        changed: changed.length,\n        unchanged: unchanged.length,\n      });\n    }\n    return { added, removed, changed, unchanged };\n  }\n\n  /**\n   * Synchronous snapshot of all currently-known tools across connected servers.\n   * Servers that have not connected yet contribute nothing. Intended for use\n   * inside OpenClaw's plugin tool factory which must be sync.\n   *\n   * Tool names are namespaced and disambiguated (suffix `-2`, `-3` on collision)\n   * so cross-server name clashes never produce duplicate registrations.\n   */\n  listTools(): McpToolDescriptor[] {\n    const seen = new Set<string>();\n    const out: McpToolDescriptor[] = [];\n    for (const conn of this.connections.values()) {\n      for (const tool of conn.snapshotTools()) {\n        const finalName = disambiguateAgainst(tool.prefixed, seen);\n        seen.add(finalName);\n        out.push(finalName === tool.prefixed ? tool : { ...tool, prefixed: finalName });\n      }\n    }\n    return out;\n  }\n\n  /**\n   * Eagerly connect to every configured server and discover tools. Used by\n   * hosts that want a hot list rather than the lazy default. Errors are\n   * swallowed per-server (logged), so one bad server doesn't fail the batch.\n   */\n  async warmup(): Promise<void> {\n    if (this.disposed) return;\n    await Promise.allSettled(\n      Array.from(this.connections.values()).map(async (conn) => {\n        try {\n          await conn.ensureConnected();\n        } catch (err) {\n          this.logger?.warn(`[mcp-bundler] warmup failed for \"${conn.name}\"`, {\n            err: err instanceof Error ? err.message : String(err),\n          });\n        }\n      }),\n    );\n  }\n\n  /**\n   * Invoke a tool by its namespaced name. Routes to the originating server.\n   * Errors are returned as `{ isError: true, content: [...] }` so a failing\n   * tool doesn't crash the host.\n   */\n  async callTool(prefixed: string, args: unknown, signal?: AbortSignal): Promise<McpToolCallResult> {\n    if (this.disposed) {\n      return { isError: true, content: [{ type: 'text', text: 'mcp-bundler disposed' }] };\n    }\n    const route = this.routeToolName(prefixed);\n    if (!route) {\n      return {\n        isError: true,\n        content: [{ type: 'text', text: `unknown tool: ${prefixed}` }],\n      };\n    }\n    try {\n      return await route.connection.callTool(route.original, args, signal);\n    } catch (err) {\n      const msg = err instanceof Error ? err.message : String(err);\n      this.logger?.error(`[mcp-bundler] tool call failed for \"${prefixed}\"`, { err: msg });\n      return {\n        isError: true,\n        content: [{ type: 'text', text: `tool ${prefixed} failed: ${msg}` }],\n      };\n    }\n  }\n\n  /**\n   * Resolve a namespaced tool name back to its server connection and original\n   * tool name. Returns undefined if the tool is not currently advertised.\n   */\n  private routeToolName(prefixed: string): { connection: Connection; original: string } | undefined {\n    for (const conn of this.connections.values()) {\n      for (const tool of conn.snapshotTools()) {\n        if (tool.prefixed === prefixed) return { connection: conn, original: tool.original };\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Tear down all connections and stop background tasks. Idempotent.\n   * Call from `registerRuntimeLifecycle({ cleanup })` in the host plugin.\n   */\n  async dispose(): Promise<void> {\n    if (this.disposed) return;\n    this.disposed = true;\n    if (this.idleSweepTimer) {\n      clearInterval(this.idleSweepTimer);\n      this.idleSweepTimer = undefined;\n    }\n    await Promise.allSettled(Array.from(this.connections.values()).map((c) => c.close()));\n    this.connections.clear();\n  }\n\n  private startIdleSweep(): void {\n    this.idleSweepTimer = setInterval(() => {\n      void this.sweepIdle().catch((err: unknown) => {\n        this.logger?.warn('[mcp-bundler] idle sweep error', {\n          err: err instanceof Error ? err.message : String(err),\n        });\n      });\n    }, this.idleSweepIntervalMs);\n    // Don't keep the host process alive just for the sweep.\n    if (typeof this.idleSweepTimer === 'object' && 'unref' in this.idleSweepTimer) {\n      (this.idleSweepTimer as { unref: () => void }).unref();\n    }\n  }\n\n  private async sweepIdle(): Promise<void> {\n    if (this.idleTtlMs <= 0) return;\n    const targets: Connection[] = [];\n    for (const conn of this.connections.values()) {\n      if (conn.isConnected() && conn.idleSinceMs() > this.idleTtlMs) {\n        targets.push(conn);\n      }\n    }\n    if (targets.length === 0) return;\n    this.logger?.debug(`[mcp-bundler] reaping ${targets.length.toString()} idle server(s)`);\n    await Promise.allSettled(targets.map((c) => c.close()));\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@alfe.ai/mcp-bundler",
+  "version": "0.0.1",
+  "description": "Provider-agnostic MCP server bundler — connects to N MCP servers (stdio/SSE/streamable-http), aggregates their tools with namespacing, exposes a unified callable surface",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint ."
+  }
+}