@zereight/mcp-gitlab 2.1.68 → 2.1.70

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
 // ---------------------------------------------------------------------------