@moor-sh/mcp 0.5.1 → 0.7.0

package/package.json

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

@@ -572,6 +572,35 @@ server.registerTool(
         .enum(["no", "on-failure", "always", "unless-stopped"])
         .optional()
         .describe("Docker restart policy (default: unless-stopped)"),
+      memory_limit_mb: z
+        .number()
+        .int()
+        .min(6)
+        .optional()
+        .describe(
+          "Max RAM in MB (also caps swap to the same value so the container can't burn through host swap). Min 6 (Docker's floor), max host total memory. Omit for unbounded. Takes effect on container recreate (next moor_rebuild / moor_restart / moor_deploy / moor_project run).",
+        ),
+      cpus: z
+        .number()
+        .min(0.001)
+        .optional()
+        .describe(
+          "Max CPU cores. Fractional values OK (e.g. 0.5 = half a core). Min 0.001 (anything smaller rounds to Docker NanoCpus=0, which means unlimited — use omit for that). Max host core count. Takes effect on container recreate.",
+        ),
+      volumes: z
+        .array(
+          z.object({
+            name: z.string().min(1).describe("Logical volume name (unique per project)"),
+            target: z
+              .string()
+              .min(1)
+              .describe("Absolute in-container mount path (e.g. /var/lib/postgresql/data)"),
+          }),
+        )
+        .optional()
+        .describe(
+          "Named Docker volumes to attach. Each entry creates a per-project volume (stored as moor-<project>-<name>) and mounts it at the given target on next container recreate. Data survives container/project rebuilds unless explicitly purged via project delete with purge_volumes=true.",
+        ),
     }),
   },
   async (input) => {
@@ -581,10 +610,35 @@ server.registerTool(
     }
     if (input.github_url) validateGithubUrl(input.github_url);
 
-    const res = await apiPost("/api/projects", input);
+    const { volumes, ...createBody } = input;
+    const res = await apiPost("/api/projects", createBody);
     if (!res.ok) throw new Error(`Failed to create project: ${await res.text()}`);
-    const project = await res.json();
-    return { content: [{ type: "text", text: JSON.stringify(project, null, 2) }] };
+    const project = (await res.json()) as { id: number };
+
+    // Volumes are a separate endpoint so the API stays single-concern. Loop
+    // through them; if any one fails, report what landed and what didn't.
+    const volumeFailures: Array<{ name: string; error: string }> = [];
+    const volumeCreated: string[] = [];
+    if (volumes && volumes.length > 0) {
+      for (const v of volumes) {
+        const vRes = await apiPost(`/api/projects/${project.id}/volumes`, v);
+        if (vRes.ok) volumeCreated.push(v.name);
+        else volumeFailures.push({ name: v.name, error: await vRes.text() });
+      }
+    }
+
+    const lines = [JSON.stringify(project, null, 2)];
+    if (volumeCreated.length > 0) {
+      lines.push(`\nCreated volumes: ${volumeCreated.join(", ")}`);
+    }
+    if (volumeFailures.length > 0) {
+      lines.push(
+        `\nVolume failures (project was still created): ${volumeFailures
+          .map((f) => `${f.name}: ${f.error}`)
+          .join("; ")}`,
+      );
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
   },
 );
 
@@ -593,7 +647,7 @@ server.registerTool(
   {
     title: "Update Project",
     description:
-      "Updates project metadata. Does NOT rebuild or restart the container. Domain or domain_port changes apply to Caddy immediately.",
+      "Updates project metadata. Does NOT rebuild or restart the container. Domain or domain_port changes apply to Caddy immediately. Resource-limit changes (memory_limit_mb, cpus) take effect on the next container recreate (moor_rebuild / moor_restart / moor_deploy / moor_project run) — an already-running container keeps its existing limits.",
     inputSchema: z.object({
       project: z.string().describe("Project name or ID to update"),
       name: z
@@ -610,6 +664,23 @@ server.registerTool(
       domain: z.string().optional(),
       domain_port: z.number().int().positive().optional(),
       restart_policy: z.enum(["no", "on-failure", "always", "unless-stopped"]).optional(),
+      memory_limit_mb: z
+        .number()
+        .int()
+        .min(6)
+        .nullable()
+        .optional()
+        .describe(
+          "Max RAM in MB. Pass null to clear (return to unbounded). Min 6, max host total memory. Takes effect on container recreate.",
+        ),
+      cpus: z
+        .number()
+        .min(0.001)
+        .nullable()
+        .optional()
+        .describe(
+          "Max CPU cores (fractional OK; min 0.001). Pass null to clear. Max host core count. Takes effect on container recreate.",
+        ),
     }),
   },
   async (input) => {
@@ -635,7 +706,7 @@ server.registerTool(
   {
     title: "Delete Project",
     description:
-      "Stops and removes the container, then deletes the project record. Requires confirm_name to match the resolved project name exactly. Irreversible.",
+      "Stops and removes the container, then deletes the project record. Requires confirm_name to match the resolved project name exactly. Irreversible. Named Docker volumes are preserved by default (data survives so a recreated project can remount them); pass purge_volumes: true to also delete the underlying Docker volumes — that deletion is also irreversible.",
     inputSchema: z.object({
       project: z.string().describe("Project name or ID to delete"),
       confirm_name: z
@@ -643,18 +714,47 @@ server.registerTool(
         .describe(
           "Must equal the resolved project's name. Guards against deleting the wrong project.",
         ),
+      purge_volumes: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe(
+          "Also delete the underlying Docker volumes (their data). Default false: project gone, volumes (and their data) preserved. The volume metadata is cleaned up either way; this flag only controls whether the data goes too.",
+        ),
     }),
   },
-  async ({ project, confirm_name }) => {
+  async ({ project, confirm_name, purge_volumes }) => {
     const p = await resolveProject(project);
     if (confirm_name !== p.name) {
       throw new Error(
         `confirm_name "${confirm_name}" does not match resolved project name "${p.name}". Refusing to delete.`,
       );
     }
-    const res = await apiDelete(`/api/projects/${p.id}`);
-    if (!res.ok) throw new Error(`Failed to delete project: ${await res.text()}`);
-    return { content: [{ type: "text", text: `Deleted project ${p.name} (id=${p.id}).` }] };
+    const qs = purge_volumes ? "?purge_volumes=true" : "";
+    const res = await apiDelete(`/api/projects/${p.id}${qs}`);
+    if (!res.ok) {
+      const text = await res.text();
+      try {
+        const parsed = JSON.parse(text);
+        if (parsed?.message) throw new Error(parsed.message);
+      } catch {
+        // not json
+      }
+      throw new Error(`Failed to delete project: ${text}`);
+    }
+    // 204 No Content (no purge or no volumes) vs 200 JSON (purge with results)
+    if (res.status === 204) {
+      return { content: [{ type: "text", text: `Deleted project ${p.name} (id=${p.id}).` }] };
+    }
+    const body = (await res.json()) as { volumes_purged?: number };
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Deleted project ${p.name} (id=${p.id}). Purged ${body.volumes_purged ?? 0} Docker volume(s).`,
+        },
+      ],
+    };
   },
 );
 
@@ -846,6 +946,98 @@ server.registerTool(
   },
 );
 
+// --- Volumes (#35) ---
+
+server.registerTool(
+  "moor_volume_list",
+  {
+    title: "List Project Volumes",
+    description:
+      "List the named Docker volumes attached to a project. Each entry includes the logical name (per-project handle), the in-container target path, and the actual Docker volume name (for `docker volume ls` / `docker volume inspect` outside moor).",
+    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}/volumes`);
+    if (!res.ok) throw new Error(`Failed: ${await res.text()}`);
+    const rows = (await res.json()) as Array<{
+      id: number;
+      name: string;
+      target: string;
+      docker_name: string;
+    }>;
+    if (rows.length === 0) {
+      return { content: [{ type: "text", text: `No volumes attached to ${p.name}.` }] };
+    }
+    const lines = rows.map(
+      (v) => `id=${v.id}  name=${v.name}  target=${v.target}  docker_name=${v.docker_name}`,
+    );
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
+server.registerTool(
+  "moor_volume_add",
+  {
+    title: "Add Project Volume",
+    description:
+      "Attach a named Docker volume to a project. The volume is created lazily by Docker on first container start; moor stores the mount config (logical name, in-container target, and the generated docker_name like moor-<project>-<name>). Takes effect on container recreate (next moor_rebuild / moor_restart / moor_deploy / moor_project run) — already-running containers keep their existing mounts.",
+    inputSchema: z.object({
+      project: z.string().describe("Project name or ID"),
+      name: z
+        .string()
+        .min(1)
+        .describe("Logical volume name (unique per project; alphanumeric/_/-)"),
+      target: z
+        .string()
+        .min(1)
+        .describe("Absolute in-container mount path (e.g. /var/lib/postgresql/data)"),
+    }),
+  },
+  async ({ project, name, target }) => {
+    const p = await resolveProject(project);
+    const res = await apiPost(`/api/projects/${p.id}/volumes`, { name, target });
+    if (!res.ok) throw new Error(`Failed: ${await res.text()}`);
+    const created = (await res.json()) as {
+      id: number;
+      name: string;
+      target: string;
+      docker_name: string;
+    };
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Attached volume to ${p.name}: id=${created.id}, name=${created.name}, target=${created.target}, docker_name=${created.docker_name}. Mount applies on next container recreate.`,
+        },
+      ],
+    };
+  },
+);
+
+server.registerTool(
+  "moor_volume_remove",
+  {
+    title: "Remove Project Volume Mount",
+    description:
+      "Detach a named volume from a project's mount config. The underlying Docker volume (and its data) is intentionally preserved — to actually delete the data, use moor_project_delete with purge_volumes:true, or run `docker volume rm <docker_name>` manually. Takes effect on next container recreate.",
+    inputSchema: z.object({
+      project: z.string().describe("Project name or ID"),
+      volume_id: z.number().int().positive().describe("Volume ID from moor_volume_list"),
+    }),
+  },
+  async ({ project, volume_id }) => {
+    const p = await resolveProject(project);
+    const res = await apiDelete(`/api/projects/${p.id}/volumes/${volume_id}`);
+    if (res.status === 404) throw new Error(`Volume ${volume_id} not found on project ${p.name}`);
+    if (!res.ok) throw new Error(`Failed: ${await res.text()}`);
+    const body = (await res.json()) as { docker_name: string; message: string };
+    return { content: [{ type: "text", text: body.message }] };
+  },
+);
+
 server.registerTool(
   "moor_deploy",
   {
@@ -888,6 +1080,34 @@ server.registerTool(
         .enum(["no", "on-failure", "always", "unless-stopped"])
         .optional()
         .describe("Docker restart policy (API default: unless-stopped)"),
+      memory_limit_mb: z
+        .number()
+        .int()
+        .min(6)
+        .nullable()
+        .optional()
+        .describe(
+          "Max RAM in MB (also caps swap to the same value). Min 6, max host total memory. Pass null on update to clear. Limits apply on container recreate, which deploy always does when run: true.",
+        ),
+      cpus: z
+        .number()
+        .min(0.001)
+        .nullable()
+        .optional()
+        .describe(
+          "Max CPU cores. Fractional OK (e.g. 0.5; min 0.001). Max host core count. Pass null on update to clear.",
+        ),
+      volumes: z
+        .array(
+          z.object({
+            name: z.string().min(1),
+            target: z.string().min(1),
+          }),
+        )
+        .optional()
+        .describe(
+          "Named Docker volumes to attach. Each entry becomes a per-project volume (stored as moor-<project>-<name>) and mounts at the given target on container recreate. On update_existing, additions only — no removals. Data survives container/project rebuilds unless explicitly purged via moor_project_delete with confirm_name (purge_volumes is a separate flag).",
+        ),
       env: z
         .record(z.string(), z.string())
         .optional()
@@ -965,6 +1185,8 @@ server.registerTool(
         domain: normalizedDomain,
         domain_port: input.domain_port,
         restart_policy: input.restart_policy,
+        memory_limit_mb: input.memory_limit_mb,
+        cpus: input.cpus,
       };
       const res = await apiPost("/api/projects", createBody);
       if (!res.ok) throw new Error(`[create] ${await res.text()}`);
@@ -982,6 +1204,8 @@ server.registerTool(
       if (normalizedDomain !== undefined) updateBody.domain = normalizedDomain;
       if (input.domain_port !== undefined) updateBody.domain_port = input.domain_port;
       if (input.restart_policy !== undefined) updateBody.restart_policy = input.restart_policy;
+      if (input.memory_limit_mb !== undefined) updateBody.memory_limit_mb = input.memory_limit_mb;
+      if (input.cpus !== undefined) updateBody.cpus = input.cpus;
 
       if (Object.keys(updateBody).length > 0) {
         const res = await apiPut(`/api/projects/${existing.id}`, updateBody);
@@ -991,6 +1215,51 @@ server.registerTool(
       projectName = existing.name;
     }
 
+    // Step 1.5: add named volumes (additions only — moor_deploy never removes
+    // volumes, even on update_existing). Mounts apply on next container
+    // recreate, which the run step below triggers by default.
+    if (input.volumes && input.volumes.length > 0) {
+      // Cache the existing list once so we can resolve 409s without re-fetching
+      // per conflict. Only fetched if a 409 actually occurs.
+      let existingVolumes: Array<{ name: string; target: string }> | null = null;
+      for (const v of input.volumes) {
+        const vRes = await apiPost(`/api/projects/${projectId}/volumes`, v);
+        if (vRes.ok) continue;
+        const text = await vRes.text();
+        if (vRes.status !== 409) {
+          throw new Error(`[volumes] failed to add ${v.name}: ${text}`);
+        }
+        // 409 is tolerable ONLY if the existing volume matches the requested
+        // spec exactly (same name, same target). A 409 with a drifted target
+        // means the operator changed the desired mount and we'd silently
+        // ignore the change — fail loudly instead.
+        if (existingVolumes === null) {
+          const listRes = await apiGet(`/api/projects/${projectId}/volumes`);
+          if (!listRes.ok) {
+            throw new Error(
+              `[volumes] could not resolve 409 on ${v.name}: failed to list existing volumes: ${await listRes.text()}`,
+            );
+          }
+          existingVolumes = (await listRes.json()) as Array<{ name: string; target: string }>;
+        }
+        const match = existingVolumes.find((e) => e.name === v.name);
+        if (!match) {
+          // 409 was for some other reason (target collision under a different
+          // name, or cross-project docker_name collision). Operator must
+          // intervene.
+          throw new Error(
+            `[volumes] conflict adding ${v.name}: ${text} (no existing volume by that name; check for target collision)`,
+          );
+        }
+        if (match.target !== v.target) {
+          throw new Error(
+            `[volumes] conflict adding ${v.name}: existing target "${match.target}" differs from requested "${v.target}". moor_deploy does not change mount targets; use moor_volume_remove + moor_volume_add explicitly.`,
+          );
+        }
+        // Same name, same target — idempotent re-run, tolerable.
+      }
+    }
+
     // Step 2: merge envs. Omitted env leaves existing untouched; {} is a no-op.
     const envEntries = input.env ? Object.entries(input.env) : [];
     const envProvided = envEntries.length > 0;