@zereight/mcp-gitlab 2.1.45 → 2.1.47

package/build/index.js

@@ -70,9 +70,9 @@ import fs from "node:fs";
 import { pipeline as streamPipeline } from "node:stream/promises";
 import os from "node:os";
 import nodeFetch from "node-fetch";
-import path, { dirname } from "node:path";
+import path from "node:path";
 import { CookieJar, parse as parseCookie } from "tough-cookie";
-import { fileURLToPath, URL } from "node:url";
+import { URL } from "node:url";
 import { z } from "zod";
 import { initializeOAuthClient } from "./oauth.js";
 import { createGitLabOAuthProvider } from "./oauth-proxy.js";
@@ -84,8 +84,11 @@ import { registerDownloadProxy } from "./downloads/proxy.js";
 import { createDownloadToken } from "./utils/download-token.js";
 import { determineTransportMode, TransportMode } from "./server/transport-mode.js";
 import { formatPrometheusMetrics } from "./server/metrics.js";
+import { SERVER_VERSION } from "./server/version.js";
+import { isInitializationRequestBody, isUnauthenticatedDiscoveryRequestBody, readMcpSessionIdHeader, redactSessionIdForLog, } from "./server/request-helpers.js";
+export { readMcpSessionIdHeader } from "./server/request-helpers.js";
 import { normalizeGitLabApiUrl } from "./utils/url.js";
-import { estimateMergeCommitCount, filterDiffsByPatterns, summarizeWebhookEvents, } from "./utils/helpers.js";
+import { estimateMergeCommitCount, filterDiffsByPatterns, openSafeOutputWriteStream, readSafeExistingFile, summarizeWebhookEvents, } from "./utils/helpers.js";
 import { graphqlQueryContainsWriteOperation, graphqlQueryContainsDeleteOperation, } from "./utils/graphql-query.js";
 import { resolveNestedWikiUpdateTitle } from "./utils/wiki-title.js";
 import { redactSensitiveGitLabFields } from "./utils/redact-sensitive.js";
@@ -105,26 +108,10 @@ GitLabDiscussionNoteSchema, // Added
 GitLabDiscussionSchema, 
 // Draft Notes Schemas
 GitLabDraftNoteSchema, GitLabForkSchema, GitLabBranchSchema, GitLabProtectedBranchSchema, GitLabGroupSchema, GitLabIssueLinkSchema, GitLabIssueSchema, GitLabIssueWithLinkDetailsSchema, GitLabMarkdownUploadSchema, GitLabMergeRequestPipelineSchema, GitLabMergeRequestSchema, GitLabMilestonesSchema, GitLabGroupMilestonesSchema, GitLabNamespaceExistsResponseSchema, GitLabNamespaceSchema, GitLabPipelineJobSchema, GitLabDeploymentSchema, GitLabEnvironmentSchema, GitLabPipelineSchema, GitLabPipelineTriggerJobSchema, GitLabProjectMemberSchema, GitLabProjectSchema, GitLabTodoSchema, GitLabReferenceSchema, GitLabRepositorySchema, GitLabSearchBlobResultSchema, GitLabSearchResponseSchema, GitLabTreeItemSchema, GitLabUserSchema, GitLabUsersResponseSchema, GitLabWikiPageSchema, GroupIteration, ListCommitStatusesSchema, ListBranchesSchema, ListCommitsSchema, ListDraftNotesSchema, ListGroupIterationsSchema, ListGroupProjectsSchema, GitLabCiVariableSchema, ListProjectVariablesSchema, GetProjectVariableSchema, CreateProjectVariableSchema, UpdateProjectVariableSchema, DeleteProjectVariableSchema, ListGroupVariablesSchema, GetGroupVariableSchema, CreateGroupVariableSchema, UpdateGroupVariableSchema, DeleteGroupVariableSchema, GitLabDependencyProxySchema, GitLabDependencyProxyBlobSchema, GetDependencyProxySettingsSchema, UpdateDependencyProxySettingsSchema, ListDependencyProxyBlobsSchema, PurgeDependencyProxyCacheSchema, ListProjectVulnerabilitiesSchema, GetVulnerabilitySchema, DismissVulnerabilitySchema, ConfirmVulnerabilitySchema, ListIssueDiscussionsSchema, ListIssueLinksSchema, ListIssuesSchema, ListTodosSchema, ListLabelsSchema, ListMergeRequestDiffsSchema, // Added
-GetMergeRequestFileDiffSchema, ListMergeRequestChangedFilesSchema, ListMergeRequestDiscussionsSchema, ListMergeRequestPipelinesSchema, ListMergeRequestsSchema, ListMergeRequestVersionsSchema, GetMergeRequestVersionSchema, GitLabMergeRequestVersionSchema, GitLabMergeRequestVersionDetailSchema, ListNamespacesSchema, ListPipelineJobsSchema, ListPipelinesSchema, ListDeploymentsSchema, ListEnvironmentsSchema, ListPipelineTriggerJobsSchema, ValidateCiLintSchema, ValidateProjectCiLintSchema, ListCiCatalogResourcesSchema, GetCiCatalogResourceSchema, ListProjectMembersSchema, ListProjectMilestonesSchema, ListGroupMilestonesSchema, ListProjectsSchema, ListWikiPagesSchema, GetGroupWikiPageSchema, ListGroupWikiPagesSchema, UpdateGroupWikiPageSchema, MarkdownUploadSchema, MarkdownUploadRemoteSchema, DownloadAttachmentSchema, DownloadJobArtifactsSchema, GetJobArtifactFileSchema, GitLabArtifactEntrySchema, ListJobArtifactsSchema, MergeMergeRequestSchema, ApproveMergeRequestSchema, UnapproveMergeRequestSchema, GetMergeRequestApprovalStateSchema, GetMergeRequestConflictsSchema, GitLabMergeRequestApprovalsResponseSchema, GitLabMergeRequestApprovalStateSchema, MyIssuesSchema, MarkAllTodosDoneSchema, MarkTodoDoneSchema, PaginatedDiscussionsResponseSchema, PromoteProjectMilestoneSchema, PublishDraftNoteSchema, PlayPipelineJobSchema, PushFilesSchema, RetryPipelineJobSchema, RetryPipelineSchema, SearchCodeSchema, SearchGroupCodeSchema, SearchProjectCodeSchema, SearchRepositoriesSchema, UpdateDraftNoteSchema, UpdateIssueNoteSchema, UpdateIssueSchema, UpdateIssueDescriptionPatchSchema, UpdateLabelSchema, UpdateProjectSchema, UpdateMergeRequestNoteSchema, UpdateMergeRequestDiscussionNoteSchema, UpdateMergeRequestSchema, UpdateWikiPageSchema, VerifyNamespaceSchema, GitLabEventSchema, ListEventsSchema, GetProjectEventsSchema, ExecuteGraphQLSchema, GitLabReleaseSchema, ListReleasesSchema, GetReleaseSchema, CreateReleaseSchema, UpdateReleaseSchema, DeleteReleaseSchema, CreateReleaseEvidenceSchema, DownloadReleaseAssetSchema, ListTagsSchema, GetTagSchema, CreateTagSchema, DeleteTagSchema, GetTagSignatureSchema, GitLabTagSchema, GitLabTagSignatureSchema, GetMergeRequestNotesSchema, GetMergeRequestNoteSchema, DeleteMergeRequestDiscussionNoteSchema, ResolveMergeRequestThreadSchema, GetWorkItemSchema, ListWorkItemsSchema, CreateWorkItemSchema, UpdateWorkItemSchema, ConvertWorkItemTypeSchema, ListWorkItemStatusesSchema, ListWorkItemNotesSchema, CreateWorkItemNoteSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, ListWorkItemEmojiReactionsSchema, ListWorkItemNoteEmojiReactionsSchema, DeleteWorkItemEmojiReactionSchema, DeleteWorkItemNoteEmojiReactionSchema, MoveWorkItemSchema, ListCustomFieldDefinitionsSchema, GetTimelineEventsSchema, CreateTimelineEventSchema, ListWebhooksSchema, ListWebhookEventsSchema, GetWebhookEventSchema, HealthCheckSchema, } from "./schemas.js";
+GetMergeRequestFileDiffSchema, ListMergeRequestChangedFilesSchema, ListMergeRequestDiscussionsSchema, ListMergeRequestPipelinesSchema, ListMergeRequestsSchema, ListMergeRequestVersionsSchema, GetMergeRequestVersionSchema, GitLabMergeRequestVersionSchema, GitLabMergeRequestVersionDetailSchema, ListNamespacesSchema, ListPipelineJobsSchema, ListPipelinesSchema, ListDeploymentsSchema, ListEnvironmentsSchema, ListPipelineTriggerJobsSchema, ValidateCiLintSchema, ValidateProjectCiLintSchema, ListCiCatalogResourcesSchema, GetCiCatalogResourceSchema, ListProjectMembersSchema, ListGroupMembersSchema, ListProjectMilestonesSchema, ListGroupMilestonesSchema, ListProjectsSchema, ListWikiPagesSchema, GetGroupWikiPageSchema, ListGroupWikiPagesSchema, UpdateGroupWikiPageSchema, MarkdownUploadSchema, MarkdownUploadRemoteSchema, DownloadAttachmentSchema, DownloadJobArtifactsSchema, GetJobArtifactFileSchema, GitLabArtifactEntrySchema, ListJobArtifactsSchema, MergeMergeRequestSchema, ApproveMergeRequestSchema, UnapproveMergeRequestSchema, GetMergeRequestApprovalStateSchema, GetMergeRequestConflictsSchema, GitLabMergeRequestApprovalsResponseSchema, GitLabMergeRequestApprovalStateSchema, MyIssuesSchema, MarkAllTodosDoneSchema, MarkTodoDoneSchema, PaginatedDiscussionsResponseSchema, PromoteProjectMilestoneSchema, PublishDraftNoteSchema, PlayPipelineJobSchema, PushFilesSchema, RetryPipelineJobSchema, RetryPipelineSchema, SearchCodeSchema, SearchGroupCodeSchema, SearchProjectCodeSchema, SearchRepositoriesSchema, UpdateDraftNoteSchema, UpdateIssueNoteSchema, UpdateIssueSchema, UpdateIssueDescriptionPatchSchema, UpdateLabelSchema, UpdateProjectSchema, UpdateMergeRequestNoteSchema, UpdateMergeRequestDiscussionNoteSchema, UpdateMergeRequestSchema, UpdateWikiPageSchema, VerifyNamespaceSchema, GitLabEventSchema, ListEventsSchema, GetProjectEventsSchema, ExecuteGraphQLSchema, GitLabReleaseSchema, ListReleasesSchema, GetReleaseSchema, CreateReleaseSchema, UpdateReleaseSchema, DeleteReleaseSchema, CreateReleaseEvidenceSchema, DownloadReleaseAssetSchema, ListTagsSchema, GetTagSchema, CreateTagSchema, DeleteTagSchema, GetTagSignatureSchema, GitLabTagSchema, GitLabTagSignatureSchema, GetMergeRequestNotesSchema, GetMergeRequestNoteSchema, DeleteMergeRequestDiscussionNoteSchema, ResolveMergeRequestThreadSchema, GetWorkItemSchema, ListWorkItemsSchema, CreateWorkItemSchema, UpdateWorkItemSchema, ConvertWorkItemTypeSchema, ListWorkItemStatusesSchema, ListWorkItemNotesSchema, CreateWorkItemNoteSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, ListWorkItemEmojiReactionsSchema, ListWorkItemNoteEmojiReactionsSchema, DeleteWorkItemEmojiReactionSchema, DeleteWorkItemNoteEmojiReactionSchema, MoveWorkItemSchema, ListCustomFieldDefinitionsSchema, GetTimelineEventsSchema, CreateTimelineEventSchema, ListWebhooksSchema, ListWebhookEventsSchema, GetWebhookEventSchema, HealthCheckSchema, } from "./schemas.js";
 import { randomUUID, timingSafeEqual, } from "node:crypto";
 import { createLogger } from "./utils/logger.js";
 const logger = createLogger();
-/**
- * Read version from package.json
- */
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJsonPath = path.resolve(__dirname, "../package.json");
-let SERVER_VERSION = "unknown";
-try {
-    if (fs.existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-        SERVER_VERSION = packageJson.version || SERVER_VERSION;
-    }
-}
-catch {
-    // Intentionally ignored: version read failure is non-critical
-}
 const SERVER_NAME = process.env.MCP_SERVER_NAME?.trim() || "zereight-gitlab-mcp-server";
 /**
  * Create a new MCP Server instance with request handlers registered.
@@ -650,71 +637,6 @@ function validateConfiguration() {
 }
 let OAUTH_ACCESS_TOKEN = null;
 let oauthClient = null;
-/**
- * Produce a safe short form of a session id for logs. Legacy UUIDs pass
- * through; stateless sealed sids are truncated to the "v1.sid." prefix
- * plus a handful of bytes of the ciphertext so operators can correlate
- * flows without the log line carrying the sealed bearer token.
- */
-function redactSessionIdForLog(sid) {
-    if (!sid)
-        return "<none>";
-    if (sid.startsWith("v1.sid."))
-        return "v1.sid.<redacted>";
-    // UUIDs / other formats are low-sensitivity; show first 8 chars.
-    return sid.length > 8 ? `${sid.slice(0, 8)}…` : sid;
-}
-/**
- * Detect whether an MCP JSON-RPC request body represents an "initialize"
- * request. Accepts both single-message and batch forms. Returns false on any
- * unexpected shape — callers treat an ambiguous body as non-init, which is
- * the safer default (it means the SDK will fail loudly rather than silently
- * spawning a new session).
- */
-function isInitializationRequestBody(body) {
-    if (!body)
-        return false;
-    const isInitObj = (m) => typeof m === "object" && m !== null && m.method === "initialize";
-    if (Array.isArray(body))
-        return body.some(isInitObj);
-    return isInitObj(body);
-}
-function isUnauthenticatedDiscoveryRequestBody(body) {
-    if (!body)
-        return false;
-    const isDiscoveryMethod = (m) => {
-        if (typeof m !== "object" || m === null)
-            return false;
-        const method = m.method;
-        return (method === "initialize" || method === "notifications/initialized" || method === "tools/list");
-    };
-    if (Array.isArray(body))
-        return body.every(isDiscoveryMethod);
-    return isDiscoveryMethod(body);
-}
-/**
- * Normalize an `Mcp-Session-Id` header value.
- *
- * Node's HTTP types allow any request header to surface as `string[]` when
- * the client sends it more than once. Casting to `string` and calling
- * `.startsWith()` on an array throws `TypeError: startsWith is not a
- * function`, which Express converts to a 500 — silently turning malformed
- * requests into server errors and breaking the 401/404 semantics we
- * carefully distinguish in stateless mode. A duplicated `Mcp-Session-Id` is
- * also ill-formed at the protocol level: there is no well-defined way to
- * pick between two values, so we reject arrays rather than guess.
- *
- * Empty-string is normalized to `undefined` so call sites can use truthy
- * checks and `?? undefined`-style fallbacks uniformly.
- *
- * Exported for unit tests; otherwise used only by the /mcp handlers below.
- */
-export function readMcpSessionIdHeader(req) {
-    const raw = req.headers["mcp-session-id"];
-    if (typeof raw !== "string")
-        return undefined;
-    return raw.length > 0 ? raw : undefined;
-}
 /**
  * Loaded once at startup. Null when OAUTH_STATELESS_MODE is disabled.
  * When set, the OAuth provider and (later phases) the Mcp-Session-Id path
@@ -998,7 +920,7 @@ const BASE_HEADERS = {
 function buildAuthHeaders() {
     if (REMOTE_AUTHORIZATION || GITLAB_MCP_OAUTH) {
         const ctx = sessionAuthStore.getStore();
-        logger.debug({ context: ctx }, "buildAuthHeaders: session context");
+        logger.debug({ sessionId: ctx?.sessionId, header: ctx?.header, apiUrl: ctx?.apiUrl }, "buildAuthHeaders: session context");
         if (ctx?.token) {
             return {
                 [ctx.header]: ctx.header === "Authorization" ? `Bearer ${ctx.token}` : ctx.token,
@@ -1043,7 +965,7 @@ function getEffectiveApiUrl() {
         if (ctx?.apiUrl) {
             return ctx.apiUrl;
         }
-        logger.warn({ ctx }, "getEffectiveApiUrl: No context or apiUrl found, falling back to default");
+        logger.warn({ sessionId: ctx?.sessionId, header: ctx?.header, apiUrl: ctx?.apiUrl }, "getEffectiveApiUrl: No context or apiUrl found, falling back to default");
     }
     return GITLAB_API_URL;
 }
@@ -1344,10 +1266,14 @@ async function getFileContents(projectId, filePath, ref) {
     await handleGitLabError(response);
     const data = await response.json();
     const parsedData = GitLabContentSchema.parse(data);
-    // Decode Base64-encoded file content to UTF-8
-    if (!Array.isArray(parsedData) && parsedData.content) {
-        parsedData.content = Buffer.from(parsedData.content, "base64").toString("utf8");
-        parsedData.encoding = "utf8";
+    // Decode Base64-encoded text files while preserving binary content losslessly.
+    if (!Array.isArray(parsedData) && typeof parsedData.content === "string") {
+        const decodedContent = Buffer.from(parsedData.content, "base64");
+        const utf8Content = decodedContent.toString("utf8");
+        if (Buffer.from(utf8Content, "utf8").equals(decodedContent)) {
+            parsedData.content = utf8Content;
+            parsedData.encoding = "utf8";
+        }
     }
     return parsedData;
 }
@@ -4123,13 +4049,33 @@ async function getMergeRequestApprovalState(projectId, mergeRequestIid) {
         ...getFetchConfig(),
         method: "GET",
     });
-    if (approvalStateResponse.status === 404) {
+    // 404 when the endpoint is unavailable; 402/403 when the instance or namespace is
+    // not licensed for approval rules, which are a paid-tier feature.
+    if (approvalStateResponse.status === 404 ||
+        approvalStateResponse.status === 402 ||
+        approvalStateResponse.status === 403) {
         return getMergeRequestApprovalsFallback(projectId, mergeRequestIid);
     }
     await handleGitLabError(approvalStateResponse);
     const parsedApprovalState = GitLabMergeRequestApprovalStateSchema.parse(await approvalStateResponse.json());
     const approvedByUsers = getUniqueApprovalUsers((parsedApprovalState.rules || []).flatMap(rule => rule.approved_by || []));
     const approvedByUsernames = approvedByUsers.map(user => user.username);
+    // approval_state only reports approvals attributed to rules, so a project with no
+    // approval rules answers 200 with `rules: []` and yields no approvers even when
+    // someone has approved. Read /approvals in that case. A non-empty rules array means
+    // rules are in use and approval_state is authoritative, so no extra request is made
+    // there - including while an MR is still waiting for its first approval.
+    if ((parsedApprovalState.rules || []).length === 0) {
+        try {
+            const viaApprovals = await getMergeRequestApprovalsFallback(projectId, mergeRequestIid);
+            if ((viaApprovals.approved_by ?? []).length > 0) {
+                return viaApprovals;
+            }
+        }
+        catch {
+            // /approvals unavailable as well - keep the approval_state answer below.
+        }
+    }
     return {
         ...parsedApprovalState,
         approved_by: approvedByUsers,
@@ -5334,12 +5280,11 @@ async function downloadJobArtifacts(projectId, jobId, localPath) {
     }
     await handleGitLabError(response);
     const filename = `artifacts_job_${encodeGitLabPathSegment(jobId)}.zip`;
-    const savePath = localPath ? path.join(localPath, filename) : filename;
-    fs.mkdirSync(path.dirname(savePath), { recursive: true });
     if (!response.body) {
         throw new Error("No response body from GitLab");
     }
-    await streamPipeline(response.body, fs.createWriteStream(savePath));
+    const { stream: saveStream, path: savePath } = openSafeOutputWriteStream(filename, localPath, "local_path");
+    await streamPipeline(response.body, saveStream);
     return savePath;
 }
 /**
@@ -6168,6 +6113,35 @@ async function listProjectMembers(projectId, options = {}) {
     const data = await response.json();
     return z.array(GitLabProjectMemberSchema).parse(data);
 }
+/**
+ * List members of a GitLab group
+ * GitLab 그룹 멤버 목록 조회
+ *
+ * @param {string} groupId - Group ID or URL-encoded path
+ * @param {Omit<ListGroupMembersOptions, "group_id">} options - Options for filtering members
+ * @returns {Promise<GitLabProjectMember[]>} List of group members
+ */
+async function listGroupMembers(groupId, options = {}) {
+    groupId = decodeURIComponent(groupId);
+    const membersPath = options.include_inheritance ? "members/all" : "members";
+    const url = new URL(`${getEffectiveApiUrl()}/groups/${encodeURIComponent(groupId)}/${membersPath}`);
+    if (options.query)
+        url.searchParams.append("query", options.query);
+    if (options.user_ids) {
+        options.user_ids.forEach(id => url.searchParams.append("user_ids[]", id.toString()));
+    }
+    if (options.skip_users) {
+        options.skip_users.forEach(id => url.searchParams.append("skip_users[]", id.toString()));
+    }
+    if (options.per_page)
+        url.searchParams.append("per_page", options.per_page.toString());
+    if (options.page)
+        url.searchParams.append("page", options.page.toString());
+    const response = await fetch(url.toString(), getFetchConfig());
+    await handleGitLabError(response);
+    const data = await response.json();
+    return z.array(GitLabProjectMemberSchema).parse(data);
+}
 /**
  * list group iterations
  *
@@ -6708,12 +6682,10 @@ async function markdownUpload(projectId, filePath, content, filename) {
         fileName = filename || "upload";
     }
     else if (filePath) {
-        // Local file mode
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`File not found: ${filePath}`);
-        }
-        fileBuffer = fs.readFileSync(filePath);
-        fileName = path.basename(filePath);
+        // Local file mode — reject absolute/traversal/symlink escapes before reading
+        const { buffer, basename: safeBasename } = readSafeExistingFile(filePath, "file_path");
+        fileBuffer = buffer;
+        fileName = safeBasename;
     }
     else {
         throw new Error("Either file_path or content must be provided");
@@ -6778,29 +6750,12 @@ async function downloadAttachment(projectId, secret, filename, localPath) {
     // For non-image files, always save to disk.
     // For image files, only save to disk if local_path is explicitly provided.
     if (!mimeType || localPath) {
-        let savePath;
-        if (localPath) {
-            const normalizedLocalPath = path.normalize(localPath);
-            if (path.isAbsolute(normalizedLocalPath) ||
-                normalizedLocalPath === ".." ||
-                normalizedLocalPath.startsWith(".." + path.sep) ||
-                normalizedLocalPath.includes(path.sep + ".." + path.sep)) {
-                throw new Error("Invalid local_path: directory traversal is not allowed.");
-            }
-            savePath = path.join(normalizedLocalPath, safeFilename);
-        }
-        else {
-            savePath = safeFilename;
-        }
-        const dir = path.dirname(savePath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        // Stream directly to disk instead of buffering in memory
         if (!response.body) {
             throw new Error("No response body from GitLab");
         }
-        await streamPipeline(response.body, fs.createWriteStream(savePath));
+        const { stream: saveStream, path: savePath } = openSafeOutputWriteStream(safeFilename, localPath, "local_path");
+        // Stream directly to disk instead of buffering in memory
+        await streamPipeline(response.body, saveStream);
         return { buffer: Buffer.alloc(0), filename: safeFilename, mimeType, savedPath: savePath };
     }
     // Images returned inline — buffer into memory for base64 encoding
@@ -7781,6 +7736,14 @@ async function handleToolCall(params) {
                     content: [{ type: "text", text: JSON.stringify(members) }],
                 };
             }
+            case "list_group_members": {
+                const args = ListGroupMembersSchema.parse(params.arguments);
+                const { group_id, ...options } = args;
+                const members = await listGroupMembers(group_id, options);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(members) }],
+                };
+            }
             case "get_users": {
                 const args = GetUsersSchema.parse(params.arguments);
                 const usersMap = await getUsers(args.usernames);
@@ -9509,7 +9472,9 @@ async function handleToolCall(params) {
         }
     }
     catch (error) {
-        logger.debug(params);
+        // Log tool name only — never dump raw params (may contain approval_password).
+        // Sensitive fields are also covered by REDACT_PATHS if arguments are logged elsewhere.
+        logger.debug({ tool: params.name }, "Tool call failed");
         if (error instanceof z.ZodError) {
             throw new Error(`Invalid arguments: ${error.errors
                 .map(e => `${e.path.join(".")}: ${e.message}`)

package/build/oauth-proxy.js

@@ -49,7 +49,7 @@ import { OAuthTokensSchema } from "@modelcontextprotocol/sdk/shared/auth.js";
 import { randomUUID, randomBytes, createHash } from "node:crypto";
 import { looksLikeStatelessClientId, mintClientId, openClientId, } from "./stateless/client-id.js";
 import { looksLikeStatelessState, mintPendingAuthState, openPendingAuthState, } from "./stateless/pending-auth.js";
-import { looksLikeStatelessStoredTokensCode, mintStoredTokensCode, openStoredTokensCode, } from "./stateless/stored-tokens.js";
+import { looksLikeStatelessStoredTokensCode, mintStoredTokensCode, openStoredTokensCode, ConsumedProxyCodeCache, PROXY_CODE_CACHE_FULL, } from "./stateless/index.js";
 import { createLogger } from "./utils/logger.js";
 const logger = createLogger("gitlab-mcp-oauth-proxy");
 // ---------------------------------------------------------------------------
@@ -129,6 +129,13 @@ class GitLabOAuthServerProvider {
     _callbackUrl;
     _pendingAuth = new BoundedLRUMap(PENDING_AUTH_MAX_SIZE);
     _storedTokens = new BoundedLRUMap(PENDING_AUTH_MAX_SIZE);
+    /**
+     * Per-pod replay-prevention cache for sealed (stateless) proxy authorization
+     * codes. Keys are SHA-256 hashes of the code; entries are TTL-bound (never
+     * LRU-evicted early) and hold pending→consumed state. Cross-pod replay
+     * remains mitigated by the short stored-code TTL + PKCE.
+     */
+    _usedProxyCodes = new ConsumedProxyCodeCache(PENDING_AUTH_MAX_SIZE);
     // Stateless mode (optional). When set, DCR and callback-proxy state are
     // serialised into opaque OAuth values and the in-memory caches above are
     // bypassed. Enabled independently of callback-proxy mode.
@@ -325,102 +332,150 @@ class GitLabOAuthServerProvider {
     // ---- Token exchange ----------------------------------------------------
     async exchangeAuthorizationCode(client, authorizationCode, codeVerifier, redirectUri, resource) {
         let tokens;
-        if (this._callbackProxyEnabled) {
-            // --- Callback proxy mode ---
-            // The authorizationCode is a proxy code we generated in handleCallback().
-            // It is either a sealed token (stateless mode) or a random UUID that
-            // keys into the _storedTokens LRU (legacy mode).
-            const stateless = this._stateless;
-            let entry = null;
-            if (stateless && looksLikeStatelessStoredTokensCode(authorizationCode)) {
-                const payload = openStoredTokensCode(stateless.material, authorizationCode, stateless.storedTtlSeconds);
-                if (!payload) {
-                    throw new ServerError("Invalid or expired authorization code");
+        /** Reserved sealed-code hash + id; released on failure, committed on success. */
+        let reservedProxyCode = null;
+        /**
+         * Legacy (non-stateless) proxy code taken from `_storedTokens` before
+         * binding checks. Restored on binding/PKCE failure so a wrong verifier
+         * cannot burn the code for the legitimate client.
+         */
+        let legacyRestorable = null;
+        try {
+            if (this._callbackProxyEnabled) {
+                // --- Callback proxy mode ---
+                // The authorizationCode is a proxy code we generated in handleCallback().
+                // It is either a sealed token (stateless mode) or a random UUID that
+                // keys into the _storedTokens LRU (legacy mode).
+                const stateless = this._stateless;
+                let entry = null;
+                if (stateless && looksLikeStatelessStoredTokensCode(authorizationCode)) {
+                    const codeHash = createHash("sha256").update(authorizationCode).digest("hex");
+                    let reserved;
+                    try {
+                        reserved = this._usedProxyCodes.tryReserve(codeHash, stateless.storedTtlSeconds);
+                        if (!reserved.ok) {
+                            if (reserved.reason === "pending") {
+                                throw new ServerError("Authorization code exchange in progress — please retry");
+                            }
+                            throw new ServerError("Authorization code already used");
+                        }
+                    }
+                    catch (err) {
+                        if (err instanceof Error && err.message === PROXY_CODE_CACHE_FULL) {
+                            logger.warn({
+                                cacheSize: this._usedProxyCodes.size,
+                                cacheMaxSize: this._usedProxyCodes.maxSize,
+                            }, "Proxy code replay cache at capacity");
+                            throw new ServerError("Authorization server busy — please retry the OAuth flow");
+                        }
+                        throw err;
+                    }
+                    reservedProxyCode = { hash: codeHash, id: reserved.reservationId };
+                    const payload = openStoredTokensCode(stateless.material, authorizationCode, stateless.storedTtlSeconds);
+                    if (!payload) {
+                        throw new ServerError("Invalid or expired authorization code");
+                    }
+                    entry = {
+                        tokens: payload.t,
+                        clientId: payload.cid,
+                        clientCodeChallenge: payload.ccc,
+                        clientRedirectUri: payload.cru,
+                    };
+                    // NOTE: Cross-pod one-time use still requires a shared store. Replay
+                    // across pods is mitigated by short TTL (default 120s) + client PKCE.
+                    // Documented in stateless/stored-tokens.ts.
                 }
-                entry = {
-                    tokens: payload.t,
-                    clientId: payload.cid,
-                    clientCodeChallenge: payload.ccc,
-                    clientRedirectUri: payload.cru,
-                };
-                // NOTE: Stateless mode cannot enforce one-time use without a shared
-                // store. Replay is mitigated by short TTL + client PKCE verification
-                // below (attacker needs the code_verifier). Documented in
-                // stateless/stored-tokens.ts.
-            }
-            else {
-                const lru = this._storedTokens.get(authorizationCode);
-                if (!lru) {
-                    throw new ServerError("Invalid or expired authorization code");
+                else {
+                    // Atomic take: serialize concurrent exchanges. Restored below if
+                    // client/redirect/PKCE binding checks fail (DoS prevention).
+                    const lru = this._storedTokens.getAndDelete(authorizationCode);
+                    if (!lru) {
+                        throw new ServerError("Invalid or expired authorization code");
+                    }
+                    if (Date.now() - lru.createdAt > PENDING_AUTH_TTL_MS) {
+                        throw new ServerError("Authorization code expired — please restart the OAuth flow");
+                    }
+                    legacyRestorable = { code: authorizationCode, entry: lru };
+                    entry = {
+                        tokens: lru.tokens,
+                        clientId: lru.clientId,
+                        clientCodeChallenge: lru.clientCodeChallenge,
+                        clientRedirectUri: lru.clientRedirectUri,
+                    };
                 }
-                if (Date.now() - lru.createdAt > PENDING_AUTH_TTL_MS) {
-                    this._storedTokens.delete(authorizationCode);
-                    throw new ServerError("Authorization code expired — please restart the OAuth flow");
+                // Bind the proxy code to the client and redirect_uri that initiated
+                // /authorize, preserving the normal OAuth authorization-code invariant.
+                // Binding + PKCE run while consumption is only *reserved* (pending /
+                // restorable); failed checks release so the legitimate client can retry.
+                if (client.client_id !== entry.clientId) {
+                    throw new ServerError("Invalid client for authorization code");
                 }
-                // One-time use: delete after validation
-                this._storedTokens.delete(authorizationCode);
-                entry = {
-                    tokens: lru.tokens,
-                    clientId: lru.clientId,
-                    clientCodeChallenge: lru.clientCodeChallenge,
-                    clientRedirectUri: lru.clientRedirectUri,
-                };
-            }
-            // Bind the proxy code to the client and redirect_uri that initiated
-            // /authorize, preserving the normal OAuth authorization-code invariant.
-            if (client.client_id !== entry.clientId) {
-                throw new ServerError("Invalid client for authorization code");
-            }
-            if (redirectUri !== entry.clientRedirectUri) {
-                throw new ServerError("Invalid redirect_uri for authorization code");
+                if (redirectUri !== entry.clientRedirectUri) {
+                    throw new ServerError("Invalid redirect_uri for authorization code");
+                }
+                // Verify client PKCE: the client's code_verifier must match the
+                // code_challenge stored during /authorize.
+                if (entry.clientCodeChallenge) {
+                    if (!codeVerifier) {
+                        throw new ServerError("PKCE code_verifier is required");
+                    }
+                    const computed = createHash("sha256").update(codeVerifier).digest("base64url");
+                    if (computed !== entry.clientCodeChallenge) {
+                        throw new ServerError("PKCE verification failed");
+                    }
+                }
+                tokens = entry.tokens;
             }
-            // Verify client PKCE: the client's code_verifier must match the
-            // code_challenge stored during /authorize.
-            if (entry.clientCodeChallenge) {
-                if (!codeVerifier) {
-                    throw new ServerError("PKCE code_verifier is required");
+            else {
+                // --- Passthrough mode (original behavior) ---
+                const params = new URLSearchParams({
+                    grant_type: "authorization_code",
+                    client_id: this._gitlabAppId,
+                    code: authorizationCode,
+                });
+                if (codeVerifier)
+                    params.append("code_verifier", codeVerifier);
+                if (redirectUri)
+                    params.append("redirect_uri", redirectUri);
+                if (resource)
+                    params.append("resource", resource.href);
+                const response = await fetch(`${this._gitlabBaseUrl}/oauth/token`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                    body: params.toString(),
+                });
+                if (!response.ok) {
+                    const body = await response.text();
+                    logger.error(`Token exchange failed (${response.status}): ${body}`);
+                    throw new ServerError(`Token exchange failed: ${response.status}`);
                 }
-                const computed = createHash("sha256").update(codeVerifier).digest("base64url");
-                if (computed !== entry.clientCodeChallenge) {
-                    throw new ServerError("PKCE verification failed");
+                const data = await response.json();
+                tokens = OAuthTokensSchema.parse(data);
+            }
+            if (this._allowedGroups) {
+                const isMember = await this._checkGroupMembership(tokens.access_token);
+                if (!isMember) {
+                    logger.warn({ allowedGroups: this._allowedGroups }, "Token issuance denied: user is not a member of any allowed group");
+                    throw new ServerError("Access denied: user is not a member of an allowed group");
                 }
             }
-            tokens = entry.tokens;
-        }
-        else {
-            // --- Passthrough mode (original behavior) ---
-            const params = new URLSearchParams({
-                grant_type: "authorization_code",
-                client_id: this._gitlabAppId,
-                code: authorizationCode,
-            });
-            if (codeVerifier)
-                params.append("code_verifier", codeVerifier);
-            if (redirectUri)
-                params.append("redirect_uri", redirectUri);
-            if (resource)
-                params.append("resource", resource.href);
-            const response = await fetch(`${this._gitlabBaseUrl}/oauth/token`, {
-                method: "POST",
-                headers: { "Content-Type": "application/x-www-form-urlencoded" },
-                body: params.toString(),
-            });
-            if (!response.ok) {
-                const body = await response.text();
-                logger.error(`Token exchange failed (${response.status}): ${body}`);
-                throw new ServerError(`Token exchange failed: ${response.status}`);
+            // All checks passed — permanently consume the proxy code.
+            legacyRestorable = null;
+            if (reservedProxyCode) {
+                this._usedProxyCodes.commit(reservedProxyCode.hash, reservedProxyCode.id);
+                reservedProxyCode = null;
             }
-            const data = await response.json();
-            tokens = OAuthTokensSchema.parse(data);
+            return tokens;
         }
-        if (this._allowedGroups) {
-            const isMember = await this._checkGroupMembership(tokens.access_token);
-            if (!isMember) {
-                logger.warn({ allowedGroups: this._allowedGroups }, "Token issuance denied: user is not a member of any allowed group");
-                throw new ServerError("Access denied: user is not a member of an allowed group");
+        catch (err) {
+            if (legacyRestorable) {
+                this._storedTokens.set(legacyRestorable.code, legacyRestorable.entry);
             }
+            if (reservedProxyCode) {
+                this._usedProxyCodes.release(reservedProxyCode.hash, reservedProxyCode.id);
+            }
+            throw err;
         }
-        return tokens;
     }
     /**
      * Returns true if the token owner belongs to at least one group whose
@@ -480,9 +535,18 @@ class GitLabOAuthServerProvider {
     }
     // ---- Verify access token -----------------------------------------------
     async verifyAccessToken(token) {
-        const res = await fetch(`${this._gitlabBaseUrl}/oauth/token/info`, {
+        let res = await fetch(`${this._gitlabBaseUrl}/oauth/token/info`, {
             headers: { Authorization: `Bearer ${token}` },
         });
+        if (res.status === 401) {
+            // Some GitLab instances sit behind an edge cache that strips the
+            // Authorization header on /oauth/* paths (observed on
+            // git.drupalcode.org, fronted by Varnish), so a valid token 401s
+            // here while working fine against /api/v4. Doorkeeper also accepts
+            // the RFC 6750 access_token query parameter — retry with that form
+            // before rejecting the token.
+            res = await fetch(`${this._gitlabBaseUrl}/oauth/token/info?access_token=${encodeURIComponent(token)}`);
+        }
         if (!res.ok) {
             throw new InvalidTokenError("Invalid or expired GitLab OAuth token");
         }

package/build/schemas.js

@@ -309,8 +309,10 @@ export const GitLabCiLintResultSchema = z.object({
     valid: z.coerce.boolean(),
     errors: z.array(z.string()),
     warnings: z.array(z.string()).optional(),
-    merged_yaml: z.string().optional(),
-    includes: z.array(z.unknown()).optional(),
+    // GitLab sends null (not an omitted field) for both when the config is
+    // invalid, which is exactly when this tool is called. See #638.
+    merged_yaml: z.string().nullish(),
+    includes: z.array(z.unknown()).nullish(),
     jobs: z.array(z.unknown()).optional(),
 });
 export const ValidateCiLintSchema = z.object({
@@ -2941,6 +2943,22 @@ export const ListProjectMembersSchema = z.object({
         .describe("Number of items per page (default: 20, max: 100)"),
     page: z.coerce.number().optional().describe("Page number for pagination (default: 1)"),
 });
+// Schema for listing group members
+export const ListGroupMembersSchema = z.object({
+    group_id: z.string().describe("Group ID or URL-encoded path"),
+    query: z.string().optional().describe("Search for members by name or username"),
+    user_ids: z.array(z.coerce.number()).optional().describe("Filter by user IDs"),
+    skip_users: z.array(z.coerce.number()).optional().describe("User IDs to exclude"),
+    include_inheritance: z.coerce
+        .boolean()
+        .optional()
+        .describe("Include inherited members. Defaults to false."),
+    per_page: z.coerce
+        .number()
+        .optional()
+        .describe("Number of items per page (default: 20, max: 100)"),
+    page: z.coerce.number().optional().describe("Page number for pagination (default: 1)"),
+});
 // Schema for GitLab project member
 export const GitLabProjectMemberSchema = z.object({
     id: z.coerce.number(),