@moor-sh/mcp 0.1.1 → 0.3.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@moor-sh/mcp",
-  "version": "0.1.1",
+  "version": "0.3.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": {
     "type": "git",
-    "url": "https://github.com/caiopizzol/moor.git",
+    "url": "git+https://github.com/caiopizzol/moor.git",
     "directory": "packages/mcp"
   },
   "homepage": "https://github.com/caiopizzol/moor/tree/main/packages/mcp",

package/src/index.ts

@@ -73,6 +73,13 @@ async function apiPut(path: string, body: unknown) {
   });
 }
 
+async function apiDelete(path: string) {
+  return fetch(`${baseUrl}${path}`, {
+    method: "DELETE",
+    headers: headers(),
+  });
+}
+
 type Project = {
   id: number;
   name: string;
@@ -127,6 +134,142 @@ async function readSSE(res: Response): Promise<{ logs: string; error?: string }>
   return { logs, error };
 }
 
+// --- Validators ---
+
+/** Validate that a string is a github.com URL. Throws with a clear message on failure.
+ *  Stricter than apps/api/routes/docker.ts:validateGithubUrl, which accepts any host
+ *  ending in "github.com" (so "evilgithub.com" slips through). MCP rejects that and
+ *  surfaces the error at create/update time, not at first build/run. */
+function validateGithubUrl(url: string): void {
+  let host: string;
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    throw new Error(`github_url is not a valid URL: ${url}`);
+  }
+  if (host !== "github.com" && !host.endsWith(".github.com")) {
+    throw new Error(`github_url must be a github.com URL (got hostname "${host}")`);
+  }
+}
+
+/** Strict GitHub repo URL validator used by moor_deploy. Stricter than
+ *  validateGithubUrl: requires host = github.com or www.github.com AND a path of
+ *  exactly /owner/repo (with optional .git suffix, optional trailing slash).
+ *  Rejects gist.github.com, the bare root, and /owner/repo/tree/... extras.
+ *  Failed deploys trigger an actual image build/pull, so the up-front check is
+ *  worth being pickier than the create/update wrappers. */
+function validateGithubRepoUrl(url: string): void {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`github_url is not a valid URL: ${url}`);
+  }
+  // The downstream build path (apps/api/docker.ts:buildImage) appends ".git" and a
+  // branch ref to whatever URL we forward, so a non-http protocol, query string, or
+  // fragment quietly mangles the resulting git remote. Reject those up front.
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new Error(`github_url must use http or https (got protocol "${parsed.protocol}")`);
+  }
+  if (parsed.search) {
+    throw new Error(`github_url must not contain query parameters (got "${parsed.search}")`);
+  }
+  if (parsed.hash) {
+    throw new Error(`github_url must not contain a URL fragment (got "${parsed.hash}")`);
+  }
+  const host = parsed.hostname;
+  if (host !== "github.com" && host !== "www.github.com") {
+    throw new Error(`github_url must use github.com or www.github.com (got "${host}")`);
+  }
+  if (!/^\/[^/]+\/[^/]+?(\.git)?\/?$/.test(parsed.pathname)) {
+    throw new Error(
+      `github_url must point to /owner/repo (with optional .git); got "${parsed.pathname}"`,
+    );
+  }
+}
+
+/** Validate a 5-field crontab schedule against what apps/api/cron.ts can actually execute.
+ *  Stricter than the scheduler's permissive parser: the scheduler silently never fires
+ *  on bad input, so MCP rejects up-front. Returns an error string or null. */
+const CRON_FIELDS: ReadonlyArray<{ name: string; min: number; max: number }> = [
+  { name: "minute", min: 0, max: 59 },
+  { name: "hour", min: 0, max: 23 },
+  { name: "day-of-month", min: 1, max: 31 },
+  { name: "month", min: 1, max: 12 },
+  { name: "day-of-week", min: 0, max: 6 }, // 0=Sunday; scheduler does not translate 7
+];
+
+// Whitelist each comma-separated part against one of the canonical forms below.
+// Anything else (empty parts, leading "-", bare "N/S", "/S", stray characters) is
+// rejected. The scheduler at apps/api/cron.ts silently ignores or mis-parses these
+// inputs, so the validator must be strict where the scheduler is loose.
+const CRON_PART_PATTERNS = [
+  /^\*$/, // *
+  /^(\d+)$/, // N
+  /^(\d+)-(\d+)$/, // A-B
+  /^\*\/(\d+)$/, // */S
+  /^(\d+)-(\d+)\/(\d+)$/, // A-B/S
+];
+
+function validateCronField(field: string, min: number, max: number, name: string): string | null {
+  if (field === "*") return null;
+  if (/[?LW#]/i.test(field)) return `${name}: ?, L, W, # are not supported`;
+  if (/[a-zA-Z]/.test(field))
+    return `${name}: month/day names are not supported, use numeric values`;
+
+  for (const part of field.split(",")) {
+    if (part === "") return `${name}: empty list element`;
+
+    const match = CRON_PART_PATTERNS.map((re) => part.match(re)).find((m) => m !== null);
+    if (!match) return `${name}: invalid expression "${part}"`;
+
+    // Validate captured numbers against per-field bounds and step positivity.
+    // Capture layout depends on which pattern matched, identified by length.
+    const groups = match.slice(1);
+    if (groups.length === 1 && match[0].startsWith("*/")) {
+      // */S
+      const step = Number(groups[0]);
+      if (step <= 0) return `${name}: step must be a positive integer (got "${groups[0]}")`;
+    } else if (groups.length === 1) {
+      // N
+      const n = Number(groups[0]);
+      if (n < min || n > max) return `${name}: ${n} out of bounds [${min}-${max}]`;
+    } else if (groups.length === 2) {
+      // A-B
+      const a = Number(groups[0]);
+      const b = Number(groups[1]);
+      if (a < min || b > max) return `${name}: range ${a}-${b} out of bounds [${min}-${max}]`;
+      if (a > b) return `${name}: range ${a}-${b} is descending`;
+    } else if (groups.length === 3) {
+      // A-B/S
+      const a = Number(groups[0]);
+      const b = Number(groups[1]);
+      const step = Number(groups[2]);
+      if (a < min || b > max) return `${name}: range ${a}-${b} out of bounds [${min}-${max}]`;
+      if (a > b) return `${name}: range ${a}-${b} is descending`;
+      if (step <= 0) return `${name}: step must be a positive integer (got "${groups[2]}")`;
+    }
+  }
+  return null;
+}
+
+function validateCronSchedule(schedule: string): string | null {
+  const parts = schedule.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    return `schedule must have exactly 5 space-separated fields (got ${parts.length})`;
+  }
+  for (let i = 0; i < 5; i++) {
+    const err = validateCronField(
+      parts[i],
+      CRON_FIELDS[i].min,
+      CRON_FIELDS[i].max,
+      CRON_FIELDS[i].name,
+    );
+    if (err) return err;
+  }
+  return null;
+}
+
 // --- MCP Server ---
 
 const server = new McpServer({
@@ -340,6 +483,531 @@ server.registerTool(
   },
 );
 
+server.registerTool(
+  "moor_project_get",
+  {
+    title: "Get Project",
+    description:
+      "Returns the full record for a project (source, branch, dockerfile, domain, status, container id, restart policy).",
+    inputSchema: z.object({
+      project: z.string().describe("Project name or ID"),
+    }),
+  },
+  async ({ project }) => {
+    const p = await resolveProject(project);
+    return { content: [{ type: "text", text: JSON.stringify(p, null, 2) }] };
+  },
+);
+
+server.registerTool(
+  "moor_project_create",
+  {
+    title: "Create Project",
+    description:
+      "Creates a new project. Provide exactly one of github_url or docker_image. Does not build or start; call moor_rebuild (or moor_deploy in a future release) to bring it up.",
+    inputSchema: z.object({
+      name: z
+        .string()
+        .regex(
+          /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/,
+          "name must start with an alphanumeric character; allowed chars: a-z, A-Z, 0-9, _, -",
+        )
+        .describe("Project name (used as the container name suffix: moor-<name>)"),
+      github_url: z
+        .string()
+        .optional()
+        .describe("github.com URL; mutually exclusive with docker_image"),
+      docker_image: z
+        .string()
+        .optional()
+        .describe("Docker image reference (e.g. nginx:latest); mutually exclusive with github_url"),
+      branch: z.string().optional().describe("Git branch (default: main, for github_url projects)"),
+      dockerfile: z
+        .string()
+        .optional()
+        .describe("Dockerfile path within the repo (default: Dockerfile)"),
+      domain: z.string().optional().describe("Public domain to route to this container via Caddy"),
+      domain_port: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Container port Caddy should forward to (required if domain is set)"),
+      restart_policy: z
+        .enum(["no", "on-failure", "always", "unless-stopped"])
+        .optional()
+        .describe("Docker restart policy (default: unless-stopped)"),
+    }),
+  },
+  async (input) => {
+    const sources = (input.github_url ? 1 : 0) + (input.docker_image ? 1 : 0);
+    if (sources !== 1) {
+      throw new Error("Provide exactly one of github_url or docker_image");
+    }
+    if (input.github_url) validateGithubUrl(input.github_url);
+
+    const res = await apiPost("/api/projects", input);
+    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) }] };
+  },
+);
+
+server.registerTool(
+  "moor_project_update",
+  {
+    title: "Update Project",
+    description:
+      "Updates project metadata. Does NOT rebuild or restart the container. Domain or domain_port changes apply to Caddy immediately.",
+    inputSchema: z.object({
+      project: z.string().describe("Project name or ID to update"),
+      name: z
+        .string()
+        .regex(
+          /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/,
+          "name must start alphanumeric; allowed: a-z A-Z 0-9 _ -",
+        )
+        .optional(),
+      github_url: z.string().optional(),
+      docker_image: z.string().optional(),
+      branch: z.string().optional(),
+      dockerfile: z.string().optional(),
+      domain: z.string().optional(),
+      domain_port: z.number().int().positive().optional(),
+      restart_policy: z.enum(["no", "on-failure", "always", "unless-stopped"]).optional(),
+    }),
+  },
+  async (input) => {
+    const { project, ...updates } = input;
+    if (Object.keys(updates).length === 0) {
+      throw new Error("Provide at least one field to update");
+    }
+    if (updates.github_url && updates.docker_image) {
+      throw new Error("Cannot set both github_url and docker_image in the same update");
+    }
+    if (updates.github_url) validateGithubUrl(updates.github_url);
+
+    const p = await resolveProject(project);
+    const res = await apiPut(`/api/projects/${p.id}`, updates);
+    if (!res.ok) throw new Error(`Failed to update project: ${await res.text()}`);
+    const updated = await res.json();
+    return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
+  },
+);
+
+server.registerTool(
+  "moor_project_delete",
+  {
+    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.",
+    inputSchema: z.object({
+      project: z.string().describe("Project name or ID to delete"),
+      confirm_name: z
+        .string()
+        .describe(
+          "Must equal the resolved project's name. Guards against deleting the wrong project.",
+        ),
+    }),
+  },
+  async ({ project, confirm_name }) => {
+    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}).` }] };
+  },
+);
+
+server.registerTool(
+  "moor_cron_create",
+  {
+    title: "Create Cron",
+    description:
+      "Creates a cron schedule on a project. Schedule is a 5-field crontab string with numeric values only (no jan/sun/etc.). Day-of-week uses 0=Sunday through 6=Saturday; 7 is not accepted.",
+    inputSchema: z.object({
+      project: z.string().describe("Project name or ID"),
+      name: z.string().min(1).describe("Human-readable name for the cron"),
+      schedule: z.string().describe('5-field crontab, e.g. "0 3 * * *" for 03:00 daily'),
+      command: z.string().min(1).describe("Shell command to run inside the project's container"),
+    }),
+  },
+  async ({ project, name, schedule, command }) => {
+    const err = validateCronSchedule(schedule);
+    if (err) throw new Error(`Invalid schedule: ${err}`);
+    const p = await resolveProject(project);
+    const res = await apiPost(`/api/projects/${p.id}/crons`, { name, schedule, command });
+    if (!res.ok) throw new Error(`Failed to create cron: ${await res.text()}`);
+    const cron = await res.json();
+    return { content: [{ type: "text", text: JSON.stringify(cron, null, 2) }] };
+  },
+);
+
+server.registerTool(
+  "moor_cron_update",
+  {
+    title: "Update Cron",
+    description: "Updates a cron's fields by id. Schedule is validated if provided.",
+    inputSchema: z.object({
+      cron_id: z.number().int().positive().describe("Cron ID"),
+      name: z.string().min(1).optional(),
+      schedule: z.string().optional(),
+      command: z.string().min(1).optional(),
+      enabled: z.boolean().optional().describe("Enable or disable the cron"),
+    }),
+  },
+  async ({ cron_id, name, schedule, command, enabled }) => {
+    if (schedule !== undefined) {
+      const err = validateCronSchedule(schedule);
+      if (err) throw new Error(`Invalid schedule: ${err}`);
+    }
+    const body: Record<string, unknown> = {};
+    if (name !== undefined) body.name = name;
+    if (schedule !== undefined) body.schedule = schedule;
+    if (command !== undefined) body.command = command;
+    if (enabled !== undefined) body.enabled = enabled ? 1 : 0;
+    if (Object.keys(body).length === 0) {
+      throw new Error("Provide at least one field to update");
+    }
+    const res = await apiPut(`/api/crons/${cron_id}`, body);
+    if (!res.ok) throw new Error(`Failed to update cron: ${await res.text()}`);
+    const cron = await res.json();
+    return { content: [{ type: "text", text: JSON.stringify(cron, null, 2) }] };
+  },
+);
+
+server.registerTool(
+  "moor_cron_delete",
+  {
+    title: "Delete Cron",
+    description: "Deletes a cron by id.",
+    inputSchema: z.object({
+      cron_id: z.number().int().positive().describe("Cron ID"),
+    }),
+  },
+  async ({ cron_id }) => {
+    const res = await apiDelete(`/api/crons/${cron_id}`);
+    if (!res.ok) throw new Error(`Failed to delete cron: ${await res.text()}`);
+    // API returns 204 whether or not the row existed; phrase the response so it
+    // doesn't claim a row was removed when it might already have been gone.
+    return { content: [{ type: "text", text: `Deletion requested for cron ${cron_id}.` }] };
+  },
+);
+
+server.registerTool(
+  "moor_cron_run",
+  {
+    title: "Run Cron Now",
+    description:
+      "Triggers a cron to run immediately. Requires the project's container to be running.",
+    inputSchema: z.object({
+      cron_id: z.number().int().positive().describe("Cron ID"),
+    }),
+  },
+  async ({ cron_id }) => {
+    const res = await apiPost(`/api/crons/${cron_id}/run`);
+    if (!res.ok) {
+      const text = await res.text();
+      let message = text;
+      try {
+        const parsed = JSON.parse(text);
+        if (parsed?.error) message = parsed.error;
+      } catch {
+        // Not JSON; use raw text
+      }
+      throw new Error(message);
+    }
+    return { content: [{ type: "text", text: `Triggered cron ${cron_id}.` }] };
+  },
+);
+
+server.registerTool(
+  "moor_env_delete",
+  {
+    title: "Delete Environment Variables",
+    description:
+      "Removes one or more environment variables from a project. Restarts the container only if at least one key was actually deleted AND the project was running.",
+    inputSchema: z.object({
+      project: z.string().describe("Project name or ID"),
+      keys: z.array(z.string().min(1)).min(1).describe("Env var keys to remove"),
+    }),
+  },
+  async ({ project, keys }) => {
+    const p = await resolveProject(project);
+
+    const existingRes = await apiGet(`/api/projects/${p.id}/envs`);
+    if (!existingRes.ok) throw new Error(`Failed to get envs: ${existingRes.status}`);
+    const existing = (await existingRes.json()) as { key: string; value: string }[];
+    const existingKeys = new Set(existing.map((v) => v.key));
+
+    const toDelete = keys.filter((k) => existingKeys.has(k));
+    const missing = keys.filter((k) => !existingKeys.has(k));
+
+    if (toDelete.length === 0) {
+      const existingList = [...existingKeys].sort().join(", ") || "(none)";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No matching keys on ${p.name}. Existing keys: ${existingList}`,
+          },
+        ],
+      };
+    }
+
+    for (const key of toDelete) {
+      const res = await apiDelete(`/api/projects/${p.id}/envs/${encodeURIComponent(key)}`);
+      if (!res.ok) throw new Error(`Failed to delete ${key}: ${await res.text()}`);
+    }
+
+    let text = `Deleted ${toDelete.join(", ")} from ${p.name}.`;
+    if (missing.length > 0) text += ` (Not present: ${missing.join(", ")}.)`;
+
+    if (p.status === "running") {
+      await apiPost(`/api/projects/${p.id}/stop`);
+      const startRes = await apiPost(`/api/projects/${p.id}/start`);
+      if (!startRes.ok) {
+        throw new Error(`Deleted vars but failed to restart: ${await startRes.text()}`);
+      }
+      text += " Container restarted.";
+    }
+
+    return { content: [{ type: "text", text }] };
+  },
+);
+
+server.registerTool(
+  "moor_dns_check",
+  {
+    title: "Check Domain DNS",
+    description:
+      "Resolves a domain's A record and reports whether it matches the server's public IP. Useful before pointing a project's domain at the server.",
+    inputSchema: z.object({
+      domain: z.string().min(1).describe("Domain to check, e.g. app.example.com"),
+    }),
+  },
+  async ({ domain }) => {
+    const res = await apiPost("/api/dns-check", { domain });
+    if (!res.ok) throw new Error(`Failed: ${await res.text()}`);
+    const data = (await res.json()) as {
+      resolves: boolean;
+      ip: string | null;
+      serverIp: string | null;
+    };
+    const lines = [
+      `Domain: ${domain}`,
+      `Resolves: ${data.resolves ? "yes" : "no"}`,
+      `Resolved IP: ${data.ip ?? "(none)"}`,
+      `Server IP: ${data.serverIp ?? "(unknown)"}`,
+    ];
+    if (data.ip && data.serverIp) {
+      lines.push(`Match: ${data.ip === data.serverIp ? "yes" : "no"}`);
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
+server.registerTool(
+  "moor_deploy",
+  {
+    title: "Deploy Project",
+    description:
+      "Create-or-update a project end to end: metadata, env vars (merged into existing), and an optional build/run. Default fails if the project already exists; pass update_existing: true to upsert. When run: true (default), waits for the full Docker build/pull and start, which can take minutes for large images. Errors are tagged by the failing step ([create], [update], [set_env], or [run]) and do not roll back earlier steps.",
+    inputSchema: z.object({
+      name: z
+        .string()
+        .regex(
+          /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/,
+          "name must start alphanumeric; allowed chars: a-z A-Z 0-9 _ -",
+        )
+        .describe("Project name (also the container suffix: moor-<name>)"),
+      github_url: z
+        .string()
+        .optional()
+        .describe(
+          "GitHub repo URL: host must be github.com or www.github.com, path must be /owner/repo (optional .git). Mutually exclusive with docker_image.",
+        ),
+      docker_image: z
+        .string()
+        .optional()
+        .describe(
+          "Docker image reference (e.g. nginx:latest). Mutually exclusive with github_url.",
+        ),
+      branch: z.string().optional().describe("Git branch (API default: main)"),
+      dockerfile: z
+        .string()
+        .optional()
+        .describe("Dockerfile path in the repo (API default: Dockerfile)"),
+      domain: z.string().optional().describe("Public domain to route via Caddy"),
+      domain_port: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Container port Caddy should forward to"),
+      restart_policy: z
+        .enum(["no", "on-failure", "always", "unless-stopped"])
+        .optional()
+        .describe("Docker restart policy (API default: unless-stopped)"),
+      env: z
+        .record(z.string(), z.string())
+        .optional()
+        .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.",
+        ),
+      run: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe(
+          "Build/pull and start after create/update. Default true. Setting false leaves the container untouched; if envs changed while the container is running, the change will not apply until the next run/restart.",
+        ),
+      update_existing: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Allow updating a project that already exists. Default false (create-only)."),
+    }),
+  },
+  async (input) => {
+    // Up-front validation: do strict checks before any side effects.
+    if (input.github_url) validateGithubRepoUrl(input.github_url);
+    if (input.github_url && input.docker_image) {
+      throw new Error("Cannot set both github_url and docker_image");
+    }
+
+    // Resolve existence and check domain conflicts from a single project list.
+    const listRes = await apiGet("/api/projects");
+    if (!listRes.ok) throw new Error(`Failed to list projects: ${listRes.status}`);
+    const projects = (await listRes.json()) as Project[];
+    const existing = projects.find((p) => p.name === input.name);
+
+    if (existing && !input.update_existing) {
+      throw new Error(
+        `Project "${input.name}" already exists. Pass update_existing: true to update it.`,
+      );
+    }
+
+    if (!existing) {
+      const sources = (input.github_url ? 1 : 0) + (input.docker_image ? 1 : 0);
+      if (sources !== 1) {
+        throw new Error("Provide exactly one of github_url or docker_image");
+      }
+    }
+
+    // Normalize once for both the conflict check and the write. The API trims but
+    // does not lowercase, so " Example.com " vs an existing "example.com" would
+    // slip past the raw-string pre-check and only surface as a Caddy collision.
+    const normalizedDomain =
+      input.domain === undefined ? undefined : input.domain.trim().toLowerCase() || null;
+
+    if (normalizedDomain) {
+      const conflict = projects.find(
+        (p) =>
+          p.domain && p.domain.trim().toLowerCase() === normalizedDomain && p.id !== existing?.id,
+      );
+      if (conflict) {
+        throw new Error(
+          `Domain "${normalizedDomain}" is already used by project "${conflict.name}" (id=${conflict.id}). Refusing before Caddy reload.`,
+        );
+      }
+    }
+
+    // Step 1: create or update project metadata.
+    let projectId: number;
+    let projectName: string;
+    if (!existing) {
+      const createBody: Record<string, unknown> = {
+        name: input.name,
+        github_url: input.github_url,
+        docker_image: input.docker_image,
+        branch: input.branch,
+        dockerfile: input.dockerfile,
+        domain: normalizedDomain,
+        domain_port: input.domain_port,
+        restart_policy: input.restart_policy,
+      };
+      const res = await apiPost("/api/projects", createBody);
+      if (!res.ok) throw new Error(`[create] ${await res.text()}`);
+      const created = (await res.json()) as Project;
+      projectId = created.id;
+      projectName = created.name;
+    } else {
+      // Update only fields explicitly provided. `name` is the lookup key here,
+      // not a rename target; use moor_project_update for renames.
+      const updateBody: Record<string, unknown> = {};
+      if (input.github_url !== undefined) updateBody.github_url = input.github_url;
+      if (input.docker_image !== undefined) updateBody.docker_image = input.docker_image;
+      if (input.branch !== undefined) updateBody.branch = input.branch;
+      if (input.dockerfile !== undefined) updateBody.dockerfile = input.dockerfile;
+      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 (Object.keys(updateBody).length > 0) {
+        const res = await apiPut(`/api/projects/${existing.id}`, updateBody);
+        if (!res.ok) throw new Error(`[update] ${await res.text()}`);
+      }
+      projectId = existing.id;
+      projectName = existing.name;
+    }
+
+    // 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;
+    if (envProvided) {
+      const existingRes = await apiGet(`/api/projects/${projectId}/envs`);
+      if (!existingRes.ok) {
+        throw new Error(`[set_env] Failed to read envs: ${existingRes.status}`);
+      }
+      const existingEnvs = (await existingRes.json()) as { key: string; value: string }[];
+      const merged = new Map(existingEnvs.map((v) => [v.key, v.value]));
+      for (const [k, v] of envEntries) merged.set(k, v);
+      const allVars = Array.from(merged, ([key, value]) => ({ key, value }));
+      const putRes = await apiPut(`/api/projects/${projectId}/envs`, allVars);
+      if (!putRes.ok) throw new Error(`[set_env] ${await putRes.text()}`);
+    }
+
+    // Step 3: run, default true. Wait for the full SSE stream like moor_rebuild.
+    let runLogs = "";
+    if (input.run) {
+      const runRes = await apiPost(`/api/projects/${projectId}/run`);
+      if (!runRes.ok) throw new Error(`[run] ${await runRes.text()}`);
+      const { logs, error } = await readSSE(runRes);
+      runLogs = logs;
+      if (error) throw new Error(`[run] ${error}`);
+    }
+
+    const lines: string[] = [];
+    lines.push(
+      existing
+        ? `Updated project ${projectName} (id=${projectId}).`
+        : `Created project ${projectName} (id=${projectId}).`,
+    );
+    if (envProvided) {
+      lines.push(
+        `Merged ${envEntries.length} env var(s): ${envEntries.map(([k]) => k).join(", ")}.`,
+      );
+    }
+    if (!input.run) {
+      if (envProvided && existing?.status === "running") {
+        lines.push(
+          "Note: project is running; env changes will not take effect until the next run or restart.",
+        );
+      }
+    } else {
+      lines.push("");
+      lines.push("Build/run output:");
+      lines.push(runLogs || "(no output)");
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  },
+);
+
 // --- Start ---
 
 const transport = new StdioServerTransport();