@zereight/mcp-gitlab 2.1.68 → 2.1.69

package/build/cli/router.js

@@ -0,0 +1,158 @@
+import { GITLAB_PERMISSION_MODE } from "../config.js";
+import { allTools, deleteTools, destructiveTools, readOnlyTools } from "../tools/registry.js";
+import { getPositionalCliCommand } from "../cli-command.js";
+import { applyFlagAliases, argvHasHelp, CliUsageError, parseArgv, parseToolArgs, } from "./args.js";
+import { liveCliExposure } from "./exposure.js";
+import { canonicalGroup, findCuratedCommand, isKnownCliCommand, resolveScopedTool, } from "./curated.js";
+import { curatedHelpText, globalHelpText, groupHelpText, toolHelpText, toolIndexHelpText, } from "./help.js";
+export function isCliInvocation(argv) {
+    if (argvHasHelp(argv)) {
+        return true;
+    }
+    const positional = getPositionalCliCommand(argv);
+    if (positional === undefined) {
+        return false;
+    }
+    return isKnownCliCommand(positional);
+}
+export function resolveCli(argv, options = {}) {
+    try {
+        return resolveCliUnsafe(argv, options.permissionMode ?? GITLAB_PERMISSION_MODE, options.exposure ?? liveCliExposure());
+    }
+    catch (error) {
+        if (error instanceof CliUsageError) {
+            return { kind: "usage", message: error.message };
+        }
+        throw error;
+    }
+}
+function resolveCliUnsafe(argv, permissionMode, exposure) {
+    const parsed = parseArgv(argv);
+    const [head, action, extra] = parsed.positionals;
+    if (head === undefined) {
+        if (parsed.help) {
+            return { kind: "help", text: globalHelpText() };
+        }
+        return { kind: "server" };
+    }
+    if (head === "auth") {
+        return { kind: "auth" };
+    }
+    if (head === "tool") {
+        if (extra !== undefined) {
+            return { kind: "usage", message: `Unexpected extra arguments: ${parsed.positionals.slice(2).join(" ")}` };
+        }
+        if (action === undefined) {
+            if (parsed.help) {
+                return { kind: "help", text: toolIndexHelpText() };
+            }
+            return { kind: "usage", message: `Usage: zereight-mcp-gitlab tool <tool-name> [options]` };
+        }
+        if (parsed.help) {
+            return { kind: "help", text: toolHelpText(action) };
+        }
+        return buildRun({
+            toolName: action,
+            flags: parsed.toolFlags,
+            argsJson: parsed.argsJson,
+            extraArgs: undefined,
+            output: parsed.output ?? "json",
+            yes: parsed.yes,
+            permissionMode,
+            exposure,
+            tableSpec: undefined,
+        });
+    }
+    const group = canonicalGroup(head);
+    if (group === undefined) {
+        if (parsed.help) {
+            return { kind: "help", text: globalHelpText() };
+        }
+        return { kind: "server" };
+    }
+    if (extra !== undefined) {
+        return { kind: "usage", message: `Unexpected extra arguments: ${parsed.positionals.slice(2).join(" ")}` };
+    }
+    if (action === undefined) {
+        return { kind: "help", text: groupHelpText(group) };
+    }
+    if (parsed.help) {
+        return { kind: "help", text: curatedHelpText(group, action) };
+    }
+    const command = findCuratedCommand(group, action);
+    if (command === undefined) {
+        return { kind: "usage", message: `Unknown command: ${head} ${action}` };
+    }
+    const aliased = applyFlagAliases(parsed.toolFlags, command.flagAliases);
+    const scopeArgs = {
+        ...(parsed.argsJson ?? {}),
+        ...aliased,
+        ...(command.extraArgs ?? {}),
+    };
+    const toolName = resolveScopedTool(command, scopeArgs);
+    return buildRun({
+        toolName,
+        flags: aliased,
+        argsJson: parsed.argsJson,
+        extraArgs: command.extraArgs,
+        output: parsed.output ?? "table",
+        yes: parsed.yes,
+        permissionMode,
+        exposure,
+        tableSpec: command.table,
+    });
+}
+function buildRun(input) {
+    if (input.toolName === "discover_tools") {
+        return {
+            kind: "usage",
+            message: "discover_tools is MCP-only; use `tool <name>` for registry tools allowed by the current filters",
+        };
+    }
+    const tool = allTools.find(entry => entry.name === input.toolName);
+    if (tool === undefined) {
+        return { kind: "usage", message: `Unknown tool: ${input.toolName}` };
+    }
+    const args = parseToolArgs({
+        schema: tool.inputSchema,
+        flags: input.flags,
+        argsJson: input.argsJson,
+        extraArgs: input.extraArgs,
+    });
+    const exposureMessage = input.exposure.exposureRefusal(input.toolName);
+    if (exposureMessage !== undefined) {
+        return { kind: "refused", message: exposureMessage };
+    }
+    const permissionMessage = permissionRefusal(input.toolName, input.permissionMode);
+    if (permissionMessage !== undefined) {
+        return { kind: "refused", message: permissionMessage };
+    }
+    if (destructiveTools.has(input.toolName) && !input.yes) {
+        return {
+            kind: "refused",
+            message: `Would run ${input.toolName} with arguments [${Object.keys(args).join(", ")}]. Re-run with --yes to proceed.`,
+        };
+    }
+    if (input.exposure.needsConfirmation(input.toolName) && !input.yes) {
+        return {
+            kind: "refused",
+            message: `${input.toolName} requires confirmation (GITLAB_TOOL_POLICY_APPROVE). Re-run with --yes to proceed.`,
+        };
+    }
+    return {
+        kind: "run",
+        toolName: input.toolName,
+        args,
+        output: input.output,
+        tableSpec: input.tableSpec,
+    };
+}
+function permissionRefusal(toolName, permissionMode) {
+    if (permissionMode === "readonly" && !readOnlyTools.has(toolName)) {
+        return `${toolName} is not allowed in read-only mode`;
+    }
+    if (permissionMode === "modify" && deleteTools.has(toolName)) {
+        return `${toolName} is not allowed in modify mode (delete operations are disabled)`;
+    }
+    return undefined;
+}

package/build/cli/tables.js

@@ -0,0 +1,117 @@
+const MAX_CELL = 48;
+export function renderTable(value, spec) {
+    if (spec === undefined || spec.kind === "text") {
+        return { stdout: stringifyValue(value), stderr: "" };
+    }
+    const rows = spec.kind === "list" ? asObjectRows(value) : undefined;
+    if (spec.kind === "list") {
+        if (rows === undefined) {
+            return {
+                stdout: stringifyValue(value),
+                stderr: "No table renderer for this result; printed JSON.\n",
+            };
+        }
+        if (rows.length === 0) {
+            return { stdout: "No items.\n", stderr: "" };
+        }
+        const columns = spec.columns ?? inferColumns(rows);
+        return { stdout: formatGrid(rows, columns), stderr: "" };
+    }
+    const record = asRecord(value);
+    if (record === undefined) {
+        return {
+            stdout: stringifyValue(value),
+            stderr: "No table renderer for this result; printed JSON.\n",
+        };
+    }
+    const keys = spec.columns ?? Object.keys(record);
+    return { stdout: formatKeyValue(record, keys), stderr: "" };
+}
+function asObjectRows(value) {
+    if (Array.isArray(value)) {
+        return value.every(isRecord) ? value : undefined;
+    }
+    const record = asRecord(value);
+    if (record === undefined) {
+        return undefined;
+    }
+    for (const nested of Object.values(record)) {
+        if (Array.isArray(nested) && nested.every(isRecord)) {
+            return nested;
+        }
+    }
+    return undefined;
+}
+function inferColumns(rows) {
+    const preferred = ["iid", "id", "name", "key", "tag_name", "slug", "short_id", "state", "status", "title", "path_with_namespace"];
+    const present = new Set();
+    for (const row of rows) {
+        for (const key of Object.keys(row)) {
+            present.add(key);
+        }
+    }
+    const columns = preferred.filter(key => present.has(key));
+    return columns.length > 0 ? columns : Object.keys(rows[0] ?? {}).slice(0, 4);
+}
+function formatGrid(rows, columns) {
+    const header = columns.map(key => key.toUpperCase());
+    const cells = rows.map(row => columns.map(key => cellText(row[key])));
+    const widths = columns.map((_, index) => {
+        const longest = cells.reduce((max, row) => Math.max(max, row[index]?.length ?? 0), header[index]?.length ?? 0);
+        return Math.min(longest, MAX_CELL);
+    });
+    const lines = [
+        padRow(header, widths),
+        ...cells.map(row => padRow(row, widths)),
+    ];
+    return `${lines.join("\n")}\n`;
+}
+function formatKeyValue(record, keys) {
+    const lines = [];
+    for (const key of keys) {
+        if (record[key] === undefined) {
+            continue;
+        }
+        lines.push(`${key}\t${cellText(record[key])}`);
+    }
+    if (lines.length === 0) {
+        return stringifyValue(record);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function padRow(cells, widths) {
+    return cells
+        .map((cell, index) => truncate(cell).padEnd(widths[index] ?? 0))
+        .join("  ")
+        .trimEnd();
+}
+function cellText(value) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return truncate(String(value));
+    }
+    return truncate(JSON.stringify(value));
+}
+function truncate(value) {
+    if (value.length <= MAX_CELL) {
+        return value;
+    }
+    return `${value.slice(0, MAX_CELL - 1)}…`;
+}
+function stringifyValue(value) {
+    if (typeof value === "string") {
+        return value.endsWith("\n") ? value : `${value}\n`;
+    }
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function asRecord(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/build/cli-boolean-flags.js

@@ -0,0 +1,38 @@
+// Boolean flags accept `--flag`, `--flag=true`, or `--flag false`.
+// They must not consume the following positional command
+// (`--use-oauth mr list` is `mr`, not `list`).
+export const BOOLEAN_CLI_FLAG_NAMES = new Set([
+    "use-oauth",
+    "is-old",
+    "read-only",
+    "masking-enabled",
+    "use-wiki",
+    "use-milestone",
+    "use-pipeline",
+    "disable-version-check",
+    "sse",
+    "streamable-http",
+    "remote-auth",
+    "mcp-oauth",
+    "allow-unauthenticated-tool-discovery",
+    "mcp-trust-proxy",
+    "oauth-callback-proxy",
+    "enable-dynamic-api-url",
+    "enable-dynamic-project-scope",
+    "enable-strict-project-scope",
+    "oauth-stateless-mode",
+    "compact-results",
+]);
+const BOOLEAN_FLAG_LITERALS = new Set(["true", "false", "1", "0"]);
+export function isBooleanFlagLiteral(value) {
+    if (value === undefined || value.startsWith("-")) {
+        return false;
+    }
+    return BOOLEAN_FLAG_LITERALS.has(value.toLowerCase());
+}
+export function nextBooleanFlagValue(nextToken) {
+    if (isBooleanFlagLiteral(nextToken)) {
+        return { value: nextToken, consumeNext: true };
+    }
+    return { value: "true", consumeNext: false };
+}

package/build/cli-command.js

@@ -1,5 +1,11 @@
+import { BOOLEAN_CLI_FLAG_NAMES, isBooleanFlagLiteral } from "./cli-boolean-flags.js";
 const SCRIPT_PATH_PATTERN = /\.(cjs|mjs|js|cts|mts|ts)$/;
-const FLAGS_WITHOUT_VALUE = new Set(["--help", "-h"]);
+const FLAGS_WITHOUT_VALUE = new Set([
+    "--help",
+    "-h",
+    "--yes",
+    ...[...BOOLEAN_CLI_FLAG_NAMES].map(name => `--${name}`),
+]);
 function isScriptPath(arg) {
     return SCRIPT_PATH_PATTERN.test(arg);
 }
@@ -17,9 +23,13 @@ export function getPositionalCliCommand(argv) {
             continue;
         }
         if (arg.startsWith("-")) {
-            if (!FLAGS_WITHOUT_VALUE.has(arg) &&
-                i + 1 < args.length &&
-                !args[i + 1].startsWith("-")) {
+            if (FLAGS_WITHOUT_VALUE.has(arg)) {
+                if (BOOLEAN_CLI_FLAG_NAMES.has(arg.replace(/^--/, "")) && isBooleanFlagLiteral(args[i + 1])) {
+                    i += 1;
+                }
+                continue;
+            }
+            if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
                 i += 1;
             }
             continue;

package/build/config.js

@@ -1,15 +1,30 @@
+import { BOOLEAN_CLI_FLAG_NAMES, nextBooleanFlagValue } from "./cli-boolean-flags.js";
 // Parse CLI arguments before anything else
 const args = process.argv.slice(2);
 export const cliArgs = {};
 for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg.startsWith("--")) {
-        const [key, value] = arg.slice(2).split("=");
-        if (value) {
-            cliArgs[key] = value;
+        const eqIndex = arg.indexOf("=");
+        if (eqIndex !== -1) {
+            const key = arg.slice(2, eqIndex);
+            const value = arg.slice(eqIndex + 1);
+            if (value) {
+                cliArgs[key] = value;
+            }
         }
-        else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
-            cliArgs[key] = args[++i];
+        else {
+            const key = arg.slice(2);
+            if (BOOLEAN_CLI_FLAG_NAMES.has(key)) {
+                const parsed = nextBooleanFlagValue(args[i + 1]);
+                cliArgs[key] = parsed.value;
+                if (parsed.consumeNext) {
+                    i += 1;
+                }
+            }
+            else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+                cliArgs[key] = args[++i];
+            }
         }
     }
 }
@@ -76,7 +91,9 @@ export const MCP_SERVER_URL = getConfig("mcp-server-url", "MCP_SERVER_URL");
 export const GITLAB_OAUTH_APP_ID = getConfig("oauth-app-id", "GITLAB_OAUTH_APP_ID");
 export const GITLAB_OAUTH_SCOPES_RAW = getConfig("oauth-scopes", "GITLAB_OAUTH_SCOPES");
 export const GITLAB_OAUTH_SCOPES = GITLAB_OAUTH_SCOPES_RAW
-    ? GITLAB_OAUTH_SCOPES_RAW.split(",").map((s) => s.trim()).filter(Boolean)
+    ? GITLAB_OAUTH_SCOPES_RAW.split(",")
+        .map(s => s.trim())
+        .filter(Boolean)
     : undefined;
 export const GITLAB_OAUTH_CALLBACK_PROXY = getConfig("oauth-callback-proxy", "GITLAB_OAUTH_CALLBACK_PROXY") === "true";
 /** @deprecated Use GITLAB_OAUTH_ALLOWED_GROUPS_RAW instead. Will be removed in the next major version. */
@@ -88,7 +105,10 @@ export const GITLAB_OAUTH_ALLOWED_GROUPS = (() => {
     const raw = newVar ?? oldVar;
     if (!raw)
         return undefined;
-    const groups = raw.split(",").map((g) => g.trim()).filter(Boolean);
+    const groups = raw
+        .split(",")
+        .map(g => g.trim())
+        .filter(Boolean);
     return groups.length > 0 ? groups : undefined;
 })();
 export const ENABLE_DYNAMIC_API_URL = getConfig("enable-dynamic-api-url", "ENABLE_DYNAMIC_API_URL") === "true";
@@ -163,6 +183,9 @@ export const HOST = getConfig("host", "HOST") || "127.0.0.1";
 /** Default HTTP port for the MCP server. */
 const _PORT_DEFAULT = 3002;
 export const PORT = _intEnv("PORT", "port", _PORT_DEFAULT);
+/** When true, oversized MCP tool replies are replaced with a preview plus a CLI replay command. */
+export const GITLAB_MCP_COMPACT_RESULTS = getConfig("compact-results", "GITLAB_MCP_COMPACT_RESULTS") === "true";
+export const GITLAB_MCP_COMPACT_RESULT_CHARS = _intEnv("GITLAB_MCP_COMPACT_RESULT_CHARS", "compact-result-chars", 4000);
 // ---------------------------------------------------------------------------
 // Proxy configuration
 // ---------------------------------------------------------------------------

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_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";
+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, GITLAB_MCP_COMPACT_RESULTS, GITLAB_MCP_COMPACT_RESULT_CHARS, } 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");
@@ -74,9 +74,13 @@ import path from "node:path";
 import { CookieJar, parse as parseCookie } from "tough-cookie";
 import { URL } from "node:url";
 import { z } from "zod";
-import { initializeOAuthClient } from "./oauth.js";
+import { createGitLabOAuthClient, ensureOAuthToken } from "./oauth.js";
 import { getPositionalCliCommand } from "./cli-command.js";
 import { runAuthCommandAsync } from "./auth-cli.js";
+import { isCliInvocation, resolveCli } from "./cli/router.js";
+import { formatCliError, formatToolOutput } from "./cli/output.js";
+import { compactMcpToolResult, readOwnRecord } from "./cli/compact-mcp-result.js";
+import { compileDeniedToolsRegex } from "./tools/denied-regex.js";
 import { createGitLabOAuthProvider } from "./oauth-proxy.js";
 import { mcpAuthRouter } from "@modelcontextprotocol/sdk/server/auth/router.js";
 import rateLimit, { ipKeyGenerator } from "express-rate-limit";
@@ -179,6 +183,7 @@ const MCP_PROMPTS = [
  * Each transport connection gets its own Server instance to prevent
  * cross-client data leakage (GHSA-345p-7cg4-v4c7).
  */
+/** Builds an MCP server with the tool list filtered by toolsets, permission mode, and policy. */
 function createServer() {
     // Precompute filtered tool list once at server creation (Steps 1–5 are static)
     // Step 1: Toolset filter — keep tools in enabled toolsets
@@ -329,11 +334,18 @@ function createServer() {
                     ? (value) => maskingEngine.maskValue(value)
                     : undefined,
             });
-            return maskingEngine
+            const masked = maskingEngine
                 ? maskingEngine.maskToolResult(filtered, {
                     textFormat: isPlainTextResult ? "plain" : "json",
                 })
                 : filtered;
+            return compactMcpToolResult({
+                result: masked,
+                enabled: GITLAB_MCP_COMPACT_RESULTS,
+                maxChars: GITLAB_MCP_COMPACT_RESULT_CHARS,
+                toolName,
+                args: readOwnRecord(request.params.arguments),
+            });
         };
         const logError = (error) => {
             const durationMs = Date.now() - start;
@@ -398,6 +410,16 @@ function createServer() {
             if (jmespathSyntaxError) {
                 return logCompletion({ content: [{ type: "text", text: jmespathSyntaxError }], isError: true }, { skipJmespath: true });
             }
+            // Enforce list-time filtering on direct calls: clients can call names that tools/list omits.
+            // filteredTools is extended by discover_tools; hidden-policy tools stay callable by design,
+            // but GITLAB_DENIED_TOOLS_REGEX always wins over the hidden exemption.
+            // Permission-mode denials fall through so handleToolCall reports its mode-specific error.
+            const hiddenAndNotDenied = hiddenToolSet.has(toolName) && !GITLAB_DENIED_TOOLS_REGEX?.test(toolName);
+            if (isToolAllowedByPermissionMode(toolName) &&
+                !hiddenAndNotDenied &&
+                !filteredTools.some(t => t.name === toolName)) {
+                throw new Error(`Tool "${toolName}" is not available on this server`);
+            }
             // Handle discover_tools meta-tool directly (needs access to mcpServer and filteredTools)
             if (toolName === "discover_tools") {
                 const category = request.params.arguments?.category?.trim()?.toLowerCase();
@@ -526,6 +548,7 @@ function createServer() {
         }
         catch (error) {
             logError(error);
+            throw error;
         }
     });
     return mcpServer;
@@ -846,15 +869,10 @@ export function hasStatelessSessionId(req) {
  * This avoids background timers that cause issues with multiple instances.
  */
 async function ensureValidOAuthToken() {
-    if (!oauthClient)
-        return;
-    if (oauthClient.hasValidToken())
-        return;
     try {
-        logger.info("OAuth token expired or missing, refreshing...");
-        const freshToken = await oauthClient.getAccessToken();
-        OAUTH_ACCESS_TOKEN = freshToken;
-        logger.info("OAuth token refreshed successfully");
+        await ensureOAuthToken(oauthClient, OAUTH_ACCESS_TOKEN, token => {
+            OAUTH_ACCESS_TOKEN = token;
+        });
     }
     catch (error) {
         logger.error({ err: error }, "Failed to refresh OAuth token");
@@ -873,33 +891,11 @@ function isToolAllowedByPermissionMode(toolName) {
     }
 }
 const GITLAB_DENIED_TOOLS_REGEX = (() => {
-    const pattern = getConfig("denied-tools-regex", "GITLAB_DENIED_TOOLS_REGEX");
-    if (!pattern)
-        return undefined;
-    // Reject patterns that are too long (potential ReDoS vector)
-    const MAX_PATTERN_LENGTH = 200;
-    if (pattern.length > MAX_PATTERN_LENGTH) {
-        logger.error(`GITLAB_DENIED_TOOLS_REGEX pattern exceeds ${MAX_PATTERN_LENGTH} chars. Ignoring.`);
-        return undefined;
-    }
-    // Reject patterns with nested quantifiers that can cause catastrophic backtracking (ReDoS)
-    // e.g., (a+)+, (a*)+, (a+)*, (a{1,})+
-    // Note: lookahead (?!), (?=), lookbehind (?<), and named groups (?<name>) are safe and allowed
-    const NESTED_QUANTIFIER_PATTERN = /(\(.*[+*?].*\)|\[.*\])[+*?]/;
-    if (NESTED_QUANTIFIER_PATTERN.test(pattern)) {
-        logger.error(`GITLAB_DENIED_TOOLS_REGEX contains potentially unsafe nested quantifiers. Ignoring.`);
-        return undefined;
-    }
-    try {
-        const regex = new RegExp(pattern);
-        // Dry-run against a sample string to catch immediate issues
-        regex.test("sample_tool_name");
-        return regex;
-    }
-    catch {
-        logger.error(`Invalid GITLAB_DENIED_TOOLS_REGEX pattern: "${pattern}". Ignoring.`);
-        return undefined;
+    const compiled = compileDeniedToolsRegex(getConfig("denied-tools-regex", "GITLAB_DENIED_TOOLS_REGEX"));
+    if (compiled.error) {
+        logger.error(compiled.error);
     }
+    return compiled.regex;
 })();
 // ---------------------------------------------------------------------------
 // Tool policy: approve / hidden sets
@@ -1317,7 +1313,7 @@ if (GITLAB_MCP_OAUTH) {
     }
     logger.info("MCP OAuth enabled: GitLab OAuth proxy active (Private-Token/JOB-TOKEN headers bypass OAuth)");
 }
-if (getPositionalCliCommand(process.argv) !== "auth" &&
+if (!isCliInvocation(process.argv) &&
     !REMOTE_AUTHORIZATION &&
     !GITLAB_MCP_OAUTH &&
     !USE_OAUTH &&
@@ -12004,10 +12000,12 @@ async function runServer() {
             logger.info("Using OAuth authentication...");
             try {
                 const gitlabBaseUrl = GITLAB_API_URL.replace(/\/api\/v4$/, "");
-                const oauthResult = await initializeOAuthClient(gitlabBaseUrl);
-                oauthClient = oauthResult.client;
-                OAUTH_ACCESS_TOKEN = oauthResult.accessToken;
-                logger.info("OAuth authentication successful");
+                // Construct the client synchronously (no network). The token is
+                // acquired lazily on the first tool call via ensureValidOAuthToken,
+                // by which point the network is ready. This avoids blocking startup
+                // and avoids opening a browser on transient boot-time network errors.
+                oauthClient = createGitLabOAuthClient(gitlabBaseUrl);
+                logger.info("OAuth enabled; token acquired lazily on first use.");
             }
             catch (error) {
                 logger.error({ err: error }, "OAuth authentication failed");
@@ -12049,7 +12047,16 @@ async function runServer() {
     }
 }
 async function main() {
-    if (getPositionalCliCommand(process.argv) === "auth") {
+    const cli = resolveCli(process.argv);
+    if (cli.kind === "help") {
+        process.stdout.write(cli.text);
+        process.exit(0);
+    }
+    if (cli.kind === "usage" || cli.kind === "refused") {
+        process.stderr.write(`${cli.message}\n`);
+        process.exit(2);
+    }
+    if (cli.kind === "auth" || getPositionalCliCommand(process.argv) === "auth") {
         try {
             await runAuthCommandAsync();
             process.exit(0);
@@ -12061,8 +12068,53 @@ async function main() {
             process.exit(1);
         }
     }
+    if (cli.kind === "run") {
+        if (!hasCliCredentials()) {
+            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);
+        }
+        try {
+            const result = await handleToolCall({ name: cli.toolName, arguments: cli.args });
+            const masked = maskCliToolResult(cli.toolName, result);
+            const formatted = formatToolOutput({
+                result: masked,
+                mode: cli.output,
+                tableSpec: cli.tableSpec,
+            });
+            if (formatted.stderr) {
+                process.stderr.write(formatted.stderr);
+            }
+            process.stdout.write(formatted.stdout);
+            process.exit(formatted.isError ? 1 : 0);
+        }
+        catch (error) {
+            process.stderr.write(formatCliError(error));
+            logger.error({ err: error }, "cli command failed");
+            process.exit(1);
+        }
+    }
     await runServer();
 }
+function hasCliCredentials() {
+    return Boolean(GITLAB_PERSONAL_ACCESS_TOKEN || GITLAB_JOB_TOKEN || GITLAB_AUTH_COOKIE_PATH || USE_OAUTH);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function maskCliToolResult(toolName, result) {
+    const gitlabInstance = getConfig("api-url", "GITLAB_API_URL") || "https://gitlab.com";
+    const engine = maskingPolicyResolver?.select({
+        gitlabInstance,
+        allowBuiltinForUnscoped: true,
+    });
+    if (!engine || !isRecord(result)) {
+        return result;
+    }
+    const isPlainText = toolName === "get_pipeline_job_output" ||
+        toolName === "get_job_artifact_file" ||
+        (toolName === "download_release_asset" && !IS_REMOTE);
+    return engine.maskToolResult(result, { textFormat: isPlainText ? "plain" : "json" });
+}
 main().catch(error => {
     logger.fatal({ err: error }, "Fatal error in main()");
     process.exit(1);