@zereight/mcp-gitlab 2.1.70 → 2.2.1

package/build/test/utils/bulk-publish-options.test.js

@@ -1,32 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { buildBulkPublishDraftNotesBody, needsGitLab19_2BulkPublish, } from "../../utils/bulk-publish-options.js";
-describe("When buildBulkPublishDraftNotesBody runs", () => {
-    describe("with no-op defaults", () => {
-        test("should omit internal false and empty note", () => {
-            assert.deepEqual(buildBulkPublishDraftNotesBody({ internal: false, note: "" }), {});
-        });
-    });
-    describe("with meaningful 19.2 fields", () => {
-        test("should keep reviewer_state, note, and internal true", () => {
-            assert.deepEqual(buildBulkPublishDraftNotesBody({
-                reviewer_state: "reviewed",
-                note: "LGTM",
-                internal: true,
-            }), { reviewer_state: "reviewed", note: "LGTM", internal: true });
-        });
-    });
-});
-describe("When needsGitLab19_2BulkPublish runs", () => {
-    describe("with an empty body", () => {
-        test("should return false", () => {
-            assert.equal(needsGitLab19_2BulkPublish({}), false);
-            assert.equal(needsGitLab19_2BulkPublish(buildBulkPublishDraftNotesBody({ internal: false })), false);
-        });
-    });
-    describe("with a non-empty body", () => {
-        test("should return true", () => {
-            assert.equal(needsGitLab19_2BulkPublish({ reviewer_state: "reviewed" }), true);
-        });
-    });
-});

package/build/test/utils/download-token.test.js

@@ -1,35 +0,0 @@
-import { describe, test } from "node:test";
-import assert from "node:assert";
-import { createDownloadToken, decryptDownloadToken } from "../../utils/download-token.js";
-describe("download token helpers", () => {
-    test("round-trips auth, api URL, and resource binding", () => {
-        const token = createDownloadToken("Authorization", "Bearer glpat-example-token", "https://gitlab.example.com/api/v4", {
-            type: "attachment",
-            params: { project_id: "group/project", secret: "abc", filename: "file.txt" },
-        });
-        const decrypted = decryptDownloadToken(token);
-        assert.deepStrictEqual(decrypted, {
-            header: "Authorization",
-            token: "Bearer glpat-example-token",
-            apiUrl: "https://gitlab.example.com/api/v4",
-            resourceType: "attachment",
-            resourceParams: { project_id: "group/project", secret: "abc", filename: "file.txt" },
-        });
-    });
-    test("returns null for invalid tokens", () => {
-        assert.strictEqual(decryptDownloadToken("not-a-valid-token"), null);
-    });
-    test("returns null for expired tokens", () => {
-        const originalNow = Date.now;
-        const issuedAt = 1_700_000_000_000;
-        try {
-            Date.now = () => issuedAt;
-            const token = createDownloadToken("Private-Token", "glpat-example-token");
-            Date.now = () => issuedAt + 301_000;
-            assert.strictEqual(decryptDownloadToken(token), null);
-        }
-        finally {
-            Date.now = originalNow;
-        }
-    });
-});

package/build/test/utils/forwarded-public-base-url.test.js

@@ -1,46 +0,0 @@
-import { describe, test } from "node:test";
-import assert from "node:assert";
-import { getForwardedPublicBaseUrl, getForwardedRequestHost } from "../../utils/forwarded-public-base-url.js";
-function req(headers) {
-    return { headers };
-}
-describe("getForwardedPublicBaseUrl", () => {
-    test("returns undefined unless proxy headers are trusted", () => {
-        assert.strictEqual(getForwardedPublicBaseUrl(req({ "x-forwarded-proto": "https", "x-forwarded-host": "gitlab.example.com" }), false), undefined);
-    });
-    test("builds a public base URL from forwarded headers", () => {
-        assert.strictEqual(getForwardedPublicBaseUrl(req({
-            "x-forwarded-proto": "https",
-            "x-forwarded-host": "mcp.example.com",
-            "x-forwarded-prefix": "/gitlab-mcp/",
-        }), true), "https://mcp.example.com/gitlab-mcp");
-    });
-    test("uses the last comma-separated forwarded value", () => {
-        assert.strictEqual(getForwardedPublicBaseUrl(req({
-            "x-forwarded-proto": "http, https",
-            "x-forwarded-host": "internal, mcp.example.com",
-        }), true), "https://mcp.example.com");
-    });
-    test("parses quoted Forwarded header values", () => {
-        assert.strictEqual(getForwardedPublicBaseUrl(req({
-            forwarded: 'for=192.0.2.43; proto="https"; host="mcp.example.com"',
-            "x-forwarded-prefix": "/gitlab-mcp",
-        }), true), "https://mcp.example.com/gitlab-mcp");
-    });
-    test("rejects unsafe host and prefix values", () => {
-        assert.strictEqual(getForwardedPublicBaseUrl(req({ "x-forwarded-proto": "https", "x-forwarded-host": "bad/host" }), true), undefined);
-        assert.strictEqual(getForwardedPublicBaseUrl(req({
-            "x-forwarded-proto": "https",
-            "x-forwarded-host": "mcp.example.com",
-            "x-forwarded-prefix": "//evil",
-        }), true), "https://mcp.example.com");
-    });
-});
-describe("getForwardedRequestHost", () => {
-    test("returns undefined unless proxy headers are trusted", () => {
-        assert.strictEqual(getForwardedRequestHost(req({ "x-forwarded-host": "mcp.example.com" }), false), undefined);
-    });
-    test("returns the forwarded host when proxy headers are trusted", () => {
-        assert.strictEqual(getForwardedRequestHost(req({ "x-forwarded-host": "mcp.example.com" }), true), "mcp.example.com");
-    });
-});

package/build/test/utils/gitlab-instance-version.test.js

@@ -1,32 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { parseGitLabVersionApiResponse } from "../../utils/gitlab-instance-version.js";
-describe("When parseGitLabVersionApiResponse runs", () => {
-    describe("with a full GitLab /version payload", () => {
-        test("should return version, revision, and enterprise", () => {
-            assert.deepEqual(parseGitLabVersionApiResponse({
-                version: "18.3.1-ee",
-                revision: "abc1234",
-                enterprise: true,
-            }), {
-                version: "18.3.1-ee",
-                revision: "abc1234",
-                enterprise: true,
-            });
-        });
-    });
-    describe("with only a version field", () => {
-        test("should return version without optional fields", () => {
-            assert.deepEqual(parseGitLabVersionApiResponse({ version: "17.5.0" }), {
-                version: "17.5.0",
-            });
-        });
-    });
-    describe("with invalid payloads", () => {
-        test("should return null", () => {
-            assert.equal(parseGitLabVersionApiResponse(null), null);
-            assert.equal(parseGitLabVersionApiResponse({}), null);
-            assert.equal(parseGitLabVersionApiResponse({ version: 18 }), null);
-        });
-    });
-});

package/build/test/utils/gitlab-version-gate.test.js

@@ -1,74 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { assertGitLabVersionAtLeast, isGitLabVersionAtLeast, parseGitLabVersion, } from "../../utils/gitlab-version-gate.js";
-function versionFetcher(version) {
-    return async () => version;
-}
-function bulkPublishRequirement() {
-    return {
-        major: 19,
-        minor: 2,
-        feature: "reviewer_state, note, and internal on bulk_publish_draft_notes",
-        retryHint: "Omit reviewer_state, note, and internal, then retry.",
-    };
-}
-describe("When parseGitLabVersion runs", () => {
-    describe("with a release suffix", () => {
-        test("should parse major.minor.patch from ee builds", () => {
-            assert.deepEqual(parseGitLabVersion("19.2.0-ee"), {
-                major: 19,
-                minor: 2,
-                patch: 0,
-            });
-        });
-    });
-    describe("with a malformed string", () => {
-        test("should return null", () => {
-            assert.equal(parseGitLabVersion("unknown"), null);
-            assert.equal(parseGitLabVersion(""), null);
-        });
-    });
-});
-describe("When isGitLabVersionAtLeast compares versions", () => {
-    describe("with a version at or above the floor", () => {
-        test("should return true", () => {
-            assert.equal(isGitLabVersionAtLeast("19.2.0-ee", 19, 2), true);
-            assert.equal(isGitLabVersionAtLeast("19.3.1", 19, 2), true);
-            assert.equal(isGitLabVersionAtLeast("20.0.0", 19, 2), true);
-        });
-    });
-    describe("with a version below the floor", () => {
-        test("should return false", () => {
-            assert.equal(isGitLabVersionAtLeast("19.1.9-ee", 19, 2), false);
-            assert.equal(isGitLabVersionAtLeast("17.5.0", 19, 2), false);
-        });
-    });
-    describe("with an unparseable version", () => {
-        test("should return null", () => {
-            assert.equal(isGitLabVersionAtLeast("not-a-version", 19, 2), null);
-        });
-    });
-});
-describe("When assertGitLabVersionAtLeast runs", () => {
-    describe("with an older instance version", () => {
-        test("should throw a retryable error", async () => {
-            await assert.rejects(() => assertGitLabVersionAtLeast(bulkPublishRequirement(), versionFetcher("17.5.0-ee")), (error) => {
-                assert.ok(error instanceof Error);
-                assert.match(error.message, /GitLab 19\.2\+/);
-                assert.match(error.message, /17\.5\.0-ee/);
-                assert.match(error.message, /Omit reviewer_state/);
-                return true;
-            });
-        });
-    });
-    describe("with a new enough instance version", () => {
-        test("should resolve without throwing", async () => {
-            await assertGitLabVersionAtLeast(bulkPublishRequirement(), versionFetcher("19.2.0-ee"));
-        });
-    });
-    describe("with an unknown instance version", () => {
-        test("should fail open and resolve", async () => {
-            await assertGitLabVersionAtLeast(bulkPublishRequirement(), versionFetcher(null));
-        });
-    });
-});

package/build/test/utils/graphql-query.test.js

@@ -1,168 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { graphqlQueryContainsWriteOperation, graphqlQueryContainsDeleteOperation, } from "../../utils/graphql-query.js";
-describe("When graphqlQueryContainsWriteOperation runs", () => {
-    describe("with read-only GraphQL documents", () => {
-        test("should allow explicit query operations", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("query { project(fullPath: \"g/p\") { id } }"), false);
-        });
-        test("should allow shorthand query operations", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("{ project { id } }"), false);
-        });
-        test("should ignore mutation text inside comments", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("# mutation destroy\nquery { project { id } }"), false);
-        });
-        test("should ignore mutation text inside string literals", () => {
-            assert.equal(graphqlQueryContainsWriteOperation('query { search(query: "mutation") { nodes { id } } }'), false);
-        });
-        test("should ignore escaped triple quotes inside block strings", () => {
-            assert.equal(graphqlQueryContainsWriteOperation('query { project(fullPath: """contains \\""" not a mutation""") { id } }'), false);
-        });
-        test("should not treat subscription field names as write operations", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("query { project { id }, subscription { count } }"), false);
-        });
-        test("should allow query with operation name 'mutation'", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("query mutation { project { id } }"), false);
-        });
-        test("should allow query with operation name 'subscription'", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("query subscription { project { id } }"), false);
-        });
-    });
-    describe("with write GraphQL documents", () => {
-        test("should detect mutation operations", () => {
-            assert.equal(graphqlQueryContainsWriteOperation('mutation { destroyProject(input: { projectId: "gid://gitlab/Project/1" }) { errors } }'), true);
-        });
-        test("should detect subscription operations", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("subscription { mergeRequestCreated { id } }"), true);
-        });
-        test("should detect write operations in multi-operation documents", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("query A { a } mutation B { b }"), true);
-        });
-        test("should detect semicolon-separated write operations", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("query A { a }; mutation B { b }"), true);
-        });
-        test("should detect comma-prefixed write operations", () => {
-            assert.equal(graphqlQueryContainsWriteOperation(",mutation { destroyProject(input: { projectId: 1 }) { errors } }"), true);
-        });
-        test("should detect comma-separated write operations", () => {
-            assert.equal(graphqlQueryContainsWriteOperation("query A { a }, mutation B { b }"), true);
-        });
-    });
-});
-describe("When graphqlQueryContainsDeleteOperation runs", () => {
-    describe("with non-delete documents", () => {
-        test("should allow plain queries even when they mention delete words", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("query { project { removeSourceBranchAfterMerge } }"), false);
-        });
-        test("should allow non-delete mutations", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation('mutation { issueSetSeverity(input: { severity: HIGH }) { errors } }'), false);
-        });
-        test("should not count delete-like argument names inside parentheses", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { mergeRequestUpdate(input: { removeSourceBranch: true }) { errors } }"), false);
-        });
-        test("should not count delete-like fields nested below the mutation root", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { issueSetLabels(input: {}) { issue { canBeDeleted } } }"), false);
-        });
-        test("should ignore delete text inside comments", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("# issueDelete\nmutation { issueSetLabels { errors } }"), false);
-        });
-        test("should ignore delete text inside string literals", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation('mutation { createNote(input: { body: "projectDelete" }) { errors } }'), false);
-        });
-    });
-    describe("with delete documents", () => {
-        test("should detect delete mutation fields", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation('mutation { issueDelete(input: { projectPath: "g/p", iid: "1" }) { errors } }'), true);
-        });
-        test("should detect destroy mutation fields", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation('mutation { destroyBoard(input: { id: "gid://gitlab/Board/1" }) { errors } }'), true);
-        });
-        test("should detect remove mutation fields", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { awardEmojiRemove(input: {}) { errors } }"), true);
-        });
-        test("should detect aliased delete mutation fields", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { a: issueDelete(input: {}) { errors } }"), true);
-        });
-        test("should detect delete mutations in multi-operation documents", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("query A { project { id } } mutation B { labelDelete(input: {}) { errors } }"), true);
-        });
-        test("should detect delete mutations with variable definitions", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation DeleteIssue($id: IssueID!) { issueDelete(input: { id: $id }) { errors } }"), true);
-        });
-        test("should detect comma-prefixed delete mutations", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation(', mutation M { issueDelete(input: { iid: "1" }) { id } }'), true);
-        });
-        test("should detect comma-prefixed delete mutations without whitespace", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation(',mutation{issueDelete(input:{iid:"1"}){id}}'), true);
-        });
-        test("should detect delete mutations after a comma-separated query", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("query HealthCheck { x }, mutation M { issueDelete(input: {}) { id } }"), true);
-        });
-        test("should allow comma-separated queries", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("query A { a }, query B { b }"), false);
-        });
-        test("should conservatively block top-level fragment spreads in mutations", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { ...f } fragment f on Mutation { issueDelete(input: {}) { errors } }"), true);
-        });
-    });
-    describe("with destructive mutations that are not named delete", () => {
-        test("should detect environmentStop", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation('mutation { environmentStop(input: { environmentId: "gid://gitlab/Environment/1" }) { errors } }'), true);
-        });
-        test("should detect pipelineCancel", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { pipelineCancel(input: {}) { errors } }"), true);
-        });
-        test("should detect clusterAgentTokenRevoke", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { clusterAgentTokenRevoke(input: {}) { errors } }"), true);
-        });
-        test("should detect jobUnschedule", () => {
-            // GitLab moves the scheduled job to manual and clears its scheduled state, so it
-            // is a teardown action even though no teardown verb is part of its name.
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { jobUnschedule(input: {}) { errors } }"), true);
-        });
-        test("should detect aliased destructive mutations", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { s: environmentStop(input: {}) { errors } }"), true);
-        });
-        test("should not treat an alias as a destructive mutation field", () => {
-            for (const query of [
-                "mutation { stop: issueSetSeverity(input: {}) { errors } }",
-                "mutation { revoke: issueSetSeverity(input: {}) { errors } }",
-                "mutation { terminate: updateIssue(input: {}) { issue { id } } }",
-            ]) {
-                assert.equal(graphqlQueryContainsDeleteOperation(query), false, query);
-            }
-        });
-        test("should not treat a spaced or comma-separated alias as a destructive field", () => {
-            for (const query of [
-                "mutation { stop : issueSetSeverity(input: {}) { errors } }",
-                "mutation { revoke,: issueSetSeverity(input: {}) { errors } }",
-                "mutation { terminate\n: updateIssue(input: {}) { issue { id } } }",
-            ]) {
-                assert.equal(graphqlQueryContainsDeleteOperation(query), false, query);
-            }
-        });
-        test("should still detect a destructive field after a spaced alias", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("mutation { harmless : environmentStop(input: {}) { errors } }"), true);
-        });
-        test("should still detect a destructive field hidden behind a harmless alias", () => {
-            for (const query of [
-                "mutation { harmless: environmentStop(input: {}) { errors } }",
-                "mutation { step: pipelineCancel(input: {}) { errors } }",
-            ]) {
-                assert.equal(graphqlQueryContainsDeleteOperation(query), true, query);
-            }
-        });
-        test("should detect destructive mutations in multi-operation documents", () => {
-            assert.equal(graphqlQueryContainsDeleteOperation("query A { project { id } } mutation B { environmentStop(input: {}) { errors } }"), true);
-        });
-        test("should still allow mutations without a destructive verb", () => {
-            for (const query of [
-                "mutation { issueMove(input: {}) { errors } }",
-                "mutation { mergeRequestMerge(input: {}) { errors } }",
-                "mutation { todoMarkDone(input: {}) { errors } }",
-            ]) {
-                assert.equal(graphqlQueryContainsDeleteOperation(query), false, query);
-            }
-        });
-    });
-});

package/build/test/utils/helpers-path.test.js

@@ -1,104 +0,0 @@
-import { describe, test } from "node:test";
-import assert from "node:assert";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { assertSafeRelativePath, openSafeOutputWriteStream, readSafeExistingFile, resolveSafeExistingPath, resolveSafeOutputDir, resolveSafeOutputFile, } from "../../utils/helpers.js";
-describe("assertSafeRelativePath", () => {
-    test("allows relative paths", () => {
-        assert.strictEqual(assertSafeRelativePath("uploads"), "uploads");
-        assert.strictEqual(assertSafeRelativePath("uploads/nested"), path.normalize("uploads/nested"));
-    });
-    test("rejects absolute paths", () => {
-        assert.throws(() => assertSafeRelativePath("/etc/passwd", "file_path"), /traversal/);
-    });
-    test("rejects parent-directory traversal", () => {
-        assert.throws(() => assertSafeRelativePath("../../../tmp", "local_path"), /traversal/);
-        assert.throws(() => assertSafeRelativePath("foo/../../etc", "local_path"), /traversal/);
-    });
-});
-describe("resolveSafeExistingPath / resolveSafeOutputDir", () => {
-    let base;
-    test("setup base dir", () => {
-        base = fs.mkdtempSync(path.join(os.tmpdir(), "safe-path-"));
-    });
-    test("resolves an existing file inside the base", () => {
-        const file = path.join(base, "ok.txt");
-        fs.writeFileSync(file, "hello");
-        const resolved = resolveSafeExistingPath("ok.txt", "file_path", base);
-        assert.strictEqual(resolved, fs.realpathSync(file));
-    });
-    test("rejects symlink file escape on read", () => {
-        const target = path.join(os.tmpdir(), `outside-target-${process.pid}.txt`);
-        fs.writeFileSync(target, "secret");
-        fs.symlinkSync(target, path.join(base, "link.txt"));
-        try {
-            assert.throws(() => resolveSafeExistingPath("link.txt", "file_path", base), /symbolic links|escapes/);
-        }
-        finally {
-            fs.unlinkSync(target);
-        }
-    });
-    test("rejects symlink directory escape on write", () => {
-        fs.symlinkSync(os.tmpdir(), path.join(base, "escape-dir"));
-        assert.throws(() => resolveSafeOutputDir("escape-dir", "local_path", base), /symbolic links|escapes/);
-    });
-    test("creates nested output dirs that stay inside the base", () => {
-        const out = resolveSafeOutputDir(path.join("artifacts", "run-1"), "local_path", base);
-        const baseReal = fs.realpathSync(base);
-        const rel = path.relative(baseReal, out);
-        assert.ok(rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel)));
-        assert.ok(fs.statSync(out).isDirectory());
-    });
-    test("resolveSafeOutputFile rejects destination file symlink", () => {
-        const outDir = path.join(base, "out");
-        fs.mkdirSync(outDir, { recursive: true });
-        const target = path.join(os.tmpdir(), `outside-write-${process.pid}.txt`);
-        fs.writeFileSync(target, "before");
-        fs.symlinkSync(target, path.join(outDir, "payload.bin"));
-        try {
-            assert.throws(() => resolveSafeOutputFile("payload.bin", "out", "local_path", base), /symbolic links/);
-        }
-        finally {
-            fs.unlinkSync(target);
-        }
-    });
-    test("resolveSafeOutputFile returns contained path for new files", () => {
-        const dest = resolveSafeOutputFile("fresh.bin", "downloads", "local_path", base);
-        assert.ok(dest.startsWith(fs.realpathSync(base) + path.sep));
-        assert.ok(dest.endsWith(`${path.sep}fresh.bin`));
-    });
-    test("anchors to cwd snapshot when baseDir is omitted", () => {
-        const nested = path.join(base, "anchored");
-        fs.mkdirSync(nested, { recursive: true });
-        const file = path.join(nested, "data.txt");
-        fs.writeFileSync(file, "anchored");
-        const originalCwd = process.cwd();
-        try {
-            process.chdir(nested);
-            const resolved = resolveSafeExistingPath("data.txt", "file_path");
-            assert.strictEqual(resolved, fs.realpathSync(file));
-        }
-        finally {
-            process.chdir(originalCwd);
-        }
-    });
-    test("readSafeExistingFile reads without returning a reusable path", () => {
-        const file = path.join(base, "inline.txt");
-        fs.writeFileSync(file, "payload");
-        const { buffer, basename } = readSafeExistingFile("inline.txt", "file_path", base);
-        assert.strictEqual(buffer.toString(), "payload");
-        assert.strictEqual(basename, "inline.txt");
-    });
-    test("openSafeOutputWriteStream writes without a separate createWriteStream call", async () => {
-        const { stream, path: dest } = openSafeOutputWriteStream("streamed.bin", "downloads", "local_path", base);
-        await new Promise((resolve, reject) => {
-            stream.on("error", reject);
-            stream.end("streamed", () => resolve());
-        });
-        assert.strictEqual(fs.readFileSync(dest, "utf8"), "streamed");
-    });
-    test("cleanup base dir", () => {
-        fs.rmSync(base, { recursive: true, force: true });
-    });
-});

package/build/test/utils/jmespath-tool-result.test.js

@@ -1,91 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { applyJmespathFilter, applyJmespathToToolResult, getJmespathSyntaxError, omitJmespathArgument, readJmespathExpression, shouldApplyJmespathFilter, } from "../../utils/jmespath-tool-result.js";
-describe("jmespath tool result helpers", () => {
-    test("readJmespathExpression trims and rejects blank values", () => {
-        assert.equal(readJmespathExpression({ jmespath: "  [].title  " }), "[].title");
-        assert.equal(readJmespathExpression({ jmespath: "   " }), undefined);
-        assert.equal(readJmespathExpression({ jmespath: 1 }), undefined);
-    });
-    test("omitJmespathArgument removes MCP-only key", () => {
-        assert.deepEqual(omitJmespathArgument({ project_id: "1", jmespath: "[].id" }), {
-            project_id: "1",
-        });
-    });
-    test("applyJmespathFilter projects array fields", () => {
-        const data = [
-            { title: "a", description: "long" },
-            { title: "b", description: "longer" },
-        ];
-        assert.deepEqual(applyJmespathFilter(data, "[].title"), ["a", "b"]);
-    });
-    test("applyJmespathToToolResult filters JSON text content", () => {
-        const result = applyJmespathToToolResult({
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify([{ title: "mr-one", iid: 1 }]),
-                },
-            ],
-        }, "[].title");
-        assert.equal(result.content[0].text, JSON.stringify(["mr-one"]));
-    });
-    test("applyJmespathToToolResult applies maskValue before JMESPath", () => {
-        const result = applyJmespathToToolResult({
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify([{ title: "ProjectOneSecret" }]),
-                },
-            ],
-        }, "[].starts_with(title, `ProjectOne`)", {
-            maskValue: value => {
-                if (!Array.isArray(value))
-                    return value;
-                return value.map(entry => entry && typeof entry === "object" && "title" in entry
-                    ? { ...entry, title: "[one]" }
-                    : entry);
-            },
-        });
-        assert.deepEqual(JSON.parse(result.content[0].text), [false]);
-    });
-    test("shouldApplyJmespathFilter is false for isError and explicit skip", () => {
-        const errorResult = {
-            content: [{ type: "text", text: 'Unknown category "foo"' }],
-            isError: true,
-        };
-        assert.equal(shouldApplyJmespathFilter(errorResult, "[].title"), false);
-        assert.equal(shouldApplyJmespathFilter({ content: [{ type: "text", text: "requires confirmation" }] }, "[].title", { skipJmespath: true }), false);
-        assert.equal(shouldApplyJmespathFilter({ content: [{ type: "text", text: "[]" }] }, "[].title"), true);
-    });
-    test("applyJmespathToToolResult preserves isError tool results", () => {
-        const original = {
-            content: [{ type: "text", text: 'Unknown category "foo"' }],
-            isError: true,
-        };
-        assert.deepEqual(applyJmespathToToolResult(original, "[].title"), original);
-    });
-    test("applyJmespathToToolResult preserves approval-style plain text when skipJmespath", () => {
-        const original = {
-            content: [
-                {
-                    type: "text",
-                    text: 'Tool "create_issue" requires confirmation. Re-call with _confirmed: true to proceed.',
-                },
-            ],
-        };
-        assert.deepEqual(applyJmespathToToolResult(original, "[].title", { skipJmespath: true }), original);
-    });
-    test("applyJmespathToToolResult passes non-JSON success text through unchanged", () => {
-        const original = { content: [{ type: "text", text: "Created pipeline #1 for main." }] };
-        assert.deepEqual(applyJmespathToToolResult(original, "id"), original);
-    });
-    test("applyJmespathToToolResult returns the original result when evaluation fails", () => {
-        const original = { content: [{ type: "text", text: JSON.stringify({ title: 1 }) }] };
-        assert.deepEqual(applyJmespathToToolResult(original, "starts_with(title, `a`)"), original);
-    });
-    test("getJmespathSyntaxError rejects invalid expressions before execution", () => {
-        assert.match(getJmespathSyntaxError("[[[") ?? "", /Invalid jmespath expression/);
-        assert.equal(getJmespathSyntaxError("[].title"), undefined);
-    });
-});