@usex/mikrotik-mcp 4.3.0 → 4.5.0

package/README.md

@@ -119,6 +119,34 @@ bun run start            # serve from source
 bun run build            # bundle to dist/
 ```
 
+### As an MCP Bundle (`.mcpb`)
+
+A one-click install for Claude Desktop and other MCPB hosts — no Bun, Node or npm
+needed on the machine, and the router credentials are entered in the host's UI
+rather than a shell.
+
+```bash
+bun run build:mcp                       # bundle for this machine
+bun run build:mcp --target linux-x64    # or one specific target
+bun run build:mcp:all                   # every target
+```
+
+Bundles land in `dist-mcpb/` as `mikrotik-mcp-<version>-<platform>-<arch>.mcpb`.
+Open one with your MCPB host (on Claude Desktop, drag it onto Settings →
+Extensions) and fill in the router address and credentials it prompts for.
+
+Because the server is Bun-native — `bun:sqlite`, `Bun.serve`, `Bun.S3Client`, and
+`@tikoci/centrs`, which ships raw TypeScript — it cannot run on the Node runtime an
+MCPB host provides. Each bundle therefore **vendors the Bun binary it was built
+against** and runs `runtime/bun dist/cli.js serve`, so every subsystem (MAC-Telnet,
+the dashboard, S3 backups) behaves exactly as it does from source. That costs about
+60 MB per bundle and makes each one platform-specific — hence one artifact per
+platform/arch rather than a single universal file.
+
+The build stages the bundle, validates the manifest, and drives the staged server
+over stdio (`initialize` + `tools/list`, asserting the tool count matches the
+manifest) before packing. Pass `--no-smoke` to skip that last check.
+
 ## The tool catalog
 
 **706 tools across 111 modules.** Full, always-current reference (parameters +

package/dist/cli.js

@@ -106,7 +106,7 @@ import {
   updateAaaEntity,
   updateSummaryLine,
   writeBackup
-} from "./shared/cli-mm90zmj3.js";
+} from "./shared/cli-hfhmh1qe.js";
 
 // src/cli.ts
 import { existsSync as existsSync2 } from "fs";
@@ -650,6 +650,52 @@ function stopHealthChecks() {
   }
 }
 
+// src/observability/traffic-hub.ts
+var POLL_MS = 1000;
+var hubs = new Map;
+function subscribeTraffic(device, fn) {
+  let hub = hubs.get(device);
+  if (!hub) {
+    const broadcast = (sample) => {
+      const h = hubs.get(device);
+      if (!h)
+        return;
+      h.last = sample;
+      for (const l of h.listeners)
+        l(sample);
+    };
+    const poll = async () => {
+      try {
+        broadcast(await sampleAllTraffic(createContext(undefined, device || undefined)));
+      } catch (e) {
+        broadcast({
+          ts: Date.now(),
+          source: "none",
+          note: e instanceof Error ? e.message : String(e),
+          hosts: {},
+          limits: {}
+        });
+      }
+    };
+    hub = { listeners: new Set, timer: setInterval(() => void poll(), POLL_MS) };
+    hubs.set(device, hub);
+    poll();
+  }
+  hub.listeners.add(fn);
+  if (hub.last)
+    fn(hub.last);
+  return () => {
+    const h = hubs.get(device);
+    if (!h)
+      return;
+    h.listeners.delete(fn);
+    if (h.listeners.size === 0) {
+      clearInterval(h.timer);
+      hubs.delete(device);
+    }
+  };
+}
+
 // src/observability/store.ts
 import { mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname2 } from "path";
@@ -1595,6 +1641,45 @@ data: ${JSON.stringify(e)}
 `));
       ping = setInterval(() => send(`: ping
 
+`), 15000);
+    },
+    cancel() {
+      unsub?.();
+      if (ping)
+        clearInterval(ping);
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-cache, no-transform",
+      connection: "keep-alive"
+    }
+  });
+}
+function sseTrafficResponse(device, transportLabel) {
+  let unsub;
+  let ping;
+  const stream = new ReadableStream({
+    start(controller) {
+      const enc = new TextEncoder;
+      const send = (text) => {
+        try {
+          controller.enqueue(enc.encode(text));
+        } catch {}
+      };
+      send(`event: hello
+data: ${JSON.stringify({ transport: transportLabel })}
+
+`);
+      unsub = subscribeTraffic(device, (sample) => {
+        send(`event: traffic
+data: ${JSON.stringify(sample)}
+
+`);
+      });
+      ping = setInterval(() => send(`: ping
+
 `), 15000);
     },
     cancel() {
@@ -1775,7 +1860,12 @@ async function modulesRoutes(req, url) {
   if (p === "/api/modules" && req.method === "GET") {
     const cfg = getConfig();
     const src = getConfigSource();
-    return json3({ ...moduleSurface(cfg.tools), filter: cfg.tools, source: src, appViews: cfg.mcp.appViews });
+    return json3({
+      ...moduleSurface(cfg.tools),
+      filter: cfg.tools,
+      source: src,
+      appViews: cfg.mcp.appViews
+    });
   }
   if (p === "/api/modules/toggle" && req.method === "POST") {
     const b = await readJson(req);
@@ -2295,12 +2385,14 @@ async function runDashboard(cfg, transportLabel) {
   };
   async function dashboardRoute(req, url, srv, ca, tl) {
     if (url.pathname === "/api/stream") {
-      if (srv.upgrade(req, { data: {} }))
+      const traffic = url.searchParams.has("traffic") ? url.searchParams.get("traffic") ?? "" : undefined;
+      if (srv.upgrade(req, { data: { traffic } }))
         return;
       return new Response("WebSocket upgrade failed", { status: 400 });
     }
     if (url.pathname === "/api/sse") {
-      return sseResponse(tl);
+      const traffic = url.searchParams.has("traffic") ? url.searchParams.get("traffic") ?? "" : undefined;
+      return traffic === undefined ? sseResponse(tl) : sseTrafficResponse(traffic, tl);
     }
     const configResp = await configRoutes(req, url, ca);
     if (configResp)
@@ -2471,11 +2563,19 @@ async function runDashboard(cfg, transportLabel) {
     },
     websocket: {
       open(ws) {
-        ws.data.unsub = subscribe((e) => {
-          try {
-            ws.send(JSON.stringify({ type: "event", event: e }));
-          } catch {}
-        });
+        if (ws.data.traffic !== undefined) {
+          ws.data.unsub = subscribeTraffic(ws.data.traffic, (sample) => {
+            try {
+              ws.send(JSON.stringify({ type: "traffic", sample }));
+            } catch {}
+          });
+        } else {
+          ws.data.unsub = subscribe((e) => {
+            try {
+              ws.send(JSON.stringify({ type: "event", event: e }));
+            } catch {}
+          });
+        }
         ws.send(JSON.stringify({ type: "hello", transport: transportLabel }));
       },
       message() {},

package/dist/index.js

@@ -29,7 +29,7 @@ import {
   selectToolModules,
   setConfig,
   updateSummaryLine
-} from "./shared/library-t0cfgfyj.js";
+} from "./shared/library-399v2azd.js";
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";

package/dist/shared/{cli-k18dkv4w.js → cli-6xcbh1kn.js}

@@ -4,7 +4,7 @@ import {
   allToolModules,
   moduleCatalog,
   selectToolModules
-} from "./cli-mm90zmj3.js";
+} from "./cli-hfhmh1qe.js";
 export {
   selectToolModules,
   moduleCatalog,

package/dist/shared/{cli-mm90zmj3.js → cli-hfhmh1qe.js}

@@ -359,7 +359,8 @@ var DashboardConfigSchema = z.object({
   captureBody: z.boolean().default(true),
   redactInput: z.boolean().default(false),
   maxBodyBytes: z.coerce.number().int().nonnegative().default(16384),
-  token: z.string().optional()
+  token: z.string().optional(),
+  feedLimit: z.coerce.number().int().positive().max(1e4).default(200)
 });
 var MemoryConfigSchema = z.object({
   enabled: z.boolean().default(true),
@@ -572,7 +573,8 @@ function loadConfig(argv = process.argv.slice(2)) {
     captureBody: boolOpt(pick("dashboard-capture-body", "MIKROTIK_DASHBOARD__CAPTURE_BODY")),
     redactInput: boolOpt(pick("dashboard-redact-input", "MIKROTIK_DASHBOARD__REDACT_INPUT")),
     maxBodyBytes: pick("dashboard-max-body-bytes", "MIKROTIK_DASHBOARD__MAX_BODY_BYTES"),
-    token: pick("dashboard-token", "MIKROTIK_DASHBOARD__TOKEN")
+    token: pick("dashboard-token", "MIKROTIK_DASHBOARD__TOKEN"),
+    feedLimit: pick("dashboard-feed-limit", "MIKROTIK_DASHBOARD__FEED_LIMIT")
   });
   const ssh = overlay(fileSsh, {
     keepAlive: boolOpt(pick("ssh-keep-alive", "MIKROTIK_SSH__KEEP_ALIVE")),
@@ -2761,6 +2763,43 @@ var BLOCK_TAG = "mcp-blocked";
 function normalizeMac(mac) {
   return mac.trim().toUpperCase().replace(/-/g, ":");
 }
+var resolvedSource = new Map;
+var firstLine = (s) => s.trim().split(`
+`)[0].trim();
+async function enableAccounting(ctx) {
+  const out = await executeMikrotikCommand("/ip accounting set enabled=yes threshold=2000", ctx);
+  return looksLikeError(out) ? firstLine(out) : null;
+}
+async function enableKidControl(ctx) {
+  const count = await executeMikrotikCommand("/ip kid-control print count-only", ctx);
+  if (looksLikeError(count))
+    return firstLine(count);
+  if ((parseLeadingNumber(count.trim()) ?? 0) > 0)
+    return null;
+  const days = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"].map((d) => `${d}=0s-1d`).join(" ");
+  const add = await executeMikrotikCommand(`/ip kid-control add name=mcp-monitor ${days}`, ctx);
+  return looksLikeError(add) ? firstLine(add) : null;
+}
+async function resolveSource(ctx) {
+  const key = ctx.device ?? "";
+  const cached = resolvedSource.get(key);
+  if (cached)
+    return { source: cached };
+  const accErr = await enableAccounting(ctx);
+  if (!accErr) {
+    resolvedSource.set(key, "accounting");
+    return { source: "accounting" };
+  }
+  const kidErr = await enableKidControl(ctx);
+  if (!kidErr) {
+    resolvedSource.set(key, "kid-control");
+    return { source: "kid-control" };
+  }
+  return {
+    source: "none",
+    note: `No per-host traffic source. /ip accounting (v6): ${accErr}. Kid Control (v7): ${kidErr}.`
+  };
+}
 async function fetchDevices(ctx) {
   const leaseOut = await executeMikrotikCommand("/ip dhcp-server lease print detail", ctx);
   const arpOut = await executeMikrotikCommand("/ip arp print detail", ctx);
@@ -2840,27 +2879,113 @@ async function sampleDeviceTraffic(ctx, ip) {
     uploadLimit: limit(upLim)
   };
 }
-async function sampleAllTraffic(ctx) {
-  const ts = Date.now();
-  const out = await executeMikrotikCommand("/queue simple print stats detail", ctx);
+async function readQueueLimits(ctx) {
+  const limits = {};
+  const out = await executeMikrotikCommand("/queue simple print detail", ctx);
   if (isEmpty(out) || looksLikeError(out))
-    return { ts, queues: {} };
-  const queues = {};
-  const limit = (v) => v && v !== "0" ? v : "";
+    return limits;
+  const val = (v) => v && v !== "0" ? v : "";
   for (const row of parseRecords(out).rows) {
     const ip = (row.target ?? "").split("/")[0]?.trim();
     if (!ip)
       continue;
-    const [txB, rxB] = (row.bytes ?? "0/0").split("/");
     const [upLim, downLim] = (row["max-limit"] ?? "0/0").split("/");
-    queues[ip] = {
-      txBytes: parseLeadingNumber(txB) ?? 0,
-      rxBytes: parseLeadingNumber(rxB) ?? 0,
-      downloadLimit: limit(downLim),
-      uploadLimit: limit(upLim)
+    limits[ip] = { download: val(downLim), upload: val(upLim) };
+  }
+  return limits;
+}
+function parseMagnitude(v) {
+  const m = (v ?? "").trim().match(/^(-?\d+(?:\.\d+)?)\s*([kMGT])?/i);
+  if (!m)
+    return 0;
+  const u = (m[2] ?? "").toLowerCase();
+  const factor = u === "k" ? 1000 : u === "m" ? 1e6 : u === "g" ? 1e9 : u === "t" ? 1000000000000 : 1;
+  return Number(m[1]) * factor;
+}
+var acctState = new Map;
+function aggregateHostTraffic(rows) {
+  const hosts = {};
+  const bump = (ip, key, b) => {
+    if (!ip)
+      return;
+    (hosts[ip] ??= { rxBytes: 0, txBytes: 0 })[key] += b;
+  };
+  for (const row of rows) {
+    const bytes = parseLeadingNumber(row.bytes) ?? 0;
+    if (bytes <= 0)
+      continue;
+    bump((row["dst-address"] ?? "").trim(), "rxBytes", bytes);
+    bump((row["src-address"] ?? "").trim(), "txBytes", bytes);
+  }
+  return hosts;
+}
+async function sampleAccounting(ctx, ts) {
+  const key = ctx.device ?? "";
+  await executeMikrotikCommand("/ip accounting snapshot take", ctx);
+  const out = await executeMikrotikCommand("/ip accounting snapshot print", ctx);
+  if (looksLikeError(out))
+    throw new Error(firstLine(out));
+  const deltas = aggregateHostTraffic(parseRecords(out).rows);
+  const st = acctState.get(key) ?? { lastTs: 0, cum: new Map };
+  const dtSec = st.lastTs ? Math.max(0.1, (ts - st.lastTs) / 1000) : 0;
+  const hosts = {};
+  for (const [ip, d] of Object.entries(deltas)) {
+    const c = st.cum.get(ip) ?? { rx: 0, tx: 0 };
+    c.rx += d.rxBytes;
+    c.tx += d.txBytes;
+    st.cum.set(ip, c);
+    hosts[ip] = {
+      rxRate: dtSec ? d.rxBytes / dtSec * 8 : 0,
+      txRate: dtSec ? d.txBytes / dtSec * 8 : 0,
+      rxBytes: c.rx,
+      txBytes: c.tx
+    };
+  }
+  st.lastTs = ts;
+  acctState.set(key, st);
+  return hosts;
+}
+function parseKidDevices(rows) {
+  const hosts = {};
+  for (const row of rows) {
+    const ip = (row["ip-address"] ?? "").trim();
+    if (!ip)
+      continue;
+    hosts[ip] = {
+      rxRate: parseMagnitude(row["rate-down"]),
+      txRate: parseMagnitude(row["rate-up"]),
+      rxBytes: parseMagnitude(row["bytes-down"]),
+      txBytes: parseMagnitude(row["bytes-up"])
+    };
+  }
+  return hosts;
+}
+async function sampleKidControl(ctx) {
+  const out = await executeMikrotikCommand("/ip kid-control device print detail", ctx);
+  if (looksLikeError(out))
+    throw new Error(firstLine(out));
+  if (isEmpty(out))
+    return {};
+  return parseKidDevices(parseRecords(out).rows);
+}
+async function sampleAllTraffic(ctx) {
+  const ts = Date.now();
+  const limits = await readQueueLimits(ctx);
+  const { source, note } = await resolveSource(ctx);
+  if (source === "none")
+    return { ts, source, note, hosts: {}, limits };
+  try {
+    const hosts = source === "accounting" ? await sampleAccounting(ctx, ts) : await sampleKidControl(ctx);
+    return { ts, source, hosts, limits };
+  } catch (e) {
+    return {
+      ts,
+      source: "none",
+      note: e instanceof Error ? e.message : String(e),
+      hosts: {},
+      limits
     };
   }
-  return { ts, queues };
 }
 async function setDeviceLimits(ctx, ip, opts) {
   const rate = (v) => {
@@ -8364,7 +8489,7 @@ var cache = null;
 async function gateway() {
   if (cache)
     return cache;
-  const { moduleCatalog } = await import("./cli-k18dkv4w.js");
+  const { moduleCatalog } = await import("./cli-6xcbh1kn.js");
   const forIndex = [];
   const byName = new Map;
   for (const mod of moduleCatalog) {

package/dist/shared/{library-t0cfgfyj.js → library-399v2azd.js}

@@ -359,7 +359,8 @@ var DashboardConfigSchema = z.object({
   captureBody: z.boolean().default(true),
   redactInput: z.boolean().default(false),
   maxBodyBytes: z.coerce.number().int().nonnegative().default(16384),
-  token: z.string().optional()
+  token: z.string().optional(),
+  feedLimit: z.coerce.number().int().positive().max(1e4).default(200)
 });
 var MemoryConfigSchema = z.object({
   enabled: z.boolean().default(true),
@@ -569,7 +570,8 @@ function loadConfig(argv = process.argv.slice(2)) {
     captureBody: boolOpt(pick("dashboard-capture-body", "MIKROTIK_DASHBOARD__CAPTURE_BODY")),
     redactInput: boolOpt(pick("dashboard-redact-input", "MIKROTIK_DASHBOARD__REDACT_INPUT")),
     maxBodyBytes: pick("dashboard-max-body-bytes", "MIKROTIK_DASHBOARD__MAX_BODY_BYTES"),
-    token: pick("dashboard-token", "MIKROTIK_DASHBOARD__TOKEN")
+    token: pick("dashboard-token", "MIKROTIK_DASHBOARD__TOKEN"),
+    feedLimit: pick("dashboard-feed-limit", "MIKROTIK_DASHBOARD__FEED_LIMIT")
   });
   const ssh = overlay(fileSsh, {
     keepAlive: boolOpt(pick("ssh-keep-alive", "MIKROTIK_SSH__KEEP_ALIVE")),
@@ -2713,6 +2715,7 @@ var BLOCK_TAG = "mcp-blocked";
 function normalizeMac(mac) {
   return mac.trim().toUpperCase().replace(/-/g, ":");
 }
+var resolvedSource = new Map;
 async function fetchDevices(ctx) {
   const leaseOut = await executeMikrotikCommand("/ip dhcp-server lease print detail", ctx);
   const arpOut = await executeMikrotikCommand("/ip arp print detail", ctx);
@@ -2792,6 +2795,7 @@ async function sampleDeviceTraffic(ctx, ip) {
     uploadLimit: limit(upLim)
   };
 }
+var acctState = new Map;
 async function setDeviceLimits(ctx, ip, opts) {
   const rate = (v) => {
     const t = (v ?? "").trim();
@@ -8294,7 +8298,7 @@ var cache = null;
 async function gateway() {
   if (cache)
     return cache;
-  const { moduleCatalog } = await import("./library-tmmvpwjf.js");
+  const { moduleCatalog } = await import("./library-8hq0qqwm.js");
   const forIndex = [];
   const byName = new Map;
   for (const mod of moduleCatalog) {

package/dist/shared/{library-tmmvpwjf.js → library-8hq0qqwm.js}

@@ -4,7 +4,7 @@ import {
   allToolModules,
   moduleCatalog,
   selectToolModules
-} from "./library-t0cfgfyj.js";
+} from "./library-399v2azd.js";
 export {
   selectToolModules,
   moduleCatalog,