yontrack-mcp 1.0.0

package/build/tools/builds.test.js

@@ -0,0 +1,156 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createTestClient } from "../test/helpers.js";
+import { registerBuildTools } from "./builds.js";
+vi.mock("../client.js", () => ({
+    gqlClient: { request: vi.fn() },
+}));
+// Import after mock is hoisted
+const { gqlClient } = await import("../client.js");
+const mockRequest = gqlClient.request;
+beforeEach(() => {
+    mockRequest.mockReset();
+});
+describe("list_builds", () => {
+    it("returns builds for a branch", async () => {
+        const builds = [
+            { id: 1, name: "1.0.1", displayName: "1.0.1", description: null, creation: { user: "alice", time: "2024-01-01T00:00:00Z" } },
+        ];
+        mockRequest.mockResolvedValueOnce({ branches: [{ builds }] });
+        const client = await createTestClient(registerBuildTools);
+        const result = await client.callTool({
+            name: "list_builds",
+            arguments: { project: "myproject", branch: "main" },
+        });
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual(builds);
+    });
+    it("returns empty array when branch not found", async () => {
+        mockRequest.mockResolvedValueOnce({ branches: [] });
+        const client = await createTestClient(registerBuildTools);
+        const result = await client.callTool({
+            name: "list_builds",
+            arguments: { project: "myproject", branch: "missing" },
+        });
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual([]);
+    });
+});
+describe("find_build", () => {
+    it("returns the matching build", async () => {
+        const build = { id: 42, name: "1.0.2", displayName: "1.0.2", description: null };
+        mockRequest.mockResolvedValueOnce({ builds: [build] });
+        const client = await createTestClient(registerBuildTools);
+        const result = await client.callTool({
+            name: "find_build",
+            arguments: { project: "myproject", branch: "main", name: "1.0.2" },
+        });
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual(build);
+    });
+    it("returns null when no build matches", async () => {
+        mockRequest.mockResolvedValueOnce({ builds: [] });
+        const client = await createTestClient(registerBuildTools);
+        const result = await client.callTool({
+            name: "find_build",
+            arguments: { project: "myproject", branch: "main", name: "9.9.9" },
+        });
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toBeNull();
+    });
+});
+describe("create_build", () => {
+    it("returns the created build", async () => {
+        const build = { id: 10, name: "2.0.0", displayName: "2.0.0" };
+        mockRequest.mockResolvedValueOnce({ createBuild: { build, userErrors: [] } });
+        const client = await createTestClient(registerBuildTools);
+        const result = await client.callTool({
+            name: "create_build",
+            arguments: { project: "myproject", branch: "main", name: "2.0.0" },
+        });
+        expect(result.isError).toBeFalsy();
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual(build);
+    });
+    it("returns an error when userErrors is non-empty", async () => {
+        mockRequest.mockResolvedValueOnce({
+            createBuild: { build: null, userErrors: [{ message: "Branch not found" }] },
+        });
+        const client = await createTestClient(registerBuildTools);
+        const result = await client.callTool({
+            name: "create_build",
+            arguments: { project: "myproject", branch: "ghost", name: "2.0.0" },
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toContain("Branch not found");
+    });
+    it("is not registered when mutations are disabled", async () => {
+        const client = await createTestClient(registerBuildTools, false);
+        const { tools } = await client.listTools();
+        expect(tools.map((t) => t.name)).not.toContain("create_build");
+    });
+    it("is registered when mutations are enabled", async () => {
+        const client = await createTestClient(registerBuildTools, true);
+        const { tools } = await client.listTools();
+        expect(tools.map((t) => t.name)).toContain("create_build");
+    });
+});
+describe("get_build_duration", () => {
+    it("calculates duration in seconds from build creation to promotion", async () => {
+        mockRequest.mockResolvedValueOnce({
+            builds: [{
+                    creation: { time: "2024-01-01T10:00:00Z" },
+                    promotionRuns: [{ creation: { time: "2024-01-01T10:05:30Z" } }],
+                }],
+        });
+        const client = await createTestClient(registerBuildTools);
+        const result = await client.callTool({
+            name: "get_build_duration",
+            arguments: { project: "myproject", branch: "main", build: "1.0.1" },
+        });
+        const text = result.content[0].text;
+        const data = JSON.parse(text);
+        expect(data.durationSeconds).toBe(330); // 5m30s
+        expect(data.promoted).toBeUndefined(); // only present when not promoted
+        expect(data.promotedAt).toBe("2024-01-01T10:05:30Z");
+    });
+    it("reports not promoted when no promotion run exists", async () => {
+        mockRequest.mockResolvedValueOnce({
+            builds: [{
+                    creation: { time: "2024-01-01T10:00:00Z" },
+                    promotionRuns: [],
+                }],
+        });
+        const client = await createTestClient(registerBuildTools);
+        const result = await client.callTool({
+            name: "get_build_duration",
+            arguments: { project: "myproject", branch: "main", build: "1.0.1" },
+        });
+        const text = result.content[0].text;
+        const data = JSON.parse(text);
+        expect(data.promoted).toBe(false);
+        expect(data.durationSeconds).toBeNull();
+    });
+    it("returns an error when build not found", async () => {
+        mockRequest.mockResolvedValueOnce({ builds: [] });
+        const client = await createTestClient(registerBuildTools);
+        const result = await client.callTool({
+            name: "get_build_duration",
+            arguments: { project: "myproject", branch: "main", build: "9.9.9" },
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toContain("Build not found");
+    });
+    it("uses BRONZE as default promotion level", async () => {
+        mockRequest.mockResolvedValueOnce({
+            builds: [{ creation: { time: "2024-01-01T10:00:00Z" }, promotionRuns: [] }],
+        });
+        const client = await createTestClient(registerBuildTools);
+        await client.callTool({
+            name: "get_build_duration",
+            arguments: { project: "myproject", branch: "main", build: "1.0.1" },
+        });
+        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ promotion: "BRONZE" }));
+    });
+});

package/build/tools/graphql.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { gqlClient } from "../client.js";
+// Resolves to yontrack.graphql at the package root, both in dev (src/tools/) and built (build/tools/)
+const schemaPath = fileURLToPath(new URL("../../yontrack.graphql", import.meta.url));
+const schemaContent = readFileSync(schemaPath, "utf-8");
+export function registerGraphQLTools(server, allowMutations) {
+    server.resource("yontrack-schema", "yontrack://schema", async (uri) => ({
+        contents: [{
+                uri: uri.href,
+                text: schemaContent,
+                mimeType: "text/plain",
+            }],
+    }));
+    server.tool("graphql_query", "Execute a raw GraphQL query against the Yontrack API. Prefer this over the simpler tools whenever: (1) no existing tool covers the exact data needed, (2) the task would otherwise require calling simpler tools in a loop (N+1 pattern — e.g. fetching validation runs for each of N builds), or (3) multiple related entities can be retrieved in a single round-trip (e.g. builds with their promotion runs and build links). Read the yontrack://schema resource first to understand available types and fields.", {
+        query: z.string().describe("GraphQL query string"),
+        variables: z.record(z.unknown()).optional().describe("Query variables"),
+    }, async ({ query, variables }) => {
+        if (!allowMutations && /^\s*mutation\b/i.test(query)) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: "Mutations are disabled. Set YONTRACK_MUTATIONS_ENABLED=true to allow them." }],
+            };
+        }
+        const data = await gqlClient.request(query, variables ?? {});
+        return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        };
+    });
+}

package/build/tools/graphql.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createTestClient } from "../test/helpers.js";
+// Mock fs before the module is imported — readFileSync runs at load time
+vi.mock("node:fs", () => ({
+    readFileSync: vi.fn().mockReturnValue("type Query { hello: String }"),
+}));
+vi.mock("../client.js", () => ({
+    gqlClient: { request: vi.fn() },
+}));
+// Import after mocks are hoisted
+const { gqlClient } = await import("../client.js");
+const mockRequest = gqlClient.request;
+const { registerGraphQLTools } = await import("./graphql.js");
+beforeEach(() => {
+    mockRequest.mockReset();
+});
+describe("yontrack://schema resource", () => {
+    it("returns the schema content", async () => {
+        const client = await createTestClient(registerGraphQLTools);
+        const result = await client.readResource({ uri: "yontrack://schema" });
+        expect(result.contents).toHaveLength(1);
+        const content = result.contents[0];
+        expect(content.uri).toBe("yontrack://schema");
+        expect(content.text).toBe("type Query { hello: String }");
+    });
+});
+describe("graphql_query tool", () => {
+    it("executes a query and returns JSON result", async () => {
+        const responseData = { branches: [{ id: 1, name: "main" }] };
+        mockRequest.mockResolvedValueOnce(responseData);
+        const client = await createTestClient(registerGraphQLTools);
+        const result = await client.callTool({
+            name: "graphql_query",
+            arguments: {
+                query: "query { branches(project: \"myproject\", name: \"main\") { id name } }",
+            },
+        });
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual(responseData);
+    });
+    it("passes variables to the GraphQL client", async () => {
+        mockRequest.mockResolvedValueOnce({ builds: [] });
+        const client = await createTestClient(registerGraphQLTools);
+        await client.callTool({
+            name: "graphql_query",
+            arguments: {
+                query: "query ListBuilds($project: String!) { builds(project: $project) { id } }",
+                variables: { project: "myproject" },
+            },
+        });
+        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), { project: "myproject" });
+    });
+    it("uses empty object when variables are omitted", async () => {
+        mockRequest.mockResolvedValueOnce({ hello: "world" });
+        const client = await createTestClient(registerGraphQLTools);
+        await client.callTool({
+            name: "graphql_query",
+            arguments: { query: "query { hello }" },
+        });
+        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), {});
+    });
+    it("rejects mutation queries when mutations are disabled", async () => {
+        const client = await createTestClient(registerGraphQLTools, false);
+        const result = await client.callTool({
+            name: "graphql_query",
+            arguments: { query: "mutation CreateBuild { createBuild(input: {}) { build { id } } }" },
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toMatch(/mutations are disabled/i);
+        expect(mockRequest).not.toHaveBeenCalled();
+    });
+    it("allows mutation queries when mutations are enabled", async () => {
+        mockRequest.mockResolvedValueOnce({ createBuild: { build: { id: 1 } } });
+        const client = await createTestClient(registerGraphQLTools, true);
+        const result = await client.callTool({
+            name: "graphql_query",
+            arguments: { query: "mutation CreateBuild { createBuild(input: {}) { build { id } } }" },
+        });
+        expect(result.isError).toBeFalsy();
+    });
+});

package/build/tools/index.js

@@ -0,0 +1,23 @@
+import { mutationsEnabled } from "../config.js";
+import { registerProjectTools } from "./projects.js";
+import { registerBranchTools } from "./branches.js";
+import { registerBuildTools } from "./builds.js";
+import { registerValidationStampTools } from "./validation-stamps.js";
+import { registerValidationRunTools } from "./validation-runs.js";
+import { registerPromotionLevelTools } from "./promotion-levels.js";
+import { registerPromotionRunTools } from "./promotion-runs.js";
+import { registerBuildLinkTools } from "./build-links.js";
+import { registerSearchTools } from "./search.js";
+import { registerGraphQLTools } from "./graphql.js";
+export function registerAllTools(server) {
+    registerProjectTools(server, mutationsEnabled);
+    registerBranchTools(server, mutationsEnabled);
+    registerBuildTools(server, mutationsEnabled);
+    registerValidationStampTools(server, mutationsEnabled);
+    registerValidationRunTools(server, mutationsEnabled);
+    registerPromotionLevelTools(server, mutationsEnabled);
+    registerPromotionRunTools(server, mutationsEnabled);
+    registerBuildLinkTools(server, mutationsEnabled);
+    registerSearchTools(server);
+    registerGraphQLTools(server, mutationsEnabled);
+}

package/build/tools/projects.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { gqlClient } from "../client.js";
+const LIST_PROJECTS = `
+  query ListProjects($name: String) {
+    projects(name: $name) {
+      id
+      name
+      description
+      disabled
+    }
+  }
+`;
+const CREATE_PROJECT = `
+  mutation CreateProject($name: String!, $description: String) {
+    createProject(input: { name: $name, description: $description }) {
+      project { id name description disabled }
+      userErrors { message }
+    }
+  }
+`;
+export function registerProjectTools(server, allowMutations) {
+    server.tool("list_projects", "List all projects in Yontrack, optionally filtered by name", {
+        name: z.string().optional().describe("Filter by exact project name"),
+    }, async ({ name }) => {
+        const data = await gqlClient.request(LIST_PROJECTS, { name });
+        return {
+            content: [{ type: "text", text: JSON.stringify(data.projects, null, 2) }],
+        };
+    });
+    if (allowMutations)
+        server.tool("create_project", "Create a new project in Yontrack", {
+            name: z.string().describe("Project name"),
+            description: z.string().optional().describe("Project description"),
+        }, async ({ name, description }) => {
+            const data = await gqlClient.request(CREATE_PROJECT, { name, description });
+            const { project, userErrors } = data.createProject;
+            if (userErrors?.length) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(project, null, 2) }],
+            };
+        });
+}

package/build/tools/projects.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createTestClient } from "../test/helpers.js";
+import { registerProjectTools } from "./projects.js";
+vi.mock("../client.js", () => ({
+    gqlClient: { request: vi.fn() },
+}));
+const { gqlClient } = await import("../client.js");
+const mockRequest = gqlClient.request;
+beforeEach(() => {
+    mockRequest.mockReset();
+});
+describe("list_projects", () => {
+    it("returns all projects", async () => {
+        const projects = [
+            { id: 1, name: "myproject", description: "A project", disabled: false },
+        ];
+        mockRequest.mockResolvedValueOnce({ projects });
+        const client = await createTestClient(registerProjectTools);
+        const result = await client.callTool({ name: "list_projects", arguments: {} });
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual(projects);
+    });
+    it("returns empty array when no projects match", async () => {
+        mockRequest.mockResolvedValueOnce({ projects: [] });
+        const client = await createTestClient(registerProjectTools);
+        const result = await client.callTool({
+            name: "list_projects",
+            arguments: { name: "nonexistent" },
+        });
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual([]);
+    });
+    it("passes the name filter to the GraphQL client", async () => {
+        mockRequest.mockResolvedValueOnce({ projects: [] });
+        const client = await createTestClient(registerProjectTools);
+        await client.callTool({ name: "list_projects", arguments: { name: "foo" } });
+        expect(mockRequest).toHaveBeenCalledWith(expect.any(String), { name: "foo" });
+    });
+});
+describe("create_project", () => {
+    it("returns the created project", async () => {
+        const project = { id: 1, name: "newproject", description: "New", disabled: false };
+        mockRequest.mockResolvedValueOnce({ createProject: { project, userErrors: [] } });
+        const client = await createTestClient(registerProjectTools);
+        const result = await client.callTool({
+            name: "create_project",
+            arguments: { name: "newproject", description: "New" },
+        });
+        expect(result.isError).toBeFalsy();
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual(project);
+    });
+    it("returns an error when userErrors is non-empty", async () => {
+        mockRequest.mockResolvedValueOnce({
+            createProject: { project: null, userErrors: [{ message: "Project already exists" }] },
+        });
+        const client = await createTestClient(registerProjectTools);
+        const result = await client.callTool({
+            name: "create_project",
+            arguments: { name: "existing" },
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toContain("Project already exists");
+    });
+    it("is not registered when mutations are disabled", async () => {
+        const client = await createTestClient(registerProjectTools, false);
+        const { tools } = await client.listTools();
+        expect(tools.map((t) => t.name)).not.toContain("create_project");
+    });
+    it("is registered when mutations are enabled", async () => {
+        const client = await createTestClient(registerProjectTools, true);
+        const { tools } = await client.listTools();
+        expect(tools.map((t) => t.name)).toContain("create_project");
+    });
+});

package/build/tools/promotion-levels.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { gqlClient } from "../client.js";
+import { config } from "../config.js";
+import { resolveBranchId } from "../utils.js";
+const LIST_PROMOTION_LEVELS = `
+  query ListPromotionLevels($project: String!, $branch: String!) {
+    branches(project: $project, name: $branch) {
+      promotionLevels {
+        id
+        name
+        description
+        image
+      }
+    }
+  }
+`;
+const CREATE_PROMOTION_LEVEL = `
+  mutation CreatePromotionLevelById(
+    $branchId: Int!
+    $name: String!
+    $description: String!
+  ) {
+    createPromotionLevelById(input: {
+      branchId: $branchId
+      name: $name
+      description: $description
+    }) {
+      promotionLevel { id name description branch { id name } }
+      userErrors { message }
+    }
+  }
+`;
+export function registerPromotionLevelTools(server, allowMutations) {
+    server.tool("list_promotion_levels", "List all promotion levels for a branch", {
+        project: z.string().describe("Project name"),
+        branch: z.string().describe("Branch name"),
+    }, async ({ project, branch }) => {
+        const data = await gqlClient.request(LIST_PROMOTION_LEVELS, { project, branch });
+        const levels = data.branches?.[0]?.promotionLevels ?? [];
+        return {
+            content: [{ type: "text", text: JSON.stringify(levels, null, 2) }],
+        };
+    });
+    server.tool("get_promotion_level_image", "Fetch the PNG image for a promotion level. Returns an image if the promotion level has one, or an error text if it does not.", {
+        promotionLevelId: z.number().int().describe("Numeric ID of the promotion level"),
+    }, async ({ promotionLevelId }) => {
+        const url = `${config.YONTRACK_URL}/rest/structure/promotionLevels/${promotionLevelId}/image`;
+        const response = await fetch(url, {
+            headers: { "X-Ontrack-Token": config.YONTRACK_TOKEN },
+        });
+        if (!response.ok) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `No image available for promotion level ${promotionLevelId} (HTTP ${response.status})` }],
+            };
+        }
+        const buffer = await response.arrayBuffer();
+        const base64 = Buffer.from(buffer).toString("base64");
+        return {
+            content: [{ type: "image", data: base64, mimeType: "image/png" }],
+        };
+    });
+    if (allowMutations)
+        server.tool("create_promotion_level", "Create a new promotion level on a branch", {
+            project: z.string().describe("Project name"),
+            branch: z.string().describe("Branch name"),
+            name: z.string().describe("Promotion level name (e.g. 'GOLD', 'SILVER')"),
+            description: z.string().optional().default("").describe("Description"),
+        }, async ({ project, branch, name, description }) => {
+            const branchId = await resolveBranchId(project, branch);
+            const data = await gqlClient.request(CREATE_PROMOTION_LEVEL, { branchId, name, description });
+            const { promotionLevel, userErrors } = data.createPromotionLevelById;
+            if (userErrors?.length) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(promotionLevel, null, 2) }],
+            };
+        });
+}

package/build/tools/promotion-levels.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createTestClient } from "../test/helpers.js";
+import { registerPromotionLevelTools } from "./promotion-levels.js";
+vi.mock("../client.js", () => ({
+    gqlClient: { request: vi.fn() },
+}));
+vi.mock("../utils.js", () => ({
+    resolveBranchId: vi.fn().mockResolvedValue(42),
+}));
+vi.mock("../config.js", () => ({
+    config: { YONTRACK_URL: "https://yontrack.example.com", YONTRACK_TOKEN: "test-token" },
+    mutationsEnabled: false,
+    oauthConfig: null,
+}));
+const { gqlClient } = await import("../client.js");
+const mockRequest = gqlClient.request;
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+beforeEach(() => {
+    mockRequest.mockReset();
+    mockFetch.mockReset();
+});
+describe("list_promotion_levels", () => {
+    it("returns promotion levels for a branch", async () => {
+        const levels = [
+            { id: 1, name: "BRONZE", description: "Bronze level" },
+            { id: 2, name: "SILVER", description: "Silver level" },
+        ];
+        mockRequest.mockResolvedValueOnce({ branches: [{ promotionLevels: levels }] });
+        const client = await createTestClient(registerPromotionLevelTools);
+        const result = await client.callTool({
+            name: "list_promotion_levels",
+            arguments: { project: "myproject", branch: "main" },
+        });
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual(levels);
+    });
+    it("returns empty array when branch not found", async () => {
+        mockRequest.mockResolvedValueOnce({ branches: [] });
+        const client = await createTestClient(registerPromotionLevelTools);
+        const result = await client.callTool({
+            name: "list_promotion_levels",
+            arguments: { project: "myproject", branch: "missing" },
+        });
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual([]);
+    });
+});
+describe("get_promotion_level_image", () => {
+    it("returns base64-encoded PNG image when available", async () => {
+        const pngBytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47]); // PNG magic bytes
+        const expectedBase64 = Buffer.from(pngBytes).toString("base64");
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            arrayBuffer: () => Promise.resolve(pngBytes.buffer),
+        });
+        const client = await createTestClient(registerPromotionLevelTools);
+        const result = await client.callTool({
+            name: "get_promotion_level_image",
+            arguments: { promotionLevelId: 1 },
+        });
+        expect(result.isError).toBeFalsy();
+        const item = result.content[0];
+        expect(item.type).toBe("image");
+        expect(item.mimeType).toBe("image/png");
+        expect(item.data).toBe(expectedBase64);
+        expect(mockFetch).toHaveBeenCalledWith("https://yontrack.example.com/rest/structure/promotionLevels/1/image", { headers: { "X-Ontrack-Token": "test-token" } });
+    });
+    it("returns error when image is not found", async () => {
+        mockFetch.mockResolvedValueOnce({ ok: false, status: 404 });
+        const client = await createTestClient(registerPromotionLevelTools);
+        const result = await client.callTool({
+            name: "get_promotion_level_image",
+            arguments: { promotionLevelId: 99 },
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toContain("99");
+        expect(text).toContain("404");
+    });
+});
+describe("create_promotion_level", () => {
+    it("returns the created promotion level", async () => {
+        const level = { id: 3, name: "GOLD", description: "Gold level", branch: { id: 42, name: "main" } };
+        mockRequest.mockResolvedValueOnce({ createPromotionLevelById: { promotionLevel: level, userErrors: [] } });
+        const client = await createTestClient(registerPromotionLevelTools);
+        const result = await client.callTool({
+            name: "create_promotion_level",
+            arguments: { project: "myproject", branch: "main", name: "GOLD", description: "Gold level" },
+        });
+        expect(result.isError).toBeFalsy();
+        const text = result.content[0].text;
+        expect(JSON.parse(text)).toEqual(level);
+    });
+    it("returns an error when userErrors is non-empty", async () => {
+        mockRequest.mockResolvedValueOnce({
+            createPromotionLevelById: { promotionLevel: null, userErrors: [{ message: "Promotion level already exists" }] },
+        });
+        const client = await createTestClient(registerPromotionLevelTools);
+        const result = await client.callTool({
+            name: "create_promotion_level",
+            arguments: { project: "myproject", branch: "main", name: "BRONZE" },
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toContain("Promotion level already exists");
+    });
+    it("is not registered when mutations are disabled", async () => {
+        const client = await createTestClient(registerPromotionLevelTools, false);
+        const { tools } = await client.listTools();
+        expect(tools.map((t) => t.name)).not.toContain("create_promotion_level");
+    });
+    it("is registered when mutations are enabled", async () => {
+        const client = await createTestClient(registerPromotionLevelTools, true);
+        const { tools } = await client.listTools();
+        expect(tools.map((t) => t.name)).toContain("create_promotion_level");
+    });
+});