@moor-sh/mcp 0.20.0 → 0.22.0

package/package.json

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

@@ -1174,6 +1174,15 @@ server.registerTool(
         .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.",
         ),
+      source_credential_id: z
+        .number()
+        .int()
+        .positive()
+        .nullable()
+        .optional()
+        .describe(
+          "For github_url projects: pin the source credential row (from moor_source_credential_add) the build path should use. Build synthesizes the credentialed clone URL in memory; the secret is never stored on the project. Ignored when docker_image is set; save-time validation is structural only (id exists).",
+        ),
     }),
   },
   async (input) => {
@@ -1254,6 +1263,15 @@ server.registerTool(
         .describe(
           "Max CPU cores (fractional OK; min 0.001). Pass null to clear. Max host core count. Takes effect on container recreate.",
         ),
+      source_credential_id: z
+        .number()
+        .int()
+        .positive()
+        .nullable()
+        .optional()
+        .describe(
+          "Pin (or unlink, by passing null) the source credential the build path should use for this github_url project. Switching to docker_image force-clears the id regardless of input. Save-time validation is structural only; host-mismatch / not-active is enforced at build time.",
+        ),
     }),
   },
   async (input) => {
@@ -1879,6 +1897,15 @@ server.registerTool(
         .describe(
           "Env vars to MERGE into existing project envs. Omit to leave envs untouched. Pass {} for an explicit no-op. Use moor_env_delete to remove keys.",
         ),
+      source_credential_id: z
+        .number()
+        .int()
+        .positive()
+        .nullable()
+        .optional()
+        .describe(
+          "For github_url projects: pin the source credential row (created via moor_source_credential_add). Build path synthesizes the credentialed clone URL in memory; secret never gets stored on the project row. Pass null to detach without switching source type. Ignored when docker_image is set. Save-time validation is structural only (id exists); host-mismatch / not-active is enforced at build time so configuration can survive transient credential outages.",
+        ),
       run: z
         .boolean()
         .optional()
@@ -1978,6 +2005,7 @@ server.registerTool(
         restart_policy: input.restart_policy,
         memory_limit_mb: input.memory_limit_mb,
         cpus: input.cpus,
+        source_credential_id: input.source_credential_id,
       };
       const res = await apiPost("/api/projects", createBody);
       if (!res.ok) throw new Error(`[create] ${await res.text()}`);
@@ -1997,6 +2025,8 @@ server.registerTool(
       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 (input.source_credential_id !== undefined)
+        updateBody.source_credential_id = input.source_credential_id;
 
       if (Object.keys(updateBody).length > 0) {
         const res = await apiPut(`/api/projects/${existing.id}`, updateBody);
@@ -2442,6 +2472,290 @@ server.registerTool(
   },
 );
 
+// --- Source credentials (HTTPS PATs for private Git repos) ---
+//
+// v1 ships HTTPS PATs only. Read paths return metadata + secret.kind;
+// the raw token only crosses MCP on `add` and `update`. Delete uses
+// confirm_label since (hostname, label) is the disambiguation key
+// (multiple github.com rows coexist by design). The check tool runs a
+// real `git ls-remote` inside moor to validate access before any
+// deploy commits state.
+
+type SourceCredentialMetadata = {
+  id: number;
+  hostname: string;
+  label: string;
+  username: string;
+  secret: {
+    configured: true;
+    kind: "github_classic_pat" | "github_fine_grained_pat" | "unknown";
+  };
+  state: "active" | "failed";
+  expires_at: string | null;
+  last_checked_at: string | null;
+  last_check_status: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+function renderSourceCredentialLine(c: SourceCredentialMetadata): string {
+  const checked = c.last_check_status ? ` last_check=${c.last_check_status}` : "";
+  return `id=${c.id} ${c.hostname} label=${c.label} user=${c.username} kind=${c.secret.kind} state=${c.state}${checked}`;
+}
+
+server.registerTool(
+  "moor_source_credentials_list",
+  {
+    title: "List Source Credentials",
+    description:
+      "List all stored Git source credentials (HTTPS PATs). Returns metadata only - the raw secret value is never returned by any read path. Multiple credentials can share a hostname (e.g. two github.com rows for different orgs); use label to disambiguate.",
+  },
+  async () => {
+    const res = await apiGet("/api/server/source-credentials");
+    if (!res.ok) throw new Error(`Failed: ${res.status} ${await res.text()}`);
+    const data = (await res.json()) as { rows: SourceCredentialMetadata[] };
+    const text =
+      data.rows.length === 0
+        ? "No source credentials configured. Public repos work anonymously."
+        : data.rows.map(renderSourceCredentialLine).join("\n");
+    return {
+      content: [{ type: "text", text }],
+      structuredContent: { rows: data.rows },
+    };
+  },
+);
+
+server.registerTool(
+  "moor_source_credential_get",
+  {
+    title: "Get Source Credential",
+    description:
+      "Get a single source credential by id. Returns metadata only. Use this before moor_source_credential_delete to confirm the label you intend to delete.",
+    inputSchema: z.object({
+      id: z.number().int().positive().describe("Credential id (from moor_source_credentials_list)"),
+    }),
+  },
+  async ({ id }) => {
+    const res = await apiGet(`/api/server/source-credentials/${id}`);
+    if (res.status === 404) throw new Error(`source credential id=${id} not found`);
+    if (!res.ok) throw new Error(`Failed: ${res.status} ${await res.text()}`);
+    const row = (await res.json()) as SourceCredentialMetadata;
+    return {
+      content: [{ type: "text", text: renderSourceCredentialLine(row) }],
+      structuredContent: row as unknown as Record<string, unknown>,
+    };
+  },
+);
+
+server.registerTool(
+  "moor_source_credential_add",
+  {
+    title: "Add Source Credential",
+    description:
+      "Store a Git source credential (HTTPS PAT) for a private repo host. v1 supports HTTPS PATs only; SSH deploy keys may be added in a future version. Hostname must be the bare host as parsed from a Git URL (github.com, gitlab.com, etc.) - no scheme, no path. Multiple credentials can share a hostname; the (hostname, label) pair is unique. For GitHub: use a fine-grained PAT with `Contents: read` (username `x-access-token`), or a classic PAT with `repo` scope. Note: the secret value passes through the MCP client and tool-call transport on input, same security model as moor_env_set.",
+    inputSchema: z.object({
+      hostname: z
+        .string()
+        .describe("Bare Git host: github.com, gitlab.com, etc. No scheme, no path."),
+      label: z
+        .string()
+        .describe(
+          "Operator-supplied label for disambiguation when multiple credentials share a host (e.g. 'personal', 'work-org', 'acme-clients'). Trimmed at storage.",
+        ),
+      username: z
+        .string()
+        .describe(
+          "Git username. For GitHub fine-grained PATs, use 'x-access-token'. For classic PATs, your GitHub username works too.",
+        ),
+      secret: z
+        .string()
+        .describe(
+          "Git token (PAT). Visible to the MCP client on input; rotate via moor_source_credential_update if exposed.",
+        ),
+      expires_at: z
+        .string()
+        .nullable()
+        .optional()
+        .describe(
+          "Operator-supplied expiry timestamp (PAT expiry from GitHub). Optional; helps rotation reminders.",
+        ),
+    }),
+  },
+  async ({ hostname, label, username, secret, expires_at }) => {
+    const body: Record<string, unknown> = { hostname, label, username, secret };
+    if (expires_at !== undefined) body.expires_at = expires_at;
+    const res = await apiPost("/api/server/source-credentials", body);
+    if (!res.ok) throw new Error(`Failed: ${res.status} ${await res.text()}`);
+    const row = (await res.json()) as SourceCredentialMetadata;
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Added source credential for ${row.hostname} label="${row.label}" (id=${row.id}, kind=${row.secret.kind}).`,
+        },
+      ],
+      structuredContent: row as unknown as Record<string, unknown>,
+    };
+  },
+);
+
+server.registerTool(
+  "moor_source_credential_update",
+  {
+    title: "Update Source Credential",
+    description:
+      "Rotate username, secret, label, or expires_at on an existing source credential. Hostname is intentionally not patchable - changing the lookup key on an existing row would silently break in-flight builds. To change hostname, delete and recreate. Requires at least one of username, secret, label, or expires_at.",
+    inputSchema: z.object({
+      id: z.number().int().positive().describe("Credential id to update"),
+      username: z.string().optional().describe("New username (optional)"),
+      secret: z
+        .string()
+        .optional()
+        .describe("New secret (optional). Visible to the MCP client on input."),
+      label: z.string().optional().describe("New label (optional). Trimmed at storage."),
+      expires_at: z.string().nullable().optional().describe("New expiry; null to clear"),
+    }),
+  },
+  async ({ id, username, secret, label, expires_at }) => {
+    if (
+      username === undefined &&
+      secret === undefined &&
+      label === undefined &&
+      expires_at === undefined
+    ) {
+      throw new Error("must provide at least one of username, secret, label, or expires_at");
+    }
+    const patch: Record<string, unknown> = {};
+    if (username !== undefined) patch.username = username;
+    if (secret !== undefined) patch.secret = secret;
+    if (label !== undefined) patch.label = label;
+    if (expires_at !== undefined) patch.expires_at = expires_at;
+    const res = await apiPut(`/api/server/source-credentials/${id}`, patch);
+    if (res.status === 404) throw new Error(`source credential id=${id} not found`);
+    if (!res.ok) throw new Error(`Failed: ${res.status} ${await res.text()}`);
+    const row = (await res.json()) as SourceCredentialMetadata;
+    const fields: string[] = [];
+    if (username !== undefined) fields.push("username");
+    if (secret !== undefined) fields.push("secret");
+    if (label !== undefined) fields.push("label");
+    if (expires_at !== undefined) fields.push("expires_at");
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Updated source credential id=${id} (${row.hostname}, ${row.label}): rotated ${fields.join(" + ")}. kind=${row.secret.kind}.`,
+        },
+      ],
+      structuredContent: row as unknown as Record<string, unknown>,
+    };
+  },
+);
+
+server.registerTool(
+  "moor_source_credential_delete",
+  {
+    title: "Delete Source Credential",
+    description:
+      "Delete a stored source credential. Requires confirm_label to match the resolved row's label exactly - protects against deleting the wrong credential on a host that has several (e.g. two github.com rows). Refused with credential_in_use if any project still references this credential. Irreversible.",
+    inputSchema: z.object({
+      id: z.number().int().positive().describe("Credential id to delete"),
+      confirm_label: z
+        .string()
+        .describe(
+          "Must equal the credential row's label exactly. Resolved via moor_source_credential_get and compared before deletion.",
+        ),
+    }),
+  },
+  async ({ id, confirm_label }) => {
+    const getRes = await apiGet(`/api/server/source-credentials/${id}`);
+    if (getRes.status === 404) throw new Error(`source credential id=${id} not found`);
+    if (!getRes.ok)
+      throw new Error(`Failed to fetch credential: ${getRes.status} ${await getRes.text()}`);
+    const row = (await getRes.json()) as SourceCredentialMetadata;
+    if (confirm_label !== row.label) {
+      throw new Error(
+        `confirm_label "${confirm_label}" does not match resolved label "${row.label}". Refusing to delete.`,
+      );
+    }
+    const delRes = await apiDelete(
+      `/api/server/source-credentials/${id}?confirm_label=${encodeURIComponent(row.label)}`,
+    );
+    if (delRes.status === 409) {
+      const body = (await delRes.json()) as { projects: string[] };
+      throw new Error(
+        `credential_in_use: ${body.projects.length} project(s) still reference id=${id}: ${body.projects.join(", ")}`,
+      );
+    }
+    if (!delRes.ok) throw new Error(`Failed to delete: ${delRes.status} ${await delRes.text()}`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Deleted source credential ${row.hostname}/${row.label} (id=${id}).`,
+        },
+      ],
+      structuredContent: { deleted: { id, hostname: row.hostname, label: row.label } },
+    };
+  },
+);
+
+server.registerTool(
+  "moor_source_credential_check",
+  {
+    title: "Check Source Credential Access",
+    description:
+      "Run a real `git ls-remote` against the repo URL to verify access. Without source_credential_id, probes anonymously first; if private and exactly one credential matches the host, auto-selects it. With source_credential_id, tests that exact credential. With branch, tests the specific branch (branch_not_found is distinct from auth failure). Discovers default_branch via HEAD symref when no branch is provided. Side effect: updates last_checked_at and last_check_status on the credential row; flips state to failed on a credentialed rejection.",
+    inputSchema: z.object({
+      github_url: z
+        .string()
+        .describe(
+          "HTTPS Git repo URL: https://host/owner/repo (optional .git). No query, no fragment, no embedded credentials.",
+        ),
+      branch: z
+        .string()
+        .optional()
+        .describe("Specific branch to verify. Omit to discover the default branch."),
+      source_credential_id: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Pin a specific credential. Required when multiple credentials match the host."),
+    }),
+  },
+  async ({ github_url, branch, source_credential_id }) => {
+    const body: Record<string, unknown> = { github_url };
+    if (branch !== undefined) body.branch = branch;
+    if (source_credential_id !== undefined) body.source_credential_id = source_credential_id;
+    const res = await apiPost("/api/server/source-credentials/check", body);
+    const json = (await res.json()) as Record<string, unknown>;
+    if (res.ok) {
+      const def = json.default_branch ? ` default_branch=${json.default_branch}` : "";
+      const head = json.head_sha ? ` head_sha=${String(json.head_sha).slice(0, 12)}` : "";
+      const auto = json.auto_selected_credential_id
+        ? ` auto_selected=${json.auto_selected_credential_id}`
+        : "";
+      return {
+        content: [{ type: "text", text: `reachable${def}${head}${auto}` }],
+        structuredContent: json,
+      };
+    }
+    // Non-OK: surface the structured failure shape directly. The agent
+    // can branch on `code` to decide what to do next (ask for a PAT,
+    // pick from candidates, etc.).
+    return {
+      content: [
+        {
+          type: "text",
+          text: `check failed: code=${json.code}${json.reason ? ` reason=${json.reason}` : ""}`,
+        },
+      ],
+      structuredContent: json,
+      isError: true,
+    };
+  },
+);
+
 function formatMs(ms: number): string {
   if (ms < 1000) return `${ms}ms`;
   const s = Math.floor(ms / 1000);