mikromcp 1.0.9 → 1.1.0

package/dist/main.js

@@ -3,7 +3,7 @@
 // src/main.ts
 import { config as loadDotenv } from "dotenv";
 import { join as join5 } from "path";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir4 } from "os";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -50,9 +50,8 @@ function loadAppConfig() {
       failureThreshold: 5,
       cooldownMs: 3e4
     },
-    pagination: {
-      defaultLimit: 100,
-      maxLimit: 500
+    retention: {
+      snapshotMaxAgeDays: parseInt(env.MIKROMCP_SNAPSHOT_RETENTION_DAYS ?? "30", 10)
     }
   };
 }
@@ -371,8 +370,8 @@ function buildTextSummary(sections) {
   if (sections.health) {
     const h = sections.health;
     lines.push(`Health:`);
-    for (const [key, value] of Object.entries(h)) {
-      if (key !== ".id") lines.push(`  ${key}: ${value}`);
+    for (const [key2, value] of Object.entries(h)) {
+      if (key2 !== ".id") lines.push(`  ${key2}: ${value}`);
     }
   }
   if (sections.clock) {
@@ -493,9 +492,9 @@ var listInterfacesTool = {
       const paginated = interfaces.slice(parsed.offset, parsed.offset + parsed.limit);
       const results2 = parsed.includeCounters ? paginated : paginated.map((iface) => {
         const cleaned = {};
-        for (const [key, value] of Object.entries(iface)) {
-          if (!COUNTER_PROPS.includes(key)) {
-            cleaned[key] = value;
+        for (const [key2, value] of Object.entries(iface)) {
+          if (!COUNTER_PROPS.includes(key2)) {
+            cleaned[key2] = value;
           }
         }
         return cleaned;
@@ -2112,8 +2111,8 @@ var runCommandTool = {
   async handler(params, context) {
     const parsed = runCommandInputSchema.parse(params);
     log8.info({ routerId: context.routerId, command: parsed.command }, "Running command");
-    const globalAllow = (process.env.MIKROMCP_CMD_ALLOW ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-    const globalDeny = (process.env.MIKROMCP_CMD_DENY ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    const globalAllow = context.appConfig.cmdAllow;
+    const globalDeny = context.appConfig.cmdDeny;
     const policy = resolveCommandPolicy(context.routerConfig, globalAllow, globalDeny);
     checkCommand(parsed.command, policy);
     if (parsed.dryRun) {
@@ -2711,9 +2710,9 @@ var listPeersTool = {
       const lines = [`WireGuard peers on ${context.routerId}: ${total} total`];
       for (const peer of peers) {
         const rec = peer;
-        const key = rec["public-key"] ? rec["public-key"].slice(0, 8) + "\u2026" : "unknown";
+        const key2 = rec["public-key"] ? rec["public-key"].slice(0, 8) + "\u2026" : "unknown";
         lines.push(
-          `  [${rec.interface ?? "?"}] ${key} last-handshake=${rec["last-handshake"] ?? "never"}`
+          `  [${rec.interface ?? "?"}] ${key2} last-handshake=${rec["last-handshake"] ?? "never"}`
         );
       }
       return {
@@ -4905,12 +4904,10 @@ var containerTools = [listContainersTool, manageContainerTool];
 
 // src/domain/tools/change-management-tools.ts
 import { z as z23 } from "zod";
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
+import { readFileSync } from "fs";
 
 // src/domain/snapshot/snapshot-engine.ts
-import { mkdirSync, writeFileSync, readFileSync } from "fs";
+import { mkdir, writeFile, readFile } from "fs/promises";
 import { join as join2 } from "path";
 import { nanoid } from "nanoid";
 function pathToSlug(rosPath) {
@@ -4925,13 +4922,13 @@ async function takeSnapshot(client, routerId, path, snapshotDir) {
   const dir = join2(snapshotDir, routerId);
   const filePath = join2(dir, `${id}.json`);
   const ts = (/* @__PURE__ */ new Date()).toISOString();
-  mkdirSync(dir, { recursive: true });
+  await mkdir(dir, { recursive: true });
   const stored = { id, routerId, path, ts, records };
-  writeFileSync(filePath, JSON.stringify(stored, null, 2));
+  await writeFile(filePath, JSON.stringify(stored, null, 2));
   return { id, routerId, path, ts, filePath, recordCount: records.length };
 }
-function loadSnapshot(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf-8"));
+async function loadSnapshot(filePath) {
+  return JSON.parse(await readFile(filePath, "utf-8"));
 }
 
 // src/domain/snapshot/diff-engine.ts
@@ -4951,7 +4948,16 @@ var SEMANTIC_KEYS = {
   "system/scheduler": ["name"],
   "system/script": ["name"],
   "system/package": ["name"],
-  "container": ["name"]
+  "container": ["name"],
+  "certificate": ["name"],
+  "file": ["name"],
+  "interface/vrrp": ["name"],
+  "ip/dhcp-server": ["name"],
+  "ip/ipsec/peer": ["name"],
+  "ip/pool": ["name"],
+  "queue/simple": ["name"],
+  "tool/netwatch": ["host"],
+  "user": ["name"]
 };
 function normalizeValue(v) {
   if (v === "true" || v === "yes") return "true";
@@ -4986,8 +4992,8 @@ function computeRestorePlan(path, before, current) {
   const beforeByKey = new Map(before.map((r) => [semanticKey(r, keys), r]));
   const toCreate = [];
   const toUpdate = [];
-  for (const [key, beforeRecord] of beforeByKey) {
-    const currentRecord = currentByKey.get(key);
+  for (const [key2, beforeRecord] of beforeByKey) {
+    const currentRecord = currentByKey.get(key2);
     if (!currentRecord) {
       toCreate.push(beforeRecord);
     } else if (!recordsAreEqual(beforeRecord, currentRecord)) {
@@ -5012,52 +5018,63 @@ async function applyRestorePlan(plan, client) {
 }
 
 // src/domain/snapshot/write-journal.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { appendFile as appendFile2, mkdir as mkdir2 } from "fs/promises";
 import { dirname } from "path";
 import { nanoid as nanoid2 } from "nanoid";
 
 // src/observability/audit-log.ts
-import { appendFileSync } from "fs";
+import { appendFile } from "fs/promises";
 var log22 = createLogger("audit");
-var SENSITIVE_KEYS = /* @__PURE__ */ new Set(["password", "token", "secret", "authorization", "credentials"]);
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "password",
+  "pass",
+  "token",
+  "secret",
+  "authorization",
+  "credentials",
+  "privatekey",
+  "presharedkey",
+  "psk",
+  "passphrase",
+  "community",
+  "apikey",
+  "confirmationsecret"
+]);
 function redactParams(params) {
   const out = {};
-  for (const [key, value] of Object.entries(params)) {
-    if (SENSITIVE_KEYS.has(key)) continue;
+  for (const [key2, value] of Object.entries(params)) {
+    if (SENSITIVE_KEYS.has(key2.toLowerCase())) continue;
     if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      out[key] = redactParams(value);
+      out[key2] = redactParams(value);
     } else {
-      out[key] = value;
+      out[key2] = value;
     }
   }
   return out;
 }
-var auditFilePath = process.env.MIKROMCP_AUDIT_LOG_PATH || void 0;
-function auditLog(event) {
+function auditLog(event, auditLogPath) {
   const safeEvent = { ...event, params: redactParams(event.params) };
   log22.info(safeEvent, "audit");
-  if (auditFilePath) {
-    try {
-      appendFileSync(auditFilePath, JSON.stringify(safeEvent) + "\n");
-    } catch (err) {
-      log22.error({ err, auditFilePath }, "Failed to write audit event to file");
-    }
+  if (auditLogPath) {
+    appendFile(auditLogPath, JSON.stringify(safeEvent) + "\n").catch((err) => {
+      log22.error({ err, auditLogPath }, "Failed to write audit event to file");
+    });
   }
 }
 
 // src/domain/snapshot/write-journal.ts
 var log23 = createLogger("write-journal");
-function appendLine(filePath, obj) {
+async function appendLine(filePath, obj) {
   try {
-    mkdirSync2(dirname(filePath), { recursive: true });
-    appendFileSync2(filePath, JSON.stringify(obj) + "\n");
+    await mkdir2(dirname(filePath), { recursive: true });
+    await appendFile2(filePath, JSON.stringify(obj) + "\n");
   } catch (err) {
     log23.error({ err, filePath }, "Failed to write to write journal");
   }
 }
 function recordAttempt(args) {
   const id = nanoid2();
-  appendLine(args.journalPath, {
+  void appendLine(args.journalPath, {
     id,
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     identityId: args.identityId,
@@ -5071,7 +5088,7 @@ function recordAttempt(args) {
   return id;
 }
 function recordOutcome(args) {
-  appendLine(args.journalPath, {
+  void appendLine(args.journalPath, {
     id: args.journalId,
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     phase: args.phase,
@@ -5185,9 +5202,8 @@ function createChangeManagementTools(baseTools2) {
     async handler(params, context) {
       const parsed = applyPlanInputSchema.parse(params);
       log24.info({ routerId: context.routerId, stepCount: parsed.steps.length }, "Applying plan");
-      const dataDir = process.env.MIKROMCP_DATA_DIR ?? join3(homedir2(), ".mikromcp", "data");
-      const journalPath = `${dataDir}/write-journal.ndjson`;
-      const snapshotDir = `${dataDir}/snapshots`;
+      const journalPath = context.appConfig.journalPath;
+      const snapshotDir = context.appConfig.snapshotDir;
       const results2 = [];
       for (const [i, step] of parsed.steps.entries()) {
         const tool = requireTool(step.tool);
@@ -5212,9 +5228,11 @@ function createChangeManagementTools(baseTools2) {
           params: stepParams,
           snapshotIds
         });
+        const stepStartMs = Date.now();
         try {
-          const result = await tool.handler(stepParams, context);
-          recordOutcome({ journalPath, journalId: stepJournalId, phase: "success", durationMs: 0 });
+          const runStep = () => tool.handler(stepParams, context);
+          const result = context.circuitBreaker ? await context.circuitBreaker.execute(runStep) : await runStep();
+          recordOutcome({ journalPath, journalId: stepJournalId, phase: "success", durationMs: Date.now() - stepStartMs });
           results2.push({
             stepIndex: i,
             tool: step.tool,
@@ -5224,7 +5242,7 @@ function createChangeManagementTools(baseTools2) {
           });
         } catch (err) {
           const error = err instanceof MikroMCPError ? err : enrichError(err, { tool: step.tool });
-          recordOutcome({ journalPath, journalId: stepJournalId, phase: "failure", outcome: error.code, durationMs: 0 });
+          recordOutcome({ journalPath, journalId: stepJournalId, phase: "failure", outcome: error.code, durationMs: Date.now() - stepStartMs });
           log24.error({ err: error, tool: step.tool, step: i }, "apply_plan step failed");
           return {
             content: `Apply failed at step ${i + 1}/${parsed.steps.length} (${step.tool}): ${error.message}. ${i} step(s) completed before failure.`,
@@ -5250,7 +5268,7 @@ function createChangeManagementTools(baseTools2) {
     }
   };
   function findJournalEntry(journalPath, journalId) {
-    const raw = readFileSync2(journalPath, "utf-8");
+    const raw = readFileSync(journalPath, "utf-8");
     const lines = raw.split("\n").filter(Boolean);
     const entry = lines.map((l) => JSON.parse(l)).find((e) => e.id === journalId && e.phase === "attempt");
     if (!entry) {
@@ -5279,9 +5297,8 @@ function createChangeManagementTools(baseTools2) {
     },
     async handler(params, context) {
       const parsed = rollbackChangeInputSchema.parse(params);
-      const dataDir = process.env.MIKROMCP_DATA_DIR ?? join3(homedir2(), ".mikromcp", "data");
-      const journalPath = `${dataDir}/write-journal.ndjson`;
-      const snapshotDir = `${dataDir}/snapshots`;
+      const journalPath = context.appConfig.journalPath;
+      const snapshotDir = context.appConfig.snapshotDir;
       log24.info({ routerId: context.routerId, journalId: parsed.journalId }, "Rolling back change");
       const { snapshotIds } = findJournalEntry(journalPath, parsed.journalId);
       if (snapshotIds.length === 0) {
@@ -5293,7 +5310,7 @@ function createChangeManagementTools(baseTools2) {
       const restorePlans = [];
       for (const snapshotId of snapshotIds) {
         const filePath = `${snapshotDir}/${context.routerId}/${snapshotId}.json`;
-        const stored = loadSnapshot(filePath);
+        const stored = await loadSnapshot(filePath);
         const current = await context.routerClient.get(stored.path, {});
         const plan = computeRestorePlan(stored.path, stored.records, current);
         restorePlans.push(plan);
@@ -7284,6 +7301,51 @@ function checkAuthz(identity, toolName, routerId) {
   }
 }
 
+// src/config/secrets.ts
+function getCredentials(router) {
+  const { source, envPrefix, vaultPath } = router.credentials;
+  if (source === "vault") {
+    throw new MikroMCPError({
+      category: "CONFIGURATION" /* CONFIGURATION */,
+      code: "VAULT_NOT_SUPPORTED",
+      message: `Vault credential source is not supported in v0.1 (vaultPath=${vaultPath ?? "n/a"})`,
+      recoverability: {
+        retryable: false,
+        suggestedAction: 'Switch to source="env" and provide credentials via environment variables.'
+      }
+    });
+  }
+  if (!envPrefix) {
+    throw new MikroMCPError({
+      category: "CONFIGURATION" /* CONFIGURATION */,
+      code: "MISSING_ENV_PREFIX",
+      message: `Router "${router.id}" uses source="env" but no envPrefix is configured`,
+      recoverability: {
+        retryable: false,
+        suggestedAction: "Set envPrefix in the router configuration."
+      }
+    });
+  }
+  const userKey = `${envPrefix}_USER`;
+  const passKey = `${envPrefix}_PASS`;
+  const username = process.env[userKey];
+  const password = process.env[passKey];
+  if (!username || !password) {
+    const missing = [!username ? userKey : null, !password ? passKey : null].filter(Boolean);
+    throw new MikroMCPError({
+      category: "CONFIGURATION" /* CONFIGURATION */,
+      code: "MISSING_CREDENTIALS",
+      message: `Missing environment variable(s) for router "${router.id}": ${missing.join(", ")}`,
+      details: { missing },
+      recoverability: {
+        retryable: false,
+        suggestedAction: `Set the ${missing.join(" and ")} environment variable(s).`
+      }
+    });
+  }
+  return { username, password };
+}
+
 // src/adapter/ssh-client.ts
 import { createHash } from "crypto";
 import { Client } from "ssh2";
@@ -7356,8 +7418,8 @@ var SshClient = class {
       };
       if (this.config.sshFingerprint) {
         const expected = this.config.sshFingerprint.toLowerCase();
-        connectOptions.hostVerifier = (key) => {
-          const actual = createHash("sha256").update(key).digest("hex");
+        connectOptions.hostVerifier = (key2) => {
+          const actual = createHash("sha256").update(key2).digest("hex");
           return actual === expected;
         };
       }
@@ -7413,51 +7475,6 @@ var FtpClient = class {
   }
 };
 
-// src/config/secrets.ts
-function getCredentials(router) {
-  const { source, envPrefix, vaultPath } = router.credentials;
-  if (source === "vault") {
-    throw new MikroMCPError({
-      category: "CONFIGURATION" /* CONFIGURATION */,
-      code: "VAULT_NOT_SUPPORTED",
-      message: `Vault credential source is not supported in v0.1 (vaultPath=${vaultPath ?? "n/a"})`,
-      recoverability: {
-        retryable: false,
-        suggestedAction: 'Switch to source="env" and provide credentials via environment variables.'
-      }
-    });
-  }
-  if (!envPrefix) {
-    throw new MikroMCPError({
-      category: "CONFIGURATION" /* CONFIGURATION */,
-      code: "MISSING_ENV_PREFIX",
-      message: `Router "${router.id}" uses source="env" but no envPrefix is configured`,
-      recoverability: {
-        retryable: false,
-        suggestedAction: "Set envPrefix in the router configuration."
-      }
-    });
-  }
-  const userKey = `${envPrefix}_USER`;
-  const passKey = `${envPrefix}_PASS`;
-  const username = process.env[userKey];
-  const password = process.env[passKey];
-  if (!username || !password) {
-    const missing = [!username ? userKey : null, !password ? passKey : null].filter(Boolean);
-    throw new MikroMCPError({
-      category: "CONFIGURATION" /* CONFIGURATION */,
-      code: "MISSING_CREDENTIALS",
-      message: `Missing environment variable(s) for router "${router.id}": ${missing.join(", ")}`,
-      details: { missing },
-      recoverability: {
-        retryable: false,
-        suggestedAction: `Set the ${missing.join(" and ")} environment variable(s).`
-      }
-    });
-  }
-  return { username, password };
-}
-
 // src/adapter/adapter-factory.ts
 function createSshClient(routerConfig, options) {
   const creds = getCredentials(routerConfig);
@@ -7468,6 +7485,82 @@ function createFtpClient(routerConfig) {
   return new FtpClient(routerConfig.host, 21, creds.username, creds.password);
 }
 
+// src/mcp/tool-context.ts
+function buildRouterToolContext(args) {
+  const { routerConfig, correlationId, identity, pool, config, registry } = args;
+  const credentials = getCredentials(routerConfig);
+  return {
+    routerClient: pool.getClient(routerConfig, credentials),
+    routerId: routerConfig.id,
+    correlationId,
+    routerConfig,
+    sshClient: createSshClient(routerConfig, config.ssh),
+    ftpClient: createFtpClient(routerConfig),
+    identity,
+    routerRegistry: registry,
+    connectionPool: pool,
+    appConfig: config
+  };
+}
+
+// src/middleware/fleet-confirmation.ts
+import { createHmac, createHash as createHash2 } 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");
+}
+function evictExpired() {
+  const now = /* @__PURE__ */ new Date();
+  for (const [token, entry] of pending) {
+    if (entry.expiresAt <= now) pending.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) {
+      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.",
+        recoverability: {
+          retryable: true,
+          suggestedAction: "Re-submit bulk_execute without confirmationToken to get a fresh token."
+        }
+      });
+    }
+    pending.delete(args.submittedToken);
+    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 });
+  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: expiresAt.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 log33 = createLogger("fleet-tools");
 var checkHealthInputSchema = z31.object({
@@ -7478,7 +7571,10 @@ var bulkExecuteInputSchema = z31.object({
   routerIds: z31.array(z31.string()).optional().describe("Explicit list of router IDs to target"),
   tags: z31.array(z31.string()).optional().describe("Target all routers with ALL of these tags (mutually exclusive with routerIds)"),
   params: z31.record(z31.string(), z31.unknown()).describe("Params to pass to the tool (omit routerId \u2014 injected per router)"),
-  concurrency: z31.number().int().min(1).max(20).default(5).describe("Max simultaneous router calls")
+  concurrency: z31.number().int().min(1).max(20).default(5).describe("Max simultaneous router calls"),
+  confirmationToken: z31.string().optional().describe(
+    "Fleet confirmation token from a prior APPROVAL_REQUIRED response. Required to fan out a destructive tool."
+  )
 }).strict();
 function createFleetTools(baseTools2) {
   const toolMap = new Map(baseTools2.map((t) => [t.name, t]));
@@ -7533,7 +7629,7 @@ function createFleetTools(baseTools2) {
   const bulkExecuteTool = {
     name: "bulk_execute",
     title: "Bulk Execute",
-    description: "Fan out a single-router tool to multiple routers in parallel (up to `concurrency` at a time). Target routers via explicit routerIds or by tag. Destructive tools are not allowed. Returns per-router results with succeeded/failed counts.",
+    description: "Fan out a single-router tool to multiple routers in parallel (up to `concurrency` at a time). Target routers via explicit routerIds or by tag. Non-destructive tools fan out immediately. Destructive tools require a two-step confirmation: call without `confirmationToken` to receive a fleet token (requires `MIKROMCP_CONFIRMATION_SECRET`), then re-call with that token to proceed. Returns per-router results with succeeded/failed counts.",
     inputSchema: bulkExecuteInputSchema,
     annotations: {
       readOnlyHint: false,
@@ -7561,6 +7657,17 @@ function createFleetTools(baseTools2) {
         { 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 */,
@@ -7585,17 +7692,6 @@ function createFleetTools(baseTools2) {
         });
       }
       const targetTool = foundTool;
-      if (targetTool.annotations.destructiveHint) {
-        throw new MikroMCPError({
-          category: "VALIDATION" /* VALIDATION */,
-          code: "BULK_DESTRUCTIVE_NOT_ALLOWED",
-          message: `Tool "${parsed.toolName}" is destructive. Destructive tools require per-router confirmation and cannot be fanned out via bulk_execute.`,
-          recoverability: {
-            retryable: false,
-            suggestedAction: "Call the tool directly on each router to provide the required confirmation token."
-          }
-        });
-      }
       const preErrors = [];
       let routers;
       if (hasRouterIds) {
@@ -7605,14 +7701,55 @@ function createFleetTools(baseTools2) {
             resolved.push(context.routerRegistry.getRouter(id));
           } catch {
             log33.warn({ routerId: id }, "bulk_execute: router not found");
-            preErrors.push({ routerId: id, status: "error", error: `Router "${id}" not found in registry`, durationMs: 0 });
+            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: {
@@ -7628,28 +7765,50 @@ function createFleetTools(baseTools2) {
         const start = Date.now();
         try {
           checkAuthz(context.identity, parsed.toolName, router.id);
-          const credentials = getCredentials(router);
-          const client = context.connectionPool.getClient(router, credentials);
-          const sshClient = createSshClient(router, {});
-          const ftpClient = createFtpClient(router);
-          const routerContext = {
-            routerClient: client,
-            routerId: router.id,
-            correlationId: context.correlationId,
+          const routerContext = buildRouterToolContext({
             routerConfig: router,
-            sshClient,
-            ftpClient,
-            identity: context.identity
-          };
+            correlationId: context.correlationId,
+            identity: context.identity,
+            pool: context.connectionPool,
+            config: context.appConfig,
+            registry: context.routerRegistry
+          });
           const toolParams = { ...parsed.params, routerId: router.id };
           const result = await targetTool.handler(
             toolParams,
             routerContext
           );
-          return { routerId: router.id, status: "ok", result, durationMs: Date.now() - start };
+          const elapsed = Date.now() - start;
+          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);
-          return { routerId: router.id, status: "error", error: message, durationMs: Date.now() - start };
+          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];
@@ -7660,6 +7819,17 @@ function createFleetTools(baseTools2) {
       }
       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: {
@@ -7712,217 +7882,63 @@ var allTools = [
   ...createFleetTools(baseTools)
 ];
 
-// 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 Error) {
-    const code = error.code;
-    if (code && RETRYABLE_CODES.has(code)) {
-      return true;
-    }
-    const statusCode = error.statusCode;
-    if (typeof statusCode === "number") {
-      return statusCode >= 500;
-    }
-  }
-  return false;
+// 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);
 }
-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;
+
+// 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 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/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 TRANSIENT_CATEGORIES.has(error.category);
-}
-var DEFAULTS2 = {
-  failureThreshold: 5,
-  cooldownMs: 3e4
-};
-var CircuitBreaker = class {
-  constructor(routerId, options) {
-    this.routerId = routerId;
-    this.options = { ...DEFAULTS2, ...options };
-  }
-  routerId;
-  options;
-  currentState = "closed";
-  consecutiveFailures = 0;
-  lastFailureTime = 0;
-  get state() {
-    if (this.currentState === "open") {
-      const elapsed = Date.now() - this.lastFailureTime;
-      if (elapsed >= this.options.cooldownMs) {
-        this.currentState = "half-open";
-      }
-    }
-    return this.currentState;
-  }
-  /**
-   * 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) {
-    const currentState = this.state;
-    if (currentState === "open") {
-      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
-        },
-        recoverability: {
-          retryable: true,
-          retryAfterMs: this.options.cooldownMs,
-          suggestedAction: "Wait for the circuit breaker cooldown period to expire, then retry."
-        }
-      });
-    }
-    try {
-      const result = await fn();
-      this.onSuccess();
-      return result;
-    } catch (error) {
-      if (isTransientFailure(error)) {
-        this.onFailure();
-      }
-      throw error;
-    }
-  }
-  /** Force the circuit back to the closed state. */
-  reset() {
-    this.currentState = "closed";
-    this.consecutiveFailures = 0;
-    this.lastFailureTime = 0;
-  }
-  // ---------- 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/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
-  };
-}
-
-// 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/mcp/tool-registry.ts
-import { nanoid as nanoid4 } from "nanoid";
-
-// 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;
+  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",
@@ -7951,19 +7967,19 @@ function getStdioIdentity(stdioIdentityName, registry) {
 }
 
 // src/middleware/confirmation.ts
-import { createHmac, createHash as createHash2 } from "crypto";
-var CONFIRMATION_TTL_MS = 5 * 60 * 1e3;
+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 createHash2("sha256").update(JSON.stringify(rest)).digest("hex");
+  return createHash3("sha256").update(JSON.stringify(rest)).digest("hex");
 }
 function computeToken(tool, routerId, identityId, paramHash, expiresAt, secret) {
   const payload = JSON.stringify({ tool, routerId, paramHash, identityId, expiresAt });
-  return createHmac("sha256", secret).update(payload).digest("hex");
+  return createHmac2("sha256", secret).update(payload).digest("hex");
 }
-function evictExpired() {
+function evictExpired2() {
   const now = /* @__PURE__ */ new Date();
   for (const [token, entry] of pendingConfirmations) {
     if (entry.expiresAt <= now) pendingConfirmations.delete(token);
@@ -7971,7 +7987,7 @@ function evictExpired() {
 }
 async function checkConfirmation(toolName, routerId, params, identity, secret) {
   if (BYPASS_ROLES.includes(identity.role)) return;
-  evictExpired();
+  evictExpired2();
   const submittedToken = typeof params.confirmationToken === "string" ? params.confirmationToken : null;
   if (submittedToken) {
     const entry = pendingConfirmations.get(submittedToken);
@@ -8001,7 +8017,7 @@ async function checkConfirmation(toolName, routerId, params, identity, secret) {
     pendingConfirmations.delete(submittedToken);
     return;
   }
-  const expiresAt = new Date(Date.now() + CONFIRMATION_TTL_MS).toISOString();
+  const expiresAt = new Date(Date.now() + CONFIRMATION_TTL_MS2).toISOString();
   const paramHash = computeParamHash(params);
   const token = computeToken(toolName, routerId, identity.id, paramHash, expiresAt, secret);
   pendingConfirmations.set(token, {
@@ -8028,6 +8044,49 @@ async function checkConfirmation(toolName, routerId, params, identity, secret) {
   });
 }
 
+// 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;
+    }
+  }
+  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 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",
@@ -8058,9 +8117,352 @@ function isWithinMaintenanceWindow(windows, now) {
   });
 }
 
+// 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
+  };
+}
+
+// src/observability/metrics.ts
+var toolCalls = /* @__PURE__ */ new Map();
+function key(tool, status) {
+  return `${tool}\0${status}`;
+}
+function recordToolCall(tool, status) {
+  const k = key(tool, status);
+  toolCalls.set(k, (toolCalls.get(k) ?? 0) + 1);
+}
+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";
+}
+
+// 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 TRANSIENT_CATEGORIES.has(error.category);
+}
+var DEFAULTS2 = {
+  failureThreshold: 5,
+  cooldownMs: 3e4
+};
+var CircuitBreaker = class {
+  constructor(routerId, options) {
+    this.routerId = routerId;
+    this.options = { ...DEFAULTS2, ...options };
+  }
+  routerId;
+  options;
+  currentState = "closed";
+  consecutiveFailures = 0;
+  lastFailureTime = 0;
+  probeInFlight = false;
+  get state() {
+    if (this.currentState === "open") {
+      const elapsed = Date.now() - this.lastFailureTime;
+      if (elapsed >= this.options.cooldownMs) {
+        this.currentState = "half-open";
+      }
+    }
+    return this.currentState;
+  }
+  /**
+   * 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) {
+    const currentState = this.state;
+    if (currentState === "open") {
+      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
+        },
+        recoverability: {
+          retryable: true,
+          retryAfterMs: this.options.cooldownMs,
+          suggestedAction: "Wait for the circuit breaker cooldown period to expire, then retry."
+        }
+      });
+    }
+    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;
+    }
+  }
+  /** 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 log34 = createLogger("tool-executor");
+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 routerId = args.routerId;
+      if (!routerId) {
+        throw new MikroMCPError({
+          category: "VALIDATION" /* VALIDATION */,
+          code: "MISSING_ROUTER_ID",
+          message: "routerId is required",
+          recoverability: {
+            retryable: false,
+            suggestedAction: "Provide a valid routerId parameter."
+          }
+        });
+      }
+      checkAuthz(identity, tool.name, routerId);
+      const routerConfig = registry.getRouter(routerId);
+      if (tool.annotations.destructiveHint) {
+        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 "${routerId}" 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."
+            }
+          });
+        }
+      }
+      if (tool.annotations.destructiveHint && config.confirmationSecret) {
+        await checkConfirmation(tool.name, routerId, 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,
+          phase: "attempt",
+          params: args
+        }, config.auditLogPath);
+      }
+      const toolContext = buildRouterToolContext({
+        routerConfig,
+        correlationId,
+        identity,
+        pool,
+        config,
+        registry
+      });
+      let cb = circuitBreakers.get(routerId);
+      if (!cb) {
+        cb = new CircuitBreaker(routerId, {
+          failureThreshold: config.circuitBreaker.failureThreshold,
+          cooldownMs: config.circuitBreaker.cooldownMs
+        });
+        circuitBreakers.set(routerId, cb);
+      }
+      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, routerId, path, config.snapshotDir);
+            snapshotIds.push(meta.id);
+            log34.debug({ snapshotId: meta.id, path }, "Snapshot taken");
+          } catch (err) {
+            log34.warn({ err, path, routerId }, "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,
+          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,
+          phase: "success",
+          params: args,
+          durationMs: Date.now() - startMs
+        }, config.auditLogPath);
+      }
+      log34.info({ tool: tool.name, routerId, 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);
+          log34.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 routerId = 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,
+          phase: "failure",
+          params: args,
+          outcome: error.code,
+          durationMs: Date.now() - startMs
+        }, config.auditLogPath);
+      }
+      log34.error({ err: error, tool: tool.name, correlationId }, "Tool execution failed");
+      recordToolCall(tool.name, "error");
+      return formatError(error);
+    }
+  });
+}
+
 // src/mcp/tool-registry.ts
-var log34 = createLogger("tool-registry");
+var log35 = createLogger("tool-registry");
 function registerAllTools(server, registry, pool, circuitBreakers, config, identityRegistry) {
+  const deps = { registry, pool, circuitBreakers, config, identityRegistry };
   for (const tool of allTools) {
     const registrationSchema = tool.annotations.destructiveHint ? tool.inputSchema.extend({
       confirmationToken: z32.string().optional().describe(
@@ -8075,193 +8477,18 @@ function registerAllTools(server, registry, pool, circuitBreakers, config, ident
         inputSchema: registrationSchema,
         annotations: tool.annotations
       },
-      async (args) => {
-        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
-              };
-              return formatToolResult(await tool.handler(args, fleetContext));
-            }
-            const routerId = args.routerId;
-            if (!routerId) {
-              throw new MikroMCPError({
-                category: "VALIDATION" /* VALIDATION */,
-                code: "MISSING_ROUTER_ID",
-                message: "routerId is required",
-                recoverability: {
-                  retryable: false,
-                  suggestedAction: "Provide a valid routerId parameter."
-                }
-              });
-            }
-            checkAuthz(identity, tool.name, routerId);
-            const routerConfig = registry.getRouter(routerId);
-            if (tool.annotations.destructiveHint) {
-              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 "${routerId}" 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."
-                  }
-                });
-              }
-            }
-            if (tool.annotations.destructiveHint && config.confirmationSecret) {
-              await checkConfirmation(tool.name, routerId, 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,
-                phase: "attempt",
-                params: args
-              });
-            }
-            const credentials = getCredentials(routerConfig);
-            const client = pool.getClient(routerConfig, credentials);
-            const sshClient = createSshClient(routerConfig, config.ssh);
-            const ftpClient = createFtpClient(routerConfig);
-            let cb = circuitBreakers.get(routerId);
-            if (!cb) {
-              cb = new CircuitBreaker(routerId, {
-                failureThreshold: config.circuitBreaker.failureThreshold,
-                cooldownMs: config.circuitBreaker.cooldownMs
-              });
-              circuitBreakers.set(routerId, 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(client, routerId, path, config.snapshotDir);
-                  snapshotIds.push(meta.id);
-                  log34.debug({ snapshotId: meta.id, path }, "Snapshot taken");
-                } catch (err) {
-                  log34.warn({ err, path, routerId }, "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,
-                params: handlerArgs,
-                snapshotIds
-              });
-            }
-            const runHandler = () => tool.handler(handlerArgs, {
-              routerClient: client,
-              routerId,
-              correlationId,
-              routerConfig,
-              sshClient,
-              ftpClient,
-              identity,
-              routerRegistry: registry,
-              connectionPool: pool
-            });
-            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,
-                phase: "success",
-                params: args,
-                durationMs: Date.now() - startMs
-              });
-            }
-            log34.info({ tool: tool.name, routerId, correlationId }, "Tool executed successfully");
-            return formatToolResult(result);
-          } catch (err) {
-            const error = err instanceof MikroMCPError ? err : enrichError(err, { tool: tool.name });
-            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 routerId = 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,
-                phase: "failure",
-                params: args,
-                outcome: error.code,
-                durationMs: Date.now() - startMs
-              });
-            }
-            log34.error({ err: error, tool: tool.name, correlationId }, "Tool execution failed");
-            return formatError(error);
-          }
-        });
-      }
+      (args) => executeToolCall(tool, args, deps)
     );
-    log34.debug({ tool: tool.name }, "Registered tool");
+    log35.debug({ tool: tool.name }, "Registered tool");
   }
-  log34.info({ count: allTools.length }, "All tools registered");
+  log35.info({ count: allTools.length }, "All tools registered");
 }
 
 // src/config/router-registry.ts
-import { readFileSync as readFileSync3, existsSync } from "fs";
+import { readFileSync as readFileSync2, existsSync } from "fs";
 import { parse } from "yaml";
 import { z as z33 } from "zod";
-var log35 = createLogger("router-registry");
+var log36 = createLogger("router-registry");
 var RouterConfigSchema = z33.object({
   host: z33.string().min(1, "host is required"),
   port: z33.number().int().min(1).max(65535),
@@ -8301,10 +8528,10 @@ var RouterRegistry = class {
   constructor(configPath) {
     this.routers = /* @__PURE__ */ new Map();
     if (!existsSync(configPath)) {
-      log35.warn({ configPath }, "Router config file not found; starting with empty registry");
+      log36.warn({ configPath }, "Router config file not found; starting with empty registry");
       return;
     }
-    const raw = readFileSync3(configPath, "utf-8");
+    const raw = readFileSync2(configPath, "utf-8");
     const parsed = parse(raw);
     const result = ConfigFileSchema.safeParse(parsed);
     if (!result.success) {
@@ -8315,14 +8542,14 @@ ${issues}`);
     for (const [id, config] of Object.entries(result.data.routers)) {
       const routerConfig = { ...config, id };
       if (routerConfig.tls.enabled && !routerConfig.tls.rejectUnauthorized) {
-        log35.warn(
+        log36.warn(
           { routerId: id },
           "TLS certificate validation is DISABLED (rejectUnauthorized=false). Set tls.fingerprint to pin the server certificate instead."
         );
       }
       this.routers.set(id, routerConfig);
     }
-    log35.info({ count: this.routers.size }, "Loaded routers from config");
+    log36.info({ count: this.routers.size }, "Loaded routers from config");
   }
   getRouter(id) {
     const router = this.routers.get(id);
@@ -8345,7 +8572,7 @@ ${issues}`);
 import { request, Agent } from "undici";
 
 // src/adapter/tls-manager.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 function buildAgentOptions(tls) {
   if (!tls.enabled) {
     return {};
@@ -8354,7 +8581,7 @@ function buildAgentOptions(tls) {
     rejectUnauthorized: tls.rejectUnauthorized
   };
   if (tls.ca) {
-    connectOptions.ca = readFileSync4(tls.ca, "utf-8");
+    connectOptions.ca = readFileSync3(tls.ca, "utf-8");
   }
   if (tls.fingerprint) {
     const expected = tls.fingerprint.replace(/:/g, "").toLowerCase();
@@ -8376,8 +8603,8 @@ function buildAgentOptions(tls) {
 // src/adapter/response-parser.ts
 var NUMERIC_RE = /^-?\d+(\.\d+)?$/;
 var DURATION_RE = /^\d+[wdhms](\d+[wdhms])*$/;
-function parseRouterOSValue(key, value) {
-  if (key === ".id") {
+function parseRouterOSValue(key2, value) {
+  if (key2 === ".id") {
     return value;
   }
   if (value === "true") return true;
@@ -8395,8 +8622,8 @@ function parseRouterOSValue(key, value) {
 }
 function parseRecord(raw) {
   const parsed = {};
-  for (const [key, value] of Object.entries(raw)) {
-    parsed[key] = parseRouterOSValue(key, value);
+  for (const [key2, value] of Object.entries(raw)) {
+    parsed[key2] = parseRouterOSValue(key2, value);
   }
   return parsed;
 }
@@ -8418,8 +8645,8 @@ function buildListQuery(options) {
     }
     if (hasFilter) {
       const queryParts = [];
-      for (const [key, value] of Object.entries(options.filter)) {
-        queryParts.push(`${key}=${value}`);
+      for (const [key2, value] of Object.entries(options.filter)) {
+        queryParts.push(`${key2}=${value}`);
       }
       body[".query"] = queryParts;
     }
@@ -8427,8 +8654,8 @@ function buildListQuery(options) {
   }
   if (hasFilter) {
     const queryParams = {};
-    for (const [key, value] of Object.entries(options.filter)) {
-      queryParams[key] = value;
+    for (const [key2, value] of Object.entries(options.filter)) {
+      queryParams[key2] = value;
     }
     return { method: "GET", queryParams };
   }
@@ -8606,6 +8833,9 @@ var ConnectionPool = class {
   }
 };
 
+// src/version.ts
+var VERSION = "1.1.0";
+
 // src/mcp/server.ts
 function createServerFactory(config, identityRegistry) {
   const registry = new RouterRegistry(config.configPath);
@@ -8614,7 +8844,7 @@ function createServerFactory(config, identityRegistry) {
   const makeServer = () => {
     const server = new McpServer({
       name: "mikromcp",
-      version: "1.0.9"
+      version: VERSION
     });
     registerAllTools(server, registry, pool, circuitBreakers, config, identityRegistry);
     return server;
@@ -8634,17 +8864,17 @@ import { randomUUID } from "crypto";
 import { createServer } from "http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-var log36 = createLogger("transport-http");
+var log37 = createLogger("transport-http");
 var BodyTooLargeError = class extends Error {
   constructor() {
     super("Request body exceeds maximum allowed size");
   }
 };
 function createRateLimiter(rpm) {
-  if (rpm === 0) return () => true;
   const WINDOW_MS = 6e4;
   const windows = /* @__PURE__ */ new Map();
-  return (ip) => {
+  const check = (ip) => {
+    if (rpm === 0) return true;
     const now = Date.now();
     const entry = windows.get(ip);
     if (!entry || now - entry.windowStart >= WINDOW_MS) {
@@ -8657,6 +8887,17 @@ function createRateLimiter(rpm) {
     entry.count++;
     return true;
   };
+  const limiter = check;
+  limiter.sweep = () => {
+    const now = Date.now();
+    for (const [ip, entry] of windows) {
+      if (now - entry.windowStart >= WINDOW_MS) {
+        windows.delete(ip);
+      }
+    }
+  };
+  limiter.size = () => windows.size;
+  return limiter;
 }
 async function readBody(req, maxBytes) {
   return new Promise((resolve, reject) => {
@@ -8696,18 +8937,30 @@ async function readBody(req, maxBytes) {
 async function connectHttp(makeServer, config, identityRegistry) {
   const { port, bindHost, maxBodyBytes, rateLimitRpm } = config;
   const checkRateLimit = createRateLimiter(rateLimitRpm);
+  const sweepTimer = setInterval(() => checkRateLimit.sweep(), 6e4);
+  sweepTimer.unref();
   const streamableSessions = /* @__PURE__ */ new Map();
   const sseTransports = /* @__PURE__ */ new Map();
   const httpServer = createServer(async (req, res) => {
     const ip = req.socket.remoteAddress ?? "unknown";
+    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+    const { pathname } = url;
+    if (pathname === "/healthz") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok" }));
+      return;
+    }
+    if (pathname === "/metrics") {
+      res.writeHead(200, { "Content-Type": "text/plain; version=0.0.4; charset=utf-8" });
+      res.end(renderPrometheus());
+      return;
+    }
     if (!checkRateLimit(ip)) {
-      log36.warn({ ip }, "Rate limit exceeded");
+      log37.warn({ ip }, "Rate limit exceeded");
       res.writeHead(429, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Too many requests. Retry after 60 seconds." }));
       return;
     }
-    const url = new URL(req.url ?? "/", `http://localhost:${port}`);
-    const { pathname } = url;
     try {
       if (pathname === "/mcp" || pathname === "/sse" || pathname === "/messages") {
         let identity;
@@ -8744,16 +8997,17 @@ async function connectHttp(makeServer, config, identityRegistry) {
         }
         return;
       }
-      log36.error({ err }, "HTTP transport error");
+      log37.error({ err }, "HTTP transport error");
       if (!res.headersSent) {
         res.writeHead(500, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Internal server error" }));
       }
     }
   });
+  httpServer.on("close", () => clearInterval(sweepTimer));
   await new Promise((resolve, reject) => {
     httpServer.listen(port, bindHost, () => {
-      log36.info(
+      log37.info(
         { port, bindHost },
         "HTTP transport listening (POST /mcp for Streamable HTTP, GET /sse for legacy SSE)"
       );
@@ -8761,6 +9015,7 @@ async function connectHttp(makeServer, config, identityRegistry) {
     });
     httpServer.on("error", reject);
   });
+  return httpServer;
 }
 async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, makeServer, streamableSessions, sseTransports) {
   if (pathname === "/mcp") {
@@ -8776,13 +9031,13 @@ async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, mak
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (id) => {
           streamableSessions.set(id, transport2);
-          log36.info({ sessionId: id }, "Streamable HTTP session created");
+          log37.info({ sessionId: id }, "Streamable HTTP session created");
         }
       });
       transport2.onclose = () => {
         if (transport2.sessionId) {
           streamableSessions.delete(transport2.sessionId);
-          log36.info({ sessionId: transport2.sessionId }, "Streamable HTTP session closed");
+          log37.info({ sessionId: transport2.sessionId }, "Streamable HTTP session closed");
         }
       };
       await makeServer().connect(transport2);
@@ -8799,7 +9054,7 @@ async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, mak
     sseTransport.onclose = () => {
       sseTransports.delete(sseTransport.sessionId);
     };
-    log36.info({ sessionId: sseTransport.sessionId }, "SSE client connected");
+    log37.info({ sessionId: sseTransport.sessionId }, "SSE client connected");
     await sseTransport.start();
     return;
   }
@@ -8818,11 +9073,11 @@ async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, mak
 }
 
 // src/config/identity-registry.ts
-import { readFileSync as readFileSync5, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync2 } from "fs";
 import { parse as parse2 } from "yaml";
 import { z as z34 } from "zod";
 import bcrypt from "bcryptjs";
-var log37 = createLogger("identity-registry");
+var log38 = createLogger("identity-registry");
 var IdentityConfigSchema = z34.object({
   token: z34.string().min(1, "token hash is required"),
   role: z34.enum(["readonly", "operator", "admin", "superadmin"]),
@@ -8836,13 +9091,13 @@ var IdentityRegistry = class {
   identities = [];
   constructor(configPath) {
     if (!existsSync2(configPath)) {
-      log37.warn(
+      log38.warn(
         { configPath },
         "Identity config file not found; starting with empty registry (stdio callers do not require it)"
       );
       return;
     }
-    const raw = readFileSync5(configPath, "utf-8");
+    const raw = readFileSync4(configPath, "utf-8");
     const parsed = parse2(raw);
     const result = ConfigFileSchema2.safeParse(parsed);
     if (!result.success) {
@@ -8859,7 +9114,7 @@ ${issues}`);
         allowedToolPatterns: config.allowedToolPatterns
       });
     }
-    log37.info({ count: this.identities.length }, "Loaded identities from config");
+    log38.info({ count: this.identities.length }, "Loaded identities from config");
   }
   getIdentities() {
     return this.identities.map(({ id, role, allowedRouters, allowedToolPatterns }) => ({
@@ -8885,18 +9140,59 @@ ${issues}`);
   }
 };
 
+// src/domain/snapshot/retention.ts
+import { readdir, stat, unlink } from "fs/promises";
+import { join as join3 } from "path";
+var log39 = createLogger("snapshot-retention");
+async function pruneSnapshots(snapshotDir, maxAgeDays) {
+  const cutoffMs = Date.now() - maxAgeDays * 864e5;
+  let removed = 0;
+  let routerDirs;
+  try {
+    routerDirs = await readdir(snapshotDir);
+  } catch {
+    return 0;
+  }
+  for (const routerDir of routerDirs) {
+    const dirPath = join3(snapshotDir, routerDir);
+    let files;
+    try {
+      files = await readdir(dirPath);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const filePath = join3(dirPath, file);
+      try {
+        const info = await stat(filePath);
+        if (info.isFile() && info.mtimeMs < cutoffMs) {
+          await unlink(filePath);
+          removed++;
+        }
+      } catch (err) {
+        log39.warn({ err, filePath }, "Failed to evaluate snapshot for retention");
+      }
+    }
+  }
+  if (removed > 0) {
+    log39.info({ removed, maxAgeDays }, "Pruned expired snapshots");
+  }
+  return removed;
+}
+
 // src/cli/serve.ts
-var log38 = createLogger("main");
+var log40 = createLogger("main");
 async function runServe() {
   const config = loadAppConfig();
-  log38.info({ transport: config.transport, logLevel: config.logLevel }, "Starting MikroMCP server");
+  log40.info({ transport: config.transport, logLevel: config.logLevel }, "Starting MikroMCP server");
+  void pruneSnapshots(config.snapshotDir, config.retention.snapshotMaxAgeDays);
   const identityRegistry = new IdentityRegistry(config.identitiesPath);
   if (config.transport === "http") {
     const hasLimitedRoles = identityRegistry.getIdentities().some(
       (i) => i.role === "readonly" || i.role === "operator"
     );
     if (hasLimitedRoles && !config.confirmationSecret) {
-      log38.error(
+      log40.error(
         "MIKROMCP_CONFIRMATION_SECRET is required in HTTP mode when identities with role readonly or operator are configured"
       );
       process.exit(1);
@@ -8906,7 +9202,7 @@ async function runServe() {
   if (config.transport === "stdio") {
     const stdioIdentity = getStdioIdentity(config.stdioIdentity, identityRegistry);
     await withIdentity(stdioIdentity, () => connectStdio(makeServer()));
-    log38.info("MikroMCP server running via stdio");
+    log40.info("MikroMCP server running via stdio");
   } else if (config.transport === "http") {
     await connectHttp(
       makeServer,
@@ -8918,13 +9214,13 @@ async function runServe() {
       },
       identityRegistry
     );
-    log38.info(
+    log40.info(
       { port: config.port, bindHost: config.bindHost },
       "MikroMCP server running via HTTP/SSE"
     );
   }
   const shutdown = () => {
-    log38.info("Shutting down MikroMCP server");
+    log40.info("Shutting down MikroMCP server");
     pool.closeAll();
     process.exit(0);
   };
@@ -8933,11 +9229,11 @@ async function runServe() {
 }
 
 // src/cli/doctor.ts
-import { existsSync as existsSync3, readFileSync as readFileSync6 } from "fs";
-import { homedir as homedir3 } from "os";
+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.0.9";
+var localVersion = "1.1.0";
 var results = [];
 function ok(msg) {
   console.log(chalk.green("\u2705 ") + msg);
@@ -9117,8 +9413,8 @@ function checkIdentities(identitiesPath, transport2) {
 }
 function checkClaudeDesktop() {
   const candidatePaths = [
-    `${homedir3()}/Library/Application Support/Claude/claude_desktop_config.json`,
-    `${homedir3()}/.config/Claude/claude_desktop_config.json`
+    `${homedir2()}/Library/Application Support/Claude/claude_desktop_config.json`,
+    `${homedir2()}/.config/Claude/claude_desktop_config.json`
   ];
   const configPath = candidatePaths.find((p) => existsSync3(p));
   if (!configPath) {
@@ -9126,7 +9422,7 @@ function checkClaudeDesktop() {
     return;
   }
   try {
-    const raw = readFileSync6(configPath, "utf-8");
+    const raw = readFileSync5(configPath, "utf-8");
     const config = JSON.parse(raw);
     const servers = config.mcpServers ?? {};
     if ("mikromcp" in servers || "mikrotik-mcp-server" in servers) {
@@ -9211,18 +9507,18 @@ import { input, confirm, select } from "@inquirer/prompts";
 import { randomBytes } from "crypto";
 import {
   existsSync as existsSync4,
-  readFileSync as readFileSync7,
-  writeFileSync as writeFileSync2,
-  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync6,
+  writeFileSync,
+  mkdirSync,
   copyFileSync
 } from "fs";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
 import { parse as yamlParse, Document, visit } from "yaml";
 import bcrypt2 from "bcryptjs";
 import chalk2 from "chalk";
 function mikromcpDir2() {
-  return join4(homedir4(), ".mikromcp");
+  return join4(homedir3(), ".mikromcp");
 }
 function defaultAuditLogPath() {
   return join4(mikromcpDir2(), "audit.ndjson");
@@ -9230,8 +9526,8 @@ function defaultAuditLogPath() {
 function toYaml(obj) {
   const doc = new Document(obj);
   visit(doc, {
-    Scalar(key, node) {
-      if (key !== "key" && typeof node.value === "string") {
+    Scalar(key2, node) {
+      if (key2 !== "key" && typeof node.value === "string") {
         node.type = "QUOTE_DOUBLE";
       }
     },
@@ -9253,8 +9549,8 @@ function splitTags(val) {
 }
 function findClaudeDesktopConfig() {
   const candidates = [
-    join4(homedir4(), "Library", "Application Support", "Claude", "claude_desktop_config.json"),
-    join4(homedir4(), ".config", "Claude", "claude_desktop_config.json")
+    join4(homedir3(), "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+    join4(homedir3(), ".config", "Claude", "claude_desktop_config.json")
   ];
   return candidates.find((p) => existsSync4(p)) ?? null;
 }
@@ -9419,13 +9715,13 @@ function writeRoutersYaml(data) {
   };
   let parsed = { routers: {} };
   if (existsSync4(filePath)) {
-    const raw = readFileSync7(filePath, "utf-8");
+    const raw = readFileSync6(filePath, "utf-8");
     parsed = yamlParse(raw) ?? { routers: {} };
     if (!parsed.routers) parsed.routers = {};
   }
   parsed.routers[data.routerId] = newEntry;
-  mkdirSync3(data.configDir, { recursive: true });
-  writeFileSync2(filePath, toYaml(parsed));
+  mkdirSync(data.configDir, { recursive: true });
+  writeFileSync(filePath, toYaml(parsed));
   return true;
 }
 function writeIdentitiesYaml(data) {
@@ -9433,18 +9729,18 @@ function writeIdentitiesYaml(data) {
   const newEntry = {
     token: data.tokenHash,
     role: data.role,
-    allowedRouters: data.allowedRouters === "*" ? ["*"] : data.allowedRouters.split(",").map((s) => s.trim()),
-    allowedToolPatterns: data.allowedToolPatterns === "*" ? ["*"] : data.allowedToolPatterns.split(",").map((s) => s.trim())
+    allowedRouters: data.allowedRouters === "*" ? [] : data.allowedRouters.split(",").map((s) => s.trim()),
+    allowedToolPatterns: data.allowedToolPatterns === "*" ? [] : data.allowedToolPatterns.split(",").map((s) => s.trim())
   };
   let parsed = { identities: {} };
   if (existsSync4(filePath)) {
-    const raw = readFileSync7(filePath, "utf-8");
+    const raw = readFileSync6(filePath, "utf-8");
     parsed = yamlParse(raw) ?? { identities: {} };
     if (!parsed.identities) parsed.identities = {};
   }
   parsed.identities[data.identityId] = newEntry;
-  mkdirSync3(data.configDir, { recursive: true });
-  writeFileSync2(filePath, toYaml(parsed));
+  mkdirSync(data.configDir, { recursive: true });
+  writeFileSync(filePath, toYaml(parsed));
   return true;
 }
 function writeDotEnv(data) {
@@ -9478,8 +9774,8 @@ function writeDotEnv(data) {
     "# \u2500\u2500 RBAC (optional, for stdio with identity enforcement) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
     "# MIKROMCP_STDIO_IDENTITY="
   ];
-  mkdirSync3(data.configDir, { recursive: true });
-  writeFileSync2(data.envPath, lines.join("\n") + "\n");
+  mkdirSync(data.configDir, { recursive: true });
+  writeFileSync(data.envPath, lines.join("\n") + "\n");
 }
 function registerClaudeDesktop() {
   const configPath = findClaudeDesktopConfig();
@@ -9500,13 +9796,13 @@ function registerClaudeDesktop() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupPath = `${configPath}.backup-${timestamp}`;
   copyFileSync(configPath, backupPath);
-  const raw = readFileSync7(configPath, "utf-8");
+  const raw = readFileSync6(configPath, "utf-8");
   const config = JSON.parse(raw);
   if (!config.mcpServers || typeof config.mcpServers !== "object") {
     config.mcpServers = {};
   }
   config.mcpServers["mikromcp"] = entry;
-  writeFileSync2(configPath, JSON.stringify(config, null, 2));
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
   console.log(chalk2.dim(`  Backed up to ${backupPath}`));
   console.log(chalk2.dim("  Restart Claude to apply."));
   return { registered: true };
@@ -9589,7 +9885,7 @@ async function runInit() {
 }
 
 // src/cli/index.ts
-var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.0.9");
+var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.1.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);
@@ -9599,6 +9895,6 @@ program.command("update").description("Update mikromcp to the latest version via
 });
 
 // src/main.ts
-loadDotenv({ path: join5(homedir5(), ".mikromcp", ".env"), override: false, quiet: true });
+loadDotenv({ path: join5(homedir4(), ".mikromcp", ".env"), override: false, quiet: true });
 program.parse();
 //# sourceMappingURL=main.js.map