mcp-squared 0.3.0 → 0.3.1

package/dist/index.js

@@ -405,7 +405,6 @@ import { randomUUID as randomUUID2 } from "crypto";
 import { UnauthorizedError as UnauthorizedError4 } from "@modelcontextprotocol/sdk/client/auth.js";
 import { Client as Client4 } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport as StreamableHTTPClientTransport4 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { VERSION as VERSION4 } from "@/version.js";
 
 // src/cli/index.ts
 function isValidSecurityProfile(value) {
@@ -1433,173 +1432,9 @@ function computeConfigHash(config) {
 }
 
 // src/daemon/proxy.ts
+init_paths();
 import { spawn } from "child_process";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { getDaemonSocketPath as getDaemonSocketPath2 } from "@/config/paths.js";
-import {
-  loadLiveDaemonRegistry
-} from "@/daemon/registry.js";
-import { SocketClientTransport } from "@/daemon/transport.js";
-var DEFAULT_STARTUP_TIMEOUT_MS = 5000;
-var HEARTBEAT_INTERVAL_MS = 5000;
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-async function waitForDaemon(timeoutMs, configHash) {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    const entry = await loadLiveDaemonRegistry(configHash);
-    if (entry) {
-      return entry;
-    }
-    await sleep(100);
-  }
-  return null;
-}
-function spawnDaemonProcess(sharedSecret) {
-  const execPath = process.execPath;
-  const scriptPath = process.argv[1];
-  const args = scriptPath ? [scriptPath, "daemon"] : ["daemon"];
-  const child = spawn(execPath, args, {
-    detached: true,
-    stdio: "ignore",
-    env: {
-      ...process.env,
-      ...sharedSecret ? { MCP_SQUARED_DAEMON_SECRET: sharedSecret } : {}
-    }
-  });
-  child.unref();
-}
-async function createProxyBridge(options) {
-  const spawnDaemon = options.spawnDaemon ?? spawnDaemonProcess;
-  let endpoint = options.endpoint;
-  let sharedSecret = options.sharedSecret?.trim();
-  let sessionId = null;
-  let heartbeatTimer = null;
-  let isOwner = false;
-  let daemonClosed = false;
-  let stdioClosed = false;
-  const debug = options.debug ?? process.env["MCP_SQUARED_PROXY_DEBUG"] === "1";
-  if (!endpoint) {
-    const registry = await loadLiveDaemonRegistry(options.configHash);
-    if (registry) {
-      endpoint = registry.endpoint;
-      sharedSecret ??= registry.sharedSecret;
-    } else if (!options.noSpawn) {
-      spawnDaemon(sharedSecret);
-      const entry = await waitForDaemon(DEFAULT_STARTUP_TIMEOUT_MS, options.configHash);
-      if (!entry) {
-        throw new Error("Timed out waiting for daemon to start");
-      }
-      endpoint = entry.endpoint;
-      sharedSecret ??= entry.sharedSecret;
-    } else if (options.configHash) {
-      endpoint = getDaemonSocketPath2(options.configHash);
-    }
-  }
-  if (!endpoint) {
-    throw new Error("Daemon endpoint not available");
-  }
-  const transportOptions = {
-    endpoint
-  };
-  if (options.timeoutMs !== undefined) {
-    transportOptions.timeoutMs = options.timeoutMs;
-  }
-  const daemonTransport = new SocketClientTransport(transportOptions);
-  const stdioTransport = options.stdioTransport;
-  const closeDaemon = async (sendGoodbye) => {
-    if (daemonClosed) {
-      return;
-    }
-    daemonClosed = true;
-    if (sendGoodbye && sessionId) {
-      await daemonTransport.sendControl({ type: "goodbye", sessionId }).catch(() => {});
-    }
-    await daemonTransport.close().catch(() => {});
-  };
-  daemonTransport.oncontrol = (message) => {
-    switch (message.type) {
-      case "helloAck":
-        sessionId = message.sessionId;
-        isOwner = message.isOwner;
-        if (debug) {
-          console.error(`[proxy] session ${message.sessionId} owner=${message.isOwner}`);
-        }
-        break;
-      case "ownerChanged":
-        isOwner = message.ownerSessionId === sessionId;
-        if (debug) {
-          console.error(`[proxy] owner changed: ${message.ownerSessionId} (isOwner=${isOwner})`);
-        }
-        break;
-    }
-  };
-  daemonTransport.onmessage = (message) => {
-    stdioTransport.send(message);
-  };
-  daemonTransport.onclose = () => {
-    daemonClosed = true;
-    if (heartbeatTimer) {
-      clearInterval(heartbeatTimer);
-      heartbeatTimer = null;
-    }
-    stdioTransport.close();
-  };
-  daemonTransport.onerror = (error) => {
-    console.error(`Daemon transport error: ${error.message}`);
-  };
-  stdioTransport.onmessage = (message) => {
-    daemonTransport.send(message);
-  };
-  stdioTransport.onclose = () => {
-    stdioClosed = true;
-    if (heartbeatTimer) {
-      clearInterval(heartbeatTimer);
-      heartbeatTimer = null;
-    }
-    closeDaemon(true);
-  };
-  stdioTransport.onerror = (error) => {
-    console.error(`Stdio transport error: ${error.message}`);
-  };
-  await daemonTransport.start();
-  const launcherHint = process.env["MCP_SQUARED_LAUNCHER"] ?? process.env["MCP_CLIENT_NAME"] ?? process.env["MCP_SQUARED_AGENT"];
-  const clientId = launcherHint ? `${launcherHint}-${process.pid}` : `proxy-${process.pid}`;
-  daemonTransport.sendControl({
-    type: "hello",
-    clientId,
-    ...sharedSecret ? { sharedSecret } : {}
-  });
-  heartbeatTimer = setInterval(() => {
-    if (!sessionId) {
-      return;
-    }
-    daemonTransport.sendControl({
-      type: "heartbeat",
-      sessionId
-    });
-  }, options.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS);
-  await stdioTransport.start();
-  return {
-    stop: async () => {
-      if (heartbeatTimer) {
-        clearInterval(heartbeatTimer);
-        heartbeatTimer = null;
-      }
-      await closeDaemon(true);
-      if (!stdioClosed) {
-        await stdioTransport.close();
-      }
-    }
-  };
-}
-async function runProxy(options = {}) {
-  return createProxyBridge({
-    ...options,
-    stdioTransport: new StdioServerTransport
-  });
-}
 
 // src/daemon/registry.ts
 init_paths();
@@ -1698,7 +1533,7 @@ async function isDaemonAlive(entry, timeoutMs = DEFAULT_CONNECT_TIMEOUT_MS2) {
   }
   return canConnect2(entry.endpoint, timeoutMs);
 }
-async function loadLiveDaemonRegistry2(configHash) {
+async function loadLiveDaemonRegistry(configHash) {
   const entry = readDaemonRegistry(configHash);
   if (!entry) {
     return null;
@@ -1711,20 +1546,8 @@ async function loadLiveDaemonRegistry2(configHash) {
   return entry;
 }
 
-// src/daemon/server.ts
-init_paths();
-import { randomUUID } from "crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3 } from "fs";
-import {
-  connect as connect3,
-  createServer,
-  isIPv4,
-  isIPv6
-} from "net";
-import { dirname as dirname2 } from "path";
-import { VERSION } from "@/version.js";
-
 // src/daemon/transport.ts
+import { connect as connect3 } from "net";
 var HEADER_LENGTH = 4;
 function encodeFrame(message) {
   const payload = Buffer.from(JSON.stringify(message), "utf8");
@@ -1822,10 +1645,275 @@ class SocketServerTransport extends BaseSocketTransport {
     this.socket = socket;
   }
 }
+function isTcpEndpoint3(endpoint) {
+  return endpoint.startsWith("tcp://");
+}
+function parseTcpEndpoint3(endpoint) {
+  const url = new URL(endpoint);
+  if (url.protocol !== "tcp:") {
+    throw new Error(`Invalid TCP endpoint protocol: ${url.protocol}`);
+  }
+  const host = url.hostname;
+  const port = Number.parseInt(url.port, 10);
+  if (!host || Number.isNaN(port)) {
+    throw new Error(`Invalid TCP endpoint: ${endpoint}`);
+  }
+  return { host, port };
+}
+
+class SocketClientTransport extends BaseSocketTransport {
+  endpoint;
+  timeoutMs;
+  constructor(options) {
+    super();
+    this.endpoint = options.endpoint;
+    this.timeoutMs = options.timeoutMs ?? 5000;
+  }
+  async start() {
+    if (this.started) {
+      return;
+    }
+    await new Promise((resolve2, reject) => {
+      const socket = isTcpEndpoint3(this.endpoint) ? connect3(parseTcpEndpoint3(this.endpoint)) : connect3(this.endpoint);
+      this.socket = socket;
+      const timeoutId = setTimeout(() => {
+        socket.destroy();
+        reject(new Error(`Connection timeout after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+      socket.once("connect", () => {
+        clearTimeout(timeoutId);
+        this.started = true;
+        this.attachHandlers();
+        resolve2();
+      });
+      socket.once("error", (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+}
+
+// src/daemon/proxy.ts
+var DEFAULT_STARTUP_TIMEOUT_MS = 5000;
+var HEARTBEAT_INTERVAL_MS = 5000;
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function waitForDaemon(timeoutMs, configHash) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const entry = await loadLiveDaemonRegistry(configHash);
+    if (entry) {
+      return entry;
+    }
+    await sleep(100);
+  }
+  return null;
+}
+function spawnDaemonProcess(sharedSecret) {
+  const execPath = process.execPath;
+  const scriptPath = process.argv[1];
+  const args = scriptPath ? [scriptPath, "daemon"] : ["daemon"];
+  const child = spawn(execPath, args, {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      ...sharedSecret ? { MCP_SQUARED_DAEMON_SECRET: sharedSecret } : {}
+    }
+  });
+  child.unref();
+}
+async function createProxyBridge(options) {
+  const spawnDaemon = options.spawnDaemon ?? spawnDaemonProcess;
+  let endpoint = options.endpoint;
+  let sharedSecret = options.sharedSecret?.trim();
+  let sessionId = null;
+  let heartbeatTimer = null;
+  let isOwner = false;
+  let daemonClosed = false;
+  let stdioClosed = false;
+  const debug = options.debug ?? process.env["MCP_SQUARED_PROXY_DEBUG"] === "1";
+  if (!endpoint) {
+    const registry = await loadLiveDaemonRegistry(options.configHash);
+    if (registry) {
+      endpoint = registry.endpoint;
+      sharedSecret ??= registry.sharedSecret;
+    } else if (!options.noSpawn) {
+      spawnDaemon(sharedSecret);
+      const entry = await waitForDaemon(DEFAULT_STARTUP_TIMEOUT_MS, options.configHash);
+      if (!entry) {
+        throw new Error("Timed out waiting for daemon to start");
+      }
+      endpoint = entry.endpoint;
+      sharedSecret ??= entry.sharedSecret;
+    } else if (options.configHash) {
+      endpoint = getDaemonSocketPath(options.configHash);
+    }
+  }
+  if (!endpoint) {
+    throw new Error("Daemon endpoint not available");
+  }
+  const transportOptions = {
+    endpoint
+  };
+  if (options.timeoutMs !== undefined) {
+    transportOptions.timeoutMs = options.timeoutMs;
+  }
+  const daemonTransport = new SocketClientTransport(transportOptions);
+  const stdioTransport = options.stdioTransport;
+  const closeDaemon = async (sendGoodbye) => {
+    if (daemonClosed) {
+      return;
+    }
+    daemonClosed = true;
+    if (sendGoodbye && sessionId) {
+      await daemonTransport.sendControl({ type: "goodbye", sessionId }).catch(() => {});
+    }
+    await daemonTransport.close().catch(() => {});
+  };
+  daemonTransport.oncontrol = (message) => {
+    switch (message.type) {
+      case "helloAck":
+        sessionId = message.sessionId;
+        isOwner = message.isOwner;
+        if (debug) {
+          console.error(`[proxy] session ${message.sessionId} owner=${message.isOwner}`);
+        }
+        break;
+      case "ownerChanged":
+        isOwner = message.ownerSessionId === sessionId;
+        if (debug) {
+          console.error(`[proxy] owner changed: ${message.ownerSessionId} (isOwner=${isOwner})`);
+        }
+        break;
+    }
+  };
+  daemonTransport.onmessage = (message) => {
+    stdioTransport.send(message);
+  };
+  daemonTransport.onclose = () => {
+    daemonClosed = true;
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    stdioTransport.close();
+  };
+  daemonTransport.onerror = (error) => {
+    console.error(`Daemon transport error: ${error.message}`);
+  };
+  stdioTransport.onmessage = (message) => {
+    daemonTransport.send(message);
+  };
+  stdioTransport.onclose = () => {
+    stdioClosed = true;
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    closeDaemon(true);
+  };
+  stdioTransport.onerror = (error) => {
+    console.error(`Stdio transport error: ${error.message}`);
+  };
+  await daemonTransport.start();
+  const launcherHint = process.env["MCP_SQUARED_LAUNCHER"] ?? process.env["MCP_CLIENT_NAME"] ?? process.env["MCP_SQUARED_AGENT"];
+  const clientId = launcherHint ? `${launcherHint}-${process.pid}` : `proxy-${process.pid}`;
+  daemonTransport.sendControl({
+    type: "hello",
+    clientId,
+    ...sharedSecret ? { sharedSecret } : {}
+  });
+  heartbeatTimer = setInterval(() => {
+    if (!sessionId) {
+      return;
+    }
+    daemonTransport.sendControl({
+      type: "heartbeat",
+      sessionId
+    });
+  }, options.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS);
+  await stdioTransport.start();
+  return {
+    stop: async () => {
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+        heartbeatTimer = null;
+      }
+      await closeDaemon(true);
+      if (!stdioClosed) {
+        await stdioTransport.close();
+      }
+    }
+  };
+}
+async function runProxy(options = {}) {
+  return createProxyBridge({
+    ...options,
+    stdioTransport: new StdioServerTransport
+  });
+}
+
+// src/daemon/server.ts
+init_paths();
+import { randomUUID } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3 } from "fs";
+import {
+  connect as connect4,
+  createServer,
+  isIPv4,
+  isIPv6
+} from "net";
+import { dirname as dirname2 } from "path";
+
+// src/version.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { createRequire } from "module";
+function normalizeVersion(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+function readManifestFile(manifestUrl) {
+  const raw = readFileSync3(manifestUrl, "utf8");
+  return JSON.parse(raw);
+}
+function readBundledManifestFile() {
+  const require2 = createRequire(import.meta.url);
+  return require2("../package.json");
+}
+function resolveVersion(options = {}) {
+  const readManifest = options.readManifest ?? readManifestFile;
+  const manifestUrl = options.manifestUrl ?? new URL("../package.json", import.meta.url);
+  try {
+    const manifest = readManifest(manifestUrl);
+    const manifestVersion = normalizeVersion(manifest.version);
+    if (manifestVersion) {
+      return manifestVersion;
+    }
+  } catch {}
+  const envVersion = normalizeVersion((options.env ?? process.env)["npm_package_version"]);
+  if (envVersion) {
+    return envVersion;
+  }
+  const readBundledManifest = options.readBundledManifest ?? readBundledManifestFile;
+  try {
+    const bundledVersion = normalizeVersion(readBundledManifest().version);
+    if (bundledVersion) {
+      return bundledVersion;
+    }
+  } catch {}
+  return normalizeVersion(options.fallbackVersion) ?? "0.0.0";
+}
+var VERSION = resolveVersion();
 
 // src/daemon/server.ts
 var DEFAULT_CONNECT_TIMEOUT_MS3 = 300;
-function isTcpEndpoint3(endpoint) {
+function isTcpEndpoint4(endpoint) {
   return endpoint.startsWith("tcp://");
 }
 function parseMappedIpv4Address(normalizedHost) {
@@ -1850,7 +1938,7 @@ function parseMappedIpv4Address(normalizedHost) {
   }
   return `${high >> 8 & 255}.${high & 255}.${low >> 8 & 255}.${low & 255}`;
 }
-function parseTcpEndpoint3(endpoint) {
+function parseTcpEndpoint4(endpoint) {
   const url = new URL(endpoint);
   if (url.protocol !== "tcp:") {
     throw new Error(`Invalid TCP endpoint protocol: ${url.protocol}`);
@@ -1898,7 +1986,7 @@ function formatTcpEndpoint(host, port) {
   return `tcp://${normalized}:${port}`;
 }
 function assertLoopbackTcpEndpoint(endpoint) {
-  const { host } = parseTcpEndpoint3(endpoint);
+  const { host } = parseTcpEndpoint4(endpoint);
   if (!isLoopbackHost(host)) {
     throw new Error(`Refusing non-loopback daemon TCP endpoint: ${endpoint}. Use localhost, 127.0.0.1, or ::1.`);
   }
@@ -1907,7 +1995,7 @@ async function canConnect3(endpoint, timeoutMs = DEFAULT_CONNECT_TIMEOUT_MS3) {
   return new Promise((resolve2) => {
     let socket = null;
     try {
-      socket = isTcpEndpoint3(endpoint) ? connect3(parseTcpEndpoint3(endpoint)) : connect3(endpoint);
+      socket = isTcpEndpoint4(endpoint) ? connect4(parseTcpEndpoint4(endpoint)) : connect4(endpoint);
     } catch {
       resolve2(false);
       return;
@@ -1962,7 +2050,7 @@ class DaemonServer {
       return;
     }
     ensureDaemonDir(this.configHash);
-    const tcp = isTcpEndpoint3(this.socketPath);
+    const tcp = isTcpEndpoint4(this.socketPath);
     if (tcp) {
       assertLoopbackTcpEndpoint(this.socketPath);
     }
@@ -1970,7 +2058,7 @@ class DaemonServer {
       mkdirSync3(dirname2(this.socketPath), { recursive: true });
     }
     if (tcp) {
-      const port = parseTcpEndpoint3(this.socketPath).port;
+      const port = parseTcpEndpoint4(this.socketPath).port;
       if (port > 0 && await canConnect3(this.socketPath)) {
         throw new Error(`Daemon already running at ${this.socketPath}. Refusing to start another.`);
       }
@@ -1990,7 +2078,7 @@ class DaemonServer {
     await new Promise((resolve2, reject) => {
       this.server?.once("error", (error) => reject(error));
       if (tcp) {
-        const { host, port } = parseTcpEndpoint3(this.socketPath);
+        const { host, port } = parseTcpEndpoint4(this.socketPath);
         if (!host || Number.isNaN(port)) {
           reject(new Error(`Invalid TCP endpoint: ${this.socketPath}`));
           return;
@@ -3667,7 +3755,7 @@ function promptUser(question) {
 }
 
 // src/install/runner.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3 } from "path";
 import { createInterface } from "readline";
 import { parse as parseToml3, stringify as stringifyToml2 } from "smol-toml";
@@ -3987,7 +4075,7 @@ function performInstallation(options) {
   if (existsSync7(path)) {
     configExists = true;
     try {
-      const content = readFileSync3(path, "utf-8");
+      const content = readFileSync4(path, "utf-8");
       existingConfig = isToml ? parseToml3(content) : JSON.parse(content);
     } catch (error) {
       return {
@@ -4404,7 +4492,6 @@ class OAuthCallbackServer {
 import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { VERSION as VERSION2 } from "@/version.js";
 
 // src/oauth/provider.ts
 var DEFAULT_OAUTH_CALLBACK_PORT = 8089;
@@ -4575,7 +4662,7 @@ import {
   chmodSync,
   existsSync as existsSync8,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync4
 } from "fs";
@@ -4613,7 +4700,7 @@ class TokenStorage {
       return;
     }
     try {
-      const content = readFileSync4(filePath, "utf-8");
+      const content = readFileSync5(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return;
@@ -4695,7 +4782,7 @@ class TokenStorage {
 function getPreflightClientMetadata() {
   return {
     name: "mcp-squared-preflight",
-    version: VERSION2
+    version: VERSION
   };
 }
 async function performPreflightAuth(config) {
@@ -4800,7 +4887,6 @@ async function performInteractiveAuth(name, sseConfig, authProvider, callbackPor
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport as StdioServerTransport2 } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z3 } from "zod";
-import { VERSION as VERSION3 } from "@/version.js";
 
 // agent_safety_kit/policy/matchers.ts
 var GLOB_SPECIALS = /[.+^${}()|[\]\\]/g;
@@ -5158,7 +5244,7 @@ class Guard {
   }
 }
 // agent_safety_kit/policy/load.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve3 } from "path";
 import { parse as parseYaml } from "yaml";
 
@@ -5221,7 +5307,7 @@ function load_policy(options = {}) {
   if (!existsSync9(sourcePath)) {
     throw new Error(`Agent safety policy file not found at ${sourcePath}`);
   }
-  const raw = readFileSync5(sourcePath, "utf8");
+  const raw = readFileSync6(sourcePath, "utf8");
   const parsed = parseYaml(raw);
   const policy = AgentPolicySchema.parse(parsed);
   const playbookName = options.playbook ?? envConfig.playbook;
@@ -5258,7 +5344,7 @@ class NullSink {
 }
 
 // agent_safety_kit/observability/sinks/otel.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 
 // agent_safety_kit/observability/sinks/base.ts
 function compactAttributes(attributes) {
@@ -5275,7 +5361,7 @@ function compactAttributes(attributes) {
 }
 
 // agent_safety_kit/observability/sinks/otel.ts
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 function loadOpenTelemetryApi() {
   try {
     return require2("@opentelemetry/api");
@@ -7154,10 +7240,10 @@ async function testUpstreamConnection(name, config, options = {}) {
 // src/server/monitor-server.ts
 import { existsSync as existsSync10, unlinkSync as unlinkSync5 } from "fs";
 import { createServer as createServer3 } from "net";
-function isTcpEndpoint4(endpoint) {
+function isTcpEndpoint5(endpoint) {
   return endpoint.startsWith("tcp://");
 }
-function parseTcpEndpoint4(endpoint) {
+function parseTcpEndpoint5(endpoint) {
   let url;
   try {
     url = new URL(endpoint);
@@ -7197,7 +7283,7 @@ class MonitorServer {
     if (this.isRunning) {
       return;
     }
-    const tcp = isTcpEndpoint4(this.socketPath);
+    const tcp = isTcpEndpoint5(this.socketPath);
     if (!tcp && existsSync10(this.socketPath)) {
       try {
         unlinkSync5(this.socketPath);
@@ -7218,7 +7304,7 @@ class MonitorServer {
         reject(error);
       });
       if (tcp) {
-        const { host, port } = parseTcpEndpoint4(this.socketPath);
+        const { host, port } = parseTcpEndpoint5(this.socketPath);
         server.listen({ host, port }, () => {
           const address = server.address();
           if (address && typeof address !== "string") {
@@ -7252,7 +7338,7 @@ class MonitorServer {
         }
       });
     });
-    if (!isTcpEndpoint4(this.socketPath)) {
+    if (!isTcpEndpoint5(this.socketPath)) {
       try {
         if (existsSync10(this.socketPath)) {
           unlinkSync5(this.socketPath);
@@ -7609,7 +7695,7 @@ class McpSquaredServer {
   guard;
   constructor(options = {}) {
     const name = options.name ?? "mcp-squared";
-    const version = options.version ?? VERSION3;
+    const version = options.version ?? VERSION;
     this.serverName = name;
     this.serverVersion = version;
     if (options.cataloger) {
@@ -8186,7 +8272,7 @@ async function startServer() {
     startedAt: Date.now(),
     cwd: process.cwd(),
     configPath,
-    version: VERSION4,
+    version: VERSION,
     command: process.argv.join(" "),
     role: "server",
     ...launcher ? { launcher } : {}
@@ -8413,7 +8499,7 @@ Callback URL: ${callbackServer.getCallbackUrl()}`);
   });
   const client = new Client4({
     name: "mcp-squared-auth",
-    version: VERSION4
+    version: VERSION
   });
   console.log(`
 Connecting to server...`);
@@ -8476,7 +8562,7 @@ async function runMonitor(options) {
   if (!socketPath) {
     const { config, path: configPath } = await loadConfig();
     const configHash = computeConfigHash(config);
-    const daemonRegistry = await loadLiveDaemonRegistry2(configHash);
+    const daemonRegistry = await loadLiveDaemonRegistry(configHash);
     if (!daemonRegistry) {
       console.error("Error: No running shared MCP\xB2 daemon found for the active configuration.");
       console.error("Start the daemon first:");
@@ -8690,7 +8776,7 @@ async function runDaemon(options) {
     startedAt: Date.now(),
     cwd: process.cwd(),
     configPath,
-    version: VERSION4,
+    version: VERSION,
     command: process.argv.join(" "),
     role: "daemon",
     ...daemonLauncher ? { launcher: daemonLauncher } : {}
@@ -8743,7 +8829,7 @@ async function runProxyCommand(options) {
     startedAt: Date.now(),
     cwd: process.cwd(),
     configPath,
-    version: VERSION4,
+    version: VERSION,
     command: process.argv.join(" "),
     role: "proxy",
     ...proxyLauncher ? { launcher: proxyLauncher } : {}
@@ -8818,7 +8904,7 @@ async function main(argv = process.argv.slice(2)) {
     process.exit(0);
   }
   if (args.version) {
-    console.log(`MCP\xB2 v${VERSION4}`);
+    console.log(`MCP\xB2 v${VERSION}`);
     process.exit(0);
   }
   switch (args.mode) {
@@ -8888,5 +8974,5 @@ export {
   main,
   logSecurityProfile,
   logSearchModeProfile,
-  VERSION4 as VERSION
+  VERSION
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-squared",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "MCP² (Mercury Control Plane) - A local-first meta-server and proxy for the Model Context Protocol",
   "author": "aditzel",
   "license": "Apache-2.0",