mikromcp 1.14.0 → 1.15.0

package/README.md

@@ -12,12 +12,12 @@
 
 [![CI](https://github.com/AliKarami/MikroMCP/actions/workflows/ci.yml/badge.svg)](https://github.com/AliKarami/MikroMCP/actions/workflows/ci.yml)
 [![Release](https://github.com/AliKarami/MikroMCP/actions/workflows/release.yml/badge.svg)](https://github.com/AliKarami/MikroMCP/actions/workflows/release.yml)
-[![Version](https://img.shields.io/badge/version-v1.14.0-2DD4BF)](package.json)
+[![Version](https://img.shields.io/badge/version-v1.15.0-2DD4BF)](package.json)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node.js >= 22](https://img.shields.io/badge/node-%3E%3D22-339933)](package.json)
 [![RouterOS 7.x](https://img.shields.io/badge/RouterOS-7.x-293239)](https://help.mikrotik.com/docs/display/ROS/REST+API)
 [![MCP Server](https://img.shields.io/badge/MCP-server-6f42c1)](https://modelcontextprotocol.io)
-[![Tools](https://img.shields.io/badge/MCP%20tools-132-0f766e)](https://github.com/AliKarami/MikroMCP/wiki/Available-Tools)
+[![Tools](https://img.shields.io/badge/MCP%20tools-133-0f766e)](https://github.com/AliKarami/MikroMCP/wiki/Available-Tools)
 [![MikroMCP MCP server](https://glama.ai/mcp/servers/AliKarami/MikroMCP/badges/score.svg)](https://glama.ai/mcp/servers/AliKarami/MikroMCP)
 
 MikroMCP exists because raw router CLI access is the wrong abstraction for AI agents. RouterOS is powerful, but asking an LLM to improvise shell commands against production network gear is risky. MikroMCP gives agents a controlled tool surface: strict schemas, idempotent writes, dry-run previews, per-router circuit breakers, retry policies, RBAC, audit logs, snapshots, and rollback-aware change workflows.
@@ -54,7 +54,7 @@ That's the whole setup for a single-router stdio deployment. For standalone bina
 | 🤖 **AI-agent fit**        | Human-readable responses plus structured JSON content for reasoning, chaining, and automation; server advertises an `instructions` string on MCP initialize so clients self-configure; optional [`routerId` resolved via `MIKROMCP_DEFAULT_ROUTER`](https://github.com/AliKarami/MikroMCP/wiki/Configuration) for single-router setups; [usage skill](docs/wiki/Using-the-Skill.md) for safe, guided tool use in Claude Code |
 | 🧩 **MCP compatibility**   | stdio for desktop clients, Streamable HTTP and legacy SSE for remote or service-style clients         |
 
-**132 typed tools** in total — browse the full catalog with parameters, defaults, and copy-paste example prompts in **[Available Tools](https://github.com/AliKarami/MikroMCP/wiki/Available-Tools)**.
+**133 typed tools** in total — browse the full catalog with parameters, defaults, and copy-paste example prompts in **[Available Tools](https://github.com/AliKarami/MikroMCP/wiki/Available-Tools)**.
 
 ---
 
@@ -140,7 +140,7 @@ AI assistants can use MikroMCP to:
 
 ### What is MikroMCP?
 
-MikroMCP is an open-source [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server that exposes MikroTik RouterOS as 132 typed, auditable tools — letting AI assistants inspect, diagnose, and safely operate routers in natural language instead of improvising CLI commands.
+MikroMCP is an open-source [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server that exposes MikroTik RouterOS as 133 typed, auditable tools — letting AI assistants inspect, diagnose, and safely operate routers in natural language instead of improvising CLI commands.
 
 ### MikroMCP vs RouterOS API
 
@@ -189,7 +189,7 @@ The README stays intentionally short. Everything below is documented in depth in
 | [Connecting to Claude Desktop](https://github.com/AliKarami/MikroMCP/wiki/Connecting-to-Claude-Desktop) | Register MikroMCP in Claude Desktop                      |
 | [Connecting to AI Assistants](https://github.com/AliKarami/MikroMCP/wiki/Connecting-to-AI-Assistants) | Claude Code, Cursor, Codex, HTTP/Docker/systemd            |
 | [Using the Skill](docs/wiki/Using-the-Skill.md)                                                        | Install the MikroMCP usage skill so your assistant drives the tools safely |
-| [Available Tools](https://github.com/AliKarami/MikroMCP/wiki/Available-Tools)                         | All 132 tools — parameters and example prompts             |
+| [Available Tools](https://github.com/AliKarami/MikroMCP/wiki/Available-Tools)                         | All 133 tools — parameters and example prompts             |
 | [Architecture](https://github.com/AliKarami/MikroMCP/wiki/Architecture)                               | System layers, request pipeline, auth model                |
 | [Error Handling](https://github.com/AliKarami/MikroMCP/wiki/Error-Handling)                           | Error categories, retry engine, circuit breaker            |
 | [Security](https://github.com/AliKarami/MikroMCP/wiki/Security)                                       | Threat model, hardening checklist, vulnerability reporting |

package/dist/main.js

@@ -398,6 +398,13 @@ function loggableParams(tool, params) {
     return { routerId: params.routerId, params: "<withheld: redaction failed>" };
   }
 }
+function isEffectiveDryRun(tool, params) {
+  try {
+    return tool.inputSchema.parse(params).dryRun === true;
+  } catch {
+    return params.dryRun === true;
+  }
+}
 function snapshotPathsFor(tool, params) {
   return typeof tool.snapshotPaths === "function" ? tool.snapshotPaths(params) : tool.snapshotPaths ?? [];
 }
@@ -2666,7 +2673,7 @@ var runCommandInputSchema = z10.object({
 var runCommandTool = {
   name: "run_command",
   title: "Run Command",
-  description: "Execute an arbitrary RouterOS console command via SSH. Guarded by an allow/deny policy (built-in deny list blocks destructive commands; tighten via cmdAllow in routers.yaml or MIKROMCP_CMD_ALLOW). Prefer dedicated tools (reboot, etc.) where available. Output capped at 4000 characters.",
+  description: "Execute an arbitrary RouterOS console command via SSH. Guarded by an allow/deny policy (built-in deny list blocks destructive commands; tighten via cmdAllow in routers.yaml or MIKROMCP_CMD_ALLOW). Prefer dedicated tools (reboot, etc.) where available. Output capped at 4000 characters. Journaled for audit like every write (see list_journal), but never snapshotted: arbitrary commands touch unknown config sections, so it cannot be rolled back via rollback_change \u2014 prefer a dedicated tool when one exists, and note the manual undo command in your own records.",
   inputSchema: runCommandInputSchema,
   annotations: {
     readOnlyHint: false,
@@ -2725,6 +2732,26 @@ var systemOpsTools = [
 
 // src/domain/tools/bridge-tools.ts
 import { z as z11 } from "zod";
+
+// src/domain/tools/interface-name.ts
+var NEW_INTERFACE_NAME_MAX = 64;
+var NEW_INTERFACE_NAME_PATTERN = /^[a-zA-Z0-9_.-]+$/;
+function assertNewInterfaceName(name, opts) {
+  const tooLong = name.length > NEW_INTERFACE_NAME_MAX;
+  if (!tooLong && NEW_INTERFACE_NAME_PATTERN.test(name)) return;
+  throw new MikroMCPError({
+    category: "VALIDATION" /* VALIDATION */,
+    code: opts.code,
+    message: tooLong ? `${opts.kind} name is ${name.length} chars; ${opts.action} allows at most ${NEW_INTERFACE_NAME_MAX}.` : `${opts.kind} name "${name}" uses characters ${opts.action} does not allow (permitted: letters, digits, dot, hyphen, underscore).`,
+    details: { name },
+    recoverability: {
+      retryable: false,
+      suggestedAction: `Use a name of letters, digits, dot, hyphen or underscore, at most ${NEW_INTERFACE_NAME_MAX} chars.`
+    }
+  });
+}
+
+// src/domain/tools/bridge-tools.ts
 var log9 = createLogger("bridge-tools");
 var listBridgesInputSchema = z11.object({
   routerId,
@@ -2865,7 +2892,9 @@ var listBridgePortsTool = {
 var manageBridgeInputSchema = z11.object({
   routerId,
   action: z11.enum(["create", "remove"]).describe("Action to perform"),
-  name: z11.string().regex(/^[a-zA-Z0-9_-]+$/).max(15).describe("Bridge interface name"),
+  name: z11.string().min(1).describe(
+    "Bridge interface name, taken verbatim for remove; create accepts letters, digits, dot, hyphen, underscore, up to 64 chars"
+  ),
   comment: z11.string().max(255).optional().describe("Optional comment"),
   disabled: z11.boolean().default(false).describe("Whether the bridge should be disabled"),
   dryRun
@@ -2893,6 +2922,11 @@ var manageBridgeTool = {
         filter: { name: parsed.name }
       });
       if (parsed.action === "create") {
+        assertNewInterfaceName(parsed.name, {
+          kind: "Bridge",
+          action: "create",
+          code: "BRIDGE_NAME_INVALID"
+        });
         if (existing.length > 0) {
           return {
             content: `Bridge "${parsed.name}" already exists. No changes made.`,
@@ -3270,6 +3304,7 @@ var wifiTools = [listWifiTool, listWifiClientsTool, manageWifiTool];
 
 // src/domain/tools/wireguard-tools.ts
 import { z as z13 } from "zod";
+import { isIP } from "net";
 var log11 = createLogger("wireguard-tools");
 var listWgInputSchema = z13.object({
   routerId,
@@ -3363,6 +3398,7 @@ var listPeersTool = {
             "interface",
             "public-key",
             "endpoint-address",
+            "endpoint-port",
             "allowed-address",
             "disabled"
           ])
@@ -3381,20 +3417,71 @@ var listPeersTool = {
     }
   }
 };
+function parsePeerEndpoint(endpoint) {
+  if (/\s/.test(endpoint) || endpoint.includes("%")) return void 0;
+  if (isIP(endpoint) === 6) return { "endpoint-address": endpoint };
+  const ipv6 = /^\[([^\]]+)\](?::(\d+))?$/.exec(endpoint);
+  const host = /^([^:]+)(?::(\d+))?$/.exec(endpoint);
+  const match = ipv6 ?? host;
+  if (!match) return void 0;
+  const [, address, port] = match;
+  if (ipv6) {
+    if (isIP(address) !== 6) return void 0;
+  } else if (isIP(address) !== 4) {
+    const hostname = address.endsWith(".") ? address.slice(0, -1) : address;
+    if (hostname.length > 253 || /^[\d.]+$/.test(hostname) || !hostname.split(".").every((label) => /^[a-z\d_](?:[a-z\d_-]{0,61}[a-z\d_])?$/i.test(label))) {
+      return void 0;
+    }
+  }
+  if (port !== void 0 && (Number(port) < 1 || Number(port) > 65535)) return void 0;
+  return {
+    "endpoint-address": address,
+    ...port === void 0 ? {} : { "endpoint-port": String(Number(port)) }
+  };
+}
+var peerEndpointSchema = z13.string().transform((endpoint, ctx) => {
+  const fields = parsePeerEndpoint(endpoint);
+  if (fields) return fields;
+  ctx.addIssue({
+    code: z13.ZodIssueCode.custom,
+    message: "Use IPv4:port, hostname:port or [IPv6]:port with port 1\u201365535, or an address without a port"
+  });
+  return z13.NEVER;
+});
+function canonicalPeerAddress(value) {
+  const address = String(value ?? "");
+  if (isIP(address) === 6) return new URL(`http://[${address}]/`).hostname;
+  return address.toLowerCase().replace(/\.$/, "");
+}
+function canonicalAllowedAddresses(value) {
+  const addresses = String(value ?? "").split(",").map((item) => {
+    const cidr2 = item.trim();
+    const [address, prefix] = cidr2.split("/");
+    const family = isIP(address);
+    if (!family || prefix !== void 0 && !/^\d+$/.test(prefix)) return cidr2;
+    const bits = family === 4 ? 32 : 128;
+    const length = Number(prefix ?? bits);
+    if (length > bits || cidr2.split("/").length > 2) return cidr2;
+    return `${canonicalPeerAddress(address)}/${length}`;
+  });
+  return [...new Set(addresses)].sort().join(",");
+}
 var managePeerInputSchema = z13.object({
   routerId,
   action: z13.enum(["add", "remove"]).describe("Action to perform"),
   interface: z13.string().describe("WireGuard interface name (e.g. wg0)"),
   publicKey: z13.string().min(1).describe("Peer public key in base64 format (44 characters)"),
   allowedAddress: z13.string().optional().describe("Allowed IP address/CIDR for this peer (e.g. 10.0.0.2/32)"),
-  endpoint: z13.string().optional().describe("Peer endpoint as IP:port (e.g. 1.2.3.4:51820)"),
+  endpoint: z13.string().optional().describe(
+    "Add only: IPv4:port, hostname:port or [IPv6]:port (port 1\u201365535); hostname labels may contain underscores. Address-only IPv4/hostname/IPv6 (bare or bracketed) leaves the RouterOS port default unchanged, which may not allow initiation. Ignored for remove; omit for a roaming peer."
+  ),
   comment: z13.string().max(255).optional().describe("Optional comment"),
   dryRun
 }).strict();
 var managePeerTool = {
   name: "manage_wireguard_peer",
   title: "Manage WireGuard Peer",
-  description: "Add or remove a WireGuard peer. Idempotent by public key: add returns already_exists if a peer with the same public key already exists on the interface.",
+  description: "Add or remove a WireGuard peer. Add returns already_exists when the public key and explicitly requested endpoint/allowed addresses match; different settings produce CONFLICT without changing the peer. Omitted settings are left unchanged.",
   inputSchema: managePeerInputSchema,
   annotations: {
     readOnlyHint: false,
@@ -3410,11 +3497,44 @@ var managePeerTool = {
       "Managing WireGuard peer"
     );
     try {
+      const endpointFields = parsed.action === "add" && parsed.endpoint !== void 0 ? peerEndpointSchema.parse(parsed.endpoint) : {};
       const existing = await context.routerClient.get("interface/wireguard/peers", {
         filter: { interface: parsed.interface, "public-key": parsed.publicKey }
       });
       if (parsed.action === "add") {
         if (existing.length > 0) {
+          const rec2 = existing[0];
+          const requestedFields = {
+            ...endpointFields,
+            ...parsed.allowedAddress === void 0 ? {} : { "allowed-address": parsed.allowedAddress }
+          };
+          const mismatched = Object.entries(requestedFields).filter(([property, desired]) => {
+            if (property === "endpoint-address") {
+              return canonicalPeerAddress(rec2[property]) !== canonicalPeerAddress(desired);
+            }
+            if (property === "allowed-address") {
+              return canonicalAllowedAddresses(rec2[property]) !== canonicalAllowedAddresses(desired);
+            }
+            return !sameValue(rec2[property], desired);
+          });
+          if (mismatched.length > 0) {
+            throw new MikroMCPError({
+              category: "CONFLICT" /* CONFLICT */,
+              code: "WIREGUARD_PEER_CONFLICT",
+              message: `WireGuard peer already exists on "${parsed.interface}" with different requested settings.`,
+              details: {
+                existing: Object.fromEntries(
+                  mismatched.map(([property]) => [property, rec2[property]])
+                ),
+                requested: Object.fromEntries(mismatched)
+              },
+              recoverability: {
+                retryable: false,
+                suggestedAction: "Inspect the peer with list_wireguard_peers, then remove it before adding different settings.",
+                alternativeTools: ["list_wireguard_peers", "manage_wireguard_peer"]
+              }
+            });
+          }
           return {
             content: `WireGuard peer with this public key already exists on "${parsed.interface}". No changes made.`,
             structuredContent: { action: "already_exists", peer: existing[0] }
@@ -3424,8 +3544,12 @@ var managePeerTool = {
           const diff = [
             { property: "interface", before: null, after: parsed.interface },
             { property: "public-key", before: null, after: parsed.publicKey },
-            ...parsed.allowedAddress ? [{ property: "allowed-address", before: null, after: parsed.allowedAddress }] : [],
-            ...parsed.endpoint ? [{ property: "endpoint-address", before: null, after: parsed.endpoint }] : []
+            ...parsed.allowedAddress !== void 0 ? [{ property: "allowed-address", before: null, after: parsed.allowedAddress }] : [],
+            ...Object.entries(endpointFields).map(([property, after]) => ({
+              property,
+              before: null,
+              after
+            }))
           ];
           return {
             content: `Dry run: Would add WireGuard peer on "${parsed.interface}".`,
@@ -3434,10 +3558,10 @@ var managePeerTool = {
         }
         const body = {
           interface: parsed.interface,
-          "public-key": parsed.publicKey
+          "public-key": parsed.publicKey,
+          ...endpointFields
         };
-        if (parsed.allowedAddress) body["allowed-address"] = parsed.allowedAddress;
-        if (parsed.endpoint) body["endpoint-address"] = parsed.endpoint;
+        if (parsed.allowedAddress !== void 0) body["allowed-address"] = parsed.allowedAddress;
         if (parsed.comment) body.comment = parsed.comment.replace(/[\x00-\x1f\x7f]/g, "");
         const created = await context.routerClient.create("interface/wireguard/peers", body);
         log11.info({ interface: parsed.interface, id: created[".id"] }, "WireGuard peer added");
@@ -8027,6 +8151,7 @@ function recordAttempt(args) {
     routerId: args.routerId,
     params: redactParams(args.params),
     snapshotIds: args.snapshotIds,
+    ...args.dryRun ? { dryRun: true } : {},
     phase: "attempt"
   });
   return id;
@@ -8921,6 +9046,47 @@ function unionVlanBlob(currentWire, targetWire) {
   return dumpBlob([...rows.entries()].sort((a, b) => a[0] - b[0]).map(([, row]) => row));
 }
 
+// src/middleware/authz.ts
+function matchesPattern(name, pattern) {
+  return globMatch(pattern, name);
+}
+function checkAuthz(identity, toolName, routerId2) {
+  if (identity.allowedRouters.length > 0 && !identity.allowedRouters.includes(routerId2)) {
+    throw new MikroMCPError({
+      category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
+      code: "ROUTER_NOT_ALLOWED",
+      message: `Identity "${identity.id}" is not allowed to access router "${routerId2}".`,
+      details: { identityId: identity.id, routerId: routerId2, allowedRouters: identity.allowedRouters },
+      recoverability: {
+        retryable: false,
+        suggestedAction: `Add "${routerId2}" to allowedRouters for identity "${identity.id}" in identities.yaml.`
+      }
+    });
+  }
+  checkToolAllowed(identity, toolName);
+}
+function checkToolAllowed(identity, toolName) {
+  if (identity.allowedToolPatterns.length > 0) {
+    const allowed = identity.allowedToolPatterns.some((p) => matchesPattern(toolName, p));
+    if (!allowed) {
+      throw new MikroMCPError({
+        category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
+        code: "TOOL_NOT_ALLOWED",
+        message: `Identity "${identity.id}" is not allowed to call tool "${toolName}".`,
+        details: {
+          identityId: identity.id,
+          toolName,
+          allowedToolPatterns: identity.allowedToolPatterns
+        },
+        recoverability: {
+          retryable: false,
+          suggestedAction: `Add a matching pattern to allowedToolPatterns for identity "${identity.id}" in identities.yaml.`
+        }
+      });
+    }
+  }
+}
+
 // src/domain/tools/change-management-tools.ts
 var log24 = createLogger("change-management");
 var stepSchema = z25.object({
@@ -8936,6 +9102,116 @@ var applyPlanInputSchema = z25.object({
   steps: z25.array(stepSchema).min(1).max(10).describe("Ordered list of write operations to apply in sequence"),
   confirmationToken: z25.string().optional()
 }).strict();
+function journalEntryWasDryRun(entry) {
+  const params = entry.params ?? {};
+  return entry.dryRun === true || params.dryRun === true;
+}
+var listJournalInputSchema = z25.object({
+  routerId: z25.string().optional().describe("Only entries for this router id"),
+  tool: z25.string().optional().describe("Only entries written by this tool"),
+  limit: z25.number().int().min(1).max(500).default(20).describe("Max entries to return")
+}).strict();
+var listJournalTool = {
+  name: "list_journal",
+  title: "List Write Journal",
+  description: "List recent entries from the server's write journal (write-journal.ndjson): every journaled write with its journalId, timestamp, tool, router, parameters (as redacted at write time), snapshot ids and outcome \u2014 newest first. Read-only. Use it to recover a lost journalId for rollback_change, or to audit what was written when. Only entries with rollbackable: true can be rolled back \u2014 dry runs and writes without snapshots (run_command, plan_changes) cannot.",
+  inputSchema: listJournalInputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  skipRouterContext: true,
+  async handler(params, context) {
+    const parsed = listJournalInputSchema.parse(params);
+    checkToolAllowed(context.identity, "list_journal");
+    const journalPath = context.appConfig.journalPath;
+    if (!journalPath) {
+      return {
+        content: "Write journal is disabled (no journal path configured on this server).",
+        structuredContent: { journalEnabled: false, entries: [], total: 0, returned: 0 }
+      };
+    }
+    let raw;
+    try {
+      raw = readFileSync2(journalPath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        raw = "";
+      } else {
+        throw new MikroMCPError({
+          category: "INTERNAL" /* INTERNAL */,
+          code: "JOURNAL_READ_FAILED",
+          message: `Could not read the write journal: ${err.message}`,
+          details: { journalPath },
+          recoverability: {
+            retryable: false,
+            suggestedAction: "Check the file's permissions under the MikroMCP data directory."
+          }
+        });
+      }
+    }
+    const outcomes = /* @__PURE__ */ new Map();
+    const attempts = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.phase === "attempt") attempts.push(entry);
+      else
+        outcomes.set(entry.id, {
+          phase: entry.phase,
+          outcome: entry.outcome,
+          durationMs: entry.durationMs
+        });
+    }
+    let entries = attempts.map((a) => {
+      const outcome = outcomes.get(a.id);
+      const snapshotIds = Array.isArray(a.snapshotIds) ? a.snapshotIds : [];
+      const dryRun2 = journalEntryWasDryRun(a);
+      return {
+        journalId: a.id,
+        ts: a.ts,
+        tool: a.tool,
+        routerId: a.routerId,
+        identityId: a.identityId,
+        role: a.role,
+        params: a.params ?? {},
+        snapshotIds,
+        dryRun: dryRun2,
+        rollbackable: !dryRun2 && snapshotIds.length > 0,
+        status: outcome ? outcome.phase : "unknown",
+        outcomeCode: outcome?.outcome,
+        durationMs: outcome?.durationMs
+      };
+    }).reverse();
+    if (parsed.routerId) entries = entries.filter((e) => e.routerId === parsed.routerId);
+    if (parsed.tool) entries = entries.filter((e) => e.tool === parsed.tool);
+    const scope = context.identity.allowedRouters;
+    if (scope.length > 0) entries = entries.filter((e) => scope.includes(e.routerId));
+    const total = entries.length;
+    const returned = entries.slice(0, parsed.limit);
+    const header = total === 0 ? "Write journal: no entries." : `Write journal: ${returned.length} of ${total}, newest first.`;
+    const lines = returned.map(
+      (e) => `  ${String(e.journalId)} ${String(e.tool)} ${String(e.routerId)} \u2192 ${e.status}${e.outcomeCode ? ` (${e.outcomeCode})` : ""}${e.dryRun ? " dry-run" : e.rollbackable ? "" : " not-rollbackable"} [${String(e.ts)}]`
+    );
+    return {
+      content: total === 0 ? header : [header, ...lines].join("\n"),
+      structuredContent: {
+        journalEnabled: true,
+        entries: returned,
+        total,
+        returned: returned.length,
+        note: "Pass the journalId of an entry with rollbackable: true to rollback_change to restore that write. Dry runs and entries without snapshots (e.g. run_command) cannot be rolled back."
+      }
+    };
+  }
+};
 var rollbackChangeInputSchema = z25.object({
   routerId,
   journalId: z25.string().describe("Journal entry ID from write-journal.ndjson to roll back"),
@@ -9156,7 +9432,8 @@ function createChangeManagementTools(baseTools2) {
           tool: step.tool,
           routerId: context.routerId,
           params: loggableParams(tool, stepParams),
-          snapshotIds
+          snapshotIds,
+          dryRun: isEffectiveDryRun(tool, stepParams)
         });
         const stepStartMs = Date.now();
         try {
@@ -9223,7 +9500,10 @@ function createChangeManagementTools(baseTools2) {
         }
       });
     }
-    return { snapshotIds: entry.snapshotIds ?? [] };
+    return {
+      snapshotIds: entry.snapshotIds ?? [],
+      dryRun: journalEntryWasDryRun(entry)
+    };
   }
   const rollbackChangeTool = {
     name: "rollback_change",
@@ -9242,7 +9522,16 @@ function createChangeManagementTools(baseTools2) {
       const journalPath = context.appConfig.journalPath;
       const snapshotDir = context.appConfig.snapshotDir;
       log24.info({ routerId: context.routerId, journalId: parsed.journalId }, "Rolling back change");
-      const { snapshotIds } = findJournalEntry(journalPath, parsed.journalId);
+      const { snapshotIds, dryRun: entryWasDryRun } = findJournalEntry(
+        journalPath,
+        parsed.journalId
+      );
+      if (entryWasDryRun) {
+        return {
+          content: `Journal entry "${parsed.journalId}" was a dry run \u2014 nothing was changed, so there is nothing to roll back.`,
+          structuredContent: { action: "dry_run_entry", journalId: parsed.journalId }
+        };
+      }
       if (snapshotIds.length === 0) {
         return {
           content: `Journal entry "${parsed.journalId}" has no associated snapshots \u2014 cannot rollback automatically.`,
@@ -9297,7 +9586,7 @@ ${warnings.map((w) => `  - ${w}`).join("\n")}` : "";
       };
     }
   };
-  return [planChangesTool, applyPlanTool, rollbackChangeTool];
+  return [planChangesTool, applyPlanTool, rollbackChangeTool, listJournalTool];
 }
 
 // src/domain/tools/ipsec-tools.ts
@@ -11770,8 +12059,8 @@ function sanitizeComment3(comment) {
 var manageVlanInputSchema = z35.object({
   routerId,
   action: z35.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
-  name: z35.string().regex(/^[a-zA-Z0-9_-]+$/).max(15).describe(
-    "VLAN interface name \u2014 idempotency key (alphanumeric, hyphens, underscores, max 15 chars)"
+  name: z35.string().min(1).describe(
+    "VLAN interface name \u2014 idempotency key, taken verbatim for remove/enable/disable; add accepts letters, digits, dot, hyphen, underscore, up to 64 chars"
   ),
   vlanId: z35.number().int().min(1).max(4094).optional().describe("VLAN ID (1-4094; required for add)"),
   parentInterface: z35.string().optional().describe("Parent interface name (e.g., ether1, bridge1; required for add)"),
@@ -11808,6 +12097,11 @@ var manageVlanTool = {
         (v) => sameValue(v.name, parsed.name)
       );
       if (parsed.action === "add") {
+        assertNewInterfaceName(parsed.name, {
+          kind: "VLAN",
+          action: "add",
+          code: "VLAN_NAME_INVALID"
+        });
         if (parsed.vlanId === void 0) {
           throw new MikroMCPError({
             category: "VALIDATION" /* VALIDATION */,
@@ -11952,9 +12246,12 @@ var vlanTools = [manageVlanTool];
 // src/domain/tools/dhcp-client-tools.ts
 import { z as z36 } from "zod";
 var log35 = createLogger("dhcp-client-tools");
+function findClient(clients, target, byNameToo = true) {
+  return clients.find((c) => sameValue(c.interface, target)) ?? (byNameToo ? clients.find((c) => sameValue(c.name, target)) : void 0);
+}
 var listDhcpClientsInputSchema = z36.object({
   routerId,
-  interface: z36.string().optional().describe("Filter by interface name (exact match)"),
+  interface: z36.string().optional().describe("Filter by interface or display name (exact match)"),
   status: z36.enum(["bound", "searching", "requesting", "init", "all"]).default("all").describe("Filter by DHCP client status"),
   limit,
   offset
@@ -11980,7 +12277,9 @@ var listDhcpClientsTool = {
       });
       let filtered = allClients;
       if (parsed.interface) {
-        filtered = filtered.filter((c) => c.interface === parsed.interface);
+        filtered = filtered.filter(
+          (c) => sameValue(c.interface, parsed.interface) || sameValue(c.name, parsed.interface)
+        );
       }
       if (parsed.status !== "all") {
         filtered = filtered.filter((c) => c.status === parsed.status);
@@ -11993,7 +12292,7 @@ var listDhcpClientsTool = {
           clients,
           total,
           parsed.offset,
-          (c) => compactFields(c, ["interface", "status", "address", "gateway", "disabled"])
+          (c) => compactFields(c, ["interface", "name", "status", "address", "gateway", "disabled"])
         ),
         structuredContent: {
           routerId: context.routerId,
@@ -12012,7 +12311,9 @@ var listDhcpClientsTool = {
 var manageDhcpClientInputSchema = z36.object({
   routerId,
   action: z36.enum(["add", "remove", "enable", "disable"]).describe("Action to perform"),
-  interface: z36.string().describe("Interface name \u2014 idempotency key (e.g. ether1, ether2)"),
+  interface: z36.string().describe(
+    "Interface name \u2014 idempotency key (e.g. ether1); for remove/enable/disable a client's display name also matches"
+  ),
   usePeerDns: z36.boolean().default(true).describe("Use DNS servers provided by DHCP server (add only)"),
   usePeerNtp: z36.boolean().default(false).describe("Use NTP servers provided by DHCP server (add only)"),
   addDefaultRoute: z36.boolean().default(true).describe("Add default route from DHCP (add only)"),
@@ -12042,8 +12343,10 @@ var manageDhcpClientTool = {
         limit: void 0,
         offset: void 0
       });
-      const existing = allClients.find(
-        (c) => c.interface === parsed.interface
+      const existing = findClient(
+        allClients,
+        parsed.interface,
+        parsed.action !== "add"
       );
       if (parsed.action === "add") {
         if (existing) {
@@ -12084,9 +12387,19 @@ var manageDhcpClientTool = {
       }
       if (parsed.action === "remove") {
         if (!existing) {
+          const candidates = allClients.map((c) => ({
+            interface: c.interface,
+            name: c.name,
+            status: c.status
+          }));
+          const names = candidates.map((c) => c.name ?? c.interface).slice(0, 5).join(", ");
           return {
-            content: `No DHCP client found on "${parsed.interface}". Nothing to remove.`,
-            structuredContent: { action: "not_found", interface: parsed.interface }
+            content: `No DHCP client found on "${parsed.interface}". Nothing to remove.` + (names ? ` Existing clients: ${names}.` : ""),
+            structuredContent: {
+              action: "not_found",
+              interface: parsed.interface,
+              clients: candidates
+            }
           };
         }
         if (parsed.dryRun) {
@@ -12094,7 +12407,7 @@ var manageDhcpClientTool = {
             content: `Dry run: Would remove DHCP client on "${parsed.interface}".`,
             structuredContent: {
               action: "dry_run",
-              diff: [{ property: "interface", before: parsed.interface, after: null }]
+              diff: [{ property: "interface", before: existing.interface, after: null }]
             }
           };
         }
@@ -12236,7 +12549,7 @@ var manageIpServiceInputSchema = z37.object({
 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.",
+  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. MikroMCP reaches RouterOS through the REST API on www-ssl (or www for plaintext): disabling the service its connection uses cuts MikroMCP off from the router, including any later call to re-enable it.",
   inputSchema: manageIpServiceInputSchema,
   annotations: {
     readOnlyHint: false,
@@ -16389,44 +16702,6 @@ var swosMaintenanceTools = [
 // src/domain/tools/fleet-tools.ts
 import { z as z50 } from "zod";
 
-// src/middleware/authz.ts
-function matchesPattern(name, pattern) {
-  return globMatch(pattern, name);
-}
-function checkAuthz(identity, toolName, routerId2) {
-  if (identity.allowedRouters.length > 0 && !identity.allowedRouters.includes(routerId2)) {
-    throw new MikroMCPError({
-      category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
-      code: "ROUTER_NOT_ALLOWED",
-      message: `Identity "${identity.id}" is not allowed to access router "${routerId2}".`,
-      details: { identityId: identity.id, routerId: routerId2, allowedRouters: identity.allowedRouters },
-      recoverability: {
-        retryable: false,
-        suggestedAction: `Add "${routerId2}" to allowedRouters for identity "${identity.id}" in identities.yaml.`
-      }
-    });
-  }
-  if (identity.allowedToolPatterns.length > 0) {
-    const allowed = identity.allowedToolPatterns.some((p) => matchesPattern(toolName, p));
-    if (!allowed) {
-      throw new MikroMCPError({
-        category: "PERMISSION_DENIED" /* PERMISSION_DENIED */,
-        code: "TOOL_NOT_ALLOWED",
-        message: `Identity "${identity.id}" is not allowed to call tool "${toolName}".`,
-        details: {
-          identityId: identity.id,
-          toolName,
-          allowedToolPatterns: identity.allowedToolPatterns
-        },
-        recoverability: {
-          retryable: false,
-          suggestedAction: `Add a matching pattern to allowedToolPatterns for identity "${identity.id}" in identities.yaml.`
-        }
-      });
-    }
-  }
-}
-
 // src/config/secrets.ts
 function getCredentials(router) {
   const { source, envPrefix, vaultPath } = router.credentials;
@@ -17320,6 +17595,7 @@ async function executeToolCall(tool, args, deps) {
         }
       }
       toolContext.snapshots = snapshots;
+      const dryRun2 = !tool.annotations.readOnlyHint && isEffectiveDryRun(tool, handlerArgs);
       if (!tool.annotations.readOnlyHint && config.journalPath) {
         const { confirmationToken: _token, ...journalArgs } = loggedArgs;
         journalId = recordAttempt({
@@ -17329,7 +17605,8 @@ async function executeToolCall(tool, args, deps) {
           tool: tool.name,
           routerId: routerId2,
           params: journalArgs,
-          snapshotIds
+          snapshotIds,
+          dryRun: dryRun2
         });
       }
       const runHandler = () => tool.handler(handlerArgs, toolContext);
@@ -17343,6 +17620,11 @@ async function executeToolCall(tool, args, deps) {
           phase: "success",
           durationMs: Date.now() - startMs
         });
+        if (!dryRun2 && snapshotIds.length > 0) {
+          result.structuredContent = { ...result.structuredContent, journalId };
+          result.content += `
+Journal ID: ${journalId} (pass to rollback_change to undo).`;
+        }
       }
       if (shouldAudit) {
         auditLog(
@@ -17520,7 +17802,7 @@ var listRoutersInputSchema = z50.object({
 var listRoutersTool = {
   name: "list_routers",
   title: "List Routers",
-  description: "List the routers configured in the registry (routers.yaml): id, host, port, TLS status, tags, ROS version, and which is the default. Read-only reflection of local config \u2014 no RouterOS API call, no credentials in the response. Use it to discover valid routerId values and tags for targeting other tools (including bulk_read and bulk_execute).",
+  description: "List the routers configured in the registry (routers.yaml): id, host, port, TLS status, tags, ROS version, and which is the default. Read-only reflection of local config \u2014 no RouterOS API call, no credentials in the response. rosVersion is what routers.yaml states and may lag a router upgrade \u2014 ask get_system_status for the live version. Use it to discover valid routerId values and tags for targeting other tools (including bulk_read and bulk_execute).",
   inputSchema: listRoutersInputSchema,
   annotations: {
     readOnlyHint: true,
@@ -17563,9 +17845,17 @@ var listRoutersTool = {
         "isDefault"
       ])}`
     );
+    const hasRouterOS = rows.some((r) => r.deviceType === "routeros");
     return {
       content: total === 0 ? header : [header, ...lines].join("\n"),
-      structuredContent: { routers: rows, total, returned: total }
+      structuredContent: {
+        routers: rows,
+        total,
+        returned: total,
+        ...hasRouterOS ? {
+          note: "rosVersion comes from routers.yaml and may be stale; use get_system_status for the live version."
+        } : {}
+      }
     };
   }
 };
@@ -17724,7 +18014,8 @@ async function fanOut(req) {
           tool: input2.toolName,
           routerId: router.id,
           params: loggedParams,
-          snapshotIds
+          snapshotIds,
+          dryRun: isEffectiveDryRun(targetTool, toolParams)
         });
       }
       const cb = getOrCreateBreaker(context.circuitBreakers, router.id, context.appConfig);
@@ -18308,7 +18599,7 @@ var ConnectionPool = class {
 };
 
 // src/version.ts
-var VERSION2 = "1.14.0";
+var VERSION2 = "1.15.0";
 
 // src/mcp/server.ts
 var SERVER_INSTRUCTIONS = [
@@ -18786,7 +19077,7 @@ import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
 import { homedir as homedir2 } from "os";
 import * as net from "net";
 import chalk from "chalk";
-var localVersion = "1.14.0";
+var localVersion = "1.15.0";
 var results = [];
 function ok(msg) {
   console.log(chalk.green("\u2705 ") + msg);
@@ -19602,7 +19893,7 @@ async function runInit() {
 }
 
 // src/cli/index.ts
-var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.14.0");
+var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.15.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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikromcp",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "mcpName": "io.github.AliKarami/mikromcp",
   "description": "Production-grade MCP server for MikroTik RouterOS routers and SwOS switches",
   "type": "module",