mikromcp 1.7.0 → 1.8.0

package/dist/main.js

@@ -12,15 +12,80 @@ import { spawnSync } from "child_process";
 // src/config/app-config.ts
 import { join } from "path";
 import { homedir } from "os";
+
+// src/domain/errors/error-types.ts
+var MikroMCPError = class extends Error {
+  category;
+  code;
+  details;
+  recoverability;
+  constructor(options) {
+    super(options.message);
+    this.name = "MikroMCPError";
+    this.category = options.category;
+    this.code = options.code;
+    this.details = options.details;
+    this.recoverability = options.recoverability;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+  /** Serialize to a plain JSON-safe object. */
+  toJSON() {
+    return {
+      name: this.name,
+      category: this.category,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      recoverability: this.recoverability
+    };
+  }
+  /** Convert to the wire-format error data used in DomainResult. */
+  toMikroMCPErrorData() {
+    return {
+      category: this.category,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      recoverability: {
+        retryable: this.recoverability.retryable,
+        retryAfterMs: this.recoverability.retryAfterMs,
+        suggestedAction: this.recoverability.suggestedAction,
+        alternativeTools: this.recoverability.alternativeTools
+      }
+    };
+  }
+};
+
+// src/config/app-config.ts
 function mikromcpDir() {
   return join(homedir(), ".mikromcp");
 }
+function intEnv(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return fallback;
+  const value = Number(raw);
+  if (!Number.isInteger(value)) {
+    throw new MikroMCPError({
+      category: "CONFIGURATION" /* CONFIGURATION */,
+      code: "INVALID_ENV_INT",
+      message: `Environment variable ${name} must be an integer, got "${raw}".`,
+      details: { variable: name, value: raw },
+      recoverability: {
+        retryable: false,
+        suggestedAction: `Set ${name} to an integer, or unset it to use the default (${fallback}).`
+      }
+    });
+  }
+  return value;
+}
 function loadAppConfig() {
   const env = process.env;
   const dataDir = env.MIKROMCP_DATA_DIR ?? join(mikromcpDir(), "data");
   return {
     transport: env.MIKROMCP_TRANSPORT === "http" ? "http" : "stdio",
-    port: parseInt(env.MIKROMCP_PORT ?? "3000", 10),
+    port: intEnv("MIKROMCP_PORT", 3e3),
     bindHost: env.MIKROMCP_BIND_HOST ?? "127.0.0.1",
     logLevel: env.MIKROMCP_LOG_LEVEL ?? "info",
     configPath: env.MIKROMCP_CONFIG_PATH ?? join(mikromcpDir(), "routers.yaml"),
@@ -35,12 +100,12 @@ function loadAppConfig() {
     confirmationSecret: env.MIKROMCP_CONFIRMATION_SECRET || void 0,
     auditLogPath: env.MIKROMCP_AUDIT_LOG_PATH || void 0,
     http: {
-      maxBodyBytes: parseInt(env.MIKROMCP_HTTP_MAX_BODY_BYTES ?? String(1024 * 1024), 10),
-      rateLimitRpm: parseInt(env.MIKROMCP_HTTP_RATE_LIMIT_RPM ?? "60", 10)
+      maxBodyBytes: intEnv("MIKROMCP_HTTP_MAX_BODY_BYTES", 1024 * 1024),
+      rateLimitRpm: intEnv("MIKROMCP_HTTP_RATE_LIMIT_RPM", 60)
     },
     ssh: {
-      commandTimeoutMs: parseInt(env.MIKROMCP_SSH_COMMAND_TIMEOUT_MS ?? "30000", 10),
-      maxOutputBytes: parseInt(env.MIKROMCP_SSH_MAX_OUTPUT_BYTES ?? String(512 * 1024), 10)
+      commandTimeoutMs: intEnv("MIKROMCP_SSH_COMMAND_TIMEOUT_MS", 3e4),
+      maxOutputBytes: intEnv("MIKROMCP_SSH_MAX_OUTPUT_BYTES", 512 * 1024)
     },
     retry: {
       maxRetries: 3,
@@ -52,7 +117,7 @@ function loadAppConfig() {
       cooldownMs: 3e4
     },
     retention: {
-      snapshotMaxAgeDays: parseInt(env.MIKROMCP_SNAPSHOT_RETENTION_DAYS ?? "30", 10)
+      snapshotMaxAgeDays: intEnv("MIKROMCP_SNAPSHOT_RETENTION_DAYS", 30)
     }
   };
 }
@@ -75,53 +140,6 @@ var limit = z.number().int().min(1).max(500).default(100).describe("Max results
 
 // src/domain/errors/error-enricher.ts
 import { ZodError } from "zod";
-
-// src/domain/errors/error-types.ts
-var MikroMCPError = class extends Error {
-  category;
-  code;
-  details;
-  recoverability;
-  constructor(options) {
-    super(options.message);
-    this.name = "MikroMCPError";
-    this.category = options.category;
-    this.code = options.code;
-    this.details = options.details;
-    this.recoverability = options.recoverability;
-    if (options.cause !== void 0) {
-      this.cause = options.cause;
-    }
-  }
-  /** Serialize to a plain JSON-safe object. */
-  toJSON() {
-    return {
-      name: this.name,
-      category: this.category,
-      code: this.code,
-      message: this.message,
-      details: this.details,
-      recoverability: this.recoverability
-    };
-  }
-  /** Convert to the wire-format error data used in DomainResult. */
-  toMikroMCPErrorData() {
-    return {
-      category: this.category,
-      code: this.code,
-      message: this.message,
-      details: this.details,
-      recoverability: {
-        retryable: this.recoverability.retryable,
-        retryAfterMs: this.recoverability.retryAfterMs,
-        suggestedAction: this.recoverability.suggestedAction,
-        alternativeTools: this.recoverability.alternativeTools
-      }
-    };
-  }
-};
-
-// src/domain/errors/error-enricher.ts
 var UNREACHABLE_CODES = /* @__PURE__ */ new Set([
   "ECONNREFUSED",
   "ECONNRESET",
@@ -441,6 +459,41 @@ var systemTools = [getSystemStatusTool];
 // src/domain/tools/interface-tools.ts
 import { z as z3 } from "zod";
 
+// src/adapter/response-parser.ts
+var NUMERIC_RE = /^-?\d+(\.\d+)?$/;
+var DURATION_RE = /^\d+[wdhms](\d+[wdhms])*$/;
+function parseRouterOSValue(key2, value) {
+  if (key2 === ".id") {
+    return value;
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (DURATION_RE.test(value)) {
+    return value;
+  }
+  if (NUMERIC_RE.test(value)) {
+    const num = Number(value);
+    const isInteger = !value.includes(".");
+    if (isInteger ? Number.isSafeInteger(num) : Number.isFinite(num)) {
+      return num;
+    }
+  }
+  return value;
+}
+function isTrue(v) {
+  return v === true || v === "true" || v === "yes";
+}
+function parseRecord(raw) {
+  const parsed = {};
+  for (const [key2, value] of Object.entries(raw)) {
+    parsed[key2] = parseRouterOSValue(key2, value);
+  }
+  return parsed;
+}
+function parseRecords(raw) {
+  return raw.map((r) => parseRecord(r));
+}
+
 // src/domain/tools/pagination.ts
 function paginate(items, offset2, limit2) {
   const total = items.length;
@@ -528,7 +581,7 @@ var listInterfacesTool = {
       if (parsed.status !== "all") {
         interfaces = interfaces.filter((iface) => {
           const running = iface.running;
-          const isUp = running === true || running === "true";
+          const isUp = isTrue(running);
           if (parsed.status === "up") return isUp;
           if (parsed.status === "down") return !isUp;
           return true;
@@ -537,8 +590,8 @@ var listInterfacesTool = {
       const { items: paginated, total, hasMore } = paginate(interfaces, parsed.offset, parsed.limit);
       const results2 = paginated.map((iface) => {
         const rec = iface;
-        const isRunning2 = rec.running === true || rec.running === "true";
-        const isDisabled = rec.disabled === true || rec.disabled === "true";
+        const isRunning2 = isTrue(rec.running);
+        const isDisabled = isTrue(rec.disabled);
         const enriched = { status: isDisabled ? "disabled" : isRunning2 ? "up" : "down" };
         for (const [key2, value] of Object.entries(rec)) {
           if (parsed.includeCounters || !COUNTER_PROPS.includes(key2)) {
@@ -660,7 +713,7 @@ var manageIpAddressTool = {
       if (parsed.action === "add") {
         if (existing) {
           const rec = existing;
-          const sameDisabled = rec.disabled === "true" === parsed.disabled;
+          const sameDisabled = isTrue(rec.disabled) === parsed.disabled;
           const sameComment = (rec.comment ?? "") === (comment ?? "");
           const sameNetwork = !parsed.network || rec.network === parsed.network;
           if (sameDisabled && sameComment && sameNetwork) {
@@ -887,7 +940,7 @@ var listDhcpLeasesTool = {
       if (parsed.leaseType !== "all") {
         leases = leases.filter((lease) => {
           const rec = lease;
-          const isDynamic = rec.dynamic === true || rec.dynamic === "true";
+          const isDynamic = isTrue(rec.dynamic);
           if (parsed.leaseType === "dynamic") return isDynamic;
           return !isDynamic;
         });
@@ -966,7 +1019,7 @@ var manageDhcpLeaseTool = {
           });
         }
         const existingDynamic = existing.dynamic;
-        const isAlreadyStatic = existingDynamic === "false" || existingDynamic === false;
+        const isAlreadyStatic = !isTrue(existingDynamic);
         if (isAlreadyStatic) {
           return {
             content: `Lease for ${upperMac} (${existing.address ?? "unknown"}) is already static. No changes made.`,
@@ -1059,13 +1112,13 @@ var listRoutesTool = {
       if (parsed.activeOnly) {
         routes = routes.filter((route) => {
           const rec = route;
-          return rec.active === true || rec.active === "true";
+          return isTrue(rec.active);
         });
       }
       if (parsed.staticOnly) {
         routes = routes.filter((route) => {
           const rec = route;
-          return rec.dynamic !== true && rec.dynamic !== "true";
+          return !isTrue(rec.dynamic);
         });
       }
       const { items: paginated, total, hasMore } = paginate(routes, parsed.offset, parsed.limit);
@@ -1154,7 +1207,7 @@ var manageRouteTool = {
         if (existing) {
           const rec = existing;
           const existingDistance = rec.distance ?? "1";
-          const existingDisabled = rec.disabled === "true" || rec.disabled === true;
+          const existingDisabled = isTrue(rec.disabled);
           const sameDistance = existingDistance === String(parsed.distance);
           const sameDisabled = existingDisabled === parsed.disabled;
           if (sameDistance && sameDisabled) {
@@ -1328,7 +1381,7 @@ var listFirewallRulesTool = {
       if (parsed.disabled !== "all") {
         rules = rules.filter((r) => {
           const rec = r;
-          const isDisabled = rec.disabled === true || rec.disabled === "true";
+          const isDisabled = isTrue(rec.disabled);
           return isDisabled === (parsed.disabled === "true");
         });
       }
@@ -1572,7 +1625,7 @@ var manageFirewallRuleTool = {
           });
         }
         const id = existing[".id"];
-        const isDisabled = existing.disabled === "true";
+        const isDisabled = isTrue(existing.disabled);
         if (isDisabled === wantDisabled) {
           return {
             content: `Firewall ${parsed.table} rule with comment "${comment}" is already ${wantDisabled ? "disabled" : "enabled"}. No changes made.`,
@@ -1948,6 +2001,12 @@ var diagnosticTools = [pingTool, tracerouteTool, torchTool, getLogTool];
 // src/domain/tools/system-ops-tools.ts
 import { z as z10 } from "zod";
 
+// src/util/glob.ts
+function globMatch(pattern, value) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i").test(value);
+}
+
 // src/domain/tools/command-guard.ts
 var BUILTIN_DENY_PATTERNS = [
   "/system shutdown*",
@@ -1959,14 +2018,20 @@ var BUILTIN_DENY_PATTERNS = [
   "/ip service set*",
   "/certificate*private-key*",
   "/system package uninstall*",
-  "/system routerboard upgrade*"
+  "/system routerboard upgrade*",
+  // Block indirection primitives that would otherwise smuggle a denied command
+  // past a segment-wise check.
+  "*:execute*",
+  "*:parse*"
 ];
 var DENIED_TOOL_SUGGESTIONS = {
   "/system reboot*": "reboot"
 };
-function globMatch(pattern, value) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`, "i").test(value);
+function normalizeCommand(raw) {
+  return raw.replace(/\//g, " ").replace(/\s+/g, " ").trim();
+}
+function segments(raw) {
+  return raw.split(/[;\n]/).map((s) => normalizeCommand(s)).filter(Boolean);
 }
 function resolveCommandPolicy(routerConfig, globalAllow, globalDeny) {
   const routerDeny = routerConfig.cmdDeny ?? [];
@@ -1977,8 +2042,10 @@ function resolveCommandPolicy(routerConfig, globalAllow, globalDeny) {
   };
 }
 function checkCommand(command, policy) {
+  const normSegs = segments(command);
   for (const pattern of policy.deny) {
-    if (globMatch(pattern, command)) {
+    const normPattern = normalizeCommand(pattern);
+    if (normSegs.some((seg) => globMatch(normPattern, seg))) {
       const suggestedTool = DENIED_TOOL_SUGGESTIONS[pattern];
       throw new MikroMCPError({
         category: "VALIDATION" /* VALIDATION */,
@@ -1993,17 +2060,23 @@ function checkCommand(command, policy) {
       });
     }
   }
-  if (policy.allow.length > 0 && !policy.allow.some((p) => globMatch(p, command))) {
-    throw new MikroMCPError({
-      category: "VALIDATION" /* VALIDATION */,
-      code: "COMMAND_NOT_ALLOWED",
-      message: "Command not in allow list",
-      details: { command, allowPatterns: policy.allow },
-      recoverability: {
-        retryable: false,
-        suggestedAction: "The command does not match any pattern in the configured allow list."
-      }
-    });
+  if (policy.allow.length > 0) {
+    const normAllow = policy.allow.map((p) => normalizeCommand(p));
+    const everySegmentAllowed = normSegs.every(
+      (seg) => normAllow.some((p) => globMatch(p, seg))
+    );
+    if (!everySegmentAllowed) {
+      throw new MikroMCPError({
+        category: "VALIDATION" /* VALIDATION */,
+        code: "COMMAND_NOT_ALLOWED",
+        message: "Command not in allow list",
+        details: { command, allowPatterns: policy.allow },
+        recoverability: {
+          retryable: false,
+          suggestedAction: "The command does not match any pattern in the configured allow list."
+        }
+      });
+    }
   }
 }
 
@@ -2599,7 +2672,7 @@ var manageWifiTool = {
   inputSchema: manageWifiInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -2890,7 +2963,7 @@ var manageWgIfaceTool = {
   inputSchema: manageWgIfaceInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -3267,7 +3340,7 @@ var manageDnsSettingsTool = {
   inputSchema: manageDnsSettingsInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -3379,7 +3452,7 @@ var listMangleRulesTool = {
       if (parsed.disabled !== void 0) {
         rules = rules.filter((r) => {
           const rec = r;
-          const isDisabled = rec.disabled === true || rec.disabled === "true";
+          const isDisabled = isTrue(rec.disabled);
           return isDisabled === parsed.disabled;
         });
       }
@@ -3435,7 +3508,7 @@ var manageMangleRuleTool = {
   inputSchema: manageMangleRuleInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -3576,7 +3649,7 @@ var manageMangleRuleTool = {
           });
         }
         const id = existing[".id"];
-        const isDisabled = existing.disabled === "true";
+        const isDisabled = isTrue(existing.disabled);
         if (isDisabled === wantDisabled) {
           return {
             content: `Mangle rule with comment "${parsed.comment}" is already ${wantDisabled ? "disabled" : "enabled"}. No changes made.`,
@@ -3681,7 +3754,7 @@ var manageAddressListTool = {
   inputSchema: manageAddressListInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -3806,7 +3879,7 @@ var listRoutingRulesTool = {
       if (parsed.disabled !== void 0) {
         rules = rules.filter((r) => {
           const rec = r;
-          const isDisabled = rec.disabled === true || rec.disabled === "true";
+          const isDisabled = isTrue(rec.disabled);
           return isDisabled === parsed.disabled;
         });
       }
@@ -3851,7 +3924,7 @@ var manageRoutingRuleTool = {
   inputSchema: manageRoutingRuleInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -3957,7 +4030,7 @@ var manageRoutingRuleTool = {
           });
         }
         const id = existing[".id"];
-        const isDisabled = existing.disabled === "true";
+        const isDisabled = isTrue(existing.disabled);
         if (isDisabled === wantDisabled) {
           return {
             content: `Routing rule is already ${wantDisabled ? "disabled" : "enabled"}. No changes made.`,
@@ -4048,7 +4121,7 @@ var manageRoutingTableTool = {
   inputSchema: manageRoutingTableInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -4286,7 +4359,7 @@ var manageScriptTool = {
   inputSchema: manageScriptInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -4431,7 +4504,7 @@ var runScriptTool = {
   inputSchema: runScriptInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: false,
     openWorldHint: false
   },
@@ -4678,7 +4751,7 @@ var manageScheduledJobTool = {
           });
         }
         const id = existing[".id"];
-        const isDisabled = existing.disabled === "true";
+        const isDisabled = isTrue(existing.disabled);
         if (isDisabled === wantDisabled) {
           return {
             content: `Scheduled job "${parsed.name}" is already ${wantDisabled ? "disabled" : "enabled"}. No changes made.`,
@@ -4782,7 +4855,7 @@ var managePackageTool = {
   inputSchema: managePackageInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -4813,7 +4886,7 @@ var managePackageTool = {
         });
       }
       const wantDisabled = parsed.action === "disable";
-      const isDisabled = pkg.disabled === "true";
+      const isDisabled = isTrue(pkg.disabled);
       const id = pkg[".id"];
       if (isDisabled === wantDisabled) {
         return {
@@ -4849,6 +4922,7 @@ var packagesTools = [listPackagesTool, managePackageTool];
 import { z as z22 } from "zod";
 var log20 = createLogger("files-tools");
 var FILE_PATH = "file";
+var CONTENT_CAP = 65536;
 var listFilesInputSchema = z22.object({
   routerId,
   name: z22.string().optional().describe("Filter by file name (substring match)"),
@@ -4937,11 +5011,20 @@ var getFileContentTool = {
       }
       const id = file[".id"];
       const full = await context.routerClient.getOne(FILE_PATH, id);
-      const contents = full.contents ?? "";
+      const rawContents = full.contents ?? "";
+      const truncated = rawContents.length > CONTENT_CAP;
+      const contents = truncated ? `${rawContents.slice(0, CONTENT_CAP)}
+[TRUNCATED at ${CONTENT_CAP} chars \u2014 file is ${rawContents.length} chars]` : rawContents;
       return {
         content: `Contents of "${parsed.name}" on ${context.routerId}:
 ${contents}`,
-        structuredContent: { routerId: context.routerId, name: parsed.name, contents }
+        structuredContent: {
+          routerId: context.routerId,
+          name: parsed.name,
+          contents,
+          truncated,
+          totalLength: rawContents.length
+        }
       };
     } catch (err) {
       throw toolError(err, context, "get_file_content");
@@ -4957,7 +5040,7 @@ var uploadFileInputSchema = z22.object({
 var uploadFileTool = {
   name: "upload_file",
   title: "Upload File",
-  description: "Upload a text file to a router via FTP using the router's credentials, overwriting any existing file of the same name. Requires FTP permission on the router user (see config/routers.example.yaml). Dry-run tests FTP connectivity only.",
+  description: "Upload a text file to a router, overwriting any existing file of the same name. Prefers SFTP (encrypted, over SSH) and falls back to plaintext FTP if SFTP is unavailable. Requires SSH (or FTP) access for the router user. Dry-run tests connectivity only.",
   inputSchema: uploadFileInputSchema,
   annotations: {
     readOnlyHint: false,
@@ -4969,30 +5052,50 @@ var uploadFileTool = {
   async handler(params, context) {
     const parsed = uploadFileInputSchema.parse(params);
     log20.info({ routerId: context.routerId, name: parsed.name }, "Uploading file");
+    const ftpPlaintextNote = " (via FTP, plaintext \u2014 enable SSH on the router for encrypted transfer)";
     try {
       if (parsed.dryRun) {
-        await context.ftpClient.connect();
+        try {
+          await context.sftpClient.upload(`${parsed.name}.mikromcp-probe`, "");
+          return {
+            content: `Dry run: SFTP connectivity to ${context.routerId} verified. Would upload "${parsed.name}".`,
+            structuredContent: { action: "dry_run", transport: "sftp", name: parsed.name, routerId: context.routerId }
+          };
+        } catch (sftpErr) {
+          log20.warn({ err: sftpErr, routerId: context.routerId }, "SFTP dry-run probe failed \u2014 falling back to FTP");
+          await context.ftpClient.connect();
+          return {
+            content: `Dry run: FTP connectivity to ${context.routerId} verified${ftpPlaintextNote}. Would upload "${parsed.name}".`,
+            structuredContent: { action: "dry_run", transport: "ftp", name: parsed.name, routerId: context.routerId }
+          };
+        }
+      }
+      try {
+        await context.sftpClient.upload(parsed.name, parsed.content);
+        log20.info({ name: parsed.name }, "File uploaded via SFTP");
         return {
-          content: `Dry run: FTP connectivity to ${context.routerId} verified. Would upload "${parsed.name}".`,
-          structuredContent: { action: "dry_run", name: parsed.name, routerId: context.routerId }
+          content: `Uploaded "${parsed.name}" to ${context.routerId} via SFTP.`,
+          structuredContent: { action: "uploaded", transport: "sftp", name: parsed.name, routerId: context.routerId }
+        };
+      } catch (sftpErr) {
+        log20.warn({ err: sftpErr, routerId: context.routerId }, "SFTP upload failed \u2014 falling back to FTP");
+        await context.ftpClient.upload(parsed.name, parsed.content);
+        log20.info({ name: parsed.name }, "File uploaded via FTP");
+        return {
+          content: `Uploaded "${parsed.name}" to ${context.routerId}${ftpPlaintextNote}.`,
+          structuredContent: { action: "uploaded", transport: "ftp", name: parsed.name, routerId: context.routerId }
         };
       }
-      await context.ftpClient.upload(parsed.name, parsed.content);
-      log20.info({ name: parsed.name }, "File uploaded via FTP");
-      return {
-        content: `Uploaded "${parsed.name}" to ${context.routerId}.`,
-        structuredContent: { action: "uploaded", name: parsed.name, routerId: context.routerId }
-      };
     } catch (err) {
       if (err instanceof Error && err.code === "ECONNREFUSED") {
         throw new MikroMCPError({
           category: "CONFIGURATION" /* CONFIGURATION */,
-          code: "FTP_SERVICE_UNAVAILABLE",
-          message: `FTP service is not running on ${context.routerConfig.host}:21. Enable it on the router and ensure the user has the 'ftp' policy.`,
-          details: { host: context.routerConfig.host, port: 21, routerId: context.routerId },
+          code: "FILE_TRANSFER_UNAVAILABLE",
+          message: `Neither SFTP (SSH) nor FTP is reachable on ${context.routerConfig.host}. Enable SSH (recommended) or FTP on the router.`,
+          details: { host: context.routerConfig.host, routerId: context.routerId },
           recoverability: {
             retryable: false,
-            suggestedAction: "Run on the router: /ip service enable ftp  \u2014 then add 'ftp' to the user group policy: /user group set <group> policy=...,ftp,..."
+            suggestedAction: "Enable SSH: /ip service enable ssh and ensure the user has the 'ssh'/'ftp' policy. FTP fallback needs: /ip service enable ftp plus the 'ftp' policy."
           }
         });
       }
@@ -5127,7 +5230,7 @@ var manageContainerTool = {
   inputSchema: manageContainerInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -5301,28 +5404,49 @@ import { readFileSync } from "fs";
 import { mkdir, writeFile, readFile } from "fs/promises";
 import { join as join2 } from "path";
 import { nanoid } from "nanoid";
-function pathToSlug(rosPath) {
-  return rosPath.replace(/\//g, "-");
-}
-function timestampPrefix() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 15);
-}
-async function takeSnapshot(client, routerId2, path, snapshotDir) {
-  const records = await client.get(path, {});
-  const id = `${timestampPrefix()}-${pathToSlug(path)}-${nanoid(6)}`;
-  const dir = join2(snapshotDir, routerId2);
-  const filePath = join2(dir, `${id}.json`);
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  await mkdir(dir, { recursive: true });
-  const stored = { id, routerId: routerId2, path, ts, records };
-  await writeFile(filePath, JSON.stringify(stored, null, 2));
-  return { id, routerId: routerId2, path, ts, filePath, recordCount: records.length };
-}
-async function loadSnapshot(filePath) {
-  return JSON.parse(await readFile(filePath, "utf-8"));
-}
 
 // src/domain/snapshot/diff-engine.ts
+var RUNTIME_FIELDS = /* @__PURE__ */ new Set([
+  "bytes",
+  "packets",
+  "dynamic",
+  "invalid",
+  "dead",
+  "expired",
+  "active",
+  "running",
+  "about",
+  ".about",
+  ".nextid",
+  "creation-time",
+  "last-logged-in",
+  "last-link-up-time",
+  "last-link-down-time",
+  "link-downs",
+  "rx-byte",
+  "tx-byte",
+  "rx-packet",
+  "tx-packet",
+  "uptime"
+]);
+var ORDER_SENSITIVE_PATHS = /* @__PURE__ */ new Set([
+  "ip/firewall/filter",
+  "ip/firewall/nat",
+  "ip/firewall/mangle",
+  "routing/rule"
+]);
+function normalizeForDiff(records) {
+  const out = [];
+  for (const r of records) {
+    if (isTrue(r.dynamic)) continue;
+    const clean = {};
+    for (const [k, v] of Object.entries(r)) {
+      if (!RUNTIME_FIELDS.has(k)) clean[k] = v;
+    }
+    out.push(clean);
+  }
+  return out;
+}
 var SEMANTIC_KEYS = {
   "ip/route": ["dst-address", "gateway", "routing-table"],
   "ip/firewall/filter": ["comment"],
@@ -5351,9 +5475,9 @@ var SEMANTIC_KEYS = {
   "user": ["name"]
 };
 function normalizeValue(v) {
-  if (v === "true" || v === "yes") return "true";
-  if (v === "false" || v === "no") return "false";
-  return v;
+  if (v === true || v === "true" || v === "yes") return "true";
+  if (v === false || v === "false" || v === "no") return "false";
+  return String(v ?? "");
 }
 function semanticKey(record, keys) {
   return keys.map((k) => normalizeValue(record[k] ?? "")).join("|");
@@ -5367,17 +5491,45 @@ function recordsAreEqual(a, b) {
   if (keysA.length !== keysB.length) return false;
   return keysA.every((k) => normalizeValue(a[k]) === normalizeValue(b[k] ?? ""));
 }
-function computeRestorePlan(path, before, current) {
+function hasDuplicateKeys(records, keys) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of records) {
+    const k = semanticKey(r, keys);
+    if (seen.has(k)) return true;
+    seen.add(k);
+  }
+  return false;
+}
+function applyUserRestriction(path, plan) {
+  if (path === "user" && plan.toCreate.length > 0) {
+    plan.warnings.push(
+      `Refusing to recreate ${plan.toCreate.length} deleted user(s): passwords are not stored in snapshots and recreation would produce password-less logins. Recreate manually with manage_user.`
+    );
+    plan.toCreate = [];
+  }
+  return plan;
+}
+function computeRestorePlan(path, beforeRaw, currentRaw) {
+  const before = normalizeForDiff(beforeRaw);
+  const current = normalizeForDiff(currentRaw);
+  const warnings = [];
+  if (ORDER_SENSITIVE_PATHS.has(path)) {
+    warnings.push(
+      `Restored entries for ${path} are re-created at the end of the list \u2014 rule ORDER is not restored. Review ordering manually after rollback.`
+    );
+  }
   const keys = SEMANTIC_KEYS[path];
-  if (!keys) {
+  const canUseKeys = keys !== void 0 && !hasDuplicateKeys(before, keys) && !hasDuplicateKeys(current, keys);
+  if (!canUseKeys) {
     const beforeSigs = new Set(before.map(recordSignature));
     const currentSigs = new Set(current.map(recordSignature));
-    return {
+    return applyUserRestriction(path, {
       path,
       toCreate: before.filter((r) => !currentSigs.has(recordSignature(r))),
       toRemove: current.filter((r) => !beforeSigs.has(recordSignature(r))).map((r) => r[".id"]),
-      toUpdate: []
-    };
+      toUpdate: [],
+      warnings
+    });
   }
   const currentByKey = new Map(current.map((r) => [semanticKey(r, keys), r]));
   const beforeByKey = new Map(before.map((r) => [semanticKey(r, keys), r]));
@@ -5393,7 +5545,7 @@ function computeRestorePlan(path, before, current) {
     }
   }
   const toRemove = current.filter((r) => !beforeByKey.has(semanticKey(r, keys))).map((r) => r[".id"]);
-  return { path, toCreate, toRemove, toUpdate };
+  return applyUserRestriction(path, { path, toCreate, toRemove, toUpdate, warnings });
 }
 async function applyRestorePlan(plan, client) {
   for (const id of plan.toRemove) {
@@ -5408,6 +5560,28 @@ async function applyRestorePlan(plan, client) {
   }
 }
 
+// src/domain/snapshot/snapshot-engine.ts
+function pathToSlug(rosPath) {
+  return rosPath.replace(/\//g, "-");
+}
+function timestampPrefix() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 15);
+}
+async function takeSnapshot(client, routerId2, path, snapshotDir) {
+  const records = normalizeForDiff(await client.get(path, {}));
+  const id = `${timestampPrefix()}-${pathToSlug(path)}-${nanoid(6)}`;
+  const dir = join2(snapshotDir, routerId2);
+  const filePath = join2(dir, `${id}.json`);
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  await mkdir(dir, { recursive: true });
+  const stored = { id, routerId: routerId2, path, ts, records };
+  await writeFile(filePath, JSON.stringify(stored, null, 2));
+  return { id, routerId: routerId2, path, ts, filePath, recordCount: records.length };
+}
+async function loadSnapshot(filePath) {
+  return JSON.parse(await readFile(filePath, "utf-8"));
+}
+
 // src/domain/snapshot/write-journal.ts
 import { appendFile as appendFile2, mkdir as mkdir2 } from "fs/promises";
 import { dirname } from "path";
@@ -5715,18 +5889,22 @@ function createChangeManagementTools(baseTools2) {
         (sum, p) => sum + p.toCreate.length + p.toRemove.length + p.toUpdate.length,
         0
       );
+      const warnings = restorePlans.flatMap((p) => p.warnings);
+      const warningSuffix = warnings.length > 0 ? `
+Warnings:
+${warnings.map((w) => `  - ${w}`).join("\n")}` : "";
       if (parsed.dryRun) {
         return {
-          content: `Rollback dry run for journal entry "${parsed.journalId}": ${totalOps} operation(s) would be applied across ${restorePlans.length} path(s).`,
-          structuredContent: { action: "dry_run", journalId: parsed.journalId, restorePlans }
+          content: `Rollback dry run for journal entry "${parsed.journalId}": ${totalOps} operation(s) would be applied across ${restorePlans.length} path(s).${warningSuffix}`,
+          structuredContent: { action: "dry_run", journalId: parsed.journalId, restorePlans, warnings }
         };
       }
       for (const plan of restorePlans) {
         await applyRestorePlan(plan, context.routerClient);
       }
       return {
-        content: `Rolled back journal entry "${parsed.journalId}": ${totalOps} operation(s) applied across ${restorePlans.length} path(s).`,
-        structuredContent: { action: "rolled_back", journalId: parsed.journalId, restorePlans }
+        content: `Rolled back journal entry "${parsed.journalId}": ${totalOps} operation(s) applied across ${restorePlans.length} path(s).${warningSuffix}`,
+        structuredContent: { action: "rolled_back", journalId: parsed.journalId, restorePlans, warnings }
       };
     }
   };
@@ -6019,7 +6197,7 @@ var manageIpsecPolicyTool = {
   inputSchema: manageIpsecPolicyInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -6401,7 +6579,7 @@ var manageUserTool = {
   inputSchema: manageUserInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -6681,7 +6859,7 @@ var manageUserGroupTool = {
   inputSchema: manageUserGroupInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -6904,7 +7082,7 @@ var manageDhcpServerTool = {
   inputSchema: manageDhcpServerInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -7516,7 +7694,7 @@ var manageVrrpInstanceTool = {
   inputSchema: manageVrrpInstanceInputSchema,
   annotations: {
     readOnlyHint: false,
-    destructiveHint: false,
+    destructiveHint: true,
     idempotentHint: true,
     openWorldHint: false
   },
@@ -8551,7 +8729,7 @@ var listIpServicesTool = {
       }
       if (parsed.enabled !== void 0) {
         filtered = filtered.filter((s) => {
-          const isDisabled = s.disabled === true || s.disabled === "true";
+          const isDisabled = isTrue(s.disabled);
           return parsed.enabled ? !isDisabled : isDisabled;
         });
       }
@@ -8616,7 +8794,7 @@ var manageIpServiceTool = {
           }
         });
       }
-      const isCurrentlyDisabled = existing.disabled === "true" || existing.disabled === true;
+      const isCurrentlyDisabled = isTrue(existing.disabled);
       const wouldBeDisabled = parsed.action === "disable";
       if (isCurrentlyDisabled === wouldBeDisabled) {
         const alreadyState = parsed.action === "disable" ? "disabled" : "enabled";
@@ -8667,7 +8845,7 @@ var listPppoeClientsInputSchema = z37.object({
   offset
 }).strict();
 function isRunning(record) {
-  return record.running === true || record.running === "true";
+  return isTrue(record.running);
 }
 var listPppoeClientsTool = {
   name: "list_pppoe_clients",
@@ -9689,8 +9867,9 @@ var exportConfigTool = {
   title: "Export Config",
   description: "Export the router configuration as a RouterOS script. When no file is specified, returns the script text inline. When a file is specified, saves it as <file>.rsc on the router's filesystem. Supports compact mode to show only non-default values.",
   inputSchema: exportConfigInputSchema,
+  // Not read-only: with a `file` argument it writes a file on the router.
   annotations: {
-    readOnlyHint: true,
+    readOnlyHint: false,
     destructiveHint: false,
     idempotentHint: true,
     openWorldHint: false
@@ -10131,14 +10310,17 @@ var bandwidthTestInputSchema = z43.object({
   address: z43.string().describe("Remote host running RouterOS btest server"),
   protocol: z43.enum(["tcp", "udp"]).default("tcp").describe("Test protocol"),
   direction: z43.enum(["send", "receive", "both"]).default("both").describe("Test direction"),
-  duration: z43.number().int().min(1).max(30).default(5).describe("Test duration in seconds (max 30)")
+  duration: z43.number().int().min(1).max(20).default(5).describe("Test duration in seconds (max 20)")
 }).strict();
 var bandwidthTestTool = {
   name: "bandwidth_test",
   title: "Bandwidth Test",
-  description: "Run a RouterOS bandwidth test from the router to a remote host running a RouterOS btest server. Returns TX and RX throughput in Mbps. Duration capped at 30 seconds.",
+  description: "Run a RouterOS bandwidth test from the router to a remote host running a RouterOS btest server. Returns TX and RX throughput in Mbps. Duration capped at 20 seconds. Saturates the link \u2014 not auto-retried.",
   inputSchema: bandwidthTestInputSchema,
-  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+  // Reaches an external host and saturates the link; a silent retry would
+  // double the load, so opt out of auto-retry.
+  retryable: false,
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: false, openWorldHint: true },
   async handler(params, context) {
     const parsed = bandwidthTestInputSchema.parse(params);
     log43.info({ routerId: context.routerId, address: parsed.address }, "Running bandwidth test");
@@ -10180,9 +10362,11 @@ var fetchUrlInputSchema = z43.object({
 var fetchUrlTool = {
   name: "fetch_url",
   title: "Fetch URL",
-  description: "Send an HTTP/HTTPS request from the router using /tool/fetch. Response body is returned inline (capped at 64 KB with [TRUNCATED] marker). Use outputFile to save to router filesystem instead.",
+  description: "Send an HTTP/HTTPS request from the router using /tool/fetch. Response body is returned inline (capped at 64 KB with [TRUNCATED] marker). Use outputFile to save to router filesystem instead. Not read-only: POSTs have side effects and outputFile writes to the router.",
   inputSchema: fetchUrlInputSchema,
-  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+  // Not read-only: a POST has external side effects and outputFile writes a
+  // file on the router. openWorld: reaches arbitrary external hosts.
+  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
   async handler(params, context) {
     const parsed = fetchUrlInputSchema.parse(params);
     log43.info({ routerId: context.routerId, url: parsed.url, method: parsed.method }, "Fetching URL");
@@ -10235,6 +10419,14 @@ var listConnectionsTool = {
     log43.info({ routerId: context.routerId }, "Listing connections");
     try {
       const all = await context.routerClient.get("ip/firewall/connection", {
+        proplist: [
+          "protocol",
+          "src-address",
+          "dst-address",
+          "tcp-state",
+          "connection-mark",
+          "timeout"
+        ],
         limit: void 0,
         offset: void 0
       });
@@ -10695,7 +10887,7 @@ var manageInterfaceListTool = {
   title: "Manage Interface List",
   description: "Add or remove an interface list. Idempotent by name. Removing a list that has members is blocked by RouterOS \u2014 the error is surfaced as-is.",
   inputSchema: manageInterfaceListInputSchema,
-  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
   async handler(params, context) {
     const parsed = manageInterfaceListInputSchema.parse(params);
     log45.info({ routerId: context.routerId, action: parsed.action, name: parsed.name }, "Managing interface list");
@@ -10769,7 +10961,7 @@ var manageInterfaceListMemberTool = {
   title: "Manage Interface List Member",
   description: "Add or remove an interface from an interface list. Idempotent by list+interface composite key. add returns already_exists if the membership exists. remove returns not_found gracefully.",
   inputSchema: manageInterfaceListMemberInputSchema,
-  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
   async handler(params, context) {
     const parsed = manageInterfaceListMemberInputSchema.parse(params);
     log45.info(
@@ -10851,9 +11043,7 @@ import { z as z46 } from "zod";
 
 // src/middleware/authz.ts
 function matchesPattern(name, pattern) {
-  if (!pattern.includes("*")) return name === pattern;
-  const prefix = pattern.slice(0, pattern.indexOf("*"));
-  return name.startsWith(prefix);
+  return globMatch(pattern, name);
 }
 function checkAuthz(identity, toolName, routerId2) {
   if (identity.allowedRouters.length > 0 && !identity.allowedRouters.includes(routerId2)) {
@@ -10949,11 +11139,16 @@ var SshClient = class {
     const maxOutputBytes = this.maxOutputBytes;
     return new Promise((resolve, reject) => {
       const conn = new Client();
-      let output = "";
+      const chunks = [];
       let outputSize = 0;
       let truncated = false;
+      let timedOut = false;
       let settled = false;
       let timer;
+      const decodeOutput = () => {
+        const text = Buffer.concat(chunks).toString("utf-8");
+        return truncated ? text + "\n[OUTPUT TRUNCATED]" : text;
+      };
       const cleanup = (err) => {
         if (settled) return;
         settled = true;
@@ -10962,7 +11157,7 @@ var SshClient = class {
         if (err) {
           reject(err);
         } else {
-          resolve(truncated ? output + "\n[OUTPUT TRUNCATED]" : output);
+          resolve(decodeOutput());
         }
       };
       conn.on("ready", () => {
@@ -10972,24 +11167,35 @@ var SshClient = class {
             return;
           }
           timer = setTimeout(() => {
+            timedOut = true;
             stream.close();
           }, timeoutMs);
           const appendOutput = (data) => {
             if (truncated) return;
             const remaining = maxOutputBytes - outputSize;
             if (data.length >= remaining) {
-              output += data.slice(0, remaining).toString();
+              chunks.push(data.subarray(0, remaining));
               outputSize = maxOutputBytes;
               truncated = true;
               stream.close();
               return;
             }
-            output += data.toString();
+            chunks.push(data);
             outputSize += data.length;
           };
           stream.on("data", appendOutput);
           stream.stderr.on("data", appendOutput);
-          stream.on("close", () => cleanup());
+          stream.on("close", () => {
+            if (timedOut) {
+              const err2 = new Error(
+                `SSH command timed out after ${timeoutMs}ms (${outputSize} bytes of partial output discarded)`
+              );
+              err2.code = "ETIMEDOUT";
+              cleanup(err2);
+            } else {
+              cleanup();
+            }
+          });
         });
       });
       conn.on("error", (err) => cleanup(err));
@@ -11059,6 +11265,58 @@ var FtpClient = class {
   }
 };
 
+// src/adapter/sftp-client.ts
+import { createHash as createHash2 } from "crypto";
+import { Client as Client3 } from "ssh2";
+var SftpClient = class {
+  constructor(config, credentials) {
+    this.config = config;
+    this.credentials = credentials;
+  }
+  config;
+  credentials;
+  async upload(remoteName, content) {
+    return new Promise((resolve, reject) => {
+      const conn = new Client3();
+      let settled = false;
+      const cleanup = (err) => {
+        if (settled) return;
+        settled = true;
+        conn.end();
+        if (err) reject(err);
+        else resolve();
+      };
+      conn.on("ready", () => {
+        conn.sftp((err, sftp) => {
+          if (err) {
+            cleanup(err);
+            return;
+          }
+          sftp.writeFile(remoteName, Buffer.from(content, "utf-8"), (writeErr) => {
+            cleanup(writeErr ?? void 0);
+          });
+        });
+      });
+      conn.on("error", (err) => cleanup(err));
+      const connectOptions = {
+        host: this.config.host,
+        port: this.config.sshPort ?? 22,
+        username: this.credentials.username,
+        password: this.credentials.password,
+        readyTimeout: 1e4
+      };
+      if (this.config.sshFingerprint) {
+        const expected = this.config.sshFingerprint.toLowerCase();
+        connectOptions.hostVerifier = (key2) => {
+          const actual = createHash2("sha256").update(key2).digest("hex");
+          return actual === expected;
+        };
+      }
+      conn.connect(connectOptions);
+    });
+  }
+};
+
 // src/adapter/adapter-factory.ts
 function createSshClient(routerConfig, options) {
   const creds = getCredentials(routerConfig);
@@ -11068,6 +11326,10 @@ function createFtpClient(routerConfig) {
   const creds = getCredentials(routerConfig);
   return new FtpClient(routerConfig.host, 21, creds.username, creds.password);
 }
+function createSftpClient(routerConfig) {
+  const creds = getCredentials(routerConfig);
+  return new SftpClient(routerConfig, creds);
+}
 
 // src/mcp/tool-context.ts
 function buildRouterToolContext(args) {
@@ -11080,6 +11342,7 @@ function buildRouterToolContext(args) {
     routerConfig,
     sshClient: createSshClient(routerConfig, config.ssh),
     ftpClient: createFtpClient(routerConfig),
+    sftpClient: createSftpClient(routerConfig),
     identity,
     routerRegistry: registry,
     connectionPool: pool,
@@ -11087,1082 +11350,1136 @@ function buildRouterToolContext(args) {
   };
 }
 
-// src/middleware/fleet-confirmation.ts
-import { createHmac, createHash as createHash2 } from "crypto";
+// src/mcp/tool-executor.ts
+import { nanoid as nanoid4 } from "nanoid";
+
+// src/observability/correlation.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { nanoid as nanoid3 } from "nanoid";
+var requestContext = new AsyncLocalStorage();
+function withContext(ctx, fn) {
+  const fullContext = {
+    correlationId: ctx.correlationId ?? nanoid3(),
+    routerId: ctx.routerId,
+    tool: ctx.tool,
+    identity: ctx.identity
+  };
+  return requestContext.run(fullContext, fn);
+}
+
+// src/middleware/auth.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var identityStorage = new AsyncLocalStorage2();
+function getCurrentIdentity() {
+  return identityStorage.getStore();
+}
+function withIdentity(identity, fn) {
+  return identityStorage.run(identity, fn);
+}
+function extractBearerToken(authHeader) {
+  if (!authHeader) return null;
+  const match = /^Bearer (.+)$/i.exec(authHeader);
+  return match ? match[1] : null;
+}
+async function authenticateHttp(req, registry) {
+  const token = extractBearerToken(req.headers.authorization);
+  if (!token) {
+    throw new MikroMCPError({
+      category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
+      code: "INVALID_TOKEN",
+      message: "Missing or malformed Authorization header. Use: Authorization: Bearer <token>",
+      recoverability: {
+        retryable: false,
+        suggestedAction: "Provide a valid bearer token in the Authorization header."
+      }
+    });
+  }
+  const identity = await registry.findIdentityByToken(token);
+  if (!identity) {
+    throw new MikroMCPError({
+      category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
+      code: "INVALID_TOKEN",
+      message: "Token does not match any configured identity.",
+      recoverability: {
+        retryable: false,
+        suggestedAction: "Verify the bearer token matches a configured identity in identities.yaml."
+      }
+    });
+  }
+  return identity;
+}
+var BUILTIN_SUPERADMIN = {
+  id: "superadmin-builtin",
+  role: "superadmin",
+  allowedRouters: [],
+  allowedToolPatterns: []
+};
+function getStdioIdentity(stdioIdentityName, registry) {
+  if (!stdioIdentityName) {
+    return BUILTIN_SUPERADMIN;
+  }
+  const found = registry.getIdentities().find((i) => i.id === stdioIdentityName);
+  if (!found) {
+    throw new MikroMCPError({
+      category: "CONFIGURATION" /* CONFIGURATION */,
+      code: "STDIO_IDENTITY_NOT_FOUND",
+      message: `MIKROMCP_STDIO_IDENTITY="${stdioIdentityName}" was not found in identities.yaml`,
+      details: { stdioIdentityName },
+      recoverability: {
+        retryable: false,
+        suggestedAction: `Add an identity named "${stdioIdentityName}" to ~/.mikromcp/identities.yaml or unset MIKROMCP_STDIO_IDENTITY.`
+      }
+    });
+  }
+  return found;
+}
+
+// src/middleware/confirmation.ts
+import { createHmac, createHash as createHash3, timingSafeEqual } from "crypto";
 var CONFIRMATION_TTL_MS = 5 * 60 * 1e3;
-var pending = /* @__PURE__ */ new Map();
-function fingerprint(args) {
-  const sortedRouters = [...args.routerIds].sort();
-  const payload = JSON.stringify({
-    toolName: args.toolName,
-    routerIds: sortedRouters,
-    params: args.params,
-    identityId: args.identityId
-  });
-  return createHash2("sha256").update(payload).digest("hex");
+var BYPASS_ROLES = ["admin", "superadmin"];
+var usedTokens = /* @__PURE__ */ new Map();
+function computeParamHash(params) {
+  const { confirmationToken: _, ...rest } = params;
+  return createHash3("sha256").update(JSON.stringify(rest)).digest("hex");
+}
+function sign(tool, routerId2, identityId, paramHash, expiresAtMs, secret) {
+  const payload = `${tool}|${routerId2}|${identityId}|${paramHash}|${expiresAtMs}`;
+  const mac = createHmac("sha256", secret).update(payload).digest("hex");
+  return `${expiresAtMs}.${mac}`;
 }
-function evictExpired() {
-  const now = /* @__PURE__ */ new Date();
-  for (const [token, entry] of pending) {
-    if (entry.expiresAt <= now) pending.delete(token);
+function tokensEqual(a, b) {
+  const bufA = Buffer.from(a, "utf-8");
+  const bufB = Buffer.from(b, "utf-8");
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+function sweepUsed(now) {
+  for (const [token, expiresAtMs] of usedTokens) {
+    if (expiresAtMs <= now) usedTokens.delete(token);
   }
 }
-function checkFleetConfirmation(args, secret) {
-  evictExpired();
-  const fp = fingerprint(args);
-  if (args.submittedToken) {
-    const entry = pending.get(args.submittedToken);
-    if (!entry || entry.expiresAt <= /* @__PURE__ */ new Date() || entry.fingerprint !== fp) {
+async function checkConfirmation(toolName, routerId2, params, identity, secret) {
+  if (BYPASS_ROLES.includes(identity.role)) return;
+  const now = Date.now();
+  sweepUsed(now);
+  const submittedToken = typeof params.confirmationToken === "string" ? params.confirmationToken : null;
+  const paramHash = computeParamHash(params);
+  if (submittedToken) {
+    const dot = submittedToken.indexOf(".");
+    const expiresAtMs2 = dot > 0 ? Number(submittedToken.slice(0, dot)) : NaN;
+    if (!Number.isFinite(expiresAtMs2) || expiresAtMs2 <= now || usedTokens.has(submittedToken)) {
       throw new MikroMCPError({
         category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
-        code: "FLEET_CONFIRMATION_MISMATCH",
-        message: "Fleet confirmation token is expired, already used, or does not match the current toolName/routerIds/params.",
+        code: "CONFIRMATION_EXPIRED",
+        message: "Confirmation token has expired or was already used. Re-submit without confirmationToken to get a fresh token.",
         recoverability: {
           retryable: true,
-          suggestedAction: "Re-submit bulk_execute without confirmationToken to get a fresh token."
+          suggestedAction: "Re-submit the tool call without confirmationToken to receive a new token."
+        }
+      });
+    }
+    const expected = sign(toolName, routerId2, identity.id, paramHash, expiresAtMs2, secret);
+    if (!tokensEqual(submittedToken, expected)) {
+      throw new MikroMCPError({
+        category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
+        code: "CONFIRMATION_MISMATCH",
+        message: "Confirmation token does not match the current call parameters.",
+        recoverability: {
+          retryable: true,
+          suggestedAction: "Re-submit the tool call without confirmationToken to receive a new token."
         }
       });
     }
-    pending.delete(args.submittedToken);
+    usedTokens.set(submittedToken, expiresAtMs2);
     return;
   }
-  const expiresAt = new Date(Date.now() + CONFIRMATION_TTL_MS);
-  const token = createHmac("sha256", secret).update(`${fp}:${expiresAt.toISOString()}`).digest("hex");
-  pending.set(token, { expiresAt, fingerprint: fp });
+  const expiresAtMs = now + CONFIRMATION_TTL_MS;
+  const token = sign(toolName, routerId2, identity.id, paramHash, expiresAtMs, secret);
   throw new MikroMCPError({
     category: "APPROVAL_REQUIRED" /* APPROVAL_REQUIRED */,
-    code: "FLEET_CONFIRMATION_REQUIRED",
-    message: `This will run destructive tool "${args.toolName}" across ${args.routerIds.length} router(s). Re-submit with confirmationToken to proceed.`,
+    code: "CONFIRMATION_REQUIRED",
+    message: "This action is destructive. Re-submit with confirmationToken to proceed.",
     details: {
       confirmationToken: token,
-      expiresAt: expiresAt.toISOString(),
-      routerCount: args.routerIds.length
+      expiresAt: new Date(expiresAtMs).toISOString(),
+      tool: toolName,
+      routerId: routerId2
     },
     recoverability: {
       retryable: true,
-      suggestedAction: "Re-submit the identical bulk_execute call with details.confirmationToken."
+      suggestedAction: "Re-submit the exact same tool call with the confirmationToken from details.confirmationToken."
     }
   });
 }
 
-// src/domain/tools/fleet-tools.ts
-var log47 = createLogger("fleet-tools");
-var checkHealthInputSchema = z46.object({
-  routerId
-}).strict();
-var bulkExecuteInputSchema = z46.object({
-  toolName: z46.string().describe("Name of the tool to fan out (must be a single-router tool)"),
-  routerIds: z46.array(z46.string()).optional().describe("Explicit list of router IDs to target"),
-  tags: z46.array(z46.string()).optional().describe("Target all routers with ALL of these tags (mutually exclusive with routerIds)"),
-  params: z46.record(z46.string(), z46.unknown()).describe("Params to pass to the tool (omit routerId \u2014 injected per router)"),
-  concurrency: z46.number().int().min(1).max(20).default(5).describe("Max simultaneous router calls"),
-  confirmationToken: z46.string().optional().describe(
-    "Fleet confirmation token from a prior APPROVAL_REQUIRED response. Required to fan out a destructive tool."
-  )
-}).strict();
-var listRoutersInputSchema = z46.object({
-  tags: z46.array(z46.string()).optional().describe('Only return routers having any of these tags (e.g. ["edge", "prod"])')
-}).strict();
-var listRoutersTool = {
-  name: "list_routers",
-  title: "List Routers",
-  description: "List the routers configured in the registry (routers.yaml): id, host, port, TLS status, tags, ROS version, and which is the default. Read-only reflection of local config \u2014 no RouterOS API call, no credentials in the response. Use it to discover valid routerId values and tags for targeting other tools (including bulk_execute).",
-  inputSchema: listRoutersInputSchema,
-  annotations: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-  },
-  skipRouterContext: true,
-  async handler(params, context) {
-    const parsed = listRoutersInputSchema.parse(params);
-    const { identity, appConfig } = context;
-    const defaultRouter = appConfig.defaultRouter;
-    log47.info({ tags: parsed.tags, identityId: identity.id }, "Listing routers");
-    let routers = context.routerRegistry.listRouters(parsed.tags);
-    if (identity.allowedRouters.length > 0) {
-      routers = routers.filter((r) => identity.allowedRouters.includes(r.id));
+// src/adapter/retry-engine.ts
+var DEFAULTS = {
+  maxRetries: 3,
+  baseDelayMs: 200,
+  maxDelayMs: 5e3
+};
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "ENOTFOUND"]);
+function isRetryable(error) {
+  if (error instanceof MikroMCPError) {
+    return error.recoverability.retryable;
+  }
+  if (error instanceof Error) {
+    const code = error.code;
+    if (code && RETRYABLE_CODES.has(code)) {
+      return true;
     }
-    const soleDefaultId = defaultRouter === void 0 && routers.length === 1 ? routers[0].id : void 0;
-    const rows = routers.map((r) => ({
-      id: r.id,
-      host: r.host,
-      port: r.port,
-      tlsEnabled: r.tls.enabled,
-      tags: r.tags,
-      rosVersion: r.rosVersion,
-      isDefault: defaultRouter !== void 0 ? r.id === defaultRouter : r.id === soleDefaultId
-    }));
-    const total = rows.length;
-    const header = `Routers: ${total === 0 ? "none" : `1-${total} of ${total}`}.`;
-    const lines = rows.map(
-      (r) => `  ${compactFields(
-        { ...r, tags: r.tags.join(",") },
-        ["id", "host", "port", "tlsEnabled", "tags", "rosVersion", "isDefault"]
-      )}`
-    );
-    return {
-      content: total === 0 ? header : [header, ...lines].join("\n"),
-      structuredContent: { routers: rows, total, returned: total }
-    };
-  }
-};
-function createFleetTools(baseTools2) {
-  const toolMap = new Map(baseTools2.map((t) => [t.name, t]));
-  const checkRouterHealthTool = {
-    name: "check_router_health",
-    title: "Check Router Health",
-    description: "Probe a router by fetching system/resource. Returns health status, ROS version, uptime, CPU load, and memory info. Unlike other tools, this never throws \u2014 unreachable routers are reported as healthy=false.",
-    inputSchema: checkHealthInputSchema,
-    annotations: {
-      readOnlyHint: true,
-      destructiveHint: false,
-      idempotentHint: true,
-      openWorldHint: false
-    },
-    async handler(params, context) {
-      checkHealthInputSchema.parse(params);
-      log47.info({ routerId: context.routerId }, "Checking router health");
-      const startMs = Date.now();
-      try {
-        const resources = await context.routerClient.get("system/resource");
-        const resource = resources[0];
-        const latencyMs = Date.now() - startMs;
-        const result = {
-          routerId: context.routerId,
-          healthy: true,
-          rosVersion: resource?.["version"],
-          uptime: resource?.["uptime"],
-          cpuLoad: resource?.["cpu-load"],
-          freeMemory: resource?.["free-memory"],
-          totalMemory: resource?.["total-memory"],
-          latencyMs
-        };
-        return {
-          content: `Router ${context.routerId} is healthy (${latencyMs}ms)`,
-          structuredContent: result
-        };
-      } catch (err) {
-        const latencyMs = Date.now() - startMs;
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-          content: `Router ${context.routerId} is unhealthy: ${message}`,
-          structuredContent: {
-            routerId: context.routerId,
-            healthy: false,
-            latencyMs,
-            error: message
-          }
-        };
-      }
+    const statusCode = error.statusCode;
+    if (typeof statusCode === "number") {
+      return statusCode >= 500;
     }
-  };
-  const bulkExecuteTool = {
-    name: "bulk_execute",
-    title: "Bulk Execute",
-    description: "Fan out a single-router tool to many routers in parallel (up to `concurrency`), targeted by routerIds or tag. Destructive tools need two-step confirmation: call without `confirmationToken` to get a fleet token (needs MIKROMCP_CONFIRMATION_SECRET), then re-call with it. Writes snapshot+journal each router for rollback. Returns per-router results with succeeded/failed counts.",
-    inputSchema: bulkExecuteInputSchema,
-    annotations: {
-      readOnlyHint: false,
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: false
-    },
-    skipRouterContext: true,
-    async handler(params, context) {
-      const parsed = bulkExecuteInputSchema.parse(params);
-      const hasRouterIds = Array.isArray(parsed.routerIds) && parsed.routerIds.length > 0;
-      const hasTags = Array.isArray(parsed.tags) && parsed.tags.length > 0;
-      if (hasRouterIds === hasTags) {
-        throw new MikroMCPError({
-          category: "VALIDATION" /* VALIDATION */,
-          code: "BULK_TARGET_REQUIRED",
-          message: "Provide exactly one of routerIds or tags, not both and not neither.",
-          recoverability: {
-            retryable: false,
-            suggestedAction: "Supply either routerIds (array of IDs) or tags (array of tag strings)."
-          }
-        });
-      }
-      log47.info(
-        { toolName: parsed.toolName, concurrency: parsed.concurrency },
-        "bulk_execute invoked"
-      );
-      auditLog({
-        type: "audit",
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        correlationId: context.correlationId,
-        identityId: context.identity.id,
-        role: context.identity.role,
-        tool: "bulk_execute",
-        routerId: "(fleet)",
-        phase: "attempt",
-        params: { toolName: parsed.toolName, routerIds: parsed.routerIds, tags: parsed.tags }
-      }, context.appConfig.auditLogPath);
-      if (parsed.toolName === "bulk_execute" || parsed.toolName === "check_router_health") {
-        throw new MikroMCPError({
-          category: "VALIDATION" /* VALIDATION */,
-          code: "BULK_SELF_REFERENCE",
-          message: `Cannot use bulk_execute to fan out fleet tools ("${parsed.toolName}").`,
-          recoverability: {
-            retryable: false,
-            suggestedAction: "Choose a single-router tool as the toolName."
-          }
-        });
-      }
-      const foundTool = toolMap.get(parsed.toolName);
-      if (!foundTool) {
-        throw new MikroMCPError({
-          category: "NOT_FOUND" /* NOT_FOUND */,
-          code: "TOOL_NOT_FOUND",
-          message: `Tool "${parsed.toolName}" not found. Available tools: ${[...toolMap.keys()].join(", ")}`,
-          recoverability: {
-            retryable: false,
-            suggestedAction: "Check the tool name and try again."
-          }
-        });
-      }
-      const targetTool = foundTool;
-      const preErrors = [];
-      let routers;
-      if (hasRouterIds) {
-        const resolved = [];
-        for (const id of parsed.routerIds) {
-          try {
-            resolved.push(context.routerRegistry.getRouter(id));
-          } catch {
-            log47.warn({ routerId: id }, "bulk_execute: router not found");
-            preErrors.push({
-              routerId: id,
-              status: "error",
-              error: `Router "${id}" not found in registry`,
-              durationMs: 0
-            });
-          }
-        }
-        routers = resolved;
-      } else {
-        routers = context.routerRegistry.listRouters(parsed.tags);
-      }
-      if (targetTool.annotations.destructiveHint) {
-        const secret = context.appConfig.confirmationSecret;
-        if (!secret) {
-          throw new MikroMCPError({
-            category: "CONFIGURATION" /* CONFIGURATION */,
-            code: "FLEET_CONFIRMATION_UNAVAILABLE",
-            message: "Fanning out a destructive tool requires MIKROMCP_CONFIRMATION_SECRET to be configured.",
-            recoverability: {
-              retryable: false,
-              suggestedAction: "Set MIKROMCP_CONFIRMATION_SECRET, or call the tool per-router."
-            }
-          });
-        }
-        const routerIdList = routers.map((r) => r.id);
-        checkFleetConfirmation(
-          {
-            toolName: parsed.toolName,
-            routerIds: routerIdList,
-            params: parsed.params,
-            identityId: context.identity.id,
-            submittedToken: parsed.confirmationToken
-          },
-          secret
-        );
-      }
-      if (routers.length === 0 && preErrors.length === 0) {
-        auditLog({
-          type: "audit",
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          correlationId: context.correlationId,
-          identityId: context.identity.id,
-          role: context.identity.role,
-          tool: "bulk_execute",
-          routerId: "(fleet)",
-          phase: "success",
-          params: { toolName: parsed.toolName, succeeded: 0, failed: 0 }
-        }, context.appConfig.auditLogPath);
-        return {
-          content: `Executed ${parsed.toolName} on 0 routers: 0 succeeded, 0 failed`,
-          structuredContent: {
-            toolName: parsed.toolName,
-            totalRouters: 0,
-            succeeded: 0,
-            failed: 0,
-            results: []
-          }
-        };
-      }
-      const isWrite = !targetTool.annotations.readOnlyHint;
-      const snapshotDir = context.appConfig.snapshotDir;
-      const journalPath = context.appConfig.journalPath;
-      async function runForRouter(router) {
-        const start = Date.now();
-        let journalId;
-        try {
-          checkAuthz(context.identity, parsed.toolName, router.id);
-          const routerContext = buildRouterToolContext({
-            routerConfig: router,
-            correlationId: context.correlationId,
-            identity: context.identity,
-            pool: context.connectionPool,
-            config: context.appConfig,
-            registry: context.routerRegistry
-          });
-          const toolParams = { ...parsed.params, routerId: router.id };
-          const snapshotIds = [];
-          if (isWrite && targetTool.snapshotPaths && targetTool.snapshotPaths.length > 0) {
-            for (const path of targetTool.snapshotPaths) {
-              try {
-                const meta = await takeSnapshot(
-                  routerContext.routerClient,
-                  router.id,
-                  path,
-                  snapshotDir
-                );
-                snapshotIds.push(meta.id);
-              } catch (err) {
-                log47.warn(
-                  { err, path, routerId: router.id },
-                  "bulk_execute snapshot failed \u2014 proceeding without snapshot"
-                );
-              }
-            }
-          }
-          if (isWrite && journalPath) {
-            journalId = recordAttempt({
-              journalPath,
-              identityId: context.identity.id,
-              role: context.identity.role,
-              tool: parsed.toolName,
-              routerId: router.id,
-              params: toolParams,
-              snapshotIds
-            });
-          }
-          const result = await targetTool.handler(
-            toolParams,
-            routerContext
-          );
-          const elapsed = Date.now() - start;
-          if (journalId) {
-            recordOutcome({ journalPath, journalId, phase: "success", durationMs: elapsed });
-          }
-          auditLog({
-            type: "audit",
-            ts: (/* @__PURE__ */ new Date()).toISOString(),
-            correlationId: context.correlationId,
-            identityId: context.identity.id,
-            role: context.identity.role,
-            tool: parsed.toolName,
-            routerId: router.id,
-            phase: "success",
-            params: parsed.params,
-            durationMs: elapsed
-          }, context.appConfig.auditLogPath);
-          return { routerId: router.id, status: "ok", result, durationMs: elapsed };
-        } catch (err) {
-          const elapsed = Date.now() - start;
-          const message = err instanceof Error ? err.message : String(err);
-          if (journalId) {
-            recordOutcome({ journalPath, journalId, phase: "failure", outcome: message, durationMs: elapsed });
-          }
-          auditLog({
-            type: "audit",
-            ts: (/* @__PURE__ */ new Date()).toISOString(),
-            correlationId: context.correlationId,
-            identityId: context.identity.id,
-            role: context.identity.role,
-            tool: parsed.toolName,
-            routerId: router.id,
-            phase: "failure",
-            params: parsed.params,
-            outcome: message,
-            durationMs: elapsed
-          }, context.appConfig.auditLogPath);
-          return { routerId: router.id, status: "error", error: message, durationMs: elapsed };
-        }
-      }
-      const results2 = [...preErrors];
-      for (let i = 0; i < routers.length; i += parsed.concurrency) {
-        const batch = routers.slice(i, i + parsed.concurrency);
-        const batchResults = await Promise.all(batch.map(runForRouter));
-        results2.push(...batchResults);
+  }
+  return false;
+}
+async function withRetry(fn, options) {
+  const opts = { ...DEFAULTS, ...options };
+  let lastError;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= opts.maxRetries || !isRetryable(error)) {
+        throw error;
       }
-      const succeeded = results2.filter((r) => r.status === "ok").length;
-      const failed = results2.filter((r) => r.status === "error").length;
-      auditLog({
-        type: "audit",
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        correlationId: context.correlationId,
-        identityId: context.identity.id,
-        role: context.identity.role,
-        tool: "bulk_execute",
-        routerId: "(fleet)",
-        phase: "success",
-        params: { toolName: parsed.toolName, succeeded, failed }
-      }, context.appConfig.auditLogPath);
-      return {
-        content: `Executed ${parsed.toolName} on ${results2.length} routers: ${succeeded} succeeded, ${failed} failed`,
-        structuredContent: {
-          toolName: parsed.toolName,
-          totalRouters: results2.length,
-          succeeded,
-          failed,
-          results: results2
-        }
-      };
+      const exponentialDelay = opts.baseDelayMs * 2 ** attempt;
+      const jitter = Math.random() * opts.baseDelayMs;
+      const delay = Math.min(exponentialDelay + jitter, opts.maxDelayMs);
+      await new Promise((resolve) => setTimeout(resolve, delay));
     }
-  };
-  return [checkRouterHealthTool, bulkExecuteTool, listRoutersTool];
+  }
+  throw lastError;
 }
 
-// src/domain/tools/index.ts
-var baseTools = [
-  ...systemTools,
-  ...interfaceTools,
-  ...ipTools,
-  ...dhcpTools,
-  ...routeTools,
-  ...firewallTools,
-  ...diagnosticTools,
-  ...systemOpsTools,
-  ...bridgeTools,
-  ...wifiTools,
-  ...wireguardTools,
-  ...dnsTools,
-  ...mangleTools,
-  ...addressListTools,
-  ...policyRoutingTools,
-  ...routingProtocolTools,
-  ...scriptsTools,
-  ...schedulerTools,
-  ...packagesTools,
-  ...filesTools,
-  ...containerTools,
-  ...ipsecTools,
-  ...certificateTools,
-  ...userTools,
-  ...userGroupTools,
-  ...dhcpServerTools,
-  ...ipPoolTools,
-  ...queueTools,
-  ...vrrpTools,
-  ...networkServicesTools,
-  ...vlanTools,
-  ...dhcpClientTools,
-  ...ipServiceTools,
-  ...pppoeTools,
-  ...ovpnTools,
-  ...pppTools,
-  ...upgradeTools,
-  ...backupTools,
-  ...logTools,
-  ...networkTestTools,
-  ...containerConfigTools,
-  ...interfaceListTools
-];
-var allTools = [
-  ...baseTools,
-  ...createChangeManagementTools(baseTools),
-  ...createFleetTools(baseTools)
-];
-
-// src/mcp/tool-executor.ts
-import { nanoid as nanoid4 } from "nanoid";
+// src/config/maintenance-window.ts
+var DAY_ABBREVS = {
+  Sun: "Sun",
+  Mon: "Mon",
+  Tue: "Tue",
+  Wed: "Wed",
+  Thu: "Thu",
+  Fri: "Fri",
+  Sat: "Sat"
+};
+var DAY_ORDER = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function isWithinMaintenanceWindow(windows, now) {
+  if (windows.length === 0) return true;
+  return windows.some((w) => {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: w.timezone,
+      weekday: "short",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false
+    }).formatToParts(now);
+    const rawDay = parts.find((p) => p.type === "weekday")?.value ?? "";
+    const day = DAY_ABBREVS[rawDay];
+    if (!day) return false;
+    const hour = parts.find((p) => p.type === "hour")?.value?.padStart(2, "0") ?? "00";
+    const minute = parts.find((p) => p.type === "minute")?.value?.padStart(2, "0") ?? "00";
+    const currentTime = `${hour}:${minute}`;
+    if (w.startTime === w.endTime) return false;
+    if (w.startTime < w.endTime) {
+      return w.days.includes(day) && currentTime >= w.startTime && currentTime <= w.endTime;
+    }
+    const prevDay = DAY_ORDER[(DAY_ORDER.indexOf(day) + 6) % 7];
+    return w.days.includes(day) && currentTime >= w.startTime || w.days.includes(prevDay) && currentTime <= w.endTime;
+  });
+}
 
-// src/observability/correlation.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { nanoid as nanoid3 } from "nanoid";
-var requestContext = new AsyncLocalStorage();
-function withContext(ctx, fn) {
-  const fullContext = {
-    correlationId: ctx.correlationId ?? nanoid3(),
-    routerId: ctx.routerId,
-    tool: ctx.tool,
-    identity: ctx.identity
+// src/mcp/response-formatter.ts
+function formatToolResult(result) {
+  return {
+    content: [{ type: "text", text: result.content }],
+    structuredContent: result.structuredContent,
+    ...result.isError ? { isError: true } : {}
   };
-  return requestContext.run(fullContext, fn);
 }
-
-// src/middleware/auth.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var identityStorage = new AsyncLocalStorage2();
-function getCurrentIdentity() {
-  return identityStorage.getStore();
+function formatError(error) {
+  const hint = error.recoverability.suggestedAction;
+  const text = `Error [${error.category}]: ${error.message}${hint ? `
+Suggested action: ${hint}` : ""}`;
+  return {
+    content: [{ type: "text", text }],
+    structuredContent: error.toJSON(),
+    isError: true
+  };
 }
-function withIdentity(identity, fn) {
-  return identityStorage.run(identity, fn);
+
+// src/observability/metrics.ts
+var toolCalls = /* @__PURE__ */ new Map();
+function key(tool, status) {
+  return `${tool}\0${status}`;
 }
-function extractBearerToken(authHeader) {
-  if (!authHeader) return null;
-  const match = /^Bearer (.+)$/i.exec(authHeader);
-  return match ? match[1] : null;
+function recordToolCall(tool, status) {
+  const k = key(tool, status);
+  toolCalls.set(k, (toolCalls.get(k) ?? 0) + 1);
 }
-async function authenticateHttp(req, registry) {
-  const token = extractBearerToken(req.headers.authorization);
-  if (!token) {
-    throw new MikroMCPError({
-      category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
-      code: "INVALID_TOKEN",
-      message: "Missing or malformed Authorization header. Use: Authorization: Bearer <token>",
-      recoverability: {
-        retryable: false,
-        suggestedAction: "Provide a valid bearer token in the Authorization header."
-      }
-    });
+function renderPrometheus() {
+  const lines = [
+    "# HELP mikromcp_tool_calls_total Total MCP tool calls by tool and status.",
+    "# TYPE mikromcp_tool_calls_total counter"
+  ];
+  for (const [k, count] of toolCalls) {
+    const [tool, status] = k.split("\0");
+    lines.push(`mikromcp_tool_calls_total{tool="${tool}",status="${status}"} ${count}`);
   }
-  const identity = await registry.findIdentityByToken(token);
-  if (!identity) {
-    throw new MikroMCPError({
-      category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
-      code: "INVALID_TOKEN",
-      message: "Token does not match any configured identity.",
-      recoverability: {
-        retryable: false,
-        suggestedAction: "Verify the bearer token matches a configured identity in identities.yaml."
-      }
-    });
+  return lines.join("\n") + "\n";
+}
+
+// src/adapter/circuit-breaker.ts
+var TRANSIENT_CATEGORIES = /* @__PURE__ */ new Set([
+  "ROUTER_UNREACHABLE" /* ROUTER_UNREACHABLE */,
+  "ROUTER_TIMEOUT" /* ROUTER_TIMEOUT */,
+  "ROUTER_ERROR" /* ROUTER_ERROR */,
+  "ROUTER_BUSY" /* ROUTER_BUSY */
+]);
+function isTransientFailure(error) {
+  if (!(error instanceof MikroMCPError)) {
+    return false;
   }
-  return identity;
+  return TRANSIENT_CATEGORIES.has(error.category);
 }
-var BUILTIN_SUPERADMIN = {
-  id: "superadmin-builtin",
-  role: "superadmin",
-  allowedRouters: [],
-  allowedToolPatterns: []
+var DEFAULTS2 = {
+  failureThreshold: 5,
+  cooldownMs: 3e4
 };
-function getStdioIdentity(stdioIdentityName, registry) {
-  if (!stdioIdentityName) {
-    return BUILTIN_SUPERADMIN;
+var CircuitBreaker = class {
+  constructor(routerId2, options) {
+    this.routerId = routerId2;
+    this.options = { ...DEFAULTS2, ...options };
   }
-  const found = registry.getIdentities().find((i) => i.id === stdioIdentityName);
-  if (!found) {
-    throw new MikroMCPError({
-      category: "CONFIGURATION" /* CONFIGURATION */,
-      code: "STDIO_IDENTITY_NOT_FOUND",
-      message: `MIKROMCP_STDIO_IDENTITY="${stdioIdentityName}" was not found in identities.yaml`,
-      details: { stdioIdentityName },
-      recoverability: {
-        retryable: false,
-        suggestedAction: `Add an identity named "${stdioIdentityName}" to ~/.mikromcp/identities.yaml or unset MIKROMCP_STDIO_IDENTITY.`
-      }
-    });
+  routerId;
+  options;
+  currentState = "closed";
+  consecutiveFailures = 0;
+  lastFailureTime = 0;
+  probeInFlight = false;
+  /** Effective state, accounting for an elapsed cooldown. Pure — does not mutate. */
+  get state() {
+    if (this.currentState === "open" && this.cooldownElapsed()) {
+      return "half-open";
+    }
+    return this.currentState;
   }
-  return found;
-}
-
-// src/middleware/confirmation.ts
-import { createHmac as createHmac2, createHash as createHash3 } from "crypto";
-var CONFIRMATION_TTL_MS2 = 5 * 60 * 1e3;
-var BYPASS_ROLES = ["admin", "superadmin"];
-var pendingConfirmations = /* @__PURE__ */ new Map();
-function computeParamHash(params) {
-  const { confirmationToken: _, ...rest } = params;
-  return createHash3("sha256").update(JSON.stringify(rest)).digest("hex");
-}
-function computeToken(tool, routerId2, identityId, paramHash, expiresAt, secret) {
-  const payload = JSON.stringify({ tool, routerId: routerId2, paramHash, identityId, expiresAt });
-  return createHmac2("sha256", secret).update(payload).digest("hex");
-}
-function evictExpired2() {
-  const now = /* @__PURE__ */ new Date();
-  for (const [token, entry] of pendingConfirmations) {
-    if (entry.expiresAt <= now) pendingConfirmations.delete(token);
+  cooldownElapsed() {
+    return Date.now() - this.lastFailureTime >= this.options.cooldownMs;
   }
-}
-async function checkConfirmation(toolName, routerId2, params, identity, secret) {
-  if (BYPASS_ROLES.includes(identity.role)) return;
-  evictExpired2();
-  const submittedToken = typeof params.confirmationToken === "string" ? params.confirmationToken : null;
-  if (submittedToken) {
-    const entry = pendingConfirmations.get(submittedToken);
-    if (!entry || entry.expiresAt <= /* @__PURE__ */ new Date()) {
-      throw new MikroMCPError({
-        category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
-        code: "CONFIRMATION_EXPIRED",
-        message: "Confirmation token has expired or was already used. Re-submit without confirmationToken to get a fresh token.",
-        recoverability: {
-          retryable: true,
-          suggestedAction: "Re-submit the tool call without confirmationToken to receive a new token."
-        }
-      });
+  /** Apply the time-based open→half-open transition. Call before acting on state. */
+  transitionIfCooldownElapsed() {
+    if (this.currentState === "open" && this.cooldownElapsed()) {
+      this.currentState = "half-open";
     }
-    const currentParamHash = computeParamHash(params);
-    if (entry.tool !== toolName || entry.routerId !== routerId2 || entry.identityId !== identity.id || entry.paramHash !== currentParamHash) {
+  }
+  /**
+   * Execute `fn` through the circuit breaker.
+   *
+   * - **closed**: execute normally; track consecutive failures.
+   * - **open**: reject immediately with `ROUTER_BUSY`.
+   * - **half-open**: execute as a probe; success closes, failure reopens.
+   */
+  async execute(fn) {
+    this.transitionIfCooldownElapsed();
+    const currentState = this.currentState;
+    if (currentState === "open") {
       throw new MikroMCPError({
-        category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
-        code: "CONFIRMATION_MISMATCH",
-        message: "Confirmation token does not match the current call parameters.",
+        category: "ROUTER_BUSY" /* ROUTER_BUSY */,
+        code: "CIRCUIT_OPEN",
+        message: `Circuit breaker is open for router "${this.routerId}". Try again after cooldown.`,
+        details: {
+          routerId: this.routerId,
+          consecutiveFailures: this.consecutiveFailures,
+          cooldownMs: this.options.cooldownMs
+        },
         recoverability: {
           retryable: true,
-          suggestedAction: "Re-submit the tool call without confirmationToken to receive a new token."
+          retryAfterMs: this.options.cooldownMs,
+          suggestedAction: "Wait for the circuit breaker cooldown period to expire, then retry."
         }
       });
     }
-    pendingConfirmations.delete(submittedToken);
-    return;
+    if (currentState === "half-open") {
+      if (this.probeInFlight) {
+        throw new MikroMCPError({
+          category: "ROUTER_BUSY" /* ROUTER_BUSY */,
+          code: "CIRCUIT_PROBE_IN_FLIGHT",
+          message: `Circuit breaker for router "${this.routerId}" is half-open and a recovery probe is already in flight.`,
+          details: { routerId: this.routerId },
+          recoverability: {
+            retryable: true,
+            retryAfterMs: 1e3,
+            suggestedAction: "Wait for the in-flight probe to complete, then retry."
+          }
+        });
+      }
+      this.probeInFlight = true;
+    }
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      if (isTransientFailure(error)) {
+        this.onFailure();
+      }
+      throw error;
+    } finally {
+      this.probeInFlight = false;
+    }
   }
-  const expiresAt = new Date(Date.now() + CONFIRMATION_TTL_MS2).toISOString();
-  const paramHash = computeParamHash(params);
-  const token = computeToken(toolName, routerId2, identity.id, paramHash, expiresAt, secret);
-  pendingConfirmations.set(token, {
-    expiresAt: new Date(expiresAt),
-    tool: toolName,
-    routerId: routerId2,
-    identityId: identity.id,
-    paramHash
-  });
+  /** Force the circuit back to the closed state. */
+  reset() {
+    this.currentState = "closed";
+    this.consecutiveFailures = 0;
+    this.lastFailureTime = 0;
+    this.probeInFlight = false;
+  }
+  // ---------- internal helpers ----------
+  onSuccess() {
+    this.consecutiveFailures = 0;
+    this.currentState = "closed";
+  }
+  onFailure() {
+    this.consecutiveFailures++;
+    this.lastFailureTime = Date.now();
+    if (this.currentState === "half-open") {
+      this.currentState = "open";
+    } else if (this.consecutiveFailures >= this.options.failureThreshold) {
+      this.currentState = "open";
+    }
+  }
+};
+
+// src/mcp/tool-executor.ts
+var log47 = createLogger("tool-executor");
+var AMBIGUOUS_WRITE_CATEGORIES = /* @__PURE__ */ new Set([
+  "ROUTER_TIMEOUT" /* ROUTER_TIMEOUT */,
+  "ROUTER_UNREACHABLE" /* ROUTER_UNREACHABLE */
+]);
+var VERIFY_STATE_PREFIX = "The write may already have been applied \u2014 verify router state before retrying. ";
+function resolveRouterId(explicit, registry, config) {
+  if (explicit) {
+    return explicit;
+  }
+  const fallback = config.defaultRouter ?? registry.soleRouterId();
+  if (fallback) {
+    return fallback;
+  }
+  const available = registry.routerIds();
   throw new MikroMCPError({
-    category: "APPROVAL_REQUIRED" /* APPROVAL_REQUIRED */,
-    code: "CONFIRMATION_REQUIRED",
-    message: "This action is destructive. Re-submit with confirmationToken to proceed.",
-    details: {
-      confirmationToken: token,
-      expiresAt,
-      tool: toolName,
-      routerId: routerId2
-    },
+    category: "VALIDATION" /* VALIDATION */,
+    code: "MISSING_ROUTER_ID",
+    message: available.length > 0 ? `routerId is required: more than one router is configured. Available: ${available.join(", ")}.` : "routerId is required, but no routers are configured.",
+    details: { availableRouters: available },
     recoverability: {
-      retryable: true,
-      suggestedAction: "Re-submit the exact same tool call with the confirmationToken from details.confirmationToken."
+      retryable: false,
+      suggestedAction: available.length > 0 ? "Provide a routerId, or set MIKROMCP_DEFAULT_ROUTER to choose a default." : "Configure at least one router in routers.yaml."
     }
   });
 }
-
-// src/adapter/retry-engine.ts
-var DEFAULTS = {
-  maxRetries: 3,
-  baseDelayMs: 200,
-  maxDelayMs: 5e3
-};
-var RETRYABLE_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ECONNRESET", "ETIMEDOUT", "ENOTFOUND"]);
-function isRetryable(error) {
-  if (error instanceof MikroMCPError) {
-    return error.recoverability.retryable;
-  }
-  if (error instanceof Error) {
-    const code = error.code;
-    if (code && RETRYABLE_CODES.has(code)) {
-      return true;
-    }
-    const statusCode = error.statusCode;
-    if (typeof statusCode === "number") {
-      return statusCode >= 500;
-    }
+function getOrCreateBreaker(circuitBreakers, routerId2, config) {
+  let cb = circuitBreakers.get(routerId2);
+  if (!cb) {
+    cb = new CircuitBreaker(routerId2, {
+      failureThreshold: config.circuitBreaker.failureThreshold,
+      cooldownMs: config.circuitBreaker.cooldownMs
+    });
+    circuitBreakers.set(routerId2, cb);
   }
-  return false;
+  return cb;
 }
-async function withRetry(fn, options) {
-  const opts = { ...DEFAULTS, ...options };
-  let lastError;
-  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt >= opts.maxRetries || !isRetryable(error)) {
-        throw error;
+function assertMaintenanceWindow(isDestructive, routerConfig, routerId2) {
+  if (!isDestructive) return;
+  const windows = routerConfig.maintenanceWindows;
+  if (windows && windows.length > 0 && !isWithinMaintenanceWindow(windows, /* @__PURE__ */ new Date())) {
+    throw new MikroMCPError({
+      category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
+      code: "OUTSIDE_MAINTENANCE_WINDOW",
+      message: `Router "${routerId2}" has maintenance windows configured. Destructive operations are only permitted during scheduled windows.`,
+      details: { maintenanceWindows: windows },
+      recoverability: {
+        retryable: true,
+        suggestedAction: "Wait for a scheduled maintenance window, or remove maintenanceWindows from routers.yaml to allow unrestricted access."
       }
-      const exponentialDelay = opts.baseDelayMs * 2 ** attempt;
-      const jitter = Math.random() * opts.baseDelayMs;
-      const delay = Math.min(exponentialDelay + jitter, opts.maxDelayMs);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
+    });
   }
-  throw lastError;
 }
-
-// src/config/maintenance-window.ts
-var DAY_ABBREVS = {
-  Sun: "Sun",
-  Mon: "Mon",
-  Tue: "Tue",
-  Wed: "Wed",
-  Thu: "Thu",
-  Fri: "Fri",
-  Sat: "Sat"
-};
-function isWithinMaintenanceWindow(windows, now) {
-  if (windows.length === 0) return true;
-  return windows.some((w) => {
-    const parts = new Intl.DateTimeFormat("en-US", {
-      timeZone: w.timezone,
-      weekday: "short",
-      hour: "2-digit",
-      minute: "2-digit",
-      hour12: false
-    }).formatToParts(now);
-    const rawDay = parts.find((p) => p.type === "weekday")?.value ?? "";
-    const day = DAY_ABBREVS[rawDay];
-    if (!day || !w.days.includes(day)) return false;
-    const hour = parts.find((p) => p.type === "hour")?.value?.padStart(2, "0") ?? "00";
-    const minute = parts.find((p) => p.type === "minute")?.value?.padStart(2, "0") ?? "00";
-    const currentTime = `${hour}:${minute}`;
-    return w.startTime !== w.endTime && currentTime >= w.startTime && currentTime <= w.endTime;
+function fleetUnavailable(what) {
+  return new Proxy({}, {
+    get() {
+      throw new MikroMCPError({
+        category: "INTERNAL" /* INTERNAL */,
+        code: "FLEET_CONTEXT_UNAVAILABLE",
+        message: `${what} is not available in a fleet-tool context (skipRouterContext). Target a specific router instead.`,
+        recoverability: {
+          retryable: false,
+          suggestedAction: "Use a router-scoped tool, or pass a routerId to operate on one router."
+        }
+      });
+    }
   });
 }
-
-// src/mcp/response-formatter.ts
-function formatToolResult(result) {
-  return {
-    content: [{ type: "text", text: result.content }],
-    structuredContent: result.structuredContent,
-    ...result.isError ? { isError: true } : {}
-  };
-}
-function formatError(error) {
-  const hint = error.recoverability.suggestedAction;
-  const text = `Error [${error.category}]: ${error.message}${hint ? `
-Suggested action: ${hint}` : ""}`;
-  return {
-    content: [{ type: "text", text }],
-    structuredContent: error.toJSON(),
-    isError: true
-  };
+async function executeToolCall(tool, args, deps) {
+  const { registry, pool, circuitBreakers, config, identityRegistry } = deps;
+  const correlationId = nanoid4();
+  return withContext({ correlationId, tool: tool.name }, async () => {
+    const startMs = Date.now();
+    let journalId;
+    try {
+      const identity = getCurrentIdentity() ?? getStdioIdentity(config.stdioIdentity, identityRegistry);
+      if (tool.skipRouterContext) {
+        const fleetContext = {
+          routerClient: fleetUnavailable("routerClient"),
+          routerId: "",
+          correlationId,
+          routerConfig: fleetUnavailable("routerConfig"),
+          sshClient: fleetUnavailable("sshClient"),
+          ftpClient: fleetUnavailable("ftpClient"),
+          sftpClient: fleetUnavailable("sftpClient"),
+          identity,
+          routerRegistry: registry,
+          connectionPool: pool,
+          circuitBreakers,
+          appConfig: config
+        };
+        const fleetResult = await tool.handler(args, fleetContext);
+        recordToolCall(tool.name, "success");
+        return formatToolResult(fleetResult);
+      }
+      const routerId2 = resolveRouterId(args.routerId, registry, config);
+      args.routerId = routerId2;
+      checkAuthz(identity, tool.name, routerId2);
+      const routerConfig = registry.getRouter(routerId2);
+      assertMaintenanceWindow(tool.annotations.destructiveHint, routerConfig, routerId2);
+      if (tool.annotations.destructiveHint && config.confirmationSecret) {
+        await checkConfirmation(tool.name, routerId2, args, identity, config.confirmationSecret);
+      }
+      const shouldAudit = tool.annotations.destructiveHint || !tool.annotations.readOnlyHint;
+      if (shouldAudit) {
+        auditLog({
+          type: "audit",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          correlationId,
+          identityId: identity.id,
+          role: identity.role,
+          tool: tool.name,
+          routerId: routerId2,
+          phase: "attempt",
+          params: args
+        }, config.auditLogPath);
+      }
+      const toolContext = buildRouterToolContext({
+        routerConfig,
+        correlationId,
+        identity,
+        pool,
+        config,
+        registry
+      });
+      const cb = getOrCreateBreaker(circuitBreakers, routerId2, config);
+      toolContext.circuitBreaker = cb;
+      const { confirmationToken: _ct, ...handlerArgs } = args;
+      const snapshotIds = [];
+      if (tool.snapshotPaths && tool.snapshotPaths.length > 0 && !tool.annotations.readOnlyHint) {
+        for (const path of tool.snapshotPaths) {
+          try {
+            const meta = await takeSnapshot(toolContext.routerClient, routerId2, path, config.snapshotDir);
+            snapshotIds.push(meta.id);
+            log47.debug({ snapshotId: meta.id, path }, "Snapshot taken");
+          } catch (err) {
+            log47.warn({ err, path, routerId: routerId2 }, "Snapshot failed \u2014 proceeding without snapshot");
+          }
+        }
+      }
+      if (!tool.annotations.readOnlyHint && config.journalPath) {
+        journalId = recordAttempt({
+          journalPath: config.journalPath,
+          identityId: identity.id,
+          role: identity.role,
+          tool: tool.name,
+          routerId: routerId2,
+          params: handlerArgs,
+          snapshotIds
+        });
+      }
+      const runHandler = () => tool.handler(handlerArgs, toolContext);
+      const shouldRetry = tool.annotations.readOnlyHint && tool.retryable !== false;
+      const executeHandler = () => cb.execute(shouldRetry ? () => withRetry(runHandler, config.retry) : runHandler);
+      const result = await executeHandler();
+      if (journalId) {
+        recordOutcome({
+          journalPath: config.journalPath,
+          journalId,
+          phase: "success",
+          durationMs: Date.now() - startMs
+        });
+      }
+      if (shouldAudit) {
+        auditLog({
+          type: "audit",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          correlationId,
+          identityId: identity.id,
+          role: identity.role,
+          tool: tool.name,
+          routerId: routerId2,
+          phase: "success",
+          params: args,
+          durationMs: Date.now() - startMs
+        }, config.auditLogPath);
+      }
+      log47.info({ tool: tool.name, routerId: routerId2, correlationId }, "Tool executed successfully");
+      recordToolCall(tool.name, "success");
+      return formatToolResult(result);
+    } catch (err) {
+      const error = err instanceof MikroMCPError ? err : enrichError(err, { tool: tool.name });
+      if (!tool.annotations.readOnlyHint && AMBIGUOUS_WRITE_CATEGORIES.has(error.category) && !error.recoverability.suggestedAction.startsWith(VERIFY_STATE_PREFIX)) {
+        error.recoverability.suggestedAction = `${VERIFY_STATE_PREFIX}${error.recoverability.suggestedAction}`;
+      }
+      if (error.category === "ROUTER_AUTH_FAILED" /* ROUTER_AUTH_FAILED */) {
+        const failedRouterId = args.routerId;
+        if (failedRouterId) {
+          pool.removeClient(failedRouterId);
+          log47.info({ routerId: failedRouterId }, "Evicted pooled client after auth failure");
+        }
+      }
+      if (journalId) {
+        recordOutcome({
+          journalPath: config.journalPath,
+          journalId,
+          phase: "failure",
+          outcome: error.code,
+          durationMs: Date.now() - startMs
+        });
+      }
+      const shouldAudit = tool.annotations.destructiveHint || !tool.annotations.readOnlyHint;
+      if (shouldAudit && error.category !== "APPROVAL_REQUIRED" /* APPROVAL_REQUIRED */) {
+        const routerId2 = args.routerId ?? "unknown";
+        const identity = getCurrentIdentity() ?? getStdioIdentity(config.stdioIdentity, identityRegistry);
+        auditLog({
+          type: "audit",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          correlationId,
+          identityId: identity.id,
+          role: identity.role,
+          tool: tool.name,
+          routerId: routerId2,
+          phase: "failure",
+          params: args,
+          outcome: error.code,
+          durationMs: Date.now() - startMs
+        }, config.auditLogPath);
+      }
+      log47.error({ err: error, tool: tool.name, correlationId }, "Tool execution failed");
+      recordToolCall(tool.name, "error");
+      return formatError(error);
+    }
+  });
 }
 
-// src/observability/metrics.ts
-var toolCalls = /* @__PURE__ */ new Map();
-function key(tool, status) {
-  return `${tool}\0${status}`;
+// src/middleware/fleet-confirmation.ts
+import { createHmac as createHmac2, createHash as createHash4, timingSafeEqual as timingSafeEqual2 } from "crypto";
+var CONFIRMATION_TTL_MS2 = 5 * 60 * 1e3;
+var usedTokens2 = /* @__PURE__ */ new Map();
+function fingerprint(args) {
+  const sortedRouters = [...args.routerIds].sort();
+  const payload = JSON.stringify({
+    toolName: args.toolName,
+    routerIds: sortedRouters,
+    params: args.params,
+    identityId: args.identityId
+  });
+  return createHash4("sha256").update(payload).digest("hex");
 }
-function recordToolCall(tool, status) {
-  const k = key(tool, status);
-  toolCalls.set(k, (toolCalls.get(k) ?? 0) + 1);
+function sign2(fp, expiresAtMs, secret) {
+  const mac = createHmac2("sha256", secret).update(`${fp}|${expiresAtMs}`).digest("hex");
+  return `${expiresAtMs}.${mac}`;
 }
-function renderPrometheus() {
-  const lines = [
-    "# HELP mikromcp_tool_calls_total Total MCP tool calls by tool and status.",
-    "# TYPE mikromcp_tool_calls_total counter"
-  ];
-  for (const [k, count] of toolCalls) {
-    const [tool, status] = k.split("\0");
-    lines.push(`mikromcp_tool_calls_total{tool="${tool}",status="${status}"} ${count}`);
-  }
-  return lines.join("\n") + "\n";
+function tokensEqual2(a, b) {
+  const bufA = Buffer.from(a, "utf-8");
+  const bufB = Buffer.from(b, "utf-8");
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual2(bufA, bufB);
 }
-
-// src/adapter/circuit-breaker.ts
-var TRANSIENT_CATEGORIES = /* @__PURE__ */ new Set([
-  "ROUTER_UNREACHABLE" /* ROUTER_UNREACHABLE */,
-  "ROUTER_TIMEOUT" /* ROUTER_TIMEOUT */,
-  "ROUTER_ERROR" /* ROUTER_ERROR */,
-  "ROUTER_BUSY" /* ROUTER_BUSY */
-]);
-function isTransientFailure(error) {
-  if (!(error instanceof MikroMCPError)) {
-    return false;
+function sweepUsed2(now) {
+  for (const [token, expiresAtMs] of usedTokens2) {
+    if (expiresAtMs <= now) usedTokens2.delete(token);
   }
-  return TRANSIENT_CATEGORIES.has(error.category);
 }
-var DEFAULTS2 = {
-  failureThreshold: 5,
-  cooldownMs: 3e4
-};
-var CircuitBreaker = class {
-  constructor(routerId2, options) {
-    this.routerId = routerId2;
-    this.options = { ...DEFAULTS2, ...options };
-  }
-  routerId;
-  options;
-  currentState = "closed";
-  consecutiveFailures = 0;
-  lastFailureTime = 0;
-  probeInFlight = false;
-  /** Effective state, accounting for an elapsed cooldown. Pure — does not mutate. */
-  get state() {
-    if (this.currentState === "open" && this.cooldownElapsed()) {
-      return "half-open";
-    }
-    return this.currentState;
-  }
-  cooldownElapsed() {
-    return Date.now() - this.lastFailureTime >= this.options.cooldownMs;
-  }
-  /** Apply the time-based open→half-open transition. Call before acting on state. */
-  transitionIfCooldownElapsed() {
-    if (this.currentState === "open" && this.cooldownElapsed()) {
-      this.currentState = "half-open";
-    }
-  }
-  /**
-   * Execute `fn` through the circuit breaker.
-   *
-   * - **closed**: execute normally; track consecutive failures.
-   * - **open**: reject immediately with `ROUTER_BUSY`.
-   * - **half-open**: execute as a probe; success closes, failure reopens.
-   */
-  async execute(fn) {
-    this.transitionIfCooldownElapsed();
-    const currentState = this.currentState;
-    if (currentState === "open") {
+function checkFleetConfirmation(args, secret) {
+  const now = Date.now();
+  sweepUsed2(now);
+  const fp = fingerprint(args);
+  if (args.submittedToken) {
+    const token2 = args.submittedToken;
+    const dot = token2.indexOf(".");
+    const expiresAtMs2 = dot > 0 ? Number(token2.slice(0, dot)) : NaN;
+    const expected = Number.isFinite(expiresAtMs2) ? sign2(fp, expiresAtMs2, secret) : "";
+    if (!Number.isFinite(expiresAtMs2) || expiresAtMs2 <= now || usedTokens2.has(token2) || !tokensEqual2(token2, expected)) {
       throw new MikroMCPError({
-        category: "ROUTER_BUSY" /* ROUTER_BUSY */,
-        code: "CIRCUIT_OPEN",
-        message: `Circuit breaker is open for router "${this.routerId}". Try again after cooldown.`,
-        details: {
-          routerId: this.routerId,
-          consecutiveFailures: this.consecutiveFailures,
-          cooldownMs: this.options.cooldownMs
-        },
+        category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
+        code: "FLEET_CONFIRMATION_MISMATCH",
+        message: "Fleet confirmation token is expired, already used, or does not match the current toolName/routerIds/params.",
         recoverability: {
           retryable: true,
-          retryAfterMs: this.options.cooldownMs,
-          suggestedAction: "Wait for the circuit breaker cooldown period to expire, then retry."
+          suggestedAction: "Re-submit bulk_execute without confirmationToken to get a fresh token."
         }
       });
     }
-    if (currentState === "half-open") {
-      if (this.probeInFlight) {
+    usedTokens2.set(token2, expiresAtMs2);
+    return;
+  }
+  const expiresAtMs = now + CONFIRMATION_TTL_MS2;
+  const token = sign2(fp, expiresAtMs, secret);
+  throw new MikroMCPError({
+    category: "APPROVAL_REQUIRED" /* APPROVAL_REQUIRED */,
+    code: "FLEET_CONFIRMATION_REQUIRED",
+    message: `This will run destructive tool "${args.toolName}" across ${args.routerIds.length} router(s). Re-submit with confirmationToken to proceed.`,
+    details: {
+      confirmationToken: token,
+      expiresAt: new Date(expiresAtMs).toISOString(),
+      routerCount: args.routerIds.length
+    },
+    recoverability: {
+      retryable: true,
+      suggestedAction: "Re-submit the identical bulk_execute call with details.confirmationToken."
+    }
+  });
+}
+
+// src/domain/tools/fleet-tools.ts
+var log48 = createLogger("fleet-tools");
+var checkHealthInputSchema = z46.object({
+  routerId
+}).strict();
+var bulkExecuteInputSchema = z46.object({
+  toolName: z46.string().describe("Name of the tool to fan out (must be a single-router tool)"),
+  routerIds: z46.array(z46.string()).optional().describe("Explicit list of router IDs to target"),
+  tags: z46.array(z46.string()).optional().describe("Target all routers with ALL of these tags (mutually exclusive with routerIds)"),
+  params: z46.record(z46.string(), z46.unknown()).describe("Params to pass to the tool (omit routerId \u2014 injected per router)"),
+  concurrency: z46.number().int().min(1).max(20).default(5).describe("Max simultaneous router calls"),
+  confirmationToken: z46.string().optional().describe(
+    "Fleet confirmation token from a prior APPROVAL_REQUIRED response. Required to fan out a destructive tool."
+  )
+}).strict();
+var listRoutersInputSchema = z46.object({
+  tags: z46.array(z46.string()).optional().describe('Only return routers having any of these tags (e.g. ["edge", "prod"])')
+}).strict();
+var listRoutersTool = {
+  name: "list_routers",
+  title: "List Routers",
+  description: "List the routers configured in the registry (routers.yaml): id, host, port, TLS status, tags, ROS version, and which is the default. Read-only reflection of local config \u2014 no RouterOS API call, no credentials in the response. Use it to discover valid routerId values and tags for targeting other tools (including bulk_execute).",
+  inputSchema: listRoutersInputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  skipRouterContext: true,
+  async handler(params, context) {
+    const parsed = listRoutersInputSchema.parse(params);
+    const { identity, appConfig } = context;
+    const defaultRouter = appConfig.defaultRouter;
+    log48.info({ tags: parsed.tags, identityId: identity.id }, "Listing routers");
+    let routers = context.routerRegistry.listRouters(parsed.tags);
+    if (identity.allowedRouters.length > 0) {
+      routers = routers.filter((r) => identity.allowedRouters.includes(r.id));
+    }
+    const soleDefaultId = defaultRouter === void 0 && routers.length === 1 ? routers[0].id : void 0;
+    const rows = routers.map((r) => ({
+      id: r.id,
+      host: r.host,
+      port: r.port,
+      tlsEnabled: r.tls.enabled,
+      tags: r.tags,
+      rosVersion: r.rosVersion,
+      isDefault: defaultRouter !== void 0 ? r.id === defaultRouter : r.id === soleDefaultId
+    }));
+    const total = rows.length;
+    const header = `Routers: ${total === 0 ? "none" : `1-${total} of ${total}`}.`;
+    const lines = rows.map(
+      (r) => `  ${compactFields(
+        { ...r, tags: r.tags.join(",") },
+        ["id", "host", "port", "tlsEnabled", "tags", "rosVersion", "isDefault"]
+      )}`
+    );
+    return {
+      content: total === 0 ? header : [header, ...lines].join("\n"),
+      structuredContent: { routers: rows, total, returned: total }
+    };
+  }
+};
+function createFleetTools(baseTools2) {
+  const toolMap = new Map(baseTools2.map((t) => [t.name, t]));
+  const checkRouterHealthTool = {
+    name: "check_router_health",
+    title: "Check Router Health",
+    description: "Probe a router by fetching system/resource. Returns health status, ROS version, uptime, CPU load, and memory info. Unlike other tools, this never throws \u2014 unreachable routers are reported as healthy=false.",
+    inputSchema: checkHealthInputSchema,
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    async handler(params, context) {
+      checkHealthInputSchema.parse(params);
+      log48.info({ routerId: context.routerId }, "Checking router health");
+      const startMs = Date.now();
+      try {
+        const resources = await context.routerClient.get("system/resource");
+        const resource = resources[0];
+        const latencyMs = Date.now() - startMs;
+        const result = {
+          routerId: context.routerId,
+          healthy: true,
+          rosVersion: resource?.["version"],
+          uptime: resource?.["uptime"],
+          cpuLoad: resource?.["cpu-load"],
+          freeMemory: resource?.["free-memory"],
+          totalMemory: resource?.["total-memory"],
+          latencyMs
+        };
+        return {
+          content: `Router ${context.routerId} is healthy (${latencyMs}ms)`,
+          structuredContent: result
+        };
+      } catch (err) {
+        const latencyMs = Date.now() - startMs;
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: `Router ${context.routerId} is unhealthy: ${message}`,
+          structuredContent: {
+            routerId: context.routerId,
+            healthy: false,
+            latencyMs,
+            error: message
+          }
+        };
+      }
+    }
+  };
+  const bulkExecuteTool = {
+    name: "bulk_execute",
+    title: "Bulk Execute",
+    description: "Fan out a single-router tool to many routers in parallel (up to `concurrency`), targeted by routerIds or tag. Destructive tools need two-step confirmation: call without `confirmationToken` to get a fleet token (needs MIKROMCP_CONFIRMATION_SECRET), then re-call with it. Writes snapshot+journal each router for rollback. Returns per-router results with succeeded/failed counts.",
+    inputSchema: bulkExecuteInputSchema,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    skipRouterContext: true,
+    async handler(params, context) {
+      const parsed = bulkExecuteInputSchema.parse(params);
+      const hasRouterIds = Array.isArray(parsed.routerIds) && parsed.routerIds.length > 0;
+      const hasTags = Array.isArray(parsed.tags) && parsed.tags.length > 0;
+      if (hasRouterIds === hasTags) {
+        throw new MikroMCPError({
+          category: "VALIDATION" /* VALIDATION */,
+          code: "BULK_TARGET_REQUIRED",
+          message: "Provide exactly one of routerIds or tags, not both and not neither.",
+          recoverability: {
+            retryable: false,
+            suggestedAction: "Supply either routerIds (array of IDs) or tags (array of tag strings)."
+          }
+        });
+      }
+      log48.info(
+        { toolName: parsed.toolName, concurrency: parsed.concurrency },
+        "bulk_execute invoked"
+      );
+      auditLog({
+        type: "audit",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        correlationId: context.correlationId,
+        identityId: context.identity.id,
+        role: context.identity.role,
+        tool: "bulk_execute",
+        routerId: "(fleet)",
+        phase: "attempt",
+        params: { toolName: parsed.toolName, routerIds: parsed.routerIds, tags: parsed.tags }
+      }, context.appConfig.auditLogPath);
+      if (parsed.toolName === "bulk_execute" || parsed.toolName === "check_router_health") {
         throw new MikroMCPError({
-          category: "ROUTER_BUSY" /* ROUTER_BUSY */,
-          code: "CIRCUIT_PROBE_IN_FLIGHT",
-          message: `Circuit breaker for router "${this.routerId}" is half-open and a recovery probe is already in flight.`,
-          details: { routerId: this.routerId },
+          category: "VALIDATION" /* VALIDATION */,
+          code: "BULK_SELF_REFERENCE",
+          message: `Cannot use bulk_execute to fan out fleet tools ("${parsed.toolName}").`,
           recoverability: {
-            retryable: true,
-            retryAfterMs: 1e3,
-            suggestedAction: "Wait for the in-flight probe to complete, then retry."
+            retryable: false,
+            suggestedAction: "Choose a single-router tool as the toolName."
           }
         });
       }
-      this.probeInFlight = true;
-    }
-    try {
-      const result = await fn();
-      this.onSuccess();
-      return result;
-    } catch (error) {
-      if (isTransientFailure(error)) {
-        this.onFailure();
+      const foundTool = toolMap.get(parsed.toolName);
+      if (!foundTool) {
+        throw new MikroMCPError({
+          category: "NOT_FOUND" /* NOT_FOUND */,
+          code: "TOOL_NOT_FOUND",
+          message: `Tool "${parsed.toolName}" not found. Available tools: ${[...toolMap.keys()].join(", ")}`,
+          recoverability: {
+            retryable: false,
+            suggestedAction: "Check the tool name and try again."
+          }
+        });
       }
-      throw error;
-    } finally {
-      this.probeInFlight = false;
-    }
-  }
-  /** Force the circuit back to the closed state. */
-  reset() {
-    this.currentState = "closed";
-    this.consecutiveFailures = 0;
-    this.lastFailureTime = 0;
-    this.probeInFlight = false;
-  }
-  // ---------- internal helpers ----------
-  onSuccess() {
-    this.consecutiveFailures = 0;
-    this.currentState = "closed";
-  }
-  onFailure() {
-    this.consecutiveFailures++;
-    this.lastFailureTime = Date.now();
-    if (this.currentState === "half-open") {
-      this.currentState = "open";
-    } else if (this.consecutiveFailures >= this.options.failureThreshold) {
-      this.currentState = "open";
-    }
-  }
-};
-
-// src/mcp/tool-executor.ts
-var log48 = createLogger("tool-executor");
-function resolveRouterId(explicit, registry, config) {
-  if (explicit) {
-    return explicit;
-  }
-  const fallback = config.defaultRouter ?? registry.soleRouterId();
-  if (fallback) {
-    return fallback;
-  }
-  const available = registry.routerIds();
-  throw new MikroMCPError({
-    category: "VALIDATION" /* VALIDATION */,
-    code: "MISSING_ROUTER_ID",
-    message: available.length > 0 ? `routerId is required: more than one router is configured. Available: ${available.join(", ")}.` : "routerId is required, but no routers are configured.",
-    details: { availableRouters: available },
-    recoverability: {
-      retryable: false,
-      suggestedAction: available.length > 0 ? "Provide a routerId, or set MIKROMCP_DEFAULT_ROUTER to choose a default." : "Configure at least one router in routers.yaml."
-    }
-  });
-}
-async function executeToolCall(tool, args, deps) {
-  const { registry, pool, circuitBreakers, config, identityRegistry } = deps;
-  const correlationId = nanoid4();
-  return withContext({ correlationId, tool: tool.name }, async () => {
-    const startMs = Date.now();
-    let journalId;
-    try {
-      const identity = getCurrentIdentity() ?? getStdioIdentity(config.stdioIdentity, identityRegistry);
-      if (tool.skipRouterContext) {
-        const fleetContext = {
-          routerClient: null,
-          routerId: "",
-          correlationId,
-          routerConfig: null,
-          sshClient: null,
-          ftpClient: null,
-          identity,
-          routerRegistry: registry,
-          connectionPool: pool,
-          appConfig: config
-        };
-        const fleetResult = await tool.handler(args, fleetContext);
-        recordToolCall(tool.name, "success");
-        return formatToolResult(fleetResult);
+      const targetTool = foundTool;
+      const preErrors = [];
+      let routers;
+      if (hasRouterIds) {
+        const resolved = [];
+        for (const id of parsed.routerIds) {
+          try {
+            resolved.push(context.routerRegistry.getRouter(id));
+          } catch {
+            log48.warn({ routerId: id }, "bulk_execute: router not found");
+            preErrors.push({
+              routerId: id,
+              status: "error",
+              error: `Router "${id}" not found in registry`,
+              durationMs: 0
+            });
+          }
+        }
+        routers = resolved;
+      } else {
+        const tags = parsed.tags;
+        routers = context.routerRegistry.listRouters().filter((r) => tags.every((t) => r.tags.includes(t)));
       }
-      const routerId2 = resolveRouterId(args.routerId, registry, config);
-      args.routerId = routerId2;
-      checkAuthz(identity, tool.name, routerId2);
-      const routerConfig = registry.getRouter(routerId2);
-      if (tool.annotations.destructiveHint) {
-        const windows = routerConfig.maintenanceWindows;
-        if (windows && windows.length > 0 && !isWithinMaintenanceWindow(windows, /* @__PURE__ */ new Date())) {
+      if (targetTool.annotations.destructiveHint) {
+        const secret = context.appConfig.confirmationSecret;
+        if (!secret) {
           throw new MikroMCPError({
-            category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
-            code: "OUTSIDE_MAINTENANCE_WINDOW",
-            message: `Router "${routerId2}" has maintenance windows configured. Destructive operations are only permitted during scheduled windows.`,
-            details: { maintenanceWindows: windows },
+            category: "CONFIGURATION" /* CONFIGURATION */,
+            code: "FLEET_CONFIRMATION_UNAVAILABLE",
+            message: "Fanning out a destructive tool requires MIKROMCP_CONFIRMATION_SECRET to be configured.",
             recoverability: {
-              retryable: true,
-              suggestedAction: "Wait for a scheduled maintenance window, or remove maintenanceWindows from routers.yaml to allow unrestricted access."
+              retryable: false,
+              suggestedAction: "Set MIKROMCP_CONFIRMATION_SECRET, or call the tool per-router."
             }
           });
         }
+        const routerIdList = routers.map((r) => r.id);
+        checkFleetConfirmation(
+          {
+            toolName: parsed.toolName,
+            routerIds: routerIdList,
+            params: parsed.params,
+            identityId: context.identity.id,
+            submittedToken: parsed.confirmationToken
+          },
+          secret
+        );
       }
-      if (tool.annotations.destructiveHint && config.confirmationSecret) {
-        await checkConfirmation(tool.name, routerId2, args, identity, config.confirmationSecret);
-      }
-      const shouldAudit = tool.annotations.destructiveHint || !tool.annotations.readOnlyHint;
-      if (shouldAudit) {
+      if (routers.length === 0 && preErrors.length === 0) {
         auditLog({
           type: "audit",
           ts: (/* @__PURE__ */ new Date()).toISOString(),
-          correlationId,
-          identityId: identity.id,
-          role: identity.role,
-          tool: tool.name,
-          routerId: routerId2,
-          phase: "attempt",
-          params: args
-        }, config.auditLogPath);
-      }
-      const toolContext = buildRouterToolContext({
-        routerConfig,
-        correlationId,
-        identity,
-        pool,
-        config,
-        registry
-      });
-      let cb = circuitBreakers.get(routerId2);
-      if (!cb) {
-        cb = new CircuitBreaker(routerId2, {
-          failureThreshold: config.circuitBreaker.failureThreshold,
-          cooldownMs: config.circuitBreaker.cooldownMs
-        });
-        circuitBreakers.set(routerId2, cb);
+          correlationId: context.correlationId,
+          identityId: context.identity.id,
+          role: context.identity.role,
+          tool: "bulk_execute",
+          routerId: "(fleet)",
+          phase: "success",
+          params: { toolName: parsed.toolName, succeeded: 0, failed: 0 }
+        }, context.appConfig.auditLogPath);
+        return {
+          content: `Executed ${parsed.toolName} on 0 routers: 0 succeeded, 0 failed`,
+          structuredContent: {
+            toolName: parsed.toolName,
+            totalRouters: 0,
+            succeeded: 0,
+            failed: 0,
+            results: []
+          }
+        };
       }
-      toolContext.circuitBreaker = cb;
-      const { confirmationToken: _ct, ...handlerArgs } = args;
-      const snapshotIds = [];
-      if (tool.snapshotPaths && tool.snapshotPaths.length > 0 && !tool.annotations.readOnlyHint) {
-        for (const path of tool.snapshotPaths) {
-          try {
-            const meta = await takeSnapshot(toolContext.routerClient, routerId2, path, config.snapshotDir);
-            snapshotIds.push(meta.id);
-            log48.debug({ snapshotId: meta.id, path }, "Snapshot taken");
-          } catch (err) {
-            log48.warn({ err, path, routerId: routerId2 }, "Snapshot failed \u2014 proceeding without snapshot");
+      const isWrite = !targetTool.annotations.readOnlyHint;
+      const snapshotDir = context.appConfig.snapshotDir;
+      const journalPath = context.appConfig.journalPath;
+      async function runForRouter(router) {
+        const start = Date.now();
+        let journalId;
+        try {
+          checkAuthz(context.identity, parsed.toolName, router.id);
+          assertMaintenanceWindow(targetTool.annotations.destructiveHint, router, router.id);
+          const routerContext = buildRouterToolContext({
+            routerConfig: router,
+            correlationId: context.correlationId,
+            identity: context.identity,
+            pool: context.connectionPool,
+            config: context.appConfig,
+            registry: context.routerRegistry
+          });
+          const toolParams = { ...parsed.params, routerId: router.id };
+          const snapshotIds = [];
+          if (isWrite && targetTool.snapshotPaths && targetTool.snapshotPaths.length > 0) {
+            for (const path of targetTool.snapshotPaths) {
+              try {
+                const meta = await takeSnapshot(
+                  routerContext.routerClient,
+                  router.id,
+                  path,
+                  snapshotDir
+                );
+                snapshotIds.push(meta.id);
+              } catch (err) {
+                log48.warn(
+                  { err, path, routerId: router.id },
+                  "bulk_execute snapshot failed \u2014 proceeding without snapshot"
+                );
+              }
+            }
+          }
+          if (isWrite && journalPath) {
+            journalId = recordAttempt({
+              journalPath,
+              identityId: context.identity.id,
+              role: context.identity.role,
+              tool: parsed.toolName,
+              routerId: router.id,
+              params: toolParams,
+              snapshotIds
+            });
+          }
+          const cb = getOrCreateBreaker(context.circuitBreakers, router.id, context.appConfig);
+          routerContext.circuitBreaker = cb;
+          const runOnce = () => targetTool.handler(toolParams, routerContext);
+          const shouldRetry = targetTool.annotations.readOnlyHint && targetTool.retryable !== false;
+          const result = await cb.execute(
+            shouldRetry ? () => withRetry(runOnce, context.appConfig.retry) : runOnce
+          );
+          const elapsed = Date.now() - start;
+          if (journalId) {
+            recordOutcome({ journalPath, journalId, phase: "success", durationMs: elapsed });
+          }
+          auditLog({
+            type: "audit",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            correlationId: context.correlationId,
+            identityId: context.identity.id,
+            role: context.identity.role,
+            tool: parsed.toolName,
+            routerId: router.id,
+            phase: "success",
+            params: parsed.params,
+            durationMs: elapsed
+          }, context.appConfig.auditLogPath);
+          return { routerId: router.id, status: "ok", result, durationMs: elapsed };
+        } catch (err) {
+          const elapsed = Date.now() - start;
+          const message = err instanceof Error ? err.message : String(err);
+          if (journalId) {
+            recordOutcome({ journalPath, journalId, phase: "failure", outcome: message, durationMs: elapsed });
           }
+          auditLog({
+            type: "audit",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            correlationId: context.correlationId,
+            identityId: context.identity.id,
+            role: context.identity.role,
+            tool: parsed.toolName,
+            routerId: router.id,
+            phase: "failure",
+            params: parsed.params,
+            outcome: message,
+            durationMs: elapsed
+          }, context.appConfig.auditLogPath);
+          return { routerId: router.id, status: "error", error: message, durationMs: elapsed };
         }
       }
-      if (!tool.annotations.readOnlyHint && config.journalPath) {
-        journalId = recordAttempt({
-          journalPath: config.journalPath,
-          identityId: identity.id,
-          role: identity.role,
-          tool: tool.name,
-          routerId: routerId2,
-          params: handlerArgs,
-          snapshotIds
-        });
-      }
-      const runHandler = () => tool.handler(handlerArgs, toolContext);
-      const executeHandler = () => cb.execute(
-        tool.annotations.readOnlyHint ? () => withRetry(runHandler, config.retry) : runHandler
-      );
-      const result = await executeHandler();
-      if (journalId) {
-        recordOutcome({
-          journalPath: config.journalPath,
-          journalId,
-          phase: "success",
-          durationMs: Date.now() - startMs
-        });
-      }
-      if (shouldAudit) {
-        auditLog({
-          type: "audit",
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          correlationId,
-          identityId: identity.id,
-          role: identity.role,
-          tool: tool.name,
-          routerId: routerId2,
-          phase: "success",
-          params: args,
-          durationMs: Date.now() - startMs
-        }, config.auditLogPath);
+      const results2 = [...preErrors];
+      for (let i = 0; i < routers.length; i += parsed.concurrency) {
+        const batch = routers.slice(i, i + parsed.concurrency);
+        const batchResults = await Promise.all(batch.map(runForRouter));
+        results2.push(...batchResults);
       }
-      log48.info({ tool: tool.name, routerId: routerId2, correlationId }, "Tool executed successfully");
-      recordToolCall(tool.name, "success");
-      return formatToolResult(result);
-    } catch (err) {
-      const error = err instanceof MikroMCPError ? err : enrichError(err, { tool: tool.name });
-      if (error.category === "ROUTER_AUTH_FAILED" /* ROUTER_AUTH_FAILED */) {
-        const failedRouterId = args.routerId;
-        if (failedRouterId) {
-          pool.removeClient(failedRouterId);
-          log48.info({ routerId: failedRouterId }, "Evicted pooled client after auth failure");
+      const succeeded = results2.filter((r) => r.status === "ok").length;
+      const failed = results2.filter((r) => r.status === "error").length;
+      auditLog({
+        type: "audit",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        correlationId: context.correlationId,
+        identityId: context.identity.id,
+        role: context.identity.role,
+        tool: "bulk_execute",
+        routerId: "(fleet)",
+        phase: "success",
+        params: { toolName: parsed.toolName, succeeded, failed }
+      }, context.appConfig.auditLogPath);
+      return {
+        content: `Executed ${parsed.toolName} on ${results2.length} routers: ${succeeded} succeeded, ${failed} failed`,
+        structuredContent: {
+          toolName: parsed.toolName,
+          totalRouters: results2.length,
+          succeeded,
+          failed,
+          results: results2
         }
-      }
-      if (journalId) {
-        recordOutcome({
-          journalPath: config.journalPath,
-          journalId,
-          phase: "failure",
-          outcome: error.code,
-          durationMs: Date.now() - startMs
-        });
-      }
-      const shouldAudit = tool.annotations.destructiveHint || !tool.annotations.readOnlyHint;
-      if (shouldAudit && error.category !== "APPROVAL_REQUIRED" /* APPROVAL_REQUIRED */) {
-        const routerId2 = args.routerId ?? "unknown";
-        const identity = getCurrentIdentity() ?? getStdioIdentity(config.stdioIdentity, identityRegistry);
-        auditLog({
-          type: "audit",
-          ts: (/* @__PURE__ */ new Date()).toISOString(),
-          correlationId,
-          identityId: identity.id,
-          role: identity.role,
-          tool: tool.name,
-          routerId: routerId2,
-          phase: "failure",
-          params: args,
-          outcome: error.code,
-          durationMs: Date.now() - startMs
-        }, config.auditLogPath);
-      }
-      log48.error({ err: error, tool: tool.name, correlationId }, "Tool execution failed");
-      recordToolCall(tool.name, "error");
-      return formatError(error);
+      };
     }
-  });
+  };
+  return [checkRouterHealthTool, bulkExecuteTool, listRoutersTool];
 }
 
+// src/domain/tools/index.ts
+var baseTools = [
+  ...systemTools,
+  ...interfaceTools,
+  ...ipTools,
+  ...dhcpTools,
+  ...routeTools,
+  ...firewallTools,
+  ...diagnosticTools,
+  ...systemOpsTools,
+  ...bridgeTools,
+  ...wifiTools,
+  ...wireguardTools,
+  ...dnsTools,
+  ...mangleTools,
+  ...addressListTools,
+  ...policyRoutingTools,
+  ...routingProtocolTools,
+  ...scriptsTools,
+  ...schedulerTools,
+  ...packagesTools,
+  ...filesTools,
+  ...containerTools,
+  ...ipsecTools,
+  ...certificateTools,
+  ...userTools,
+  ...userGroupTools,
+  ...dhcpServerTools,
+  ...ipPoolTools,
+  ...queueTools,
+  ...vrrpTools,
+  ...networkServicesTools,
+  ...vlanTools,
+  ...dhcpClientTools,
+  ...ipServiceTools,
+  ...pppoeTools,
+  ...ovpnTools,
+  ...pppTools,
+  ...upgradeTools,
+  ...backupTools,
+  ...logTools,
+  ...networkTestTools,
+  ...containerConfigTools,
+  ...interfaceListTools
+];
+var allTools = [
+  ...baseTools,
+  ...createChangeManagementTools(baseTools),
+  ...createFleetTools(baseTools)
+];
+
 // src/mcp/tool-registry.ts
 var log49 = createLogger("tool-registry");
 function registerAllTools(server, registry, pool, circuitBreakers, config, identityRegistry) {
@@ -12280,11 +12597,40 @@ ${issues}`);
   }
 };
 
+// src/adapter/connection-pool.ts
+import { createHash as createHash5 } from "crypto";
+
 // src/adapter/rest-client.ts
-import { request, Agent } from "undici";
+import { request, Agent as Agent2 } from "undici";
 
 // src/adapter/tls-manager.ts
 import { readFileSync as readFileSync3 } from "fs";
+import { buildConnector } from "undici";
+function makePinnedConnector(inner, expectedFingerprint) {
+  const expected = expectedFingerprint.replace(/:/g, "").toLowerCase();
+  return (opts, cb) => {
+    inner(opts, (err, socket) => {
+      if (err || !socket) {
+        cb(err ?? new Error("TLS connection failed"), null);
+        return;
+      }
+      const peer = socket;
+      const cert = typeof peer.getPeerCertificate === "function" ? peer.getPeerCertificate() : void 0;
+      const actual = (cert?.fingerprint256 ?? "").replace(/:/g, "").toLowerCase();
+      if (actual !== expected) {
+        socket.destroy();
+        cb(
+          new Error(
+            `TLS certificate fingerprint mismatch. Expected: ${expected}, got: ${actual || "none"}`
+          ),
+          null
+        );
+        return;
+      }
+      cb(null, socket);
+    });
+  };
+}
 function buildAgentOptions(tls) {
   if (!tls.enabled) {
     return {};
@@ -12296,53 +12642,14 @@ function buildAgentOptions(tls) {
     connectOptions.ca = readFileSync3(tls.ca, "utf-8");
   }
   if (tls.fingerprint) {
-    const expected = tls.fingerprint.replace(/:/g, "").toLowerCase();
-    connectOptions.checkServerIdentity = (_host, cert) => {
-      const actual = cert.fingerprint256.replace(/:/g, "").toLowerCase();
-      if (actual !== expected) {
-        return new Error(
-          `TLS certificate fingerprint mismatch. Expected: ${expected}, got: ${actual}`
-        );
-      }
-      return void 0;
-    };
+    const inner = buildConnector(connectOptions);
+    return { connect: makePinnedConnector(inner, tls.fingerprint) };
   }
   return {
     connect: connectOptions
   };
 }
 
-// src/adapter/response-parser.ts
-var NUMERIC_RE = /^-?\d+(\.\d+)?$/;
-var DURATION_RE = /^\d+[wdhms](\d+[wdhms])*$/;
-function parseRouterOSValue(key2, value) {
-  if (key2 === ".id") {
-    return value;
-  }
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (DURATION_RE.test(value)) {
-    return value;
-  }
-  if (NUMERIC_RE.test(value)) {
-    const num = Number(value);
-    if (Number.isFinite(num)) {
-      return num;
-    }
-  }
-  return value;
-}
-function parseRecord(raw) {
-  const parsed = {};
-  for (const [key2, value] of Object.entries(raw)) {
-    parsed[key2] = parseRouterOSValue(key2, value);
-  }
-  return parsed;
-}
-function parseRecords(raw) {
-  return raw.map((r) => parseRecord(r));
-}
-
 // src/adapter/query-builder.ts
 function buildListQuery(options) {
   if (!options) {
@@ -12404,7 +12711,7 @@ var RouterOSRestClient = class {
     const scheme = config.tls.enabled ? "https" : "http";
     this.baseUrl = `${scheme}://${config.host}:${config.port}/rest`;
     this.authHeader = "Basic " + Buffer.from(`${credentials.username}:${credentials.password}`).toString("base64");
-    this.agent = new Agent(buildAgentOptions(config.tls));
+    this.agent = new Agent2(buildAgentOptions(config.tls));
   }
   // ---------- public CRUD methods ----------
   /**
@@ -12497,19 +12804,27 @@ var RouterOSRestClient = class {
 };
 
 // src/adapter/connection-pool.ts
+function credentialHash(credentials) {
+  return createHash5("sha256").update(`${credentials.username}\0${credentials.password}`).digest("hex");
+}
 var ConnectionPool = class {
   clients = /* @__PURE__ */ new Map();
   /**
-   * Get an existing client for the given router or create a new one.
-   * Clients are keyed by `config.id`.
+   * Get an existing client for the given router or create a new one. Clients are
+   * keyed by `config.id`, but a client whose credentials no longer match the
+   * request is closed and rebuilt so rotated credentials take effect.
    */
   getClient(config, credentials) {
+    const credHash = credentialHash(credentials);
     const existing = this.clients.get(config.id);
     if (existing) {
-      return existing;
+      if (existing.credHash === credHash) {
+        return existing.client;
+      }
+      existing.client.close();
     }
     const client = new RouterOSRestClient(config, credentials);
-    this.clients.set(config.id, client);
+    this.clients.set(config.id, { client, credHash });
     return client;
   }
   /**
@@ -12517,12 +12832,12 @@ var ConnectionPool = class {
    * `/rest/system/resource`. Returns `true` if the request succeeds.
    */
   async healthCheck(routerId2) {
-    const client = this.clients.get(routerId2);
-    if (!client) {
+    const entry = this.clients.get(routerId2);
+    if (!entry) {
       return false;
     }
     try {
-      await client.get("system/resource");
+      await entry.client.get("system/resource");
       return true;
     } catch {
       return false;
@@ -12530,23 +12845,23 @@ var ConnectionPool = class {
   }
   /** Remove and close a single client by router ID. */
   removeClient(routerId2) {
-    const client = this.clients.get(routerId2);
-    if (client) {
-      client.close();
+    const entry = this.clients.get(routerId2);
+    if (entry) {
+      entry.client.close();
       this.clients.delete(routerId2);
     }
   }
   /** Close and remove all clients. */
   closeAll() {
-    for (const [id, client] of this.clients) {
-      client.close();
+    for (const [id, entry] of this.clients) {
+      entry.client.close();
       this.clients.delete(id);
     }
   }
 };
 
 // src/version.ts
-var VERSION = "1.7.0";
+var VERSION = "1.8.0";
 
 // src/mcp/server.ts
 var SERVER_INSTRUCTIONS = [
@@ -12589,6 +12904,7 @@ import { createServer } from "http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 var log51 = createLogger("transport-http");
+var SESSION_TTL_MS = 30 * 6e4;
 var BodyTooLargeError = class extends Error {
   constructor() {
     super("Request body exceeds maximum allowed size");
@@ -12625,7 +12941,7 @@ function createRateLimiter(rpm) {
 }
 async function readBody(req, maxBytes) {
   return new Promise((resolve, reject) => {
-    let data = "";
+    const chunks = [];
     let size = 0;
     let settled = false;
     const fail2 = (err) => {
@@ -12640,11 +12956,12 @@ async function readBody(req, maxBytes) {
         fail2(new BodyTooLargeError());
         return;
       }
-      data += chunk.toString();
+      chunks.push(chunk);
     });
     req.on("end", () => {
       if (settled) return;
       settled = true;
+      const data = Buffer.concat(chunks).toString("utf-8");
       if (!data) {
         resolve(void 0);
         return;
@@ -12665,6 +12982,17 @@ async function connectHttp(makeServer, config, identityRegistry) {
   sweepTimer.unref();
   const streamableSessions = /* @__PURE__ */ new Map();
   const sseTransports = /* @__PURE__ */ new Map();
+  const sessionSweep = setInterval(() => {
+    const now = Date.now();
+    for (const [id, session] of streamableSessions) {
+      if (now - session.lastSeenMs > SESSION_TTL_MS) {
+        streamableSessions.delete(id);
+        session.transport.close();
+        log51.info({ sessionId: id }, "Streamable HTTP session expired (idle TTL)");
+      }
+    }
+  }, 6e4);
+  sessionSweep.unref();
   const httpServer = createServer(async (req, res) => {
     const ip = req.socket.remoteAddress ?? "unknown";
     const url = new URL(req.url ?? "/", `http://localhost:${port}`);
@@ -12675,6 +13003,21 @@ async function connectHttp(makeServer, config, identityRegistry) {
       return;
     }
     if (pathname === "/metrics") {
+      if (identityRegistry.getIdentities().length > 0) {
+        try {
+          await authenticateHttp(req, identityRegistry);
+        } catch (err) {
+          if (err instanceof MikroMCPError) {
+            res.writeHead(401, {
+              "Content-Type": "application/json",
+              "WWW-Authenticate": "Bearer"
+            });
+            res.end(JSON.stringify({ error: err.message, code: err.code }));
+            return;
+          }
+          throw err;
+        }
+      }
       res.writeHead(200, { "Content-Type": "text/plain; version=0.0.4; charset=utf-8" });
       res.end(renderPrometheus());
       return;
@@ -12692,14 +13035,18 @@ async function connectHttp(makeServer, config, identityRegistry) {
           identity = await authenticateHttp(req, identityRegistry);
         } catch (err) {
           if (err instanceof MikroMCPError) {
-            res.writeHead(401, { "Content-Type": "application/json" });
+            res.writeHead(401, {
+              "Content-Type": "application/json",
+              "WWW-Authenticate": "Bearer"
+            });
             res.end(JSON.stringify({ error: err.message, code: err.code }));
             return;
           }
           throw err;
         }
-        await withIdentity(identity, async () => {
-          await handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, makeServer, streamableSessions, sseTransports);
+        const boundIdentity = identity;
+        await withIdentity(boundIdentity, async () => {
+          await handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, makeServer, streamableSessions, sseTransports, boundIdentity.id);
         });
         return;
       }
@@ -12728,7 +13075,10 @@ async function connectHttp(makeServer, config, identityRegistry) {
       }
     }
   });
-  httpServer.on("close", () => clearInterval(sweepTimer));
+  httpServer.on("close", () => {
+    clearInterval(sweepTimer);
+    clearInterval(sessionSweep);
+  });
   await new Promise((resolve, reject) => {
     httpServer.listen(port, bindHost, () => {
       log51.info(
@@ -12741,10 +13091,19 @@ async function connectHttp(makeServer, config, identityRegistry) {
   });
   return httpServer;
 }
-async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, makeServer, streamableSessions, sseTransports) {
+async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, makeServer, streamableSessions, sseTransports, identityId) {
   if (pathname === "/mcp") {
     const sessionId = req.headers["mcp-session-id"];
-    let transport2 = sessionId ? streamableSessions.get(sessionId) : void 0;
+    let session = sessionId ? streamableSessions.get(sessionId) : void 0;
+    if (session) {
+      if (session.identityId !== identityId) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Session belongs to a different identity." }));
+        return;
+      }
+      session.lastSeenMs = Date.now();
+    }
+    let transport2 = session?.transport;
     if (!transport2) {
       if (sessionId) {
         res.writeHead(404, { "Content-Type": "application/json" });
@@ -12754,8 +13113,8 @@ async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, mak
       transport2 = new StreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (id) => {
-          streamableSessions.set(id, transport2);
-          log51.info({ sessionId: id }, "Streamable HTTP session created");
+          streamableSessions.set(id, { transport: transport2, identityId, lastSeenMs: Date.now() });
+          log51.info({ sessionId: id, identityId }, "Streamable HTTP session created");
         }
       });
       transport2.onclose = () => {
@@ -12798,6 +13157,7 @@ async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, mak
 
 // src/config/identity-registry.ts
 import { readFileSync as readFileSync4, existsSync as existsSync2 } from "fs";
+import { createHash as createHash6 } from "crypto";
 import { parse as parse2 } from "yaml";
 import { z as z49 } from "zod";
 import bcrypt from "bcryptjs";
@@ -12813,6 +13173,9 @@ var ConfigFileSchema2 = z49.object({
 }).strict();
 var IdentityRegistry = class {
   identities = [];
+  // Maps sha256(token) → resolved identity id. Avoids a bcrypt compare against
+  // every identity on each authenticated request after the first match.
+  tokenCache = /* @__PURE__ */ new Map();
   constructor(configPath) {
     if (!existsSync2(configPath)) {
       log52.warn(
@@ -12849,15 +13212,24 @@ ${issues}`);
     }));
   }
   async findIdentityByToken(token) {
+    const cacheKey = createHash6("sha256").update(token).digest("hex");
+    const toIdentity = (stored) => ({
+      id: stored.id,
+      role: stored.role,
+      allowedRouters: stored.allowedRouters,
+      allowedToolPatterns: stored.allowedToolPatterns
+    });
+    const cachedId = this.tokenCache.get(cacheKey);
+    if (cachedId !== void 0) {
+      const stored = this.identities.find((i) => i.id === cachedId);
+      if (stored) return toIdentity(stored);
+      this.tokenCache.delete(cacheKey);
+    }
     for (const stored of this.identities) {
       const match = await bcrypt.compare(token, stored.tokenHash);
       if (match) {
-        return {
-          id: stored.id,
-          role: stored.role,
-          allowedRouters: stored.allowedRouters,
-          allowedToolPatterns: stored.allowedToolPatterns
-        };
+        this.tokenCache.set(cacheKey, stored.id);
+        return toIdentity(stored);
       }
     }
     return null;
@@ -12957,7 +13329,7 @@ import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
 import * as net from "net";
 import chalk from "chalk";
-var localVersion = "1.7.0";
+var localVersion = "1.8.0";
 var results = [];
 function ok(msg) {
   console.log(chalk.green("\u2705 ") + msg);
@@ -13669,7 +14041,7 @@ async function runInit() {
 }
 
 // src/cli/index.ts
-var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.7.0");
+var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.8.0");
 program.command("serve", { isDefault: true }).description("Start the MCP server (default)").action(runServe);
 program.command("doctor").description("Check config, connectivity, and permissions").action(runDoctor);
 program.command("init").description("Interactive setup wizard").action(runInit);