@moor-sh/mcp 0.23.1 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moor-sh/mcp",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "description": "MCP server for moor - lets AI agents (Claude Code, Cursor, etc.) manage your moor projects via the moor HTTP API.",
   "license": "MIT",
   "repository": {

package/src/index.ts

@@ -574,7 +574,7 @@ server.registerTool(
   {
     title: "Server Stats",
     description:
-      "Get server resource usage: load, memory, root disk, Docker disk by category (images/containers/volumes/build cache) with reclaimable bytes, and container counts. Note: cpu.percent is load-derived (load avg ÷ cores), not instantaneous CPU; use the `load` field for the same signal with explicit naming.",
+      "Get server resource usage: load, memory, per-filesystem disk usage (every real mount, not just root — so a separate data volume can't hide), Docker disk by category (images/containers/volumes/build cache) with reclaimable bytes, and container counts. Note: cpu.percent is load-derived (load avg ÷ cores), not instantaneous CPU; use the `load` field for the same signal with explicit naming.",
   },
   async () => {
     const res = await apiGet("/api/server/stats");
@@ -587,6 +587,7 @@ server.registerTool(
       load?: { one_min: number; cores: number; normalized_percent: number };
       memory: { total: string; used: string; percent: number };
       disk: { total: string; used: string; percent: number };
+      disks?: { mount: string; total: string; used: string; percent: number }[];
       containers: { running: number; total: number };
       docker?: {
         images: { bytes: number; reclaimable_bytes: number; count: number; unused_count: number };
@@ -611,11 +612,12 @@ server.registerTool(
         `Load (1m): ${s.load.one_min.toFixed(2)} on ${s.load.cores} cores (${s.load.normalized_percent}%)`,
       );
     }
-    lines.push(
-      `Memory: ${s.memory.used} / ${s.memory.total} (${s.memory.percent}%)`,
-      `Disk (root /): ${s.disk.used} / ${s.disk.total} (${s.disk.percent}%)`,
-      `Containers: ${s.containers.running} running / ${s.containers.total} total`,
-    );
+    lines.push(`Memory: ${s.memory.used} / ${s.memory.total} (${s.memory.percent}%)`);
+    const disks = s.disks?.length ? s.disks : [{ mount: "/", ...s.disk }];
+    for (const d of disks) {
+      lines.push(`Disk ${d.mount}: ${d.used} / ${d.total} (${d.percent}%)`);
+    }
+    lines.push(`Containers: ${s.containers.running} running / ${s.containers.total} total`);
     if (s.docker) {
       const d = s.docker;
       lines.push(
@@ -1123,6 +1125,71 @@ function formatBytes(bytes: number): string {
   return `${val.toFixed(val < 10 ? 1 : 0)} ${units[i]}`;
 }
 
+server.registerTool(
+  "moor_project_history",
+  {
+    title: "Project History (stored)",
+    description:
+      "Stored resource history + lifecycle events for one project over a time window — answers 'what was going on with this project around this case?' (NOT live: use moor_project_stats for a current snapshot). Resource samples are taken ~every minute; CPU is averaged across each interval and network/block reported as rates, both computed from raw counters and reset-aware. Events come from the Docker event stream (start/die/oom/kill/restart) and moor's own state changes. Window defaults to the last `hours` (24); pass from_ms/to_ms (epoch ms) for an exact window. A gap warning means events may be incomplete in that window.",
+    inputSchema: z.object({
+      project: z.string().describe("Project name or ID"),
+      hours: z
+        .number()
+        .optional()
+        .describe("Lookback window in hours (default 24). Ignored if from_ms/to_ms are given."),
+      from_ms: z.number().optional().describe("Window start, epoch milliseconds"),
+      to_ms: z.number().optional().describe("Window end, epoch milliseconds"),
+    }),
+  },
+  async ({ project, hours, from_ms, to_ms }) => {
+    const p = await resolveProject(project);
+    const to = to_ms ?? Date.now();
+    const from = from_ms ?? to - (hours ?? 24) * 3_600_000;
+    const res = await apiGet(`/api/projects/${p.id}/stats/history?from=${from}&to=${to}`);
+    if (!res.ok) throw new Error(`Failed: ${res.status} ${await res.text()}`);
+    const h = (await res.json()) as {
+      from_ms: number;
+      to_ms: number;
+      events: Array<{ occurred_at_ms: number; source: string; action: string }>;
+      summary: {
+        sample_count: number;
+        running_sample_count: number;
+        cpu_percent_avg: number | null;
+        cpu_percent_max: number | null;
+        mem_bytes_max: number | null;
+        net_rx_bytes_total: number;
+        net_tx_bytes_total: number;
+        event_counts: Record<string, number>;
+        has_gap: boolean;
+      };
+    };
+    const s = h.summary;
+    const windowH = Math.round(((h.to_ms - h.from_ms) / 3_600_000) * 10) / 10;
+    const lines = [
+      `${p.name} history — window ~${windowH}h${s.has_gap ? "  [⚠ event gap recorded: events may be incomplete]" : ""}`,
+      `Samples: ${s.sample_count} total, ${s.running_sample_count} running`,
+      `CPU: avg ${s.cpu_percent_avg ?? "n/a"}% / max ${s.cpu_percent_max ?? "n/a"}%`,
+      `Memory: max ${s.mem_bytes_max !== null ? formatBytes(s.mem_bytes_max) : "n/a"}`,
+      `Network: in ${formatBytes(s.net_rx_bytes_total)} / out ${formatBytes(s.net_tx_bytes_total)}`,
+    ];
+    const counts = Object.entries(s.event_counts);
+    if (counts.length > 0) {
+      lines.push(`Events: ${counts.map(([a, n]) => `${a} ${n}`).join(", ")}`);
+    }
+    const recent = h.events.slice(-8);
+    if (recent.length > 0) {
+      lines.push("Recent events:");
+      for (const e of recent) {
+        lines.push(`  ${new Date(e.occurred_at_ms).toISOString()} ${e.action} (${e.source})`);
+      }
+    }
+    if (s.sample_count === 0 && h.events.length === 0) {
+      lines.push("(no stored history in this window)");
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
 server.registerTool(
   "moor_project_get",
   {