mcp-proxy-conductor 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/config/store.ts
@@ -111,98 +113,185 @@ import {
   ResourceListChangedNotificationSchema,
   PromptListChangedNotificationSchema
 } from "@modelcontextprotocol/sdk/types.js";
+
+// src/version.ts
+var VERSION = "0.1.2";
+
+// src/registry/connection.ts
+var EMPTY = { tools: [], resources: [], prompts: [] };
 var DownstreamConnection = class {
-  constructor(def, transportFactory, onChange) {
+  constructor(def, transportFactory, opts = {}) {
     this.def = def;
     this.transportFactory = transportFactory;
-    this.onChange = onChange;
-    this.client = new Client({ name: "ai-conductor", version: "0.1.0" });
+    this.capabilities = opts.cachedCaps ?? { ...EMPTY };
+    this.hydrated = opts.cachedCaps !== void 0;
+    this.idleMs = opts.idleMs ?? 0;
+    this.onChange = opts.onChange;
   }
   def;
   transportFactory;
-  onChange;
-  state = "connecting";
+  state = "idle";
   error;
-  capabilities = { tools: [], resources: [], prompts: [] };
+  capabilities;
+  hydrated;
+  // true while capabilities come from cache (not a live fetch)
+  idleMs;
+  onChange;
   client;
-  async connect() {
+  idleTimer;
+  connecting;
+  // Connect if not already connected. Concurrent callers share one in-flight connect.
+  // Every call (re)starts the idle timer.
+  async ensureConnected() {
+    this.touch();
+    if (this.state === "connected") return;
+    if (!this.connecting) {
+      this.connecting = this.doConnect().finally(() => {
+        this.connecting = void 0;
+      });
+    }
+    return this.connecting;
+  }
+  async callTool(name, args) {
+    await this.ensureConnected();
+    this.touch();
+    return this.client.callTool({ name, arguments: args });
+  }
+  async readResource(uri) {
+    await this.ensureConnected();
+    this.touch();
+    return this.client.readResource({ uri });
+  }
+  async getPrompt(name, args) {
+    await this.ensureConnected();
+    this.touch();
+    return this.client.getPrompt({ name, arguments: args });
+  }
+  async refresh() {
+    const before = JSON.stringify(this.capabilities);
+    const caps = this.client.getServerCapabilities() ?? {};
+    this.capabilities = {
+      tools: caps.tools ? (await this.client.listTools()).tools : [],
+      resources: caps.resources ? (await this.client.listResources()).resources : [],
+      prompts: caps.prompts ? (await this.client.listPrompts()).prompts : []
+    };
+    return JSON.stringify(this.capabilities) !== before;
+  }
+  async close() {
+    this.clearIdle();
+    await this.client?.close().catch(() => void 0);
+    this.client = void 0;
+    if (this.state !== "error") this.state = "idle";
+  }
+  async doConnect() {
     this.state = "connecting";
+    const client = new Client({ name: "ai-conductor", version: VERSION });
     try {
       const transport = await this.transportFactory(this.def);
-      await this.client.connect(transport);
-      this.client.onclose = () => {
-        if (this.state === "connected") this.state = "disconnected";
+      await client.connect(transport);
+      this.client = client;
+      client.onclose = () => {
+        if (this.state === "connected") this.state = "idle";
         this.onChange?.();
       };
-      this.registerNotificationHandlers();
-      await this.refresh();
+      this.registerNotificationHandlers(client);
+      const changed = await this.refresh();
       this.state = "connected";
+      this.error = void 0;
+      this.hydrated = false;
+      this.touch();
+      if (changed) this.onChange?.();
     } catch (err) {
       this.state = "error";
       this.error = err instanceof Error ? err.message : String(err);
+      await client.close().catch(() => void 0);
+      this.client = void 0;
       throw err;
     }
   }
-  registerNotificationHandlers() {
+  registerNotificationHandlers(client) {
     const refreshAndNotify = async () => {
       await this.refresh().catch(() => void 0);
       this.onChange?.();
     };
-    this.client.setNotificationHandler(ToolListChangedNotificationSchema, refreshAndNotify);
-    this.client.setNotificationHandler(ResourceListChangedNotificationSchema, refreshAndNotify);
-    this.client.setNotificationHandler(PromptListChangedNotificationSchema, refreshAndNotify);
-  }
-  async refresh() {
-    const caps = this.client.getServerCapabilities() ?? {};
-    this.capabilities = {
-      tools: caps.tools ? (await this.client.listTools()).tools : [],
-      resources: caps.resources ? (await this.client.listResources()).resources : [],
-      prompts: caps.prompts ? (await this.client.listPrompts()).prompts : []
-    };
+    client.setNotificationHandler(ToolListChangedNotificationSchema, refreshAndNotify);
+    client.setNotificationHandler(ResourceListChangedNotificationSchema, refreshAndNotify);
+    client.setNotificationHandler(PromptListChangedNotificationSchema, refreshAndNotify);
+  }
+  touch() {
+    this.clearIdle();
+    if (this.idleMs > 0) {
+      this.idleTimer = setTimeout(() => {
+        void this.close();
+      }, this.idleMs);
+      this.idleTimer.unref?.();
+    }
   }
-  async close() {
-    await this.client.close().catch(() => void 0);
-    this.state = "disconnected";
+  clearIdle() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = void 0;
+    }
   }
 };
 
 // src/registry/manager.ts
 var DownstreamManager = class {
-  constructor(transportFactory, onChange = () => void 0) {
+  constructor(transportFactory, opts = {}) {
     this.transportFactory = transportFactory;
-    this.onChange = onChange;
+    this.onChange = opts.onChange ?? (() => void 0);
+    this.cache = opts.cache;
+    this.idleMs = opts.idleMs ?? 0;
   }
   transportFactory;
-  onChange;
   conns = /* @__PURE__ */ new Map();
-  // Connect all enabled definitions. Individual failures are captured as error state;
-  // they never reject start() or prevent other servers from connecting.
+  onChange;
+  cache;
+  idleMs;
+  cacheMap = {};
+  // Non-blocking: create idle connections hydrated from cache; only servers with no cached
+  // capabilities are background-filled (fire-and-forget) so they can be advertised.
   async start(defs) {
-    await Promise.all(defs.filter((d) => d.enabled).map((d) => this.connectOne(d)));
+    this.cacheMap = this.cache ? await this.cache.load() : {};
+    for (const def of defs.filter((d) => d.enabled)) {
+      const conn = this.createConn(def);
+      this.conns.set(def.id, conn);
+      if (!this.cacheMap[def.id]) {
+        void conn.ensureConnected().catch(() => void 0);
+      }
+    }
   }
-  async connectOne(def) {
-    const conn = new DownstreamConnection(def, this.transportFactory, this.onChange);
+  async add(def) {
+    if (this.conns.has(def.id)) throw new Error(`server '${def.id}' already exists`);
+    const conn = this.createConn(def);
     this.conns.set(def.id, conn);
-    await conn.connect().catch(() => void 0);
+    await conn.ensureConnected().catch(() => void 0);
+    if (conn.state === "connected" && this.cache) {
+      this.cacheMap[def.id] = {
+        tools: conn.capabilities.tools,
+        resources: conn.capabilities.resources,
+        prompts: conn.capabilities.prompts,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.cache.save(this.cacheMap).catch(() => void 0);
+    }
     this.onChange();
     return conn;
   }
-  async add(def) {
-    if (this.conns.has(def.id)) throw new Error(`server '${def.id}' already exists`);
-    return this.connectOne(def);
-  }
   async remove(id) {
     const conn = this.conns.get(id);
     if (!conn) return;
     await conn.close();
     this.conns.delete(id);
+    delete this.cacheMap[id];
+    if (this.cache) await this.cache.save(this.cacheMap).catch(() => void 0);
     this.onChange();
   }
   get(id) {
     return this.conns.get(id);
   }
-  connected() {
-    return [...this.conns.values()].filter((c) => c.state === "connected");
+  entries() {
+    return [...this.conns.values()];
   }
   list() {
     return [...this.conns.values()].map((c) => ({
@@ -211,13 +300,36 @@ var DownstreamManager = class {
       error: c.error,
       toolCount: c.capabilities.tools.length,
       resourceCount: c.capabilities.resources.length,
-      promptCount: c.capabilities.prompts.length
+      promptCount: c.capabilities.prompts.length,
+      cached: c.hydrated
     }));
   }
   async closeAll() {
     await Promise.all([...this.conns.values()].map((c) => c.close()));
     this.conns.clear();
   }
+  createConn(def) {
+    return new DownstreamConnection(def, this.transportFactory, {
+      idleMs: this.idleMs,
+      cachedCaps: this.cacheMap[def.id],
+      onChange: () => this.onConnChange(def.id)
+    });
+  }
+  // A connection reports a capability/state change: persist live caps to the cache and
+  // propagate listChanged upstream.
+  onConnChange(id) {
+    const conn = this.conns.get(id);
+    if (conn && conn.state === "connected") {
+      this.cacheMap[id] = {
+        tools: conn.capabilities.tools,
+        resources: conn.capabilities.resources,
+        prompts: conn.capabilities.prompts,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (this.cache) void this.cache.save(this.cacheMap).catch(() => void 0);
+    }
+    this.onChange();
+  }
 };
 
 // src/aggregator/namespace.ts
@@ -250,38 +362,39 @@ var Aggregator = class {
     this.manager = manager;
   }
   manager;
+  // Advertise from every known connection's capabilities (cached while idle, live when
+  // connected). No connection is established just to list.
   async listTools() {
-    return this.manager.connected().flatMap(
+    return this.manager.entries().flatMap(
       (c) => c.capabilities.tools.map((t) => ({ ...t, name: encodeName(c.def.id, t.name) }))
     );
   }
   async listPrompts() {
-    return this.manager.connected().flatMap(
+    return this.manager.entries().flatMap(
       (c) => c.capabilities.prompts.map((p) => ({ ...p, name: encodeName(c.def.id, p.name) }))
     );
   }
   async listResources() {
-    return this.manager.connected().flatMap(
+    return this.manager.entries().flatMap(
       (c) => c.capabilities.resources.map((r) => ({ ...r, uri: encodeUri(c.def.id, r.uri) }))
     );
   }
+  // Routing connects on demand via the connection's own methods (ensureConnected inside).
   async callTool(qualifiedName, args) {
     const { serverId, name } = decodeName(qualifiedName);
-    return this.connOrThrow(serverId).client.callTool({ name, arguments: args });
+    return this.connOrThrow(serverId).callTool(name, args);
   }
   async getPrompt(qualifiedName, args) {
     const { serverId, name } = decodeName(qualifiedName);
-    return this.connOrThrow(serverId).client.getPrompt({ name, arguments: args });
+    return this.connOrThrow(serverId).getPrompt(name, args);
   }
   async readResource(qualifiedUri) {
     const { serverId, uri } = decodeUri(qualifiedUri);
-    return this.connOrThrow(serverId).client.readResource({ uri });
+    return this.connOrThrow(serverId).readResource(uri);
   }
   connOrThrow(serverId) {
     const conn = this.manager.get(serverId);
-    if (!conn || conn.state !== "connected") {
-      throw new Error(`downstream server '${serverId}' is not connected`);
-    }
+    if (!conn) throw new Error(`unknown downstream server '${serverId}'`);
     return conn;
   }
 };
@@ -317,7 +430,7 @@ var MetaTools = class {
       },
       {
         name: "list_servers",
-        description: "List managed downstream servers with connection state and capability counts.",
+        description: "List managed downstream servers: connection state (idle/connected/error), whether capabilities are served from cache, and capability counts.",
         inputSchema: { type: "object", properties: {} }
       }
     ];
@@ -367,7 +480,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 function buildUpstreamServer(aggregator, meta) {
   const server = new Server(
-    { name: "ai-conductor", version: "0.1.0" },
+    { name: "ai-conductor", version: VERSION },
     { capabilities: { tools: { listChanged: true }, resources: { listChanged: true }, prompts: { listChanged: true } } }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -389,6 +502,51 @@ function buildUpstreamServer(aggregator, meta) {
   return server;
 }
 
+// src/config/capability-cache.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import envPaths2 from "env-paths";
+import { z as z2 } from "zod";
+var CachedCapabilitiesSchema = z2.object({
+  tools: z2.array(z2.any()),
+  resources: z2.array(z2.any()),
+  prompts: z2.array(z2.any()),
+  fetchedAt: z2.string()
+});
+var CacheMapSchema = z2.record(z2.string(), CachedCapabilitiesSchema);
+function defaultCapabilityCachePath() {
+  return `${envPaths2("ai-conductor", { suffix: "" }).config}/capabilities.json`;
+}
+var CapabilityCache = class {
+  constructor(path = defaultCapabilityCachePath()) {
+    this.path = path;
+  }
+  path;
+  async load() {
+    let raw;
+    try {
+      raw = await readFile2(this.path, "utf8");
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      throw err;
+    }
+    const parsed = CacheMapSchema.safeParse(JSON.parse(tryJson(raw)));
+    return parsed.success ? parsed.data : {};
+  }
+  async save(map) {
+    await mkdir2(dirname2(this.path), { recursive: true });
+    await writeFile2(this.path, JSON.stringify(map, null, 2), "utf8");
+  }
+};
+function tryJson(raw) {
+  try {
+    JSON.parse(raw);
+    return raw;
+  } catch {
+    return "null";
+  }
+}
+
 // src/index.ts
 async function createConductor(opts = {}) {
   const store = opts.store ?? new ConfigStore();
@@ -401,7 +559,10 @@ async function createConductor(opts = {}) {
     server.sendResourceListChanged();
     server.sendPromptListChanged();
   };
-  const manager = new DownstreamManager(transportFactory, onChange);
+  const cache = opts.cache ?? new CapabilityCache();
+  const rawIdleMs = Number(process.env.CONDUCTOR_IDLE_TIMEOUT_MS ?? 3e5);
+  const idleMs = opts.idleMs ?? (Number.isFinite(rawIdleMs) ? rawIdleMs : 3e5);
+  const manager = new DownstreamManager(transportFactory, { onChange, cache, idleMs });
   const aggregator = new Aggregator(manager);
   const meta = new MetaTools(manager, store);
   server = buildUpstreamServer(aggregator, meta);
@@ -415,12 +576,21 @@ async function createConductor(opts = {}) {
     }
   };
 }
-if (import.meta.url === `file://${process.argv[1]}`) {
+function isMainModule(argv1, importMetaUrl) {
+  if (!argv1) return false;
+  try {
+    return realpathSync(argv1) === fileURLToPath(importMetaUrl);
+  } catch {
+    return false;
+  }
+}
+if (isMainModule(process.argv[1], import.meta.url)) {
   createConductor().then((c) => c.start()).catch((err) => {
     console.error("ai-conductor failed to start:", err);
     process.exit(1);
   });
 }
 export {
-  createConductor
+  createConductor,
+  isMainModule
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-proxy-conductor",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Local MCP proxy that aggregates dynamically managed downstream MCP servers, managed at runtime without restarting the client.",
   "type": "module",
   "license": "MIT",
@@ -32,11 +32,12 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsx src/index.ts",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
+    "gen:version": "node scripts/gen-version.mjs",
+    "build": "pnpm gen:version && tsup",
+    "dev": "pnpm gen:version && tsx src/index.ts",
+    "test": "pnpm gen:version && vitest run",
+    "test:watch": "pnpm gen:version && vitest",
+    "typecheck": "pnpm gen:version && tsc --noEmit",
     "prepublishOnly": "pnpm typecheck && pnpm test && pnpm build"
   },
   "dependencies": {