@moor-sh/mcp 0.9.0 → 0.11.0

package/package.json

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

@@ -548,6 +548,159 @@ server.registerTool(
   },
 );
 
+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") }] };
+  },
+);
+
+server.registerTool(
+  "moor_project_stats",
+  {
+    title: "Project Container Stats (live)",
+    description:
+      "Live container stats for one project: CPU percent, memory (excluding page cache, same accounting as `docker stats`), network and block I/O totals, PID count. Single Docker stats snapshot — CPU uses the cpu_stats/precpu_stats delta the daemon already includes. Stopped or never-started projects return running=false with zeroed counters (no 404).",
+    inputSchema: z.object({
+      project: z.string().describe("Project name or ID"),
+    }),
+  },
+  async ({ project }) => {
+    const p = await resolveProject(project);
+    const res = await apiGet(`/api/projects/${p.id}/container-stats`);
+    if (!res.ok) throw new Error(`Failed: ${res.status} ${await res.text()}`);
+    const s = (await res.json()) as {
+      running: boolean;
+      cpu_percent: number;
+      memory_bytes: number;
+      memory_limit_bytes: number;
+      memory_percent: number;
+      network_rx_bytes: number;
+      network_tx_bytes: number;
+      block_read_bytes: number;
+      block_write_bytes: number;
+      pids: number;
+    };
+    if (!s.running) {
+      return {
+        content: [{ type: "text", text: `${p.name}: not running (zeroed counters returned).` }],
+      };
+    }
+    const memLimit = s.memory_limit_bytes > 0 ? formatBytes(s.memory_limit_bytes) : "unlimited";
+    const lines = [
+      `${p.name}: CPU ${s.cpu_percent}% | Memory ${formatBytes(s.memory_bytes)} / ${memLimit} (${s.memory_percent}%) | PIDs ${s.pids}`,
+      `Network: rx ${formatBytes(s.network_rx_bytes)} / tx ${formatBytes(s.network_tx_bytes)}`,
+      `Block I/O: read ${formatBytes(s.block_read_bytes)} / write ${formatBytes(s.block_write_bytes)}`,
+    ];
+    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"];