@mavonengine/cli 0.0.2 → 0.0.3

package/dist/{server-35RY6IGC.js → server-NNL4IMYV.js}

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
+import {
+  fetchPluginReadme,
+  fetchPluginRegistry
+} from "./chunk-ZEMFSSJP.js";
 import {
   LOG_LEVELS,
   READ_ONLY,
   registerDocsTools,
   run,
   vec3
-} from "./chunk-OSCNM66O.js";
+} from "./chunk-NIBSLCCZ.js";
 import {
   version
-} from "./chunk-TNN4S5K4.js";
+} from "./chunk-XPKCYSMN.js";
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 
 // src/mcp/clientTools.ts
 import { mkdir, writeFile } from "fs/promises";
@@ -448,9 +452,9 @@ function compareEntities(id, server, client) {
     note: "Client state of remote entities is interpolated and the local player is predicted, so small deltas are expected while moving"
   };
 }
-function defaultTracePath(clientId2, at = /* @__PURE__ */ new Date()) {
+function defaultTracePath(clientId3, at = /* @__PURE__ */ new Date()) {
   const stamp = at.toISOString().replace(/[:.]/g, "-");
-  return join(tmpdir(), "mavonengine-traces", `trace-${clientId2}-${stamp}.json`);
+  return join(tmpdir(), "mavonengine-traces", `trace-${clientId3}-${stamp}.json`);
 }
 function registerClientTools(server, client) {
   server.registerTool("list_clients", {
@@ -466,7 +470,7 @@ function registerClientTools(server, client) {
     description: "One tab's rendering and state: FPS, draw calls / triangles / points / lines of one frame, GPU geometries / textures / shader programs, JS heap, canvas size, camera, entity count, active scene, resource loading.",
     inputSchema: { clientId },
     annotations: READ_ONLY
-  }, ({ clientId: clientId2 }) => run(() => client.client("status", {}, clientId2)));
+  }, ({ clientId: clientId3 }) => run(() => client.client("status", {}, clientId3)));
   server.registerTool("client_entities", {
     title: "Entities on a client",
     description: "Entities in a tab's world, in the same shape as list_entities on the server, plus `localPlayer` for the entity the tab controls. Filter by type and/or distance to a point (nearest first).",
@@ -479,14 +483,14 @@ function registerClientTools(server, client) {
       offset: z.number().int().min(0).default(0)
     },
     annotations: READ_ONLY
-  }, ({ clientId: clientId2, near, ...query }) => run(() => client.client("entities", { ...query, near: near && `${near.x},${near.y},${near.z}` }, clientId2)));
+  }, ({ clientId: clientId3, near, ...query }) => run(() => client.client("entities", { ...query, near: near && `${near.x},${near.y},${near.z}` }, clientId3)));
   server.registerTool("client_entity", {
     title: "One entity on a client",
     description: "One entity in a tab's world with its serialized state. The server id of the tab's own player finds its local player.",
     inputSchema: { id: z.string().min(1), clientId },
     annotations: READ_ONLY
-  }, ({ id, clientId: clientId2 }) => run(async () => {
-    const { entity } = await client.client("entity", { id }, clientId2);
+  }, ({ id, clientId: clientId3 }) => run(async () => {
+    const { entity } = await client.client("entity", { id }, clientId3);
     if (!entity)
       throw new Error(`The client has no entity with id "${id}". client_entities shows its ids`);
     return entity;
@@ -496,8 +500,8 @@ function registerClientTools(server, client) {
     description: "The scene loaded in a tab, in the same shape as get_scene: objects with `built` telling whether the client built them.",
     inputSchema: { clientId, includeObjects: z.boolean().default(true) },
     annotations: READ_ONLY
-  }, ({ clientId: clientId2, includeObjects }) => run(async () => {
-    const { scene } = await client.client("scene", {}, clientId2);
+  }, ({ clientId: clientId3, includeObjects }) => run(async () => {
+    const { scene } = await client.client("scene", {}, clientId3);
     if (!scene)
       return { scene: null, note: "No scene is loaded in this tab. The client opens one with game.openScene(name)" };
     if (includeObjects)
@@ -510,7 +514,7 @@ function registerClientTools(server, client) {
     description: "A tab's connection to the game server: connected, player id, ping, editor mode, inputs sent but not yet acknowledged (pendingCommands, replayed for prediction) and the next input sequence id.",
     inputSchema: { clientId },
     annotations: READ_ONLY
-  }, ({ clientId: clientId2 }) => run(() => client.client("network", {}, clientId2)));
+  }, ({ clientId: clientId3 }) => run(() => client.client("network", {}, clientId3)));
   server.registerTool("client_logs", {
     title: "Client console",
     description: "A tab's console output, uncaught errors and unhandled promise rejections since it loaded (the last 500), oldest first. Pass the returned latestId as afterId later to get only newer lines.",
@@ -522,8 +526,8 @@ function registerClientTools(server, client) {
       limit: z.number().int().min(1).max(500).default(100).describe("Newest lines kept when more match")
     },
     annotations: READ_ONLY
-  }, ({ clientId: clientId2, level, contains, afterId, limit }) => run(async () => {
-    const { entries = [], latestId = 0 } = await client.client("logs", { after: afterId }, clientId2);
+  }, ({ clientId: clientId3, level, contains, afterId, limit }) => run(async () => {
+    const { entries = [], latestId = 0 } = await client.client("logs", { after: afterId }, clientId3);
     const maxSeverity = level ? SEVERITY[level] : Infinity;
     const needle = contains?.toLowerCase();
     const matches = entries.filter((entry) => (SEVERITY[entry.level] ?? 2) <= maxSeverity && (!needle || entry.message.toLowerCase().includes(needle)));
@@ -542,9 +546,9 @@ function registerClientTools(server, client) {
       format: z.enum(["jpeg", "png"]).default("jpeg")
     },
     annotations: READ_ONLY
-  }, async ({ clientId: clientId2, maxWidth, format }) => {
+  }, async ({ clientId: clientId3, maxWidth, format }) => {
     try {
-      const shot = await client.client("screenshot", { maxWidth, format }, clientId2);
+      const shot = await client.client("screenshot", { maxWidth, format }, clientId3);
       return {
         content: [
           { type: "image", data: shot.data, mimeType: shot.mimeType },
@@ -569,12 +573,12 @@ function registerClientTools(server, client) {
       save: z.boolean().default(true).describe("Write the trace file")
     },
     annotations: { ...READ_ONLY, idempotentHint: false }
-  }, ({ clientId: clientId2, durationMs, jsProfile, sampleIntervalMs, gpu, maxHitches, savePath, save }) => run(async () => {
-    const capture = await client.client("trace", { durationMs, jsProfile: String(jsProfile), sampleIntervalMs, gpu: String(gpu) }, clientId2);
+  }, ({ clientId: clientId3, durationMs, jsProfile, sampleIntervalMs, gpu, maxHitches, savePath, save }) => run(async () => {
+    const capture = await client.client("trace", { durationMs, jsProfile: String(jsProfile), sampleIntervalMs, gpu: String(gpu) }, clientId3);
     const analysis = analyzeTrace(capture, { maxHitches });
     let traceFile;
     if (save) {
-      traceFile = savePath ? resolve(savePath) : defaultTracePath(clientId2 ?? "auto");
+      traceFile = savePath ? resolve(savePath) : defaultTracePath(clientId3 ?? "auto");
       await mkdir(dirname(traceFile), { recursive: true });
       await writeFile(traceFile, JSON.stringify(toTraceEvents(capture)));
     }
@@ -589,12 +593,196 @@ function registerClientTools(server, client) {
     description: "One entity as the server has it next to a tab's copy: position / rotation / scale deltas and the serialized fields that differ. For the tab's own player pass its server id (playerId from list_clients). Needs the server in development too.",
     inputSchema: { id: z.string().min(1).describe("Entity id on the server"), clientId },
     annotations: READ_ONLY
-  }, ({ id, clientId: clientId2 }) => run(async () => {
-    const [onServer, onClient] = await Promise.all([client.entity(id), client.client("entity", { id }, clientId2)]);
+  }, ({ id, clientId: clientId3 }) => run(async () => {
+    const [onServer, onClient] = await Promise.all([client.entity(id), client.client("entity", { id }, clientId3)]);
     return compareEntities(id, onServer.entity, onClient.entity);
   }));
 }
 
+// src/mcp/networkTools.ts
+import { z as z2 } from "zod";
+var clientId2 = z2.string().optional().describe("Tab id from list_clients. Default: the only open tab, or the only one not running the editor");
+var packetFilters = {
+  kind: z2.enum(["packet", "event"]).optional().describe("packet: messages on the wire. event: connect, disconnect, sync_enter, sync_leave, dropped, state_gap\u2026"),
+  direction: z2.enum(["in", "out"]).optional().describe("Seen from the side that recorded it: out was sent, in was received"),
+  type: z2.string().optional().describe("Message or event name, e.g. sv_state or command. Several separated by commas"),
+  afterId: z2.number().int().min(0).default(0),
+  limit: z2.number().int().min(1).max(2e3).default(50).describe("Newest records kept when more match")
+};
+function withTime({ timestamp, ...record }) {
+  return { ...record, time: new Date(timestamp).toISOString() };
+}
+function listing(list) {
+  return {
+    latestId: list.latestId,
+    matched: list.matched,
+    records: list.records.map(withTime),
+    ...list.enabled === false ? { note: "Nothing is being recorded on this side" } : {}
+  };
+}
+function mergeTimeline(server, client) {
+  return [
+    ...server.map((record) => ({ side: "server", ...record })),
+    ...client.map((record) => ({ side: "client", ...record }))
+  ].sort((a, b) => a.timestamp - b.timestamp || (a.side === b.side ? a.id - b.id : a.side === "server" ? -1 : 1));
+}
+function registerNetworkTools(server, client) {
+  server.registerTool("network_packets", {
+    title: "Packets on the server",
+    description: "Packets the game server sent and received and its network events, oldest first: time, direction, message name, client (peer), size in bytes, server tick, input sequence id and a few facts about the payload (entity count, ack, command). The server keeps the last 2000. Pass the returned latestId as afterId to get only newer ones; network_packet shows a payload. Development only.",
+    inputSchema: { ...packetFilters, peer: z2.string().optional().describe("Only one client: its player id (list_players, or playerId from list_clients)") },
+    annotations: READ_ONLY
+  }, ({ afterId, ...query }) => run(async () => listing(await client.packets({ ...query, after: afterId }))));
+  server.registerTool("network_packet", {
+    title: "One packet on the server",
+    description: "One record from network_packets with its payload, as it was serialized for the wire. Payloads of old records are dropped to bound memory (hasPayload false). Development only.",
+    inputSchema: { id: z2.number().int().min(1) },
+    annotations: READ_ONLY
+  }, ({ id }) => run(async () => {
+    const { record } = await client.packet(id);
+    if (!record)
+      throw new Error(`No record ${id}: it is older than the 2000 the server keeps, or was never recorded`);
+    return withTime(record);
+  }));
+  server.registerTool("network_sync", {
+    title: "State sync",
+    description: "Who is sent what: the current server tick, the sync distance, each player with the entities in its last state update (tracked), its last acknowledged input and the size of that update; and each synced entity with how many players track it (trackedBy, 0 means no player is in range), whether it changed since it was last synced and the tick it was last sent in. For entities that do not show up or stop updating on a client. Development only.",
+    inputSchema: {
+      player: z2.string().optional().describe("Only this player, and the entities with `tracked` telling whether it is sent them"),
+      includeEntities: z2.boolean().default(true)
+    },
+    annotations: READ_ONLY
+  }, ({ player, includeEntities }) => run(async () => {
+    const sync = await client.sync();
+    const { entities = [], players = [], ...rest } = sync;
+    if (!player)
+      return includeEntities ? sync : { ...rest, players, entityCount: entities.length };
+    const one = players.find((p) => p.id === player);
+    if (!one)
+      throw new Error(`No player "${player}". Players: ${players.map((p) => p.id).join(", ") || "none"}`);
+    const tracked = new Set(one.tracked);
+    return {
+      ...rest,
+      player: one,
+      ...includeEntities ? { entities: entities.map((entity) => ({ ...entity, tracked: tracked.has(entity.id) })) } : { entityCount: entities.length }
+    };
+  }));
+  server.registerTool("client_packets", {
+    title: "Packets on a client",
+    description: "Packets a tab sent and received and its network events (connect, disconnect, state_gap for lost state updates, state_out_of_order), in the same shape as network_packets. Recorded since the tab loaded, the last 2000.",
+    inputSchema: { clientId: clientId2, ...packetFilters },
+    annotations: READ_ONLY
+  }, ({ clientId: clientId3, afterId, ...query }) => run(async () => listing(await client.client("packets", { ...query, after: afterId }, clientId3))));
+  server.registerTool("client_packet", {
+    title: "One packet on a client",
+    description: "One record from client_packets with its payload.",
+    inputSchema: { id: z2.number().int().min(1), clientId: clientId2 },
+    annotations: READ_ONLY
+  }, ({ id, clientId: clientId3 }) => run(async () => {
+    const { record } = await client.client("packet", { id }, clientId3);
+    if (!record)
+      throw new Error(`No record ${id}: it is older than the 2000 the tab keeps, or was never recorded`);
+    return withTime(record);
+  }));
+  server.registerTool("network_timeline", {
+    title: "Network timeline of one client",
+    description: "What happened between the server and one tab, in order of time: the server's records for that client and the tab's own, merged, each marked with its side. Shows a packet leaving one side and arriving on the other (or not), inputs against the state updates that acknowledge them, and events like sync_enter / sync_leave, dropped and state_gap. Needs the server in development too.",
+    inputSchema: {
+      clientId: clientId2,
+      sinceMs: z2.number().int().min(100).max(6e5).default(5e3).describe("How far back to look"),
+      includePings: z2.boolean().default(false).describe("Keep ping / pong, one pair per second"),
+      eventsOnly: z2.boolean().default(false).describe("Leave the packets out"),
+      limit: z2.number().int().min(1).max(2e3).default(200).describe("Newest entries kept when more match")
+    },
+    annotations: READ_ONLY
+  }, ({ clientId: clientId3, sinceMs, includePings, eventsOnly, limit }) => run(async () => {
+    const { network } = await client.client("network", {}, clientId3);
+    if (!network?.playerId)
+      throw new Error("This tab is not connected to the game server, so the server has no records for it");
+    const kind = eventsOnly ? "event" : void 0;
+    const [onServer, onClient] = await Promise.all([
+      client.packets({ peer: network.playerId, kind, limit: 2e3 }),
+      client.client("packets", { kind, limit: 2e3 }, clientId3)
+    ]);
+    const from = Date.now() - sinceMs;
+    const entries = mergeTimeline(onServer.records, onClient.records).filter((record) => record.timestamp >= from && (includePings || record.type !== "ping" && record.type !== "pong"));
+    return {
+      playerId: network.playerId,
+      pingMs: network.pingMs,
+      matched: entries.length,
+      entries: entries.slice(-limit).map(withTime),
+      note: "Times are each side's own clock. On one machine they line up; otherwise shift one side by the clock difference"
+    };
+  }));
+}
+
+// src/mcp/pluginTools.ts
+import { z as z3 } from "zod";
+var installCommand = (pkg) => `npx @mavonengine/cli install ${pkg}`;
+async function installedPlugins(client) {
+  const [{ plugins = [] }, routes] = await Promise.all([
+    client.plugins(),
+    // An older server lists its plugins but not its routes: the plugins are still worth showing
+    client.routes().then((result) => result.routes ?? [], () => null)
+  ]);
+  return plugins.map((plugin) => ({
+    ...plugin,
+    endpoints: routes ? routes.filter((route) => route.source === "plugin" && route.plugin === plugin.package).map(({ method, path, devOnly, summary }) => ({ method, path, devOnly, summary })) : null
+  }));
+}
+function registerPluginTools(server, client, list) {
+  server.registerTool("list_plugins", {
+    title: "Plugins of the project",
+    description: "The engine plugins in the project's mavonengine.json: version, whether each is enabled and runs on this server, where it runs (client, server or both), its prefabs and the HTTP endpoints it registered. A problem is reported for a plugin that is missing or invalid. See available_plugins for plugins the project could add.",
+    annotations: READ_ONLY
+  }, () => run(async () => ({ plugins: await installedPlugins(client) })));
+  if (!list)
+    return;
+  const registry = () => fetchPluginRegistry({ url: list.url, fetch: list.fetch });
+  server.registerTool("available_plugins", {
+    title: "Plugins that can be installed",
+    description: "The official MavonEngine plugins: what each does, where it runs, the engine versions it supports and the command that installs it. Says which ones the project already has. Check this before building something a plugin already does, such as chat or a monitoring dashboard, and read plugin_readme before suggesting one. Installing is for the user to do: this server is read-only.",
+    annotations: { ...READ_ONLY, openWorldHint: true }
+  }, () => run(async () => {
+    const [{ url, plugins }, installed] = await Promise.all([
+      registry(),
+      // Whether the project has them is extra: the list is worth showing without a running server
+      installedPlugins(client).then((found) => new Map(found.map((plugin) => [plugin.package, plugin])), () => null)
+    ]);
+    return {
+      source: url,
+      projectPlugins: installed ? "known" : "unknown: the game server could not be asked",
+      plugins: plugins.map((plugin) => ({
+        package: plugin.package,
+        name: plugin.name,
+        description: plugin.description,
+        runsOn: plugin.target,
+        engine: plugin.engine,
+        homepage: plugin.homepage,
+        hasReadme: !!plugin.readme,
+        inProject: installed ? installed.has(plugin.package) : null,
+        install: installCommand(plugin.package)
+      }))
+    };
+  }));
+  server.registerTool("plugin_readme", {
+    title: "Read a plugin's readme",
+    description: "The README of an official MavonEngine plugin as Markdown, by its package name from available_plugins: what it does, its options for mavonengine.json, how a game hooks into it and its limits.",
+    inputSchema: { package: z3.string().describe("npm package of the plugin, e.g. @mavonengine/chat") },
+    annotations: { ...READ_ONLY, openWorldHint: true }
+  }, async ({ package: pkg }) => {
+    try {
+      const { plugins } = await registry();
+      const plugin = plugins.find((candidate) => candidate.package === pkg);
+      if (!plugin)
+        throw new Error(`${pkg} is not on the list of plugins. It has: ${plugins.map((candidate) => candidate.package).join(", ") || "nothing"}`);
+      return { content: [{ type: "text", text: await fetchPluginReadme(plugin, { fetch: list.fetch }) }] };
+    } catch (err) {
+      return { isError: true, content: [{ type: "text", text: err.message }] };
+    }
+  });
+}
+
 // src/mcp/server.ts
 var INSTRUCTIONS = `Reads the live state of a running MavonEngine game: the game server (health, performance, players, scene,
 entities, logs, HTTP requests) and, in development, the game tabs open in a browser (renderer stats, the client's world,
@@ -602,8 +790,12 @@ network state, console logs, screenshots). Every tool is read-only.
 Server scene / entity tools need the server in development (NODE_ENV is not "production"); client tools need the client
 served by Vite in dev. Start with server_status and list_clients. Use type / near filters rather than paging through a world.
 compare_entity shows one entity on both sides, for prediction, interpolation and sync bugs.
+network_packets / client_packets list the packets each side sent and received, network_timeline merges both sides for one
+client, and network_sync tells which entities each player is sent: use them when something does not arrive or arrives late.
 client_trace records a few seconds of a tab for frame drops, stutter and slow rendering: the bottleneck, hitches with
 their causes, hot JS functions, WebGL load, and a trace file for flame charts.
+list_plugins shows the plugins the project has, available_plugins the official ones it could add and plugin_readme how
+one is set up and used: look there before building something a plugin already does, like chat.
 docs_list_pages / docs_get_page read the MavonEngine documentation: check it before guessing how an engine API works.`;
 function summarize(metrics) {
   const { cpu, bandwidth, tick, players, ...rest } = metrics ?? {};
@@ -618,7 +810,7 @@ function summarize(metrics) {
 function levelOf(level) {
   return level.toLowerCase().replace(/[^a-z]/g, "");
 }
-function createMcpServer(client, docs) {
+function createMcpServer(client, docs, pluginList) {
   const server = new McpServer({ name: "mavonengine", version }, { instructions: INSTRUCTIONS });
   server.registerTool("server_status", {
     title: "Game server status",
@@ -628,7 +820,7 @@ function createMcpServer(client, docs) {
   server.registerTool("server_metrics", {
     title: "Full metrics snapshot",
     description: "The full metrics snapshot. With includeHistory, also the last ~60 samples of CPU, bandwidth and tick timings, to spot spikes.",
-    inputSchema: { includeHistory: z2.boolean().default(false).describe("Include the per-sample history arrays") },
+    inputSchema: { includeHistory: z4.boolean().default(false).describe("Include the per-sample history arrays") },
     annotations: READ_ONLY
   }, ({ includeHistory }) => run(async () => {
     const metrics = await client.metrics();
@@ -648,7 +840,7 @@ function createMcpServer(client, docs) {
   server.registerTool("get_scene", {
     title: "Active scene",
     description: "The scene loaded on the server: name, file, whether it hot-reloads, unsaved changes, settings, and its objects with type, transform, props, the plugin that registered the type and whether the server built it (false for client-only types). Development only.",
-    inputSchema: { includeObjects: z2.boolean().default(true).describe("Include the scene objects, not just the summary") },
+    inputSchema: { includeObjects: z4.boolean().default(true).describe("Include the scene objects, not just the summary") },
     annotations: READ_ONLY
   }, ({ includeObjects }) => run(async () => {
     const { scene } = await client.scene();
@@ -663,18 +855,18 @@ function createMcpServer(client, docs) {
     title: "Entities in the world",
     description: "Entities in the server world: id, type, position, rotation, scale, whether networked or a player, and the scene object it was built from. Filter by type and/or distance to a point (results are then nearest first). Returns the total match count. Development only.",
     inputSchema: {
-      type: z2.string().optional().describe("Entity class / networked type name, or scene object type, case-insensitive"),
+      type: z4.string().optional().describe("Entity class / networked type name, or scene object type, case-insensitive"),
       near: vec3.optional().describe("Only entities around this point, nearest first"),
-      radius: z2.number().nonnegative().optional().describe("Max distance from `near`"),
-      limit: z2.number().int().min(1).max(500).default(50),
-      offset: z2.number().int().min(0).default(0)
+      radius: z4.number().nonnegative().optional().describe("Max distance from `near`"),
+      limit: z4.number().int().min(1).max(500).default(50),
+      offset: z4.number().int().min(0).default(0)
     },
     annotations: READ_ONLY
   }, (query) => run(() => client.entities(query)));
   server.registerTool("get_entity", {
     title: "One entity",
     description: "One entity by id, with the state it sends to clients (its serialize() output). Development only.",
-    inputSchema: { id: z2.string().min(1) },
+    inputSchema: { id: z4.string().min(1) },
     annotations: READ_ONLY
   }, ({ id }) => run(async () => {
     const { entity } = await client.entity(id);
@@ -686,10 +878,10 @@ function createMcpServer(client, docs) {
     title: "Server logs",
     description: "Recent game server log lines, oldest first. The server keeps the last 500 by default. Pass the returned latestId as afterId later to get only newer lines.",
     inputSchema: {
-      level: z2.enum(LOG_LEVELS).optional().describe("Only this level and more severe ones, e.g. warn includes error"),
-      contains: z2.string().optional().describe("Only lines containing this text, case-insensitive"),
-      afterId: z2.number().int().min(0).default(0),
-      limit: z2.number().int().min(1).max(500).default(100).describe("Newest lines kept when more match")
+      level: z4.enum(LOG_LEVELS).optional().describe("Only this level and more severe ones, e.g. warn includes error"),
+      contains: z4.string().optional().describe("Only lines containing this text, case-insensitive"),
+      afterId: z4.number().int().min(0).default(0),
+      limit: z4.number().int().min(1).max(500).default(100).describe("Newest lines kept when more match")
     },
     annotations: READ_ONLY
   }, ({ level, contains, afterId, limit }) => run(async () => {
@@ -710,10 +902,10 @@ function createMcpServer(client, docs) {
     title: "HTTP requests",
     description: "Recent HTTP requests the game server answered: method, path, status, duration, bytes, address. Pass the returned latestId as afterId later to get only newer ones.",
     inputSchema: {
-      pathContains: z2.string().optional(),
-      minStatus: z2.number().int().optional().describe("e.g. 400 for errors only"),
-      afterId: z2.number().int().min(0).default(0),
-      limit: z2.number().int().min(1).max(500).default(50).describe("Newest requests kept when more match")
+      pathContains: z4.string().optional(),
+      minStatus: z4.number().int().optional().describe("e.g. 400 for errors only"),
+      afterId: z4.number().int().min(0).default(0),
+      limit: z4.number().int().min(1).max(500).default(50).describe("Newest requests kept when more match")
     },
     annotations: READ_ONLY
   }, ({ pathContains, minStatus, afterId, limit }) => run(async () => {
@@ -722,6 +914,8 @@ function createMcpServer(client, docs) {
     return { latestId, matched: matches.length, entries: matches.slice(-limit) };
   }));
   registerClientTools(server, client);
+  registerNetworkTools(server, client);
+  registerPluginTools(server, client, pluginList);
   if (docs)
     registerDocsTools(server, docs);
   return server;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mavonengine/cli",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "MavonEngine command line tools",
   "license": "MIT",
   "keywords": [