mikromcp 1.1.0 → 1.2.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 z32 } from "zod";
+import { z as z36 } from "zod";
 
 // src/domain/tools/system-tools.ts
 import { z } from "zod";
@@ -446,7 +446,12 @@ var COUNTER_PROPS = [
   "rx-drop",
   "tx-error",
   "rx-error",
-  "tx-queue-drop"
+  "tx-queue-drop",
+  "fp-tx-byte",
+  "fp-rx-byte",
+  "fp-tx-packet",
+  "fp-rx-packet",
+  "fp-rps-drop"
 ];
 var listInterfacesTool = {
   name: "list_interfaces",
@@ -490,14 +495,17 @@ var listInterfacesTool = {
       }
       const total = interfaces.length;
       const paginated = interfaces.slice(parsed.offset, parsed.offset + parsed.limit);
-      const results2 = parsed.includeCounters ? paginated : paginated.map((iface) => {
-        const cleaned = {};
-        for (const [key2, value] of Object.entries(iface)) {
-          if (!COUNTER_PROPS.includes(key2)) {
-            cleaned[key2] = value;
+      const results2 = paginated.map((iface) => {
+        const rec = iface;
+        const isRunning = rec.running === true || rec.running === "true";
+        const isDisabled = rec.disabled === true || rec.disabled === "true";
+        const enriched = { status: isDisabled ? "disabled" : isRunning ? "up" : "down" };
+        for (const [key2, value] of Object.entries(rec)) {
+          if (parsed.includeCounters || !COUNTER_PROPS.includes(key2)) {
+            enriched[key2] = value;
           }
         }
-        return cleaned;
+        return enriched;
       });
       const hasMore = parsed.offset + parsed.limit < total;
       const lines = [
@@ -507,8 +515,8 @@ var listInterfacesTool = {
         const rec = iface;
         const name = rec.name ?? rec[".id"] ?? "unknown";
         const type = rec.type ?? parsed.type;
-        const running = rec.running === "true" ? "UP" : "DOWN";
-        lines.push(`  ${name} [${type}] ${running}`);
+        const status = String(rec.status).toUpperCase();
+        lines.push(`  ${name} [${type}] ${status}`);
       }
       return {
         content: lines.join("\n"),
@@ -526,115 +534,7 @@ var listInterfacesTool = {
     }
   }
 };
-var createVlanInputSchema = z2.object({
-  routerId: z2.string().describe("Target router identifier from the router registry"),
-  name: z2.string().regex(/^[a-zA-Z0-9_-]+$/).max(15).describe("VLAN interface name (alphanumeric, hyphens, underscores, max 15 chars)"),
-  vlanId: z2.number().int().min(1).max(4094).describe("VLAN ID (1-4094)"),
-  parentInterface: z2.string().describe("Parent interface name (e.g., ether1, bridge1)"),
-  mtu: z2.number().int().min(68).max(9e3).default(1500).describe("MTU size"),
-  disabled: z2.boolean().default(false).describe("Whether the VLAN interface should be disabled"),
-  comment: z2.string().max(255).optional().describe("Optional comment for the VLAN interface"),
-  dryRun: z2.boolean().default(false).describe("If true, validate and return planned changes without applying")
-}).strict();
-function sanitizeComment(comment) {
-  if (comment === void 0) return void 0;
-  return comment.replace(/[\x00-\x1f\x7f]/g, "");
-}
-var createVlanTool = {
-  name: "create_vlan",
-  title: "Create VLAN Interface",
-  description: "Create a new VLAN interface on a MikroTik router. Performs idempotency checks: if a VLAN with the same name already exists with matching configuration, returns success without changes. Supports dry-run mode.",
-  inputSchema: createVlanInputSchema,
-  annotations: {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-  },
-  async handler(params, context) {
-    const parsed = createVlanInputSchema.parse(params);
-    const comment = sanitizeComment(parsed.comment);
-    log2.info(
-      { routerId: context.routerId, name: parsed.name, vlanId: parsed.vlanId },
-      "Creating VLAN interface"
-    );
-    try {
-      const existing = await context.routerClient.get("interface/vlan", {
-        filter: { name: parsed.name }
-      });
-      if (existing.length > 0) {
-        const found = existing[0];
-        const existingVlanId = found["vlan-id"];
-        const existingInterface = found.interface;
-        if (existingVlanId === String(parsed.vlanId) && existingInterface === parsed.parentInterface) {
-          log2.info({ name: parsed.name }, "VLAN already exists with matching config");
-          return {
-            content: `VLAN "${parsed.name}" already exists with VLAN ID ${parsed.vlanId} on ${parsed.parentInterface}. No changes made.`,
-            structuredContent: {
-              action: "already_exists",
-              vlan: found
-            }
-          };
-        }
-        throw new MikroMCPError({
-          category: "CONFLICT" /* CONFLICT */,
-          code: "VLAN_NAME_CONFLICT",
-          message: `VLAN "${parsed.name}" already exists but with different configuration (vlan-id=${existingVlanId}, interface=${existingInterface}). Expected vlan-id=${parsed.vlanId}, interface=${parsed.parentInterface}.`,
-          details: {
-            existingVlanId,
-            existingInterface,
-            requestedVlanId: parsed.vlanId,
-            requestedInterface: parsed.parentInterface
-          },
-          recoverability: {
-            retryable: false,
-            suggestedAction: "Use a different name or update the existing VLAN."
-          }
-        });
-      }
-      if (parsed.dryRun) {
-        const diff = [
-          { property: "name", before: null, after: parsed.name },
-          { property: "vlan-id", before: null, after: String(parsed.vlanId) },
-          { property: "interface", before: null, after: parsed.parentInterface },
-          { property: "mtu", before: null, after: String(parsed.mtu) },
-          { property: "disabled", before: null, after: parsed.disabled ? "true" : "false" },
-          ...comment ? [{ property: "comment", before: null, after: comment }] : []
-        ];
-        return {
-          content: `Dry run: Would create VLAN "${parsed.name}" (ID ${parsed.vlanId}) on ${parsed.parentInterface} with MTU ${parsed.mtu}.`,
-          structuredContent: {
-            action: "dry_run",
-            diff
-          }
-        };
-      }
-      const body = {
-        name: parsed.name,
-        "vlan-id": String(parsed.vlanId),
-        interface: parsed.parentInterface,
-        mtu: String(parsed.mtu),
-        disabled: parsed.disabled ? "true" : "false"
-      };
-      if (comment) {
-        body.comment = comment;
-      }
-      const created = await context.routerClient.create("interface/vlan", body);
-      log2.info({ name: parsed.name, id: created[".id"] }, "VLAN created successfully");
-      return {
-        content: `Created VLAN "${parsed.name}" (ID ${parsed.vlanId}) on ${parsed.parentInterface} with MTU ${parsed.mtu}.`,
-        structuredContent: {
-          action: "created",
-          vlan: created
-        }
-      };
-    } catch (err) {
-      if (err instanceof MikroMCPError) throw err;
-      throw enrichError(err, { routerId: context.routerId, tool: "create_vlan" });
-    }
-  }
-};
-var interfaceTools = [listInterfacesTool, createVlanTool];
+var interfaceTools = [listInterfacesTool];
 
 // src/domain/tools/ip-tools.ts
 import { z as z4 } from "zod";
@@ -685,7 +585,7 @@ var inputSchema2 = z4.object({
   disabled: z4.boolean().default(false).describe("Whether the IP address should be disabled"),
   dryRun: z4.boolean().default(false).describe("If true, validate and return planned changes without applying")
 }).strict();
-function sanitizeComment2(comment) {
+function sanitizeComment(comment) {
   if (comment === void 0) return void 0;
   return comment.replace(/[\x00-\x1f\x7f]/g, "");
 }
@@ -709,7 +609,7 @@ var manageIpAddressTool = {
   snapshotPaths: ["ip/address"],
   async handler(params, context) {
     const parsed = inputSchema2.parse(params);
-    const comment = sanitizeComment2(parsed.comment);
+    const comment = sanitizeComment(parsed.comment);
     log3.info(
       {
         routerId: context.routerId,
@@ -898,13 +798,14 @@ var listDhcpLeasesInputSchema = z5.object({
   server: z5.string().optional().describe("Filter by DHCP server name"),
   status: z5.enum(["bound", "waiting", "offered", "blocked", "all"]).default("all").describe("Filter by lease status"),
   macAddress: z5.string().optional().describe("Filter by MAC address (exact match, case-insensitive)"),
+  leaseType: z5.enum(["dynamic", "static", "all"]).default("all").describe("Filter by lease type (dynamic or static)"),
   limit: z5.number().int().min(1).max(500).default(100).describe("Maximum number of leases to return"),
   offset: z5.number().int().min(0).default(0).describe("Offset for pagination")
 }).strict();
 var listDhcpLeasesTool = {
   name: "list_dhcp_leases",
   title: "List DHCP Leases",
-  description: "List DHCP leases on a MikroTik router with optional filtering by server, status, and MAC address. Supports pagination.",
+  description: "List DHCP leases on a MikroTik router with optional filtering by server, status, lease type (dynamic/static), and MAC address. Supports pagination.",
   inputSchema: listDhcpLeasesInputSchema,
   annotations: {
     readOnlyHint: true,
@@ -948,6 +849,14 @@ var listDhcpLeasesTool = {
           return leaseMAC === upperMac;
         });
       }
+      if (parsed.leaseType !== "all") {
+        leases = leases.filter((lease) => {
+          const rec = lease;
+          const isDynamic = rec.dynamic === true || rec.dynamic === "true";
+          if (parsed.leaseType === "dynamic") return isDynamic;
+          return !isDynamic;
+        });
+      }
       const total = leases.length;
       const paginated = leases.slice(parsed.offset, parsed.offset + parsed.limit);
       const hasMore = parsed.offset + parsed.limit < total;
@@ -979,7 +888,110 @@ var listDhcpLeasesTool = {
     }
   }
 };
-var dhcpTools = [listDhcpLeasesTool];
+var manageDhcpLeaseInputSchema = z5.object({
+  routerId: z5.string().describe("Target router identifier from the router registry"),
+  action: z5.enum(["make-static", "remove"]).describe(
+    "Action to perform: make-static converts a dynamic lease to static; remove deletes the lease"
+  ),
+  macAddress: z5.string().describe("MAC address of the lease \u2014 idempotency key (case-insensitive)"),
+  dryRun: z5.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageDhcpLeaseTool = {
+  name: "manage_dhcp_lease",
+  title: "Manage DHCP Lease",
+  description: "Convert a dynamic DHCP lease to static (make-static) or remove a lease. Idempotent by MAC address.",
+  inputSchema: manageDhcpLeaseInputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  snapshotPaths: ["ip/dhcp-server/lease"],
+  async handler(params, context) {
+    const parsed = manageDhcpLeaseInputSchema.parse(params);
+    const upperMac = parsed.macAddress.toUpperCase();
+    log4.info(
+      { routerId: context.routerId, action: parsed.action, macAddress: upperMac },
+      "Managing DHCP lease"
+    );
+    try {
+      const allLeases = await context.routerClient.get("ip/dhcp-server/lease", {
+        limit: void 0,
+        offset: void 0
+      });
+      const existing = allLeases.find(
+        (l) => (l["mac-address"] ?? "").toUpperCase() === upperMac
+      );
+      if (parsed.action === "make-static") {
+        if (!existing) {
+          throw new MikroMCPError({
+            category: "NOT_FOUND" /* NOT_FOUND */,
+            code: "DHCP_LEASE_NOT_FOUND",
+            message: `No DHCP lease found for MAC address ${upperMac}.`,
+            details: { macAddress: upperMac },
+            recoverability: {
+              retryable: false,
+              suggestedAction: "Verify the MAC address with list_dhcp_leases.",
+              alternativeTools: ["list_dhcp_leases"]
+            }
+          });
+        }
+        const existingDynamic = existing.dynamic;
+        const isAlreadyStatic = existingDynamic === "false" || existingDynamic === false;
+        if (isAlreadyStatic) {
+          return {
+            content: `Lease for ${upperMac} (${existing.address ?? "unknown"}) is already static. No changes made.`,
+            structuredContent: { action: "already_static", macAddress: upperMac, id: existing[".id"] }
+          };
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would convert lease for ${upperMac} (${existing.address ?? "unknown"}) to static.`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [{ property: "dynamic", before: "true", after: "false" }],
+              lease: existing
+            }
+          };
+        }
+        await context.routerClient.update("ip/dhcp-server/lease", existing[".id"], {
+          dynamic: "false"
+        });
+        log4.info({ macAddress: upperMac, id: existing[".id"] }, "DHCP lease converted to static");
+        return {
+          content: `Lease for ${upperMac} (${existing.address ?? "unknown"}) converted to static.`,
+          structuredContent: { action: "made-static", macAddress: upperMac, id: existing[".id"] }
+        };
+      }
+      if (!existing) {
+        return {
+          content: `No DHCP lease found for MAC address ${upperMac}. Nothing to remove.`,
+          structuredContent: { action: "not_found", macAddress: upperMac }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would remove lease for ${upperMac}.`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [{ property: "mac-address", before: upperMac, after: null }]
+          }
+        };
+      }
+      await context.routerClient.remove("ip/dhcp-server/lease", existing[".id"]);
+      log4.info({ macAddress: upperMac }, "DHCP lease removed");
+      return {
+        content: `Removed DHCP lease for ${upperMac}.`,
+        structuredContent: { action: "removed", macAddress: upperMac, id: existing[".id"] }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_dhcp_lease" });
+    }
+  }
+};
+var dhcpTools = [listDhcpLeasesTool, manageDhcpLeaseTool];
 
 // src/domain/tools/route-tools.ts
 import { z as z6 } from "zod";
@@ -1083,7 +1095,7 @@ var manageRouteInputSchema = z6.object({
   disabled: z6.boolean().default(false).describe("Whether the route should be disabled"),
   dryRun: z6.boolean().default(false).describe("If true, validate and return planned changes without applying")
 }).strict();
-function sanitizeComment3(comment) {
+function sanitizeComment2(comment) {
   if (comment === void 0) return void 0;
   return comment.replace(/[\x00-\x1f\x7f]/g, "");
 }
@@ -1111,7 +1123,7 @@ var manageRouteTool = {
   snapshotPaths: ["ip/route"],
   async handler(params, context) {
     const parsed = manageRouteInputSchema.parse(params);
-    const comment = sanitizeComment3(parsed.comment);
+    const comment = sanitizeComment2(parsed.comment);
     log5.info(
       {
         routerId: context.routerId,
@@ -1252,7 +1264,7 @@ var log6 = createLogger("firewall-tools");
 function tableToPath(table) {
   return table === "filter" ? "ip/firewall/filter" : "ip/firewall/nat";
 }
-function sanitizeComment4(comment) {
+function sanitizeComment3(comment) {
   if (comment === void 0) return void 0;
   return comment.replace(/[\x00-\x1f\x7f]/g, "");
 }
@@ -1391,7 +1403,7 @@ var manageFirewallRuleTool = {
   snapshotPaths: ["ip/firewall/filter", "ip/firewall/nat"],
   async handler(params, context) {
     const parsed = manageFirewallRuleInputSchema.parse(params);
-    const comment = sanitizeComment4(parsed.comment);
+    const comment = sanitizeComment3(parsed.comment);
     log6.info(
       {
         routerId: context.routerId,
@@ -6051,7 +6063,8 @@ var log28 = createLogger("dhcp-server-tools");
 var listDhcpServersInputSchema = z27.object({
   routerId: z27.string().describe("Target router identifier from the router registry"),
   interface: z27.string().optional().describe("Filter by interface name (exact match)"),
-  limit: z27.number().int().min(1).max(500).default(100).describe("Maximum number of DHCP servers to return")
+  limit: z27.number().int().min(1).max(500).default(100).describe("Maximum number of DHCP servers to return"),
+  offset: z27.number().int().min(0).default(0).describe("Offset for pagination")
 }).strict();
 var listDhcpServersTool = {
   name: "list_dhcp_servers",
@@ -6072,17 +6085,19 @@ var listDhcpServersTool = {
         limit: void 0,
         offset: void 0
       });
-      const filtered = parsed.interface ? allServers.filter(
-        (s) => s.interface === parsed.interface
-      ) : allServers;
-      const servers = filtered.slice(0, parsed.limit);
+      let filtered = parsed.interface ? allServers.filter((s) => s.interface === parsed.interface) : allServers;
+      const total = filtered.length;
+      const servers = filtered.slice(parsed.offset, parsed.offset + parsed.limit);
+      const hasMore = parsed.offset + parsed.limit < total;
       return {
-        content: `DHCP servers on ${context.routerId}: ${servers.length} returned (${allServers.length} total)`,
+        content: `DHCP servers on ${context.routerId}: ${total} total, showing ${servers.length} (offset ${parsed.offset})`,
         structuredContent: {
           routerId: context.routerId,
           servers,
-          total: allServers.length,
-          returned: servers.length
+          total,
+          hasMore,
+          offset: parsed.offset,
+          limit: parsed.limit
         }
       };
     } catch (err) {
@@ -6273,16 +6288,22 @@ var manageDhcpServerTool = {
     }
   }
 };
-var listDhcpPoolsInputSchema = z27.object({
-  routerId: z27.string().describe("Target router identifier from the router registry"),
-  name: z27.string().optional().describe("Filter by pool name (substring match)"),
-  limit: z27.number().int().min(1).max(500).default(100).describe("Maximum number of pools to return")
+var dhcpServerTools = [listDhcpServersTool, manageDhcpServerTool];
+
+// src/domain/tools/ip-pool-tools.ts
+import { z as z28 } from "zod";
+var log29 = createLogger("ip-pool-tools");
+var listIpPoolsInputSchema = z28.object({
+  routerId: z28.string().describe("Target router identifier from the router registry"),
+  name: z28.string().optional().describe("Filter by pool name (substring match)"),
+  limit: z28.number().int().min(1).max(500).default(100).describe("Maximum number of pools to return"),
+  offset: z28.number().int().min(0).default(0).describe("Offset for pagination")
 }).strict();
-var listDhcpPoolsTool = {
-  name: "list_dhcp_pools",
-  title: "List DHCP Pools",
-  description: "List IP pools on a MikroTik router.",
-  inputSchema: listDhcpPoolsInputSchema,
+var listIpPoolsTool = {
+  name: "list_ip_pools",
+  title: "List IP Pools",
+  description: "List IP address pools on a MikroTik router. Supports filtering by name and pagination.",
+  inputSchema: listIpPoolsInputSchema,
   annotations: {
     readOnlyHint: true,
     destructiveHint: false,
@@ -6290,44 +6311,49 @@ var listDhcpPoolsTool = {
     openWorldHint: false
   },
   async handler(params, context) {
-    const parsed = listDhcpPoolsInputSchema.parse(params);
-    log28.info({ routerId: context.routerId }, "Listing DHCP pools");
+    const parsed = listIpPoolsInputSchema.parse(params);
+    log29.info({ routerId: context.routerId }, "Listing IP pools");
     try {
       const allPools = await context.routerClient.get("ip/pool", {
         limit: void 0,
         offset: void 0
       });
-      const filtered = parsed.name ? allPools.filter(
-        (p) => (p.name ?? "").includes(parsed.name)
-      ) : allPools;
-      const pools = filtered.slice(0, parsed.limit);
+      let filtered = allPools;
+      if (parsed.name) {
+        filtered = filtered.filter((p) => (p.name ?? "").includes(parsed.name));
+      }
+      const total = filtered.length;
+      const pools = filtered.slice(parsed.offset, parsed.offset + parsed.limit);
+      const hasMore = parsed.offset + parsed.limit < total;
       return {
-        content: `DHCP pools on ${context.routerId}: ${pools.length} returned (${allPools.length} total)`,
+        content: `IP pools on ${context.routerId}: ${total} total, showing ${pools.length} (offset ${parsed.offset})`,
         structuredContent: {
           routerId: context.routerId,
           pools,
-          total: allPools.length,
-          returned: pools.length
+          total,
+          hasMore,
+          offset: parsed.offset,
+          limit: parsed.limit
         }
       };
     } catch (err) {
-      throw enrichError(err, { routerId: context.routerId, tool: "list_dhcp_pools" });
+      throw enrichError(err, { routerId: context.routerId, tool: "list_ip_pools" });
     }
   }
 };
-var manageDhcpPoolInputSchema = z27.object({
-  routerId: z27.string().describe("Target router identifier from the router registry"),
-  action: z27.enum(["add", "remove"]).describe("Action to perform"),
-  name: z27.string().describe("Pool name \u2014 idempotency key"),
-  ranges: z27.string().optional().describe("IP range (e.g. '192.168.1.100-192.168.1.200'; required for add)"),
-  nextPool: z27.string().optional().describe("Next pool name for overflow"),
-  dryRun: z27.boolean().default(false).describe("Preview changes without applying")
+var manageIpPoolInputSchema = z28.object({
+  routerId: z28.string().describe("Target router identifier from the router registry"),
+  action: z28.enum(["add", "remove"]).describe("Action to perform"),
+  name: z28.string().describe("Pool name \u2014 idempotency key"),
+  ranges: z28.string().optional().describe("IP range (e.g. '192.168.1.100-192.168.1.200'; required for add)"),
+  nextPool: z28.string().optional().describe("Next pool name for overflow"),
+  dryRun: z28.boolean().default(false).describe("Preview changes without applying")
 }).strict();
-var manageDhcpPoolTool = {
-  name: "manage_dhcp_pool",
-  title: "Manage DHCP Pool",
-  description: "Add or remove an IP pool. Idempotent by name: add returns already_exists if a pool with the same name and ranges already exists.",
-  inputSchema: manageDhcpPoolInputSchema,
+var manageIpPoolTool = {
+  name: "manage_ip_pool",
+  title: "Manage IP Pool",
+  description: "Add or remove an IP address pool. Idempotent by name: add returns already_exists if a pool with the same name and ranges already exists.",
+  inputSchema: manageIpPoolInputSchema,
   annotations: {
     readOnlyHint: false,
     destructiveHint: false,
@@ -6336,25 +6362,20 @@ var manageDhcpPoolTool = {
   },
   snapshotPaths: ["ip/pool"],
   async handler(params, context) {
-    const parsed = manageDhcpPoolInputSchema.parse(params);
-    log28.info(
-      { routerId: context.routerId, action: parsed.action, name: parsed.name },
-      "Managing DHCP pool"
-    );
+    const parsed = manageIpPoolInputSchema.parse(params);
+    log29.info({ routerId: context.routerId, action: parsed.action, name: parsed.name }, "Managing IP pool");
     try {
       const allPools = await context.routerClient.get("ip/pool", {
         limit: void 0,
         offset: void 0
       });
-      const existing = allPools.find(
-        (p) => p.name === parsed.name
-      );
+      const existing = allPools.find((p) => p.name === parsed.name);
       if (parsed.action === "add") {
         if (!parsed.ranges) {
           throw new MikroMCPError({
             category: "VALIDATION" /* VALIDATION */,
-            code: "DHCP_POOL_RANGES_REQUIRED",
-            message: "ranges is required when adding a DHCP pool.",
+            code: "IP_POOL_RANGES_REQUIRED",
+            message: "ranges is required when adding an IP pool.",
             details: { name: parsed.name },
             recoverability: {
               retryable: false,
@@ -6365,22 +6386,19 @@ var manageDhcpPoolTool = {
         if (existing) {
           if (existing.ranges === parsed.ranges) {
             return {
-              content: `DHCP pool "${parsed.name}" already exists with the same ranges. No changes made.`,
+              content: `IP pool "${parsed.name}" already exists with the same ranges. No changes made.`,
               structuredContent: { action: "already_exists", pool: existing }
             };
           }
           throw new MikroMCPError({
             category: "CONFLICT" /* CONFLICT */,
-            code: "DHCP_POOL_CONFLICT",
-            message: `DHCP pool "${parsed.name}" exists with different ranges.`,
-            details: {
-              existing: existing.ranges,
-              requested: parsed.ranges
-            },
+            code: "IP_POOL_CONFLICT",
+            message: `IP pool "${parsed.name}" exists with different ranges.`,
+            details: { existing: existing.ranges, requested: parsed.ranges },
             recoverability: {
               retryable: false,
               suggestedAction: "Remove the existing pool first or use a different name.",
-              alternativeTools: ["manage_dhcp_pool"]
+              alternativeTools: ["manage_ip_pool"]
             }
           });
         }
@@ -6391,63 +6409,52 @@ var manageDhcpPoolTool = {
             ...parsed.nextPool ? [{ property: "next-pool", before: null, after: parsed.nextPool }] : []
           ];
           return {
-            content: `Dry run: Would add DHCP pool "${parsed.name}".`,
+            content: `Dry run: Would add IP pool "${parsed.name}" with ranges ${parsed.ranges}.`,
             structuredContent: { action: "dry_run", diff }
           };
         }
-        const body = {
-          name: parsed.name,
-          ranges: parsed.ranges
-        };
+        const body = { name: parsed.name, ranges: parsed.ranges };
         if (parsed.nextPool) body["next-pool"] = parsed.nextPool;
         const created = await context.routerClient.create("ip/pool", body);
-        log28.info({ name: parsed.name, id: created[".id"] }, "DHCP pool added");
+        log29.info({ name: parsed.name, id: created[".id"] }, "IP pool added");
         return {
-          content: `Added DHCP pool "${parsed.name}".`,
+          content: `Added IP pool "${parsed.name}" with ranges ${parsed.ranges}.`,
           structuredContent: { action: "created", pool: created }
         };
       }
       if (!existing) {
         return {
-          content: `DHCP pool "${parsed.name}" not found. Nothing to remove.`,
+          content: `IP pool "${parsed.name}" not found. Nothing to remove.`,
           structuredContent: { action: "not_found", name: parsed.name }
         };
       }
       if (parsed.dryRun) {
         return {
-          content: `Dry run: Would remove DHCP pool "${parsed.name}".`,
-          structuredContent: {
-            action: "dry_run",
-            diff: [{ property: "name", before: parsed.name, after: null }]
-          }
+          content: `Dry run: Would remove IP pool "${parsed.name}".`,
+          structuredContent: { action: "dry_run", diff: [{ property: "name", before: parsed.name, after: null }] }
         };
       }
       await context.routerClient.remove("ip/pool", existing[".id"]);
-      log28.info({ name: parsed.name }, "DHCP pool removed");
+      log29.info({ name: parsed.name }, "IP pool removed");
       return {
-        content: `Removed DHCP pool "${parsed.name}".`,
+        content: `Removed IP pool "${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_dhcp_pool" });
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_ip_pool" });
     }
   }
 };
-var dhcpServerTools = [
-  listDhcpServersTool,
-  manageDhcpServerTool,
-  listDhcpPoolsTool,
-  manageDhcpPoolTool
-];
+var ipPoolTools = [listIpPoolsTool, manageIpPoolTool];
 
 // src/domain/tools/queue-tools.ts
-import { z as z28 } from "zod";
-var log29 = createLogger("queue-tools");
-var listQueuesInputSchema = z28.object({
-  routerId: z28.string().describe("Target router identifier from the router registry"),
-  target: z28.string().optional().describe("Filter by target address (substring match)"),
-  limit: z28.number().int().min(1).max(500).default(100).describe("Maximum number of queues to return")
+import { z as z29 } from "zod";
+var log30 = createLogger("queue-tools");
+var listQueuesInputSchema = z29.object({
+  routerId: z29.string().describe("Target router identifier from the router registry"),
+  target: z29.string().optional().describe("Filter by target address (substring match)"),
+  limit: z29.number().int().min(1).max(500).default(100).describe("Maximum number of queues to return")
 }).strict();
 var listQueuesTool = {
   name: "list_queues",
@@ -6462,7 +6469,7 @@ var listQueuesTool = {
   },
   async handler(params, context) {
     const parsed = listQueuesInputSchema.parse(params);
-    log29.info({ routerId: context.routerId }, "Listing queues");
+    log30.info({ routerId: context.routerId }, "Listing queues");
     try {
       const allQueues = await context.routerClient.get("queue/simple", {
         limit: void 0,
@@ -6486,15 +6493,15 @@ var listQueuesTool = {
     }
   }
 };
-var manageQueueInputSchema = z28.object({
-  routerId: z28.string().describe("Target router identifier from the router registry"),
-  action: z28.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
-  name: z28.string().describe("Queue name \u2014 idempotency key"),
-  target: z28.string().optional().describe("Target address (required for add; e.g. '192.168.1.0/24')"),
-  maxLimit: z28.string().optional().describe("Max upload/download limit (e.g. '10M/10M')"),
-  limitAt: z28.string().optional().describe("Guaranteed rate (e.g. '1M/1M')"),
-  comment: z28.string().optional().describe("Optional comment"),
-  dryRun: z28.boolean().default(false).describe("Preview changes without applying")
+var manageQueueInputSchema = z29.object({
+  routerId: z29.string().describe("Target router identifier from the router registry"),
+  action: z29.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
+  name: z29.string().describe("Queue name \u2014 idempotency key"),
+  target: z29.string().optional().describe("Target address (required for add; e.g. '192.168.1.0/24')"),
+  maxLimit: z29.string().optional().describe("Max upload/download limit (e.g. '10M/10M')"),
+  limitAt: z29.string().optional().describe("Guaranteed rate (e.g. '1M/1M')"),
+  comment: z29.string().optional().describe("Optional comment"),
+  dryRun: z29.boolean().default(false).describe("Preview changes without applying")
 }).strict();
 var manageQueueTool = {
   name: "manage_queue",
@@ -6510,7 +6517,7 @@ var manageQueueTool = {
   snapshotPaths: ["queue/simple"],
   async handler(params, context) {
     const parsed = manageQueueInputSchema.parse(params);
-    log29.info(
+    log30.info(
       { routerId: context.routerId, action: parsed.action, name: parsed.name },
       "Managing queue"
     );
@@ -6572,7 +6579,7 @@ var manageQueueTool = {
         if (parsed.limitAt) body["limit-at"] = parsed.limitAt;
         if (parsed.comment) body.comment = parsed.comment;
         const created = await context.routerClient.create("queue/simple", body);
-        log29.info({ name: parsed.name, id: created[".id"] }, "Queue added");
+        log30.info({ name: parsed.name, id: created[".id"] }, "Queue added");
         return {
           content: `Added queue "${parsed.name}".`,
           structuredContent: { action: "created", queue: created }
@@ -6595,7 +6602,7 @@ var manageQueueTool = {
           };
         }
         await context.routerClient.remove("queue/simple", existing[".id"]);
-        log29.info({ name: parsed.name }, "Queue removed");
+        log30.info({ name: parsed.name }, "Queue removed");
         return {
           content: `Removed queue "${parsed.name}".`,
           structuredContent: { action: "removed", name: parsed.name, id: existing[".id"] }
@@ -6634,7 +6641,7 @@ var manageQueueTool = {
         disabled: disabledValue
       });
       const resultAction = parsed.action === "disable" ? "disabled" : "enabled";
-      log29.info({ name: parsed.name, action: resultAction }, "Queue updated");
+      log30.info({ name: parsed.name, action: resultAction }, "Queue updated");
       return {
         content: `Queue "${parsed.name}" ${resultAction}.`,
         structuredContent: { action: resultAction, name: parsed.name, id: existing[".id"] }
@@ -6648,12 +6655,12 @@ var manageQueueTool = {
 var queueTools = [listQueuesTool, manageQueueTool];
 
 // src/domain/tools/vrrp-tools.ts
-import { z as z29 } from "zod";
-var log30 = createLogger("vrrp-tools");
-var listVrrpInstancesInputSchema = z29.object({
-  routerId: z29.string().describe("Target router identifier from the router registry"),
-  interface: z29.string().optional().describe("Filter by master interface name (exact match)"),
-  limit: z29.number().int().min(1).max(500).default(100).describe("Maximum number of instances to return")
+import { z as z30 } from "zod";
+var log31 = createLogger("vrrp-tools");
+var listVrrpInstancesInputSchema = z30.object({
+  routerId: z30.string().describe("Target router identifier from the router registry"),
+  interface: z30.string().optional().describe("Filter by master interface name (exact match)"),
+  limit: z30.number().int().min(1).max(500).default(100).describe("Maximum number of instances to return")
 }).strict();
 var listVrrpInstancesTool = {
   name: "list_vrrp_instances",
@@ -6668,7 +6675,7 @@ var listVrrpInstancesTool = {
   },
   async handler(params, context) {
     const parsed = listVrrpInstancesInputSchema.parse(params);
-    log30.info({ routerId: context.routerId }, "Listing VRRP instances");
+    log31.info({ routerId: context.routerId }, "Listing VRRP instances");
     try {
       const allInstances = await context.routerClient.get("interface/vrrp", {
         limit: void 0,
@@ -6692,17 +6699,17 @@ var listVrrpInstancesTool = {
     }
   }
 };
-var manageVrrpInstanceInputSchema = z29.object({
-  routerId: z29.string().describe("Target router identifier from the router registry"),
-  action: z29.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
-  name: z29.string().describe("VRRP interface name \u2014 idempotency key"),
-  interface: z29.string().optional().describe("Master interface (required for add)"),
-  vrid: z29.number().int().min(1).max(255).optional().describe("Virtual router ID (required for add)"),
-  priority: z29.number().int().min(1).max(254).default(100).describe("Router priority (1\u2013254)"),
-  interval: z29.number().int().min(1).optional().describe("Advertisement interval in seconds"),
-  version: z29.enum(["2", "3"]).default("3").describe("VRRP protocol version"),
-  comment: z29.string().optional().describe("Optional comment"),
-  dryRun: z29.boolean().default(false).describe("Preview changes without applying")
+var manageVrrpInstanceInputSchema = z30.object({
+  routerId: z30.string().describe("Target router identifier from the router registry"),
+  action: z30.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
+  name: z30.string().describe("VRRP interface name \u2014 idempotency key"),
+  interface: z30.string().optional().describe("Master interface (required for add)"),
+  vrid: z30.number().int().min(1).max(255).optional().describe("Virtual router ID (required for add)"),
+  priority: z30.number().int().min(1).max(254).default(100).describe("Router priority (1\u2013254)"),
+  interval: z30.number().int().min(1).optional().describe("Advertisement interval in seconds"),
+  version: z30.enum(["2", "3"]).default("3").describe("VRRP protocol version"),
+  comment: z30.string().optional().describe("Optional comment"),
+  dryRun: z30.boolean().default(false).describe("Preview changes without applying")
 }).strict();
 var manageVrrpInstanceTool = {
   name: "manage_vrrp_instance",
@@ -6718,7 +6725,7 @@ var manageVrrpInstanceTool = {
   snapshotPaths: ["interface/vrrp"],
   async handler(params, context) {
     const parsed = manageVrrpInstanceInputSchema.parse(params);
-    log30.info(
+    log31.info(
       { routerId: context.routerId, action: parsed.action, name: parsed.name },
       "Managing VRRP instance"
     );
@@ -6802,7 +6809,7 @@ var manageVrrpInstanceTool = {
         if (parsed.interval) body.interval = String(parsed.interval);
         if (parsed.comment) body.comment = parsed.comment;
         const created = await context.routerClient.create("interface/vrrp", body);
-        log30.info({ name: parsed.name, id: created[".id"] }, "VRRP instance added");
+        log31.info({ name: parsed.name, id: created[".id"] }, "VRRP instance added");
         return {
           content: `Added VRRP instance "${parsed.name}".`,
           structuredContent: { action: "created", instance: created }
@@ -6825,7 +6832,7 @@ var manageVrrpInstanceTool = {
           };
         }
         await context.routerClient.remove("interface/vrrp", existing[".id"]);
-        log30.info({ name: parsed.name }, "VRRP instance removed");
+        log31.info({ name: parsed.name }, "VRRP instance removed");
         return {
           content: `Removed VRRP instance "${parsed.name}".`,
           structuredContent: { action: "removed", name: parsed.name, id: existing[".id"] }
@@ -6864,7 +6871,7 @@ var manageVrrpInstanceTool = {
         disabled: disabledValue
       });
       const resultAction = parsed.action === "disable" ? "disabled" : "enabled";
-      log30.info({ name: parsed.name, action: resultAction }, "VRRP instance updated");
+      log31.info({ name: parsed.name, action: resultAction }, "VRRP instance updated");
       return {
         content: `VRRP instance "${parsed.name}" ${resultAction}.`,
         structuredContent: { action: resultAction, name: parsed.name, id: existing[".id"] }
@@ -6878,10 +6885,10 @@ var manageVrrpInstanceTool = {
 var vrrpTools = [listVrrpInstancesTool, manageVrrpInstanceTool];
 
 // src/domain/tools/network-services-tools.ts
-import { z as z30 } from "zod";
-var log31 = createLogger("network-services-tools");
-var getSnmpSettingsInputSchema = z30.object({
-  routerId: z30.string().describe("Target router identifier from the router registry")
+import { z as z31 } from "zod";
+var log32 = createLogger("network-services-tools");
+var getSnmpSettingsInputSchema = z31.object({
+  routerId: z31.string().describe("Target router identifier from the router registry")
 }).strict();
 var getSnmpSettingsTool = {
   name: "get_snmp_settings",
@@ -6896,7 +6903,7 @@ var getSnmpSettingsTool = {
   },
   async handler(params, context) {
     const parsed = getSnmpSettingsInputSchema.parse(params);
-    log31.info({ routerId: context.routerId }, "Fetching SNMP settings");
+    log32.info({ routerId: context.routerId }, "Fetching SNMP settings");
     try {
       const results2 = await context.routerClient.get("snmp");
       if (!results2 || results2.length === 0) {
@@ -6925,8 +6932,8 @@ var getSnmpSettingsTool = {
     }
   }
 };
-var getNtpSettingsInputSchema = z30.object({
-  routerId: z30.string().describe("Target router identifier from the router registry")
+var getNtpSettingsInputSchema = z31.object({
+  routerId: z31.string().describe("Target router identifier from the router registry")
 }).strict();
 var getNtpSettingsTool = {
   name: "get_ntp_settings",
@@ -6941,7 +6948,7 @@ var getNtpSettingsTool = {
   },
   async handler(params, context) {
     const parsed = getNtpSettingsInputSchema.parse(params);
-    log31.info({ routerId: context.routerId }, "Fetching NTP settings");
+    log32.info({ routerId: context.routerId }, "Fetching NTP settings");
     try {
       const results2 = await context.routerClient.get("system/ntp/client");
       if (!results2 || results2.length === 0) {
@@ -6970,11 +6977,11 @@ var getNtpSettingsTool = {
     }
   }
 };
-var listNetwatchEntriesInputSchema = z30.object({
-  routerId: z30.string().describe("Target router identifier from the router registry"),
-  host: z30.string().optional().describe("Filter by host (substring match)"),
-  status: z30.enum(["up", "down", "unknown"]).optional().describe("Filter by current status"),
-  limit: z30.number().int().min(1).max(500).default(100).describe("Maximum number of entries to return")
+var listNetwatchEntriesInputSchema = z31.object({
+  routerId: z31.string().describe("Target router identifier from the router registry"),
+  host: z31.string().optional().describe("Filter by host (substring match)"),
+  status: z31.enum(["up", "down", "unknown"]).optional().describe("Filter by current status"),
+  limit: z31.number().int().min(1).max(500).default(100).describe("Maximum number of entries to return")
 }).strict();
 var listNetwatchEntriesTool = {
   name: "list_netwatch_entries",
@@ -6989,7 +6996,7 @@ var listNetwatchEntriesTool = {
   },
   async handler(params, context) {
     const parsed = listNetwatchEntriesInputSchema.parse(params);
-    log31.info({ routerId: context.routerId }, "Listing Netwatch entries");
+    log32.info({ routerId: context.routerId }, "Listing Netwatch entries");
     try {
       const allEntries = await context.routerClient.get("tool/netwatch", {
         limit: void 0,
@@ -7011,15 +7018,15 @@ var listNetwatchEntriesTool = {
     }
   }
 };
-var manageNetwatchEntryInputSchema = z30.object({
-  routerId: z30.string().describe("Target router identifier from the router registry"),
-  action: z30.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
-  host: z30.string().describe("Host to monitor \u2014 idempotency key"),
-  port: z30.number().int().min(1).max(65535).optional().describe("TCP port (optional; ICMP if omitted)"),
-  interval: z30.string().optional().describe("Check interval (e.g. '1m'; default '1m')"),
-  timeout: z30.string().optional().describe("Probe timeout (e.g. '500ms')"),
-  comment: z30.string().optional().describe("Optional comment"),
-  dryRun: z30.boolean().default(false).describe("Preview changes without applying")
+var manageNetwatchEntryInputSchema = z31.object({
+  routerId: z31.string().describe("Target router identifier from the router registry"),
+  action: z31.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
+  host: z31.string().describe("Host to monitor \u2014 idempotency key"),
+  port: z31.number().int().min(1).max(65535).optional().describe("TCP port (optional; ICMP if omitted)"),
+  interval: z31.string().optional().describe("Check interval (e.g. '1m'; default '1m')"),
+  timeout: z31.string().optional().describe("Probe timeout (e.g. '500ms')"),
+  comment: z31.string().optional().describe("Optional comment"),
+  dryRun: z31.boolean().default(false).describe("Preview changes without applying")
 }).strict();
 var manageNetwatchEntryTool = {
   name: "manage_netwatch_entry",
@@ -7035,7 +7042,7 @@ var manageNetwatchEntryTool = {
   snapshotPaths: ["tool/netwatch"],
   async handler(params, context) {
     const parsed = manageNetwatchEntryInputSchema.parse(params);
-    log31.info(
+    log32.info(
       { routerId: context.routerId, action: parsed.action, host: parsed.host },
       "Managing Netwatch entry"
     );
@@ -7092,7 +7099,7 @@ var manageNetwatchEntryTool = {
         if (parsed.timeout) body.timeout = parsed.timeout;
         if (parsed.comment) body.comment = parsed.comment;
         const created = await context.routerClient.create("tool/netwatch", body);
-        log31.info({ host: parsed.host, id: created[".id"] }, "Netwatch entry added");
+        log32.info({ host: parsed.host, id: created[".id"] }, "Netwatch entry added");
         return {
           content: `Added Netwatch entry for "${parsed.host}".`,
           structuredContent: { action: "created", entry: created }
@@ -7116,7 +7123,7 @@ var manageNetwatchEntryTool = {
           };
         }
         await context.routerClient.remove("tool/netwatch", existing2[".id"]);
-        log31.info({ host: parsed.host }, "Netwatch entry removed");
+        log32.info({ host: parsed.host }, "Netwatch entry removed");
         return {
           content: `Removed Netwatch entry for "${parsed.host}".`,
           structuredContent: { action: "removed", host: parsed.host, id: existing2[".id"] }
@@ -7156,7 +7163,7 @@ var manageNetwatchEntryTool = {
         disabled: disabledValue
       });
       const resultAction = parsed.action === "disable" ? "disabled" : "enabled";
-      log31.info({ host: parsed.host, action: resultAction }, "Netwatch entry updated");
+      log32.info({ host: parsed.host, action: resultAction }, "Netwatch entry updated");
       return {
         content: `Netwatch entry for "${parsed.host}" ${resultAction}.`,
         structuredContent: { action: resultAction, host: parsed.host, id: existing[".id"] }
@@ -7167,10 +7174,10 @@ var manageNetwatchEntryTool = {
     }
   }
 };
-var listNeighborsInputSchema = z30.object({
-  routerId: z30.string().describe("Target router identifier from the router registry"),
-  interface: z30.string().optional().describe("Filter by interface name (substring match)"),
-  limit: z30.number().int().min(1).max(500).default(100).describe("Maximum number of neighbors to return")
+var listNeighborsInputSchema = z31.object({
+  routerId: z31.string().describe("Target router identifier from the router registry"),
+  interface: z31.string().optional().describe("Filter by interface name (substring match)"),
+  limit: z31.number().int().min(1).max(500).default(100).describe("Maximum number of neighbors to return")
 }).strict();
 var listNeighborsTool = {
   name: "list_neighbors",
@@ -7185,7 +7192,7 @@ var listNeighborsTool = {
   },
   async handler(params, context) {
     const parsed = listNeighborsInputSchema.parse(params);
-    log31.info({ routerId: context.routerId }, "Listing neighbors");
+    log32.info({ routerId: context.routerId }, "Listing neighbors");
     try {
       const allNeighbors = await context.routerClient.get("ip/neighbor", {
         limit: void 0,
@@ -7209,12 +7216,12 @@ var listNeighborsTool = {
     }
   }
 };
-var listArpEntriesInputSchema = z30.object({
-  routerId: z30.string().describe("Target router identifier from the router registry"),
-  interface: z30.string().optional().describe("Filter by interface (substring match)"),
-  address: z30.string().optional().describe("Filter by IP address (substring match)"),
-  macAddress: z30.string().optional().describe("Filter by MAC address (substring match)"),
-  limit: z30.number().int().min(1).max(500).default(100).describe("Maximum number of ARP entries to return")
+var listArpEntriesInputSchema = z31.object({
+  routerId: z31.string().describe("Target router identifier from the router registry"),
+  interface: z31.string().optional().describe("Filter by interface (substring match)"),
+  address: z31.string().optional().describe("Filter by IP address (substring match)"),
+  macAddress: z31.string().optional().describe("Filter by MAC address (substring match)"),
+  limit: z31.number().int().min(1).max(500).default(100).describe("Maximum number of ARP entries to return")
 }).strict();
 var listArpEntriesTool = {
   name: "list_arp_entries",
@@ -7229,7 +7236,7 @@ var listArpEntriesTool = {
   },
   async handler(params, context) {
     const parsed = listArpEntriesInputSchema.parse(params);
-    log31.info({ routerId: context.routerId }, "Listing ARP entries");
+    log32.info({ routerId: context.routerId }, "Listing ARP entries");
     try {
       const allEntries = await context.routerClient.get("ip/arp", {
         limit: void 0,
@@ -7262,8 +7269,514 @@ var networkServicesTools = [
   listArpEntriesTool
 ];
 
+// src/domain/tools/vlan-tools.ts
+import { z as z32 } from "zod";
+var log33 = createLogger("vlan-tools");
+function sanitizeComment4(comment) {
+  if (comment === void 0) return void 0;
+  return comment.replace(/[\x00-\x1f\x7f]/g, "");
+}
+var manageVlanInputSchema = z32.object({
+  routerId: z32.string().describe("Target router identifier from the router registry"),
+  action: z32.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
+  name: z32.string().regex(/^[a-zA-Z0-9_-]+$/).max(15).describe("VLAN interface name \u2014 idempotency key (alphanumeric, hyphens, underscores, max 15 chars)"),
+  vlanId: z32.number().int().min(1).max(4094).optional().describe("VLAN ID (1-4094; required for add)"),
+  parentInterface: z32.string().optional().describe("Parent interface name (e.g., ether1, bridge1; required for add)"),
+  mtu: z32.number().int().min(68).max(9e3).default(1500).describe("MTU size (add only)"),
+  disabled: z32.boolean().default(false).describe("Whether to create the VLAN disabled (add only)"),
+  comment: z32.string().max(255).optional().describe("Optional comment (add only)"),
+  dryRun: z32.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageVlanTool = {
+  name: "manage_vlan",
+  title: "Manage VLAN Interface",
+  description: "Add, remove, enable, or disable a VLAN interface. Idempotent by name: add returns already_exists when a VLAN with matching name, vlan-id, and parent interface exists. Supports dry-run mode.",
+  inputSchema: manageVlanInputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  snapshotPaths: ["interface/vlan"],
+  async handler(params, context) {
+    const parsed = manageVlanInputSchema.parse(params);
+    const comment = sanitizeComment4(parsed.comment);
+    log33.info({ routerId: context.routerId, action: parsed.action, name: parsed.name }, "Managing VLAN");
+    try {
+      const allVlans = await context.routerClient.get("interface/vlan", {
+        limit: void 0,
+        offset: void 0
+      });
+      const existing = allVlans.find((v) => v.name === parsed.name);
+      if (parsed.action === "add") {
+        if (parsed.vlanId === void 0) {
+          throw new MikroMCPError({
+            category: "VALIDATION" /* VALIDATION */,
+            code: "VLAN_ID_REQUIRED",
+            message: "vlanId is required when adding a VLAN.",
+            details: { name: parsed.name },
+            recoverability: { retryable: false, suggestedAction: "Provide vlanId (1-4094)." }
+          });
+        }
+        if (!parsed.parentInterface) {
+          throw new MikroMCPError({
+            category: "VALIDATION" /* VALIDATION */,
+            code: "VLAN_PARENT_REQUIRED",
+            message: "parentInterface is required when adding a VLAN.",
+            details: { name: parsed.name },
+            recoverability: { retryable: false, suggestedAction: "Provide the parent interface name." }
+          });
+        }
+        if (existing) {
+          if (existing["vlan-id"] === String(parsed.vlanId) && existing.interface === parsed.parentInterface) {
+            log33.info({ name: parsed.name }, "VLAN already exists with matching config");
+            return {
+              content: `VLAN "${parsed.name}" already exists with VLAN ID ${parsed.vlanId} on ${parsed.parentInterface}. No changes made.`,
+              structuredContent: { action: "already_exists", vlan: existing }
+            };
+          }
+          throw new MikroMCPError({
+            category: "CONFLICT" /* CONFLICT */,
+            code: "VLAN_NAME_CONFLICT",
+            message: `VLAN "${parsed.name}" already exists but with different configuration (vlan-id=${existing["vlan-id"]}, interface=${existing.interface}).`,
+            details: {
+              existing: { vlanId: existing["vlan-id"], interface: existing.interface },
+              requested: { vlanId: parsed.vlanId, interface: parsed.parentInterface }
+            },
+            recoverability: {
+              retryable: false,
+              suggestedAction: "Use a different name or remove the existing VLAN first.",
+              alternativeTools: ["manage_vlan"]
+            }
+          });
+        }
+        if (parsed.dryRun) {
+          const diff = [
+            { property: "name", before: null, after: parsed.name },
+            { property: "vlan-id", before: null, after: String(parsed.vlanId) },
+            { property: "interface", before: null, after: parsed.parentInterface },
+            { property: "mtu", before: null, after: String(parsed.mtu) },
+            { property: "disabled", before: null, after: parsed.disabled ? "true" : "false" },
+            ...comment ? [{ property: "comment", before: null, after: comment }] : []
+          ];
+          return {
+            content: `Dry run: Would create VLAN "${parsed.name}" (ID ${parsed.vlanId}) on ${parsed.parentInterface} with MTU ${parsed.mtu}.`,
+            structuredContent: { action: "dry_run", diff }
+          };
+        }
+        const body = {
+          name: parsed.name,
+          "vlan-id": String(parsed.vlanId),
+          interface: parsed.parentInterface,
+          mtu: String(parsed.mtu),
+          disabled: parsed.disabled ? "true" : "false"
+        };
+        if (comment) body.comment = comment;
+        const created = await context.routerClient.create("interface/vlan", body);
+        log33.info({ name: parsed.name, id: created[".id"] }, "VLAN created");
+        return {
+          content: `Created VLAN "${parsed.name}" (ID ${parsed.vlanId}) on ${parsed.parentInterface} with MTU ${parsed.mtu}.`,
+          structuredContent: { action: "created", vlan: created }
+        };
+      }
+      if (parsed.action === "remove") {
+        if (!existing) {
+          return {
+            content: `VLAN "${parsed.name}" not found. Nothing to remove.`,
+            structuredContent: { action: "not_found", name: parsed.name }
+          };
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would remove VLAN "${parsed.name}".`,
+            structuredContent: { action: "dry_run", diff: [{ property: "name", before: parsed.name, after: null }] }
+          };
+        }
+        await context.routerClient.remove("interface/vlan", existing[".id"]);
+        log33.info({ name: parsed.name }, "VLAN removed");
+        return {
+          content: `Removed VLAN "${parsed.name}".`,
+          structuredContent: { action: "removed", name: parsed.name, id: existing[".id"] }
+        };
+      }
+      if (!existing) {
+        throw new MikroMCPError({
+          category: "NOT_FOUND" /* NOT_FOUND */,
+          code: "VLAN_NOT_FOUND",
+          message: `VLAN "${parsed.name}" not found.`,
+          details: { name: parsed.name },
+          recoverability: {
+            retryable: false,
+            suggestedAction: "Verify the VLAN name with list_interfaces.",
+            alternativeTools: ["list_interfaces"]
+          }
+        });
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would ${parsed.action} VLAN "${parsed.name}".`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [{ property: "disabled", before: existing.disabled, after: parsed.action === "disable" ? "true" : "false" }]
+          }
+        };
+      }
+      const disabledValue = parsed.action === "disable" ? "true" : "false";
+      await context.routerClient.update("interface/vlan", existing[".id"], { disabled: disabledValue });
+      const resultAction = parsed.action === "disable" ? "disabled" : "enabled";
+      log33.info({ name: parsed.name, action: resultAction }, "VLAN updated");
+      return {
+        content: `VLAN "${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_vlan" });
+    }
+  }
+};
+var vlanTools = [manageVlanTool];
+
+// src/domain/tools/dhcp-client-tools.ts
+import { z as z33 } from "zod";
+var log34 = createLogger("dhcp-client-tools");
+var listDhcpClientsInputSchema = z33.object({
+  routerId: z33.string().describe("Target router identifier from the router registry"),
+  interface: z33.string().optional().describe("Filter by interface name (exact match)"),
+  status: z33.enum(["bound", "searching", "requesting", "init", "all"]).default("all").describe("Filter by DHCP client status"),
+  limit: z33.number().int().min(1).max(500).default(100).describe("Maximum number of clients to return"),
+  offset: z33.number().int().min(0).default(0).describe("Offset for pagination")
+}).strict();
+var listDhcpClientsTool = {
+  name: "list_dhcp_clients",
+  title: "List DHCP Clients",
+  description: "List DHCP client configurations on a MikroTik router. Shows which interfaces obtain their IP via DHCP, current status, and assigned address.",
+  inputSchema: listDhcpClientsInputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  async handler(params, context) {
+    const parsed = listDhcpClientsInputSchema.parse(params);
+    log34.info({ routerId: context.routerId }, "Listing DHCP clients");
+    try {
+      const allClients = await context.routerClient.get("ip/dhcp-client", {
+        limit: void 0,
+        offset: void 0
+      });
+      let filtered = allClients;
+      if (parsed.interface) {
+        filtered = filtered.filter((c) => c.interface === parsed.interface);
+      }
+      if (parsed.status !== "all") {
+        filtered = filtered.filter((c) => c.status === parsed.status);
+      }
+      const total = filtered.length;
+      const clients = filtered.slice(parsed.offset, parsed.offset + parsed.limit);
+      const hasMore = parsed.offset + parsed.limit < total;
+      const lines = [
+        `DHCP clients on ${context.routerId}: ${total} total, showing ${clients.length} (offset ${parsed.offset})`
+      ];
+      for (const c of clients) {
+        const rec = c;
+        const iface = rec.interface ?? "unknown";
+        const status = rec.status ?? "unknown";
+        const address = rec.address ?? rec["active-address"] ?? "-";
+        const isDisabled = rec.disabled === true || rec.disabled === "true";
+        lines.push(`  ${iface}  [${status}]  ${address}${isDisabled ? "  DISABLED" : ""}`);
+      }
+      return {
+        content: lines.join("\n"),
+        structuredContent: {
+          routerId: context.routerId,
+          clients,
+          total,
+          hasMore,
+          offset: parsed.offset,
+          limit: parsed.limit
+        }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "list_dhcp_clients" });
+    }
+  }
+};
+var manageDhcpClientInputSchema = z33.object({
+  routerId: z33.string().describe("Target router identifier from the router registry"),
+  action: z33.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
+  interface: z33.string().describe("Interface name \u2014 idempotency key (e.g. ether1, ether2)"),
+  usePeerDns: z33.boolean().default(true).describe("Use DNS servers provided by DHCP server (add only)"),
+  usePeerNtp: z33.boolean().default(false).describe("Use NTP servers provided by DHCP server (add only)"),
+  addDefaultRoute: z33.boolean().default(true).describe("Add default route from DHCP (add only)"),
+  comment: z33.string().max(255).optional().describe("Optional comment (add only)"),
+  dryRun: z33.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageDhcpClientTool = {
+  name: "manage_dhcp_client",
+  title: "Manage DHCP Client",
+  description: "Add, remove, enable, or disable a DHCP client on an interface. Idempotent by interface name: add returns already_exists if a DHCP client is already configured on the same interface.",
+  inputSchema: manageDhcpClientInputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  snapshotPaths: ["ip/dhcp-client"],
+  async handler(params, context) {
+    const parsed = manageDhcpClientInputSchema.parse(params);
+    log34.info({ routerId: context.routerId, action: parsed.action, interface: parsed.interface }, "Managing DHCP client");
+    try {
+      const allClients = await context.routerClient.get("ip/dhcp-client", {
+        limit: void 0,
+        offset: void 0
+      });
+      const existing = allClients.find(
+        (c) => c.interface === parsed.interface
+      );
+      if (parsed.action === "add") {
+        if (existing) {
+          return {
+            content: `DHCP client already configured on "${parsed.interface}". No changes made.`,
+            structuredContent: { action: "already_exists", client: existing }
+          };
+        }
+        if (parsed.dryRun) {
+          const diff = [
+            { property: "interface", before: null, after: parsed.interface },
+            { property: "use-peer-dns", before: null, after: parsed.usePeerDns ? "yes" : "no" },
+            { property: "use-peer-ntp", before: null, after: parsed.usePeerNtp ? "yes" : "no" },
+            { property: "add-default-route", before: null, after: parsed.addDefaultRoute ? "yes" : "no" }
+          ];
+          return {
+            content: `Dry run: Would add DHCP client on "${parsed.interface}".`,
+            structuredContent: { action: "dry_run", diff }
+          };
+        }
+        const body = {
+          interface: parsed.interface,
+          "use-peer-dns": parsed.usePeerDns ? "yes" : "no",
+          "use-peer-ntp": parsed.usePeerNtp ? "yes" : "no",
+          "add-default-route": parsed.addDefaultRoute ? "yes" : "no"
+        };
+        if (parsed.comment) body.comment = parsed.comment;
+        const created = await context.routerClient.create("ip/dhcp-client", body);
+        log34.info({ interface: parsed.interface, id: created[".id"] }, "DHCP client added");
+        return {
+          content: `Added DHCP client on "${parsed.interface}".`,
+          structuredContent: { action: "created", client: created }
+        };
+      }
+      if (parsed.action === "remove") {
+        if (!existing) {
+          return {
+            content: `No DHCP client found on "${parsed.interface}". Nothing to remove.`,
+            structuredContent: { action: "not_found", interface: parsed.interface }
+          };
+        }
+        if (parsed.dryRun) {
+          return {
+            content: `Dry run: Would remove DHCP client on "${parsed.interface}".`,
+            structuredContent: {
+              action: "dry_run",
+              diff: [{ property: "interface", before: parsed.interface, after: null }]
+            }
+          };
+        }
+        await context.routerClient.remove("ip/dhcp-client", existing[".id"]);
+        log34.info({ interface: parsed.interface }, "DHCP client removed");
+        return {
+          content: `Removed DHCP client on "${parsed.interface}".`,
+          structuredContent: { action: "removed", interface: parsed.interface, id: existing[".id"] }
+        };
+      }
+      if (!existing) {
+        throw new MikroMCPError({
+          category: "NOT_FOUND" /* NOT_FOUND */,
+          code: "DHCP_CLIENT_NOT_FOUND",
+          message: `No DHCP client found on interface "${parsed.interface}".`,
+          details: { interface: parsed.interface },
+          recoverability: {
+            retryable: false,
+            suggestedAction: "Verify with list_dhcp_clients.",
+            alternativeTools: ["list_dhcp_clients"]
+          }
+        });
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would ${parsed.action} DHCP client on "${parsed.interface}".`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [
+              {
+                property: "disabled",
+                before: existing.disabled,
+                after: parsed.action === "disable" ? "true" : "false"
+              }
+            ]
+          }
+        };
+      }
+      const disabledValue = parsed.action === "disable" ? "true" : "false";
+      await context.routerClient.update("ip/dhcp-client", existing[".id"], { disabled: disabledValue });
+      const resultAction = parsed.action === "disable" ? "disabled" : "enabled";
+      log34.info({ interface: parsed.interface, action: resultAction }, "DHCP client updated");
+      return {
+        content: `DHCP client on "${parsed.interface}" ${resultAction}.`,
+        structuredContent: { action: resultAction, interface: parsed.interface, id: existing[".id"] }
+      };
+    } catch (err) {
+      if (err instanceof MikroMCPError) throw err;
+      throw enrichError(err, { routerId: context.routerId, tool: "manage_dhcp_client" });
+    }
+  }
+};
+var dhcpClientTools = [listDhcpClientsTool, manageDhcpClientTool];
+
+// src/domain/tools/ip-service-tools.ts
+import { z as z34 } from "zod";
+var log35 = createLogger("ip-service-tools");
+var SERVICE_NAMES = ["api", "api-ssl", "ssh", "telnet", "www", "www-ssl", "winbox", "ftp"];
+var listIpServicesInputSchema = z34.object({
+  routerId: z34.string().describe("Target router identifier from the router registry"),
+  name: z34.enum(SERVICE_NAMES).optional().describe("Filter by service name (api, api-ssl, ssh, telnet, www, www-ssl, winbox, ftp)"),
+  enabled: z34.boolean().optional().describe("When true, return only enabled services; when false, only disabled services")
+}).strict();
+var listIpServicesTool = {
+  name: "list_ip_services",
+  title: "List IP Services",
+  description: "List IP services on a MikroTik router (api, api-ssl, ssh, telnet, www, www-ssl, winbox, ftp) with their port numbers and enabled/disabled status.",
+  inputSchema: listIpServicesInputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  async handler(params, context) {
+    const parsed = listIpServicesInputSchema.parse(params);
+    log35.info({ routerId: context.routerId }, "Listing IP services");
+    try {
+      const allServices = await context.routerClient.get("ip/service", {
+        limit: void 0,
+        offset: void 0
+      });
+      let filtered = allServices;
+      if (parsed.name) {
+        filtered = filtered.filter((s) => s.name === parsed.name);
+      }
+      if (parsed.enabled !== void 0) {
+        filtered = filtered.filter((s) => {
+          const isDisabled = s.disabled === true || s.disabled === "true";
+          return parsed.enabled ? !isDisabled : isDisabled;
+        });
+      }
+      const lines = [`IP services on ${context.routerId}: ${filtered.length} returned`];
+      for (const s of filtered) {
+        const rec = s;
+        const isDisabled = rec.disabled === true || rec.disabled === "true";
+        lines.push(`  ${rec.name}  port:${rec.port ?? "-"}  [${isDisabled ? "DISABLED" : "enabled"}]`);
+      }
+      return {
+        content: lines.join("\n"),
+        structuredContent: {
+          routerId: context.routerId,
+          services: filtered,
+          total: filtered.length
+        }
+      };
+    } catch (err) {
+      throw enrichError(err, { routerId: context.routerId, tool: "list_ip_services" });
+    }
+  }
+};
+var manageIpServiceInputSchema = z34.object({
+  routerId: z34.string().describe("Target router identifier from the router registry"),
+  action: z34.enum(["enable", "disable"]).describe(
+    "Action to perform \u2014 only enable/disable to prevent accidental lockout from changing ports"
+  ),
+  name: z34.enum(SERVICE_NAMES).describe("Service name to manage (api, api-ssl, ssh, telnet, www, www-ssl, winbox, ftp)"),
+  dryRun: z34.boolean().default(false).describe("Preview changes without applying")
+}).strict();
+var manageIpServiceTool = {
+  name: "manage_ip_service",
+  title: "Manage IP Service",
+  description: "Enable or disable a RouterOS IP service (api, api-ssl, ssh, telnet, www, www-ssl, winbox, ftp). Port number changes are intentionally not supported to prevent accidental lockout.",
+  inputSchema: manageIpServiceInputSchema,
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  async handler(params, context) {
+    const parsed = manageIpServiceInputSchema.parse(params);
+    log35.info({ routerId: context.routerId, action: parsed.action, name: parsed.name }, "Managing IP service");
+    try {
+      const allServices = await context.routerClient.get("ip/service", {
+        limit: void 0,
+        offset: void 0
+      });
+      const existing = allServices.find((s) => s.name === parsed.name);
+      if (!existing) {
+        throw new MikroMCPError({
+          category: "NOT_FOUND" /* NOT_FOUND */,
+          code: "IP_SERVICE_NOT_FOUND",
+          message: `IP service "${parsed.name}" not found on router.`,
+          details: { name: parsed.name },
+          recoverability: {
+            retryable: false,
+            suggestedAction: "Verify service name with list_ip_services.",
+            alternativeTools: ["list_ip_services"]
+          }
+        });
+      }
+      const isCurrentlyDisabled = existing.disabled === "true" || existing.disabled === true;
+      const wouldBeDisabled = parsed.action === "disable";
+      if (isCurrentlyDisabled === wouldBeDisabled) {
+        const alreadyState = parsed.action === "disable" ? "disabled" : "enabled";
+        return {
+          content: `IP service "${parsed.name}" is already ${alreadyState}. No changes made.`,
+          structuredContent: { action: "no_change", name: parsed.name, id: existing[".id"] }
+        };
+      }
+      if (parsed.dryRun) {
+        return {
+          content: `Dry run: Would ${parsed.action} IP service "${parsed.name}".`,
+          structuredContent: {
+            action: "dry_run",
+            diff: [
+              {
+                property: "disabled",
+                before: existing.disabled,
+                after: parsed.action === "disable" ? "true" : "false"
+              }
+            ]
+          }
+        };
+      }
+      const disabledValue = parsed.action === "disable" ? "true" : "false";
+      await context.routerClient.update("ip/service", existing[".id"], { disabled: disabledValue });
+      const resultAction = parsed.action === "disable" ? "disabled" : "enabled";
+      log35.info({ name: parsed.name, action: resultAction }, "IP service updated");
+      return {
+        content: `IP service "${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_ip_service" });
+    }
+  }
+};
+var ipServiceTools = [listIpServicesTool, manageIpServiceTool];
+
 // src/domain/tools/fleet-tools.ts
-import { z as z31 } from "zod";
+import { z as z35 } from "zod";
 
 // src/middleware/authz.ts
 function matchesPattern(name, pattern) {
@@ -7431,7 +7944,7 @@ var SshClient = class {
 // src/adapter/ftp-client.ts
 import { Client as Client2 } from "basic-ftp";
 import { Readable } from "stream";
-var log32 = createLogger("ftp-client");
+var log36 = createLogger("ftp-client");
 var FtpClient = class {
   #host;
   #port;
@@ -7444,7 +7957,7 @@ var FtpClient = class {
     this.#password = password;
   }
   async upload(remoteName, content) {
-    log32.info({ host: this.#host, remoteName }, "Uploading file via FTP");
+    log36.info({ host: this.#host, remoteName }, "Uploading file via FTP");
     const client = new Client2();
     try {
       await client.access({
@@ -7454,7 +7967,7 @@ var FtpClient = class {
         password: this.#password
       });
       await client.uploadFrom(Readable.from(Buffer.from(content, "utf-8")), remoteName);
-      log32.info({ host: this.#host, remoteName }, "FTP upload complete");
+      log36.info({ host: this.#host, remoteName }, "FTP upload complete");
     } finally {
       client.close();
     }
@@ -7562,17 +8075,17 @@ function checkFleetConfirmation(args, secret) {
 }
 
 // src/domain/tools/fleet-tools.ts
-var log33 = createLogger("fleet-tools");
-var checkHealthInputSchema = z31.object({
-  routerId: z31.string().describe("Target router to health-check")
+var log37 = createLogger("fleet-tools");
+var checkHealthInputSchema = z35.object({
+  routerId: z35.string().describe("Target router to health-check")
 }).strict();
-var bulkExecuteInputSchema = z31.object({
-  toolName: z31.string().describe("Name of the tool to fan out (must be a single-router tool)"),
-  routerIds: z31.array(z31.string()).optional().describe("Explicit list of router IDs to target"),
-  tags: z31.array(z31.string()).optional().describe("Target all routers with ALL of these tags (mutually exclusive with routerIds)"),
-  params: z31.record(z31.string(), z31.unknown()).describe("Params to pass to the tool (omit routerId \u2014 injected per router)"),
-  concurrency: z31.number().int().min(1).max(20).default(5).describe("Max simultaneous router calls"),
-  confirmationToken: z31.string().optional().describe(
+var bulkExecuteInputSchema = z35.object({
+  toolName: z35.string().describe("Name of the tool to fan out (must be a single-router tool)"),
+  routerIds: z35.array(z35.string()).optional().describe("Explicit list of router IDs to target"),
+  tags: z35.array(z35.string()).optional().describe("Target all routers with ALL of these tags (mutually exclusive with routerIds)"),
+  params: z35.record(z35.string(), z35.unknown()).describe("Params to pass to the tool (omit routerId \u2014 injected per router)"),
+  concurrency: z35.number().int().min(1).max(20).default(5).describe("Max simultaneous router calls"),
+  confirmationToken: z35.string().optional().describe(
     "Fleet confirmation token from a prior APPROVAL_REQUIRED response. Required to fan out a destructive tool."
   )
 }).strict();
@@ -7591,7 +8104,7 @@ function createFleetTools(baseTools2) {
     },
     async handler(params, context) {
       checkHealthInputSchema.parse(params);
-      log33.info({ routerId: context.routerId }, "Checking router health");
+      log37.info({ routerId: context.routerId }, "Checking router health");
       const startMs = Date.now();
       try {
         const resources = await context.routerClient.get("system/resource");
@@ -7653,7 +8166,7 @@ function createFleetTools(baseTools2) {
           }
         });
       }
-      log33.info(
+      log37.info(
         { toolName: parsed.toolName, concurrency: parsed.concurrency },
         "bulk_execute invoked"
       );
@@ -7700,7 +8213,7 @@ function createFleetTools(baseTools2) {
           try {
             resolved.push(context.routerRegistry.getRouter(id));
           } catch {
-            log33.warn({ routerId: id }, "bulk_execute: router not found");
+            log37.warn({ routerId: id }, "bulk_execute: router not found");
             preErrors.push({
               routerId: id,
               status: "error",
@@ -7872,9 +8385,13 @@ var baseTools = [
   ...certificateTools,
   ...userTools,
   ...dhcpServerTools,
+  ...ipPoolTools,
   ...queueTools,
   ...vrrpTools,
-  ...networkServicesTools
+  ...networkServicesTools,
+  ...vlanTools,
+  ...dhcpClientTools,
+  ...ipServiceTools
 ];
 var allTools = [
   ...baseTools,
@@ -8273,7 +8790,7 @@ var CircuitBreaker = class {
 };
 
 // src/mcp/tool-executor.ts
-var log34 = createLogger("tool-executor");
+var log38 = createLogger("tool-executor");
 async function executeToolCall(tool, args, deps) {
   const { registry, pool, circuitBreakers, config, identityRegistry } = deps;
   const correlationId = nanoid4();
@@ -8369,9 +8886,9 @@ async function executeToolCall(tool, args, deps) {
           try {
             const meta = await takeSnapshot(toolContext.routerClient, routerId, path, config.snapshotDir);
             snapshotIds.push(meta.id);
-            log34.debug({ snapshotId: meta.id, path }, "Snapshot taken");
+            log38.debug({ snapshotId: meta.id, path }, "Snapshot taken");
           } catch (err) {
-            log34.warn({ err, path, routerId }, "Snapshot failed \u2014 proceeding without snapshot");
+            log38.warn({ err, path, routerId }, "Snapshot failed \u2014 proceeding without snapshot");
           }
         }
       }
@@ -8413,7 +8930,7 @@ async function executeToolCall(tool, args, deps) {
           durationMs: Date.now() - startMs
         }, config.auditLogPath);
       }
-      log34.info({ tool: tool.name, routerId, correlationId }, "Tool executed successfully");
+      log38.info({ tool: tool.name, routerId, correlationId }, "Tool executed successfully");
       recordToolCall(tool.name, "success");
       return formatToolResult(result);
     } catch (err) {
@@ -8422,7 +8939,7 @@ async function executeToolCall(tool, args, deps) {
         const failedRouterId = args.routerId;
         if (failedRouterId) {
           pool.removeClient(failedRouterId);
-          log34.info({ routerId: failedRouterId }, "Evicted pooled client after auth failure");
+          log38.info({ routerId: failedRouterId }, "Evicted pooled client after auth failure");
         }
       }
       if (journalId) {
@@ -8452,7 +8969,7 @@ async function executeToolCall(tool, args, deps) {
           durationMs: Date.now() - startMs
         }, config.auditLogPath);
       }
-      log34.error({ err: error, tool: tool.name, correlationId }, "Tool execution failed");
+      log38.error({ err: error, tool: tool.name, correlationId }, "Tool execution failed");
       recordToolCall(tool.name, "error");
       return formatError(error);
     }
@@ -8460,12 +8977,12 @@ async function executeToolCall(tool, args, deps) {
 }
 
 // src/mcp/tool-registry.ts
-var log35 = createLogger("tool-registry");
+var log39 = createLogger("tool-registry");
 function registerAllTools(server, registry, pool, circuitBreakers, config, identityRegistry) {
   const deps = { registry, pool, circuitBreakers, config, identityRegistry };
   for (const tool of allTools) {
     const registrationSchema = tool.annotations.destructiveHint ? tool.inputSchema.extend({
-      confirmationToken: z32.string().optional().describe(
+      confirmationToken: z36.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;
@@ -8479,56 +8996,56 @@ function registerAllTools(server, registry, pool, circuitBreakers, config, ident
       },
       (args) => executeToolCall(tool, args, deps)
     );
-    log35.debug({ tool: tool.name }, "Registered tool");
+    log39.debug({ tool: tool.name }, "Registered tool");
   }
-  log35.info({ count: allTools.length }, "All tools registered");
+  log39.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 z33 } from "zod";
-var log36 = createLogger("router-registry");
-var RouterConfigSchema = z33.object({
-  host: z33.string().min(1, "host is required"),
-  port: z33.number().int().min(1).max(65535),
-  tls: z33.object({
-    enabled: z33.boolean(),
-    rejectUnauthorized: z33.boolean(),
-    ca: z33.string().optional(),
-    fingerprint: z33.string().optional()
+import { z as z37 } from "zod";
+var log40 = createLogger("router-registry");
+var RouterConfigSchema = z37.object({
+  host: z37.string().min(1, "host is required"),
+  port: z37.number().int().min(1).max(65535),
+  tls: z37.object({
+    enabled: z37.boolean(),
+    rejectUnauthorized: z37.boolean(),
+    ca: z37.string().optional(),
+    fingerprint: z37.string().optional()
   }).strict(),
-  credentials: z33.object({
-    source: z33.enum(["env", "vault"]),
-    envPrefix: z33.string().optional(),
-    vaultPath: z33.string().optional()
+  credentials: z37.object({
+    source: z37.enum(["env", "vault"]),
+    envPrefix: z37.string().optional(),
+    vaultPath: z37.string().optional()
   }).strict(),
-  tags: z33.array(z33.string()).default([]),
-  rosVersion: z33.string().min(1),
-  sshPort: z33.number().int().min(1).max(65535).optional(),
-  sshFingerprint: z33.string().optional(),
-  cmdAllow: z33.array(z33.string()).optional(),
-  cmdDeny: z33.array(z33.string()).optional(),
-  maintenanceWindows: z33.array(
-    z33.object({
-      days: z33.array(
-        z33.enum(["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"])
+  tags: z37.array(z37.string()).default([]),
+  rosVersion: z37.string().min(1),
+  sshPort: z37.number().int().min(1).max(65535).optional(),
+  sshFingerprint: z37.string().optional(),
+  cmdAllow: z37.array(z37.string()).optional(),
+  cmdDeny: z37.array(z37.string()).optional(),
+  maintenanceWindows: z37.array(
+    z37.object({
+      days: z37.array(
+        z37.enum(["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"])
       ),
-      startTime: z33.string().regex(/^\d{2}:\d{2}$/, "startTime must be HH:MM"),
-      endTime: z33.string().regex(/^\d{2}:\d{2}$/, "endTime must be HH:MM"),
-      timezone: z33.string().min(1)
+      startTime: z37.string().regex(/^\d{2}:\d{2}$/, "startTime must be HH:MM"),
+      endTime: z37.string().regex(/^\d{2}:\d{2}$/, "endTime must be HH:MM"),
+      timezone: z37.string().min(1)
     }).strict()
   ).optional()
 }).strict();
-var ConfigFileSchema = z33.object({
-  routers: z33.record(z33.string(), RouterConfigSchema)
+var ConfigFileSchema = z37.object({
+  routers: z37.record(z37.string(), RouterConfigSchema)
 }).strict();
 var RouterRegistry = class {
   routers;
   constructor(configPath) {
     this.routers = /* @__PURE__ */ new Map();
     if (!existsSync(configPath)) {
-      log36.warn({ configPath }, "Router config file not found; starting with empty registry");
+      log40.warn({ configPath }, "Router config file not found; starting with empty registry");
       return;
     }
     const raw = readFileSync2(configPath, "utf-8");
@@ -8542,14 +9059,14 @@ ${issues}`);
     for (const [id, config] of Object.entries(result.data.routers)) {
       const routerConfig = { ...config, id };
       if (routerConfig.tls.enabled && !routerConfig.tls.rejectUnauthorized) {
-        log36.warn(
+        log40.warn(
           { routerId: id },
           "TLS certificate validation is DISABLED (rejectUnauthorized=false). Set tls.fingerprint to pin the server certificate instead."
         );
       }
       this.routers.set(id, routerConfig);
     }
-    log36.info({ count: this.routers.size }, "Loaded routers from config");
+    log40.info({ count: this.routers.size }, "Loaded routers from config");
   }
   getRouter(id) {
     const router = this.routers.get(id);
@@ -8834,7 +9351,7 @@ var ConnectionPool = class {
 };
 
 // src/version.ts
-var VERSION = "1.1.0";
+var VERSION = "1.2.0";
 
 // src/mcp/server.ts
 function createServerFactory(config, identityRegistry) {
@@ -8864,7 +9381,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 log37 = createLogger("transport-http");
+var log41 = createLogger("transport-http");
 var BodyTooLargeError = class extends Error {
   constructor() {
     super("Request body exceeds maximum allowed size");
@@ -8956,7 +9473,7 @@ async function connectHttp(makeServer, config, identityRegistry) {
       return;
     }
     if (!checkRateLimit(ip)) {
-      log37.warn({ ip }, "Rate limit exceeded");
+      log41.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;
@@ -8997,7 +9514,7 @@ async function connectHttp(makeServer, config, identityRegistry) {
         }
         return;
       }
-      log37.error({ err }, "HTTP transport error");
+      log41.error({ err }, "HTTP transport error");
       if (!res.headersSent) {
         res.writeHead(500, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "Internal server error" }));
@@ -9007,7 +9524,7 @@ async function connectHttp(makeServer, config, identityRegistry) {
   httpServer.on("close", () => clearInterval(sweepTimer));
   await new Promise((resolve, reject) => {
     httpServer.listen(port, bindHost, () => {
-      log37.info(
+      log41.info(
         { port, bindHost },
         "HTTP transport listening (POST /mcp for Streamable HTTP, GET /sse for legacy SSE)"
       );
@@ -9031,13 +9548,13 @@ async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, mak
         sessionIdGenerator: () => randomUUID(),
         onsessioninitialized: (id) => {
           streamableSessions.set(id, transport2);
-          log37.info({ sessionId: id }, "Streamable HTTP session created");
+          log41.info({ sessionId: id }, "Streamable HTTP session created");
         }
       });
       transport2.onclose = () => {
         if (transport2.sessionId) {
           streamableSessions.delete(transport2.sessionId);
-          log37.info({ sessionId: transport2.sessionId }, "Streamable HTTP session closed");
+          log41.info({ sessionId: transport2.sessionId }, "Streamable HTTP session closed");
         }
       };
       await makeServer().connect(transport2);
@@ -9054,7 +9571,7 @@ async function handleMcpRequest(pathname, req, res, url, port, maxBodyBytes, mak
     sseTransport.onclose = () => {
       sseTransports.delete(sseTransport.sessionId);
     };
-    log37.info({ sessionId: sseTransport.sessionId }, "SSE client connected");
+    log41.info({ sessionId: sseTransport.sessionId }, "SSE client connected");
     await sseTransport.start();
     return;
   }
@@ -9075,23 +9592,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 z34 } from "zod";
+import { z as z38 } from "zod";
 import bcrypt from "bcryptjs";
-var log38 = createLogger("identity-registry");
-var IdentityConfigSchema = z34.object({
-  token: z34.string().min(1, "token hash is required"),
-  role: z34.enum(["readonly", "operator", "admin", "superadmin"]),
-  allowedRouters: z34.array(z34.string()).default([]),
-  allowedToolPatterns: z34.array(z34.string()).default([])
+var log42 = createLogger("identity-registry");
+var IdentityConfigSchema = z38.object({
+  token: z38.string().min(1, "token hash is required"),
+  role: z38.enum(["readonly", "operator", "admin", "superadmin"]),
+  allowedRouters: z38.array(z38.string()).default([]),
+  allowedToolPatterns: z38.array(z38.string()).default([])
 }).strict();
-var ConfigFileSchema2 = z34.object({
-  identities: z34.record(z34.string(), IdentityConfigSchema)
+var ConfigFileSchema2 = z38.object({
+  identities: z38.record(z38.string(), IdentityConfigSchema)
 }).strict();
 var IdentityRegistry = class {
   identities = [];
   constructor(configPath) {
     if (!existsSync2(configPath)) {
-      log38.warn(
+      log42.warn(
         { configPath },
         "Identity config file not found; starting with empty registry (stdio callers do not require it)"
       );
@@ -9114,7 +9631,7 @@ ${issues}`);
         allowedToolPatterns: config.allowedToolPatterns
       });
     }
-    log38.info({ count: this.identities.length }, "Loaded identities from config");
+    log42.info({ count: this.identities.length }, "Loaded identities from config");
   }
   getIdentities() {
     return this.identities.map(({ id, role, allowedRouters, allowedToolPatterns }) => ({
@@ -9143,7 +9660,7 @@ ${issues}`);
 // src/domain/snapshot/retention.ts
 import { readdir, stat, unlink } from "fs/promises";
 import { join as join3 } from "path";
-var log39 = createLogger("snapshot-retention");
+var log43 = createLogger("snapshot-retention");
 async function pruneSnapshots(snapshotDir, maxAgeDays) {
   const cutoffMs = Date.now() - maxAgeDays * 864e5;
   let removed = 0;
@@ -9170,21 +9687,21 @@ async function pruneSnapshots(snapshotDir, maxAgeDays) {
           removed++;
         }
       } catch (err) {
-        log39.warn({ err, filePath }, "Failed to evaluate snapshot for retention");
+        log43.warn({ err, filePath }, "Failed to evaluate snapshot for retention");
       }
     }
   }
   if (removed > 0) {
-    log39.info({ removed, maxAgeDays }, "Pruned expired snapshots");
+    log43.info({ removed, maxAgeDays }, "Pruned expired snapshots");
   }
   return removed;
 }
 
 // src/cli/serve.ts
-var log40 = createLogger("main");
+var log44 = createLogger("main");
 async function runServe() {
   const config = loadAppConfig();
-  log40.info({ transport: config.transport, logLevel: config.logLevel }, "Starting MikroMCP server");
+  log44.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") {
@@ -9192,7 +9709,7 @@ async function runServe() {
       (i) => i.role === "readonly" || i.role === "operator"
     );
     if (hasLimitedRoles && !config.confirmationSecret) {
-      log40.error(
+      log44.error(
         "MIKROMCP_CONFIRMATION_SECRET is required in HTTP mode when identities with role readonly or operator are configured"
       );
       process.exit(1);
@@ -9202,7 +9719,7 @@ async function runServe() {
   if (config.transport === "stdio") {
     const stdioIdentity = getStdioIdentity(config.stdioIdentity, identityRegistry);
     await withIdentity(stdioIdentity, () => connectStdio(makeServer()));
-    log40.info("MikroMCP server running via stdio");
+    log44.info("MikroMCP server running via stdio");
   } else if (config.transport === "http") {
     await connectHttp(
       makeServer,
@@ -9214,13 +9731,13 @@ async function runServe() {
       },
       identityRegistry
     );
-    log40.info(
+    log44.info(
       { port: config.port, bindHost: config.bindHost },
       "MikroMCP server running via HTTP/SSE"
     );
   }
   const shutdown = () => {
-    log40.info("Shutting down MikroMCP server");
+    log44.info("Shutting down MikroMCP server");
     pool.closeAll();
     process.exit(0);
   };
@@ -9233,7 +9750,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.1.0";
+var localVersion = "1.2.0";
 var results = [];
 function ok(msg) {
   console.log(chalk.green("\u2705 ") + msg);
@@ -9885,7 +10402,7 @@ async function runInit() {
 }
 
 // src/cli/index.ts
-var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.1.0");
+var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.2.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);