@pellux/goodvibes-sdk 0.33.25 → 0.33.27

package/dist/platform/mcp/registry.js

@@ -8,11 +8,11 @@
  * Tool namespace: mcp:<server-name>:<tool-name>
  */
 import { logger } from '../utils/logger.js';
-import { loadMcpConfig } from './config.js';
+import { loadMcpEffectiveConfig, removeMcpServerConfig, upsertMcpServerConfig, } from './config.js';
 import { McpClient } from './client.js';
 import { McpPermissionManager } from '../runtime/mcp/permissions.js';
 import { McpSchemaFreshnessTracker } from '../runtime/mcp/schema-freshness.js';
-import { emitMcpConfigured, emitMcpPolicyUpdated, emitMcpSchemaQuarantineApproved, emitMcpSchemaQuarantined, } from '../runtime/emitters/mcp.js';
+import { emitMcpConfigured, emitMcpDisconnected, emitMcpPolicyUpdated, emitMcpSchemaQuarantineApproved, emitMcpSchemaQuarantined, } from '../runtime/emitters/mcp.js';
 import { getSandboxConfigSnapshot } from '../runtime/sandbox/manager.js';
 import {} from '../runtime/sandbox/session-registry.js';
 import { resolveSandboxCommandPlan } from '../runtime/sandbox/backend.js';
@@ -20,8 +20,12 @@ import { summarizeError } from '../utils/error-display.js';
 function compactEnv(env) {
     return Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === 'string'));
 }
+function sameServerConfig(a, b) {
+    return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}
 export class McpRegistry {
     clients = new Map();
+    serverConfigs = new Map();
     permissions = new McpPermissionManager();
     freshness = new McpSchemaFreshnessTracker();
     runtimeBus = null;
@@ -45,16 +49,74 @@ export class McpRegistry {
      * Errors on individual servers are logged but do not abort the whole startup.
      */
     async connectAll(roots) {
-        const mcpConfig = loadMcpConfig(roots);
-        await Promise.allSettled(mcpConfig.servers.map((serverConfig) => this._connectServer(serverConfig)));
+        await this.reload(roots);
     }
     /**
      * connectServer — Connect a single MCP server by config.
      * Exposed for programmatic use (testing, dynamic registration).
      */
     async connectServer(serverConfig) {
+        this.serverConfigs.set(serverConfig.name, serverConfig);
         await this._connectServer(serverConfig);
     }
+    async reload(roots) {
+        const effective = loadMcpEffectiveConfig(roots);
+        return this.applyConfig(effective.servers.map((entry) => entry.server));
+    }
+    getEffectiveConfig(roots) {
+        return loadMcpEffectiveConfig(roots);
+    }
+    async upsertServerConfig(roots, scope, serverConfig) {
+        const written = upsertMcpServerConfig(roots, scope, serverConfig);
+        return { path: written.path, reload: await this.reload(roots) };
+    }
+    async removeServerConfig(roots, scope, serverName) {
+        const written = removeMcpServerConfig(roots, scope, serverName);
+        return { path: written.path, removed: written.removed, reload: await this.reload(roots) };
+    }
+    async applyConfig(serverConfigs) {
+        const next = new Map(serverConfigs.map((serverConfig) => [serverConfig.name, serverConfig]));
+        const results = [];
+        let added = 0;
+        let changed = 0;
+        let removed = 0;
+        let unchanged = 0;
+        for (const name of [...this.serverConfigs.keys()]) {
+            if (next.has(name))
+                continue;
+            await this.disconnectServer(name, 'config-removed');
+            this.serverConfigs.delete(name);
+            removed += 1;
+            results.push({ name, action: 'removed', connected: false });
+        }
+        for (const [name, serverConfig] of next) {
+            const previous = this.serverConfigs.get(name);
+            if (previous && sameServerConfig(previous, serverConfig)) {
+                unchanged += 1;
+                const client = this.clients.get(name);
+                if (!client?.isConnected) {
+                    await this._connectServer(serverConfig);
+                }
+                results.push({ name, action: 'unchanged', connected: this.clients.get(name)?.isConnected ?? false });
+                continue;
+            }
+            if (previous) {
+                await this.disconnectServer(name, 'config-changed');
+                changed += 1;
+            }
+            else {
+                added += 1;
+            }
+            this.serverConfigs.set(name, serverConfig);
+            await this._connectServer(serverConfig);
+            results.push({
+                name,
+                action: previous ? 'changed' : 'added',
+                connected: this.clients.get(name)?.isConnected ?? false,
+            });
+        }
+        return { added, changed, removed, unchanged, servers: results };
+    }
     /**
      * listAllTools — Return all registered tools (name + description) from all connected servers.
      * Only loads tool names and descriptions — full schemas are NOT fetched here.
@@ -194,6 +256,38 @@ export class McpRegistry {
         }
         this.sandboxSessionByServer.clear();
     }
+    async disconnectServer(serverName, reason = 'manual') {
+        const client = this.clients.get(serverName);
+        if (!client)
+            return false;
+        await client.disconnect();
+        this.clients.delete(serverName);
+        const sessionId = this.sandboxSessionByServer.get(serverName);
+        if (sessionId) {
+            this.sandboxSessions.stop(sessionId);
+            this.sandboxSessionByServer.delete(serverName);
+        }
+        if (this.runtimeBus) {
+            emitMcpDisconnected(this.runtimeBus, {
+                sessionId: 'mcp-registry',
+                traceId: `mcp-registry:${serverName}:disconnected`,
+                source: 'mcp-registry',
+            }, { serverId: serverName, reason, willRetry: false });
+        }
+        const disconnectedEvent = {
+            path: 'Lifecycle:mcp:disconnected',
+            phase: 'Lifecycle',
+            category: 'mcp',
+            specific: 'disconnected',
+            sessionId: '',
+            timestamp: Date.now(),
+            payload: { server: serverName, reason },
+        };
+        this.hookDispatcher.fire(disconnectedEvent).catch((err) => {
+            logger.warn('Lifecycle:mcp:disconnected hook error', { error: summarizeError(err) });
+        });
+        return true;
+    }
     /**
      * getClient — Get the McpClient for a given server name (for advanced use).
      */
@@ -202,15 +296,15 @@ export class McpRegistry {
     }
     /** Connected server names. */
     get serverNames() {
-        return Array.from(this.clients.keys());
+        return Array.from(new Set([...this.serverConfigs.keys(), ...this.clients.keys()])).sort();
     }
     /**
      * listServers — Return status info for all known servers (connected or not).
      */
     listServers() {
-        return Array.from(this.clients.entries()).map(([name, client]) => ({
+        return this.serverNames.map((name) => ({
             name,
-            connected: client.isConnected,
+            connected: this.clients.get(name)?.isConnected ?? false,
         }));
     }
     listServerSecurity() {
@@ -283,10 +377,14 @@ export class McpRegistry {
     // ---------------------------------------------------------------------------
     async _connectServer(serverConfig) {
         const { name } = serverConfig;
-        if (this.clients.has(name)) {
+        const existing = this.clients.get(name);
+        if (existing?.isConnected) {
             logger.info('McpRegistry: server already registered', { name });
             return;
         }
+        if (existing) {
+            await this.disconnectServer(name, 'reconnect');
+        }
         let sandboxSessionId = null;
         let processSpec;
         if (this.sandboxConfigManager) {

package/dist/platform/version.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-let version = '0.33.25';
+let version = '0.33.27';
 try {
     const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', '..', 'package.json'), 'utf-8'));
     version = pkg.version ?? version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-sdk",
-  "version": "0.33.25",
+  "version": "0.33.27",
   "description": "TypeScript SDK for building GoodVibes operator, peer, web, mobile, and daemon-connected apps with typed contracts, auth, realtime events, and transport layers.",
   "keywords": [
     "goodvibes",
@@ -449,14 +449,14 @@
   "sideEffects": false,
   "type": "module",
   "dependencies": {
-    "@pellux/goodvibes-contracts": "0.33.25",
-    "@pellux/goodvibes-daemon-sdk": "0.33.25",
-    "@pellux/goodvibes-errors": "0.33.25",
-    "@pellux/goodvibes-operator-sdk": "0.33.25",
-    "@pellux/goodvibes-peer-sdk": "0.33.25",
-    "@pellux/goodvibes-transport-core": "0.33.25",
-    "@pellux/goodvibes-transport-http": "0.33.25",
-    "@pellux/goodvibes-transport-realtime": "0.33.25"
+    "@pellux/goodvibes-contracts": "0.33.27",
+    "@pellux/goodvibes-daemon-sdk": "0.33.27",
+    "@pellux/goodvibes-errors": "0.33.27",
+    "@pellux/goodvibes-operator-sdk": "0.33.27",
+    "@pellux/goodvibes-peer-sdk": "0.33.27",
+    "@pellux/goodvibes-transport-core": "0.33.27",
+    "@pellux/goodvibes-transport-http": "0.33.27",
+    "@pellux/goodvibes-transport-realtime": "0.33.27"
   },
   "optionalDependencies": {
     "@agentclientprotocol/sdk": "^0.21.0",