@moor-sh/mcp 0.8.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moor-sh/mcp",
-  "version": "0.8.0",
+  "version": "0.10.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

@@ -491,7 +491,8 @@ server.registerTool(
   "moor_stats",
   {
     title: "Server Stats",
-    description: "Get server resource usage: CPU, memory, disk, and container counts.",
+    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.",
   },
   async () => {
     const res = await apiGet("/api/server/stats");
@@ -501,23 +502,172 @@ server.registerTool(
       os: string;
       uptime: string;
       cpu: { percent: number; cores: number };
+      load?: { one_min: number; cores: number; normalized_percent: number };
       memory: { total: string; used: string; percent: number };
       disk: { total: string; used: string; percent: number };
       containers: { running: number; total: number };
+      docker?: {
+        images: { bytes: number; reclaimable_bytes: number; count: number; unused_count: number };
+        containers: {
+          bytes: number;
+          reclaimable_bytes: number;
+          count: number;
+          stopped_count: number;
+        };
+        volumes: { bytes: number; reclaimable_bytes: number; count: number; unused_count: number };
+        build_cache: { bytes: number; reclaimable_bytes: number; count: number };
+      } | null;
     };
-    const text = [
+    const lines = [
       `Host: ${s.hostname}`,
       `OS: ${s.os}`,
       `Uptime: ${s.uptime}`,
-      `CPU: ${s.cpu.percent}% (${s.cpu.cores} cores)`,
+      `CPU: ${s.cpu.percent}% (${s.cpu.cores} cores) — load-derived, not instantaneous`,
+    ];
+    if (s.load) {
+      lines.push(
+        `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: ${s.disk.used} / ${s.disk.total} (${s.disk.percent}%)`,
+      `Disk (root /): ${s.disk.used} / ${s.disk.total} (${s.disk.percent}%)`,
       `Containers: ${s.containers.running} running / ${s.containers.total} total`,
-    ].join("\n");
-    return { content: [{ type: "text", text }] };
+    );
+    if (s.docker) {
+      const d = s.docker;
+      lines.push(
+        "Docker disk:",
+        `  Images: ${formatBytes(d.images.bytes)} (${formatBytes(d.images.reclaimable_bytes)} reclaimable, ${d.images.unused_count}/${d.images.count} unused)`,
+        `  Containers: ${formatBytes(d.containers.bytes)} (${formatBytes(d.containers.reclaimable_bytes)} reclaimable, ${d.containers.stopped_count}/${d.containers.count} stopped)`,
+        `  Volumes: ${formatBytes(d.volumes.bytes)} (${formatBytes(d.volumes.reclaimable_bytes)} reclaimable, ${d.volumes.unused_count}/${d.volumes.count} unused)`,
+        `  Build cache: ${formatBytes(d.build_cache.bytes)} (${formatBytes(d.build_cache.reclaimable_bytes)} reclaimable, ${d.build_cache.count} entries)`,
+      );
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
+server.registerTool(
+  "moor_cleanup_plan",
+  {
+    title: "Cleanup Plan (dry-run)",
+    description:
+      "Dry-run: list Docker resources that are safe to delete on this host. v1 covers build cache (host-wide prune) and dangling images (per-ID). Returns candidates with reclaimable bytes. Pass the same candidate list to moor_cleanup_execute to actually delete. No state is kept between plan and execute — execute re-validates eligibility against current Docker state.",
+    inputSchema: z.object({
+      scope: z
+        .array(z.enum(["build_cache", "dangling_image"]))
+        .optional()
+        .describe("Subset of categories to plan. Defaults to all v1 categories."),
+    }),
+  },
+  async ({ scope }) => {
+    const res = await apiPost("/api/server/cleanup/plan", { scope });
+    if (!res.ok) throw new Error(`plan failed: ${res.status} ${await res.text()}`);
+    const data = (await res.json()) as {
+      candidates: Array<
+        | { category: "build_cache"; reclaimable_bytes: number; label: string }
+        | {
+            category: "dangling_image";
+            id: string;
+            reclaimable_bytes: number;
+            repo_tags: string[];
+            label: string;
+          }
+      >;
+      total_reclaimable_bytes: number;
+    };
+    if (data.candidates.length === 0) {
+      return { content: [{ type: "text", text: "Nothing to clean up." }] };
+    }
+    const lines = [
+      `${data.candidates.length} candidate(s), total reclaimable: ${formatBytes(data.total_reclaimable_bytes)}.`,
+      "Pass the candidates_json block below back to moor_cleanup_execute to delete.",
+      "",
+    ];
+    for (const c of data.candidates) {
+      if (c.category === "build_cache") {
+        lines.push(
+          `build_cache [${c.label}] — ${formatBytes(c.reclaimable_bytes)} reclaimable (host-wide prune)`,
+        );
+      } else {
+        const tags = c.repo_tags.length > 0 ? ` tags=${c.repo_tags.join(",")}` : "";
+        lines.push(
+          `dangling_image [${c.label}] id=${c.id} ${formatBytes(c.reclaimable_bytes)}${tags}`,
+        );
+      }
+    }
+    // Emit candidates_json so the agent doesn't have to reconstruct identifiers
+    // from the prose lines above. The execute side ignores extra fields, so
+    // passing the whole candidate objects (label, reclaimable_bytes, etc.) is
+    // safe — server re-validates eligibility and computes actual freed bytes.
+    lines.push("", "candidates_json:", JSON.stringify(data.candidates, null, 2));
+    return { content: [{ type: "text", text: lines.join("\n") }] };
   },
 );
 
+server.registerTool(
+  "moor_cleanup_execute",
+  {
+    title: "Cleanup Execute",
+    description:
+      "Delete the candidates returned by moor_cleanup_plan. Server uses only the identifying fields (category + id where applicable) and re-validates eligibility against current Docker state immediately before each delete — Docker state can change between plan and execute. Reclaimable byte estimates from plan are ignored; the server reports the actual freed bytes. Every execute writes an audit row.",
+    inputSchema: z.object({
+      candidates: z
+        .array(
+          z.union([
+            z.object({ category: z.literal("build_cache") }).passthrough(),
+            z
+              .object({ category: z.literal("dangling_image"), id: z.string().min(1) })
+              .passthrough(),
+          ]),
+        )
+        .min(1)
+        .describe("Candidates from moor_cleanup_plan. Extra fields are ignored server-side."),
+    }),
+  },
+  async ({ candidates }) => {
+    const res = await apiPost("/api/server/cleanup/execute", { candidates });
+    if (!res.ok) throw new Error(`execute failed: ${res.status} ${await res.text()}`);
+    const data = (await res.json()) as {
+      audit_id: number;
+      total_reclaimed_bytes: number;
+      results: Array<
+        | { category: "build_cache"; reclaimed_bytes: number; error: string | null }
+        | {
+            category: "dangling_image";
+            id: string;
+            reclaimed_bytes: number;
+            error: string | null;
+          }
+      >;
+    };
+    const lines = [
+      `audit_id=${data.audit_id} total_reclaimed=${formatBytes(data.total_reclaimed_bytes)}`,
+      "",
+    ];
+    for (const r of data.results) {
+      const status = r.error ? `ERROR: ${r.error}` : "ok";
+      if (r.category === "build_cache") {
+        lines.push(`build_cache: reclaimed=${formatBytes(r.reclaimed_bytes)} ${status}`);
+      } else {
+        lines.push(
+          `dangling_image id=${r.id} reclaimed=${formatBytes(r.reclaimed_bytes)} ${status}`,
+        );
+      }
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
+function formatBytes(bytes: number): string {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
+  const val = bytes / 1024 ** i;
+  return `${val.toFixed(val < 10 ? 1 : 0)} ${units[i]}`;
+}
+
 server.registerTool(
   "moor_project_get",
   {