@agiflowai/one-mcp 0.3.15 → 0.3.16

package/dist/{src-CH93aUm2.mjs → src-Dn6vMZIk.mjs}

@@ -1495,23 +1495,11 @@ var McpClientManagerService = class {
 	clients = /* @__PURE__ */ new Map();
 	serverConfigs = /* @__PURE__ */ new Map();
 	connectionPromises = /* @__PURE__ */ new Map();
-	constructor() {
-		process.on("exit", () => {
-			this.cleanupOnExit();
-		});
-		process.on("SIGINT", () => {
-			this.cleanupOnExit();
-			process.exit(0);
-		});
-		process.on("SIGTERM", () => {
-			this.cleanupOnExit();
-			process.exit(0);
-		});
-	}
 	/**
-	* Cleanup all resources on exit (child processes)
+	* Synchronously kill all stdio MCP server child processes.
+	* Must be called by the owner (e.g. transport/command layer) during shutdown.
 	*/
-	cleanupOnExit() {
+	cleanupChildProcesses() {
 		for (const [serverName, client] of this.clients) try {
 			const childProcess = client["childProcess"];
 			if (childProcess && !childProcess.killed) {
@@ -2779,7 +2767,7 @@ IMPORTANT: Only use tools discovered from describe_tools with id="${this.serverI
 
 //#endregion
 //#region package.json
-var version = "0.3.14";
+var version = "0.3.15";
 
 //#endregion
 //#region src/server/index.ts
@@ -2790,6 +2778,7 @@ var version = "0.3.14";
 * - Factory pattern for server creation
 * - Tool registration pattern
 * - Dependency injection for services
+* - Shared services pattern for multi-session HTTP transport
 *
 * CODING STANDARDS:
 * - Register all tools, resources, and prompts here
@@ -2893,7 +2882,13 @@ function buildProxyInstructions(serverDefinitions, mode, includeSkillsTool) {
 		"Use describe_tools to inspect capabilities and use_tool to execute them."
 	].join("\n\n");
 }
-async function createServer(options) {
+/**
+* Initialize shared services and tools once for use across multiple sessions.
+* Use with createSessionServer() for HTTP transport where multiple agents
+* connect concurrently. This avoids duplicating downstream connections,
+* file watchers, caches, and tool instances per session.
+*/
+async function initializeSharedServices(options) {
 	const clientManager = new McpClientManagerService();
 	let configSkills;
 	let configId;
@@ -2966,13 +2961,47 @@ async function createServer(options) {
 		definitionsCacheService = new DefinitionsCacheService(clientManager, skillService);
 	}
 	else definitionsCacheService = new DefinitionsCacheService(clientManager, skillService);
+	const proxyMode = options?.proxyMode || "meta";
 	const describeTools = new DescribeToolsTool(clientManager, skillService, serverId, definitionsCacheService);
-	const useToolWithCache = new UseToolTool(clientManager, skillService, serverId, definitionsCacheService);
+	const useTool = new UseToolTool(clientManager, skillService, serverId, definitionsCacheService);
 	const searchListTools = new SearchListToolsTool(clientManager, definitionsCacheService);
 	toolsRef.describeTools = describeTools;
-	const serverDefinitions = await definitionsCacheService.getServerDefinitions();
-	const includeSkillsTool = await hasAnySkills(definitionsCacheService, skillService);
-	const proxyMode = options?.proxyMode || "meta";
+	if (skillService) skillService.startWatching().catch((error) => {
+		console.error(`[skill-watcher] File watcher failed (non-critical): ${error instanceof Error ? error.message : "Unknown error"}`);
+	});
+	if (!shouldStartFromCache && effectiveDefinitionsCachePath && options?.configFilePath) definitionsCacheService.collectForCache({
+		configPath: options.configFilePath,
+		configHash,
+		oneMcpVersion: version,
+		serverId
+	}).then((definitionsCache) => DefinitionsCacheService.writeToFile(effectiveDefinitionsCachePath, definitionsCache)).then(() => {
+		console.error(`[definitions-cache] Wrote ${effectiveDefinitionsCachePath}`);
+	}).catch((error) => {
+		console.error(`[definitions-cache] Failed to persist ${effectiveDefinitionsCachePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+	});
+	const dispose = async () => {
+		await clientManager.disconnectAll();
+		if (skillService) skillService.stopWatching();
+	};
+	return {
+		clientManager,
+		definitionsCacheService,
+		skillService,
+		describeTools,
+		useTool,
+		searchListTools,
+		serverId,
+		proxyMode,
+		dispose
+	};
+}
+/**
+* Create a lightweight per-session MCP Server instance that delegates
+* to shared services and tools. Use with initializeSharedServices()
+* for multi-session HTTP transport.
+*/
+async function createSessionServer(shared) {
+	const { clientManager, definitionsCacheService, skillService, describeTools, useTool: useToolWithCache, searchListTools, serverId, proxyMode } = shared;
 	const server = new Server({
 		name: "@agiflowai/one-mcp",
 		version: "0.1.0"
@@ -2982,10 +3011,7 @@ async function createServer(options) {
 			resources: {},
 			prompts: {}
 		},
-		instructions: buildProxyInstructions(serverDefinitions, proxyMode, includeSkillsTool)
-	});
-	if (skillService) skillService.startWatching().catch((error) => {
-		console.error(`[skill-watcher] File watcher failed (non-critical): ${error instanceof Error ? error.message : "Unknown error"}`);
+		instructions: buildProxyInstructions(await definitionsCacheService.getServerDefinitions(), proxyMode, await hasAnySkills(definitionsCacheService, skillService))
 	});
 	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: proxyMode === "flat" ? await (async () => {
 		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
@@ -3022,14 +3048,14 @@ async function createServer(options) {
 		throw new Error(`Unknown tool: ${name}`);
 	});
 	server.setRequestHandler(ListResourcesRequestSchema, async () => {
-		const serverDefinitions$1 = await definitionsCacheService.getServerDefinitions();
+		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
 		const resourceToServers = /* @__PURE__ */ new Map();
-		for (const serverDefinition of serverDefinitions$1) for (const resource of serverDefinition.resources) {
+		for (const serverDefinition of currentServerDefinitions) for (const resource of serverDefinition.resources) {
 			if (!resourceToServers.has(resource.uri)) resourceToServers.set(resource.uri, []);
 			resourceToServers.get(resource.uri)?.push(serverDefinition.serverName);
 		}
 		const resources = [];
-		for (const serverDefinition of serverDefinitions$1) for (const resource of serverDefinition.resources) {
+		for (const serverDefinition of currentServerDefinitions) for (const resource of serverDefinition.resources) {
 			const hasClash = (resourceToServers.get(resource.uri) || []).length > 1;
 			resources.push({
 				...resource,
@@ -3048,10 +3074,10 @@ async function createServer(options) {
 		return await (await clientManager.ensureConnected(matchingServers[0])).readResource(actualUri);
 	});
 	server.setRequestHandler(ListPromptsRequestSchema, async () => {
-		const serverDefinitions$1 = await definitionsCacheService.getServerDefinitions();
+		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
 		const promptToServers = /* @__PURE__ */ new Map();
 		const serverPromptsMap = /* @__PURE__ */ new Map();
-		for (const serverDefinition of serverDefinitions$1) {
+		for (const serverDefinition of currentServerDefinitions) {
 			serverPromptsMap.set(serverDefinition.serverName, serverDefinition.prompts);
 			for (const prompt of serverDefinition.prompts) {
 				if (!promptToServers.has(prompt.name)) promptToServers.set(prompt.name, []);
@@ -3059,7 +3085,7 @@ async function createServer(options) {
 			}
 		}
 		const aggregatedPrompts = [];
-		for (const serverDefinition of serverDefinitions$1) {
+		for (const serverDefinition of currentServerDefinitions) {
 			const prompts = serverPromptsMap.get(serverDefinition.serverName) || [];
 			for (const prompt of prompts) {
 				const hasClash = (promptToServers.get(prompt.name) || []).length > 1;
@@ -3074,29 +3100,26 @@ async function createServer(options) {
 	});
 	server.setRequestHandler(GetPromptRequestSchema, async (request) => {
 		const { name, arguments: args } = request.params;
-		const serverDefinitions$1 = await definitionsCacheService.getServerDefinitions();
+		const currentServerDefinitions = await definitionsCacheService.getServerDefinitions();
 		const { serverName, actualToolName: actualPromptName } = parseToolName(name);
 		if (serverName) return await (await clientManager.ensureConnected(serverName)).getPrompt(actualPromptName, args);
 		const serversWithPrompt = [];
-		for (const serverDefinition of serverDefinitions$1) if (serverDefinition.prompts.some((prompt) => prompt.name === name)) serversWithPrompt.push(serverDefinition.serverName);
+		for (const serverDefinition of currentServerDefinitions) if (serverDefinition.prompts.some((prompt) => prompt.name === name)) serversWithPrompt.push(serverDefinition.serverName);
 		if (serversWithPrompt.length === 0) throw new Error(`Prompt not found: ${name}`);
 		if (serversWithPrompt.length > 1) throw new Error(`Prompt "${name}" exists on multiple servers: ${serversWithPrompt.join(", ")}. Use the prefixed format (e.g., "${serversWithPrompt[0]}__${name}") to specify which server to use.`);
 		const client = clientManager.getClient(serversWithPrompt[0]);
 		if (!client) return await (await clientManager.ensureConnected(serversWithPrompt[0])).getPrompt(name, args);
 		return await client.getPrompt(name, args);
 	});
-	if (!shouldStartFromCache && effectiveDefinitionsCachePath && options?.configFilePath) definitionsCacheService.collectForCache({
-		configPath: options.configFilePath,
-		configHash,
-		oneMcpVersion: version,
-		serverId
-	}).then((definitionsCache) => DefinitionsCacheService.writeToFile(effectiveDefinitionsCachePath, definitionsCache)).then(() => {
-		console.error(`[definitions-cache] Wrote ${effectiveDefinitionsCachePath}`);
-	}).catch((error) => {
-		console.error(`[definitions-cache] Failed to persist ${effectiveDefinitionsCachePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
-	});
 	return server;
 }
+/**
+* Create a single MCP server instance (backward-compatible wrapper).
+* For multi-session HTTP transport, use initializeSharedServices() + createSessionServer() instead.
+*/
+async function createServer(options) {
+	return createSessionServer(await initializeSharedServices(options));
+}
 
 //#endregion
 //#region src/types/index.ts
@@ -4080,4 +4103,4 @@ var StopServerService = class {
 };
 
 //#endregion
-export { findConfigFile as _, SseTransportHandler as a, createServer as c, SearchListToolsTool as d, DescribeToolsTool as f, generateServerId as g, DefinitionsCacheService as h, StdioTransportHandler as i, version as l, McpClientManagerService as m, RuntimeStateService as n, HttpTransportHandler as o, SkillService as p, StdioHttpTransportHandler as r, TRANSPORT_MODE as s, StopServerService as t, UseToolTool as u, ConfigFetcherService as v };
+export { DefinitionsCacheService as _, SseTransportHandler as a, ConfigFetcherService as b, createServer as c, version as d, UseToolTool as f, McpClientManagerService as g, SkillService as h, StdioTransportHandler as i, createSessionServer as l, DescribeToolsTool as m, RuntimeStateService as n, HttpTransportHandler as o, SearchListToolsTool as p, StdioHttpTransportHandler as r, TRANSPORT_MODE as s, StopServerService as t, initializeSharedServices as u, generateServerId as v, findConfigFile as y };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agiflowai/one-mcp",
   "description": "One MCP server package",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "license": "AGPL-3.0",
   "keywords": [
     "mcp",