mikromcp 1.6.0 → 1.7.0

package/dist/main.js

@@ -450,9 +450,21 @@ function paginate(items, offset2, limit2) {
     hasMore: offset2 + limit2 < total
   };
 }
-function listSummary(label, routerId2, shown, total, offset2) {
-  const range = total === 0 ? "none" : `${offset2 + 1}-${offset2 + shown} of ${total}`;
-  return `${label} on ${routerId2}: ${range}. Full records in structuredContent.`;
+function compactFields(record, fields) {
+  const parts = [];
+  for (const field of fields) {
+    const value = record[field];
+    if (value === void 0 || value === null || value === "") continue;
+    const str = String(value);
+    parts.push(str.includes(" ") ? `${field}="${str}"` : `${field}=${str}`);
+  }
+  return parts.join(" ");
+}
+function listContent(label, routerId2, page, total, offset2, renderItem) {
+  const range = total === 0 ? "none" : `${offset2 + 1}-${offset2 + page.length} of ${total}`;
+  const header = `${label} on ${routerId2}: ${range}.`;
+  if (page.length === 0) return header;
+  return [header, ...page.map((item) => `  ${renderItem(item)}`)].join("\n");
 }
 
 // src/domain/tools/interface-tools.ts
@@ -536,7 +548,14 @@ var listInterfacesTool = {
         return enriched;
       });
       return {
-        content: listSummary("Interfaces", context.routerId, results2.length, total, parsed.offset),
+        content: listContent(
+          "Interfaces",
+          context.routerId,
+          results2,
+          total,
+          parsed.offset,
+          (i) => compactFields(i, ["name", "type", "running", "disabled", "mtu", "comment"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           interfaces: results2,
@@ -875,7 +894,14 @@ var listDhcpLeasesTool = {
       }
       const { items: paginated, total, hasMore } = paginate(leases, parsed.offset, parsed.limit);
       return {
-        content: listSummary("DHCP leases", context.routerId, paginated.length, total, parsed.offset),
+        content: listContent(
+          "DHCP leases",
+          context.routerId,
+          paginated,
+          total,
+          parsed.offset,
+          (l) => compactFields(l, ["address", "mac-address", "host-name", "server", "status"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           leases: paginated,
@@ -1044,7 +1070,14 @@ var listRoutesTool = {
       }
       const { items: paginated, total, hasMore } = paginate(routes, parsed.offset, parsed.limit);
       return {
-        content: listSummary("Routes", context.routerId, paginated.length, total, parsed.offset),
+        content: listContent(
+          "Routes",
+          context.routerId,
+          paginated,
+          total,
+          parsed.offset,
+          (r) => compactFields(r, ["dst-address", "gateway", "distance", "routing-table", "active", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           routes: paginated,
@@ -1301,12 +1334,24 @@ var listFirewallRulesTool = {
       }
       const { items: paginated, total, hasMore } = paginate(rules, parsed.offset, parsed.limit);
       return {
-        content: listSummary(
+        content: listContent(
           `Firewall ${parsed.table} rules`,
           context.routerId,
-          paginated.length,
+          paginated,
           total,
-          parsed.offset
+          parsed.offset,
+          (r) => compactFields(r, [
+            "chain",
+            "action",
+            "protocol",
+            "src-address",
+            "dst-address",
+            "dst-port",
+            "in-interface",
+            "out-interface",
+            "disabled",
+            "comment"
+          ])
         ),
         structuredContent: {
           routerId: context.routerId,
@@ -1751,9 +1796,36 @@ var getLogInputSchema = z9.object({
     'Filter entries whose topics field contains any of these strings (e.g. ["firewall", "dhcp"])'
   ),
   prefix: z9.string().optional().describe("Substring to match against the log message"),
-  sinceMinutes: z9.number().int().min(1).max(1440).optional().describe("Only return entries from the last N minutes (1\u20131440)")
+  sinceMinutes: z9.number().int().min(1).max(1440).optional().describe(
+    "Only return entries from the last N minutes (1\u20131440), measured against the router's clock"
+  )
 }).strict();
+var MONTHS = {
+  jan: 0,
+  feb: 1,
+  mar: 2,
+  apr: 3,
+  may: 4,
+  jun: 5,
+  jul: 6,
+  aug: 7,
+  sep: 8,
+  oct: 9,
+  nov: 10,
+  dec: 11
+};
 function parseRouterOsTimestamp(ts, now) {
+  const isoDateTime = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/.exec(ts);
+  if (isoDateTime) {
+    return new Date(
+      parseInt(isoDateTime[1], 10),
+      parseInt(isoDateTime[2], 10) - 1,
+      parseInt(isoDateTime[3], 10),
+      parseInt(isoDateTime[4], 10),
+      parseInt(isoDateTime[5], 10),
+      parseInt(isoDateTime[6], 10)
+    );
+  }
   const timeOnly = /^(\d{2}):(\d{2}):(\d{2})$/.exec(ts);
   if (timeOnly) {
     const d = new Date(now);
@@ -1761,20 +1833,6 @@ function parseRouterOsTimestamp(ts, now) {
     if (d > now) d.setDate(d.getDate() - 1);
     return d;
   }
-  const MONTHS = {
-    jan: 0,
-    feb: 1,
-    mar: 2,
-    apr: 3,
-    may: 4,
-    jun: 5,
-    jul: 6,
-    aug: 7,
-    sep: 8,
-    oct: 9,
-    nov: 10,
-    dec: 11
-  };
   const monthDay = /^([a-z]{3})\/(\d{2}) (\d{2}):(\d{2}):(\d{2})$/i.exec(ts);
   if (monthDay) {
     const month = MONTHS[monthDay[1].toLowerCase()];
@@ -1792,10 +1850,29 @@ function parseRouterOsTimestamp(ts, now) {
   }
   return null;
 }
+function parseRouterClock(dateStr, timeStr) {
+  if (!dateStr || !timeStr) return null;
+  const time = /^(\d{2}):(\d{2}):(\d{2})$/.exec(timeStr);
+  if (!time) return null;
+  const hh = parseInt(time[1], 10);
+  const mm = parseInt(time[2], 10);
+  const ss = parseInt(time[3], 10);
+  const iso = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateStr);
+  if (iso) {
+    return new Date(parseInt(iso[1], 10), parseInt(iso[2], 10) - 1, parseInt(iso[3], 10), hh, mm, ss);
+  }
+  const named = /^([a-z]{3})\/(\d{2})\/(\d{4})$/i.exec(dateStr);
+  if (named) {
+    const month = MONTHS[named[1].toLowerCase()];
+    if (month === void 0) return null;
+    return new Date(parseInt(named[3], 10), month, parseInt(named[2], 10), hh, mm, ss);
+  }
+  return null;
+}
 var getLogTool = {
   name: "get_log",
   title: "Get Log",
-  description: "Read and filter the system log from a MikroTik router. Supports filtering by topic, message prefix, and a time window (last N minutes). Entries with unparseable timestamps are included conservatively.",
+  description: "Read and filter the system log from a MikroTik router. Supports filtering by topic, message prefix, and a time window (last N minutes) measured against the router's own clock. Entries with unparseable timestamps are included conservatively.",
   inputSchema: getLogInputSchema,
   annotations: {
     readOnlyHint: true,
@@ -1811,7 +1888,18 @@ var getLogTool = {
     );
     try {
       const allEntries = await context.routerClient.get("log");
-      const now = /* @__PURE__ */ new Date();
+      let now = /* @__PURE__ */ new Date();
+      if (parsed.sinceMinutes !== void 0) {
+        try {
+          const clockResult = await context.routerClient.get("system/clock");
+          const clock = Array.isArray(clockResult) ? clockResult[0] : clockResult;
+          const routerNow = parseRouterClock(clock?.date, clock?.time);
+          if (routerNow !== null) now = routerNow;
+          else log7.warn({ routerId: context.routerId }, "Unparseable router clock; using host clock");
+        } catch {
+          log7.warn({ routerId: context.routerId }, "Router clock unavailable; using host clock");
+        }
+      }
       const cutoff = parsed.sinceMinutes !== void 0 ? new Date(now.getTime() - parsed.sinceMinutes * 6e4) : null;
       let filtered = allEntries.map((e) => e);
       if (parsed.topics && parsed.topics.length > 0) {
@@ -2168,7 +2256,14 @@ var listBridgesTool = {
       });
       const { items: paginated, total, hasMore } = paginate(enriched, parsed.offset, parsed.limit);
       return {
-        content: listSummary("Bridges", context.routerId, paginated.length, total, parsed.offset),
+        content: listContent(
+          "Bridges",
+          context.routerId,
+          paginated,
+          total,
+          parsed.offset,
+          (b) => compactFields(b, ["name", "protocol-mode", "vlan-filtering", "mtu", "disabled", "comment"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           bridges: paginated,
@@ -2420,7 +2515,14 @@ var listWifiTool = {
       });
       const { items: paginated, total, hasMore } = paginate(interfaces, parsed.offset, parsed.limit);
       return {
-        content: listSummary("WiFi interfaces", context.routerId, paginated.length, total, parsed.offset),
+        content: listContent(
+          "WiFi interfaces",
+          context.routerId,
+          paginated,
+          total,
+          parsed.offset,
+          (i) => compactFields(i, ["name", "master-interface", "mac-address", "disabled", "comment"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           interfaces: paginated,
@@ -2461,7 +2563,14 @@ var listWifiClientsTool = {
       const allClients = await context.routerClient.get(path, { filter });
       const { items: clients, total, hasMore } = paginate(allClients, parsed.offset, parsed.limit);
       return {
-        content: listSummary("WiFi clients", context.routerId, clients.length, total, parsed.offset),
+        content: listContent(
+          "WiFi clients",
+          context.routerId,
+          clients,
+          total,
+          parsed.offset,
+          (c) => compactFields(c, ["interface", "mac-address", "signal", "tx-rate", "rx-rate", "uptime"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           clients,
@@ -2593,12 +2702,13 @@ var listWgTool = {
       });
       const { items: paginated, total, hasMore } = paginate(interfaces, parsed.offset, parsed.limit);
       return {
-        content: listSummary(
+        content: listContent(
           "WireGuard interfaces",
           context.routerId,
-          paginated.length,
+          paginated,
           total,
-          parsed.offset
+          parsed.offset,
+          (i) => compactFields(i, ["name", "listen-port", "mtu", "running", "disabled", "comment"])
         ),
         structuredContent: {
           routerId: context.routerId,
@@ -2644,7 +2754,14 @@ var listPeersTool = {
       });
       const { items: peers, total, hasMore } = paginate(allPeers, parsed.offset, parsed.limit);
       return {
-        content: listSummary("WireGuard peers", context.routerId, peers.length, total, parsed.offset),
+        content: listContent(
+          "WireGuard peers",
+          context.routerId,
+          peers,
+          total,
+          parsed.offset,
+          (p) => compactFields(p, ["interface", "public-key", "endpoint-address", "allowed-address", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           peers,
@@ -2939,7 +3056,14 @@ var listDnsTool = {
       }
       const { items: paginated, total, hasMore } = paginate(entries, parsed.offset, parsed.limit);
       return {
-        content: listSummary("DNS entries", context.routerId, paginated.length, total, parsed.offset),
+        content: listContent(
+          "DNS entries",
+          context.routerId,
+          paginated,
+          total,
+          parsed.offset,
+          (e) => compactFields(e, ["name", "type", "address", "cname", "ttl", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           entries: paginated,
@@ -3260,7 +3384,23 @@ var listMangleRulesTool = {
         });
       }
       return {
-        content: `Mangle rules on ${context.routerId}: ${rules.length} rule(s).`,
+        content: listContent(
+          "Mangle rules",
+          context.routerId,
+          rules,
+          rules.length,
+          0,
+          (r) => compactFields(r, [
+            "chain",
+            "action",
+            "new-packet-mark",
+            "new-connection-mark",
+            "new-routing-mark",
+            "passthrough",
+            "disabled",
+            "comment"
+          ])
+        ),
         structuredContent: { routerId: context.routerId, rules, total: rules.length }
       };
     } catch (err) {
@@ -3510,7 +3650,14 @@ var listAddressListTool = {
         offset: void 0
       });
       return {
-        content: `Address list entries on ${context.routerId}: ${entries.length} entry(ies).`,
+        content: listContent(
+          "Address list entries",
+          context.routerId,
+          entries,
+          entries.length,
+          0,
+          (e) => compactFields(e, ["list", "address", "timeout", "dynamic", "disabled", "comment"])
+        ),
         structuredContent: { routerId: context.routerId, entries, total: entries.length }
       };
     } catch (err) {
@@ -3664,7 +3811,14 @@ var listRoutingRulesTool = {
         });
       }
       return {
-        content: `Routing rules on ${context.routerId}: ${rules.length} rule(s).`,
+        content: listContent(
+          "Routing rules",
+          context.routerId,
+          rules,
+          rules.length,
+          0,
+          (r) => compactFields(r, ["src-address", "dst-address", "action", "table", "interface", "disabled"])
+        ),
         structuredContent: { routerId: context.routerId, rules, total: rules.length }
       };
     } catch (err) {
@@ -3865,7 +4019,14 @@ var listRoutingTablesTool = {
         offset: void 0
       });
       return {
-        content: `Routing tables on ${context.routerId}: ${tables.length} table(s).`,
+        content: listContent(
+          "Routing tables",
+          context.routerId,
+          tables,
+          tables.length,
+          0,
+          (t) => compactFields(t, ["name", "fib", "disabled"])
+        ),
         structuredContent: { routerId: context.routerId, tables, total: tables.length }
       };
     } catch (err) {
@@ -4001,7 +4162,14 @@ var listBgpPeersTool = {
         sessions = sessions.filter((s) => s.state === parsed.state);
       }
       return {
-        content: `BGP sessions on ${context.routerId}: ${sessions.length} session(s).`,
+        content: listContent(
+          "BGP sessions",
+          context.routerId,
+          sessions,
+          sessions.length,
+          0,
+          (s) => compactFields(s, ["name", "remote.address", "remote.as", "established", "uptime"])
+        ),
         structuredContent: { routerId: context.routerId, sessions, total: sessions.length }
       };
     } catch (err) {
@@ -4036,7 +4204,14 @@ var listOspfNeighborsTool = {
         neighbors = neighbors.filter((n) => n.state === parsed.state);
       }
       return {
-        content: `OSPF neighbors on ${context.routerId}: ${neighbors.length} neighbor(s).`,
+        content: listContent(
+          "OSPF neighbors",
+          context.routerId,
+          neighbors,
+          neighbors.length,
+          0,
+          (n) => compactFields(n, ["instance", "router-id", "address", "state", "state-changes"])
+        ),
         structuredContent: { routerId: context.routerId, neighbors, total: neighbors.length }
       };
     } catch (err) {
@@ -4080,7 +4255,14 @@ var listScriptsTool = {
         );
       }
       return {
-        content: `Scripts on ${context.routerId}: ${scripts.length} script(s).`,
+        content: listContent(
+          "Scripts",
+          context.routerId,
+          scripts,
+          scripts.length,
+          0,
+          (s) => compactFields(s, ["name", "owner", "policy", "run-count", "last-started"])
+        ),
         structuredContent: { routerId: context.routerId, scripts, total: scripts.length }
       };
     } catch (err) {
@@ -4319,7 +4501,14 @@ var listScheduledJobsTool = {
         jobs = jobs.filter((j) => j.name === parsed.name);
       }
       return {
-        content: `Scheduled jobs on ${context.routerId}: ${jobs.length} job(s).`,
+        content: listContent(
+          "Scheduled jobs",
+          context.routerId,
+          jobs,
+          jobs.length,
+          0,
+          (j) => compactFields(j, ["name", "start-time", "interval", "on-event", "disabled"])
+        ),
         structuredContent: { routerId: context.routerId, jobs, total: jobs.length }
       };
     } catch (err) {
@@ -4565,7 +4754,14 @@ var listPackagesTool = {
         packages = packages.filter((p) => p.name === parsed.name);
       }
       return {
-        content: `Packages on ${context.routerId}: ${packages.length} package(s).`,
+        content: listContent(
+          "Packages",
+          context.routerId,
+          packages,
+          packages.length,
+          0,
+          (p) => compactFields(p, ["name", "version", "disabled", "scheduled"])
+        ),
         structuredContent: { routerId: context.routerId, packages, total: packages.length }
       };
     } catch (err) {
@@ -4687,7 +4883,14 @@ var listFilesTool = {
         files = files.filter((f) => f.type === parsed.type);
       }
       return {
-        content: `Files on ${context.routerId}: ${files.length} file(s).`,
+        content: listContent(
+          "Files",
+          context.routerId,
+          files,
+          files.length,
+          0,
+          (f) => compactFields(f, ["name", "type", "size", "creation-time"])
+        ),
         structuredContent: { routerId: context.routerId, files, total: files.length }
       };
     } catch (err) {
@@ -4889,7 +5092,14 @@ var listContainersTool = {
         offset: void 0
       });
       return {
-        content: `Containers on ${context.routerId}: ${containers.length} container(s).`,
+        content: listContent(
+          "Containers",
+          context.routerId,
+          containers,
+          containers.length,
+          0,
+          (c) => compactFields(c, ["name", "tag", "status", "interface", "root-dir"])
+        ),
         structuredContent: { routerId: context.routerId, containers, total: containers.length }
       };
     } catch (err) {
@@ -5555,7 +5765,14 @@ var listIpsecPeersTool = {
       ) : allPeers;
       const peers = filtered.slice(0, parsed.limit);
       return {
-        content: `IPSec peers on ${context.routerId}: ${peers.length} returned (${allPeers.length} total)`,
+        content: listContent(
+          "IPSec peers",
+          context.routerId,
+          peers,
+          allPeers.length,
+          0,
+          (p) => compactFields(p, ["name", "address", "profile", "exchange-mode", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           peers,
@@ -5600,7 +5817,14 @@ var listIpsecPoliciesTool = {
       );
       const policies = filtered.slice(0, parsed.limit);
       return {
-        content: `IPSec policies on ${context.routerId}: ${policies.length} returned (${allPolicies.length} total)`,
+        content: listContent(
+          "IPSec policies",
+          context.routerId,
+          policies,
+          allPolicies.length,
+          0,
+          (p) => compactFields(p, ["src-address", "dst-address", "protocol", "action", "level", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           policies,
@@ -5974,7 +6198,14 @@ var listCertificatesTool = {
       });
       const certs = filtered.slice(0, parsed.limit);
       return {
-        content: `Certificates on ${context.routerId}: ${certs.length} returned (${allCerts.length} total)`,
+        content: listContent(
+          "Certificates",
+          context.routerId,
+          certs,
+          allCerts.length,
+          0,
+          (c) => compactFields(c, ["name", "common-name", "invalid-after", "expired", "revoked"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           certificates: certs,
@@ -6133,7 +6364,14 @@ var listUsersTool = {
       const filtered = parsed.group ? safeUsers.filter((u) => u.group === parsed.group) : safeUsers;
       const users = filtered.slice(0, parsed.limit);
       return {
-        content: `Users on ${context.routerId}: ${users.length} returned (${allUsers.length} total)`,
+        content: listContent(
+          "Users",
+          context.routerId,
+          users,
+          allUsers.length,
+          0,
+          (u) => compactFields(u, ["name", "group", "address", "disabled", "comment"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           users,
@@ -6408,7 +6646,14 @@ var listUserGroupsTool = {
       });
       const groups = all.slice(0, parsed.limit);
       return {
-        content: `User groups on ${context.routerId}: ${groups.length} returned (${all.length} total)`,
+        content: listContent(
+          "User groups",
+          context.routerId,
+          groups,
+          all.length,
+          0,
+          (g) => compactFields(g, ["name", "policy", "comment"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           groups,
@@ -6620,7 +6865,14 @@ var listDhcpServersTool = {
       let filtered = parsed.interface ? allServers.filter((s) => s.interface === parsed.interface) : allServers;
       const { items: servers, total, hasMore } = paginate(filtered, parsed.offset, parsed.limit);
       return {
-        content: `DHCP servers on ${context.routerId}: ${total} total, showing ${servers.length} (offset ${parsed.offset})`,
+        content: listContent(
+          "DHCP servers",
+          context.routerId,
+          servers,
+          total,
+          parsed.offset,
+          (s) => compactFields(s, ["name", "interface", "address-pool", "lease-time", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           servers,
@@ -6853,7 +7105,14 @@ var listIpPoolsTool = {
       }
       const { items: pools, total, hasMore } = paginate(filtered, parsed.offset, parsed.limit);
       return {
-        content: `IP pools on ${context.routerId}: ${total} total, showing ${pools.length} (offset ${parsed.offset})`,
+        content: listContent(
+          "IP pools",
+          context.routerId,
+          pools,
+          total,
+          parsed.offset,
+          (p) => compactFields(p, ["name", "ranges", "next-pool"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           pools,
@@ -7006,7 +7265,14 @@ var listQueuesTool = {
       ) : allQueues;
       const queues = filtered.slice(0, parsed.limit);
       return {
-        content: `Queues on ${context.routerId}: ${queues.length} returned (${allQueues.length} total)`,
+        content: listContent(
+          "Queues",
+          context.routerId,
+          queues,
+          allQueues.length,
+          0,
+          (q) => compactFields(q, ["name", "target", "max-limit", "limit-at", "disabled", "comment"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           queues,
@@ -7211,7 +7477,14 @@ var listVrrpInstancesTool = {
       ) : allInstances;
       const instances = filtered.slice(0, parsed.limit);
       return {
-        content: `VRRP instances on ${context.routerId}: ${instances.length} returned (${allInstances.length} total)`,
+        content: listContent(
+          "VRRP instances",
+          context.routerId,
+          instances,
+          allInstances.length,
+          0,
+          (i) => compactFields(i, ["name", "interface", "vrid", "priority", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           instances,
@@ -7527,7 +7800,14 @@ var listNetwatchEntriesTool = {
       const filtered = allEntries.filter((e) => parsed.host ? (e.host ?? "").includes(parsed.host) : true).filter((e) => parsed.status ? e.status === parsed.status : true);
       const entries = filtered.slice(0, parsed.limit);
       return {
-        content: `Netwatch entries on ${context.routerId}: ${entries.length} returned (${allEntries.length} total)`,
+        content: listContent(
+          "Netwatch entries",
+          context.routerId,
+          entries,
+          allEntries.length,
+          0,
+          (e) => compactFields(e, ["host", "type", "status", "interval", "disabled", "comment"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           entries,
@@ -7724,7 +8004,14 @@ var listNeighborsTool = {
       ) : allNeighbors;
       const neighbors = filtered.slice(0, parsed.limit);
       return {
-        content: `Neighbors on ${context.routerId}: ${neighbors.length} returned (${allNeighbors.length} total)`,
+        content: listContent(
+          "Neighbors",
+          context.routerId,
+          neighbors,
+          allNeighbors.length,
+          0,
+          (n) => compactFields(n, ["interface", "address", "mac-address", "identity", "platform", "board"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           neighbors,
@@ -7768,7 +8055,14 @@ var listArpEntriesTool = {
       );
       const entries = filtered.slice(0, parsed.limit);
       return {
-        content: `ARP entries on ${context.routerId}: ${entries.length} returned (${allEntries.length} total)`,
+        content: listContent(
+          "ARP entries",
+          context.routerId,
+          entries,
+          allEntries.length,
+          0,
+          (e) => compactFields(e, ["address", "mac-address", "interface", "status", "complete", "dynamic"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           entries,
@@ -8069,7 +8363,14 @@ var listDhcpClientsTool = {
       }
       const { items: clients, total, hasMore } = paginate(filtered, parsed.offset, parsed.limit);
       return {
-        content: listSummary("DHCP clients", context.routerId, clients.length, total, parsed.offset),
+        content: listContent(
+          "DHCP clients",
+          context.routerId,
+          clients,
+          total,
+          parsed.offset,
+          (c) => compactFields(c, ["interface", "status", "address", "gateway", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           clients,
@@ -8255,7 +8556,14 @@ var listIpServicesTool = {
         });
       }
       return {
-        content: `IP services on ${context.routerId}: ${filtered.length} returned. Full records in structuredContent.`,
+        content: listContent(
+          "IP services",
+          context.routerId,
+          filtered,
+          filtered.length,
+          0,
+          (s) => compactFields(s, ["name", "port", "address", "certificate", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           services: filtered,
@@ -8391,7 +8699,14 @@ var listPppoeClientsTool = {
       }
       const { items: clients, total, hasMore } = paginate(filtered, parsed.offset, parsed.limit);
       return {
-        content: listSummary("PPPoE clients", context.routerId, clients.length, total, parsed.offset),
+        content: listContent(
+          "PPPoE clients",
+          context.routerId,
+          clients,
+          total,
+          parsed.offset,
+          (c) => compactFields(c, ["name", "interface", "status", "user", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           clients,
@@ -8649,7 +8964,14 @@ var listOvpnClientsTool = {
       });
       const { items: clients, total, hasMore } = paginate(allClients, parsed.offset, parsed.limit);
       return {
-        content: `OpenVPN clients on ${context.routerId}: ${total} total, showing ${clients.length} (offset ${parsed.offset})`,
+        content: listContent(
+          "OpenVPN clients",
+          context.routerId,
+          clients,
+          total,
+          parsed.offset,
+          (c) => compactFields(c, ["name", "connect-to", "user", "profile", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           clients,
@@ -9051,7 +9373,14 @@ var listPppProfilesTool = {
       const filtered = parsed.name ? all.filter((p) => p.name === parsed.name) : all;
       const profiles = filtered.slice(0, parsed.limit);
       return {
-        content: `PPP profiles on ${context.routerId}: ${profiles.length} returned`,
+        content: listContent(
+          "PPP profiles",
+          context.routerId,
+          profiles,
+          all.length,
+          0,
+          (p) => compactFields(p, ["name", "local-address", "remote-address", "dns-server", "rate-limit"])
+        ),
         structuredContent: { routerId: context.routerId, profiles, total: all.length, returned: profiles.length }
       };
     } catch (err) {
@@ -9440,7 +9769,14 @@ var listLogRulesTool = {
       }
       const returned = rules.slice(0, parsed.limit);
       return {
-        content: `Log rules on ${context.routerId}: ${returned.length} rule(s) (${all.length} total).`,
+        content: listContent(
+          "Log rules",
+          context.routerId,
+          returned,
+          all.length,
+          0,
+          (r) => compactFields(r, ["topics", "action", "prefix", "disabled"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           rules: returned,
@@ -9631,7 +9967,14 @@ var listLogActionsTool = {
       }
       const returned = actions.slice(0, parsed.limit);
       return {
-        content: `Log actions on ${context.routerId}: ${returned.length} action(s) (${all.length} total).`,
+        content: listContent(
+          "Log actions",
+          context.routerId,
+          returned,
+          all.length,
+          0,
+          (a) => compactFields(a, ["name", "target", "type", "remote"])
+        ),
         structuredContent: {
           routerId: context.routerId,
           actions: returned,
@@ -9898,7 +10241,20 @@ var listConnectionsTool = {
       const filtered = all.filter((c) => parsed.srcAddress ? (c["src-address"] ?? "").includes(parsed.srcAddress) : true).filter((c) => parsed.dstAddress ? (c["dst-address"] ?? "").includes(parsed.dstAddress) : true).filter((c) => parsed.protocol ? c.protocol === parsed.protocol : true);
       const connections = filtered.slice(0, parsed.limit);
       return {
-        content: `Active connections on ${context.routerId}: ${connections.length} returned (${all.length} total)`,
+        content: listContent(
+          "Active connections",
+          context.routerId,
+          connections,
+          all.length,
+          0,
+          (c) => compactFields(c, [
+            "protocol",
+            "src-address",
+            "dst-address",
+            "tcp-state",
+            "connection-mark"
+          ])
+        ),
         structuredContent: { routerId: context.routerId, connections, total: all.length, returned: connections.length }
       };
     } catch (err) {
@@ -10021,7 +10377,14 @@ var listContainerEnvsTool = {
       const filtered = parsed.name ? all.filter((e) => e.name === parsed.name) : all;
       const envs = filtered.slice(0, parsed.limit);
       return {
-        content: `Container envs on ${context.routerId}: ${envs.length} returned`,
+        content: listContent(
+          "Container envs",
+          context.routerId,
+          envs,
+          all.length,
+          0,
+          (e) => compactFields(e, ["name", "key", "value"])
+        ),
         structuredContent: { routerId: context.routerId, envs, total: all.length, returned: envs.length }
       };
     } catch (err) {
@@ -10158,7 +10521,14 @@ var listContainerMountsTool = {
       const filtered = parsed.name ? all.filter((m) => m.name === parsed.name) : all;
       const mounts = filtered.slice(0, parsed.limit);
       return {
-        content: `Container mounts on ${context.routerId}: ${mounts.length} returned`,
+        content: listContent(
+          "Container mounts",
+          context.routerId,
+          mounts,
+          all.length,
+          0,
+          (m) => compactFields(m, ["name", "src", "dst"])
+        ),
         structuredContent: { routerId: context.routerId, mounts, total: all.length, returned: mounts.length }
       };
     } catch (err) {
@@ -10298,7 +10668,14 @@ var listInterfaceListsTool = {
       });
       const lists = all.slice(0, parsed.limit);
       return {
-        content: `Interface lists on ${context.routerId}: ${lists.length} returned`,
+        content: listContent(
+          "Interface lists",
+          context.routerId,
+          lists,
+          all.length,
+          0,
+          (l) => compactFields(l, ["name", "include", "exclude", "comment"])
+        ),
         structuredContent: { routerId: context.routerId, lists, total: all.length, returned: lists.length }
       };
     } catch (err) {
@@ -10783,6 +11160,54 @@ var bulkExecuteInputSchema = z46.object({
     "Fleet confirmation token from a prior APPROVAL_REQUIRED response. Required to fan out a destructive tool."
   )
 }).strict();
+var listRoutersInputSchema = z46.object({
+  tags: z46.array(z46.string()).optional().describe('Only return routers having any of these tags (e.g. ["edge", "prod"])')
+}).strict();
+var listRoutersTool = {
+  name: "list_routers",
+  title: "List Routers",
+  description: "List the routers configured in the registry (routers.yaml): id, host, port, TLS status, tags, ROS version, and which is the default. Read-only reflection of local config \u2014 no RouterOS API call, no credentials in the response. Use it to discover valid routerId values and tags for targeting other tools (including bulk_execute).",
+  inputSchema: listRoutersInputSchema,
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  skipRouterContext: true,
+  async handler(params, context) {
+    const parsed = listRoutersInputSchema.parse(params);
+    const { identity, appConfig } = context;
+    const defaultRouter = appConfig.defaultRouter;
+    log47.info({ tags: parsed.tags, identityId: identity.id }, "Listing routers");
+    let routers = context.routerRegistry.listRouters(parsed.tags);
+    if (identity.allowedRouters.length > 0) {
+      routers = routers.filter((r) => identity.allowedRouters.includes(r.id));
+    }
+    const soleDefaultId = defaultRouter === void 0 && routers.length === 1 ? routers[0].id : void 0;
+    const rows = routers.map((r) => ({
+      id: r.id,
+      host: r.host,
+      port: r.port,
+      tlsEnabled: r.tls.enabled,
+      tags: r.tags,
+      rosVersion: r.rosVersion,
+      isDefault: defaultRouter !== void 0 ? r.id === defaultRouter : r.id === soleDefaultId
+    }));
+    const total = rows.length;
+    const header = `Routers: ${total === 0 ? "none" : `1-${total} of ${total}`}.`;
+    const lines = rows.map(
+      (r) => `  ${compactFields(
+        { ...r, tags: r.tags.join(",") },
+        ["id", "host", "port", "tlsEnabled", "tags", "rosVersion", "isDefault"]
+      )}`
+    );
+    return {
+      content: total === 0 ? header : [header, ...lines].join("\n"),
+      structuredContent: { routers: rows, total, returned: total }
+    };
+  }
+};
 function createFleetTools(baseTools2) {
   const toolMap = new Map(baseTools2.map((t) => [t.name, t]));
   const checkRouterHealthTool = {
@@ -11089,7 +11514,7 @@ function createFleetTools(baseTools2) {
       };
     }
   };
-  return [checkRouterHealthTool, bulkExecuteTool];
+  return [checkRouterHealthTool, bulkExecuteTool, listRoutersTool];
 }
 
 // src/domain/tools/index.ts
@@ -12121,7 +12546,7 @@ var ConnectionPool = class {
 };
 
 // src/version.ts
-var VERSION = "1.6.0";
+var VERSION = "1.7.0";
 
 // src/mcp/server.ts
 var SERVER_INSTRUCTIONS = [
@@ -12532,7 +12957,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.6.0";
+var localVersion = "1.7.0";
 var results = [];
 function ok(msg) {
   console.log(chalk.green("\u2705 ") + msg);
@@ -13244,7 +13669,7 @@ async function runInit() {
 }
 
 // src/cli/index.ts
-var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.6.0");
+var program = new Command().name("mikromcp").description("MikroTik RouterOS MCP server").version("1.7.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);