@zereight/mcp-gitlab 1.0.62 → 1.0.64

package/README.md

@@ -111,6 +111,7 @@ $ sh scripts/image_push.sh docker_user_name
 - `USE_GITLAB_WIKI`: When set to 'true', enables the wiki-related tools (list_wiki_pages, get_wiki_page, create_wiki_page, update_wiki_page, delete_wiki_page). By default, wiki features are disabled.
 - `USE_MILESTONE`: When set to 'true', enables the milestone-related tools (list_milestones, get_milestone, create_milestone, edit_milestone, delete_milestone, get_milestone_issue, get_milestone_merge_requests, promote_milestone, get_milestone_burndown_events). By default, milestone features are disabled.
 - `USE_PIPELINE`: When set to 'true', enables the pipeline-related tools (list_pipelines, get_pipeline, list_pipeline_jobs, get_pipeline_job, get_pipeline_job_output, create_pipeline, retry_pipeline, cancel_pipeline). By default, pipeline features are disabled.
+- `GITLAB_AUTH_COOKIE_PATH`: Path to an authentication cookie file for GitLab instances that require cookie-based authentication. When provided, the cookie will be included in all GitLab API requests.
 
 ## Tools 🛠️
 

package/build/index.js

@@ -3,7 +3,9 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import fetch from "node-fetch";
+import nodeFetch from "node-fetch";
+import fetchCookie from "fetch-cookie";
+import { CookieJar, parse as parseCookie } from "tough-cookie";
 import { SocksProxyAgent } from "socks-proxy-agent";
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { HttpProxyAgent } from "http-proxy-agent";
@@ -51,6 +53,7 @@ const server = new Server({
     },
 });
 const GITLAB_PERSONAL_ACCESS_TOKEN = process.env.GITLAB_PERSONAL_ACCESS_TOKEN;
+const GITLAB_AUTH_COOKIE_PATH = process.env.GITLAB_AUTH_COOKIE_PATH;
 const IS_OLD = process.env.GITLAB_IS_OLD === "true";
 const GITLAB_READ_ONLY_MODE = process.env.GITLAB_READ_ONLY_MODE === "true";
 const USE_GITLAB_WIKI = process.env.USE_GITLAB_WIKI === "true";
@@ -91,6 +94,76 @@ if (HTTPS_PROXY) {
 }
 httpsAgent = httpsAgent || new HttpsAgent(sslOptions);
 httpAgent = httpAgent || new Agent();
+// Create cookie jar with clean Netscape file parsing
+const createCookieJar = () => {
+    if (!GITLAB_AUTH_COOKIE_PATH)
+        return null;
+    try {
+        const cookiePath = GITLAB_AUTH_COOKIE_PATH.startsWith("~/")
+            ? path.join(process.env.HOME || "", GITLAB_AUTH_COOKIE_PATH.slice(2))
+            : GITLAB_AUTH_COOKIE_PATH;
+        const jar = new CookieJar();
+        const cookieContent = fs.readFileSync(cookiePath, "utf8");
+        cookieContent.split("\n").forEach(line => {
+            // Handle #HttpOnly_ prefix
+            if (line.startsWith("#HttpOnly_")) {
+                line = line.slice(10);
+            }
+            // Skip comments and empty lines
+            if (line.startsWith("#") || !line.trim()) {
+                return;
+            }
+            // Parse Netscape format: domain, flag, path, secure, expires, name, value
+            const parts = line.split("\t");
+            if (parts.length >= 7) {
+                const [domain, , path, secure, expires, name, value] = parts;
+                // Build cookie string in standard format
+                const cookieStr = `${name}=${value}; Domain=${domain}; Path=${path}${secure === "TRUE" ? "; Secure" : ""}${expires !== "0" ? `; Expires=${new Date(parseInt(expires) * 1000).toUTCString()}` : ""}`;
+                // Use tough-cookie's parse function for robust parsing
+                const cookie = parseCookie(cookieStr);
+                if (cookie) {
+                    const url = `${secure === "TRUE" ? "https" : "http"}://${domain.startsWith(".") ? domain.slice(1) : domain}`;
+                    jar.setCookieSync(cookie, url);
+                }
+            }
+        });
+        return jar;
+    }
+    catch (error) {
+        console.error("Error loading cookie file:", error);
+        return null;
+    }
+};
+// Initialize cookie jar and fetch
+const cookieJar = createCookieJar();
+const fetch = cookieJar ? fetchCookie(nodeFetch, cookieJar) : nodeFetch;
+// Ensure session is established for the current request
+async function ensureSessionForRequest() {
+    if (!cookieJar || !GITLAB_AUTH_COOKIE_PATH)
+        return;
+    // Extract the base URL from GITLAB_API_URL
+    const apiUrl = new URL(GITLAB_API_URL);
+    const baseUrl = `${apiUrl.protocol}//${apiUrl.hostname}`;
+    // Check if we already have GitLab session cookies
+    const gitlabCookies = cookieJar.getCookiesSync(baseUrl);
+    const hasSessionCookie = gitlabCookies.some(cookie => cookie.key === '_gitlab_session' || cookie.key === 'remember_user_token');
+    if (!hasSessionCookie) {
+        try {
+            // Establish session with a lightweight request
+            await fetch(`${GITLAB_API_URL}/user`, {
+                ...DEFAULT_FETCH_CONFIG,
+                redirect: 'follow'
+            }).catch(() => {
+                // Ignore errors - the important thing is that cookies get set during redirects
+            });
+            // Small delay to ensure cookies are fully processed
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        catch (error) {
+            // Ignore session establishment errors
+        }
+    }
+}
 // Modify DEFAULT_HEADERS to include agent configuration
 const DEFAULT_HEADERS = {
     Accept: "application/json",
@@ -366,7 +439,7 @@ const allTools = [
     },
     {
         name: "get_pipeline_job_output",
-        description: "Get the output/trace of a GitLab pipeline job number",
+        description: "Get the output/trace of a GitLab pipeline job with optional pagination to limit context window usage",
         inputSchema: zodToJsonSchema(GetPipelineJobOutputSchema),
     },
     {
@@ -1963,9 +2036,11 @@ async function getPipelineJob(projectId, jobId) {
  *
  * @param {string} projectId - The ID or URL-encoded path of the project
  * @param {number} jobId - The ID of the job
+ * @param {number} limit - Maximum number of lines to return from the end (default: 1000)
+ * @param {number} offset - Number of lines to skip from the end (default: 0)
  * @returns {Promise<string>} The job output/trace
  */
-async function getPipelineJobOutput(projectId, jobId) {
+async function getPipelineJobOutput(projectId, jobId, limit, offset) {
     projectId = decodeURIComponent(projectId); // Decode project ID
     const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/jobs/${jobId}/trace`);
     const response = await fetch(url.toString(), {
@@ -1979,7 +2054,28 @@ async function getPipelineJobOutput(projectId, jobId) {
         throw new Error(`Job trace not found or job is not finished yet`);
     }
     await handleGitLabError(response);
-    return await response.text();
+    const fullTrace = await response.text();
+    // Apply client-side pagination to limit context window usage
+    if (limit !== undefined || offset !== undefined) {
+        const lines = fullTrace.split('\n');
+        const startOffset = offset || 0;
+        const maxLines = limit || 1000;
+        // Return lines from the end, skipping offset lines and limiting to maxLines
+        const startIndex = Math.max(0, lines.length - startOffset - maxLines);
+        const endIndex = lines.length - startOffset;
+        const selectedLines = lines.slice(startIndex, endIndex);
+        const result = selectedLines.join('\n');
+        // Add metadata about truncation
+        if (startIndex > 0 || endIndex < lines.length) {
+            const totalLines = lines.length;
+            const shownLines = selectedLines.length;
+            const skippedFromStart = startIndex;
+            const skippedFromEnd = startOffset;
+            return `[Log truncated: showing ${shownLines} of ${totalLines} lines, skipped ${skippedFromStart} from start, ${skippedFromEnd} from end]\n\n${result}`;
+        }
+        return result;
+    }
+    return fullTrace;
 }
 /**
  * Create a new pipeline
@@ -2339,6 +2435,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (!request.params.arguments) {
             throw new Error("Arguments are required");
         }
+        // Ensure session is established for every request if cookie authentication is enabled
+        if (GITLAB_AUTH_COOKIE_PATH) {
+            await ensureSessionForRequest();
+        }
         switch (request.params.name) {
             case "fork_repository": {
                 const forkArgs = ForkRepositorySchema.parse(request.params.arguments);
@@ -2823,8 +2923,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "get_pipeline_job_output": {
-                const { project_id, job_id } = GetPipelineJobOutputSchema.parse(request.params.arguments);
-                const jobOutput = await getPipelineJobOutput(project_id, job_id);
+                const { project_id, job_id, limit, offset } = GetPipelineJobOutputSchema.parse(request.params.arguments);
+                const jobOutput = await getPipelineJobOutput(project_id, job_id, limit, offset);
                 return {
                     content: [
                         {

package/build/schemas.js

@@ -178,6 +178,8 @@ export const CancelPipelineSchema = z.object({
 export const GetPipelineJobOutputSchema = z.object({
     project_id: z.string().describe("Project ID or URL-encoded path"),
     job_id: z.number().describe("The ID of the job"),
+    limit: z.number().optional().describe("Maximum number of lines to return from the end of the log (default: 1000)"),
+    offset: z.number().optional().describe("Number of lines to skip from the end of the log (default: 0)"),
 });
 // User schemas
 export const GitLabUserSchema = z.object({
@@ -272,14 +274,14 @@ export const GitLabRepositorySchema = z.object({
         project_access: z
             .object({
             access_level: z.number(),
-            notification_level: z.number().optional(),
+            notification_level: z.number().nullable().optional(),
         })
             .optional()
             .nullable(),
         group_access: z
             .object({
             access_level: z.number(),
-            notification_level: z.number().optional(),
+            notification_level: z.number().nullable().optional(),
         })
             .optional()
             .nullable(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "1.0.62",
+  "version": "1.0.64",
   "description": "MCP server for using the GitLab API",
   "license": "MIT",
   "author": "zereight",
@@ -33,11 +33,13 @@
     "@modelcontextprotocol/sdk": "1.8.0",
     "@types/node-fetch": "^2.6.12",
     "express": "^5.1.0",
+    "fetch-cookie": "^3.1.0",
     "form-data": "^4.0.0",
     "http-proxy-agent": "^7.0.2",
     "https-proxy-agent": "^7.0.6",
     "node-fetch": "^3.3.2",
     "socks-proxy-agent": "^8.0.5",
+    "tough-cookie": "^5.1.2",
     "zod-to-json-schema": "^3.23.5"
   },
   "devDependencies": {