mikromcp 1.4.0 → 1.5.0

package/dist/main.js

@@ -60,7 +60,7 @@ function loadAppConfig() {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/mcp/tool-registry.ts
-import { z as z42 } from "zod";
+import { z as z46 } from "zod";
 
 // src/domain/tools/system-tools.ts
 import { z } from "zod";
@@ -2842,7 +2842,148 @@ var managePeerTool = {
     }
   }
 };
-var wireguardTools = [listWgTool, listPeersTool, managePeerTool];
+var manageWgIfaceInputSchema = z12.object({
+  routerId: z12.string().describe("Target router identifier from the router registry"),
+  action: z12.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
+  name: z12.string().describe("Interface name \u2014 idempotency key (e.g. wg0)"),
+  listenPort: z12.number().int().min(1).max(65535).optional().describe("UDP listen port (RouterOS picks one if omitted)"),
+  mtu: z12.number().int().min(1280).max(65535).default(1420).describe("MTU (default 1420)"),
+  comment: z12.string().optional().describe("Optional comment"),
+  dryRun: z12.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageWgIfaceTool = {
+  name: "manage_wireguard_interface",
+  title: "Manage WireGuard Interface",
+  description: "Add, remove, enable, or disable a WireGuard interface. Idempotent by name. RouterOS generates the private key on create \u2014 it is never passed in. The public key is returned after creation.",
+  inputSchema: manageWgIfaceInputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  snapshotPaths: ["interface/wireguard"],
+  async handler(params, context) {
+    const parsed = manageWgIfaceInputSchema.parse(params);
+    log11.info(
+      { routerId: context.routerId, action: parsed.action, name: parsed.name },
+      "Managing WireGuard interface"
+    );
+    try {
+      const all = await context.routerClient.get("interface/wireguard", {
+        limit: void 0,
+        offset: void 0
+      });
+      const existing = all.find((i) => i.name === parsed.name);
+      if (parsed.action === "add") {
+        if (existing) {
+          return {
+            content: `WireGuard interface "${parsed.name}" already exists. No changes made.`,
+            structuredContent: {
+              action: "already_exists",
+              name: parsed.name,
+              publicKey: existing["public-key"] ?? null
+            }
+          };
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would create WireGuard interface "${parsed.name}".`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [{ property: "name", before: null, after: parsed.name }]
+            }
+          };
+        }
+        const body = { name: parsed.name, mtu: String(parsed.mtu) };
+        if (parsed.listenPort !== void 0) body["listen-port"] = String(parsed.listenPort);
+        if (parsed.comment) body.comment = parsed.comment;
+        const created = await context.routerClient.create(
+          "interface/wireguard",
+          body
+        );
+        log11.info({ name: parsed.name, id: created[".id"] }, "WireGuard interface created");
+        return {
+          content: `Created WireGuard interface "${parsed.name}". Public key: ${created["public-key"] ?? "unknown"}`,
+          structuredContent: {
+            action: "created",
+            name: parsed.name,
+            id: created[".id"],
+            publicKey: created["public-key"] ?? null
+          }
+        };
+      }
+      if (parsed.action === "remove") {
+        if (!existing) {
+          return {
+            content: `WireGuard interface "${parsed.name}" not found. Nothing to remove.`,
+            structuredContent: { action: "not_found", name: parsed.name }
+          };
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would remove WireGuard interface "${parsed.name}".`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [{ property: "name", before: parsed.name, after: null }]
+            }
+          };
+        }
+        await context.routerClient.remove("interface/wireguard", existing[".id"]);
+        log11.info({ name: parsed.name }, "WireGuard interface removed");
+        return {
+          content: `Removed WireGuard interface "${parsed.name}".`,
+          structuredContent: { action: "removed", name: parsed.name, id: existing[".id"] }
+        };
+      }
+      if (!existing) {
+        throw new MikroMCPError({
+          category: "NOT_FOUND" /* NOT_FOUND */,
+          code: "WIREGUARD_IFACE_NOT_FOUND",
+          message: `WireGuard interface "${parsed.name}" not found.`,
+          recoverability: {
+            retryable: false,
+            suggestedAction: "Verify with list_wireguard_interfaces.",
+            alternativeTools: ["list_wireguard_interfaces"]
+          }
+        });
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would ${parsed.action} WireGuard interface "${parsed.name}".`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [
+              {
+                property: "disabled",
+                before: existing.disabled,
+                after: parsed.action === "disable" ? "true" : "false"
+              }
+            ]
+          }
+        };
+      }
+      await context.routerClient.update("interface/wireguard", existing[".id"], {
+        disabled: parsed.action === "disable" ? "true" : "false"
+      });
+      const resultAction = parsed.action === "disable" ? "disabled" : "enabled";
+      log11.info({ name: parsed.name, action: resultAction }, "WireGuard interface updated");
+      return {
+        content: `WireGuard interface "${parsed.name}" ${resultAction}.`,
+        structuredContent: { action: resultAction, name: parsed.name, id: existing[".id"] }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_wireguard_interface" });
+    }
+  }
+};
+var wireguardTools = [
+  listWgTool,
+  listPeersTool,
+  managePeerTool,
+  manageWgIfaceTool
+];
 
 // src/domain/tools/dns-tools.ts
 import { z as z13 } from "zod";
@@ -3081,7 +3222,89 @@ var getDnsSettingsTool = {
     }
   }
 };
-var dnsTools = [listDnsTool, manageDnsTool, getDnsSettingsTool];
+var manageDnsSettingsInputSchema = z13.object({
+  routerId: z13.string().describe("Target router identifier from the router registry"),
+  servers: z13.string().optional().describe("Comma-separated upstream DNS server IPs (e.g. '8.8.8.8,1.1.1.1')"),
+  allowRemoteRequests: z13.boolean().optional().describe("Allow router to answer DNS queries from the network"),
+  maxUdpPacketSize: z13.number().int().min(512).max(65535).optional().describe("Maximum UDP packet size in bytes"),
+  cacheMaxTtl: z13.string().optional().describe("Maximum cache TTL (e.g. '1d', '00:30:00')"),
+  cacheSize: z13.number().int().min(1).optional().describe("DNS cache size in KiB"),
+  dryRun: z13.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageDnsSettingsTool = {
+  name: "manage_dns_settings",
+  title: "Manage DNS Settings",
+  description: "Update DNS resolver settings (upstream servers, cache size, cache TTL, allow-remote-requests). Idempotent: returns no_change if nothing differs.",
+  inputSchema: manageDnsSettingsInputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  snapshotPaths: ["ip/dns"],
+  async handler(params, context) {
+    const parsed = manageDnsSettingsInputSchema.parse(params);
+    log12.info({ routerId: context.routerId }, "Managing DNS settings");
+    try {
+      const results2 = await context.routerClient.get("ip/dns");
+      const current = Array.isArray(results2) && results2.length > 0 ? results2[0] : results2;
+      const id = current[".id"];
+      const changes = {};
+      const diff = [];
+      if (parsed.servers !== void 0 && current.servers !== parsed.servers) {
+        changes.servers = parsed.servers;
+        diff.push({ property: "servers", before: current.servers ?? null, after: parsed.servers });
+      }
+      if (parsed.allowRemoteRequests !== void 0) {
+        const next = String(parsed.allowRemoteRequests);
+        if (current["allow-remote-requests"] !== next) {
+          changes["allow-remote-requests"] = next;
+          diff.push({ property: "allow-remote-requests", before: current["allow-remote-requests"] ?? null, after: next });
+        }
+      }
+      if (parsed.maxUdpPacketSize !== void 0) {
+        const next = String(parsed.maxUdpPacketSize);
+        if (current["max-udp-packet-size"] !== next) {
+          changes["max-udp-packet-size"] = next;
+          diff.push({ property: "max-udp-packet-size", before: current["max-udp-packet-size"] ?? null, after: next });
+        }
+      }
+      if (parsed.cacheMaxTtl !== void 0 && current["cache-max-ttl"] !== parsed.cacheMaxTtl) {
+        changes["cache-max-ttl"] = parsed.cacheMaxTtl;
+        diff.push({ property: "cache-max-ttl", before: current["cache-max-ttl"] ?? null, after: parsed.cacheMaxTtl });
+      }
+      if (parsed.cacheSize !== void 0) {
+        const next = String(parsed.cacheSize);
+        if (current["cache-size"] !== next) {
+          changes["cache-size"] = next;
+          diff.push({ property: "cache-size", before: current["cache-size"] ?? null, after: next });
+        }
+      }
+      if (Object.keys(changes).length === 0) {
+        return {
+          content: "DNS settings already match requested values. No changes made.",
+          structuredContent: { action: "no_change", routerId: context.routerId }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would update DNS settings on ${context.routerId}.`,
+          structuredContent: { action: "dry_run", diff }
+        };
+      }
+      await context.routerClient.update("ip/dns", id, changes);
+      log12.info({ routerId: context.routerId, changes: Object.keys(changes) }, "DNS settings updated");
+      return {
+        content: `Updated DNS settings on ${context.routerId}.`,
+        structuredContent: { action: "updated", routerId: context.routerId, diff }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_dns_settings" });
+    }
+  }
+};
+var dnsTools = [listDnsTool, manageDnsTool, getDnsSettingsTool, manageDnsSettingsTool];
 
 // src/domain/tools/mangle-tools.ts
 import { z as z14 } from "zod";
@@ -4689,7 +4912,71 @@ var uploadFileTool = {
     }
   }
 };
-var filesTools = [listFilesTool, getFileContentTool, uploadFileTool];
+var deleteFileInputSchema = z21.object({
+  routerId: z21.string().describe("Target router identifier from the router registry"),
+  name: z21.string().describe("Exact file name on the router (e.g. flash/backup.backup)"),
+  dryRun: z21.boolean().default(false).describe("Preview deletion without removing the file")
+}).strict();
+var deleteFileTool = {
+  name: "delete_file",
+  title: "Delete File",
+  description: "Delete a file from the router filesystem by name. Idempotent: returns not_found gracefully if the file does not exist.",
+  inputSchema: deleteFileInputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  async handler(params, context) {
+    const parsed = deleteFileInputSchema.parse(params);
+    log20.info({ routerId: context.routerId, name: parsed.name }, "Deleting file");
+    try {
+      const all = await context.routerClient.get(FILE_PATH, {
+        limit: void 0,
+        offset: void 0
+      });
+      const file = all.find((f) => f.name === parsed.name);
+      if (!file) {
+        return {
+          content: `File "${parsed.name}" not found on ${context.routerId}. Nothing to delete.`,
+          structuredContent: { action: "not_found", name: parsed.name, routerId: context.routerId }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would delete "${parsed.name}" from ${context.routerId}.`,
+          structuredContent: {
+            action: "dry_run",
+            name: parsed.name,
+            id: file[".id"],
+            routerId: context.routerId
+          }
+        };
+      }
+      await context.routerClient.remove(FILE_PATH, file[".id"]);
+      log20.info({ name: parsed.name, id: file[".id"] }, "File deleted");
+      return {
+        content: `Deleted "${parsed.name}" from ${context.routerId}.`,
+        structuredContent: {
+          action: "deleted",
+          name: parsed.name,
+          id: file[".id"],
+          routerId: context.routerId
+        }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "delete_file" });
+    }
+  }
+};
+var filesTools = [
+  listFilesTool,
+  getFileContentTool,
+  uploadFileTool,
+  deleteFileTool
+];
 
 // src/domain/tools/container-tools.ts
 import { z as z22 } from "zod";
@@ -5603,86 +5890,239 @@ var manageIpsecPeerTool = {
     }
   }
 };
-var ipsecTools = [
-  listIpsecPeersTool,
-  listIpsecPoliciesTool,
-  manageIpsecPeerTool
-];
-
-// src/domain/tools/certificate-tools.ts
-import { z as z25 } from "zod";
-var log26 = createLogger("certificate-tools");
-var listCertificatesInputSchema = z25.object({
-  routerId: z25.string().describe("Target router identifier from the router registry"),
-  name: z25.string().optional().describe("Filter by certificate name (substring match)"),
-  expired: z25.boolean().optional().describe("Filter by expiry status; omit to return all"),
-  limit: z25.number().int().min(1).max(500).default(100).describe("Maximum number of certificates to return")
+var manageIpsecPolicyInputSchema = z24.object({
+  routerId: z24.string().describe("Target router identifier from the router registry"),
+  action: z24.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
+  srcAddress: z24.string().describe("Source CIDR \u2014 part of composite idempotency key"),
+  dstAddress: z24.string().describe("Destination CIDR \u2014 part of composite idempotency key"),
+  tunnel: z24.boolean().default(false).describe("Tunnel mode \u2014 part of composite idempotency key"),
+  ipsecAction: z24.enum(["encrypt", "discard", "none"]).optional().describe("IPSec action (required for add)"),
+  level: z24.enum(["require", "use", "unique"]).default("require").describe("SA level"),
+  saSourceAddress: z24.string().optional().describe("SA source IP for tunnel mode"),
+  saDstAddress: z24.string().optional().describe("SA destination IP for tunnel mode"),
+  dryRun: z24.boolean().default(false).describe("Preview changes without applying")
 }).strict();
-var listCertificatesTool = {
-  name: "list_certificates",
-  title: "List Certificates",
-  description: "List certificates on a MikroTik router.",
-  inputSchema: listCertificatesInputSchema,
+var manageIpsecPolicyTool = {
+  name: "manage_ipsec_policy",
+  title: "Manage IPSec Policy",
+  description: "Add, remove, enable, or disable an IPSec policy. Idempotent by composite key (srcAddress + dstAddress + tunnel).",
+  inputSchema: manageIpsecPolicyInputSchema,
   annotations: {
-    readOnlyHint: true,
+    readOnlyHint: false,
     destructiveHint: false,
     idempotentHint: true,
     openWorldHint: false
   },
+  snapshotPaths: ["ip/ipsec/policy"],
   async handler(params, context) {
-    const parsed = listCertificatesInputSchema.parse(params);
-    log26.info({ routerId: context.routerId }, "Listing certificates");
+    const parsed = manageIpsecPolicyInputSchema.parse(params);
+    log25.info({ routerId: context.routerId, action: parsed.action }, "Managing IPSec policy");
     try {
-      const allCerts = await context.routerClient.get("certificate", {
+      const all = await context.routerClient.get("ip/ipsec/policy", {
         limit: void 0,
         offset: void 0
       });
-      const now = /* @__PURE__ */ new Date();
-      const filtered = allCerts.filter((c) => parsed.name ? (c.name ?? "").includes(parsed.name) : true).filter((c) => {
-        if (parsed.expired === void 0) return true;
-        const invalidAfter = c["invalid-after"];
-        if (!invalidAfter) {
-          return parsed.expired === true;
+      const tunnelStr = String(parsed.tunnel);
+      const existing = all.find(
+        (p) => p["src-address"] === parsed.srcAddress && p["dst-address"] === parsed.dstAddress && p.tunnel === tunnelStr
+      );
+      if (parsed.action === "add") {
+        if (existing) {
+          return {
+            content: `IPSec policy ${parsed.srcAddress} \u2192 ${parsed.dstAddress} already exists. No changes made.`,
+            structuredContent: { action: "already_exists", policy: existing }
+          };
         }
-        const expiry = new Date(invalidAfter);
-        return parsed.expired ? expiry < now : expiry >= now;
-      });
-      const certs = filtered.slice(0, parsed.limit);
-      return {
-        content: `Certificates on ${context.routerId}: ${certs.length} returned (${allCerts.length} total)`,
-        structuredContent: {
-          routerId: context.routerId,
-          certificates: certs,
-          total: allCerts.length,
-          returned: certs.length
+        if (!parsed.ipsecAction) {
+          throw new MikroMCPError({
+            category: "VALIDATION" /* VALIDATION */,
+            code: "IPSEC_POLICY_ACTION_REQUIRED",
+            message: "ipsecAction is required when adding an IPSec policy.",
+            recoverability: {
+              retryable: false,
+              suggestedAction: "Provide ipsecAction: encrypt, discard, or none."
+            }
+          });
         }
-      };
-    } catch (err) {
-      throw enrichError(err, { routerId: context.routerId, tool: "list_certificates" });
-    }
-  }
-};
-var manageCertificateInputSchema = z25.object({
-  routerId: z25.string().describe("Target router identifier from the router registry"),
-  action: z25.enum(["remove", "trust", "untrust"]).describe("Action to perform"),
-  name: z25.string().describe("Certificate name \u2014 idempotency key"),
-  dryRun: z25.boolean().default(false).describe("Preview changes without applying")
-}).strict();
-var manageCertificateTool = {
-  name: "manage_certificate",
-  title: "Manage Certificate",
-  description: "Remove, trust, or untrust a certificate. Idempotent: trust/untrust return early if already in the target state.",
-  inputSchema: manageCertificateInputSchema,
-  annotations: {
-    readOnlyHint: false,
-    destructiveHint: true,
-    idempotentHint: false,
-    openWorldHint: false
-  },
-  snapshotPaths: ["certificate"],
-  async handler(params, context) {
-    const parsed = manageCertificateInputSchema.parse(params);
-    log26.info(
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would add IPSec policy ${parsed.srcAddress} \u2192 ${parsed.dstAddress}.`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [
+                { property: "src-address", before: null, after: parsed.srcAddress },
+                { property: "dst-address", before: null, after: parsed.dstAddress },
+                { property: "action", before: null, after: parsed.ipsecAction }
+              ]
+            }
+          };
+        }
+        const body = {
+          "src-address": parsed.srcAddress,
+          "dst-address": parsed.dstAddress,
+          tunnel: tunnelStr,
+          action: parsed.ipsecAction,
+          level: parsed.level
+        };
+        if (parsed.saSourceAddress) body["sa-src-address"] = parsed.saSourceAddress;
+        if (parsed.saDstAddress) body["sa-dst-address"] = parsed.saDstAddress;
+        const created = await context.routerClient.create("ip/ipsec/policy", body);
+        log25.info({ id: created[".id"] }, "IPSec policy added");
+        return {
+          content: `Added IPSec policy ${parsed.srcAddress} \u2192 ${parsed.dstAddress}.`,
+          structuredContent: { action: "created", policy: created }
+        };
+      }
+      if (parsed.action === "remove") {
+        if (!existing) {
+          return {
+            content: `IPSec policy ${parsed.srcAddress} \u2192 ${parsed.dstAddress} not found. Nothing to remove.`,
+            structuredContent: {
+              action: "not_found",
+              srcAddress: parsed.srcAddress,
+              dstAddress: parsed.dstAddress
+            }
+          };
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would remove IPSec policy ${parsed.srcAddress} \u2192 ${parsed.dstAddress}.`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [{ property: "src-address", before: parsed.srcAddress, after: null }]
+            }
+          };
+        }
+        await context.routerClient.remove("ip/ipsec/policy", existing[".id"]);
+        log25.info({ id: existing[".id"] }, "IPSec policy removed");
+        return {
+          content: `Removed IPSec policy ${parsed.srcAddress} \u2192 ${parsed.dstAddress}.`,
+          structuredContent: { action: "removed", id: existing[".id"] }
+        };
+      }
+      if (!existing) {
+        throw new MikroMCPError({
+          category: "NOT_FOUND" /* NOT_FOUND */,
+          code: "IPSEC_POLICY_NOT_FOUND",
+          message: `IPSec policy ${parsed.srcAddress} \u2192 ${parsed.dstAddress} not found.`,
+          recoverability: {
+            retryable: false,
+            suggestedAction: "Verify with list_ipsec_policies.",
+            alternativeTools: ["list_ipsec_policies"]
+          }
+        });
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would ${parsed.action} IPSec policy ${parsed.srcAddress} \u2192 ${parsed.dstAddress}.`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [
+              {
+                property: "disabled",
+                before: existing.disabled,
+                after: parsed.action === "disable" ? "true" : "false"
+              }
+            ]
+          }
+        };
+      }
+      await context.routerClient.update("ip/ipsec/policy", existing[".id"], {
+        disabled: parsed.action === "disable" ? "true" : "false"
+      });
+      const resultAction = parsed.action === "disable" ? "disabled" : "enabled";
+      log25.info({ id: existing[".id"], action: resultAction }, "IPSec policy updated");
+      return {
+        content: `IPSec policy ${parsed.srcAddress} \u2192 ${parsed.dstAddress} ${resultAction}.`,
+        structuredContent: { action: resultAction, id: existing[".id"] }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_ipsec_policy" });
+    }
+  }
+};
+var ipsecTools = [
+  listIpsecPeersTool,
+  listIpsecPoliciesTool,
+  manageIpsecPeerTool,
+  manageIpsecPolicyTool
+];
+
+// src/domain/tools/certificate-tools.ts
+import { z as z25 } from "zod";
+var log26 = createLogger("certificate-tools");
+var listCertificatesInputSchema = z25.object({
+  routerId: z25.string().describe("Target router identifier from the router registry"),
+  name: z25.string().optional().describe("Filter by certificate name (substring match)"),
+  expired: z25.boolean().optional().describe("Filter by expiry status; omit to return all"),
+  limit: z25.number().int().min(1).max(500).default(100).describe("Maximum number of certificates to return")
+}).strict();
+var listCertificatesTool = {
+  name: "list_certificates",
+  title: "List Certificates",
+  description: "List certificates on a MikroTik router.",
+  inputSchema: listCertificatesInputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  async handler(params, context) {
+    const parsed = listCertificatesInputSchema.parse(params);
+    log26.info({ routerId: context.routerId }, "Listing certificates");
+    try {
+      const allCerts = await context.routerClient.get("certificate", {
+        limit: void 0,
+        offset: void 0
+      });
+      const now = /* @__PURE__ */ new Date();
+      const filtered = allCerts.filter((c) => parsed.name ? (c.name ?? "").includes(parsed.name) : true).filter((c) => {
+        if (parsed.expired === void 0) return true;
+        const invalidAfter = c["invalid-after"];
+        if (!invalidAfter) {
+          return parsed.expired === true;
+        }
+        const expiry = new Date(invalidAfter);
+        return parsed.expired ? expiry < now : expiry >= now;
+      });
+      const certs = filtered.slice(0, parsed.limit);
+      return {
+        content: `Certificates on ${context.routerId}: ${certs.length} returned (${allCerts.length} total)`,
+        structuredContent: {
+          routerId: context.routerId,
+          certificates: certs,
+          total: allCerts.length,
+          returned: certs.length
+        }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "list_certificates" });
+    }
+  }
+};
+var manageCertificateInputSchema = z25.object({
+  routerId: z25.string().describe("Target router identifier from the router registry"),
+  action: z25.enum(["remove", "trust", "untrust"]).describe("Action to perform"),
+  name: z25.string().describe("Certificate name \u2014 idempotency key"),
+  dryRun: z25.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageCertificateTool = {
+  name: "manage_certificate",
+  title: "Manage Certificate",
+  description: "Remove, trust, or untrust a certificate. Idempotent: trust/untrust return early if already in the target state.",
+  inputSchema: manageCertificateInputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  snapshotPaths: ["certificate"],
+  async handler(params, context) {
+    const parsed = manageCertificateInputSchema.parse(params);
+    log26.info(
       { routerId: context.routerId, action: parsed.action, name: parsed.name },
       "Managing certificate"
     );
@@ -8758,11 +9198,184 @@ var ovpnTools = [
   manageOvpnServerTool
 ];
 
-// src/domain/tools/upgrade-tools.ts
+// src/domain/tools/ppp-tools.ts
 import { z as z38 } from "zod";
-var log39 = createLogger("upgrade-tools");
-var getUpgradeStatusInputSchema = z38.object({
-  routerId: z38.string().describe("Target router identifier from the router registry")
+var log39 = createLogger("ppp-tools");
+var listPppProfilesInputSchema = z38.object({
+  routerId: z38.string().describe("Target router identifier from the router registry"),
+  name: z38.string().optional().describe("Filter by profile name (exact match)"),
+  limit: z38.number().int().min(1).max(500).default(100).describe("Maximum profiles to return")
+}).strict();
+var listPppProfilesTool = {
+  name: "list_ppp_profiles",
+  title: "List PPP Profiles",
+  description: "List PPP profiles including the built-in default and default-encryption profiles.",
+  inputSchema: listPppProfilesInputSchema,
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  async handler(params, context) {
+    const parsed = listPppProfilesInputSchema.parse(params);
+    try {
+      log39.info({ routerId: context.routerId }, "Listing PPP profiles");
+      const all = await context.routerClient.get("ppp/profile", { limit: void 0, offset: void 0 });
+      const filtered = parsed.name ? all.filter((p) => p.name === parsed.name) : all;
+      const profiles = filtered.slice(0, parsed.limit);
+      return {
+        content: `PPP profiles on ${context.routerId}: ${profiles.length} returned`,
+        structuredContent: { routerId: context.routerId, profiles, total: all.length, returned: profiles.length }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "list_ppp_profiles" });
+    }
+  }
+};
+var managePppProfileInputSchema = z38.object({
+  routerId: z38.string().describe("Target router identifier from the router registry"),
+  action: z38.enum(["add", "update", "remove"]).describe("Action to perform"),
+  name: z38.string().describe("Profile name \u2014 idempotency key"),
+  localAddress: z38.string().optional().describe("Local IP assigned to router end of PPP link"),
+  remoteAddress: z38.string().optional().describe("IP or pool name assigned to client"),
+  dnsServer: z38.string().optional().describe("DNS server IP pushed to client"),
+  rateLimit: z38.string().optional().describe("Rate limit string (e.g. '10M/10M')"),
+  sessionTimeout: z38.string().optional().describe("Session timeout duration string (e.g. '1h')"),
+  comment: z38.string().optional().describe("Optional comment"),
+  dryRun: z38.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var managePppProfileTool = {
+  name: "manage_ppp_profile",
+  title: "Manage PPP Profile",
+  description: "Add, update, or remove a PPP profile. Idempotent by name. update returns no_change when requested values match. Built-in profiles (default, default-encryption) cannot be removed \u2014 RouterOS blocks this and the error is surfaced.",
+  inputSchema: managePppProfileInputSchema,
+  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  snapshotPaths: ["ppp/profile"],
+  async handler(params, context) {
+    const parsed = managePppProfileInputSchema.parse(params);
+    log39.info({ routerId: context.routerId, action: parsed.action, name: parsed.name }, "Managing PPP profile");
+    try {
+      const all = await context.routerClient.get("ppp/profile", { limit: void 0, offset: void 0 });
+      const existing = all.find((p) => p.name === parsed.name);
+      if (parsed.action === "add") {
+        if (existing) {
+          return {
+            content: `PPP profile "${parsed.name}" already exists. No changes made.`,
+            structuredContent: { action: "already_exists", name: parsed.name }
+          };
+        }
+        if (parsed.dryRun) {
+          const diff = [
+            { property: "name", before: null, after: parsed.name }
+          ];
+          if (parsed.localAddress) diff.push({ property: "local-address", before: null, after: parsed.localAddress });
+          if (parsed.remoteAddress) diff.push({ property: "remote-address", before: null, after: parsed.remoteAddress });
+          if (parsed.dnsServer) diff.push({ property: "dns-server", before: null, after: parsed.dnsServer });
+          if (parsed.rateLimit) diff.push({ property: "rate-limit", before: null, after: parsed.rateLimit });
+          if (parsed.sessionTimeout) diff.push({ property: "session-timeout", before: null, after: parsed.sessionTimeout });
+          if (parsed.comment) diff.push({ property: "comment", before: null, after: parsed.comment });
+          return {
+            content: `Dry run: Would create PPP profile "${parsed.name}".`,
+            structuredContent: { action: "dry_run", diff }
+          };
+        }
+        const body = { name: parsed.name };
+        if (parsed.localAddress) body["local-address"] = parsed.localAddress;
+        if (parsed.remoteAddress) body["remote-address"] = parsed.remoteAddress;
+        if (parsed.dnsServer) body["dns-server"] = parsed.dnsServer;
+        if (parsed.rateLimit) body["rate-limit"] = parsed.rateLimit;
+        if (parsed.sessionTimeout) body["session-timeout"] = parsed.sessionTimeout;
+        if (parsed.comment) body.comment = parsed.comment;
+        const created = await context.routerClient.create("ppp/profile", body);
+        log39.info({ name: parsed.name, id: created[".id"] }, "PPP profile created");
+        return {
+          content: `Created PPP profile "${parsed.name}".`,
+          structuredContent: { action: "created", name: parsed.name, id: created[".id"] }
+        };
+      }
+      if (parsed.action === "update") {
+        if (!existing) {
+          throw new MikroMCPError({
+            category: "NOT_FOUND" /* NOT_FOUND */,
+            code: "PPP_PROFILE_NOT_FOUND",
+            message: `PPP profile "${parsed.name}" not found.`,
+            details: { name: parsed.name },
+            recoverability: { retryable: false, suggestedAction: "Verify with list_ppp_profiles.", alternativeTools: ["list_ppp_profiles"] }
+          });
+        }
+        const changes = {};
+        const diff = [];
+        if (parsed.localAddress !== void 0 && existing["local-address"] !== parsed.localAddress) {
+          changes["local-address"] = parsed.localAddress;
+          diff.push({ property: "local-address", before: existing["local-address"] ?? null, after: parsed.localAddress });
+        }
+        if (parsed.remoteAddress !== void 0 && existing["remote-address"] !== parsed.remoteAddress) {
+          changes["remote-address"] = parsed.remoteAddress;
+          diff.push({ property: "remote-address", before: existing["remote-address"] ?? null, after: parsed.remoteAddress });
+        }
+        if (parsed.dnsServer !== void 0 && existing["dns-server"] !== parsed.dnsServer) {
+          changes["dns-server"] = parsed.dnsServer;
+          diff.push({ property: "dns-server", before: existing["dns-server"] ?? null, after: parsed.dnsServer });
+        }
+        if (parsed.rateLimit !== void 0 && existing["rate-limit"] !== parsed.rateLimit) {
+          changes["rate-limit"] = parsed.rateLimit;
+          diff.push({ property: "rate-limit", before: existing["rate-limit"] ?? null, after: parsed.rateLimit });
+        }
+        if (parsed.sessionTimeout !== void 0 && existing["session-timeout"] !== parsed.sessionTimeout) {
+          changes["session-timeout"] = parsed.sessionTimeout;
+          diff.push({ property: "session-timeout", before: existing["session-timeout"] ?? null, after: parsed.sessionTimeout });
+        }
+        if (parsed.comment !== void 0 && existing.comment !== parsed.comment) {
+          changes.comment = parsed.comment;
+          diff.push({ property: "comment", before: existing.comment ?? null, after: parsed.comment });
+        }
+        if (Object.keys(changes).length === 0) {
+          return {
+            content: `PPP profile "${parsed.name}" already matches requested values. No changes made.`,
+            structuredContent: { action: "no_change", name: parsed.name }
+          };
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would update PPP profile "${parsed.name}".`,
+            structuredContent: { action: "dry_run", diff }
+          };
+        }
+        await context.routerClient.update("ppp/profile", existing[".id"], changes);
+        log39.info({ name: parsed.name, id: existing[".id"] }, "PPP profile updated");
+        return {
+          content: `Updated PPP profile "${parsed.name}".`,
+          structuredContent: { action: "updated", name: parsed.name, id: existing[".id"], diff }
+        };
+      }
+      if (!existing) {
+        return {
+          content: `PPP profile "${parsed.name}" not found. Nothing to remove.`,
+          structuredContent: { action: "not_found", name: parsed.name }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would remove PPP profile "${parsed.name}".`,
+          structuredContent: { action: "dry_run", diff: [{ property: "name", before: parsed.name, after: null }] }
+        };
+      }
+      await context.routerClient.remove("ppp/profile", existing[".id"]);
+      log39.info({ name: parsed.name }, "PPP profile removed");
+      return {
+        content: `Removed PPP profile "${parsed.name}".`,
+        structuredContent: { action: "removed", name: parsed.name, id: existing[".id"] }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_ppp_profile" });
+    }
+  }
+};
+var pppTools = [listPppProfilesTool, managePppProfileTool];
+
+// src/domain/tools/upgrade-tools.ts
+import { z as z39 } from "zod";
+var log40 = createLogger("upgrade-tools");
+var getUpgradeStatusInputSchema = z39.object({
+  routerId: z39.string().describe("Target router identifier from the router registry")
 }).strict();
 var getUpgradeStatusTool = {
   name: "get_upgrade_status",
@@ -8777,7 +9390,7 @@ var getUpgradeStatusTool = {
   },
   async handler(params, context) {
     const parsed = getUpgradeStatusInputSchema.parse(params);
-    log39.info({ routerId: context.routerId }, "Getting upgrade status");
+    log40.info({ routerId: context.routerId }, "Getting upgrade status");
     try {
       const [updateResults, routerboardResults] = await Promise.all([
         context.routerClient.get("system/package/update"),
@@ -8806,12 +9419,12 @@ var getUpgradeStatusTool = {
     }
   }
 };
-var manageUpgradeInputSchema = z38.object({
-  routerId: z38.string().describe("Target router identifier from the router registry"),
-  action: z38.enum(["check", "install"]).describe(
+var manageUpgradeInputSchema = z39.object({
+  routerId: z39.string().describe("Target router identifier from the router registry"),
+  action: z39.enum(["check", "install"]).describe(
     "check \u2014 trigger a check for available updates; install \u2014 download and install the latest update (triggers reboot)"
   ),
-  dryRun: z38.boolean().default(false).describe("Preview the action without executing")
+  dryRun: z39.boolean().default(false).describe("Preview the action without executing")
 }).strict();
 var manageUpgradeTool = {
   name: "manage_upgrade",
@@ -8826,7 +9439,7 @@ var manageUpgradeTool = {
   },
   async handler(params, context) {
     const parsed = manageUpgradeInputSchema.parse(params);
-    log39.info({ routerId: context.routerId, action: parsed.action }, "Managing upgrade");
+    log40.info({ routerId: context.routerId, action: parsed.action }, "Managing upgrade");
     try {
       if (parsed.dryRun) {
         return {
@@ -8840,14 +9453,14 @@ var manageUpgradeTool = {
       }
       if (parsed.action === "check") {
         await context.routerClient.execute("system/package/update/check-for-updates");
-        log39.info({ routerId: context.routerId }, "Update check triggered");
+        log40.info({ routerId: context.routerId }, "Update check triggered");
         return {
           content: `Update check triggered on ${parsed.routerId}.`,
           structuredContent: { action: "check_triggered", routerId: parsed.routerId }
         };
       }
       await context.routerClient.execute("system/package/update/install");
-      log39.info({ routerId: context.routerId }, "Package install triggered");
+      log40.info({ routerId: context.routerId }, "Package install triggered");
       return {
         content: `Package install triggered on ${parsed.routerId}. Router will reboot automatically.`,
         structuredContent: { action: "install_triggered", routerId: parsed.routerId }
@@ -8860,13 +9473,13 @@ var manageUpgradeTool = {
 var upgradeTools = [getUpgradeStatusTool, manageUpgradeTool];
 
 // src/domain/tools/backup-tools.ts
-import { z as z39 } from "zod";
-var log40 = createLogger("backup-tools");
-var createBackupInputSchema = z39.object({
-  routerId: z39.string().describe("Target router identifier from the router registry"),
-  name: z39.string().default("backup").describe("Backup file name (without extension)"),
-  password: z39.string().optional().describe("Password to encrypt the backup file"),
-  dryRun: z39.boolean().default(false).describe("Preview the backup without creating it")
+import { z as z40 } from "zod";
+var log41 = createLogger("backup-tools");
+var createBackupInputSchema = z40.object({
+  routerId: z40.string().describe("Target router identifier from the router registry"),
+  name: z40.string().default("backup").describe("Backup file name (without extension)"),
+  password: z40.string().optional().describe("Password to encrypt the backup file"),
+  dryRun: z40.boolean().default(false).describe("Preview the backup without creating it")
 }).strict();
 var createBackupTool = {
   name: "create_backup",
@@ -8881,7 +9494,7 @@ var createBackupTool = {
   },
   async handler(params, context) {
     const parsed = createBackupInputSchema.parse(params);
-    log40.info({ routerId: context.routerId, name: parsed.name }, "Creating backup");
+    log41.info({ routerId: context.routerId, name: parsed.name }, "Creating backup");
     if (parsed.dryRun) {
       return {
         content: `Dry run: Would create backup "${parsed.name}.backup" on ${context.routerId}.`,
@@ -8894,7 +9507,7 @@ var createBackupTool = {
         body.password = parsed.password;
       }
       await context.routerClient.execute("system/backup/save", body);
-      log40.info({ routerId: context.routerId, name: parsed.name }, "Backup created");
+      log41.info({ routerId: context.routerId, name: parsed.name }, "Backup created");
       return {
         content: `Backup "${parsed.name}.backup" created on ${context.routerId}.`,
         structuredContent: {
@@ -8909,10 +9522,10 @@ var createBackupTool = {
     }
   }
 };
-var exportConfigInputSchema = z39.object({
-  routerId: z39.string().describe("Target router identifier from the router registry"),
-  compact: z39.boolean().default(false).describe("Export only non-default settings (compact format)"),
-  file: z39.string().optional().describe("Save the export to a file on the router (without extension); omit to return inline")
+var exportConfigInputSchema = z40.object({
+  routerId: z40.string().describe("Target router identifier from the router registry"),
+  compact: z40.boolean().default(false).describe("Export only non-default settings (compact format)"),
+  file: z40.string().optional().describe("Save the export to a file on the router (without extension); omit to return inline")
 }).strict();
 var exportConfigTool = {
   name: "export_config",
@@ -8927,7 +9540,7 @@ var exportConfigTool = {
   },
   async handler(params, context) {
     const parsed = exportConfigInputSchema.parse(params);
-    log40.info({ routerId: context.routerId, compact: parsed.compact }, "Exporting config");
+    log41.info({ routerId: context.routerId, compact: parsed.compact }, "Exporting config");
     try {
       if (parsed.file !== void 0) {
         const body = { file: parsed.file };
@@ -8961,16 +9574,16 @@ ${scriptText}`,
 var backupTools = [createBackupTool, exportConfigTool];
 
 // src/domain/tools/log-tools.ts
-import { z as z40 } from "zod";
-var log41 = createLogger("log-tools");
+import { z as z41 } from "zod";
+var log42 = createLogger("log-tools");
 var LOG_RULES_PATH = "system/logging";
 var LOG_ACTIONS_PATH = "system/logging/action";
-var logActionTypeEnum = z40.enum(["memory", "disk", "remote", "echo", "email"]);
-var listLogRulesInputSchema = z40.object({
-  routerId: z40.string().describe("Target router identifier from the router registry"),
-  topics: z40.string().optional().describe("Filter by topics (substring match)"),
-  logAction: z40.string().optional().describe("Filter by log action target (exact match on action field)"),
-  limit: z40.number().int().min(1).max(500).default(100).describe("Maximum number of rules to return (1-500, default 100)")
+var logActionTypeEnum = z41.enum(["memory", "disk", "remote", "echo", "email"]);
+var listLogRulesInputSchema = z41.object({
+  routerId: z41.string().describe("Target router identifier from the router registry"),
+  topics: z41.string().optional().describe("Filter by topics (substring match)"),
+  logAction: z41.string().optional().describe("Filter by log action target (exact match on action field)"),
+  limit: z41.number().int().min(1).max(500).default(100).describe("Maximum number of rules to return (1-500, default 100)")
 }).strict();
 var listLogRulesTool = {
   name: "list_log_rules",
@@ -8985,7 +9598,7 @@ var listLogRulesTool = {
   },
   async handler(params, context) {
     const parsed = listLogRulesInputSchema.parse(params);
-    log41.info({ routerId: context.routerId }, "Listing log rules");
+    log42.info({ routerId: context.routerId }, "Listing log rules");
     try {
       const all = await context.routerClient.get(LOG_RULES_PATH, {
         limit: void 0,
@@ -9014,13 +9627,13 @@ var listLogRulesTool = {
     }
   }
 };
-var manageLogRuleInputSchema = z40.object({
-  routerId: z40.string().describe("Target router identifier from the router registry"),
-  action: z40.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
-  topics: z40.string().describe("Log topics (e.g. firewall, system, info) \u2014 idempotency key"),
-  logAction: z40.string().describe("Log action target name (RouterOS action field) \u2014 idempotency key"),
-  prefix: z40.string().optional().describe("Optional prefix to prepend to log messages"),
-  dryRun: z40.boolean().default(false).describe("Preview changes without applying")
+var manageLogRuleInputSchema = z41.object({
+  routerId: z41.string().describe("Target router identifier from the router registry"),
+  action: z41.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
+  topics: z41.string().describe("Log topics (e.g. firewall, system, info) \u2014 idempotency key"),
+  logAction: z41.string().describe("Log action target name (RouterOS action field) \u2014 idempotency key"),
+  prefix: z41.string().optional().describe("Optional prefix to prepend to log messages"),
+  dryRun: z41.boolean().default(false).describe("Preview changes without applying")
 }).strict();
 var manageLogRuleTool = {
   name: "manage_log_rule",
@@ -9036,7 +9649,7 @@ var manageLogRuleTool = {
   snapshotPaths: ["system/logging"],
   async handler(params, context) {
     const parsed = manageLogRuleInputSchema.parse(params);
-    log41.info(
+    log42.info(
       { routerId: context.routerId, action: parsed.action, topics: parsed.topics },
       "Managing log rule"
     );
@@ -9078,7 +9691,7 @@ var manageLogRuleTool = {
           };
         }
         const created = await context.routerClient.create(LOG_RULES_PATH, body);
-        log41.info({ topics: parsed.topics, logAction: parsed.logAction, id: created[".id"] }, "Log rule added");
+        log42.info({ topics: parsed.topics, logAction: parsed.logAction, id: created[".id"] }, "Log rule added");
         return {
           content: `Added log rule topics="${parsed.topics}" action="${parsed.logAction}".`,
           structuredContent: {
@@ -9106,7 +9719,7 @@ var manageLogRuleTool = {
           };
         }
         await context.routerClient.remove(LOG_RULES_PATH, id);
-        log41.info({ topics: parsed.topics, logAction: parsed.logAction, id }, "Log rule removed");
+        log42.info({ topics: parsed.topics, logAction: parsed.logAction, id }, "Log rule removed");
         return {
           content: `Removed log rule topics="${parsed.topics}" action="${parsed.logAction}".`,
           structuredContent: { action: "removed", id }
@@ -9142,7 +9755,7 @@ var manageLogRuleTool = {
           disabled: wantDisabled ? "true" : "false"
         });
         const resultAction = wantDisabled ? "disabled" : "enabled";
-        log41.info({ topics: parsed.topics, id, action: resultAction }, "Log rule toggled");
+        log42.info({ topics: parsed.topics, id, action: resultAction }, "Log rule toggled");
         return {
           content: `${wantDisabled ? "Disabled" : "Enabled"} log rule topics="${parsed.topics}" action="${parsed.logAction}".`,
           structuredContent: { action: resultAction, id }
@@ -9163,10 +9776,10 @@ var manageLogRuleTool = {
     }
   }
 };
-var listLogActionsInputSchema = z40.object({
-  routerId: z40.string().describe("Target router identifier from the router registry"),
+var listLogActionsInputSchema = z41.object({
+  routerId: z41.string().describe("Target router identifier from the router registry"),
   type: logActionTypeEnum.optional().describe("Filter by action type (exact match): memory, disk, remote, echo, email"),
-  limit: z40.number().int().min(1).max(500).default(100).describe("Maximum number of actions to return (1-500, default 100)")
+  limit: z41.number().int().min(1).max(500).default(100).describe("Maximum number of actions to return (1-500, default 100)")
 }).strict();
 var listLogActionsTool = {
   name: "list_log_actions",
@@ -9181,7 +9794,7 @@ var listLogActionsTool = {
   },
   async handler(params, context) {
     const parsed = listLogActionsInputSchema.parse(params);
-    log41.info({ routerId: context.routerId }, "Listing log actions");
+    log42.info({ routerId: context.routerId }, "Listing log actions");
     try {
       const all = await context.routerClient.get(LOG_ACTIONS_PATH, {
         limit: void 0,
@@ -9207,15 +9820,15 @@ var listLogActionsTool = {
     }
   }
 };
-var manageLogActionInputSchema = z40.object({
-  routerId: z40.string().describe("Target router identifier from the router registry"),
-  action: z40.enum(["add", "remove"]).describe("Action to perform"),
-  name: z40.string().describe("Log action name \u2014 idempotency key"),
+var manageLogActionInputSchema = z41.object({
+  routerId: z41.string().describe("Target router identifier from the router registry"),
+  action: z41.enum(["add", "remove"]).describe("Action to perform"),
+  name: z41.string().describe("Log action name \u2014 idempotency key"),
   type: logActionTypeEnum.optional().describe("Action type: memory, disk, remote, echo, email (required on add)"),
-  remote: z40.string().optional().describe("Remote syslog server address (for type=remote)"),
-  remotePort: z40.number().int().min(1).max(65535).optional().describe("Remote syslog server port (for type=remote)"),
-  diskFileName: z40.string().optional().describe("Disk log file name without extension (for type=disk)"),
-  dryRun: z40.boolean().default(false).describe("Preview changes without applying")
+  remote: z41.string().optional().describe("Remote syslog server address (for type=remote)"),
+  remotePort: z41.number().int().min(1).max(65535).optional().describe("Remote syslog server port (for type=remote)"),
+  diskFileName: z41.string().optional().describe("Disk log file name without extension (for type=disk)"),
+  dryRun: z41.boolean().default(false).describe("Preview changes without applying")
 }).strict();
 var manageLogActionTool = {
   name: "manage_log_action",
@@ -9231,7 +9844,7 @@ var manageLogActionTool = {
   snapshotPaths: ["system/logging/action"],
   async handler(params, context) {
     const parsed = manageLogActionInputSchema.parse(params);
-    log41.info(
+    log42.info(
       { routerId: context.routerId, action: parsed.action, name: parsed.name },
       "Managing log action"
     );
@@ -9285,7 +9898,7 @@ var manageLogActionTool = {
           };
         }
         const created = await context.routerClient.create(LOG_ACTIONS_PATH, body);
-        log41.info({ name: parsed.name, type: parsed.type, id: created[".id"] }, "Log action added");
+        log42.info({ name: parsed.name, type: parsed.type, id: created[".id"] }, "Log action added");
         return {
           content: `Added log action "${parsed.name}" (type=${parsed.type}).`,
           structuredContent: {
@@ -9315,7 +9928,7 @@ var manageLogActionTool = {
           };
         }
         await context.routerClient.remove(LOG_ACTIONS_PATH, id);
-        log41.info({ name: parsed.name, id }, "Log action removed");
+        log42.info({ name: parsed.name, id }, "Log action removed");
         return {
           content: `Removed log action "${parsed.name}".`,
           structuredContent: { action: "removed", name: parsed.name, id }
@@ -9343,22 +9956,717 @@ var logTools = [
   manageLogActionTool
 ];
 
-// src/domain/tools/fleet-tools.ts
-import { z as z41 } 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);
-}
-function checkAuthz(identity, toolName, routerId) {
-  if (identity.allowedRouters.length > 0 && !identity.allowedRouters.includes(routerId)) {
-    throw new MikroMCPError({
-      category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
-      code: "ROUTER_NOT_ALLOWED",
-      message: `Identity "${identity.id}" is not allowed to access router "${routerId}".`,
-      details: { identityId: identity.id, routerId, allowedRouters: identity.allowedRouters },
+// src/domain/tools/network-test-tools.ts
+import { z as z42 } from "zod";
+var log43 = createLogger("network-test-tools");
+var BODY_CAP = 65536;
+var bandwidthTestInputSchema = z42.object({
+  routerId: z42.string().describe("Target router identifier from the router registry"),
+  address: z42.string().describe("Remote host running RouterOS btest server"),
+  protocol: z42.enum(["tcp", "udp"]).default("tcp").describe("Test protocol"),
+  direction: z42.enum(["send", "receive", "both"]).default("both").describe("Test direction"),
+  duration: z42.number().int().min(1).max(30).default(5).describe("Test duration in seconds (max 30)")
+}).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.",
+  inputSchema: bandwidthTestInputSchema,
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+  async handler(params, context) {
+    const parsed = bandwidthTestInputSchema.parse(params);
+    log43.info({ routerId: context.routerId, address: parsed.address }, "Running bandwidth test");
+    try {
+      const result = await context.routerClient.execute("tool/bandwidth-test", {
+        address: parsed.address,
+        protocol: parsed.protocol,
+        direction: parsed.direction,
+        duration: String(parsed.duration)
+      });
+      const txBps = Number(result["tx-current"] ?? 0);
+      const rxBps = Number(result["rx-current"] ?? 0);
+      const txMbps = Math.round(txBps / 1e6 * 100) / 100;
+      const rxMbps = Math.round(rxBps / 1e6 * 100) / 100;
+      return {
+        content: `Bandwidth test to ${parsed.address}: TX=${txMbps} Mbps RX=${rxMbps} Mbps`,
+        structuredContent: {
+          routerId: context.routerId,
+          address: parsed.address,
+          protocol: parsed.protocol,
+          direction: parsed.direction,
+          txMbps,
+          rxMbps,
+          lostPackets: result["lost-packets"] ?? null
+        }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "bandwidth_test" });
+    }
+  }
+};
+var fetchUrlInputSchema = z42.object({
+  routerId: z42.string().describe("Target router identifier from the router registry"),
+  url: z42.string().url().describe("URL to fetch from the router"),
+  method: z42.enum(["GET", "POST"]).default("GET").describe("HTTP method"),
+  httpData: z42.string().optional().describe("Request body for POST"),
+  outputFile: z42.string().optional().describe("Save response body to this router file path instead of returning inline")
+}).strict();
+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.",
+  inputSchema: fetchUrlInputSchema,
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+  async handler(params, context) {
+    const parsed = fetchUrlInputSchema.parse(params);
+    log43.info({ routerId: context.routerId, url: parsed.url, method: parsed.method }, "Fetching URL");
+    try {
+      const body = { url: parsed.url, "http-method": parsed.method.toLowerCase() };
+      if (parsed.httpData) body["http-data"] = parsed.httpData;
+      if (parsed.outputFile) {
+        body.output = "file";
+        body["dst-path"] = parsed.outputFile;
+      } else {
+        body.output = "user";
+      }
+      const sections = await context.routerClient.execute("tool/fetch", body);
+      const finished = sections.find((s) => s.status === "finished") ?? sections[sections.length - 1];
+      const statusCode = finished?.code ?? null;
+      if (parsed.outputFile) {
+        return {
+          content: `Fetched ${parsed.url} \u2192 saved to ${parsed.outputFile} (status ${statusCode})`,
+          structuredContent: { routerId: context.routerId, url: parsed.url, statusCode, outputFile: parsed.outputFile }
+        };
+      }
+      let responseBody = finished?.data ?? "";
+      if (responseBody.length > BODY_CAP) {
+        responseBody = responseBody.slice(0, BODY_CAP) + "[TRUNCATED]";
+      }
+      return {
+        content: `Fetched ${parsed.url}: status=${statusCode} body_length=${responseBody.length}`,
+        structuredContent: { routerId: context.routerId, url: parsed.url, statusCode, body: responseBody }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "fetch_url" });
+    }
+  }
+};
+var listConnectionsInputSchema = z42.object({
+  routerId: z42.string().describe("Target router identifier from the router registry"),
+  srcAddress: z42.string().optional().describe("Filter by source address (substring match)"),
+  dstAddress: z42.string().optional().describe("Filter by destination address (substring match)"),
+  protocol: z42.string().optional().describe("Filter by protocol (exact match, e.g. tcp, udp, icmp)"),
+  limit: z42.number().int().min(1).max(500).default(100).describe("Maximum connections to return")
+}).strict();
+var listConnectionsTool = {
+  name: "list_connections",
+  title: "List Connections",
+  description: "List active connection tracking entries from the router firewall table. Filters are applied client-side. Useful for diagnosing NAT and firewall behavior.",
+  inputSchema: listConnectionsInputSchema,
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  async handler(params, context) {
+    const parsed = listConnectionsInputSchema.parse(params);
+    log43.info({ routerId: context.routerId }, "Listing connections");
+    try {
+      const all = await context.routerClient.get("ip/firewall/connection", {
+        limit: void 0,
+        offset: void 0
+      });
+      const filtered = all.filter((c) => parsed.srcAddress ? (c["src-address"] ?? "").includes(parsed.srcAddress) : true).filter((c) => parsed.dstAddress ? (c["dst-address"] ?? "").includes(parsed.dstAddress) : true).filter((c) => parsed.protocol ? c.protocol === parsed.protocol : true);
+      const connections = filtered.slice(0, parsed.limit);
+      return {
+        content: `Active connections on ${context.routerId}: ${connections.length} returned (${all.length} total)`,
+        structuredContent: { routerId: context.routerId, connections, total: all.length, returned: connections.length }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "list_connections" });
+    }
+  }
+};
+var networkTestTools = [bandwidthTestTool, fetchUrlTool, listConnectionsTool];
+
+// src/domain/tools/container-config-tools.ts
+import { z as z43 } from "zod";
+var log44 = createLogger("container-config-tools");
+var getContainerConfigInputSchema = z43.object({ routerId: z43.string().describe("Target router identifier from the router registry") }).strict();
+var getContainerConfigTool = {
+  name: "get_container_config",
+  title: "Get Container Config",
+  description: "Read global container configuration: registry URL, RAM high-water mark, and veth interface.",
+  inputSchema: getContainerConfigInputSchema,
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  async handler(params, context) {
+    getContainerConfigInputSchema.parse(params);
+    log44.info({ routerId: context.routerId }, "Getting container config");
+    try {
+      const results2 = await context.routerClient.get("container/config");
+      const cfg = Array.isArray(results2) && results2.length > 0 ? results2[0] : results2;
+      return {
+        content: `Container config on ${context.routerId}: registry=${cfg["registry-url"] ?? "none"} ram-high=${cfg["ram-high"] ?? "?"}MB veth=${cfg["veth-interface"] ?? "none"}`,
+        structuredContent: {
+          routerId: context.routerId,
+          registryUrl: cfg["registry-url"] ?? null,
+          ramHighMb: cfg["ram-high"] ?? null,
+          vethInterface: cfg["veth-interface"] ?? null
+        }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "get_container_config" });
+    }
+  }
+};
+var manageContainerConfigInputSchema = z43.object({
+  routerId: z43.string().describe("Target router identifier from the router registry"),
+  registryUrl: z43.string().optional().describe("Container registry URL"),
+  ramHighMb: z43.number().int().min(1).optional().describe("RAM high-water mark in MB"),
+  vethInterface: z43.string().optional().describe("Veth interface name for container networking"),
+  dryRun: z43.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageContainerConfigTool = {
+  name: "manage_container_config",
+  title: "Manage Container Config",
+  description: "Update global container settings. Idempotent: returns no_change if nothing differs.",
+  inputSchema: manageContainerConfigInputSchema,
+  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  snapshotPaths: ["container/config"],
+  async handler(params, context) {
+    const parsed = manageContainerConfigInputSchema.parse(params);
+    log44.info({ routerId: context.routerId }, "Managing container config");
+    try {
+      const results2 = await context.routerClient.get("container/config");
+      const current = Array.isArray(results2) && results2.length > 0 ? results2[0] : results2;
+      const id = current[".id"];
+      const changes = {};
+      const diff = [];
+      if (parsed.registryUrl !== void 0 && current["registry-url"] !== parsed.registryUrl) {
+        changes["registry-url"] = parsed.registryUrl;
+        diff.push({ property: "registry-url", before: current["registry-url"] ?? null, after: parsed.registryUrl });
+      }
+      if (parsed.ramHighMb !== void 0) {
+        const next = String(parsed.ramHighMb);
+        if (current["ram-high"] !== next) {
+          changes["ram-high"] = next;
+          diff.push({ property: "ram-high", before: current["ram-high"] ?? null, after: next });
+        }
+      }
+      if (parsed.vethInterface !== void 0 && current["veth-interface"] !== parsed.vethInterface) {
+        changes["veth-interface"] = parsed.vethInterface;
+        diff.push({ property: "veth-interface", before: current["veth-interface"] ?? null, after: parsed.vethInterface });
+      }
+      if (Object.keys(changes).length === 0) {
+        return {
+          content: "Container config already matches. No changes made.",
+          structuredContent: { action: "no_change", routerId: context.routerId }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would update container config on ${context.routerId}.`,
+          structuredContent: { action: "dry_run", diff }
+        };
+      }
+      await context.routerClient.update("container/config", id, changes);
+      log44.info({ routerId: context.routerId }, "Container config updated");
+      return {
+        content: `Updated container config on ${context.routerId}.`,
+        structuredContent: { action: "updated", routerId: context.routerId, diff }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_container_config" });
+    }
+  }
+};
+var listContainerEnvsInputSchema = z43.object({
+  routerId: z43.string().describe("Target router identifier from the router registry"),
+  name: z43.string().optional().describe("Filter by container name (exact match)"),
+  limit: z43.number().int().min(1).max(500).default(100).describe("Maximum entries to return")
+}).strict();
+var listContainerEnvsTool = {
+  name: "list_container_envs",
+  title: "List Container Envs",
+  description: "List container environment variable entries, optionally filtered by container name.",
+  inputSchema: listContainerEnvsInputSchema,
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  async handler(params, context) {
+    const parsed = listContainerEnvsInputSchema.parse(params);
+    log44.info({ routerId: context.routerId }, "Listing container envs");
+    try {
+      const all = await context.routerClient.get("container/envs", {
+        limit: void 0,
+        offset: void 0
+      });
+      const filtered = parsed.name ? all.filter((e) => e.name === parsed.name) : all;
+      const envs = filtered.slice(0, parsed.limit);
+      return {
+        content: `Container envs on ${context.routerId}: ${envs.length} returned`,
+        structuredContent: { routerId: context.routerId, envs, total: all.length, returned: envs.length }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "list_container_envs" });
+    }
+  }
+};
+var manageContainerEnvInputSchema = z43.object({
+  routerId: z43.string().describe("Target router identifier from the router registry"),
+  action: z43.enum(["add", "remove"]).describe("Action to perform"),
+  name: z43.string().describe("Container name"),
+  key: z43.string().describe("Environment variable name \u2014 part of idempotency key"),
+  value: z43.string().optional().describe("Environment variable value (required for add)"),
+  dryRun: z43.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageContainerEnvTool = {
+  name: "manage_container_env",
+  title: "Manage Container Env",
+  description: "Add or remove a container environment variable. Idempotent by name+key. add returns already_exists if the entry exists with the same value; throws CONFLICT if the value differs.",
+  inputSchema: manageContainerEnvInputSchema,
+  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  async handler(params, context) {
+    const parsed = manageContainerEnvInputSchema.parse(params);
+    log44.info(
+      { routerId: context.routerId, action: parsed.action, name: parsed.name, key: parsed.key },
+      "Managing container env"
+    );
+    try {
+      const all = await context.routerClient.get("container/envs", {
+        limit: void 0,
+        offset: void 0
+      });
+      const existing = all.find(
+        (e) => e.name === parsed.name && e.key === parsed.key
+      );
+      if (parsed.action === "add") {
+        if (existing) {
+          if (existing.value === parsed.value) {
+            return {
+              content: `Env ${parsed.name}.${parsed.key} already exists with same value.`,
+              structuredContent: { action: "already_exists", name: parsed.name, key: parsed.key }
+            };
+          }
+          throw new MikroMCPError({
+            category: "CONFLICT" /* CONFLICT */,
+            code: "CONTAINER_ENV_CONFLICT",
+            message: `Env ${parsed.name}.${parsed.key} exists with a different value.`,
+            details: { existingValue: existing.value, requestedValue: parsed.value },
+            recoverability: {
+              retryable: false,
+              suggestedAction: "Remove the existing entry first.",
+              alternativeTools: ["manage_container_env"]
+            }
+          });
+        }
+        if (parsed.value === void 0) {
+          throw new MikroMCPError({
+            category: "VALIDATION" /* VALIDATION */,
+            code: "ENV_VALUE_REQUIRED",
+            message: "value is required for add.",
+            recoverability: { retryable: false, suggestedAction: "Provide the value parameter." }
+          });
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would add env ${parsed.name}.${parsed.key}=${parsed.value}.`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [{ property: "value", before: null, after: parsed.value }]
+            }
+          };
+        }
+        const created = await context.routerClient.create("container/envs", {
+          name: parsed.name,
+          key: parsed.key,
+          value: parsed.value
+        });
+        log44.info({ name: parsed.name, key: parsed.key, id: created[".id"] }, "Container env added");
+        return {
+          content: `Added env ${parsed.name}.${parsed.key}.`,
+          structuredContent: {
+            action: "created",
+            name: parsed.name,
+            key: parsed.key,
+            id: created[".id"]
+          }
+        };
+      }
+      if (!existing) {
+        return {
+          content: `Env ${parsed.name}.${parsed.key} not found. Nothing to remove.`,
+          structuredContent: { action: "not_found", name: parsed.name, key: parsed.key }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would remove env ${parsed.name}.${parsed.key}.`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [{ property: "key", before: parsed.key, after: null }]
+          }
+        };
+      }
+      await context.routerClient.remove("container/envs", existing[".id"]);
+      log44.info({ name: parsed.name, key: parsed.key }, "Container env removed");
+      return {
+        content: `Removed env ${parsed.name}.${parsed.key}.`,
+        structuredContent: { action: "removed", name: parsed.name, key: parsed.key }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_container_env" });
+    }
+  }
+};
+var listContainerMountsInputSchema = z43.object({
+  routerId: z43.string().describe("Target router identifier from the router registry"),
+  name: z43.string().optional().describe("Filter by mount name (exact match)"),
+  limit: z43.number().int().min(1).max(500).default(100).describe("Maximum entries to return")
+}).strict();
+var listContainerMountsTool = {
+  name: "list_container_mounts",
+  title: "List Container Mounts",
+  description: "List container volume mount definitions with source path, destination path, and mount name.",
+  inputSchema: listContainerMountsInputSchema,
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  async handler(params, context) {
+    const parsed = listContainerMountsInputSchema.parse(params);
+    log44.info({ routerId: context.routerId }, "Listing container mounts");
+    try {
+      const all = await context.routerClient.get("container/mounts", {
+        limit: void 0,
+        offset: void 0
+      });
+      const filtered = parsed.name ? all.filter((m) => m.name === parsed.name) : all;
+      const mounts = filtered.slice(0, parsed.limit);
+      return {
+        content: `Container mounts on ${context.routerId}: ${mounts.length} returned`,
+        structuredContent: { routerId: context.routerId, mounts, total: all.length, returned: mounts.length }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "list_container_mounts" });
+    }
+  }
+};
+var manageContainerMountInputSchema = z43.object({
+  routerId: z43.string().describe("Target router identifier from the router registry"),
+  action: z43.enum(["add", "remove"]).describe("Action to perform"),
+  name: z43.string().describe("Mount name \u2014 idempotency key"),
+  src: z43.string().optional().describe("Host source path (required for add)"),
+  dst: z43.string().optional().describe("Container destination path (required for add)"),
+  dryRun: z43.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageContainerMountTool = {
+  name: "manage_container_mount",
+  title: "Manage Container Mount",
+  description: "Add or remove a container volume mount. Idempotent by name: add returns already_exists if the mount exists with matching src/dst; throws CONFLICT if name exists with different paths.",
+  inputSchema: manageContainerMountInputSchema,
+  annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  async handler(params, context) {
+    const parsed = manageContainerMountInputSchema.parse(params);
+    log44.info({ routerId: context.routerId, action: parsed.action, name: parsed.name }, "Managing container mount");
+    try {
+      const all = await context.routerClient.get("container/mounts", {
+        limit: void 0,
+        offset: void 0
+      });
+      const existing = all.find((m) => m.name === parsed.name);
+      if (parsed.action === "add") {
+        if (existing) {
+          if (existing.src === parsed.src && existing.dst === parsed.dst) {
+            return {
+              content: `Mount "${parsed.name}" already exists with same paths.`,
+              structuredContent: { action: "already_exists", name: parsed.name }
+            };
+          }
+          throw new MikroMCPError({
+            category: "CONFLICT" /* CONFLICT */,
+            code: "CONTAINER_MOUNT_CONFLICT",
+            message: `Mount "${parsed.name}" exists with different src/dst paths.`,
+            details: {
+              existing: { src: existing.src, dst: existing.dst },
+              requested: { src: parsed.src, dst: parsed.dst }
+            },
+            recoverability: {
+              retryable: false,
+              suggestedAction: "Remove the existing mount first.",
+              alternativeTools: ["manage_container_mount"]
+            }
+          });
+        }
+        if (!parsed.src || !parsed.dst) {
+          throw new MikroMCPError({
+            category: "VALIDATION" /* VALIDATION */,
+            code: "MOUNT_PATHS_REQUIRED",
+            message: "src and dst are required for add.",
+            recoverability: { retryable: false, suggestedAction: "Provide src and dst parameters." }
+          });
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would add mount "${parsed.name}" ${parsed.src} \u2192 ${parsed.dst}.`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [{ property: "name", before: null, after: parsed.name }]
+            }
+          };
+        }
+        const created = await context.routerClient.create("container/mounts", {
+          name: parsed.name,
+          src: parsed.src,
+          dst: parsed.dst
+        });
+        log44.info({ name: parsed.name, id: created[".id"] }, "Container mount added");
+        return {
+          content: `Added mount "${parsed.name}".`,
+          structuredContent: { action: "created", name: parsed.name, id: created[".id"] }
+        };
+      }
+      if (!existing) {
+        return {
+          content: `Mount "${parsed.name}" not found. Nothing to remove.`,
+          structuredContent: { action: "not_found", name: parsed.name }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would remove mount "${parsed.name}".`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [{ property: "name", before: parsed.name, after: null }]
+          }
+        };
+      }
+      await context.routerClient.remove("container/mounts", existing[".id"]);
+      log44.info({ name: parsed.name }, "Container mount removed");
+      return {
+        content: `Removed mount "${parsed.name}".`,
+        structuredContent: { action: "removed", name: parsed.name }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_container_mount" });
+    }
+  }
+};
+var containerConfigTools = [
+  getContainerConfigTool,
+  manageContainerConfigTool,
+  listContainerEnvsTool,
+  manageContainerEnvTool,
+  listContainerMountsTool,
+  manageContainerMountTool
+];
+
+// src/domain/tools/interface-list-tools.ts
+import { z as z44 } from "zod";
+var log45 = createLogger("interface-list-tools");
+var listInterfaceListsInputSchema = z44.object({
+  routerId: z44.string().describe("Target router identifier from the router registry"),
+  limit: z44.number().int().min(1).max(500).default(100).describe("Maximum lists to return")
+}).strict();
+var listInterfaceListsTool = {
+  name: "list_interface_lists",
+  title: "List Interface Lists",
+  description: "List all interface lists defined on the router.",
+  inputSchema: listInterfaceListsInputSchema,
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  async handler(params, context) {
+    const parsed = listInterfaceListsInputSchema.parse(params);
+    log45.info({ routerId: context.routerId }, "Listing interface lists");
+    try {
+      const all = await context.routerClient.get("interface/list", {
+        limit: void 0,
+        offset: void 0
+      });
+      const lists = all.slice(0, parsed.limit);
+      return {
+        content: `Interface lists on ${context.routerId}: ${lists.length} returned`,
+        structuredContent: { routerId: context.routerId, lists, total: all.length, returned: lists.length }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "list_interface_lists" });
+    }
+  }
+};
+var manageInterfaceListInputSchema = z44.object({
+  routerId: z44.string().describe("Target router identifier from the router registry"),
+  action: z44.enum(["add", "remove"]).describe("Action to perform"),
+  name: z44.string().describe("Interface list name \u2014 idempotency key"),
+  comment: z44.string().optional().describe("Optional comment"),
+  dryRun: z44.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageInterfaceListTool = {
+  name: "manage_interface_list",
+  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 },
+  async handler(params, context) {
+    const parsed = manageInterfaceListInputSchema.parse(params);
+    log45.info({ routerId: context.routerId, action: parsed.action, name: parsed.name }, "Managing interface list");
+    try {
+      const all = await context.routerClient.get("interface/list", {
+        limit: void 0,
+        offset: void 0
+      });
+      const existing = all.find((l) => l.name === parsed.name);
+      if (parsed.action === "add") {
+        if (existing) {
+          return {
+            content: `Interface list "${parsed.name}" already exists. No changes made.`,
+            structuredContent: { action: "already_exists", name: parsed.name }
+          };
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would create interface list "${parsed.name}".`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [{ property: "name", before: null, after: parsed.name }]
+            }
+          };
+        }
+        const body = { name: parsed.name };
+        if (parsed.comment) body.comment = parsed.comment;
+        const created = await context.routerClient.create("interface/list", body);
+        log45.info({ name: parsed.name, id: created[".id"] }, "Interface list created");
+        return {
+          content: `Created interface list "${parsed.name}".`,
+          structuredContent: { action: "created", name: parsed.name, id: created[".id"] }
+        };
+      }
+      if (!existing) {
+        return {
+          content: `Interface list "${parsed.name}" not found. Nothing to remove.`,
+          structuredContent: { action: "not_found", name: parsed.name }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would remove interface list "${parsed.name}".`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [{ property: "name", before: parsed.name, after: null }]
+          }
+        };
+      }
+      await context.routerClient.remove("interface/list", existing[".id"]);
+      log45.info({ name: parsed.name }, "Interface list removed");
+      return {
+        content: `Removed interface list "${parsed.name}".`,
+        structuredContent: { action: "removed", name: parsed.name, id: existing[".id"] }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_interface_list" });
+    }
+  }
+};
+var manageInterfaceListMemberInputSchema = z44.object({
+  routerId: z44.string().describe("Target router identifier from the router registry"),
+  action: z44.enum(["add", "remove"]).describe("Action to perform"),
+  list: z44.string().describe("Interface list name \u2014 part of composite idempotency key"),
+  interface: z44.string().describe("Interface name to add/remove \u2014 part of composite idempotency key"),
+  comment: z44.string().optional().describe("Optional comment"),
+  dryRun: z44.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageInterfaceListMemberTool = {
+  name: "manage_interface_list_member",
+  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 },
+  async handler(params, context) {
+    const parsed = manageInterfaceListMemberInputSchema.parse(params);
+    log45.info(
+      { routerId: context.routerId, action: parsed.action, list: parsed.list, interface: parsed.interface },
+      "Managing interface list member"
+    );
+    try {
+      const all = await context.routerClient.get("interface/list/member", {
+        limit: void 0,
+        offset: void 0
+      });
+      const existing = all.find(
+        (m) => m.list === parsed.list && m.interface === parsed.interface
+      );
+      if (parsed.action === "add") {
+        if (existing) {
+          return {
+            content: `Interface "${parsed.interface}" is already a member of list "${parsed.list}". No changes made.`,
+            structuredContent: { action: "already_exists", list: parsed.list, interface: parsed.interface }
+          };
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would add "${parsed.interface}" to list "${parsed.list}".`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [{ property: "interface", before: null, after: parsed.interface }]
+            }
+          };
+        }
+        const body = { list: parsed.list, interface: parsed.interface };
+        if (parsed.comment) body.comment = parsed.comment;
+        const created = await context.routerClient.create("interface/list/member", body);
+        log45.info({ list: parsed.list, interface: parsed.interface, id: created[".id"] }, "Interface list member added");
+        return {
+          content: `Added "${parsed.interface}" to list "${parsed.list}".`,
+          structuredContent: { action: "created", list: parsed.list, interface: parsed.interface, id: created[".id"] }
+        };
+      }
+      if (!existing) {
+        return {
+          content: `Interface "${parsed.interface}" is not a member of list "${parsed.list}". Nothing to remove.`,
+          structuredContent: { action: "not_found", list: parsed.list, interface: parsed.interface }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would remove "${parsed.interface}" from list "${parsed.list}".`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [{ property: "interface", before: parsed.interface, after: null }]
+          }
+        };
+      }
+      await context.routerClient.remove("interface/list/member", existing[".id"]);
+      log45.info({ list: parsed.list, interface: parsed.interface }, "Interface list member removed");
+      return {
+        content: `Removed "${parsed.interface}" from list "${parsed.list}".`,
+        structuredContent: {
+          action: "removed",
+          list: parsed.list,
+          interface: parsed.interface,
+          id: existing[".id"]
+        }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_interface_list_member" });
+    }
+  }
+};
+var interfaceListTools = [
+  listInterfaceListsTool,
+  manageInterfaceListTool,
+  manageInterfaceListMemberTool
+];
+
+// src/domain/tools/fleet-tools.ts
+import { z as z45 } 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);
+}
+function checkAuthz(identity, toolName, routerId) {
+  if (identity.allowedRouters.length > 0 && !identity.allowedRouters.includes(routerId)) {
+    throw new MikroMCPError({
+      category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
+      code: "ROUTER_NOT_ALLOWED",
+      message: `Identity "${identity.id}" is not allowed to access router "${routerId}".`,
+      details: { identityId: identity.id, routerId, allowedRouters: identity.allowedRouters },
       recoverability: {
         retryable: false,
         suggestedAction: `Add "${routerId}" to allowedRouters for identity "${identity.id}" in identities.yaml.`
@@ -9512,7 +10820,7 @@ var SshClient = class {
 // src/adapter/ftp-client.ts
 import { Client as Client2 } from "basic-ftp";
 import { Readable } from "stream";
-var log42 = createLogger("ftp-client");
+var log46 = createLogger("ftp-client");
 var FtpClient = class {
   #host;
   #port;
@@ -9525,7 +10833,7 @@ var FtpClient = class {
     this.#password = password;
   }
   async upload(remoteName, content) {
-    log42.info({ host: this.#host, remoteName }, "Uploading file via FTP");
+    log46.info({ host: this.#host, remoteName }, "Uploading file via FTP");
     const client = new Client2();
     try {
       await client.access({
@@ -9535,7 +10843,7 @@ var FtpClient = class {
         password: this.#password
       });
       await client.uploadFrom(Readable.from(Buffer.from(content, "utf-8")), remoteName);
-      log42.info({ host: this.#host, remoteName }, "FTP upload complete");
+      log46.info({ host: this.#host, remoteName }, "FTP upload complete");
     } finally {
       client.close();
     }
@@ -9643,17 +10951,17 @@ function checkFleetConfirmation(args, secret) {
 }
 
 // src/domain/tools/fleet-tools.ts
-var log43 = createLogger("fleet-tools");
-var checkHealthInputSchema = z41.object({
-  routerId: z41.string().describe("Target router to health-check")
+var log47 = createLogger("fleet-tools");
+var checkHealthInputSchema = z45.object({
+  routerId: z45.string().describe("Target router to health-check")
 }).strict();
-var bulkExecuteInputSchema = z41.object({
-  toolName: z41.string().describe("Name of the tool to fan out (must be a single-router tool)"),
-  routerIds: z41.array(z41.string()).optional().describe("Explicit list of router IDs to target"),
-  tags: z41.array(z41.string()).optional().describe("Target all routers with ALL of these tags (mutually exclusive with routerIds)"),
-  params: z41.record(z41.string(), z41.unknown()).describe("Params to pass to the tool (omit routerId \u2014 injected per router)"),
-  concurrency: z41.number().int().min(1).max(20).default(5).describe("Max simultaneous router calls"),
-  confirmationToken: z41.string().optional().describe(
+var bulkExecuteInputSchema = z45.object({
+  toolName: z45.string().describe("Name of the tool to fan out (must be a single-router tool)"),
+  routerIds: z45.array(z45.string()).optional().describe("Explicit list of router IDs to target"),
+  tags: z45.array(z45.string()).optional().describe("Target all routers with ALL of these tags (mutually exclusive with routerIds)"),
+  params: z45.record(z45.string(), z45.unknown()).describe("Params to pass to the tool (omit routerId \u2014 injected per router)"),
+  concurrency: z45.number().int().min(1).max(20).default(5).describe("Max simultaneous router calls"),
+  confirmationToken: z45.string().optional().describe(
     "Fleet confirmation token from a prior APPROVAL_REQUIRED response. Required to fan out a destructive tool."
   )
 }).strict();
@@ -9672,7 +10980,7 @@ function createFleetTools(baseTools2) {
     },
     async handler(params, context) {
       checkHealthInputSchema.parse(params);
-      log43.info({ routerId: context.routerId }, "Checking router health");
+      log47.info({ routerId: context.routerId }, "Checking router health");
       const startMs = Date.now();
       try {
         const resources = await context.routerClient.get("system/resource");
@@ -9734,7 +11042,7 @@ function createFleetTools(baseTools2) {
           }
         });
       }
-      log43.info(
+      log47.info(
         { toolName: parsed.toolName, concurrency: parsed.concurrency },
         "bulk_execute invoked"
       );
@@ -9781,7 +11089,7 @@ function createFleetTools(baseTools2) {
           try {
             resolved.push(context.routerRegistry.getRouter(id));
           } catch {
-            log43.warn({ routerId: id }, "bulk_execute: router not found");
+            log47.warn({ routerId: id }, "bulk_execute: router not found");
             preErrors.push({
               routerId: id,
               status: "error",
@@ -9963,9 +11271,13 @@ var baseTools = [
   ...ipServiceTools,
   ...pppoeTools,
   ...ovpnTools,
+  ...pppTools,
   ...upgradeTools,
   ...backupTools,
-  ...logTools
+  ...logTools,
+  ...networkTestTools,
+  ...containerConfigTools,
+  ...interfaceListTools
 ];
 var allTools = [
   ...baseTools,
@@ -10364,7 +11676,7 @@ var CircuitBreaker = class {
 };
 
 // src/mcp/tool-executor.ts
-var log44 = createLogger("tool-executor");
+var log48 = createLogger("tool-executor");
 async function executeToolCall(tool, args, deps) {
   const { registry, pool, circuitBreakers, config, identityRegistry } = deps;
   const correlationId = nanoid4();
@@ -10460,9 +11772,9 @@ async function executeToolCall(tool, args, deps) {
           try {
             const meta = await takeSnapshot(toolContext.routerClient, routerId, path, config.snapshotDir);
             snapshotIds.push(meta.id);
-            log44.debug({ snapshotId: meta.id, path }, "Snapshot taken");
+            log48.debug({ snapshotId: meta.id, path }, "Snapshot taken");
           } catch (err) {
-            log44.warn({ err, path, routerId }, "Snapshot failed \u2014 proceeding without snapshot");
+            log48.warn({ err, path, routerId }, "Snapshot failed \u2014 proceeding without snapshot");
           }
         }
       }
@@ -10504,7 +11816,7 @@ async function executeToolCall(tool, args, deps) {
           durationMs: Date.now() - startMs
         }, config.auditLogPath);
       }
-      log44.info({ tool: tool.name, routerId, correlationId }, "Tool executed successfully");
+      log48.info({ tool: tool.name, routerId, correlationId }, "Tool executed successfully");
       recordToolCall(tool.name, "success");
       return formatToolResult(result);
     } catch (err) {
@@ -10513,7 +11825,7 @@ async function executeToolCall(tool, args, deps) {
         const failedRouterId = args.routerId;
         if (failedRouterId) {
           pool.removeClient(failedRouterId);
-          log44.info({ routerId: failedRouterId }, "Evicted pooled client after auth failure");
+          log48.info({ routerId: failedRouterId }, "Evicted pooled client after auth failure");
         }
       }
       if (journalId) {
@@ -10543,7 +11855,7 @@ async function executeToolCall(tool, args, deps) {
           durationMs: Date.now() - startMs
         }, config.auditLogPath);
       }
-      log44.error({ err: error, tool: tool.name, correlationId }, "Tool execution failed");
+      log48.error({ err: error, tool: tool.name, correlationId }, "Tool execution failed");
       recordToolCall(tool.name, "error");
       return formatError(error);
     }
@@ -10551,12 +11863,12 @@ async function executeToolCall(tool, args, deps) {
 }
 
 // src/mcp/tool-registry.ts
-var log45 = createLogger("tool-registry");
+var log49 = 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: z42.string().optional().describe(
+      confirmationToken: z46.string().optional().describe(
         "Token from a prior APPROVAL_REQUIRED response. Re-submit the identical call with this token to confirm the destructive action."
       )
     }) : tool.inputSchema;
@@ -10570,56 +11882,56 @@ function registerAllTools(server, registry, pool, circuitBreakers, config, ident
       },
       (args) => executeToolCall(tool, args, deps)
     );
-    log45.debug({ tool: tool.name }, "Registered tool");
+    log49.debug({ tool: tool.name }, "Registered tool");
   }
-  log45.info({ count: allTools.length }, "All tools registered");
+  log49.info({ count: allTools.length }, "All tools registered");
 }
 
 // src/config/router-registry.ts
 import { readFileSync as readFileSync2, existsSync } from "fs";
 import { parse } from "yaml";
-import { z as z43 } from "zod";
-var log46 = createLogger("router-registry");
-var RouterConfigSchema = z43.object({
-  host: z43.string().min(1, "host is required"),
-  port: z43.number().int().min(1).max(65535),
-  tls: z43.object({
-    enabled: z43.boolean(),
-    rejectUnauthorized: z43.boolean(),
-    ca: z43.string().optional(),
-    fingerprint: z43.string().optional()
+import { z as z47 } from "zod";
+var log50 = createLogger("router-registry");
+var RouterConfigSchema = z47.object({
+  host: z47.string().min(1, "host is required"),
+  port: z47.number().int().min(1).max(65535),
+  tls: z47.object({
+    enabled: z47.boolean(),
+    rejectUnauthorized: z47.boolean(),
+    ca: z47.string().optional(),
+    fingerprint: z47.string().optional()
   }).strict(),
-  credentials: z43.object({
-    source: z43.enum(["env", "vault"]),
-    envPrefix: z43.string().optional(),
-    vaultPath: z43.string().optional()
+  credentials: z47.object({
+    source: z47.enum(["env", "vault"]),
+    envPrefix: z47.string().optional(),
+    vaultPath: z47.string().optional()
   }).strict(),
-  tags: z43.array(z43.string()).default([]),
-  rosVersion: z43.string().min(1),
-  sshPort: z43.number().int().min(1).max(65535).optional(),
-  sshFingerprint: z43.string().optional(),
-  cmdAllow: z43.array(z43.string()).optional(),
-  cmdDeny: z43.array(z43.string()).optional(),
-  maintenanceWindows: z43.array(
-    z43.object({
-      days: z43.array(
-        z43.enum(["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"])
+  tags: z47.array(z47.string()).default([]),
+  rosVersion: z47.string().min(1),
+  sshPort: z47.number().int().min(1).max(65535).optional(),
+  sshFingerprint: z47.string().optional(),
+  cmdAllow: z47.array(z47.string()).optional(),
+  cmdDeny: z47.array(z47.string()).optional(),
+  maintenanceWindows: z47.array(
+    z47.object({
+      days: z47.array(
+        z47.enum(["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"])
       ),
-      startTime: z43.string().regex(/^\d{2}:\d{2}$/, "startTime must be HH:MM"),
-      endTime: z43.string().regex(/^\d{2}:\d{2}$/, "endTime must be HH:MM"),
-      timezone: z43.string().min(1)
+      startTime: z47.string().regex(/^\d{2}:\d{2}$/, "startTime must be HH:MM"),
+      endTime: z47.string().regex(/^\d{2}:\d{2}$/, "endTime must be HH:MM"),
+      timezone: z47.string().min(1)
     }).strict()
   ).optional()
 }).strict();
-var ConfigFileSchema = z43.object({
-  routers: z43.record(z43.string(), RouterConfigSchema)
+var ConfigFileSchema = z47.object({
+  routers: z47.record(z47.string(), RouterConfigSchema)
 }).strict();
 var RouterRegistry = class {
   routers;
   constructor(configPath) {
     this.routers = /* @__PURE__ */ new Map();
     if (!existsSync(configPath)) {
-      log46.warn({ configPath }, "Router config file not found; starting with empty registry");
+      log50.warn({ configPath }, "Router config file not found; starting with empty registry");
       return;
     }
     const raw = readFileSync2(configPath, "utf-8");
@@ -10633,14 +11945,14 @@ ${issues}`);
     for (const [id, config] of Object.entries(result.data.routers)) {
       const routerConfig = { ...config, id };
       if (routerConfig.tls.enabled && !routerConfig.tls.rejectUnauthorized) {
-        log46.warn(
+        log50.warn(
           { routerId: id },
           "TLS certificate validation is DISABLED (rejectUnauthorized=false). Set tls.fingerprint to pin the server certificate instead."
         );
       }
       this.routers.set(id, routerConfig);
     }
-    log46.info({ count: this.routers.size }, "Loaded routers from config");
+    log50.info({ count: this.routers.size }, "Loaded routers from config");
   }
   getRouter(id) {
     const router = this.routers.get(id);
@@ -10925,7 +12237,7 @@ var ConnectionPool = class {
 };
 
 // src/version.ts
-var VERSION = "1.4.0";
+var VERSION = "1.5.0";
 
 // src/mcp/server.ts
 function createServerFactory(config, identityRegistry) {
@@ -10955,7 +12267,7 @@ 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 log47 = createLogger("transport-http");
+var log51 = createLogger("transport-http");
 var BodyTooLargeError = class extends Error {
   constructor() {
     super("Request body exceeds maximum allowed size");
@@ -11047,7 +12359,7 @@ async function connectHttp(makeServer, config, identityRegistry) {
       return;
     }
     if (!checkRateLimit(ip)) {
-      log47.warn({ ip }, "Rate limit exceeded");
+      log51.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;
@@ -11088,7 +12400,7 @@ async function connectHttp(makeServer, config, identityRegistry) {
         }
         return;
       }
-      log47.error({ err }, "HTTP transport error");
+      log51.error({ err }, "HTTP transport error");
       if (!res.headersSent) {
         res.writeHead(500, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Internal server error" }));
@@ -11098,7 +12410,7 @@ async function connectHttp(makeServer, config, identityRegistry) {
   httpServer.on("close", () => clearInterval(sweepTimer));
   await new Promise((resolve, reject) => {
     httpServer.listen(port, bindHost, () => {
-      log47.info(
+      log51.info(
         { port, bindHost },
         "HTTP transport listening (POST /mcp for Streamable HTTP, GET /sse for legacy SSE)"
       );
@@ -11122,13 +12434,13 @@ async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, mak
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (id) => {
           streamableSessions.set(id, transport2);
-          log47.info({ sessionId: id }, "Streamable HTTP session created");
+          log51.info({ sessionId: id }, "Streamable HTTP session created");
         }
       });
       transport2.onclose = () => {
         if (transport2.sessionId) {
           streamableSessions.delete(transport2.sessionId);
-          log47.info({ sessionId: transport2.sessionId }, "Streamable HTTP session closed");
+          log51.info({ sessionId: transport2.sessionId }, "Streamable HTTP session closed");
         }
       };
       await makeServer().connect(transport2);
@@ -11145,7 +12457,7 @@ async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, mak
     sseTransport.onclose = () => {
       sseTransports.delete(sseTransport.sessionId);
     };
-    log47.info({ sessionId: sseTransport.sessionId }, "SSE client connected");
+    log51.info({ sessionId: sseTransport.sessionId }, "SSE client connected");
     await sseTransport.start();
     return;
   }
@@ -11166,23 +12478,23 @@ 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 { parse as parse2 } from "yaml";
-import { z as z44 } from "zod";
+import { z as z48 } from "zod";
 import bcrypt from "bcryptjs";
-var log48 = createLogger("identity-registry");
-var IdentityConfigSchema = z44.object({
-  token: z44.string().min(1, "token hash is required"),
-  role: z44.enum(["readonly", "operator", "admin", "superadmin"]),
-  allowedRouters: z44.array(z44.string()).default([]),
-  allowedToolPatterns: z44.array(z44.string()).default([])
+var log52 = createLogger("identity-registry");
+var IdentityConfigSchema = z48.object({
+  token: z48.string().min(1, "token hash is required"),
+  role: z48.enum(["readonly", "operator", "admin", "superadmin"]),
+  allowedRouters: z48.array(z48.string()).default([]),
+  allowedToolPatterns: z48.array(z48.string()).default([])
 }).strict();
-var ConfigFileSchema2 = z44.object({
-  identities: z44.record(z44.string(), IdentityConfigSchema)
+var ConfigFileSchema2 = z48.object({
+  identities: z48.record(z48.string(), IdentityConfigSchema)
 }).strict();
 var IdentityRegistry = class {
   identities = [];
   constructor(configPath) {
     if (!existsSync2(configPath)) {
-      log48.warn(
+      log52.warn(
         { configPath },
         "Identity config file not found; starting with empty registry (stdio callers do not require it)"
       );
@@ -11205,7 +12517,7 @@ ${issues}`);
         allowedToolPatterns: config.allowedToolPatterns
       });
     }
-    log48.info({ count: this.identities.length }, "Loaded identities from config");
+    log52.info({ count: this.identities.length }, "Loaded identities from config");
   }
   getIdentities() {
     return this.identities.map(({ id, role, allowedRouters, allowedToolPatterns }) => ({
@@ -11234,7 +12546,7 @@ ${issues}`);
 // src/domain/snapshot/retention.ts
 import { readdir, stat, unlink } from "fs/promises";
 import { join as join3 } from "path";
-var log49 = createLogger("snapshot-retention");
+var log53 = createLogger("snapshot-retention");
 async function pruneSnapshots(snapshotDir, maxAgeDays) {
   const cutoffMs = Date.now() - maxAgeDays * 864e5;
   let removed = 0;
@@ -11261,21 +12573,21 @@ async function pruneSnapshots(snapshotDir, maxAgeDays) {
           removed++;
         }
       } catch (err) {
-        log49.warn({ err, filePath }, "Failed to evaluate snapshot for retention");
+        log53.warn({ err, filePath }, "Failed to evaluate snapshot for retention");
       }
     }
   }
   if (removed > 0) {
-    log49.info({ removed, maxAgeDays }, "Pruned expired snapshots");
+    log53.info({ removed, maxAgeDays }, "Pruned expired snapshots");
   }
   return removed;
 }
 
 // src/cli/serve.ts
-var log50 = createLogger("main");
+var log54 = createLogger("main");
 async function runServe() {
   const config = loadAppConfig();
-  log50.info({ transport: config.transport, logLevel: config.logLevel }, "Starting MikroMCP server");
+  log54.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") {
@@ -11283,7 +12595,7 @@ async function runServe() {
       (i) => i.role === "readonly" || i.role === "operator"
     );
     if (hasLimitedRoles && !config.confirmationSecret) {
-      log50.error(
+      log54.error(
         "MIKROMCP_CONFIRMATION_SECRET is required in HTTP mode when identities with role readonly or operator are configured"
       );
       process.exit(1);
@@ -11293,7 +12605,7 @@ async function runServe() {
   if (config.transport === "stdio") {
     const stdioIdentity = getStdioIdentity(config.stdioIdentity, identityRegistry);
     await withIdentity(stdioIdentity, () => connectStdio(makeServer()));
-    log50.info("MikroMCP server running via stdio");
+    log54.info("MikroMCP server running via stdio");
   } else if (config.transport === "http") {
     await connectHttp(
       makeServer,
@@ -11305,13 +12617,13 @@ async function runServe() {
       },
       identityRegistry
     );
-    log50.info(
+    log54.info(
       { port: config.port, bindHost: config.bindHost },
       "MikroMCP server running via HTTP/SSE"
     );
   }
   const shutdown = () => {
-    log50.info("Shutting down MikroMCP server");
+    log54.info("Shutting down MikroMCP server");
     pool.closeAll();
     process.exit(0);
   };
@@ -11324,7 +12636,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.4.0";
+var localVersion = "1.5.0";
 var results = [];
 function ok(msg) {
   console.log(chalk.green("\u2705 ") + msg);
@@ -11976,7 +13288,7 @@ async function runInit() {
 }
 
 // src/cli/index.ts
-var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.4.0");
+var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.5.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);