mcp-squared 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,18 +1,133 @@
 #!/usr/bin/env bun
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/config/paths.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir, platform } from "os";
+import { dirname, join, resolve } from "path";
+function getEnv(key) {
+  return Bun.env[key];
+}
+function getXdgConfigHome() {
+  return getEnv("XDG_CONFIG_HOME") || join(homedir(), ".config");
+}
+function getUserConfigDir() {
+  const os = platform();
+  if (os === "win32") {
+    return join(getEnv("APPDATA") || join(homedir(), "AppData", "Roaming"), APP_NAME);
+  }
+  return join(getXdgConfigHome(), APP_NAME);
+}
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function getUserConfigPath() {
+  return join(getUserConfigDir(), "config.toml");
+}
+function getSocketFilePath(instanceId) {
+  if (!instanceId) {
+    return join(getUserConfigDir(), SOCKET_FILENAME);
+  }
+  return join(getSocketDir(), `mcp-squared.${instanceId}.sock`);
+}
+function getDaemonDir(configHash) {
+  if (configHash) {
+    return join(getUserConfigDir(), DAEMON_DIR_NAME, configHash);
+  }
+  return join(getUserConfigDir(), DAEMON_DIR_NAME);
+}
+function getDaemonRegistryPath(configHash) {
+  return join(getDaemonDir(configHash), DAEMON_REGISTRY_FILENAME);
+}
+function getDaemonSocketPath(configHash) {
+  return join(getDaemonDir(configHash), DAEMON_SOCKET_FILENAME);
+}
+function getInstanceRegistryDir() {
+  return join(getUserConfigDir(), INSTANCE_DIR_NAME);
+}
+function getSocketDir() {
+  return join(getUserConfigDir(), SOCKET_DIR_NAME);
+}
+function ensureInstanceRegistryDir() {
+  ensureDir(getInstanceRegistryDir());
+}
+function ensureSocketDir() {
+  ensureDir(getSocketDir());
+}
+function ensureDaemonDir(configHash) {
+  const daemonDir = getDaemonDir(configHash);
+  if (!existsSync(daemonDir)) {
+    mkdirSync(daemonDir, { recursive: true, mode: 448 });
+  }
+}
+function findProjectConfig(startDir) {
+  let currentDir = resolve(startDir);
+  const root = dirname(currentDir);
+  while (currentDir !== root) {
+    const directPath = join(currentDir, CONFIG_FILENAME);
+    if (existsSync(directPath)) {
+      return directPath;
+    }
+    const hiddenDirPath = join(currentDir, CONFIG_DIR_NAME, "config.toml");
+    if (existsSync(hiddenDirPath)) {
+      return hiddenDirPath;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir)
+      break;
+    currentDir = parentDir;
+  }
+  return null;
+}
+function discoverConfigPath(cwd = process.cwd()) {
+  const envPath = getEnv("MCP_SQUARED_CONFIG");
+  if (envPath) {
+    const resolvedEnvPath = resolve(envPath);
+    if (existsSync(resolvedEnvPath)) {
+      return { path: resolvedEnvPath, source: "env" };
+    }
+  }
+  const projectPath = findProjectConfig(cwd);
+  if (projectPath) {
+    return { path: projectPath, source: "project" };
+  }
+  const userPath = getUserConfigPath();
+  if (existsSync(userPath)) {
+    return { path: userPath, source: "user" };
+  }
+  return null;
+}
+function getDefaultConfigPath() {
+  return {
+    path: getUserConfigPath(),
+    source: "user"
+  };
+}
+function ensureConfigDir(configPath) {
+  const dir = dirname(configPath);
+  ensureDir(dir);
+}
+var SOCKET_FILENAME = "mcp-squared.sock", INSTANCE_DIR_NAME = "instances", SOCKET_DIR_NAME = "sockets", DAEMON_DIR_NAME = "daemon", DAEMON_REGISTRY_FILENAME = "daemon.json", DAEMON_SOCKET_FILENAME = "daemon.sock", CONFIG_FILENAME = "mcp-squared.toml", CONFIG_DIR_NAME = ".mcp-squared", APP_NAME = "mcp-squared";
+var init_paths = () => {};
+
 // src/embeddings/generator.ts
 import {
   env,
@@ -206,6 +321,84 @@ async function runConfigTui() {
   return _run();
 }
 
+// src/init/runner.ts
+var exports_runner = {};
+__export(exports_runner, {
+  runInit: () => runInit,
+  generateConfigToml: () => generateConfigToml
+});
+import { existsSync as existsSync11 } from "fs";
+import { join as join7 } from "path";
+function generateConfigToml(profile) {
+  const securityBlock = profile === "permissive" ? `[security.tools]
+# Permissive: all tools are allowed without confirmation.
+# Change to hardened defaults with: allow = [], confirm = ["*:*"]
+allow = ["*:*"]
+block = []
+confirm = []` : `[security.tools]
+# Hardened: all tools require confirmation before execution.
+# To allow specific tools without confirmation, add patterns to 'allow':
+#   allow = ["github:*", "fs:read_file"]
+# To block tools entirely:
+#   block = ["dangerous:*"]
+# To revert to permissive mode: allow = ["*:*"], confirm = []
+allow = []
+block = []
+confirm = ["*:*"]`;
+  return `# MCP\xB2 Configuration
+# https://github.com/aditzel/mcp-squared
+schemaVersion = 1
+
+# Upstream MCP servers to aggregate.
+# Add servers here or use 'mcp-squared import' to import from other tools.
+#
+# [upstreams.example]
+# transport = "stdio"
+# [upstreams.example.stdio]
+# command = "npx"
+# args = ["-y", "@modelcontextprotocol/server-example"]
+
+${securityBlock}
+
+[operations.findTools]
+defaultLimit = 5
+maxLimit = 50
+defaultMode = "fast"
+defaultDetailLevel = "L1"
+
+[operations.embeddings]
+# Enable to use semantic or hybrid search modes.
+# Requires onnxruntime shared library on the system.
+enabled = false
+
+[operations.logging]
+level = "info"
+`;
+}
+async function runInit(args) {
+  const targetPath = args.project ? join7(process.cwd(), PROJECT_CONFIG_FILENAME) : getDefaultConfigPath().path;
+  if (existsSync11(targetPath) && !args.force) {
+    console.error(`Config file already exists: ${targetPath}`);
+    console.error("Use --force to overwrite.");
+    process.exit(1);
+  }
+  ensureConfigDir(targetPath);
+  const content = generateConfigToml(args.security);
+  await Bun.write(targetPath, content);
+  const profileLabel = args.security === "permissive" ? "permissive (allow-all)" : "hardened (confirm-all)";
+  console.log(`Created ${targetPath}`);
+  console.log(`Security profile: ${profileLabel}`);
+  console.log("");
+  console.log("Next steps:");
+  console.log("  1. Add upstream servers to [upstreams] or run: mcp-squared import");
+  console.log("  2. Test connections: mcp-squared test");
+  console.log("  3. Install into MCP clients: mcp-squared install");
+}
+var PROJECT_CONFIG_FILENAME = "mcp-squared.toml";
+var init_runner = __esm(() => {
+  init_paths();
+});
+
 // src/index.ts
 import { spawnSync } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -214,6 +407,9 @@ import { Client as Client4 } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport as StreamableHTTPClientTransport4 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
 // src/cli/index.ts
+function isValidSecurityProfile(value) {
+  return value === "hardened" || value === "permissive";
+}
 function isValidInstallMode(value) {
   return value === "replace" || value === "add";
 }
@@ -266,6 +462,11 @@ function parseArgs(args) {
       verbose: false
     },
     authTarget: undefined,
+    init: {
+      security: "hardened",
+      project: false,
+      force: false
+    },
     install: {
       interactive: true,
       dryRun: false,
@@ -319,6 +520,9 @@ function parseArgs(args) {
       case "install":
         result.mode = "install";
         break;
+      case "init":
+        result.mode = "init";
+        break;
       case "monitor":
         result.mode = "monitor";
         break;
@@ -442,9 +646,30 @@ function parseArgs(args) {
         }
         break;
       }
+      case "--daemon-secret": {
+        const value = argValue ?? args[++i];
+        if (value) {
+          result.daemon.sharedSecret = value;
+          result.proxy.sharedSecret = value;
+        }
+        break;
+      }
       case "--no-daemon-spawn":
         result.proxy.noSpawn = true;
         break;
+      case "--security": {
+        const value = argValue ?? args[++i];
+        if (value && isValidSecurityProfile(value)) {
+          result.init.security = value;
+        }
+        break;
+      }
+      case "--project":
+        result.init.project = true;
+        break;
+      case "--force":
+        result.init.force = true;
+        break;
       case "--no-auto-refresh":
         result.monitor.noAutoRefresh = true;
         break;
@@ -471,6 +696,7 @@ Usage:
   mcp-squared test [upstream]   Test connection to upstream server(s)
   mcp-squared auth <upstream>   Authenticate with an OAuth-protected upstream
   mcp-squared import [options]  Import MCP configs from other tools
+  mcp-squared init [options]    Generate a starter config file with security profile
   mcp-squared install [options] Install MCP\xB2 into other MCP clients
   mcp-squared monitor [options] Launch server monitor TUI
   mcp-squared daemon [options]  Start shared MCP\xB2 daemon
@@ -483,6 +709,7 @@ Commands:
   test [name], --test, -t       Test upstream connection (all if no name given)
   auth <name>                   Authenticate with an OAuth-protected upstream
   import                        Import MCP server configs from other tools
+  init                          Generate a starter config with security profile
   install                       Install MCP\xB2 as a server in other MCP clients
   monitor                       Launch server monitor TUI
   daemon                        Start shared daemon for multiple clients
@@ -504,6 +731,11 @@ Import Options:
   --no-interactive              Disable interactive prompts (use --strategy)
   --verbose                     Show detailed output
 
+Init Options:
+  --security=<profile>          Security profile: hardened (default) or permissive
+  --project                     Write to project-local mcp-squared.toml (default: user-level)
+  --force                       Overwrite existing config without prompting
+
 Install Options:
   --tool=<tool>                 Target tool (skip selection prompt)
   --scope=<scope>               Scope: user or project
@@ -523,10 +755,12 @@ Monitor Options:
 
 Daemon Options:
   --daemon-socket=<path>        Override daemon socket path
+  --daemon-secret=<secret>      Require shared secret for daemon IPC clients
 
 Proxy Options:
   --daemon-socket=<path>        Connect to a specific daemon socket
   --no-daemon-spawn             Do not auto-spawn daemon if missing
+  --daemon-secret=<secret>      Provide shared secret for daemon handshake
 
 Supported Tools:
   ${VALID_TOOL_IDS.join(", ")}
@@ -535,6 +769,9 @@ Examples:
   mcp-squared test github       Test connection to 'github' upstream
   mcp-squared test              Test all configured upstreams
   mcp-squared auth vercel-mcp   Authenticate with 'vercel-mcp' upstream (OAuth)
+  mcp-squared init              Generate hardened config (confirm-all by default)
+  mcp-squared init --security=permissive  Generate permissive config (allow-all)
+  mcp-squared init --project    Generate project-local config
   mcp-squared import --list     List all discovered MCP configs
   mcp-squared import --dry-run  Preview import changes
   mcp-squared import            Import with interactive conflict resolution
@@ -553,6 +790,7 @@ Examples:
 }
 
 // src/config/instance-registry.ts
+init_paths();
 import {
   existsSync as existsSync2,
   mkdirSync as mkdirSync2,
@@ -565,121 +803,6 @@ import {
 import { connect } from "net";
 import { join as join2 } from "path";
 
-// src/config/paths.ts
-import { existsSync, mkdirSync } from "fs";
-import { homedir, platform } from "os";
-import { dirname, join, resolve } from "path";
-var SOCKET_FILENAME = "mcp-squared.sock";
-var INSTANCE_DIR_NAME = "instances";
-var SOCKET_DIR_NAME = "sockets";
-var DAEMON_DIR_NAME = "daemon";
-var DAEMON_REGISTRY_FILENAME = "daemon.json";
-var DAEMON_SOCKET_FILENAME = "daemon.sock";
-var CONFIG_FILENAME = "mcp-squared.toml";
-var CONFIG_DIR_NAME = ".mcp-squared";
-var APP_NAME = "mcp-squared";
-function getEnv(key) {
-  return Bun.env[key];
-}
-function getXdgConfigHome() {
-  return getEnv("XDG_CONFIG_HOME") || join(homedir(), ".config");
-}
-function getUserConfigDir() {
-  const os = platform();
-  if (os === "win32") {
-    return join(getEnv("APPDATA") || join(homedir(), "AppData", "Roaming"), APP_NAME);
-  }
-  return join(getXdgConfigHome(), APP_NAME);
-}
-function ensureDir(dir) {
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-function getUserConfigPath() {
-  return join(getUserConfigDir(), "config.toml");
-}
-function getSocketFilePath(instanceId) {
-  if (!instanceId) {
-    return join(getUserConfigDir(), SOCKET_FILENAME);
-  }
-  return join(getSocketDir(), `mcp-squared.${instanceId}.sock`);
-}
-function getDaemonDir(configHash) {
-  if (configHash) {
-    return join(getUserConfigDir(), DAEMON_DIR_NAME, configHash);
-  }
-  return join(getUserConfigDir(), DAEMON_DIR_NAME);
-}
-function getDaemonRegistryPath(configHash) {
-  return join(getDaemonDir(configHash), DAEMON_REGISTRY_FILENAME);
-}
-function getDaemonSocketPath(configHash) {
-  return join(getDaemonDir(configHash), DAEMON_SOCKET_FILENAME);
-}
-function getInstanceRegistryDir() {
-  return join(getUserConfigDir(), INSTANCE_DIR_NAME);
-}
-function getSocketDir() {
-  return join(getUserConfigDir(), SOCKET_DIR_NAME);
-}
-function ensureInstanceRegistryDir() {
-  ensureDir(getInstanceRegistryDir());
-}
-function ensureSocketDir() {
-  ensureDir(getSocketDir());
-}
-function ensureDaemonDir(configHash) {
-  ensureDir(getDaemonDir(configHash));
-}
-function findProjectConfig(startDir) {
-  let currentDir = resolve(startDir);
-  const root = dirname(currentDir);
-  while (currentDir !== root) {
-    const directPath = join(currentDir, CONFIG_FILENAME);
-    if (existsSync(directPath)) {
-      return directPath;
-    }
-    const hiddenDirPath = join(currentDir, CONFIG_DIR_NAME, "config.toml");
-    if (existsSync(hiddenDirPath)) {
-      return hiddenDirPath;
-    }
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir)
-      break;
-    currentDir = parentDir;
-  }
-  return null;
-}
-function discoverConfigPath(cwd = process.cwd()) {
-  const envPath = getEnv("MCP_SQUARED_CONFIG");
-  if (envPath) {
-    const resolvedEnvPath = resolve(envPath);
-    if (existsSync(resolvedEnvPath)) {
-      return { path: resolvedEnvPath, source: "env" };
-    }
-  }
-  const projectPath = findProjectConfig(cwd);
-  if (projectPath) {
-    return { path: projectPath, source: "project" };
-  }
-  const userPath = getUserConfigPath();
-  if (existsSync(userPath)) {
-    return { path: userPath, source: "user" };
-  }
-  return null;
-}
-function getDefaultConfigPath() {
-  return {
-    path: getUserConfigPath(),
-    source: "user"
-  };
-}
-function ensureConfigDir(configPath) {
-  const dir = dirname(configPath);
-  ensureDir(dir);
-}
-
 // src/config/pid.ts
 function isProcessRunning(pid) {
   if (pid <= 0) {
@@ -950,18 +1073,18 @@ var UpstreamServerSchema = z.discriminatedUnion("transport", [
   UpstreamSseSchema
 ]);
 var SecurityToolsSchema = z.object({
-  allow: z.array(z.string()).default(["*:*"]),
+  allow: z.array(z.string()).default([]),
   block: z.array(z.string()).default([]),
-  confirm: z.array(z.string()).default([])
+  confirm: z.array(z.string()).default(["*:*"])
 });
 var SecuritySchema = z.object({
   tools: SecurityToolsSchema.default({
-    allow: ["*:*"],
+    allow: [],
     block: [],
-    confirm: []
+    confirm: ["*:*"]
   })
 }).default({
-  tools: { allow: ["*:*"], block: [], confirm: [] }
+  tools: { allow: [], block: [], confirm: ["*:*"] }
 });
 var SearchModeSchema = z.enum(["fast", "semantic", "hybrid"]);
 var DetailLevelSchema = z.enum(["L0", "L1", "L2"]);
@@ -977,6 +1100,9 @@ var IndexSchema = z.object({
 var LoggingSchema = z.object({
   level: LogLevelSchema.default("info")
 });
+var EmbeddingsSchema = z.object({
+  enabled: z.boolean().default(false)
+});
 var SelectionCacheSchema = z.object({
   enabled: z.boolean().default(true),
   minCooccurrenceThreshold: z.number().int().min(1).default(2),
@@ -991,6 +1117,7 @@ var OperationsSchema = z.object({
   }),
   index: IndexSchema.default({ refreshIntervalMs: 30000 }),
   logging: LoggingSchema.default({ level: "info" }),
+  embeddings: EmbeddingsSchema.default({ enabled: false }),
   selectionCache: SelectionCacheSchema.default({
     enabled: true,
     minCooccurrenceThreshold: 2,
@@ -1005,6 +1132,7 @@ var OperationsSchema = z.object({
   },
   index: { refreshIntervalMs: 30000 },
   logging: { level: "info" },
+  embeddings: { enabled: false },
   selectionCache: {
     enabled: true,
     minCooccurrenceThreshold: 2,
@@ -1061,6 +1189,7 @@ function migrateV0ToV1(config) {
 }
 
 // src/config/load.ts
+init_paths();
 class ConfigError extends Error {
   cause;
   constructor(message, cause) {
@@ -1140,8 +1269,14 @@ async function loadConfigFromPath(filePath, source) {
   }
   return { config, path: filePath, source };
 }
+
+// src/config/index.ts
+init_paths();
+
 // src/config/save.ts
+init_paths();
 import { stringify as stringifyToml } from "smol-toml";
+
 class ConfigSaveError extends Error {
   filePath;
   constructor(filePath, cause) {
@@ -1285,6 +1420,9 @@ function formatValidationIssues(issues) {
   return lines.join(`
 `);
 }
+// src/index.ts
+init_paths();
+
 // src/daemon/config-hash.ts
 import { createHash } from "crypto";
 function computeConfigHash(config) {
@@ -1294,10 +1432,12 @@ function computeConfigHash(config) {
 }
 
 // src/daemon/proxy.ts
+init_paths();
 import { spawn } from "child_process";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/daemon/registry.ts
+init_paths();
 import {
   existsSync as existsSync3,
   readFileSync as readFileSync2,
@@ -1336,6 +1476,9 @@ function readDaemonRegistry(configHash) {
     if (typeof data.daemonId !== "string" || typeof data.endpoint !== "string" || typeof data.pid !== "number" || typeof data.startedAt !== "number") {
       return null;
     }
+    if (data.sharedSecret !== undefined && typeof data.sharedSecret !== "string") {
+      return null;
+    }
     return data;
   } catch {
     return null;
@@ -1347,7 +1490,7 @@ function writeDaemonRegistry(entry) {
   const tempPath = `${path}.${process.pid}.tmp`;
   const payload = `${JSON.stringify(entry, null, 2)}
 `;
-  writeFileSync2(tempPath, payload, { encoding: "utf8" });
+  writeFileSync2(tempPath, payload, { encoding: "utf8", mode: 384 });
   renameSync2(tempPath, path);
 }
 function deleteDaemonRegistry(configHash) {
@@ -1562,24 +1705,30 @@ async function waitForDaemon(timeoutMs, configHash) {
   while (Date.now() - start < timeoutMs) {
     const entry = await loadLiveDaemonRegistry(configHash);
     if (entry) {
-      return { endpoint: entry.endpoint };
+      return entry;
     }
     await sleep(100);
   }
   return null;
 }
-function spawnDaemonProcess() {
+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"
+    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;
@@ -1590,13 +1739,15 @@ async function createProxyBridge(options) {
     const registry = await loadLiveDaemonRegistry(options.configHash);
     if (registry) {
       endpoint = registry.endpoint;
+      sharedSecret ??= registry.sharedSecret;
     } else if (!options.noSpawn) {
-      spawnDaemonProcess();
+      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);
     }
@@ -1672,7 +1823,8 @@ async function createProxyBridge(options) {
   const clientId = launcherHint ? `${launcherHint}-${process.pid}` : `proxy-${process.pid}`;
   daemonTransport.sendControl({
     type: "hello",
-    clientId
+    clientId,
+    ...sharedSecret ? { sharedSecret } : {}
   });
   heartbeatTimer = setInterval(() => {
     if (!sessionId) {
@@ -1705,26 +1857,140 @@ async function runProxy(options = {}) {
 }
 
 // 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 } from "net";
+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 isTcpEndpoint4(endpoint) {
   return endpoint.startsWith("tcp://");
 }
+function parseMappedIpv4Address(normalizedHost) {
+  if (!normalizedHost.startsWith("::ffff:")) {
+    return null;
+  }
+  const mappedIpv4 = normalizedHost.slice("::ffff:".length);
+  if (isIPv4(mappedIpv4)) {
+    return mappedIpv4;
+  }
+  const hextets = mappedIpv4.split(":");
+  if (hextets.length !== 2) {
+    return null;
+  }
+  if (!hextets.every((segment) => /^[0-9a-f]{1,4}$/.test(segment))) {
+    return null;
+  }
+  const high = Number.parseInt(hextets[0] ?? "", 16);
+  const low = Number.parseInt(hextets[1] ?? "", 16);
+  if (Number.isNaN(high) || Number.isNaN(low) || high < 0 || high > 65535 || low < 0 || low > 65535) {
+    return null;
+  }
+  return `${high >> 8 & 255}.${high & 255}.${low >> 8 & 255}.${low & 255}`;
+}
 function parseTcpEndpoint4(endpoint) {
   const url = new URL(endpoint);
   if (url.protocol !== "tcp:") {
     throw new Error(`Invalid TCP endpoint protocol: ${url.protocol}`);
   }
-  const host = url.hostname;
+  const normalizedHost = normalizeHost(url.hostname);
+  const host = parseMappedIpv4Address(normalizedHost) ?? normalizedHost;
   const port = Number.parseInt(url.port, 10);
   if (!host || Number.isNaN(port)) {
     throw new Error(`Invalid TCP endpoint: ${endpoint}`);
   }
   return { host, port };
 }
+function normalizeHost(host) {
+  const lowered = host.toLowerCase();
+  if (lowered.startsWith("[") && lowered.endsWith("]")) {
+    return lowered.slice(1, -1);
+  }
+  return lowered;
+}
+function isMappedIpv4Loopback(normalizedHost) {
+  const mappedIpv4 = parseMappedIpv4Address(normalizedHost);
+  return mappedIpv4 !== null && mappedIpv4.split(".")[0] === "127";
+}
+function isLoopbackHost(host) {
+  const normalized = normalizeHost(host);
+  if (normalized === "localhost") {
+    return true;
+  }
+  if (isIPv4(normalized)) {
+    return normalized.split(".")[0] === "127";
+  }
+  if (isMappedIpv4Loopback(normalized)) {
+    return true;
+  }
+  if (isIPv6(normalized)) {
+    return normalized === "::1";
+  }
+  return false;
+}
+function formatTcpEndpoint(host, port) {
+  const normalized = normalizeHost(host);
+  if (normalized.includes(":")) {
+    return `tcp://[${normalized}]:${port}`;
+  }
+  return `tcp://${normalized}:${port}`;
+}
+function assertLoopbackTcpEndpoint(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.`);
+  }
+}
 async function canConnect3(endpoint, timeoutMs = DEFAULT_CONNECT_TIMEOUT_MS3) {
   return new Promise((resolve2) => {
     let socket = null;
@@ -1758,6 +2024,7 @@ class DaemonServer {
   idleTimeoutMs;
   heartbeatTimeoutMs;
   configHash;
+  sharedSecret;
   onIdleShutdown;
   server = null;
   sessions = new Map;
@@ -1770,6 +2037,10 @@ class DaemonServer {
     this.socketPath = options.socketPath ?? getDaemonSocketPath(this.configHash);
     this.idleTimeoutMs = options.idleTimeoutMs ?? 5000;
     this.heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? 15000;
+    const sharedSecret = options.sharedSecret?.trim();
+    if (sharedSecret) {
+      this.sharedSecret = sharedSecret;
+    }
     if (options.onIdleShutdown) {
       this.onIdleShutdown = options.onIdleShutdown;
     }
@@ -1780,6 +2051,9 @@ class DaemonServer {
     }
     ensureDaemonDir(this.configHash);
     const tcp = isTcpEndpoint4(this.socketPath);
+    if (tcp) {
+      assertLoopbackTcpEndpoint(this.socketPath);
+    }
     if (!tcp) {
       mkdirSync3(dirname2(this.socketPath), { recursive: true });
     }
@@ -1804,9 +2078,7 @@ class DaemonServer {
     await new Promise((resolve2, reject) => {
       this.server?.once("error", (error) => reject(error));
       if (tcp) {
-        const url = new URL(this.socketPath);
-        const host = url.hostname;
-        const port = Number.parseInt(url.port, 10);
+        const { host, port } = parseTcpEndpoint4(this.socketPath);
         if (!host || Number.isNaN(port)) {
           reject(new Error(`Invalid TCP endpoint: ${this.socketPath}`));
           return;
@@ -1819,7 +2091,7 @@ class DaemonServer {
     if (tcp) {
       const address = this.server.address();
       if (address && typeof address !== "string") {
-        this.endpoint = `tcp://${address.address}:${address.port}`;
+        this.endpoint = formatTcpEndpoint(address.address, address.port);
       } else {
         this.endpoint = this.socketPath;
       }
@@ -1832,7 +2104,8 @@ class DaemonServer {
       pid: process.pid,
       startedAt: Date.now(),
       version: VERSION,
-      ...this.configHash ? { configHash: this.configHash } : {}
+      ...this.configHash ? { configHash: this.configHash } : {},
+      ...this.sharedSecret ? { sharedSecret: this.sharedSecret } : {}
     };
     writeDaemonRegistry(registryEntry);
     if (!this.heartbeatTimer) {
@@ -1884,35 +2157,67 @@ class DaemonServer {
     transport.sessionId = sessionId;
     const session = {
       id: sessionId,
+      authenticated: false,
       connectedAt: Date.now(),
       lastSeen: Date.now(),
       server: sessionServer,
       transport
     };
     this.sessions.set(sessionId, session);
-    this.runtime.getStatsCollector().incrementActiveConnections();
-    this.assignOwnerIfNeeded();
-    this.clearIdleTimer();
+    let sessionServerConnected = false;
+    const connectSessionServer = async () => {
+      if (sessionServerConnected) {
+        return;
+      }
+      sessionServerConnected = true;
+      await sessionServer.connect(transport);
+      const original = transport.onmessage;
+      transport.onmessage = (message, extra) => {
+        session.lastSeen = Date.now();
+        original?.(message, extra);
+      };
+    };
     transport.onclose = () => {
       this.handleDisconnect(sessionId);
     };
     transport.onerror = () => {
       this.handleDisconnect(sessionId);
     };
-    transport.oncontrol = (message) => {
+    transport.oncontrol = async (message) => {
       switch (message.type) {
         case "hello":
+          if (this.sharedSecret !== undefined && message.sharedSecret !== this.sharedSecret) {
+            try {
+              await transport.sendControl({
+                type: "error",
+                message: "Daemon authentication failed: invalid shared secret."
+              });
+            } finally {
+              await this.handleDisconnect(sessionId);
+            }
+            break;
+          }
           if (message.clientId !== undefined) {
             session.clientId = message.clientId;
           }
+          if (!session.authenticated) {
+            session.authenticated = true;
+            this.runtime.getStatsCollector().incrementActiveConnections();
+            this.assignOwnerIfNeeded();
+            this.clearIdleTimer();
+          }
           session.lastSeen = Date.now();
           transport.sendControl({
             type: "helloAck",
             sessionId,
             isOwner: this.ownerSessionId === sessionId
           });
+          connectSessionServer().catch(() => this.handleDisconnect(sessionId));
           break;
         case "heartbeat":
+          if (!session.authenticated) {
+            break;
+          }
           session.lastSeen = Date.now();
           break;
         case "goodbye":
@@ -1920,13 +2225,7 @@ class DaemonServer {
           break;
       }
     };
-    sessionServer.connect(transport).then(() => {
-      const original = transport.onmessage;
-      transport.onmessage = (message, extra) => {
-        session.lastSeen = Date.now();
-        original?.(message, extra);
-      };
-    }).catch(() => this.handleDisconnect(sessionId));
+    transport.start().catch(() => this.handleDisconnect(sessionId));
   }
   async handleDisconnect(sessionId) {
     const session = this.sessions.get(sessionId);
@@ -1938,7 +2237,9 @@ class DaemonServer {
       await session.server.close();
       await session.transport.close();
     } catch {}
-    this.runtime.getStatsCollector().decrementActiveConnections();
+    if (session.authenticated) {
+      this.runtime.getStatsCollector().decrementActiveConnections();
+    }
     if (this.ownerSessionId === sessionId) {
       this.ownerSessionId = null;
       this.assignOwnerIfNeeded();
@@ -1951,7 +2252,7 @@ class DaemonServer {
     if (this.ownerSessionId) {
       return;
     }
-    const next = Array.from(this.sessions.values()).sort((a, b) => a.connectedAt - b.connectedAt)[0];
+    const next = Array.from(this.sessions.values()).filter((session) => session.authenticated).sort((a, b) => a.connectedAt - b.connectedAt)[0];
     if (next) {
       this.ownerSessionId = next.id;
       this.broadcastOwnerChange();
@@ -1962,6 +2263,9 @@ class DaemonServer {
       return;
     }
     for (const session of this.sessions.values()) {
+      if (!session.authenticated) {
+        continue;
+      }
       session.transport.sendControl({
         type: "ownerChanged",
         ownerSessionId: this.ownerSessionId
@@ -2015,7 +2319,7 @@ class DaemonServer {
     return this.ownerSessionId;
   }
   getClientInfo() {
-    return Array.from(this.sessions.values()).map((session) => {
+    return Array.from(this.sessions.values()).filter((session) => session.authenticated).map((session) => {
       const info = {
         sessionId: session.id,
         connectedAt: session.connectedAt,
@@ -2343,6 +2647,16 @@ function mapToSseServer(server) {
       headers: normalizeEnvVars(server.headers ?? {})
     }
   };
+  if (server.auth !== undefined) {
+    if (server.auth && typeof server.auth === "object") {
+      config.sse.auth = {
+        callbackPort: server.auth.callbackPort ?? 8089,
+        clientName: server.auth.clientName ?? "MCP\xB2"
+      };
+    } else {
+      config.sse.auth = server.auth;
+    }
+  }
   return {
     name: server.name,
     config
@@ -3441,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";
@@ -3761,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 {
@@ -4180,8 +4494,34 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
 // src/oauth/provider.ts
-var DEFAULT_CALLBACK_PORT = 8089;
-var DEFAULT_CLIENT_NAME = "MCP\xB2";
+var DEFAULT_OAUTH_CALLBACK_PORT = 8089;
+var DEFAULT_OAUTH_CLIENT_NAME = "MCP\xB2";
+function isValidCallbackPort(value) {
+  return Number.isInteger(value) && value >= 1 && value <= 65535;
+}
+function isValidClientName(value) {
+  return value.trim().length > 0;
+}
+function resolveOAuthProviderOptions(authConfig) {
+  if (!authConfig || typeof authConfig !== "object") {
+    return {
+      callbackPort: DEFAULT_OAUTH_CALLBACK_PORT,
+      clientName: DEFAULT_OAUTH_CLIENT_NAME
+    };
+  }
+  const callbackPort = authConfig.callbackPort ?? DEFAULT_OAUTH_CALLBACK_PORT;
+  if (!isValidCallbackPort(callbackPort)) {
+    throw new RangeError(`Invalid OAuth callbackPort: ${callbackPort}`);
+  }
+  const clientName = authConfig.clientName ?? DEFAULT_OAUTH_CLIENT_NAME;
+  if (typeof clientName !== "string" || !isValidClientName(clientName)) {
+    throw new TypeError(`Invalid OAuth clientName: ${String(clientName)}`);
+  }
+  return {
+    callbackPort,
+    clientName
+  };
+}
 
 class McpOAuthProvider {
   upstreamName;
@@ -4193,8 +4533,8 @@ class McpOAuthProvider {
   constructor(upstreamName, storage, options = {}) {
     this.upstreamName = upstreamName;
     this.storage = storage;
-    this.callbackPort = options.callbackPort ?? DEFAULT_CALLBACK_PORT;
-    this._clientName = options.clientName ?? DEFAULT_CLIENT_NAME;
+    this.callbackPort = options.callbackPort ?? DEFAULT_OAUTH_CALLBACK_PORT;
+    this._clientName = options.clientName ?? DEFAULT_OAUTH_CLIENT_NAME;
     this._nonInteractive = options.nonInteractive ?? false;
   }
   get redirectUrl() {
@@ -4322,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";
@@ -4360,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;
@@ -4439,6 +4779,12 @@ class TokenStorage {
 }
 
 // src/oauth/preflight.ts
+function getPreflightClientMetadata() {
+  return {
+    name: "mcp-squared-preflight",
+    version: VERSION
+  };
+}
 async function performPreflightAuth(config) {
   const result = {
     authenticated: [],
@@ -4461,23 +4807,21 @@ async function performPreflightAuth(config) {
     return result;
   }
   for (const { name, config: sseConfig } of sseUpstreams) {
-    const authConfig = typeof sseConfig.sse.auth === "object" ? sseConfig.sse.auth : undefined;
-    const callbackPort = authConfig?.callbackPort ?? 8089;
-    const clientName = authConfig?.clientName ?? "MCP\xB2";
-    const authProvider = new McpOAuthProvider(name, tokenStorage, {
-      callbackPort,
-      clientName
-    });
-    const existingTokens = authProvider.tokens();
-    if (existingTokens && !authProvider.isTokenExpired()) {
-      result.alreadyValid.push(name);
-      continue;
-    }
-    console.error(`
-[preflight] OAuth required for '${name}'`);
-    console.error(`[preflight] Server URL: ${sseConfig.sse.url}`);
     try {
-      await performInteractiveAuth(name, sseConfig, authProvider);
+      const { callbackPort, clientName } = resolveOAuthProviderOptions(sseConfig.sse.auth);
+      const authProvider = new McpOAuthProvider(name, tokenStorage, {
+        callbackPort,
+        clientName
+      });
+      const existingTokens = authProvider.tokens();
+      if (existingTokens && !authProvider.isTokenExpired()) {
+        result.alreadyValid.push(name);
+        continue;
+      }
+      console.error(`
+[preflight] OAuth required for '${name}'`);
+      console.error(`[preflight] Server URL: ${sseConfig.sse.url}`);
+      await performInteractiveAuth(name, sseConfig, authProvider, callbackPort);
       result.authenticated.push(name);
       console.error(`[preflight] \u2713 Authentication successful for '${name}'`);
     } catch (err) {
@@ -4488,9 +4832,7 @@ async function performPreflightAuth(config) {
   }
   return result;
 }
-async function performInteractiveAuth(name, sseConfig, authProvider) {
-  const authConfig = typeof sseConfig.sse.auth === "object" ? sseConfig.sse.auth : undefined;
-  const callbackPort = authConfig?.callbackPort ?? 8089;
+async function performInteractiveAuth(name, sseConfig, authProvider, callbackPort) {
   const callbackServer = new OAuthCallbackServer({
     port: callbackPort,
     path: "/callback",
@@ -4503,10 +4845,7 @@ async function performInteractiveAuth(name, sseConfig, authProvider) {
       headers: { ...sseConfig.sse.headers }
     }
   });
-  const client = new Client({
-    name: "mcp-squared-preflight",
-    version: "0.1.0"
-  });
+  const client = new Client(getPreflightClientMetadata());
   try {
     console.error(`[preflight:${name}] Connecting to server (will trigger OAuth)...`);
     await client.connect(transport);
@@ -4905,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";
 
@@ -4968,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;
@@ -5005,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) {
@@ -5022,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");
@@ -5859,7 +6198,8 @@ class Retriever {
       return {
         tools,
         query,
-        totalMatches: allTools.length
+        totalMatches: allTools.length,
+        searchMode: mode
       };
     }
     switch (mode) {
@@ -5881,12 +6221,15 @@ class Retriever {
         serverKey: r.serverKey
       })),
       query,
-      totalMatches
+      totalMatches,
+      searchMode: "fast"
     };
   }
   async searchSemantic(query, limit) {
     if (!this.embeddingGenerator || this.indexStore.getEmbeddingCount() === 0) {
-      return this.searchFast(query, limit);
+      console.error("[mcp\xB2] Semantic search requested but embeddings not available \u2014 falling back to fast (FTS5) mode.");
+      const result2 = this.searchFast(query, limit);
+      return { ...result2, searchMode: "fast" };
     }
     const result = await this.embeddingGenerator.embed(query, true);
     const queryEmbedding = result.embedding;
@@ -5898,17 +6241,20 @@ class Retriever {
         serverKey: r.serverKey
       })),
       query,
-      totalMatches: results.length
+      totalMatches: results.length,
+      searchMode: "semantic"
     };
   }
   async searchHybrid(query, limit) {
     if (!this.embeddingGenerator || this.indexStore.getEmbeddingCount() === 0) {
-      return this.searchFast(query, limit);
+      console.error("[mcp\xB2] Hybrid search requested but embeddings not available \u2014 falling back to fast (FTS5) mode.");
+      const result2 = this.searchFast(query, limit);
+      return { ...result2, searchMode: "fast" };
     }
     const candidateLimit = Math.min(limit * 3, 100);
     const ftsResults = this.indexStore.search(query, candidateLimit);
     if (ftsResults.length === 0) {
-      return { tools: [], query, totalMatches: 0 };
+      return { tools: [], query, totalMatches: 0, searchMode: "hybrid" };
     }
     const result = await this.embeddingGenerator.embed(query, true);
     const queryEmbedding = result.embedding;
@@ -5943,7 +6289,8 @@ class Retriever {
         serverKey: r.serverKey
       })),
       query,
-      totalMatches: ftsResults.length
+      totalMatches: ftsResults.length,
+      searchMode: "hybrid"
     };
   }
   getTool(name, serverKey) {
@@ -6125,6 +6472,12 @@ function evaluatePolicy(context, config) {
       reason: `Tool "${toolName}" on server "${serverKey}" is blocked by security policy`
     };
   }
+  if (matchesAnyPattern(allow, serverKey, toolName)) {
+    return {
+      decision: "allow",
+      reason: `Tool "${toolName}" is allowed by security policy`
+    };
+  }
   if (matchesAnyPattern(confirm, serverKey, toolName)) {
     if (confirmationToken && validateConfirmationToken(confirmationToken, serverKey, toolName)) {
       return {
@@ -6139,15 +6492,9 @@ function evaluatePolicy(context, config) {
       confirmationToken: token
     };
   }
-  if (matchesAnyPattern(allow, serverKey, toolName)) {
-    return {
-      decision: "allow",
-      reason: `Tool "${toolName}" is allowed by security policy`
-    };
-  }
   return {
     decision: "block",
-    reason: `Tool "${toolName}" on server "${serverKey}" is not in the allow list`
+    reason: `Tool "${toolName}" on server "${serverKey}" is not in the allow or confirm list`
   };
 }
 function compilePolicy(config) {
@@ -6164,12 +6511,12 @@ function getToolVisibilityFromPatterns(serverKey, toolName, block, confirm, allo
   if (matchesAnyPattern(block, serverKey, toolName)) {
     return { visible: false, requiresConfirmation: false };
   }
-  if (matchesAnyPattern(confirm, serverKey, toolName)) {
-    return { visible: true, requiresConfirmation: true };
-  }
   if (matchesAnyPattern(allow, serverKey, toolName)) {
     return { visible: true, requiresConfirmation: false };
   }
+  if (matchesAnyPattern(confirm, serverKey, toolName)) {
+    return { visible: true, requiresConfirmation: true };
+  }
   return { visible: false, requiresConfirmation: false };
 }
 // src/security/sanitize.ts
@@ -6355,7 +6702,8 @@ class Cataloger {
       client: null,
       transport: null,
       authProvider: null,
-      authPending: false
+      authPending: false,
+      authStateVersion: this.getAuthStateVersion(key)
     };
     this.connections.set(key, connection);
     try {
@@ -6557,7 +6905,11 @@ class Cataloger {
   }
   async refreshTools(key) {
     const connection = this.connections.get(key);
-    if (!connection?.client || connection.status !== "connected") {
+    if (!connection) {
+      return;
+    }
+    if (!connection.client || connection.status !== "connected") {
+      await this.reconnectIfAuthStateUpdated(connection);
       return;
     }
     try {
@@ -6568,7 +6920,17 @@ class Cataloger {
         inputSchema: tool.inputSchema,
         serverKey: key
       }));
+      connection.error = undefined;
+      connection.authPending = false;
     } catch (err) {
+      if (err instanceof UnauthorizedError2 && connection.authProvider) {
+        if (connection.authProvider.isNonInteractive()) {
+          connection.authPending = true;
+          connection.status = "error";
+          connection.error = `OAuth authorization required. Run: mcp-squared auth ${key}`;
+          return;
+        }
+      }
       connection.status = "error";
       connection.error = err instanceof Error ? err.message : String(err);
     }
@@ -6580,6 +6942,21 @@ class Cataloger {
     }
     await Promise.allSettled(refreshPromises);
   }
+  async reconnectIfAuthStateUpdated(connection) {
+    if (!connection.authPending || !connection.authProvider) {
+      return;
+    }
+    const authStateVersion = this.getAuthStateVersion(connection.key);
+    if (authStateVersion <= connection.authStateVersion) {
+      return;
+    }
+    connection.authStateVersion = authStateVersion;
+    await this.connect(connection.key, connection.config);
+  }
+  getAuthStateVersion(key) {
+    const tokenStorage = new TokenStorage;
+    return tokenStorage.load(key)?.updatedAt ?? 0;
+  }
   createStdioTransport(config) {
     const resolvedEnv = resolveEnvVars(config.env);
     const envWithDefaults = { ...process.env, ...resolvedEnv };
@@ -6700,10 +7077,15 @@ function createHttpTransport(config, log, verbose, authProvider) {
   const transport = new StreamableHTTPClientTransport3(new URL(config.sse.url), transportOptions);
   return transport;
 }
-async function handleOAuthCallback(transport, provider, log) {
-  const callbackServer = new OAuthCallbackServer({
-    port: 8089,
-    path: "/callback",
+async function handleOAuthCallback(transport, provider, log, callbackServerFactory = (options) => new OAuthCallbackServer(options)) {
+  const callbackUrl = new URL(provider.redirectUrl);
+  const callbackPort = Number.parseInt(callbackUrl.port, 10);
+  if (Number.isNaN(callbackPort) || callbackPort <= 0) {
+    throw new Error(`Invalid OAuth callback URL: ${provider.redirectUrl}`);
+  }
+  const callbackServer = callbackServerFactory({
+    port: callbackPort,
+    path: callbackUrl.pathname || "/callback",
     timeoutMs: 300000
   });
   log("Waiting for browser authorization...");
@@ -6760,10 +7142,11 @@ async function testUpstreamConnection(name, config, options = {}) {
       const tokenStorage = new TokenStorage;
       const hasStoredTokens = tokenStorage.load(name)?.tokens !== undefined;
       if (sseConfig.sse.auth || hasStoredTokens) {
-        const authOptions = typeof sseConfig.sse.auth === "object" ? sseConfig.sse.auth : {};
+        const authOptions = resolveOAuthProviderOptions(sseConfig.sse.auth);
         authProvider = new McpOAuthProvider(name, tokenStorage, authOptions);
       }
-      httpTransport = createHttpTransport(sseConfig, log, verbose, authProvider);
+      const httpTransportFactory = options.httpTransportFactory ?? createHttpTransport;
+      httpTransport = httpTransportFactory(sseConfig, log, verbose, authProvider);
       transport = httpTransport;
     } else {
       const unknownConfig = config;
@@ -6790,7 +7173,7 @@ async function testUpstreamConnection(name, config, options = {}) {
       if (err instanceof UnauthorizedError3 && authProvider && httpTransport) {
         if (authProvider.isInteractive()) {
           log("OAuth authorization required, opening browser...");
-          await handleOAuthCallback(httpTransport, authProvider, log);
+          await handleOAuthCallback(httpTransport, authProvider, log, options.oauthCallbackServerFactory);
           log("Retrying connection after OAuth...");
           await Promise.race([client.connect(transport), timeoutPromise]);
         } else {
@@ -7372,6 +7755,12 @@ class McpSquaredServer {
     });
     this.indexRefreshManager.on("refresh:complete", () => {
       this.statsCollector.updateIndexRefreshTime(Date.now());
+      if (this.config.operations.embeddings.enabled) {
+        this.retriever.generateToolEmbeddings().catch((err) => {
+          const message = err instanceof Error ? err.message : String(err);
+          console.error(`[mcp\xB2] Background embedding generation failed \u2014 ${message}`);
+        });
+      }
     });
     this.registerMetaTools(this.mcpServer);
   }
@@ -7446,6 +7835,8 @@ class McpSquaredServer {
                 query: result.query,
                 totalMatches: filteredTools.length,
                 detailLevel,
+                searchMode: result.searchMode,
+                embeddingsAvailable: this.retriever.hasEmbeddings(),
                 tools,
                 ...suggestedTools && { suggestedTools }
               })
@@ -7550,7 +7941,7 @@ class McpSquaredServer {
         serverKey = tool.serverKey;
         const policyResult = evaluatePolicy({
           serverKey: tool.serverKey,
-          toolName: args.tool_name,
+          toolName: tool.name,
           confirmationToken: args.confirmation_token
         }, this.config);
         if (policyResult.decision === "block") {
@@ -7792,6 +8183,21 @@ class McpSquaredServer {
     });
     await Promise.all(connectionPromises);
     this.syncIndex();
+    if (this.config.operations.embeddings.enabled) {
+      try {
+        await this.retriever.initializeEmbeddings();
+        const embeddingCount = await this.retriever.generateToolEmbeddings();
+        const toolCount = this.retriever.getIndexedToolCount();
+        if (this.retriever.hasEmbeddings()) {
+          console.error(`[mcp\xB2] Embeddings: initialized (${embeddingCount}/${toolCount} tools embedded). Search modes: semantic, hybrid available.`);
+        } else {
+          console.error(`[mcp\xB2] Embeddings: enabled but runtime unavailable (onnxruntime not found). Falling back to fast (FTS5) search.`);
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`[mcp\xB2] Embeddings: initialization failed \u2014 ${message}. Falling back to fast (FTS5) search.`);
+      }
+    }
     this.statsCollector.updateIndexRefreshTime(Date.now());
     this.indexRefreshManager.start();
     await this.monitorServer.start();
@@ -7820,9 +8226,24 @@ class McpSquaredServer {
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+function logSecurityProfile(config) {
+  const { allow, confirm } = config.security.tools;
+  const isHardened = confirm.includes("*:*") && allow.length === 0;
+  if (isHardened) {
+    console.error("[mcp\xB2] Security: confirm-all mode (default). Tools require confirmation before execution. To use permissive mode: mcp-squared init --security=permissive");
+  }
+}
+function logSearchModeProfile(config) {
+  const { defaultMode } = config.operations.findTools;
+  const { enabled: embeddingsEnabled } = config.operations.embeddings;
+  if ((defaultMode === "semantic" || defaultMode === "hybrid") && !embeddingsEnabled) {
+    console.error(`[mcp\xB2] Search: defaultMode is "${defaultMode}" but embeddings are disabled. Searches will fall back to fast (FTS5). Enable with: [operations.embeddings] enabled = true`);
+  }
+}
 async function startServer() {
   const { config, path: configPath } = await loadConfig();
+  logSecurityProfile(config);
+  logSearchModeProfile(config);
   await listActiveInstanceEntries({ prune: true });
   const preflightResult = await performPreflightAuth(config);
   if (preflightResult.authenticated.length > 0) {
@@ -8043,9 +8464,15 @@ async function runAuth(targetName) {
 Authenticating with '${targetName}'...`);
   console.log(`Server URL: ${sseConfig.sse.url}`);
   const tokenStorage = new TokenStorage;
-  const authConfig = typeof sseConfig.sse.auth === "object" ? sseConfig.sse.auth : undefined;
-  const callbackPort = authConfig?.callbackPort ?? 8089;
-  const clientName = authConfig?.clientName ?? "MCP\xB2";
+  let callbackPort;
+  let clientName;
+  try {
+    ({ callbackPort, clientName } = resolveOAuthProviderOptions(sseConfig.sse.auth));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: Invalid OAuth configuration for '${targetName}': ${message}`);
+    process.exit(1);
+  }
   const authProvider = new McpOAuthProvider(targetName, tokenStorage, {
     callbackPort,
     clientName
@@ -8303,8 +8730,21 @@ function augmentProcessInfo(entries) {
 function resolveLauncherHint() {
   return process.env["MCP_SQUARED_LAUNCHER"] ?? process.env["MCP_CLIENT_NAME"] ?? process.env["MCP_SQUARED_AGENT"] ?? undefined;
 }
+function resolveDaemonSharedSecret(cliValue) {
+  const value = cliValue ?? process.env["MCP_SQUARED_DAEMON_SECRET"];
+  if (!value) {
+    return;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return;
+  }
+  return trimmed;
+}
 async function runDaemon(options) {
   const { config, path: configPath } = await loadConfig();
+  logSecurityProfile(config);
+  logSearchModeProfile(config);
   const configHash = computeConfigHash(config);
   const monitorSocketPath = getSocketFilePath(configHash);
   const runtime = new McpSquaredServer({
@@ -8321,6 +8761,10 @@ async function runDaemon(options) {
   if (options.socketPath) {
     daemonOptions.socketPath = options.socketPath;
   }
+  const sharedSecret = resolveDaemonSharedSecret(options.sharedSecret);
+  if (sharedSecret) {
+    daemonOptions.sharedSecret = sharedSecret;
+  }
   const daemon = new DaemonServer(daemonOptions);
   ensureInstanceRegistryDir();
   ensureSocketDir();
@@ -8441,6 +8885,10 @@ async function runProxyCommand(options) {
   if (options.socketPath) {
     proxyOptions.endpoint = options.socketPath;
   }
+  const sharedSecret = resolveDaemonSharedSecret(options.sharedSecret);
+  if (sharedSecret) {
+    proxyOptions.sharedSecret = sharedSecret;
+  }
   try {
     proxyHandle = await runProxy(proxyOptions);
   } catch (error) {
@@ -8490,6 +8938,11 @@ async function main(argv = process.argv.slice(2)) {
     case "install":
       await runInstall(args.install);
       break;
+    case "init": {
+      const { runInit: runInit2 } = await Promise.resolve().then(() => (init_runner(), exports_runner));
+      await runInit2(args.init);
+      break;
+    }
     case "monitor":
       await runMonitor(args.monitor);
       break;
@@ -8519,5 +8972,7 @@ if (import.meta.main) {
 }
 export {
   main,
+  logSecurityProfile,
+  logSearchModeProfile,
   VERSION
 };