@moor-sh/mcp 0.5.0 → 0.6.0

package/package.json

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

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import { McpServer, StdioServerTransport } from "@modelcontextprotocol/server";
 import { z } from "zod";
+import { tailUtf8 } from "./tail-utf8";
 
 // --- Config ---
 
@@ -571,6 +572,21 @@ 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()
+        .positive()
+        .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.",
+        ),
     }),
   },
   async (input) => {
@@ -592,7 +608,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
@@ -609,6 +625,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()
+        .positive()
+        .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) => {
@@ -887,6 +920,23 @@ 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()
+        .positive()
+        .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.",
+        ),
       env: z
         .record(z.string(), z.string())
         .optional()
@@ -964,6 +1014,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()}`);
@@ -981,6 +1033,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);
@@ -1087,12 +1141,22 @@ server.registerTool(
   {
     title: "Get Async Exec Status",
     description:
-      "Return the current state of an async exec run: state, exit code (when finished), running tail of stdout/stderr (last 64 KiB each), total bytes seen, duration, and any error message. State is one of: running, exited, stopped, timed_out, error.",
+      "Return the current state of an async exec run: state, exit code (when finished), running tail of stdout/stderr (default 8 KiB each inline; the API stores up to 64 KiB), total bytes seen, duration, and any error message. State is one of: running, exited, stopped, timed_out, error. Pass tail_bytes to control how many bytes of each stream are returned inline (0 to 65536; default 8192). The API's 64 KiB-per-stream storage cap is unchanged — tail_bytes only controls what the MCP tool returns to keep responses under typical agent token limits.",
     inputSchema: z.object({
       run_id: z.number().int().positive().describe("Run ID returned by moor_exec_async"),
+      tail_bytes: z
+        .number()
+        .int()
+        .min(0)
+        .max(65_536)
+        .optional()
+        .describe(
+          "Max bytes of each stream (stdout, stderr) returned inline. Default 8192. Max 65536 (the API storage cap). Set to 0 for metadata-only.",
+        ),
     }),
   },
-  async ({ run_id }) => {
+  async ({ run_id, tail_bytes }) => {
+    const cap = tail_bytes ?? 8192;
     const res = await apiGet(`/api/exec/${run_id}`);
     if (res.status === 404) throw new Error(`run_id ${run_id} not found`);
     if (!res.ok) throw new Error(`Failed: ${await res.text()}`);
@@ -1119,30 +1183,42 @@ server.registerTool(
     lines.push(`command: ${data.command}`);
     if (data.killed_pid) lines.push(`killed_pid: ${data.killed_pid}`);
     if (data.error_message) lines.push(`error: ${data.error_message}`);
-    if (data.stdout) {
-      const note =
-        data.stdout_total_bytes > data.stdout.length
-          ? ` (tail of ${data.stdout_total_bytes} bytes)`
-          : "";
-      lines.push(`stdout${note}:`);
-      lines.push(data.stdout);
-    } else if (data.stdout_total_bytes > 0) {
-      lines.push(`stdout_total_bytes=${data.stdout_total_bytes}`);
-    }
-    if (data.stderr) {
-      const note =
-        data.stderr_total_bytes > data.stderr.length
-          ? ` (tail of ${data.stderr_total_bytes} bytes)`
-          : "";
-      lines.push(`stderr${note}:`);
-      lines.push(data.stderr);
-    } else if (data.stderr_total_bytes > 0) {
-      lines.push(`stderr_total_bytes=${data.stderr_total_bytes}`);
-    }
+    appendStream(lines, "stdout", data.stdout, data.stdout_total_bytes, cap);
+    appendStream(lines, "stderr", data.stderr, data.stderr_total_bytes, cap);
     return { content: [{ type: "text", text: lines.join("\n") }] };
   },
 );
 
+function appendStream(
+  lines: string[],
+  name: string,
+  raw: string,
+  totalBytes: number,
+  cap: number,
+): void {
+  if (!raw && totalBytes === 0) return;
+  if (!raw) {
+    // API returned an empty string but the stream did emit data (totalBytes > 0
+    // is possible when no bytes survived API-side tail cap, though unlikely).
+    lines.push(`${name}_total_bytes=${totalBytes}`);
+    return;
+  }
+  const { tail, storedBytes, trimmed: mcpTrimmed } = tailUtf8(raw, cap);
+  const apiTrimmed = totalBytes > storedBytes;
+  let header: string;
+  if (mcpTrimmed && apiTrimmed) {
+    header = `${name} (showing last ${tail.length} chars of ${storedBytes} stored bytes; ${totalBytes} total bytes seen):`;
+  } else if (mcpTrimmed) {
+    header = `${name} (showing last ${tail.length} chars of ${storedBytes} total bytes):`;
+  } else if (apiTrimmed) {
+    header = `${name} (tail of ${storedBytes} stored from ${totalBytes} total bytes seen):`;
+  } else {
+    header = `${name}:`;
+  }
+  lines.push(header);
+  if (cap > 0) lines.push(tail);
+}
+
 server.registerTool(
   "moor_exec_stop",
   {

package/src/tail-utf8.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import { tailUtf8 } from "./tail-utf8";
+
+describe("tailUtf8", () => {
+  test("returns the string unchanged when under maxBytes", () => {
+    const r = tailUtf8("hello", 100);
+    expect(r.tail).toBe("hello");
+    expect(r.storedBytes).toBe(5);
+    expect(r.trimmed).toBe(false);
+  });
+
+  test("returns the last maxBytes bytes for ASCII input", () => {
+    const r = tailUtf8("0123456789", 4);
+    expect(r.tail).toBe("6789");
+    expect(r.storedBytes).toBe(10);
+    expect(r.trimmed).toBe(true);
+  });
+
+  test("returns an empty string when maxBytes is 0", () => {
+    const r = tailUtf8("hello", 0);
+    expect(r.tail).toBe("");
+    expect(r.storedBytes).toBe(5);
+    expect(r.trimmed).toBe(true);
+  });
+
+  test("preserves complete trailing multi-byte codepoints", () => {
+    // "café" = c(1) a(1) f(1) é(2) = 5 bytes. Cap at 4 → trim "c", landing
+    // on "a" boundary; result "afé" (4 bytes).
+    const r = tailUtf8("café", 4);
+    expect(r.tail).toBe("afé");
+    expect(r.storedBytes).toBe(5);
+    expect(r.trimmed).toBe(true);
+    expect(r.tail).not.toContain("\ufffd");
+  });
+
+  test("aligns to a codepoint boundary when the cut falls inside a 2-byte sequence", () => {
+    // "héllo" = h(1) é(2) l(1) l(1) o(1) = 6 bytes. Cap at 4 → start at
+    // byte 2, which is the continuation of é. Align forward to "llo" (3 bytes).
+    const r = tailUtf8("héllo", 4);
+    expect(r.tail).toBe("llo");
+    expect(r.storedBytes).toBe(6);
+    expect(r.tail).not.toContain("\ufffd");
+  });
+
+  test("aligns to a codepoint boundary inside a 3-byte sequence", () => {
+    // "€€€" = 9 bytes (each € = 3 bytes). Cap at 4 → start at byte 5, which
+    // is a continuation. Align forward to start of last € → "€" (3 bytes).
+    const r = tailUtf8("€€€", 4);
+    expect(r.tail).toBe("€");
+    expect(r.storedBytes).toBe(9);
+    expect(r.tail).not.toContain("\ufffd");
+  });
+
+  test("aligns inside a 4-byte sequence (surrogate pair codepoint)", () => {
+    // "🌍🌍" = 8 bytes (each emoji = 4 bytes). Cap at 5 → start at byte 3,
+    // continuation. Align forward to start of last emoji → "🌍" (4 bytes).
+    const r = tailUtf8("🌍🌍", 5);
+    expect(r.tail).toBe("🌍");
+    expect(r.storedBytes).toBe(8);
+    expect(r.tail).not.toContain("\ufffd");
+  });
+
+  test("reports storedBytes as the original UTF-8 byte length, not JS char length", () => {
+    // "🌍" is 1 codepoint but 4 UTF-8 bytes (and 2 UTF-16 code units in JS).
+    const r = tailUtf8("🌍", 100);
+    expect(r.storedBytes).toBe(4);
+    expect(r.tail.length).toBe(2); // JS string length counts UTF-16 code units
+  });
+});

package/src/tail-utf8.ts

@@ -0,0 +1,25 @@
+// Byte-aware UTF-8 tail-trim used by moor_exec_status (#44). The MCP tool
+// can't return the full API tail (up to 64 KiB per stream) inline because
+// large responses blow agent token budgets. Caller picks how many bytes per
+// stream they want; the trim is UTF-8 safe — the result never starts mid-
+// codepoint, which would cause TextDecoder to emit U+FFFD at the head.
+
+export function tailUtf8(
+  s: string,
+  maxBytes: number,
+): { tail: string; storedBytes: number; trimmed: boolean } {
+  const bytes = new TextEncoder().encode(s);
+  const storedBytes = bytes.length;
+  if (storedBytes <= maxBytes) return { tail: s, storedBytes, trimmed: false };
+  if (maxBytes === 0) return { tail: "", storedBytes, trimmed: true };
+  // Start at the offset that leaves maxBytes bytes; walk forward past any
+  // UTF-8 continuation bytes (10xxxxxx) so the decoded tail begins on a
+  // codepoint boundary.
+  let start = storedBytes - maxBytes;
+  while (start < storedBytes && (bytes[start] & 0xc0) === 0x80) start++;
+  return {
+    tail: new TextDecoder("utf-8", { fatal: false }).decode(bytes.subarray(start)),
+    storedBytes,
+    trimmed: true,
+  };
+}