@zereight/mcp-gitlab 2.1.61 → 2.1.63

package/build/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { getConfig, ENABLE_DYNAMIC_API_URL, ENABLE_DYNAMIC_PROJECT_SCOPE, ENABLE_STRICT_PROJECT_SCOPE, GITLAB_AUTH_COOKIE_PATH, GITLAB_ALLOW_UNAUTHENTICATED_TOOL_DISCOVERY, GITLAB_CA_CERT_PATH, GITLAB_JOB_TOKEN, GITLAB_MCP_OAUTH, GITLAB_OAUTH_APP_ID, GITLAB_OAUTH_SCOPES, GITLAB_OAUTH_CALLBACK_PROXY, GITLAB_PERSONAL_ACCESS_TOKEN, GITLAB_POOL_MAX_SIZE, GITLAB_DISABLE_VERSION_CHECK, GITLAB_READ_ONLY_MODE, GITLAB_PERMISSION_MODE, GITLAB_TOOLSETS_RAW, GITLAB_TOOLS_RAW, HOST, HTTP_PROXY, HTTPS_PROXY, IS_OLD, MCP_SERVER_URL, NODE_TLS_REJECT_UNAUTHORIZED, NO_PROXY, OAUTH_STATELESS_CLIENT_TTL_SECONDS, OAUTH_STATELESS_MODE, OAUTH_STATELESS_PENDING_TTL_SECONDS, OAUTH_STATELESS_SESSION_TTL_SECONDS, OAUTH_STATELESS_STORED_TTL_SECONDS, PORT, REMOTE_AUTHORIZATION, SESSION_TIMEOUT_SECONDS, SSE, STREAMABLE_HTTP, MCP_TRUST_PROXY, USE_GITLAB_WIKI, USE_MILESTONE, USE_OAUTH, USE_PIPELINE, GITLAB_TOOL_POLICY_APPROVE_RAW, GITLAB_TOOL_POLICY_HIDDEN_RAW, GITLAB_OAUTH_ALLOWED_GROUPS_RAW, GITLAB_ALLOWED_GROUPS_RAW, GITLAB_OAUTH_ALLOWED_GROUPS, } from "./config.js";
+import { getConfig, ENABLE_DYNAMIC_API_URL, ENABLE_DYNAMIC_PROJECT_SCOPE, ENABLE_STRICT_PROJECT_SCOPE, GITLAB_AUTH_COOKIE_PATH, GITLAB_ALLOW_UNAUTHENTICATED_TOOL_DISCOVERY, GITLAB_CA_CERT_PATH, GITLAB_JOB_TOKEN, GITLAB_MCP_OAUTH, GITLAB_OAUTH_APP_ID, GITLAB_OAUTH_SCOPES, GITLAB_OAUTH_CALLBACK_PROXY, GITLAB_PERSONAL_ACCESS_TOKEN, GITLAB_POOL_MAX_SIZE, GITLAB_DISABLE_VERSION_CHECK, GITLAB_READ_ONLY_MODE, GITLAB_MASKING_ENABLED, GITLAB_MASKING_CONFIG, GITLAB_MASKING_POLICY_FILE, GITLAB_MASKING_WORKSPACE_DIR, GITLAB_PERMISSION_MODE, GITLAB_TOOLSETS_RAW, GITLAB_TOOLS_RAW, HOST, HTTP_PROXY, HTTPS_PROXY, IS_OLD, MCP_SERVER_URL, NODE_TLS_REJECT_UNAUTHORIZED, NO_PROXY, OAUTH_STATELESS_CLIENT_TTL_SECONDS, OAUTH_STATELESS_MODE, OAUTH_STATELESS_PENDING_TTL_SECONDS, OAUTH_STATELESS_SESSION_TTL_SECONDS, OAUTH_STATELESS_STORED_TTL_SECONDS, PORT, REMOTE_AUTHORIZATION, SESSION_TIMEOUT_SECONDS, SSE, STREAMABLE_HTTP, MCP_TRUST_PROXY, USE_GITLAB_WIKI, USE_MILESTONE, USE_OAUTH, USE_PIPELINE, GITLAB_TOOL_POLICY_APPROVE_RAW, GITLAB_TOOL_POLICY_HIDDEN_RAW, GITLAB_OAUTH_ALLOWED_GROUPS_RAW, GITLAB_ALLOWED_GROUPS_RAW, GITLAB_OAUTH_ALLOWED_GROUPS, } from "./config.js";
 /** True when the server is running in remote/network mode (SSE or StreamableHTTP transport). */
 const IS_REMOTE = SSE || STREAMABLE_HTTP;
 const STREAMABLE_HTTP_AUTH_TOKEN = getConfig("streamable-http-auth-token", "STREAMABLE_HTTP_AUTH_TOKEN");
@@ -95,6 +95,7 @@ import { graphqlQueryContainsWriteOperation, graphqlQueryContainsDeleteOperation
 import { resolveNestedWikiUpdateTitle } from "./utils/wiki-title.js";
 import { encodeRepoFilePayloadContent, fileOperationsIncludeDeleteOrMove, toGitLabCommitActions, } from "./utils/gitlab-commit-actions.js";
 import { redactSensitiveGitLabFields } from "./utils/redact-sensitive.js";
+import { createMaskingPolicyResolver, getManagedMaskingProjectIds, } from "./masking/index.js";
 import { checkForNewVersion } from "./utils/version-check.js";
 import { assertGitLabVersionAtLeast } from "./utils/gitlab-version-gate.js";
 import { parseGitLabVersionApiResponse, } from "./utils/gitlab-instance-version.js";
@@ -111,10 +112,18 @@ 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, GitLabPipelineScheduleSchema, GitLabPipelineScheduleVariableSchema, GitLabPipelineSchedulePlayResultSchema, ListPipelineSchedulesSchema, GetPipelineScheduleSchema, ListPipelineSchedulePipelinesSchema, CreatePipelineScheduleSchema, UpdatePipelineScheduleSchema, DeletePipelineScheduleSchema, PlayPipelineScheduleSchema, TakeOwnershipPipelineScheduleSchema, GetPipelineScheduleVariableSchema, CreatePipelineScheduleVariableSchema, UpdatePipelineScheduleVariableSchema, DeletePipelineScheduleVariableSchema, 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, ListGroupMergeRequestsSchema, 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, OrbitQuerySchema, OrbitSchemaSchema, OrbitStatusSchema, OrbitToolsSchema, 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, CreateWebhookSchema, UpdateWebhookSchema, DeleteWebhookSchema, ListWebhookEventsSchema, GetWebhookEventSchema, HealthCheckSchema, } from "./schemas.js";
+GetMergeRequestFileDiffSchema, ListMergeRequestChangedFilesSchema, ListMergeRequestDiscussionsSchema, ListMergeRequestPipelinesSchema, ListMergeRequestsSchema, ListGroupMergeRequestsSchema, 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, OrbitQuerySchema, OrbitSchemaSchema, OrbitStatusSchema, OrbitToolsSchema, 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, GetMergeRequestDiscussionSchema, DeleteMergeRequestDiscussionNoteSchema, ResolveMergeRequestThreadSchema, GetWorkItemSchema, ListWorkItemsSchema, CreateWorkItemSchema, UpdateWorkItemSchema, ConvertWorkItemTypeSchema, ListWorkItemStatusesSchema, ListWorkItemNotesSchema, CreateWorkItemNoteSchema, CreateWorkItemEmojiReactionSchema, CreateWorkItemNoteEmojiReactionSchema, ListWorkItemEmojiReactionsSchema, ListWorkItemNoteEmojiReactionsSchema, DeleteWorkItemEmojiReactionSchema, DeleteWorkItemNoteEmojiReactionSchema, MoveWorkItemSchema, ListCustomFieldDefinitionsSchema, GetTimelineEventsSchema, CreateTimelineEventSchema, ListWebhooksSchema, CreateWebhookSchema, UpdateWebhookSchema, DeleteWebhookSchema, ListWebhookEventsSchema, GetWebhookEventSchema, HealthCheckSchema, } from "./schemas.js";
 import { randomUUID, timingSafeEqual, } from "node:crypto";
 import { createLogger } from "./utils/logger.js";
 const logger = createLogger();
+// Construct once at startup. When disabled this is undefined and the result
+// path below returns the original objects without reading a config file.
+const maskingPolicyResolver = createMaskingPolicyResolver({
+    enabled: GITLAB_MASKING_ENABLED,
+    configPath: GITLAB_MASKING_CONFIG,
+    policyFilePath: GITLAB_MASKING_POLICY_FILE,
+    workspaceDir: GITLAB_MASKING_WORKSPACE_DIR,
+});
 const SERVER_NAME = process.env.MCP_SERVER_NAME?.trim() || "zereight-gitlab-mcp-server";
 /**
  * Static MCP prompt catalog. These wrap the multi-step tool workflows documented in
@@ -292,22 +301,74 @@ function createServer() {
         const sessionId = request.params.sessionId;
         const toolName = request.params.name;
         const start = Date.now();
+        let maskingEngine;
         const logCompletion = (result) => {
             const durationMs = Date.now() - start;
             logger.info({ tool: toolName, event: "tool_call_done", durationMs }, `tool_call_done: ${toolName} (${durationMs}ms)`);
-            return result;
+            const isPlainTextResult = toolName === "get_pipeline_job_output" ||
+                toolName === "get_job_artifact_file" ||
+                (toolName === "download_release_asset" && !IS_REMOTE);
+            return maskingEngine
+                ? maskingEngine.maskToolResult(result, { textFormat: isPlainTextResult ? "plain" : "json" })
+                : result;
         };
         const logError = (error) => {
             const durationMs = Date.now() - start;
+            const safeError = maskingEngine ? maskingEngine.maskError(error) : error;
             logger.error({
                 tool: toolName,
                 event: "tool_call_error",
                 durationMs,
-                error: error instanceof Error ? error.message : String(error),
+                error: safeError instanceof Error ? safeError.message : String(safeError),
             }, `tool_call_error: ${toolName} (${durationMs}ms)`);
-            throw error;
+            throw safeError;
         };
         try {
+            const authData = (REMOTE_AUTHORIZATION || GITLAB_MCP_OAUTH) && sessionId
+                ? authBySession[sessionId]
+                : undefined;
+            const sessionContext = authData
+                ? {
+                    sessionId,
+                    header: authData.header,
+                    token: authData.token,
+                    lastUsed: authData.lastUsed,
+                    apiUrl: authData.apiUrl,
+                    publicBaseUrl: authData.publicBaseUrl,
+                    allowedProjectIds: authData.allowedProjectIds,
+                }
+                : undefined;
+            const selectMaskingPolicy = () => {
+                const isToolDiscovery = toolName === "discover_tools";
+                const inputSchema = allTools.find(tool => tool.name === toolName)?.inputSchema;
+                // Optional project fields can be filters on global queries. Only supply
+                // the default when the corresponding handler actually uses it. Keep this
+                // list synchronized with getFileContents, listMyIssues, listIssues, and
+                // listMergeRequests: those are the handlers with optional project input
+                // that may call getEffectiveProjectId("") at runtime.
+                const usesDefaultProject = inputSchema?.required?.includes("project_id") ||
+                    toolName === "get_file_contents" ||
+                    (toolName === "my_issues" &&
+                        (Boolean(GITLAB_PROJECT_ID) || getEffectiveAllowedProjectIds().length > 0)) ||
+                    ((toolName === "list_issues" || toolName === "list_merge_requests") &&
+                        ENABLE_STRICT_PROJECT_SCOPE &&
+                        getEffectiveAllowedProjectIds().length > 0);
+                const maskingScope = maskingPolicyResolver
+                    ? getManagedMaskingProjectIds(inputSchema, request.params.arguments, maskingPolicyResolver.managed && usesDefaultProject
+                        ? () => getEffectiveProjectId("")
+                        : undefined)
+                    : undefined;
+                return maskingPolicyResolver?.select({
+                    gitlabInstance: getEffectiveApiUrl(),
+                    ...maskingScope,
+                    // Tool discovery does not access GitLab data and must remain available
+                    // under the default managed-policy setting.
+                    allowBuiltinForUnscoped: isToolDiscovery,
+                });
+            };
+            maskingEngine = sessionContext
+                ? sessionAuthStore.run(sessionContext, selectMaskingPolicy)
+                : selectMaskingPolicy();
             // Handle discover_tools meta-tool directly (needs access to mcpServer and filteredTools)
             if (toolName === "discover_tools") {
                 const category = request.params.arguments?.category?.trim()?.toLowerCase();
@@ -421,18 +482,9 @@ function createServer() {
                 const { _confirmed, ...cleanArgs } = request.params.arguments || {};
                 request.params.arguments = cleanArgs;
             }
-            if ((REMOTE_AUTHORIZATION || GITLAB_MCP_OAUTH) && sessionId && authBySession[sessionId]) {
-                const authData = authBySession[sessionId];
-                const sessionContext = {
-                    sessionId,
-                    header: authData.header,
-                    token: authData.token,
-                    lastUsed: authData.lastUsed,
-                    apiUrl: authData.apiUrl,
-                    publicBaseUrl: authData.publicBaseUrl,
-                    allowedProjectIds: authData.allowedProjectIds,
-                };
-                // Run the handler within the retrieved context
+            if (sessionContext) {
+                // Policy selection and the tool handler must use the same request-local
+                // API URL and project allowlist.
                 const result = await sessionAuthStore.run(sessionContext, () => handleToolCall(request.params));
                 return logCompletion(result);
             }
@@ -1248,13 +1300,17 @@ async function handleGitLabError(response) {
         const errorBody = await response.text();
         // Check specifically for Rate Limit error
         if (response.status === 403 && errorBody.includes("User API Key Rate limit exceeded")) {
-            logger.error({ err: errorBody }, "GitLab API Rate Limit Exceeded");
+            // Do not log the upstream body here; it is masked on the error object
+            // before the common tool-call boundary returns/logs it.
+            logger.error("GitLab API Rate Limit Exceeded");
             logger.error("User API Key Rate limit exceeded. Please try again later.");
-            throw new Error(`GitLab API Rate Limit Exceeded: ${errorBody}`);
+            const error = new Error(`GitLab API Rate Limit Exceeded: ${errorBody}`);
+            throw error;
         }
         else {
             // Handle other API errors
-            throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
+            const error = new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorBody}`);
+            throw error;
         }
     }
 }
@@ -3408,6 +3464,17 @@ async function getMergeRequestNote(projectId, mergeRequestIid, noteId) {
     const data = await response.json();
     return GitLabDiscussionNoteSchema.parse(data);
 }
+async function getMergeRequestDiscussion(projectId, mergeRequestIid, discussionId) {
+    projectId = decodeURIComponent(projectId); // Decode project ID
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${encodeGitLabPathSegment(mergeRequestIid)}/discussions/${encodeGitLabPathSegment(discussionId)}`);
+    const response = await fetch(url.toString(), {
+        ...getFetchConfig(),
+        method: "GET",
+    });
+    await handleGitLabError(response);
+    const data = await response.json();
+    return GitLabDiscussionSchema.parse(data);
+}
 async function getMergeRequestNotes(projectId, mergeRequestIid, sort, order_by, per_page, page) {
     projectId = decodeURIComponent(projectId); // Decode project ID
     const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${encodeGitLabPathSegment(mergeRequestIid)}/notes`);
@@ -7957,6 +8024,13 @@ async function handleToolCall(params) {
                     content: [{ type: "text", text: JSON.stringify(note) }],
                 };
             }
+            case "get_merge_request_discussion": {
+                const args = GetMergeRequestDiscussionSchema.parse(params.arguments);
+                const discussion = await getMergeRequestDiscussion(args.project_id, args.merge_request_iid, args.discussion_id);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(discussion) }],
+                };
+            }
             case "get_merge_request_notes": {
                 const args = GetMergeRequestNotesSchema.parse(params.arguments);
                 const notes = await getMergeRequestNotes(args.project_id, args.merge_request_iid, args.sort, args.order_by, args.per_page, args.page);
@@ -10233,6 +10307,7 @@ async function handleToolCall(params) {
                                 status: authenticated ? "ok" : "error",
                                 authenticated,
                                 gitlab_url: getEffectiveApiUrl(),
+                                mcp_server_version: SERVER_VERSION,
                                 ...(versionMetadata ?? {}),
                             }),
                         },
@@ -10389,7 +10464,7 @@ async function handleToolCall(params) {
         // 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
+            throw new Error(`Invalid arguments: ${error.issues
                 .map(e => `${e.path.join(".")}: ${e.message}`)
                 .join(", ")}`);
         }
@@ -11583,6 +11658,7 @@ async function startStreamableHTTPServer() {
         }
         res.status(isHealthy ? 200 : 503).json({
             status: isHealthy ? "healthy" : "degraded",
+            version: SERVER_VERSION,
             activeSessions,
             maxSessions: MAX_SESSIONS,
             uptime: process.uptime(),

package/build/masking/engine.js

@@ -0,0 +1,404 @@
+import fs from "node:fs";
+import path from "node:path";
+const BUILTIN_RULES = [
+    {
+        id: "gitlab-token",
+        type: "regex",
+        // GitLab token prefixes documented at
+        // https://docs.gitlab.com/security/token_overview/#token-prefixes
+        pattern: "\\bgl(?:pat|rt|ptt|dt|cbt|soat|oas|agent|ft|imt)-[A-Za-z0-9_-]{20,}\\b",
+        flags: "g",
+        replacement: "[Token masked]",
+    },
+    {
+        id: "ipv4",
+        type: "regex",
+        pattern: "\\b(?:25[0-5]|2[0-4]\\d|1?\\d?\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1?\\d?\\d)){3}\\b",
+        flags: "g",
+        replacement: "[IP address]",
+    },
+    {
+        id: "ipv6",
+        type: "regex",
+        pattern: "(?<![0-9A-Fa-f:])(?:(?:[0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}|(?:[0-9A-Fa-f]{1,4}:){1,7}:|(?:[0-9A-Fa-f]{1,4}:){1,6}:[0-9A-Fa-f]{1,4}|(?:[0-9A-Fa-f]{1,4}:){1,5}(?::[0-9A-Fa-f]{1,4}){1,2}|(?:[0-9A-Fa-f]{1,4}:){1,4}(?::[0-9A-Fa-f]{1,4}){1,3}|(?:[0-9A-Fa-f]{1,4}:){1,3}(?::[0-9A-Fa-f]{1,4}){1,4}|(?:[0-9A-Fa-f]{1,4}:){1,2}(?::[0-9A-Fa-f]{1,4}){1,5}|[0-9A-Fa-f]{1,4}:(?:(?::[0-9A-Fa-f]{1,4}){1,6})|:(?:(?::[0-9A-Fa-f]{1,4}){1,7}|:))(?![0-9A-Fa-f:])",
+        flags: "g",
+        replacement: "[IP address]",
+    },
+];
+const ALLOWED_REGEX_FLAGS = new Set(["g", "i", "m", "s", "u"]);
+function assertString(value, field) {
+    if (typeof value !== "string")
+        throw new Error(`${field} must be a string`);
+    return value;
+}
+function compileRule(rule, order) {
+    if (!rule || typeof rule !== "object")
+        throw new Error(`Invalid mask rule at index ${order}`);
+    const id = assertString(rule.id, `mask rule ${order}.id`);
+    if (!id)
+        throw new Error(`mask rule ${order}.id must not be empty`);
+    const replacement = assertString(rule.replacement, `mask rule ${id}.replacement`);
+    let source;
+    let flags;
+    if (rule.type === "keyword") {
+        const match = assertString(rule.match, `mask rule ${id}.match`);
+        if (!match)
+            throw new Error(`mask rule ${id}.match must not be empty`);
+        source = escapeRegExp(match);
+        flags = rule.caseSensitive === false ? "gi" : "g";
+    }
+    else if (rule.type === "regex") {
+        source = assertString(rule.pattern, `mask rule ${id}.pattern`);
+        flags = rule.flags ?? "g";
+        if (!flags.includes("g"))
+            flags += "g";
+        if ([...flags].some(flag => !ALLOWED_REGEX_FLAGS.has(flag))) {
+            throw new Error(`mask rule ${id}.flags contains an unsupported flag`);
+        }
+        if (source.length === 0)
+            throw new Error(`mask rule ${id}.pattern must not be empty`);
+    }
+    else {
+        throw new Error(`mask rule ${id}.type must be "keyword" or "regex"`);
+    }
+    let expression;
+    try {
+        expression = new RegExp(source, flags);
+    }
+    catch (error) {
+        throw new Error(`Invalid regular expression in mask rule ${id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Empty matches can make a rule unexpectedly rewrite every character and are
+    // particularly easy to create accidentally with a configurable expression.
+    if (expression.test(""))
+        throw new Error(`mask rule ${id} must not match an empty string`);
+    return { id, replacement, expression, order };
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function mergeBuiltinRules(file) {
+    const overrides = file?.builtins ?? {};
+    return BUILTIN_RULES.flatMap(rule => {
+        const override = overrides[rule.id];
+        if (override?.enabled === false)
+            return [];
+        return [
+            {
+                ...rule,
+                ...(override?.replacement !== undefined ? { replacement: override.replacement } : {}),
+            },
+        ];
+    });
+}
+function loadFile(configPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Unable to load masking config ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Masking config ${configPath} must contain a JSON object`);
+    }
+    if (isManagedReference(parsed)) {
+        const value = parsed;
+        if (value.version !== 2 || typeof value.policyGroup !== "string" || !value.policyGroup.trim()) {
+            throw new Error(`Managed masking config ${configPath} requires version 2 and a non-empty policyGroup`);
+        }
+        return value;
+    }
+    validateMaskingFile(parsed, `Masking config ${configPath}`);
+    return parsed;
+}
+function loadJsonFile(configPath) {
+    try {
+        return JSON.parse(fs.readFileSync(configPath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Unable to load masking config ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function normalizeGitLabInstance(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error(`Invalid managed masking GitLab instance: ${value}`);
+    }
+    return `${url.protocol}//${url.host}${url.pathname.replace(/\/api\/v4\/?$/, "").replace(/\/+$/, "")}`;
+}
+function isManagedReference(value) {
+    return Boolean(value && typeof value === "object" && value.mode === "managed");
+}
+function loadManagedPolicyFile(configPath) {
+    const parsed = loadJsonFile(configPath);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Managed masking policy file ${configPath} must contain a JSON object`);
+    }
+    const file = parsed;
+    if (file.version !== 1)
+        throw new Error("Unsupported managed masking policy version");
+    if (!file.policyGroups ||
+        typeof file.policyGroups !== "object" ||
+        Array.isArray(file.policyGroups)) {
+        throw new Error("Managed masking policy file policyGroups must be an object");
+    }
+    if (!Array.isArray(file.bindings))
+        throw new Error("Managed masking policy file bindings must be an array");
+    if (file.unboundProjectBehavior !== undefined &&
+        file.unboundProjectBehavior !== "deny" &&
+        file.unboundProjectBehavior !== "builtin") {
+        throw new Error('Managed masking policy file unboundProjectBehavior must be "deny" or "builtin"');
+    }
+    for (const [name, policy] of Object.entries(file.policyGroups)) {
+        if (!name.trim())
+            throw new Error("Managed masking policy group names must not be empty");
+        validateMaskingFile(policy, `managed masking policy group ${name}`);
+    }
+    for (const binding of file.bindings) {
+        if (!binding ||
+            typeof binding !== "object" ||
+            typeof binding.gitlabInstance !== "string" ||
+            typeof binding.policyGroup !== "string" ||
+            !Array.isArray(binding.projectIds)) {
+            throw new Error("Invalid managed masking policy binding");
+        }
+        normalizeGitLabInstance(binding.gitlabInstance);
+        if (!file.policyGroups[binding.policyGroup]) {
+            throw new Error(`Managed masking policy binding references unknown group: ${binding.policyGroup}`);
+        }
+        if (binding.projectIds.some(id => !Number.isSafeInteger(id) || id <= 0)) {
+            throw new Error("Managed masking policy binding projectIds must be positive integers");
+        }
+    }
+    return file;
+}
+function validateMaskingFile(value, description) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${description} must contain a JSON object`);
+    }
+    const file = value;
+    if (file.version !== undefined && file.version !== 1) {
+        throw new Error(`Unsupported masking config version: ${String(file.version)}`);
+    }
+    if (file.rules !== undefined && !Array.isArray(file.rules)) {
+        throw new Error(`${description}.rules must be an array`);
+    }
+}
+function maskStrings(value, mask, parentKey) {
+    if (typeof value === "string") {
+        const masked = mask(value);
+        return masked !== value && parentKey === "download_url" ? "[Download URL masked]" : masked;
+    }
+    if (Array.isArray(value))
+        return value.map(item => maskStrings(item, mask, parentKey));
+    if (value && typeof value === "object") {
+        const output = {};
+        for (const [key, item] of Object.entries(value))
+            output[key] = maskStrings(item, mask, key);
+        return output;
+    }
+    return value;
+}
+function maskJsonText(text, mask) {
+    try {
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== "object")
+            return mask(text);
+    }
+    catch {
+        return mask(text);
+    }
+    // Rewrite only JSON string values. Re-serializing the parsed object would
+    // change whitespace and lose precision in numeric values from GitLab.
+    let propertyKey;
+    return text.replace(/"(?:\\.|[^"\\])*"/g, (literal, offset) => {
+        const value = JSON.parse(literal);
+        if (/^\s*:/.test(text.slice(offset + literal.length))) {
+            propertyKey = value;
+            return literal;
+        }
+        const masked = mask(value);
+        if (masked === value)
+            return literal;
+        const isDownloadUrl = propertyKey === "download_url" && /:\s*$/.test(text.slice(0, offset));
+        return JSON.stringify(isDownloadUrl ? "[Download URL masked]" : masked);
+    });
+}
+function createMaskingEngineFromFile(file, configPath) {
+    const rules = [...(file.rules ?? []), ...mergeBuiltinRules(file)].map(compileRule);
+    const maskedErrors = new WeakSet();
+    const maskText = (text) => {
+        const matches = [];
+        for (const rule of rules) {
+            rule.expression.lastIndex = 0;
+            let match;
+            while ((match = rule.expression.exec(text)) !== null) {
+                const start = match.index;
+                const end = start + match[0].length;
+                if (end === start)
+                    throw new Error(`mask rule ${rule.id} produced an empty match`);
+                matches.push({ start, end, replacement: rule.replacement, order: rule.order });
+                if (!rule.expression.global)
+                    break;
+            }
+        }
+        if (matches.length === 0)
+            return text;
+        matches.sort((a, b) => a.start - b.start || b.end - b.start - (a.end - a.start) || a.order - b.order);
+        const coveredMatches = [];
+        for (const match of matches) {
+            const previous = coveredMatches[coveredMatches.length - 1];
+            if (previous && match.start < previous.end) {
+                // Preserve the selected replacement, but cover the entire overlapping
+                // interval so a longer secret cannot survive behind a shorter match.
+                previous.end = Math.max(previous.end, match.end);
+            }
+            else {
+                coveredMatches.push({ ...match });
+            }
+        }
+        let output = "";
+        let cursor = 0;
+        for (const match of coveredMatches) {
+            output += text.slice(cursor, match.start) + match.replacement;
+            cursor = match.end;
+        }
+        return output + text.slice(cursor);
+    };
+    return {
+        configPath,
+        maskText,
+        maskValue: (value) => maskStrings(value, maskText),
+        maskToolResult: (result, options) => {
+            const output = { ...result };
+            if (Array.isArray(output.content))
+                output.content = output.content.map(item => {
+                    if (!item || typeof item !== "object")
+                        return item;
+                    const block = { ...item };
+                    if (typeof block.text === "string") {
+                        block.text =
+                            options?.textFormat === "plain"
+                                ? maskText(block.text)
+                                : maskJsonText(block.text, maskText);
+                    }
+                    return block;
+                });
+            if (output.structuredContent !== undefined)
+                output.structuredContent = maskStrings(output.structuredContent, maskText);
+            return output;
+        },
+        maskError: (error) => {
+            if (error instanceof Error && !maskedErrors.has(error)) {
+                error.message = maskText(error.message);
+                maskedErrors.add(error);
+            }
+            return error;
+        },
+    };
+}
+export function createMaskingEngine(options) {
+    if (!options.enabled)
+        return undefined;
+    const workspaceDir = path.resolve(options.workspaceDir ?? process.cwd());
+    const configPath = options.configPath
+        ? path.resolve(workspaceDir, options.configPath)
+        : path.join(workspaceDir, ".gitlab-mcp-mask.json");
+    if (options.configPath && !fs.existsSync(configPath)) {
+        throw new Error(`Configured masking config does not exist: ${configPath}`);
+    }
+    const file = fs.existsSync(configPath) ? loadFile(configPath) : undefined;
+    if (isManagedReference(file))
+        throw new Error("Managed masking references require a managed policy resolver");
+    return createMaskingEngineFromFile(file ?? {}, fs.existsSync(configPath) ? configPath : undefined);
+}
+/**
+ * Selects a compiled policy for each tool request. In managed mode this keeps
+ * the secret rules on the server while the workspace carries only a group name.
+ */
+export function createMaskingPolicyResolver(options) {
+    if (!options.enabled)
+        return undefined;
+    const workspaceDir = path.resolve(options.workspaceDir ?? process.cwd());
+    const localConfigPath = options.configPath
+        ? path.resolve(workspaceDir, options.configPath)
+        : path.join(workspaceDir, ".gitlab-mcp-mask.json");
+    if (options.configPath && !fs.existsSync(localConfigPath)) {
+        throw new Error(`Configured masking config does not exist: ${localConfigPath}`);
+    }
+    const localConfig = fs.existsSync(localConfigPath) ? loadFile(localConfigPath) : undefined;
+    const localGroup = isManagedReference(localConfig) ? localConfig.policyGroup : undefined;
+    if (!options.policyFilePath) {
+        if (localGroup)
+            throw new Error("Managed masking config requires GITLAB_MASKING_POLICY_FILE");
+        const localEngine = createMaskingEngineFromFile(localConfig ?? {}, localConfigPath);
+        return { managed: false, select: () => localEngine };
+    }
+    const policyPath = path.resolve(workspaceDir, options.policyFilePath);
+    const policyFile = loadManagedPolicyFile(policyPath);
+    if (localGroup && !policyFile.policyGroups[localGroup]) {
+        throw new Error(`Managed masking config references unknown policy group: ${localGroup}`);
+    }
+    const engines = new Map();
+    for (const [name, policy] of Object.entries(policyFile.policyGroups)) {
+        engines.set(name, createMaskingEngineFromFile(policy, policyPath));
+    }
+    const builtinEngine = createMaskingEngineFromFile({}, policyPath);
+    const bindings = new Map();
+    for (const binding of policyFile.bindings) {
+        const instance = normalizeGitLabInstance(binding.gitlabInstance);
+        for (const projectId of binding.projectIds) {
+            const key = `${instance}#${projectId}`;
+            const existing = bindings.get(key);
+            if (existing && existing !== binding.policyGroup) {
+                throw new Error(`Managed masking policy has conflicting bindings for ${key}`);
+            }
+            bindings.set(key, binding.policyGroup);
+        }
+    }
+    return {
+        managed: true,
+        select: ({ gitlabInstance, projectIds = [], hasProjectScope = projectIds.length > 0, allowBuiltinForUnscoped = false, }) => {
+            const numericProjectIds = projectIds.map(projectId => {
+                if (typeof projectId === "number" && Number.isSafeInteger(projectId) && projectId > 0) {
+                    return projectId;
+                }
+                if (typeof projectId === "string" && /^\d+$/.test(projectId)) {
+                    const numericProjectId = Number(projectId);
+                    if (Number.isSafeInteger(numericProjectId) && numericProjectId > 0)
+                        return numericProjectId;
+                }
+                throw new Error("Managed masking requires numeric project IDs");
+            });
+            if (numericProjectIds.length === 0) {
+                if (hasProjectScope)
+                    throw new Error("Managed masking requires a project ID");
+                if (allowBuiltinForUnscoped || policyFile.unboundProjectBehavior === "builtin")
+                    return builtinEngine;
+                throw new Error("Managed masking policy does not cover this project-less tool");
+            }
+            const groups = new Set();
+            for (const projectId of numericProjectIds) {
+                const group = bindings.get(`${normalizeGitLabInstance(gitlabInstance)}#${projectId}`);
+                if (!group)
+                    throw new Error("No managed masking policy is bound to this GitLab project");
+                groups.add(group);
+            }
+            if (groups.size !== 1) {
+                throw new Error("Managed masking does not allow a tool call to span policy groups");
+            }
+            const [group] = groups;
+            if (localGroup && group !== localGroup) {
+                throw new Error("Managed masking policy group does not match the server project binding");
+            }
+            const engine = engines.get(group);
+            if (!engine)
+                throw new Error(`Managed masking policy group is unavailable: ${group}`);
+            return engine;
+        },
+    };
+}

package/build/masking/index.js

@@ -0,0 +1,2 @@
+export * from "./engine.js";
+export * from "./project-scope.js";