@zereight/mcp-gitlab 2.3.6-next.130 → 2.3.6-next.131

package/README.ko.md

@@ -65,6 +65,8 @@ GitLab은 [공식 MCP 서버](https://docs.gitlab.com/user/model_context_protoco
 - stdio는 `mcp-remote`를 거치며 Node.js 20 이상이 필요합니다.
 - Toolset은 `X-Gitlab-Enabled-Mcp-Server-Toolsets` 헤더를 사용합니다. 선택 헤더 `X-Gitlab-Mcp-Server-Tool-Name-Prefix`는 도구 이름 접두사의 앞 32자만 유지합니다.
 
+[공식 GitLab MCP 서버 전체 비교 →](./docs/comparison/official-gitlab-mcp.md)
+
 빠른 시작: 아래에서 Personal Access Token 또는 OAuth2 설정 중 하나를 선택하고 `@zereight/mcp-gitlab`을 설치한 뒤 MCP 클라이언트 설정에서 `zereight-mcp-gitlab`을 사용하세요.
 
 ### 클라이언트 설정 가이드

package/README.md

@@ -70,6 +70,8 @@ GitLab also ships an [official MCP server](https://docs.gitlab.com/user/model_co
 - stdio goes through `mcp-remote` and needs Node.js 20 or later.
 - Toolsets use the `X-Gitlab-Enabled-Mcp-Server-Toolsets` header. An optional `X-Gitlab-Mcp-Server-Tool-Name-Prefix` header keeps the first 32 characters of a tool-name prefix.
 
+[Full comparison with the official GitLab MCP server →](./docs/comparison/official-gitlab-mcp.md)
+
 Quick start: choose either Personal Access Token or OAuth2 setup below, install `@zereight/mcp-gitlab`, and use `zereight-mcp-gitlab` in your MCP client configuration.
 
 ### Client Setup Guides

package/README.pt-BR.md

@@ -65,6 +65,8 @@ O GitLab também inclui um [servidor MCP oficial](https://docs.gitlab.com/user/m
 - O stdio passa por `mcp-remote` e exige Node.js 20 ou posterior.
 - Os toolsets usam o cabeçalho `X-Gitlab-Enabled-Mcp-Server-Toolsets`. O cabeçalho opcional `X-Gitlab-Mcp-Server-Tool-Name-Prefix` mantém os primeiros 32 caracteres de um prefixo de nome de ferramenta.
 
+[Comparação completa com o servidor MCP oficial do GitLab →](./docs/comparison/official-gitlab-mcp.md)
+
 Início rápido: escolha abaixo uma configuração com Personal Access Token ou OAuth2, instale `@zereight/mcp-gitlab` e use `zereight-mcp-gitlab` na configuração do seu cliente MCP.
 
 ### Guias de configuração de clientes

package/README.zh-CN.md

@@ -65,6 +65,8 @@ GitLab 还提供[官方 MCP 服务器](https://docs.gitlab.com/user/model_contex
 - stdio 通过 `mcp-remote`，需要 Node.js 20 或更高版本。
 - Toolset 使用请求头 `X-Gitlab-Enabled-Mcp-Server-Toolsets`。可选请求头 `X-Gitlab-Mcp-Server-Tool-Name-Prefix` 只保留工具名前缀的前 32 个字符。
 
+[与官方 GitLab MCP 服务器的完整对比 →](./docs/comparison/official-gitlab-mcp.md)
+
 快速开始：在下面选择 Personal Access Token 或 OAuth2 设置，安装 `@zereight/mcp-gitlab`，并在 MCP 客户端配置中使用 `zereight-mcp-gitlab`。
 
 ### 客户端设置指南

package/build/auth-cli.js

@@ -5,7 +5,7 @@ import { deprecatedEnvInputFromSources, getDeprecatedEnvWarnings } from "./depre
 import { GitLabOAuth } from "./oauth.js";
 import { createLogger, flushStartupLogs } from "./utils/logger.js";
 import { stripUrlUserinfo } from "./utils/redact-url.js";
-import { apiUrlUserinfoWarning } from "./utils/url.js";
+import { apiUrlError, apiUrlUserinfoWarning } from "./utils/url.js";
 const logger = createLogger("gitlab-mcp-auth");
 const DEFAULT_API_URL = "https://gitlab.com";
 const DEFAULT_REDIRECT_URI = "http://127.0.0.1:8888/callback";
@@ -77,12 +77,18 @@ export async function runAuthCommandAsync(input = {}) {
         throw new Error("Missing OAuth client ID. Pass --client-id or set GITLAB_OAUTH_CLIENT_ID.");
     }
     const apiUrlFlag = readFlag(argv, "api-url");
+    const apiUrlSource = apiUrlFlag !== undefined ? "--api-url" : "GITLAB_API_URL";
     const configuredApiUrl = stripUrlUserinfo(apiUrlFlag ?? env.GITLAB_API_URL ?? DEFAULT_API_URL);
     if (configuredApiUrl.hadUserinfo) {
-        logger.warn(apiUrlUserinfoWarning(apiUrlFlag !== undefined ? "--api-url" : "GITLAB_API_URL"));
+        logger.warn(apiUrlUserinfoWarning(apiUrlSource));
         flushStartupLogs(logger);
     }
     const apiUrl = configuredApiUrl.url;
+    // The fetch error for a URL that does not parse would print it.
+    const invalidApiUrl = apiUrlError(apiUrlSource, apiUrl);
+    if (invalidApiUrl !== null) {
+        throw new Error(invalidApiUrl);
+    }
     const tokenPath = readFlag(argv, "token-path") ??
         env.GITLAB_OAUTH_TOKEN_PATH ??
         path.join(os.homedir(), ".gitlab-mcp-token.json");

package/build/cli/output.js

@@ -1,5 +1,5 @@
 import { renderTable } from "./tables.js";
-import { redactUrlSecretsInText } from "../utils/redact-url.js";
+import { redactUrlSecretsInErrorMessage } from "../utils/redact-url.js";
 export function formatToolOutput(input) {
     const isError = resultIsError(input.result);
     const text = unwrapToolText(input.result);
@@ -18,8 +18,7 @@ export function formatToolOutput(input) {
     return { stdout: rendered.stdout, stderr: rendered.stderr, isError };
 }
 export function formatCliError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return `${redactSecrets(message)}\n`;
+    return `${redactGitLabTokens(redactUrlSecretsInErrorMessage(error))}\n`;
 }
 export function resultIsError(result) {
     return isRecord(result) && result.isError === true;
@@ -58,8 +57,8 @@ function stringifyUnknown(value) {
 function ensureTrailingNewline(text) {
     return text.endsWith("\n") ? text : `${text}\n`;
 }
-function redactSecrets(message) {
-    return redactUrlSecretsInText(message).replace(/glpat-[A-Za-z0-9_-]+/g, "[REDACTED]");
+function redactGitLabTokens(message) {
+    return message.replace(/glpat-[A-Za-z0-9_-]+/g, "[REDACTED]");
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);

package/build/index.js

@@ -94,14 +94,14 @@ import { listMcpResources, listMcpResourceTemplates, readMcpResource, } from "./
 import { getMcpPrompt, listMcpPrompts } from "./server/mcp-prompts.js";
 import { isInitializationRequestBody, isUnauthenticatedDiscoveryRequestBody, readAcceptHeader, readMcpSessionIdHeader, redactSessionIdForLog, } from "./server/request-helpers.js";
 export { readMcpSessionIdHeader } from "./server/request-helpers.js";
-import { apiUrlUserinfoWarning, encodeGitLabPath, encodeGitLabPathSegment, isCleartextRemoteUrl, normalizeGitLabApiUrl, parseConfiguredGitLabApiUrls, } from "./utils/url.js";
+import { apiUrlUserinfoWarning, commaSplitHint, configuredApiUrlErrors, encodeGitLabPath, encodeGitLabPathSegment, invalidListEntryError, isCleartextRemoteUrl, normalizeGitLabApiUrl, parseConfiguredGitLabApiUrls, } from "./utils/url.js";
 import { estimateMergeCommitCount, filterDiffsByPatterns, openSafeOutputWriteStream, resolveDownloadRoot, readSafeExistingFile, summarizeWebhookEvents, } from "./utils/helpers.js";
 import { graphqlQueryContainsWriteOperation, graphqlQueryContainsDeleteOperation, } from "./utils/graphql-query.js";
 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 { classifyHealthCheckTransportError, describeFetchTransportError, redactGitLabUrlCredentials, } from "./utils/health-check-transport-error.js";
-import { redactUrlSecretsInError, redactUrlSecretsInErrorMessage, redactUrlSecretsInText, splitCommaSeparatedUrls, } from "./utils/redact-url.js";
+import { redactUrlSecretsInError, redactUrlSecretsInErrorMessage, redactUrlSecretsInText, } from "./utils/redact-url.js";
 import { createMaskingPolicyResolver, getManagedMaskingProjectIds, } from "./masking/index.js";
 import { checkForNewVersion } from "./utils/version-check.js";
 import { assertGitLabVersionAtLeast } from "./utils/gitlab-version-gate.js";
@@ -692,37 +692,31 @@ function validateConfiguration() {
             errors.push(`PORT must be between 1 and 65535, got: ${portStr}`);
         }
     }
-    // Validate GITLAB_API_URL format
-    const configuredApiUrls = getConfig("api-url", "GITLAB_API_URL");
-    const apiUrls = configuredApiUrls === undefined ? [] : splitCommaSeparatedUrls(configuredApiUrls);
-    if (apiUrls.length > 0) {
-        for (const url of apiUrls) {
-            try {
-                new URL(url.trim());
-            }
-            catch {
-                errors.push(`GITLAB_API_URL contains an invalid URL: ${redactUrlSecretsInText(url.trim())}`);
-            }
-        }
-    }
+    errors.push(...configuredGitLabApiUrlErrors());
+    // No entry is echoed: a comma inside a password splits these lists too.
     const allowedHosts = getConfig("allowed-hosts", "GITLAB_ALLOWED_HOSTS")?.split(",") || [];
-    for (const host of allowedHosts) {
+    let hasInvalidAllowedHost = false;
+    allowedHosts.forEach((host, index) => {
         if (host.trim() && !toAllowedGitLabApiUrl(host)) {
-            errors.push(`GITLAB_ALLOWED_HOSTS contains an invalid host or URL: ${host.trim()}`);
+            hasInvalidAllowedHost = true;
+            errors.push(invalidListEntryError("GITLAB_ALLOWED_HOSTS", index, allowedHosts.length, "is not a valid host or URL"));
         }
+    });
+    if (hasInvalidAllowedHost && allowedHosts.length > 1) {
+        errors.push(commaSplitHint("GITLAB_ALLOWED_HOSTS"));
     }
     const mcpAllowedHosts = getConfig("mcp-allowed-hosts", "MCP_ALLOWED_HOSTS")?.split(",") || [];
-    for (const host of mcpAllowedHosts) {
+    mcpAllowedHosts.forEach((host, index) => {
         if (host.trim() && !toAllowedMcpHost(host)) {
-            errors.push(`MCP_ALLOWED_HOSTS contains an invalid host or URL: ${host.trim()}`);
+            errors.push(invalidListEntryError("MCP_ALLOWED_HOSTS", index, mcpAllowedHosts.length, "is not a valid host or URL"));
         }
-    }
+    });
     const mcpAllowedOrigins = getConfig("mcp-allowed-origins", "MCP_ALLOWED_ORIGINS")?.split(",") || [];
-    for (const origin of mcpAllowedOrigins) {
+    mcpAllowedOrigins.forEach((origin, index) => {
         if (origin.trim() && !toAllowedMcpOrigin(origin)) {
-            errors.push(`MCP_ALLOWED_ORIGINS contains an invalid origin URL: ${origin.trim()}`);
+            errors.push(invalidListEntryError("MCP_ALLOWED_ORIGINS", index, mcpAllowedOrigins.length, "is not a valid origin URL"));
         }
-    }
+    });
     // Validate auth configuration
     const remoteAuth = getConfig("remote-auth", "REMOTE_AUTHORIZATION") === "true";
     const useOAuth = getConfig("use-oauth", "GITLAB_USE_OAUTH") === "true";
@@ -811,6 +805,13 @@ let STATELESS_MATERIAL = null;
 // Userinfo is dropped here, before the client pool or any request URL is built.
 // Defined before the first emitDeprecatedEnvWarnings() call, which reports it.
 const CONFIGURED_GITLAB_API_URLS = parseConfiguredGitLabApiUrls(getConfig("api-url", "GITLAB_API_URL") || "https://gitlab.com");
+const API_URL_SOURCE = cliArgs["api-url"] ? "--api-url" : "GITLAB_API_URL";
+// Checked before the first request: a fetch error would print an entry that
+// does not parse, and that entry can be the start of a password.
+function configuredGitLabApiUrlErrors() {
+    const configured = getConfig("api-url", "GITLAB_API_URL");
+    return configured === undefined ? [] : configuredApiUrlErrors(API_URL_SOURCE, configured);
+}
 let hasEmittedDeprecatedEnvWarnings = false;
 function emitDeprecatedEnvWarnings() {
     if (hasEmittedDeprecatedEnvWarnings) {
@@ -819,9 +820,7 @@ function emitDeprecatedEnvWarnings() {
     hasEmittedDeprecatedEnvWarnings = true;
     const warnings = [
         ...getDeprecatedEnvWarnings(buildDeprecatedEnvInput()),
-        ...(CONFIGURED_GITLAB_API_URLS.hadUserinfo
-            ? [apiUrlUserinfoWarning(cliArgs["api-url"] ? "--api-url" : "GITLAB_API_URL")]
-            : []),
+        ...(CONFIGURED_GITLAB_API_URLS.hadUserinfo ? [apiUrlUserinfoWarning(API_URL_SOURCE)] : []),
     ];
     for (const warning of warnings) {
         logger.warn(warning);
@@ -13028,8 +13027,7 @@ async function main() {
             process.exit(0);
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            process.stderr.write(`${redactUrlSecretsInText(message)}\n`);
+            process.stderr.write(`${redactUrlSecretsInErrorMessage(error)}\n`);
             logger.error({ err: error }, "auth command failed");
             exitAfterFlush(1);
         }
@@ -13040,6 +13038,11 @@ async function main() {
             process.stderr.write("Missing GitLab credentials. Set --token or GITLAB_PERSONAL_ACCESS_TOKEN, or run `auth` with GITLAB_USE_OAUTH=true.\n");
             process.exit(2);
         }
+        const apiUrlErrors = configuredGitLabApiUrlErrors();
+        if (apiUrlErrors.length > 0) {
+            process.stderr.write(apiUrlErrors.map(error => `${error}\n`).join(""));
+            process.exit(2);
+        }
         try {
             initOAuthClient();
             const result = await handleToolCall({ name: cli.toolName, arguments: cli.args });

package/build/utils/logger.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { pino } from "pino";
-import { redactUrlSecretsInLogLine } from "./redact-url.js";
+import { redactUrlSecretsInError, redactUrlSecretsInLogLine } from "./redact-url.js";
 const require = createRequire(import.meta.url);
 const REDACT_PATHS = [
     "token",
@@ -117,6 +117,35 @@ export function flushStartupLogs(logger) {
 export function flushBufferedLogs(logger) {
     flushDestination(logger);
 }
+/**
+ * pino's error serializer, run on the redacted error. It copies the error's own
+ * fields, and the `input` of an ERR_INVALID_URL can be the start of a password
+ * that the line redaction cannot recognize.
+ */
+export function serializeLoggedError(error) {
+    return pino.stdSerializers.err(redactUrlSecretsInError(error));
+}
+// Keys whose error pino or pino-pretty prints even though no serializer runs on it.
+const LOGGED_ERROR_KEYS = ["err", "error"];
+/**
+ * Redacts a logged error before pino reads it. Without a message argument pino
+ * takes `msg` from the error's own message, and an error under `error` is
+ * copied as it is.
+ */
+function redactLoggedErrors(args, method) {
+    const first = args[0];
+    if (first instanceof Error) {
+        redactUrlSecretsInError(first);
+    }
+    else if (typeof first === "object" && first !== null) {
+        for (const key of LOGGED_ERROR_KEYS) {
+            if (key in first) {
+                redactUrlSecretsInError(first[key]);
+            }
+        }
+    }
+    method.apply(this, args);
+}
 /**
  * Create a pino logger with consistent redaction, level, format, and
  * destination across the entire codebase.
@@ -128,6 +157,8 @@ export function flushBufferedLogs(logger) {
  * - All loggers redact the same set of sensitive fields.
  * - Every line, in either format, has URL userinfo and token query values
  *   redacted, including text from thrown fetch/URL errors and their causes.
+ * - A logged error, as the first argument or under `err` or `error`, is
+ *   redacted before pino copies its fields or its message.
  */
 export function createLogger(name) {
     const isJson = process.env.LOG_FORMAT === "json";
@@ -138,7 +169,11 @@ export function createLogger(name) {
             paths: REDACT_PATHS,
             censor: "[REDACTED]",
         },
+        serializers: {
+            err: serializeLoggedError,
+        },
         hooks: {
+            logMethod: redactLoggedErrors,
             streamWrite: redactUrlSecretsInLogLine,
         },
     };

package/build/utils/redact-url.js

@@ -39,13 +39,23 @@ export function redactUrlSecretsInText(text) {
  * Redacts an error in place: `message`, `stack`, and every `cause` below it.
  * undici and `new URL()` put the URL they rejected into the message, so a
  * credentialed URL would otherwise reach the MCP client and the log verbatim.
+ * The `input` and `base` of an ERR_INVALID_URL are replaced, not redacted:
+ * text that did not parse has no host to keep, and it can be the start of a
+ * password cut off at a comma ("http://alice:p/api/v4"), with no "@" for the
+ * text redaction to find. The same text is replaced wherever another error
+ * of the chain quotes it ("Failed to parse URL from ...", or a wrapper that
+ * copies that message): every such text, in the message and stack of every
+ * error of the chain.
  * A thrown string is returned redacted; other values are returned unchanged.
  */
 export function redactUrlSecretsInError(error) {
     if (typeof error === "string") {
         return redactUrlSecretsInText(error);
     }
-    redactErrorChain(error, new Set());
+    const chain = readErrorChain(error);
+    for (const item of chain.errors) {
+        redactChainedError(item, chain);
+    }
     return error;
 }
 /**
@@ -54,38 +64,273 @@ export function redactUrlSecretsInError(error) {
  * as an isError result.
  */
 export function redactUrlSecretsInErrorMessage(error) {
-    return redactUrlSecretsInText(error instanceof Error ? error.message : String(error));
-}
-function redactErrorChain(error, seen) {
-    if (!(error instanceof Error) || seen.has(error)) {
-        return;
+    if (!(error instanceof Error)) {
+        return redactUrlSecretsInText(String(error));
+    }
+    return redactUrlSecretsInText(withoutInvalidUrls(error.message, readErrorChain(error)));
+}
+const REDACTED = "[REDACTED]";
+// Own enumerable fields of Node's ERR_INVALID_URL, which pino's error serializer copies.
+const INVALID_URL_FIELDS = ["input", "base"];
+// The input and base of each ERR_INVALID_URL as first read. A wrapper that quoted
+// them can be redacted after the ERR_INVALID_URL already was.
+const invalidUrlTexts = new WeakMap();
+function isInvalidUrlError(value) {
+    return value instanceof Error && value.code === "ERR_INVALID_URL";
+}
+function readInvalidUrlTexts(error) {
+    if (!isInvalidUrlError(error)) {
+        return [];
+    }
+    const known = invalidUrlTexts.get(error);
+    if (known !== undefined) {
+        return known;
+    }
+    const texts = [];
+    for (const field of INVALID_URL_FIELDS) {
+        const value = error[field];
+        if (typeof value === "string" && value.length > 0 && value !== REDACTED) {
+            texts.push(value);
+        }
+    }
+    invalidUrlTexts.set(error, texts);
+    return texts;
+}
+// Every error reachable through `cause` and AggregateError `errors`, each once.
+function readErrorChain(root) {
+    const errors = [];
+    const all = new Set();
+    const seen = new Set();
+    const pending = [root];
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (!(value instanceof Error) || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        errors.push(value);
+        for (const text of readInvalidUrlTexts(value)) {
+            all.add(text);
+        }
+        pending.push(value.cause);
+        if (value instanceof AggregateError && Array.isArray(value.errors)) {
+            for (const inner of value.errors) {
+                pending.push(inner);
+            }
+        }
     }
-    seen.add(error);
+    const texts = [...all];
+    return {
+        errors,
+        texts,
+        heads: texts.length > 0 ? buildTextHeads(texts) : undefined,
+        matcher: undefined,
+    };
+}
+function redactChainedError(error, chain) {
+    // Before the text redaction can change the quoted text.
+    hideInvalidUrls(error, "message", chain);
+    hideInvalidUrls(error, "stack", chain);
     redactErrorField(error, "message");
     redactErrorField(error, "stack");
+    if (isInvalidUrlError(error)) {
+        for (const field of INVALID_URL_FIELDS) {
+            const value = error[field];
+            if (typeof value === "string" && value.length > 0) {
+                setErrorField(error, field, REDACTED);
+            }
+        }
+    }
     if (typeof error.cause === "string") {
         redactErrorField(error, "cause");
     }
-    else {
-        redactErrorChain(error.cause, seen);
+}
+function hideInvalidUrls(error, field, chain) {
+    const value = error[field];
+    if (typeof value !== "string") {
+        return;
+    }
+    const hidden = withoutInvalidUrls(value, chain);
+    if (hidden !== value) {
+        setErrorField(error, field, hidden);
+    }
+}
+// One pass to rule out the text, and at most one more to hide what it quotes.
+function withoutInvalidUrls(text, chain) {
+    if (chain.heads === undefined || !mayQuoteText(text, chain.heads)) {
+        return text;
     }
-    if (error instanceof AggregateError && Array.isArray(error.errors)) {
-        for (const inner of error.errors) {
-            redactErrorChain(inner, seen);
+    chain.matcher ??= buildTextMatcher(chain.texts);
+    return hideMatchedTexts(text, chain.matcher);
+}
+// Long enough that few windows look like the start of a URL, short enough to hash fast.
+const MAX_HEAD_WIDTH = 16;
+const HASH_BASE = 0x01000193;
+// Keeps each hash a small integer.
+const HASH_MASK = 0x3fffffff;
+function buildTextHeads(texts) {
+    let width = MAX_HEAD_WIDTH;
+    for (const text of texts) {
+        width = Math.min(width, text.length);
+    }
+    const hashes = new Set();
+    for (const text of texts) {
+        let hash = 0;
+        for (let index = 0; index < width; index += 1) {
+            hash = (Math.imul(hash, HASH_BASE) + text.charCodeAt(index)) | 0;
+        }
+        hashes.add(hash & HASH_MASK);
+    }
+    return { width, hashes };
+}
+// A rolling hash over each window of the text, in one pass.
+function mayQuoteText(text, heads) {
+    const { width, hashes } = heads;
+    // HASH_BASE ** (width - 1), to take out the code unit that leaves the window.
+    let top = 1;
+    for (let index = 1; index < width; index += 1) {
+        top = Math.imul(top, HASH_BASE);
+    }
+    let hash = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (index >= width) {
+            hash = (hash - Math.imul(text.charCodeAt(index - width), top)) | 0;
+        }
+        hash = (Math.imul(hash, HASH_BASE) + text.charCodeAt(index)) | 0;
+        if (index + 1 >= width && hashes.has(hash & HASH_MASK)) {
+            return true;
+        }
+    }
+    return false;
+}
+const CODE_UNITS = 0x10000;
+// The slot of the edge from a node on a code unit, or the empty slot it would take.
+function edgeSlot(keys, node, code) {
+    const key = node * CODE_UNITS + code + 1;
+    const mask = keys.length - 1;
+    let hash = Math.imul(node, 0x9e3779b1) ^ code;
+    hash = Math.imul(hash ^ (hash >>> 16), 0x85ebca6b);
+    let slot = (hash ^ (hash >>> 13)) & mask;
+    while (keys[slot] !== 0 && keys[slot] !== key) {
+        slot = (slot + 1) & mask;
+    }
+    return slot;
+}
+function buildTextMatcher(texts) {
+    let size = 1;
+    for (const text of texts) {
+        size += text.length;
+    }
+    // A power of two, at least twice the number of edges.
+    let slots = 2;
+    while (slots < 2 * size) {
+        slots *= 2;
+    }
+    const keys = new Float64Array(slots);
+    const targets = new Int32Array(slots);
+    const longest = new Int32Array(size);
+    // The children of a node as a list: its first child, then each child's sibling.
+    // 0 ends a list, because node 0 is no node's child.
+    const firstChild = new Int32Array(size);
+    const sibling = new Int32Array(size);
+    const unit = new Int32Array(size);
+    let nodes = 1;
+    for (const text of texts) {
+        let node = 0;
+        for (let index = 0; index < text.length; index += 1) {
+            const code = text.charCodeAt(index);
+            const slot = edgeSlot(keys, node, code);
+            if (keys[slot] === 0) {
+                keys[slot] = node * CODE_UNITS + code + 1;
+                targets[slot] = nodes;
+                unit[nodes] = code;
+                sibling[nodes] = firstChild[node];
+                firstChild[node] = nodes;
+                nodes += 1;
+            }
+            node = targets[slot];
+        }
+        longest[node] = text.length;
+    }
+    // Breadth first: a fail link points to a shorter node, whose own link and
+    // longest text are then already known.
+    const matcher = { keys, targets, fail: new Int32Array(size), longest };
+    const queue = new Int32Array(nodes);
+    let queued = 0;
+    for (let child = firstChild[0]; child !== 0; child = sibling[child]) {
+        queue[queued] = child;
+        queued += 1;
+    }
+    for (let head = 0; head < queued; head += 1) {
+        const node = queue[head];
+        if (longest[node] === 0) {
+            longest[node] = longest[matcher.fail[node]];
+        }
+        for (let child = firstChild[node]; child !== 0; child = sibling[child]) {
+            matcher.fail[child] = nextNode(matcher, matcher.fail[node], unit[child]);
+            queue[queued] = child;
+            queued += 1;
+        }
+    }
+    return matcher;
+}
+function nextNode(matcher, node, code) {
+    for (let from = node;; from = matcher.fail[from]) {
+        const slot = edgeSlot(matcher.keys, from, code);
+        if (matcher.keys[slot] !== 0) {
+            return matcher.targets[slot];
+        }
+        if (from === 0) {
+            return 0;
         }
     }
 }
+// Each part of the text covered by a text of the matcher becomes one [REDACTED].
+// Overlapping matches are merged, so a shorter text inside a longer one leaves
+// nothing behind; matches that only touch stay apart, as split and join leave them.
+function hideMatchedTexts(text, matcher) {
+    const starts = [];
+    const ends = [];
+    let node = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        node = nextNode(matcher, node, text.charCodeAt(index));
+        const length = matcher.longest[node];
+        if (length === 0) {
+            continue;
+        }
+        let start = index + 1 - length;
+        while (ends.length > 0 && ends[ends.length - 1] > start) {
+            ends.pop();
+            start = Math.min(start, starts.pop() ?? start);
+        }
+        starts.push(start);
+        ends.push(index + 1);
+    }
+    if (starts.length === 0) {
+        return text;
+    }
+    const parts = [];
+    let from = 0;
+    for (let range = 0; range < starts.length; range += 1) {
+        parts.push(text.slice(from, starts[range]), REDACTED);
+        from = ends[range];
+    }
+    parts.push(text.slice(from));
+    return parts.join("");
+}
 function redactErrorField(error, field) {
     const value = error[field];
     if (typeof value !== "string") {
         return;
     }
     const redacted = redactUrlSecretsInText(value);
-    if (redacted === value) {
-        return;
+    if (redacted !== value) {
+        setErrorField(error, field, redacted);
     }
+}
+function setErrorField(error, field, value) {
     try {
-        error[field] = redacted;
+        error[field] = value;
     }
     catch {
         // A frozen error keeps its text; the logger still redacts its own copy.

package/build/utils/url.js

@@ -27,6 +27,75 @@ export function apiUrlUserinfoWarning(source) {
     return (`${source} contains a username or password before the host. It is ignored: requests ` +
         "go to the URL without it. Use a token or OAuth configuration to authenticate instead.");
 }
+const HIDDEN_VALUE_NOTE = "(value not shown: it may contain a password)";
+const COMMA_IN_PASSWORD_HINT = "write a comma inside a username or password as %2C";
+/**
+ * Startup error for one entry of a comma-separated URL or host list. The entry
+ * is named by its position only. A comma inside a password splits the list
+ * there ("http://alice:p,http://w@host" gives "http://alice:p"), and an entry
+ * that does not parse has no host that is safe to show: any of its text can
+ * be part of the password.
+ */
+export function invalidListEntryError(source, index, total, problem) {
+    return `${source} entry ${index + 1} of ${total} ${problem} ${HIDDEN_VALUE_NOTE}`;
+}
+/** Follows the entry errors of a list that had more than one entry. */
+export function commaSplitHint(source) {
+    return `${source} is split at commas: ${COMMA_IN_PASSWORD_HINT}`;
+}
+/**
+ * Startup errors for a configured GITLAB_API_URL list, one per bad entry, and
+ * none of them echo the entry. Each entry must be an http or https URL:
+ * fetch() cannot use another scheme, and a value without "//" such as
+ * "alice:p,w@host" parses as a URL whose scheme is the username. The scheme
+ * is checked, not the "//": fetch() also accepts "https:/host".
+ */
+export function configuredApiUrlErrors(source, value) {
+    const entries = splitCommaSeparatedUrls(value);
+    const errors = [];
+    let hasInvalidEntry = false;
+    entries.forEach((entry, index) => {
+        if (entry.length === 0) {
+            errors.push(`${source} entry ${index + 1} of ${entries.length} is empty`);
+            return;
+        }
+        const problem = apiUrlProblem(entry);
+        if (problem !== null) {
+            hasInvalidEntry = true;
+            errors.push(invalidListEntryError(source, index, entries.length, problem));
+        }
+    });
+    // With only empty entries wrong, the list has an extra comma ("a,,b" or a
+    // trailing one), and the hint about a comma inside a password would mislead.
+    if (hasInvalidEntry && entries.length > 1) {
+        errors.push(commaSplitHint(source));
+    }
+    return errors;
+}
+/**
+ * The error for one API URL that is not split at commas (the `auth` command),
+ * or null when it is an http or https URL.
+ */
+export function apiUrlError(source, url) {
+    const problem = apiUrlProblem(url.trim());
+    if (problem === null) {
+        return null;
+    }
+    const hint = url.includes(",") ? `; ${COMMA_IN_PASSWORD_HINT}` : "";
+    return `${source} ${problem} ${HIDDEN_VALUE_NOTE}${hint}`;
+}
+function apiUrlProblem(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return "is not a valid URL";
+    }
+    return parsed.protocol === "http:" || parsed.protocol === "https:"
+        ? null
+        : "is not an http or https URL";
+}
 /**
  * Split a comma-separated GITLAB_API_URL, drop userinfo from each entry, and
  * normalize it. fetch() refuses a URL with credentials, so a URL that kept

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "2.3.6-next.130",
+  "version": "2.3.6-next.131",
   "mcpName": "io.github.zereight/gitlab-mcp",
   "description": "GitLab MCP server for projects, merge requests, issues, pipelines, wiki, releases, and more",
   "keywords": [