yontrack-mcp 1.14.1 → 1.14.2

package/build/graphql-documents.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { buildSchema, parse, validate } from "graphql";
+// Validates every GraphQL document sent by the server against the schema snapshots,
+// so that a field the Yontrack server does not expose fails here rather than at runtime.
+const root = (path) => fileURLToPath(new URL(`../${path}`, import.meta.url));
+const schemas = {
+    v5: buildSchema(readFileSync(root("yontrack-v5.graphql"), "utf-8")),
+    v6: buildSchema(readFileSync(root("yontrack-v6.graphql"), "utf-8")),
+};
+// Yontrack 6 only: never sent to a v5 server (see docs/adr/0001-agent-context-tools-v6-only.md)
+const V6_ONLY = new Set(["src/tools/agent-context.ts", "src/tools/agent-context-support.ts"]);
+// Known invalid documents, as "version file NAME": these must be fixed, then removed from here
+const KNOWN_INVALID = new Set([
+    // search(type:) is required on v5, but the `search` tool sends it only when given
+    "v5 src/tools/search.ts SEARCH",
+]);
+const sourceFiles = [
+    "src/capabilities.ts",
+    "src/utils.ts",
+    ...readdirSync(root("src/tools"))
+        .filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts"))
+        .map((f) => `src/tools/${f}`),
+];
+/** `const NAME = \`...\`` constants holding a query or mutation, with `${OTHER}` constants inlined. */
+function documentsOf(file) {
+    const source = readFileSync(root(file), "utf-8");
+    const constants = new Map();
+    for (const [, name, text] of source.matchAll(/const (\w+) = `([^`]*)`;/g))
+        constants.set(name, text);
+    const inline = (text) => text.replace(/\$\{(\w+)\}/g, (match, name) => (constants.has(name) ? inline(constants.get(name)) : match));
+    return [...constants]
+        .map(([name, text]) => ({ name, text: inline(text) }))
+        .filter(({ text }) => /^\s*(query|mutation)\b/.test(text));
+}
+const cases = sourceFiles.flatMap((file) => documentsOf(file).flatMap(({ name, text }) => (V6_ONLY.has(file) ? ["v6"] : ["v5", "v6"]).map((version) => ({
+    file, name, text, version, known: KNOWN_INVALID.has(`${version} ${file} ${name}`),
+}))));
+describe("GraphQL documents", () => {
+    it("finds the documents to validate", () => {
+        const names = cases.map((c) => c.name);
+        expect(names).toContain("CREATE_VALIDATION_RUN");
+        expect(names).toContain("PROMOTE_BUILD");
+        expect(names).toContain("READINESS");
+    });
+    it.each(cases.filter((c) => !c.known))("$file $name is valid against the $version schema", ({ text, version }) => {
+        const errors = validate(schemas[version], parse(text)).map((e) => e.message);
+        expect(errors).toEqual([]);
+    });
+    it.each(cases.filter((c) => c.known))("$file $name is still a known issue against the $version schema", ({ text, version }) => {
+        expect(validate(schemas[version], parse(text))).not.toEqual([]);
+    });
+});

package/build/tools/branches.js

@@ -20,7 +20,7 @@ const CREATE_BRANCH = `
       description: $description
     }) {
       branch { id name displayName description disabled project { id name } }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -41,11 +41,11 @@ export function registerBranchTools(server, allowMutations) {
             description: z.string().optional().describe("Branch description"),
         }, async ({ project, name, description }) => {
             const data = await gqlClient.request(CREATE_BRANCH, { projectName: project, name, description });
-            const { branch, userErrors } = data.createBranch;
-            if (userErrors?.length) {
+            const { branch, errors } = data.createBranch;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/branches.test.js

@@ -46,7 +46,7 @@ describe("list_branches", () => {
 describe("create_branch", () => {
     it("returns the created branch", async () => {
         const branch = { id: 10, name: "feature-x", displayName: "feature-x", description: "My feature", disabled: false };
-        mockRequest.mockResolvedValueOnce({ createBranch: { branch, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createBranch: { branch, errors: [] } });
         const client = await createTestClient(registerBranchTools);
         const result = await client.callTool({
             name: "create_branch",
@@ -56,9 +56,9 @@ describe("create_branch", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(branch);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createBranch: { branch: null, userErrors: [{ message: "Branch already exists" }] },
+            createBranch: { branch: null, errors: [{ message: "Branch already exists" }] },
         });
         const client = await createTestClient(registerBranchTools);
         const result = await client.callTool({

package/build/tools/build-links.js

@@ -31,7 +31,7 @@ const SET_BUILD_LINKS = `
       fromBuild: $fromBuild
       links: $links
     }) {
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -59,11 +59,11 @@ export function registerBuildLinkTools(server, allowMutations) {
             links: z.array(BuildLinkInput).describe("Target builds to link to"),
         }, async ({ fromProject, fromBuild, links }) => {
             const data = await gqlClient.request(SET_BUILD_LINKS, { fromProject, fromBuild, links });
-            const { userErrors } = data.linksBuild;
-            if (userErrors?.length) {
+            const { errors } = data.linksBuild;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/build-links.test.js

@@ -40,7 +40,7 @@ describe("get_build_links", () => {
 });
 describe("set_build_links", () => {
     it("returns success message when links are set", async () => {
-        mockRequest.mockResolvedValueOnce({ linksBuild: { userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ linksBuild: { errors: [] } });
         const client = await createTestClient(registerBuildLinkTools);
         const result = await client.callTool({
             name: "set_build_links",
@@ -54,9 +54,9 @@ describe("set_build_links", () => {
         const text = result.content[0].text;
         expect(text).toContain("updated successfully");
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            linksBuild: { userErrors: [{ message: "Build not found" }] },
+            linksBuild: { errors: [{ message: "Build not found" }] },
         });
         const client = await createTestClient(registerBuildLinkTools);
         const result = await client.callTool({

package/build/tools/builds.js

@@ -50,7 +50,7 @@ const CREATE_BUILD = `
       description: $description
     }) {
       build { id name displayName description branch { id name displayName project { id name } } }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -85,11 +85,11 @@ export function registerBuildTools(server, allowMutations) {
             description: z.string().optional().describe("Build description"),
         }, async ({ project, branch, name, description }) => {
             const data = await gqlClient.request(CREATE_BUILD, { project, branch, name, description });
-            const { build, userErrors } = data.createBuild;
-            if (userErrors?.length) {
+            const { build, errors } = data.createBuild;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/builds.test.js

@@ -61,7 +61,7 @@ describe("find_build", () => {
 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: [] } });
+        mockRequest.mockResolvedValueOnce({ createBuild: { build, errors: [] } });
         const client = await createTestClient(registerBuildTools);
         const result = await client.callTool({
             name: "create_build",
@@ -71,9 +71,9 @@ describe("create_build", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(build);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createBuild: { build: null, userErrors: [{ message: "Branch not found" }] },
+            createBuild: { build: null, errors: [{ message: "Branch not found" }] },
         });
         const client = await createTestClient(registerBuildTools);
         const result = await client.callTool({

package/build/tools/projects.js

@@ -14,7 +14,7 @@ const CREATE_PROJECT = `
   mutation CreateProject($name: String!, $description: String) {
     createProject(input: { name: $name, description: $description }) {
       project { id name description disabled }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -33,11 +33,11 @@ export function registerProjectTools(server, allowMutations) {
             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) {
+            const { project, errors } = data.createProject;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/projects.test.js

@@ -40,7 +40,7 @@ describe("list_projects", () => {
 describe("create_project", () => {
     it("returns the created project", async () => {
         const project = { id: 1, name: "newproject", description: "New", disabled: false };
-        mockRequest.mockResolvedValueOnce({ createProject: { project, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createProject: { project, errors: [] } });
         const client = await createTestClient(registerProjectTools);
         const result = await client.callTool({
             name: "create_project",
@@ -50,9 +50,9 @@ describe("create_project", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(project);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createProject: { project: null, userErrors: [{ message: "Project already exists" }] },
+            createProject: { project: null, errors: [{ message: "Project already exists" }] },
         });
         const client = await createTestClient(registerProjectTools);
         const result = await client.callTool({

package/build/tools/promotion-levels.js

@@ -26,7 +26,7 @@ const CREATE_PROMOTION_LEVEL = `
       description: $description
     }) {
       promotionLevel { id name description branch { id name } }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -69,11 +69,11 @@ export function registerPromotionLevelTools(server, allowMutations) {
         }, 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) {
+            const { promotionLevel, errors } = data.createPromotionLevelById;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

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

@@ -83,7 +83,7 @@ describe("get_promotion_level_image", () => {
 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: [] } });
+        mockRequest.mockResolvedValueOnce({ createPromotionLevelById: { promotionLevel: level, errors: [] } });
         const client = await createTestClient(registerPromotionLevelTools);
         const result = await client.callTool({
             name: "create_promotion_level",
@@ -93,9 +93,9 @@ describe("create_promotion_level", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(level);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createPromotionLevelById: { promotionLevel: null, userErrors: [{ message: "Promotion level already exists" }] },
+            createPromotionLevelById: { promotionLevel: null, errors: [{ message: "Promotion level already exists" }] },
         });
         const client = await createTestClient(registerPromotionLevelTools);
         const result = await client.callTool({

package/build/tools/promotion-runs.js

@@ -38,7 +38,7 @@ const PROMOTE_BUILD = `
         creation { user time }
         promotionLevel { id name }
       }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -64,11 +64,11 @@ export function registerPromotionRunTools(server, allowMutations) {
             description: z.string().optional().describe("Optional description"),
         }, async ({ project, branch, build, promotion, description }) => {
             const data = await gqlClient.request(PROMOTE_BUILD, { project, branch, build, promotion, description });
-            const { promotionRun, userErrors } = data.createPromotionRun;
-            if (userErrors?.length) {
+            const { promotionRun, errors } = data.createPromotionRun;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

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

@@ -46,7 +46,7 @@ describe("get_promotion_runs", () => {
 describe("promote_build", () => {
     it("returns the created promotion run", async () => {
         const run = { id: 5, description: null, creation: { user: "alice", time: "2024-01-01T00:00:00Z" }, promotionLevel: { id: 1, name: "BRONZE" } };
-        mockRequest.mockResolvedValueOnce({ createPromotionRun: { promotionRun: run, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createPromotionRun: { promotionRun: run, errors: [] } });
         const client = await createTestClient(registerPromotionRunTools);
         const result = await client.callTool({
             name: "promote_build",
@@ -56,9 +56,9 @@ describe("promote_build", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(run);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createPromotionRun: { promotionRun: null, userErrors: [{ message: "Build not found" }] },
+            createPromotionRun: { promotionRun: null, errors: [{ message: "Build not found" }] },
         });
         const client = await createTestClient(registerPromotionRunTools);
         const result = await client.callTool({
@@ -69,6 +69,20 @@ describe("promote_build", () => {
         const text = result.content[0].text;
         expect(text).toContain("Build not found");
     });
+    it("returns the agent policy refusal as an error", async () => {
+        const refusal = "agent x[agent] may not promote to GOLD: GOLD is reserved to humans (agent policy)";
+        mockRequest.mockResolvedValueOnce({
+            createPromotionRun: { promotionRun: null, errors: [{ message: refusal }] },
+        });
+        const client = await createTestClient(registerPromotionRunTools);
+        const result = await client.callTool({
+            name: "promote_build",
+            arguments: { project: "myproject", branch: "main", build: "1.0.1", promotion: "GOLD" },
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].text;
+        expect(text).toBe(refusal);
+    });
     it("is not registered when mutations are disabled", async () => {
         const client = await createTestClient(registerPromotionRunTools, false);
         const { tools } = await client.listTools();

package/build/tools/validation-runs.js

@@ -42,7 +42,7 @@ const CREATE_VALIDATION_RUN = `
         runOrder
         lastStatus { statusID { id name } }
       }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -79,11 +79,11 @@ export function registerValidationRunTools(server, allowMutations) {
                 status,
                 description,
             });
-            const { validationRun, userErrors } = data.createValidationRun;
-            if (userErrors?.length) {
+            const { validationRun, errors } = data.createValidationRun;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/validation-runs.test.js

@@ -46,7 +46,7 @@ describe("get_validation_runs", () => {
 describe("create_validation_run", () => {
     it("returns the created validation run", async () => {
         const run = { id: 10, runOrder: 1, lastStatus: { statusID: { id: "PASSED", name: "Passed" } } };
-        mockRequest.mockResolvedValueOnce({ createValidationRun: { validationRun: run, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createValidationRun: { validationRun: run, errors: [] } });
         const client = await createTestClient(registerValidationRunTools);
         const result = await client.callTool({
             name: "create_validation_run",
@@ -56,9 +56,9 @@ describe("create_validation_run", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(run);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createValidationRun: { validationRun: null, userErrors: [{ message: "Validation stamp not found" }] },
+            createValidationRun: { validationRun: null, errors: [{ message: "Validation stamp not found" }] },
         });
         const client = await createTestClient(registerValidationRunTools);
         const result = await client.callTool({

package/build/tools/validation-stamps.js

@@ -24,7 +24,7 @@ const CREATE_VALIDATION_STAMP = `
       description: $description
     }) {
       validationStamp { id name description }
-      userErrors { message }
+      errors { message }
     }
   }
 `;
@@ -49,11 +49,11 @@ export function registerValidationStampTools(server, allowMutations) {
         }, async ({ project, branch, name, description }) => {
             const branchId = await resolveBranchId(project, branch);
             const data = await gqlClient.request(CREATE_VALIDATION_STAMP, { branchId, name, description });
-            const { validationStamp, userErrors } = data.createValidationStampById;
-            if (userErrors?.length) {
+            const { validationStamp, errors } = data.createValidationStampById;
+            if (errors?.length) {
                 return {
                     isError: true,
-                    content: [{ type: "text", text: userErrors.map((e) => e.message).join(", ") }],
+                    content: [{ type: "text", text: errors.map((e) => e.message).join(", ") }],
                 };
             }
             return {

package/build/tools/validation-stamps.test.js

@@ -40,7 +40,7 @@ describe("list_validation_stamps", () => {
 describe("create_validation_stamp", () => {
     it("returns the created validation stamp", async () => {
         const stamp = { id: 5, name: "SECURITY", description: "Security scan" };
-        mockRequest.mockResolvedValueOnce({ createValidationStampById: { validationStamp: stamp, userErrors: [] } });
+        mockRequest.mockResolvedValueOnce({ createValidationStampById: { validationStamp: stamp, errors: [] } });
         const client = await createTestClient(registerValidationStampTools);
         const result = await client.callTool({
             name: "create_validation_stamp",
@@ -50,9 +50,9 @@ describe("create_validation_stamp", () => {
         const text = result.content[0].text;
         expect(JSON.parse(text)).toEqual(stamp);
     });
-    it("returns an error when userErrors is non-empty", async () => {
+    it("returns an error when errors is non-empty", async () => {
         mockRequest.mockResolvedValueOnce({
-            createValidationStampById: { validationStamp: null, userErrors: [{ message: "Stamp already exists" }] },
+            createValidationStampById: { validationStamp: null, errors: [{ message: "Stamp already exists" }] },
         });
         const client = await createTestClient(registerValidationStampTools);
         const result = await client.callTool({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yontrack-mcp",
-  "version": "1.14.1",
+  "version": "1.14.2",
   "description": "MCP server for Yontrack (Ontrack CI/CD monitoring platform)",
   "repository": {
     "type": "git",
@@ -34,6 +34,7 @@
     "@semantic-release/git": "^10.0.1",
     "@types/express": "^5.0.6",
     "@types/node": "^22.0.0",
+    "graphql": "^16.14.2",
     "semantic-release": "^24.2.9",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0",