@zereight/mcp-gitlab 2.1.50 → 2.1.52

package/build/test/oauth-device-flow-tests.js

@@ -0,0 +1,440 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getPositionalCliCommand } from "../cli-command.js";
+import { gitlabOriginFromApiUrl, runAuthCommandAsync } from "../auth-cli.js";
+import { runDeviceAuthorizationGrantAsync } from "../oauth-device-flow.js";
+import { GitLabOAuth } from "../oauth.js";
+const GITLAB_URL = "https://gitlab.example";
+const CLIENT_ID = "test-client-id";
+const DEVICE_CODE = "device-code-not-for-stdout";
+const USER_CODE = "0A44L90H";
+const ACCESS_TOKEN = "oauth-device-flow-access-token";
+const REFRESH_TOKEN = "refresh-token-device-flow";
+function requestUrl(input) {
+    if (typeof input === "string") {
+        return input;
+    }
+    if (input instanceof URL) {
+        return input.href;
+    }
+    return input.url;
+}
+function jsonResponse(status, body) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+function createFetchStub(plan, capture) {
+    const remainingTokens = [...plan.tokens];
+    return async (input, init) => {
+        const url = requestUrl(input);
+        if (url.includes("/oauth/authorize_device")) {
+            if (typeof init?.body === "string") {
+                capture?.authorizeBodies.push(init.body);
+            }
+            return jsonResponse(plan.authorize.status, plan.authorize.body);
+        }
+        if (url.includes("/oauth/token")) {
+            const next = remainingTokens.shift();
+            if (!next) {
+                throw new Error(`Unexpected token poll: ${url}`);
+            }
+            return jsonResponse(next.status, next.body);
+        }
+        throw new Error(`Unexpected fetch URL: ${url}`);
+    };
+}
+function deviceAuthorizationBody(interval = 5) {
+    return {
+        device_code: DEVICE_CODE,
+        user_code: USER_CODE,
+        verification_uri: `${GITLAB_URL}/oauth/device`,
+        verification_uri_complete: `${GITLAB_URL}/oauth/device?user_code=${USER_CODE}`,
+        expires_in: 300,
+        interval,
+    };
+}
+function successTokenBody() {
+    return {
+        access_token: ACCESS_TOKEN,
+        refresh_token: REFRESH_TOKEN,
+        expires_in: 7200,
+        token_type: "Bearer",
+    };
+}
+function pendingBody() {
+    return { error: "authorization_pending" };
+}
+function createTempTokenPath() {
+    return path.join(os.tmpdir(), `gitlab-mcp-device-flow-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.json`);
+}
+function createOauthClient(tokenStoragePath) {
+    return new GitLabOAuth({
+        clientId: CLIENT_ID,
+        redirectUri: "http://127.0.0.1:8888/callback",
+        gitlabUrl: GITLAB_URL,
+        scopes: ["api"],
+        tokenStoragePath,
+    });
+}
+function createAuthorizeCapture() {
+    return { authorizeBodies: [] };
+}
+function capturedAuthorizeScope(bodies) {
+    if (bodies.length !== 1) {
+        return null;
+    }
+    const [body] = bodies;
+    if (body === undefined) {
+        return null;
+    }
+    return new URLSearchParams(body).get("scope");
+}
+async function runAuthCapturingScopeAsync(input) {
+    const tokenPath = createTempTokenPath();
+    const capture = createAuthorizeCapture();
+    const fetchImpl = createFetchStub({
+        authorize: { status: 200, body: deviceAuthorizationBody() },
+        tokens: [{ status: 200, body: successTokenBody() }],
+    }, capture);
+    try {
+        await runAuthCommandAsync({
+            argv: [
+                "node",
+                "index.js",
+                "auth",
+                `--client-id=${CLIENT_ID}`,
+                `--api-url=${GITLAB_URL}`,
+                `--token-path=${tokenPath}`,
+                ...(input.extraArgv ?? []),
+            ],
+            env: input.env ?? {},
+            stdout: createStdoutBuffer().stdout,
+            fetchImpl,
+            sleepAsync: async () => { },
+        });
+        return capturedAuthorizeScope(capture.authorizeBodies);
+    }
+    finally {
+        if (fs.existsSync(tokenPath)) {
+            fs.unlinkSync(tokenPath);
+        }
+    }
+}
+function createStdoutBuffer() {
+    const chunks = [];
+    return {
+        stdout: {
+            write(chunk) {
+                chunks.push(chunk);
+                return true;
+            },
+        },
+        text: () => chunks.join(""),
+    };
+}
+function createSleepRecorder() {
+    const delays = [];
+    return {
+        delays,
+        async sleepAsync(ms) {
+            delays.push(ms);
+        },
+    };
+}
+function readStoredToken(value) {
+    if (typeof value !== "object" || value === null) {
+        throw new Error("token file is not an object");
+    }
+    const accessToken = Reflect.get(value, "access_token");
+    const refreshToken = Reflect.get(value, "refresh_token");
+    const expiresIn = Reflect.get(value, "expires_in");
+    const createdAt = Reflect.get(value, "created_at");
+    const tokenType = Reflect.get(value, "token_type");
+    if (typeof accessToken !== "string") {
+        throw new Error("access_token missing");
+    }
+    if (typeof createdAt !== "number") {
+        throw new Error("created_at missing");
+    }
+    if (typeof tokenType !== "string") {
+        throw new Error("token_type missing");
+    }
+    return {
+        access_token: accessToken,
+        refresh_token: typeof refreshToken === "string" ? refreshToken : undefined,
+        expires_in: typeof expiresIn === "number" ? expiresIn : undefined,
+        created_at: createdAt,
+        token_type: tokenType,
+    };
+}
+describe("When reading the CLI command", () => {
+    describe("with auth as the first positional argument", () => {
+        it("should return auth", () => {
+            assert.equal(getPositionalCliCommand(["node", "index.js", "auth"]), "auth");
+        });
+    });
+    describe("with only --token", () => {
+        it("should return undefined so MCP startup stays unchanged", () => {
+            assert.equal(getPositionalCliCommand(["node", "index.js", "--token=glpat-xxxxxxxx"]), undefined);
+        });
+    });
+    describe("with flags before auth", () => {
+        it("should still return auth", () => {
+            assert.equal(getPositionalCliCommand(["node", "index.js", "--api-url=https://gitlab.com", "auth"]), "auth");
+        });
+    });
+    describe("with tsx index.ts auth", () => {
+        it("should skip the script path and return auth", () => {
+            assert.equal(getPositionalCliCommand(["node", "/usr/local/bin/tsx", "index.ts", "auth", "--help"]), "auth");
+        });
+    });
+    describe("with space-separated --api-url before auth", () => {
+        it("should skip the URL value and return auth", () => {
+            assert.equal(getPositionalCliCommand([
+                "node",
+                "index.js",
+                "--api-url",
+                "https://gitlab.example/api/v4",
+                "auth",
+            ]), "auth");
+        });
+    });
+    describe("with space-separated --client-id before auth", () => {
+        it("should skip the client id value and return auth", () => {
+            assert.equal(getPositionalCliCommand(["node", "index.js", "--client-id", "app-id", "auth"]), "auth");
+        });
+    });
+    describe("with -h before auth", () => {
+        it("should not consume auth as a help value", () => {
+            assert.equal(getPositionalCliCommand(["node", "index.js", "-h", "auth"]), "auth");
+        });
+    });
+});
+describe("When converting a GitLab API URL", () => {
+    describe("with an /api/v4 suffix", () => {
+        it("should strip it the same way initializeOAuthClient does", () => {
+            assert.equal(gitlabOriginFromApiUrl("https://gitlab.com/api/v4"), "https://gitlab.com");
+        });
+    });
+    describe("with a trailing slash after /api/v4", () => {
+        it("should strip the suffix and trailing slash", () => {
+            assert.equal(gitlabOriginFromApiUrl("https://gitlab.example/api/v4/"), "https://gitlab.example");
+        });
+    });
+});
+describe("When running device authorization grant", () => {
+    describe("with authorization_pending then a token", () => {
+        it("should return TokenData compatible with the existing OAuth store", async () => {
+            const fetchImpl = createFetchStub({
+                authorize: { status: 200, body: deviceAuthorizationBody() },
+                tokens: [
+                    { status: 400, body: pendingBody() },
+                    { status: 200, body: successTokenBody() },
+                ],
+            });
+            const sleep = createSleepRecorder();
+            const token = await runDeviceAuthorizationGrantAsync({
+                gitlabUrl: GITLAB_URL,
+                clientId: CLIENT_ID,
+                scopes: ["api"],
+                fetchImpl,
+                sleepAsync: sleep.sleepAsync,
+            });
+            assert.equal(token.access_token, ACCESS_TOKEN);
+            assert.equal(token.refresh_token, REFRESH_TOKEN);
+            assert.equal(token.expires_in, 7200);
+            assert.equal(token.token_type, "Bearer");
+            assert.equal(typeof token.created_at, "number");
+            assert.deepEqual(sleep.delays, [5000]);
+        });
+    });
+    describe("with slow_down then a token", () => {
+        it("should wait the increased interval before the next poll", async () => {
+            const fetchImpl = createFetchStub({
+                authorize: { status: 200, body: deviceAuthorizationBody(5) },
+                tokens: [
+                    { status: 400, body: { error: "slow_down" } },
+                    { status: 200, body: successTokenBody() },
+                ],
+            });
+            const sleep = createSleepRecorder();
+            await runDeviceAuthorizationGrantAsync({
+                gitlabUrl: GITLAB_URL,
+                clientId: CLIENT_ID,
+                scopes: ["api"],
+                fetchImpl,
+                sleepAsync: sleep.sleepAsync,
+            });
+            assert.deepEqual(sleep.delays, [10000]);
+        });
+    });
+});
+describe("When the token endpoint returns expired_token", () => {
+    describe("with no token file yet", () => {
+        it("should throw and not write a token file", async () => {
+            const tokenPath = createTempTokenPath();
+            const fetchImpl = createFetchStub({
+                authorize: { status: 200, body: deviceAuthorizationBody() },
+                tokens: [{ status: 400, body: { error: "expired_token" } }],
+            });
+            const oauth = createOauthClient(tokenPath);
+            await assert.rejects(() => oauth.runDeviceFlowAsync({ fetchImpl, sleepAsync: async () => { } }), /Device code expired/);
+            assert.equal(fs.existsSync(tokenPath), false);
+        });
+    });
+});
+describe("When the token endpoint returns access_denied", () => {
+    describe("with no token file yet", () => {
+        it("should throw and not write a token file", async () => {
+            const tokenPath = createTempTokenPath();
+            const fetchImpl = createFetchStub({
+                authorize: { status: 200, body: deviceAuthorizationBody() },
+                tokens: [{ status: 400, body: { error: "access_denied" } }],
+            });
+            const oauth = createOauthClient(tokenPath);
+            await assert.rejects(() => oauth.runDeviceFlowAsync({ fetchImpl, sleepAsync: async () => { } }), /Authorization was denied/);
+            assert.equal(fs.existsSync(tokenPath), false);
+        });
+    });
+});
+describe("When GitLab returns 404 for authorize_device", () => {
+    describe("with a self-managed instance", () => {
+        it("should tell the user to use a PAT", async () => {
+            const fetchImpl = createFetchStub({
+                authorize: { status: 404, body: { error: "not_found" } },
+                tokens: [],
+            });
+            await assert.rejects(() => runDeviceAuthorizationGrantAsync({
+                gitlabUrl: GITLAB_URL,
+                clientId: CLIENT_ID,
+                scopes: ["api"],
+                fetchImpl,
+                sleepAsync: async () => { },
+            }), /GITLAB_PERSONAL_ACCESS_TOKEN/);
+        });
+    });
+});
+describe("When device flow succeeds", () => {
+    describe("with GitLabOAuth.saveToken", () => {
+        it("should persist the existing token file shape", async () => {
+            const tokenPath = createTempTokenPath();
+            const fetchImpl = createFetchStub({
+                authorize: { status: 200, body: deviceAuthorizationBody() },
+                tokens: [{ status: 200, body: successTokenBody() }],
+            });
+            try {
+                await createOauthClient(tokenPath).runDeviceFlowAsync({
+                    fetchImpl,
+                    sleepAsync: async () => { },
+                });
+                const raw = JSON.parse(fs.readFileSync(tokenPath, "utf8"));
+                const stored = readStoredToken(raw);
+                assert.equal(stored.access_token, ACCESS_TOKEN);
+                assert.equal(stored.refresh_token, REFRESH_TOKEN);
+                assert.equal(stored.expires_in, 7200);
+                assert.equal(stored.token_type, "Bearer");
+                assert.equal(typeof stored.created_at, "number");
+                assert.equal(fs.statSync(tokenPath).mode & 0o777, 0o600);
+            }
+            finally {
+                if (fs.existsSync(tokenPath)) {
+                    fs.unlinkSync(tokenPath);
+                }
+            }
+        });
+    });
+});
+describe("When running the auth command", () => {
+    describe("with --help", () => {
+        it("should print usage and not fetch", async () => {
+            const out = createStdoutBuffer();
+            const fetchImpl = async () => {
+                throw new Error("fetch should not run for --help");
+            };
+            await runAuthCommandAsync({
+                argv: ["node", "index.js", "auth", "--help"],
+                env: {},
+                stdout: out.stdout,
+                fetchImpl,
+            });
+            assert.match(out.text(), /zereight-mcp-gitlab auth/);
+            assert.equal(out.text().includes(DEVICE_CODE), false);
+        });
+    });
+    describe("without a client id", () => {
+        it("should fail before calling GitLab", async () => {
+            await assert.rejects(() => runAuthCommandAsync({
+                argv: ["node", "index.js", "auth"],
+                env: {},
+                stdout: createStdoutBuffer().stdout,
+                fetchImpl: async () => {
+                    throw new Error("fetch should not run without client id");
+                },
+            }), /GITLAB_OAUTH_CLIENT_ID/);
+        });
+    });
+    describe("with a successful device flow", () => {
+        it("should print the user code and not the device code or access token", async () => {
+            const tokenPath = createTempTokenPath();
+            const out = createStdoutBuffer();
+            const fetchImpl = createFetchStub({
+                authorize: { status: 200, body: deviceAuthorizationBody() },
+                tokens: [{ status: 200, body: successTokenBody() }],
+            });
+            try {
+                await runAuthCommandAsync({
+                    argv: [
+                        "node",
+                        "index.js",
+                        "auth",
+                        `--client-id=${CLIENT_ID}`,
+                        `--api-url=${GITLAB_URL}`,
+                        `--token-path=${tokenPath}`,
+                    ],
+                    env: {},
+                    stdout: out.stdout,
+                    fetchImpl,
+                    sleepAsync: async () => { },
+                });
+                const printed = out.text();
+                assert.equal(printed.includes(USER_CODE), true);
+                assert.match(printed, /Token saved to/);
+                assert.match(printed, /GITLAB_USE_OAUTH=true/);
+                assert.match(printed, /GITLAB_OAUTH_TOKEN_PATH/);
+                assert.equal(printed.includes(DEVICE_CODE), false);
+                assert.equal(printed.includes(ACCESS_TOKEN), false);
+                assert.equal(fs.existsSync(tokenPath), true);
+            }
+            finally {
+                if (fs.existsSync(tokenPath)) {
+                    fs.unlinkSync(tokenPath);
+                }
+            }
+        });
+    });
+    describe("without a read-only flag", () => {
+        it("should request the api scope", async () => {
+            assert.equal(await runAuthCapturingScopeAsync({}), "api");
+        });
+    });
+    describe("with --permission-mode=readonly", () => {
+        it("should request the read_api scope", async () => {
+            assert.equal(await runAuthCapturingScopeAsync({ extraArgv: ["--permission-mode=readonly"] }), "read_api");
+        });
+    });
+    describe("with GITLAB_PERMISSION_MODE=readonly", () => {
+        it("should request the read_api scope", async () => {
+            assert.equal(await runAuthCapturingScopeAsync({ env: { GITLAB_PERMISSION_MODE: "readonly" } }), "read_api");
+        });
+    });
+    describe("with --read-only=true", () => {
+        it("should request the read_api scope", async () => {
+            assert.equal(await runAuthCapturingScopeAsync({ extraArgv: ["--read-only=true"] }), "read_api");
+        });
+    });
+});

package/build/test/schema-tests.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env ts-node
-import { GetFileContentsSchema, GitLabFileContentSchema, GitLabRepositorySchema, CreatePipelineSchema, CreateCommitStatusSchema, ListCommitStatusesSchema, CreateIssueNoteSchema, CreateMergeRequestEmojiReactionSchema, CreateIssueEmojiReactionSchema, DeleteMergeRequestEmojiReactionSchema, DeleteIssueEmojiReactionSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, CreateIssueSchema, ListIssuesSchema, ListMergeRequestsSchema, ListLabelsSchema, GitLabMergeRequestSchema, GitLabTreeItemSchema, GetMergeRequestSchema, ListMergeRequestPipelinesSchema, GetRepositoryTreeSchema, GitLabUserFullSchema, GitLabMarkdownUploadSchema, GitLabDependencyProxySchema, GitLabDependencyProxyBlobSchema, } from '../schemas.js';
+import { GetFileContentsSchema, GitLabFileContentSchema, GitLabRepositorySchema, CreatePipelineSchema, CreateCommitStatusSchema, ListCommitStatusesSchema, CreateIssueNoteSchema, CreateMergeRequestEmojiReactionSchema, CreateIssueEmojiReactionSchema, DeleteMergeRequestEmojiReactionSchema, DeleteIssueEmojiReactionSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, CreateIssueSchema, ListIssuesSchema, ListMergeRequestsSchema, ListLabelsSchema, GitLabMergeRequestSchema, GitLabTreeItemSchema, GetMergeRequestSchema, ListMergeRequestPipelinesSchema, GetRepositoryTreeSchema, GitLabUserFullSchema, GitLabMarkdownUploadSchema, GitLabDependencyProxySchema, GitLabDependencyProxyBlobSchema, PushFilesSchema, CreateOrUpdateFileSchema, } from '../schemas.js';
 function runGetFileContentsSchemaTests() {
     console.log('🧪 Testing GetFileContentsSchema...');
     const cases = [
@@ -822,6 +822,21 @@ function runGitLabMergeRequestSchemaTests() {
             },
             validate: (data) => data.merge_user === undefined && data.merged_by === undefined,
         },
+        {
+            name: 'schema:gitlab_merge_request:preserves-sha',
+            input: {
+                ...baseMergeRequest,
+                sha: 'e82eb4a098e32c796079ca3915e07487fc4db24c',
+            },
+            validate: (data) => data.sha === 'e82eb4a098e32c796079ca3915e07487fc4db24c',
+        },
+        {
+            name: 'schema:gitlab_merge_request:allows-omitted-sha',
+            input: {
+                ...baseMergeRequest,
+            },
+            validate: (data) => data.sha === undefined,
+        },
     ];
     let passed = 0;
     let failed = 0;
@@ -1536,6 +1551,104 @@ function runGitLabDependencyProxyBlobSchemaTests() {
     console.log(`\nResults: ${passed} passed, ${failed} failed`);
     return { passed, failed };
 }
+function runPushFilesSchemaTests() {
+    console.log('🧪 Testing PushFilesSchema / CreateOrUpdateFileSchema (per-file action + encoding)...');
+    const base = { project_id: '1', branch: 'main', commit_message: 'm' };
+    function record(name, ok, error) {
+        const result = { name, status: ok ? 'passed' : 'failed', error };
+        if (result.status === 'passed') {
+            console.log(`✅ ${result.name}`);
+        }
+        else {
+            console.log(`❌ ${result.name}: ${result.error}`);
+        }
+        return result;
+    }
+    const results = [];
+    {
+        const parsed = PushFilesSchema.safeParse({ ...base, files: [{ file_path: 'a.txt', content: 'hi' }] });
+        results.push(record('schema:push_files:plain-text-default', parsed.success &&
+            parsed.data.files[0]?.action === undefined &&
+            parsed.data.files[0]?.encoding === undefined, parsed.success ? undefined : parsed.error.message));
+    }
+    {
+        const parsed = PushFilesSchema.safeParse({
+            ...base,
+            files: [{ file_path: 'logo.png', content: 'aGk=', encoding: 'base64' }],
+        });
+        results.push(record('schema:push_files:binary-base64', parsed.success && parsed.data.files[0]?.encoding === 'base64', parsed.success ? undefined : parsed.error.message));
+    }
+    {
+        const parsed = PushFilesSchema.safeParse({
+            ...base,
+            files: [{ file_path: 'a.txt', content: 'new', action: 'update' }],
+        });
+        results.push(record('schema:push_files:action-update', parsed.success && parsed.data.files[0]?.action === 'update', parsed.success ? undefined : parsed.error.message));
+    }
+    {
+        const parsed = PushFilesSchema.safeParse({
+            ...base,
+            files: [{ file_path: 'a.txt', action: 'delete' }],
+        });
+        results.push(record('schema:push_files:action-delete-content-optional', parsed.success &&
+            parsed.data.files[0]?.action === 'delete' &&
+            parsed.data.files[0]?.content === undefined, parsed.success ? undefined : parsed.error.message));
+    }
+    {
+        const parsed = PushFilesSchema.safeParse({
+            ...base,
+            files: [{ file_path: 'b.txt', action: 'move', previous_path: 'a.txt' }],
+        });
+        results.push(record('schema:push_files:action-move-previous-path', parsed.success &&
+            parsed.data.files[0]?.action === 'move' &&
+            parsed.data.files[0]?.previous_path === 'a.txt', parsed.success ? undefined : parsed.error.message));
+    }
+    {
+        const parsed = PushFilesSchema.safeParse({
+            ...base,
+            files: [{ file_path: 'a.txt', content: 'hi', encoding: 'text' }],
+        });
+        results.push(record('schema:push_files:explicit-text-encoding', parsed.success && parsed.data.files[0]?.encoding === 'text', parsed.success ? undefined : parsed.error.message));
+    }
+    results.push(record('schema:push_files:reject-create-without-content', !PushFilesSchema.safeParse({ ...base, files: [{ file_path: 'a.txt' }] }).success, 'Expected schema validation to fail'));
+    results.push(record('schema:push_files:reject-update-without-content', !PushFilesSchema.safeParse({ ...base, files: [{ file_path: 'a.txt', action: 'update' }] }).success, 'Expected schema validation to fail'));
+    results.push(record('schema:push_files:reject-move-without-previous-path', !PushFilesSchema.safeParse({ ...base, files: [{ file_path: 'b.txt', action: 'move' }] }).success, 'Expected schema validation to fail'));
+    results.push(record('schema:push_files:reject-invalid-action', !PushFilesSchema.safeParse({
+        ...base,
+        files: [{ file_path: 'a.txt', content: 'hi', action: 'copy' }],
+    }).success, 'Expected schema validation to fail'));
+    results.push(record('schema:push_files:reject-invalid-encoding', !PushFilesSchema.safeParse({
+        ...base,
+        files: [{ file_path: 'a.txt', content: 'hi', encoding: 'utf16' }],
+    }).success, 'Expected schema validation to fail'));
+    {
+        const parsed = CreateOrUpdateFileSchema.safeParse({
+            ...base,
+            file_path: 'a.txt',
+            content: 'hi',
+        });
+        results.push(record('schema:create_or_update_file:plain-text-default', parsed.success && parsed.data.encoding === undefined, parsed.success ? undefined : parsed.error.message));
+    }
+    {
+        const parsed = CreateOrUpdateFileSchema.safeParse({
+            ...base,
+            file_path: 'logo.png',
+            content: 'aGk=',
+            encoding: 'base64',
+        });
+        results.push(record('schema:create_or_update_file:encoding-base64', parsed.success && parsed.data.encoding === 'base64', parsed.success ? undefined : parsed.error.message));
+    }
+    results.push(record('schema:create_or_update_file:reject-invalid-encoding', !CreateOrUpdateFileSchema.safeParse({
+        ...base,
+        file_path: 'a.txt',
+        content: 'hi',
+        encoding: 'utf16',
+    }).success, 'Expected schema validation to fail'));
+    const passed = results.filter(result => result.status === 'passed').length;
+    const failed = results.filter(result => result.status === 'failed').length;
+    console.log(`\nResults: ${passed} passed, ${failed} failed`);
+    return { passed, failed };
+}
 if (import.meta.url === `file://${process.argv[1]}`) {
     const getFileContentsResult = runGetFileContentsSchemaTests();
     const fileContentResult = runGitLabFileContentSchemaTests();
@@ -1556,8 +1669,9 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     const gitLabMarkdownUploadResult = runGitLabMarkdownUploadSchemaTests();
     const dependencyProxyResult = runGitLabDependencyProxySchemaTests();
     const dependencyProxyBlobResult = runGitLabDependencyProxyBlobSchemaTests();
-    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed + commitStatusResult.passed + createIssueNoteResult.passed + getMergeRequestResult.passed + listMergeRequestPipelinesResult.passed + gitLabMergeRequestResult.passed + emojiReactionResult.passed + repositorySchemaResult.passed + labelsCoercionResult.passed + approvedByUsernamesResult.passed + listLabelsResult.passed + treeItemResult.passed + repositoryTreeResult.passed + gitLabUserFullResult.passed + gitLabMarkdownUploadResult.passed + dependencyProxyResult.passed + dependencyProxyBlobResult.passed;
-    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed + commitStatusResult.failed + createIssueNoteResult.failed + getMergeRequestResult.failed + listMergeRequestPipelinesResult.failed + gitLabMergeRequestResult.failed + emojiReactionResult.failed + repositorySchemaResult.failed + labelsCoercionResult.failed + approvedByUsernamesResult.failed + listLabelsResult.failed + treeItemResult.failed + repositoryTreeResult.failed + gitLabUserFullResult.failed + gitLabMarkdownUploadResult.failed + dependencyProxyResult.failed + dependencyProxyBlobResult.failed;
+    const pushFilesResult = runPushFilesSchemaTests();
+    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed + commitStatusResult.passed + createIssueNoteResult.passed + getMergeRequestResult.passed + listMergeRequestPipelinesResult.passed + gitLabMergeRequestResult.passed + emojiReactionResult.passed + repositorySchemaResult.passed + labelsCoercionResult.passed + approvedByUsernamesResult.passed + listLabelsResult.passed + treeItemResult.passed + repositoryTreeResult.passed + gitLabUserFullResult.passed + gitLabMarkdownUploadResult.passed + dependencyProxyResult.passed + dependencyProxyBlobResult.passed + pushFilesResult.passed;
+    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed + commitStatusResult.failed + createIssueNoteResult.failed + getMergeRequestResult.failed + listMergeRequestPipelinesResult.failed + gitLabMergeRequestResult.failed + emojiReactionResult.failed + repositorySchemaResult.failed + labelsCoercionResult.failed + approvedByUsernamesResult.failed + listLabelsResult.failed + treeItemResult.failed + repositoryTreeResult.failed + gitLabUserFullResult.failed + gitLabMarkdownUploadResult.failed + dependencyProxyResult.failed + dependencyProxyBlobResult.failed + pushFilesResult.failed;
     console.log(`\nTotal Results: ${totalPassed} passed, ${totalFailed} failed`);
     if (totalFailed > 0) {
         process.exit(1);

package/build/test/test-job-artifacts.js

@@ -1,4 +1,4 @@
-import { describe, test, before, after } from 'node:test';
+import { describe, test, it, before, after } from 'node:test';
 import assert from 'node:assert';
 import { spawn } from 'child_process';
 import { MockGitLabServer, findMockServerPort } from './utils/mock-gitlab-server.js';
@@ -8,6 +8,7 @@ import os from 'node:os';
 const MOCK_TOKEN = 'glpat-mock-token-12345';
 const TEST_PROJECT_ID = '123';
 const TEST_JOB_ID = '456';
+const NULL_MODE_JOB_ID = '457';
 const TEST_ENCODED_ARTIFACT_PATH = 'reports/report#1.txt';
 // Helper to run an MCP tool via the built server
 async function callTool(toolName, args, env) {
@@ -117,6 +118,25 @@ describe('job artifacts tools', () => {
             res.set('Content-Type', 'text/plain');
             res.send('encoded artifact content');
         });
+        // GitLab.com can return mode/size as null on artifacts/tree entries (#661)
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${NULL_MODE_JOB_ID}/artifacts/tree`, (req, res) => {
+            res.json([
+                {
+                    name: 'report.xml',
+                    path: 'report.xml',
+                    type: 'file',
+                    size: 1024,
+                    mode: null,
+                },
+                {
+                    name: 'logs',
+                    path: 'logs',
+                    type: 'directory',
+                    size: null,
+                    mode: '040755',
+                },
+            ]);
+        });
         // Add mock handler for 404 on non-existent artifact
         mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/999/artifacts/tree`, (req, res) => {
             res.status(404).json({ message: 'Not Found' });
@@ -147,6 +167,20 @@ describe('job artifacts tools', () => {
         assert.strictEqual(result[1].name, 'logs');
         assert.strictEqual(result[1].type, 'directory');
     });
+    describe('When listing job artifacts', () => {
+        describe('with a null mode entry', () => {
+            it('should return the entries instead of failing', async () => {
+                const result = await callTool('list_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: NULL_MODE_JOB_ID }, {
+                    GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                    GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+                });
+                assert.ok(Array.isArray(result), 'Response should be an array');
+                assert.strictEqual(result.length, 2);
+                assert.strictEqual(result[0].mode, null);
+                assert.strictEqual(result[1].size, null);
+            });
+        });
+    });
     test('download_job_artifacts saves archive to disk', async () => {
         const result = await callTool('download_job_artifacts', { project_id: TEST_PROJECT_ID, job_id: TEST_JOB_ID, local_path: tmpDir }, {
             GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,