@wrongstack/mcp 0.264.0 → 0.267.0

package/dist/index.js

@@ -1,9 +1,11 @@
 import { spawn } from 'child_process';
 import { expectDefined, buildChildEnv } from '@wrongstack/core';
-import { randomBytes } from 'crypto';
+import { createHash, randomBytes } from 'crypto';
 import * as https from 'https';
 import * as net from 'net';
 import { toErrorMessage } from '@wrongstack/core/utils';
+import * as fs from 'fs/promises';
+import * as path from 'path';
 import { createServer } from 'http';
 
 // src/client.ts
@@ -37,6 +39,13 @@ var MCP_CONSTANTS = Object.freeze({
     /** Ms after which the force disconnect is triggered. */
     FORCE_TIMEOUT_MS: 1200
   }),
+  /** Lazy-connect idle lifecycle. */
+  IDLE: Object.freeze({
+    /** Default ms a lazy server stays connected with no tool calls before auto-sleep. */
+    DEFAULT_TIMEOUT_MS: 3e5,
+    /** How often the idle sweep runs (kept well below the timeout). */
+    SWEEP_INTERVAL_MS: 3e4
+  }),
   /** JSON-RPC response timeout for outstanding requests. */
   RESPONSE_TIMEOUT_MS: 500,
   /** Max buffer size for the SSE reader. */
@@ -1211,7 +1220,8 @@ function wrapMCPTool(serverName, mcpTool, client, permission = "confirm") {
     mutating: isMutatingTool(mcpTool),
     inputSchema: mcpTool.inputSchema ?? { type: "object", properties: {} },
     async execute(input, _ctx, _opts) {
-      const res = await client.callTool(mcpTool.name, input);
+      const live = typeof client === "function" ? await client() : client;
+      const res = await live.callTool(mcpTool.name, input);
       if (res.isError) {
         throw new Error(stringify(res.content));
       }
@@ -1239,20 +1249,63 @@ function stringify(c) {
   }
   return String(c ?? "");
 }
+function manifestConfigHash(cfg) {
+  const basis = JSON.stringify({
+    transport: cfg.transport,
+    command: cfg.command ?? null,
+    args: cfg.args ?? null,
+    url: cfg.url ?? null
+  });
+  return createHash("sha256").update(basis).digest("hex").slice(0, 16);
+}
+function manifestFile(cacheDir, name) {
+  const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+  return path.join(cacheDir, "mcp-tools", `${safe}.json`);
+}
+async function readManifest(cacheDir, name, configHash) {
+  try {
+    const raw = await fs.readFile(manifestFile(cacheDir, name), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.configHash !== configHash || !Array.isArray(parsed.tools)) return null;
+    return parsed.tools;
+  } catch {
+    return null;
+  }
+}
+async function writeManifest(cacheDir, name, configHash, tools) {
+  try {
+    const file = manifestFile(cacheDir, name);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const body = { configHash, tools };
+    const tmp = `${file}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(body, null, 2), "utf8");
+    await fs.rename(tmp, file);
+  } catch {
+  }
+}
+
+// src/registry.ts
 var MCPRegistry = class _MCPRegistry {
   servers = /* @__PURE__ */ new Map();
   toolRegistry;
   events;
   log;
   lazyMode;
+  cacheDir;
+  idleTimeoutMs;
+  /** Single shared idle sweep timer (started lazily; unref'd; cleared on stopAll). */
+  idleTimer;
   constructor(opts) {
     this.toolRegistry = opts.toolRegistry;
     this.events = opts.events;
     this.log = opts.log;
     this.lazyMode = opts.lazyMode ?? false;
+    this.cacheDir = opts.cacheDir;
+    this.idleTimeoutMs = opts.idleTimeoutMs ?? MCP_CONSTANTS.IDLE.DEFAULT_TIMEOUT_MS;
   }
   async start(cfg) {
     if (cfg.enabled === false) return;
+    const lazy = !!cfg.lazy && !!this.cacheDir;
     const slot = {
       cfg,
       state: "idle",
@@ -1260,11 +1313,70 @@ var MCPRegistry = class _MCPRegistry {
       lazyTools: [],
       attempts: 0,
       reconnectPending: false,
-      reconnectCycles: 0
+      reconnectCycles: 0,
+      lazy,
+      lastUsed: Date.now(),
+      registeredLazy: false
     };
     this.servers.set(cfg.name, slot);
+    if (lazy) {
+      await this.startLazy(slot);
+    } else {
+      await this.attemptConnect(slot);
+    }
+  }
+  /**
+   * Boot a lazy server WITHOUT spawning it. If a tool manifest is cached (from a
+   * prior connect with matching config), register resolver-backed wrappers and
+   * go `dormant` — the process spawns on the first tool call. If there is no
+   * cache yet, do a one-time cold discovery connect to learn + cache the tools.
+   */
+  async startLazy(slot) {
+    const cacheDir = this.cacheDir;
+    if (!cacheDir) {
+      await this.attemptConnect(slot);
+      return;
+    }
+    const hash = manifestConfigHash(slot.cfg);
+    const cached = await readManifest(cacheDir, slot.cfg.name, hash);
+    if (cached && cached.length > 0) {
+      this.applyTools(slot, cached);
+      slot.state = "dormant";
+      this.ensureIdleSweep();
+      this.log.info(
+        `MCP server "${slot.cfg.name}" registered lazily from cache (${cached.length} tools, dormant)`
+      );
+      return;
+    }
     await this.attemptConnect(slot);
   }
+  /**
+   * Ensure a lazy server is connected, spawning it on demand. Single-flight:
+   * concurrent first-calls share one connect. Resolver wrappers call this.
+   */
+  async ensureConnected(name) {
+    const slot = this.servers.get(name);
+    if (!slot) throw new Error(`MCP server "${name}" not registered`);
+    slot.lastUsed = Date.now();
+    if (slot.client && slot.state === "connected") return slot.client;
+    if (slot.connecting) return slot.connecting;
+    slot.connecting = (async () => {
+      try {
+        slot.attempts = 0;
+        slot.reconnectCycles = 0;
+        await this.attemptConnect(slot);
+        if (!slot.client) {
+          throw new Error(`MCP server "${name}" failed to connect on demand`);
+        }
+        slot.lastUsed = Date.now();
+        this.ensureIdleSweep();
+        return slot.client;
+      } finally {
+        slot.connecting = void 0;
+      }
+    })();
+    return slot.connecting;
+  }
   /**
    * Register all cached tools for a given server into the tool registry.
    * No-op if tools are already registered or the server is not connected.
@@ -1272,7 +1384,8 @@ var MCPRegistry = class _MCPRegistry {
    */
   activateServer(name) {
     const slot = this.servers.get(name);
-    if (!slot || !slot.client) return;
+    if (!slot) return;
+    if (!slot.client && !slot.lazy) return;
     if (slot.toolNames.length > 0) return;
     const cached = slot.lazyTools;
     if (cached.length === 0) return;
@@ -1327,9 +1440,11 @@ var MCPRegistry = class _MCPRegistry {
       slot.client = void 0;
     }
     slot.onDisconnect = void 0;
+    slot.connecting = void 0;
     for (const t of slot.toolNames) this.toolRegistry.unregister(t);
     slot.toolNames = [];
     slot.lazyTools = [];
+    slot.registeredLazy = false;
     slot.state = "disconnected";
     this.events.emit("mcp.server.disconnected", { name, reason: "stop" });
   }
@@ -1342,11 +1457,89 @@ var MCPRegistry = class _MCPRegistry {
     await this.attemptConnect(slot);
   }
   list() {
-    return Array.from(this.servers.values()).map((s) => ({
-      name: s.cfg.name,
-      state: s.state,
-      toolCount: Math.max(s.toolNames.length, s.lazyTools.length)
-    }));
+    return Array.from(this.servers.values()).map((s) => {
+      const tools = this.toolNamesForSlot(s);
+      return {
+        name: s.cfg.name,
+        state: s.state,
+        toolCount: tools.length,
+        tools
+      };
+    });
+  }
+  /**
+   * Resolve the live tool names for a slot — the registered names in normal
+   * mode, or the cached lazy-tool names when running in lazy mode (where
+   * tools are connected but intentionally not registered).
+   */
+  toolNamesForSlot(s) {
+    return s.toolNames.length > 0 ? s.toolNames.slice() : (s.lazyTools ?? []).map((t) => t.name);
+  }
+  /**
+   * Wrap + register (or cache) a server's tools. Lazy servers get resolver-backed
+   * wrappers that spawn the process on first use; eager servers bind the live
+   * client directly. Honours token-saving `lazyMode` (cache, don't register) and
+   * a register-once guard for lazy resolver wrappers (so a wake/reconnect reuses
+   * the existing registrations rather than churning the tool list).
+   */
+  applyTools(slot, tools, client) {
+    if (slot.lazy && slot.registeredLazy && !this.lazyMode) return;
+    const allowed = slot.cfg.allowedTools;
+    const filtered = tools.filter((t) => !allowed || allowed.includes(t.name));
+    const clientArg = slot.lazy ? () => this.ensureConnected(slot.cfg.name) : expectDefined(client);
+    const wrapped = filtered.map(
+      (t) => wrapMCPTool(slot.cfg.name, t, clientArg, slot.cfg.permission ?? "confirm")
+    );
+    if (this.lazyMode) {
+      slot.lazyTools = wrapped;
+      return;
+    }
+    for (const tool of wrapped) {
+      try {
+        this.toolRegistry.register(tool, `mcp:${slot.cfg.name}`);
+        slot.toolNames.push(tool.name);
+      } catch (err) {
+        this.log.warn(`MCP tool "${tool.name}" not registered`, err);
+      }
+    }
+    if (slot.lazy) slot.registeredLazy = true;
+  }
+  /** Start the shared idle sweep timer once (unref'd so it never holds the process). */
+  ensureIdleSweep() {
+    if (this.idleTimer || this.idleTimeoutMs <= 0) return;
+    this.idleTimer = setInterval(() => {
+      void this.sweepIdle();
+    }, MCP_CONSTANTS.IDLE.SWEEP_INTERVAL_MS);
+    this.idleTimer.unref?.();
+  }
+  /** Auto-sleep connected lazy servers that have been idle past the timeout. */
+  async sweepIdle() {
+    if (this.idleTimeoutMs <= 0) return;
+    const now = Date.now();
+    for (const slot of this.servers.values()) {
+      if (slot.lazy && slot.state === "connected" && slot.client && now - slot.lastUsed > this.idleTimeoutMs) {
+        await this.sleepIdle(slot);
+      }
+    }
+  }
+  /**
+   * Soft stop: close the server process but KEEP its resolver wrappers and
+   * cached manifest registered, so the next tool call transparently re-wakes it.
+   * Distinct from {@link stop} (full teardown for disable/remove).
+   */
+  async sleepIdle(slot) {
+    slot.reconnectPending = false;
+    if (slot.client) {
+      slot.client.removeExitListener(this.onChildExit);
+      if (slot.onDisconnect) slot.client.removeDisconnectListener(slot.onDisconnect);
+      slot.client.removeToolsChangedListener(this.onToolsChanged);
+      await slot.client.close();
+      slot.client = void 0;
+    }
+    slot.onDisconnect = void 0;
+    slot.state = "dormant";
+    this.log.info(`MCP server "${slot.cfg.name}" idle \u2014 sleeping (tools stay registered)`);
+    this.events.emit("mcp.server.disconnected", { name: slot.cfg.name, reason: "idle-sleep" });
   }
   /**
    * Catalog of every server ever registered with this registry — includes
@@ -1355,14 +1548,22 @@ var MCPRegistry = class _MCPRegistry {
    * triggering connections.
    */
   describe() {
-    return Array.from(this.servers.values()).map((s) => ({
-      name: s.cfg.name,
-      state: s.state,
-      toolCount: Math.max(s.toolNames.length, s.lazyTools.length),
-      enabled: s.cfg.enabled !== false
-    }));
+    return Array.from(this.servers.values()).map((s) => {
+      const tools = this.toolNamesForSlot(s);
+      return {
+        name: s.cfg.name,
+        state: s.state,
+        toolCount: tools.length,
+        enabled: s.cfg.enabled !== false,
+        tools
+      };
+    });
   }
   async stopAll() {
+    if (this.idleTimer) {
+      clearInterval(this.idleTimer);
+      this.idleTimer = void 0;
+    }
     for (const name of Array.from(this.servers.keys())) {
       await this.stop(name);
     }
@@ -1394,34 +1595,32 @@ var MCPRegistry = class _MCPRegistry {
       }
     }
     slot.toolNames = [];
-    const allowed = slot.cfg.allowedTools;
-    const wrapped = slot.client.listTools().filter((t) => !allowed || allowed.includes(t.name)).map((t) => wrapMCPTool(slot.cfg.name, t, expectDefined(slot.client), slot.cfg.permission ?? "confirm"));
-    if (this.lazyMode) {
-      slot.lazyTools = wrapped;
-      this.log.info(
-        `MCP server "${slot.cfg.name}" tools refreshed in lazy mode (${wrapped.length} cached)`
-      );
-    } else {
-      for (const tool of wrapped) {
-        try {
-          this.toolRegistry.register(tool, `mcp:${slot.cfg.name}`);
-          slot.toolNames.push(tool.name);
-        } catch (err) {
-          this.log.warn(`MCP tool "${tool.name}" not re-registered after list_changed`, err);
-        }
-      }
+    slot.registeredLazy = false;
+    const discovered = slot.client.listTools();
+    if (slot.lazy && this.cacheDir) {
+      void writeManifest(this.cacheDir, slot.cfg.name, manifestConfigHash(slot.cfg), discovered);
     }
+    this.applyTools(slot, discovered, slot.client);
     this.events.emit("mcp.server.connected", {
       name: slot.cfg.name,
       toolCount: slot.toolNames.length
     });
     this.log.info(
-      `MCP server "${slot.cfg.name}" tools refreshed (${slot.toolNames.length} active, ${wrapped.length} total)`
+      `MCP server "${slot.cfg.name}" tools refreshed (${this.toolNamesForSlot(slot).length} active)`
     );
   };
   onChildExit = (name, code, _signal) => {
     const slot = this.servers.get(name);
     if (!slot) return;
+    if (slot.lazy) {
+      slot.client = void 0;
+      slot.state = "dormant";
+      this.events.emit("mcp.server.disconnected", {
+        name,
+        reason: `exit:${code ?? "unknown"} (dormant)`
+      });
+      return;
+    }
     for (const t of slot.toolNames) {
       try {
         this.toolRegistry.unregister(t);
@@ -1438,6 +1637,12 @@ var MCPRegistry = class _MCPRegistry {
   onTransportDisconnect = (name) => {
     const slot = this.servers.get(name);
     if (!slot) return;
+    if (slot.lazy) {
+      slot.client = void 0;
+      slot.state = "dormant";
+      this.events.emit("mcp.server.disconnected", { name, reason: "http-disconnect (dormant)" });
+      return;
+    }
     for (const t of slot.toolNames) {
       try {
         this.toolRegistry.unregister(t);
@@ -1531,26 +1736,19 @@ var MCPRegistry = class _MCPRegistry {
         const isReconnect = attempt > 1;
         slot.state = "connected";
         slot.reconnectCycles = 0;
-        const allowed = slot.cfg.allowedTools;
         const mc = client;
-        const candidateTools = mc.listTools();
-        const toWrap = candidateTools.length > 0 ? candidateTools : mc.listTools();
-        const wrapped = toWrap.filter((t) => !allowed || allowed.includes(t.name)).map((t) => wrapMCPTool(slot.cfg.name, t, mc, slot.cfg.permission ?? "confirm"));
-        if (this.lazyMode) {
-          slot.lazyTools = wrapped;
-          this.log.info(
-            `MCP server "${slot.cfg.name}" connected in lazy mode (${wrapped.length} tools cached, not registered)`
+        const discovered = mc.listTools();
+        if (slot.lazy && this.cacheDir) {
+          await writeManifest(
+            this.cacheDir,
+            slot.cfg.name,
+            manifestConfigHash(slot.cfg),
+            discovered
           );
-        } else {
-          for (const tool of wrapped) {
-            try {
-              this.toolRegistry.register(tool, `mcp:${slot.cfg.name}`);
-              slot.toolNames.push(tool.name);
-            } catch (err) {
-              this.log.warn(`MCP tool "${tool.name}" not registered`, err);
-            }
-          }
         }
+        this.applyTools(slot, discovered, mc);
+        slot.lastUsed = Date.now();
+        if (slot.lazy) this.ensureIdleSweep();
         this.events.emit(isReconnect ? "mcp.server.reconnected" : "mcp.server.connected", {
           name: slot.cfg.name,
           toolCount: slot.toolNames.length
@@ -1584,6 +1782,237 @@ var MCPRegistry = class _MCPRegistry {
     }
   }
 };
+async function readConfig(path2) {
+  try {
+    return JSON.parse(await fs.readFile(path2, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(path2, cfg) {
+  const raw = JSON.stringify(cfg, null, 2);
+  const tmp = `${path2}.tmp`;
+  await fs.writeFile(tmp, raw, "utf8");
+  await fs.rename(tmp, path2);
+}
+function isMcpServerRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+async function readServers(configPath) {
+  const full = await readConfig(configPath);
+  const servers = isMcpServerRecord(full.mcpServers) ? { ...full.mcpServers } : {};
+  return { full, servers };
+}
+async function persist(configPath, full, servers) {
+  full.mcpServers = servers;
+  await writeConfig(configPath, full);
+}
+function normalizeTransport(t) {
+  if (t === "sse") return "sse";
+  if (t === "http" || t === "streamable-http") return "streamable-http";
+  return "stdio";
+}
+function buildConfig(input, base) {
+  const cfg = {
+    name: input.name,
+    transport: input.transport ? normalizeTransport(String(input.transport)) : base?.transport ?? "stdio"
+  };
+  const description = input.description ?? base?.description;
+  if (description !== void 0) cfg.description = description;
+  const command = input.command ?? base?.command;
+  if (command !== void 0) cfg.command = command;
+  const args = input.args ?? base?.args;
+  if (args !== void 0) cfg.args = args;
+  const env = input.env ?? base?.env;
+  if (env !== void 0) cfg.env = env;
+  const url = input.url ?? base?.url;
+  if (url !== void 0) cfg.url = url;
+  const headers = input.headers ?? base?.headers;
+  if (headers !== void 0) cfg.headers = headers;
+  const allowedTools = input.allowedTools ?? base?.allowedTools;
+  if (allowedTools !== void 0) cfg.allowedTools = allowedTools;
+  const permission = input.permission ?? base?.permission;
+  if (permission !== void 0) cfg.permission = permission;
+  const enabled = input.enabled ?? base?.enabled;
+  if (enabled !== void 0) cfg.enabled = enabled;
+  const lazy = input.lazy ?? base?.lazy;
+  if (lazy !== void 0) cfg.lazy = lazy;
+  return cfg;
+}
+function projectServer(name, cfg, registry) {
+  const live = registry.list().find((s) => s.name === name);
+  const info = {
+    name,
+    transport: cfg.transport,
+    enabled: cfg.enabled !== false,
+    status: live ? live.state : "stopped",
+    tools: live?.tools ?? []
+  };
+  if (cfg.description !== void 0) info.description = cfg.description;
+  if (cfg.url !== void 0) info.url = cfg.url;
+  if (cfg.command !== void 0) info.command = cfg.command;
+  if (cfg.lazy !== void 0) info.lazy = cfg.lazy;
+  return info;
+}
+function liveState(name, registry) {
+  const live = registry.list().find((s) => s.name === name);
+  return { state: live?.state ?? "stopped", tools: live?.tools ?? [] };
+}
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function listMcp(deps) {
+  const { servers } = await readServers(deps.configPath);
+  return Object.entries(servers).map(
+    ([name, cfg]) => projectServer(name, { ...cfg}, deps.registry)
+  );
+}
+async function addMcp(input, deps) {
+  if (!input.name) return { ok: false, message: "Server name is required" };
+  const { full, servers } = await readServers(deps.configPath);
+  if (servers[input.name]) {
+    return { ok: false, message: `Server "${input.name}" already exists` };
+  }
+  const preset = deps.presets?.[input.name];
+  const hasExplicitConfig = !!(input.transport || input.command || input.url);
+  const cfg = hasExplicitConfig ? buildConfig(input, preset) : preset ? buildConfig({ ...input, name: input.name }, preset) : buildConfig(input);
+  if (!hasExplicitConfig && !preset) {
+    const known = Object.keys(deps.presets ?? {}).join(", ");
+    return {
+      ok: false,
+      message: known ? `Unknown server "${input.name}". Available presets: ${known}` : `No configuration provided for "${input.name}"`
+    };
+  }
+  cfg.enabled = input.enabled ?? false;
+  servers[input.name] = cfg;
+  await persist(deps.configPath, full, servers);
+  if (cfg.enabled) {
+    return startServer(input.name, cfg, deps, `Server "${input.name}" added`);
+  }
+  return {
+    ok: true,
+    message: `Server "${input.name}" added (disabled)`,
+    server: projectServer(input.name, cfg, deps.registry)
+  };
+}
+async function updateMcp(input, deps) {
+  if (!input.name) return { ok: false, message: "Server name is required" };
+  const { full, servers } = await readServers(deps.configPath);
+  const existing = servers[input.name];
+  if (!existing) return { ok: false, message: `Server "${input.name}" not found` };
+  const cfg = buildConfig(input, { ...existing, name: input.name });
+  servers[input.name] = cfg;
+  await persist(deps.configPath, full, servers);
+  if (cfg.enabled !== false) {
+    return startServer(input.name, cfg, deps, `Server "${input.name}" updated`, { restart: true });
+  }
+  await safeStop(input.name, deps);
+  return {
+    ok: true,
+    message: `Server "${input.name}" updated`,
+    server: projectServer(input.name, cfg, deps.registry)
+  };
+}
+async function removeMcp(name, deps) {
+  if (!name) return { ok: false, message: "Server name is required" };
+  const { full, servers } = await readServers(deps.configPath);
+  if (!servers[name]) return { ok: false, message: `Server "${name}" not found` };
+  await safeStop(name, deps);
+  delete servers[name];
+  await persist(deps.configPath, full, servers);
+  return { ok: true, message: `Server "${name}" removed` };
+}
+async function enableMcp(name, deps) {
+  if (!name) return { ok: false, message: "Server name is required" };
+  const { full, servers } = await readServers(deps.configPath);
+  const cfg = servers[name];
+  if (!cfg) {
+    return { ok: false, message: `Server "${name}" is not in config. Add it first.` };
+  }
+  cfg.enabled = true;
+  servers[name] = cfg;
+  await persist(deps.configPath, full, servers);
+  return startServer(name, cfg, deps, `Server "${name}" enabled`, { restart: true });
+}
+async function disableMcp(name, deps) {
+  if (!name) return { ok: false, message: "Server name is required" };
+  const { full, servers } = await readServers(deps.configPath);
+  const cfg = servers[name];
+  if (!cfg) return { ok: false, message: `Server "${name}" is not in config.` };
+  await safeStop(name, deps);
+  cfg.enabled = false;
+  servers[name] = cfg;
+  await persist(deps.configPath, full, servers);
+  return {
+    ok: true,
+    message: `Server "${name}" disabled`,
+    server: projectServer(name, cfg, deps.registry)
+  };
+}
+async function restartMcp(name, deps) {
+  if (!name) return { ok: false, message: "Server name is required" };
+  const registered = deps.registry.list().some((s) => s.name === name);
+  if (registered) {
+    try {
+      await deps.registry.restart(name);
+      const { state, tools } = liveState(name, deps.registry);
+      return { ok: true, message: `Server "${name}" restarted`, state, tools };
+    } catch (err) {
+      return { ok: false, message: `Failed to restart "${name}": ${errMessage(err)}` };
+    }
+  }
+  const { servers } = await readServers(deps.configPath);
+  const cfg = servers[name];
+  if (!cfg) return { ok: false, message: `Server "${name}" is not in config.` };
+  return startServer(name, { ...cfg, name }, deps, `Server "${name}" started`, { restart: true });
+}
+async function discoverMcp(name, deps) {
+  if (!name) return { ok: false, message: "Server name is required" };
+  const result = await restartMcp(name, deps);
+  if (!result.ok) return result;
+  const { state, tools } = liveState(name, deps.registry);
+  return {
+    ok: true,
+    message: `Discovered ${tools.length} tool${tools.length === 1 ? "" : "s"} from "${name}"`,
+    state,
+    tools
+  };
+}
+async function startServer(name, cfg, deps, okMessage, opts) {
+  try {
+    const alreadyRegistered = deps.registry.list().some((s) => s.name === name);
+    if (alreadyRegistered && opts?.restart) {
+      await deps.registry.restart(name);
+    } else if (alreadyRegistered) {
+      await deps.registry.restart(name);
+    } else {
+      await deps.registry.start({ ...cfg, enabled: true });
+    }
+    const { state, tools } = liveState(name, deps.registry);
+    return {
+      ok: true,
+      message: okMessage,
+      server: projectServer(name, cfg, deps.registry),
+      state,
+      tools
+    };
+  } catch (err) {
+    const message = errMessage(err);
+    return {
+      ok: true,
+      // config persisted — surface a soft warning, not a hard failure
+      message: `${okMessage} in config, but failed to start: ${message}`,
+      server: projectServer(name, cfg, deps.registry),
+      registryError: message
+    };
+  }
+}
+async function safeStop(name, deps) {
+  try {
+    await deps.registry.stop(name);
+  } catch {
+  }
+}
 var PARSE_ERROR = -32700;
 var INVALID_REQUEST = -32600;
 var METHOD_NOT_FOUND = -32601;
@@ -1829,6 +2258,6 @@ async function handleHttpRequest(server, req, res, token, log) {
   });
 }
 
-export { MCPClient, MCPRegistry, MCPServer, MCP_CONSTANTS, SSEReader, SSETransport, StreamableHTTPTransport, serveHttp, serveStdio, toContentBlocks, wrapMCPTool };
+export { MCPClient, MCPRegistry, MCPServer, MCP_CONSTANTS, SSEReader, SSETransport, StreamableHTTPTransport, addMcp, disableMcp, discoverMcp, enableMcp, listMcp, manifestConfigHash, readManifest, removeMcp, restartMcp, serveHttp, serveStdio, toContentBlocks, updateMcp, wrapMCPTool, writeManifest };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map