gitlab-mcp 1.2.1 → 1.4.0

package/dist/lib/gitlab-client.d.ts

@@ -1,8 +1,10 @@
 import { type SessionAuth } from "./auth-context.js";
+import type { GitLabAuthHeader } from "../types/auth.js";
 export interface GitLabClientOptions {
     timeoutMs?: number;
     apiUrls?: string[];
     maxAttachmentBytes?: number;
+    maxLocalFileBytes?: number;
     maxResponseBodyBytes?: number;
     beforeRequest?: (context: GitLabBeforeRequestContext) => Promise<GitLabBeforeRequestResult | void>;
 }
@@ -12,7 +14,7 @@ export interface GitLabRequestOptions {
     headers?: HeadersInit;
     token?: string;
     apiUrl?: string;
-    authHeader?: "authorization" | "private-token";
+    authHeader?: GitLabAuthHeader;
 }
 export interface GitLabBeforeRequestContext {
     url: URL;
@@ -20,13 +22,13 @@ export interface GitLabBeforeRequestContext {
     headers: Headers;
     body?: BodyInit;
     token?: string;
-    authHeader?: "authorization" | "private-token";
+    authHeader?: GitLabAuthHeader;
 }
 export interface GitLabBeforeRequestResult {
     headers?: Headers;
     body?: BodyInit;
     token?: string;
-    authHeader?: "authorization" | "private-token";
+    authHeader?: GitLabAuthHeader;
     fetchImpl?: typeof fetch;
 }
 export interface GitLabProject {
@@ -56,6 +58,24 @@ export interface MergeRequestCodeContextFile {
     deleted_file: boolean;
     diff: string;
 }
+export interface GitLabDownloadedFile {
+    fileName: string;
+    contentType: string;
+    base64: string;
+}
+export interface GitLabSavedFile {
+    filePath: string;
+    fileName: string;
+    contentType: string;
+    size: number;
+}
+export interface GitLabArtifactFileContent {
+    fileName: string;
+    contentType: string;
+    encoding: "utf8" | "base64";
+    content: string;
+}
+export type GitLabPipelineInputValue = string | number | boolean | Array<string | number | boolean>;
 export declare class GitLabApiError extends Error {
     readonly status: number;
     readonly details?: unknown | undefined;
@@ -63,6 +83,7 @@ export declare class GitLabApiError extends Error {
 }
 export declare class GitLabClient {
     private static readonly DEFAULT_MAX_ATTACHMENT_BYTES;
+    private static readonly DEFAULT_MAX_LOCAL_FILE_BYTES;
     private static readonly DEFAULT_MAX_RESPONSE_BODY_BYTES;
     private readonly baseApiUrl;
     private readonly apiUrls;
@@ -70,6 +91,7 @@ export declare class GitLabClient {
     private readonly defaultToken?;
     private readonly timeoutMs;
     private readonly maxAttachmentBytes;
+    private readonly maxLocalFileBytes;
     private readonly maxResponseBodyBytes;
     private readonly beforeRequest?;
     constructor(baseApiUrl: string, defaultToken?: string, options?: GitLabClientOptions);
@@ -158,6 +180,7 @@ export declare class GitLabClient {
     approveMergeRequest(projectId: string, mergeRequestIid: string, payload?: Record<string, unknown>, options?: GitLabRequestOptions): Promise<unknown>;
     unapproveMergeRequest(projectId: string, mergeRequestIid: string, options?: GitLabRequestOptions): Promise<unknown>;
     getMergeRequestApprovalState(projectId: string, mergeRequestIid: string, options?: GitLabRequestOptions): Promise<unknown>;
+    getMergeRequestConflicts(projectId: string, mergeRequestIid: string, options?: GitLabRequestOptions): Promise<unknown>;
     listMergeRequestDiscussions(projectId: string, mergeRequestIid: string, options?: GitLabRequestOptions): Promise<unknown>;
     createMergeRequestDiscussionNote(projectId: string, mergeRequestIid: string, discussionId: string, payload: {
         body: string;
@@ -257,10 +280,19 @@ export declare class GitLabClient {
     deleteWikiPage(projectId: string, slug: string, options?: GitLabRequestOptions): Promise<unknown>;
     listPipelines(projectId: string, options?: GitLabRequestOptions): Promise<unknown>;
     getPipeline(projectId: string, pipelineId: string, options?: GitLabRequestOptions): Promise<unknown>;
+    listDeployments(projectId: string, options?: GitLabRequestOptions): Promise<unknown>;
+    getDeployment(projectId: string, deploymentId: string, options?: GitLabRequestOptions): Promise<unknown>;
+    listEnvironments(projectId: string, options?: GitLabRequestOptions): Promise<unknown>;
+    getEnvironment(projectId: string, environmentId: string, options?: GitLabRequestOptions): Promise<unknown>;
     listPipelineJobs(projectId: string, pipelineId: string, options?: GitLabRequestOptions): Promise<unknown>;
     listPipelineTriggerJobs(projectId: string, pipelineId: string, options?: GitLabRequestOptions): Promise<unknown>;
     getPipelineJob(projectId: string, jobId: string, options?: GitLabRequestOptions): Promise<unknown>;
     getPipelineJobOutput(projectId: string, jobId: string, options?: GitLabRequestOptions): Promise<unknown>;
+    listJobArtifacts(projectId: string, jobId: string, options?: GitLabRequestOptions): Promise<unknown>;
+    downloadJobArtifacts(projectId: string, jobId: string, options?: GitLabRequestOptions): Promise<GitLabDownloadedFile>;
+    saveJobArtifacts(projectId: string, jobId: string, localPath?: string, options?: GitLabRequestOptions): Promise<GitLabSavedFile>;
+    getJobArtifactFile(projectId: string, jobId: string, artifactPath: string, options?: GitLabRequestOptions): Promise<GitLabArtifactFileContent>;
+    saveJobArtifactFile(projectId: string, jobId: string, artifactPath: string, localPath?: string, options?: GitLabRequestOptions): Promise<GitLabSavedFile>;
     createPipeline(projectId: string, payload: {
         ref: string;
         variables?: Array<{
@@ -268,6 +300,7 @@ export declare class GitLabClient {
             value: string;
             variable_type?: "env_var" | "file";
         }>;
+        inputs?: Record<string, GitLabPipelineInputValue>;
     }, options?: GitLabRequestOptions): Promise<unknown>;
     retryPipeline(projectId: string, pipelineId: string, options?: GitLabRequestOptions): Promise<unknown>;
     cancelPipeline(projectId: string, pipelineId: string, options?: GitLabRequestOptions): Promise<unknown>;
@@ -309,12 +342,13 @@ export declare class GitLabClient {
     getProjectEvents(projectId: string, options?: GitLabRequestOptions): Promise<unknown>;
     uploadMarkdown(projectId: string, content: string, filename: string, options?: GitLabRequestOptions): Promise<unknown>;
     uploadMarkdownFile(projectId: string, filePath: string, options?: GitLabRequestOptions): Promise<unknown>;
-    downloadAttachment(urlOrPath: string, options?: GitLabRequestOptions): Promise<{
-        fileName: string;
-        contentType: string;
-        base64: string;
-    }>;
+    downloadAttachment(urlOrPath: string, options?: GitLabRequestOptions): Promise<GitLabDownloadedFile>;
     executeGraphql(query: string, variables: Record<string, unknown> | undefined, options?: GitLabRequestOptions): Promise<unknown>;
+    private downloadFile;
+    private saveDownloadedFile;
+    private downloadFileContent;
+    private fetchRawResponse;
+    private toDownloadError;
     get(path: string, options?: GitLabRequestOptions): Promise<unknown>;
     post(path: string, options?: GitLabRequestOptions): Promise<unknown>;
     put(path: string, options?: GitLabRequestOptions): Promise<unknown>;

package/dist/lib/gitlab-client.js

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getSessionAuth } from "./auth-context.js";
@@ -13,6 +15,7 @@ export class GitLabApiError extends Error {
 }
 export class GitLabClient {
     static DEFAULT_MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+    static DEFAULT_MAX_LOCAL_FILE_BYTES = 250 * 1024 * 1024;
     static DEFAULT_MAX_RESPONSE_BODY_BYTES = 25 * 1024 * 1024;
     baseApiUrl;
     apiUrls;
@@ -20,6 +23,7 @@ export class GitLabClient {
     defaultToken;
     timeoutMs;
     maxAttachmentBytes;
+    maxLocalFileBytes;
     maxResponseBodyBytes;
     beforeRequest;
     constructor(baseApiUrl, defaultToken, options = {}) {
@@ -32,6 +36,7 @@ export class GitLabClient {
         this.timeoutMs = options.timeoutMs ?? 20_000;
         this.maxAttachmentBytes =
             options.maxAttachmentBytes ?? GitLabClient.DEFAULT_MAX_ATTACHMENT_BYTES;
+        this.maxLocalFileBytes = options.maxLocalFileBytes ?? GitLabClient.DEFAULT_MAX_LOCAL_FILE_BYTES;
         this.maxResponseBodyBytes =
             options.maxResponseBodyBytes ?? GitLabClient.DEFAULT_MAX_RESPONSE_BODY_BYTES;
         this.beforeRequest = options.beforeRequest;
@@ -229,6 +234,9 @@ export class GitLabClient {
     getMergeRequestApprovalState(projectId, mergeRequestIid, options = {}) {
         return this.get(`/projects/${encode(projectId)}/merge_requests/${encode(mergeRequestIid)}/approval_state`, options);
     }
+    getMergeRequestConflicts(projectId, mergeRequestIid, options = {}) {
+        return this.get(`/projects/${encode(projectId)}/merge_requests/${encode(mergeRequestIid)}/conflicts`, options);
+    }
     listMergeRequestDiscussions(projectId, mergeRequestIid, options = {}) {
         return this.get(`/projects/${encode(projectId)}/merge_requests/${encode(mergeRequestIid)}/discussions`, options);
     }
@@ -501,6 +509,18 @@ export class GitLabClient {
     getPipeline(projectId, pipelineId, options = {}) {
         return this.get(`/projects/${encode(projectId)}/pipelines/${encode(pipelineId)}`, options);
     }
+    listDeployments(projectId, options = {}) {
+        return this.get(`/projects/${encode(projectId)}/deployments`, options);
+    }
+    getDeployment(projectId, deploymentId, options = {}) {
+        return this.get(`/projects/${encode(projectId)}/deployments/${encode(deploymentId)}`, options);
+    }
+    listEnvironments(projectId, options = {}) {
+        return this.get(`/projects/${encode(projectId)}/environments`, options);
+    }
+    getEnvironment(projectId, environmentId, options = {}) {
+        return this.get(`/projects/${encode(projectId)}/environments/${encode(environmentId)}`, options);
+    }
     listPipelineJobs(projectId, pipelineId, options = {}) {
         return this.get(`/projects/${encode(projectId)}/pipelines/${encode(pipelineId)}/jobs`, options);
     }
@@ -513,6 +533,47 @@ export class GitLabClient {
     getPipelineJobOutput(projectId, jobId, options = {}) {
         return this.get(`/projects/${encode(projectId)}/jobs/${encode(jobId)}/trace`, options);
     }
+    listJobArtifacts(projectId, jobId, options = {}) {
+        return this.get(`/projects/${encode(projectId)}/jobs/${encode(jobId)}/artifacts/tree`, options);
+    }
+    async downloadJobArtifacts(projectId, jobId, options = {}) {
+        const requestConfig = this.resolveRequestConfig(options);
+        const url = new URL(`projects/${encode(projectId)}/jobs/${encode(jobId)}/artifacts`, `${requestConfig.apiUrl}/`);
+        return this.downloadFile(url, {
+            headers: options.headers,
+            token: requestConfig.token,
+            authHeader: requestConfig.authHeader
+        }, "Job artifacts", `artifacts-job-${jobId}.zip`);
+    }
+    async saveJobArtifacts(projectId, jobId, localPath, options = {}) {
+        const requestConfig = this.resolveRequestConfig(options);
+        const url = new URL(`projects/${encode(projectId)}/jobs/${encode(jobId)}/artifacts`, `${requestConfig.apiUrl}/`);
+        return this.saveDownloadedFile(url, {
+            headers: options.headers,
+            token: requestConfig.token,
+            authHeader: requestConfig.authHeader
+        }, "Job artifacts", `artifacts-job-${jobId}.zip`, localPath);
+    }
+    async getJobArtifactFile(projectId, jobId, artifactPath, options = {}) {
+        const requestConfig = this.resolveRequestConfig(options);
+        const encodedArtifactPath = encodeSlashPath(artifactPath);
+        const url = new URL(`projects/${encode(projectId)}/jobs/${encode(jobId)}/artifacts/${encodedArtifactPath}`, `${requestConfig.apiUrl}/`);
+        return this.downloadFileContent(url, {
+            headers: options.headers,
+            token: requestConfig.token,
+            authHeader: requestConfig.authHeader
+        }, "Job artifact file", path.basename(artifactPath) || `artifact-${jobId}`);
+    }
+    async saveJobArtifactFile(projectId, jobId, artifactPath, localPath, options = {}) {
+        const requestConfig = this.resolveRequestConfig(options);
+        const encodedArtifactPath = encodeSlashPath(artifactPath);
+        const url = new URL(`projects/${encode(projectId)}/jobs/${encode(jobId)}/artifacts/${encodedArtifactPath}`, `${requestConfig.apiUrl}/`);
+        return this.saveDownloadedFile(url, {
+            headers: options.headers,
+            token: requestConfig.token,
+            authHeader: requestConfig.authHeader
+        }, "Job artifact file", path.basename(artifactPath) || `artifact-${jobId}`, localPath);
+    }
     createPipeline(projectId, payload, options = {}) {
         return this.post(`/projects/${encode(projectId)}/pipeline`, {
             ...options,
@@ -705,21 +766,126 @@ export class GitLabClient {
     async downloadAttachment(urlOrPath, options = {}) {
         const requestConfig = this.resolveRequestConfig(options);
         const url = this.resolveAttachmentUrl(urlOrPath, requestConfig.apiUrl);
+        return this.downloadFile(url, {
+            headers: options.headers,
+            token: requestConfig.token,
+            authHeader: requestConfig.authHeader
+        }, "Attachment", `attachment-${Date.now()}`);
+    }
+    // graphql
+    executeGraphql(query, variables, options = {}) {
+        const requestConfig = this.resolveRequestConfig(options);
+        const endpoint = buildGraphqlEndpoint(requestConfig.apiUrl);
+        return this.rawRequest(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(options.headers ?? {})
+            },
+            body: JSON.stringify({ query, variables }),
+            token: requestConfig.token,
+            authHeader: requestConfig.authHeader
+        });
+    }
+    async downloadFile(url, options, label, fallbackFileName) {
+        const response = await this.fetchRawResponse(url, {
+            method: "GET",
+            headers: options.headers,
+            token: options.token,
+            authHeader: options.authHeader
+        });
+        if (!response.ok) {
+            throw await this.toDownloadError(response, label);
+        }
+        assertContentLengthWithinLimit(response, this.maxAttachmentBytes, label);
+        const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+        const disposition = response.headers.get("content-disposition") ?? "";
+        const fileName = extractFileName(disposition) ?? fallbackFileName;
+        const bytes = await readResponseBytesWithLimit(response, this.maxAttachmentBytes, label);
+        return {
+            fileName,
+            contentType,
+            base64: bytes.toString("base64")
+        };
+    }
+    async saveDownloadedFile(url, options, label, fallbackFileName, localPath) {
+        const response = await this.fetchRawResponse(url, {
+            method: "GET",
+            headers: options.headers,
+            token: options.token,
+            authHeader: options.authHeader
+        });
+        if (!response.ok) {
+            throw await this.toDownloadError(response, label);
+        }
+        assertContentLengthWithinLimit(response, this.maxLocalFileBytes, label);
+        const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+        const disposition = response.headers.get("content-disposition") ?? "";
+        const resolvedFileName = resolveDownloadedFileName(disposition, fallbackFileName);
+        const baseDirectory = localPath ? path.resolve(localPath) : process.cwd();
+        const tempFilePath = buildTemporaryDownloadPath(baseDirectory, resolvedFileName);
+        await fs.mkdir(baseDirectory, { recursive: true });
+        const size = await writeResponseToFileWithLimit(response, tempFilePath, this.maxLocalFileBytes, label);
+        const filePath = await commitDownloadedFile(tempFilePath, baseDirectory, resolvedFileName);
+        const fileName = path.basename(filePath);
+        return {
+            filePath,
+            fileName,
+            contentType,
+            size
+        };
+    }
+    async downloadFileContent(url, options, label, fallbackFileName) {
+        const response = await this.fetchRawResponse(url, {
+            method: "GET",
+            headers: options.headers,
+            token: options.token,
+            authHeader: options.authHeader
+        });
+        if (!response.ok) {
+            throw await this.toDownloadError(response, label);
+        }
+        assertContentLengthWithinLimit(response, this.maxAttachmentBytes, label);
+        const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+        const disposition = response.headers.get("content-disposition") ?? "";
+        const fileName = extractFileName(disposition) ?? fallbackFileName;
+        const bytes = await readResponseBytesWithLimit(response, this.maxAttachmentBytes, label);
+        if (isTextLikeContent(contentType, fileName)) {
+            return {
+                fileName,
+                contentType,
+                encoding: "utf8",
+                content: bytes.toString("utf8")
+            };
+        }
+        return {
+            fileName,
+            contentType,
+            encoding: "base64",
+            content: bytes.toString("base64")
+        };
+    }
+    async fetchRawResponse(url, options) {
         let headers = new Headers(options.headers);
-        let token = requestConfig.token;
-        let authHeader = requestConfig.authHeader;
+        let requestBody = options.body;
+        let token = options.token;
+        let authHeader = options.authHeader;
         let fetchImpl = fetch;
         if (this.beforeRequest) {
             const override = await this.beforeRequest({
                 url,
-                method: "GET",
+                method: options.method,
                 headers,
+                body: requestBody,
                 token,
-                authHeader: requestConfig.authHeader
+                authHeader: options.authHeader
             });
             if (override?.headers) {
                 headers = override.headers;
             }
+            if (override?.body !== undefined) {
+                requestBody = override.body;
+            }
             if (override?.token !== undefined) {
                 token = override.token;
             }
@@ -731,48 +897,24 @@ export class GitLabClient {
             }
         }
         this.attachAuth(headers, token, authHeader);
-        const response = await fetchImpl(url, {
-            method: "GET",
+        return fetchImpl(url, {
+            method: options.method,
+            body: requestBody,
             headers,
             signal: AbortSignal.timeout(this.timeoutMs)
         });
-        if (!response.ok) {
-            let details;
-            try {
-                details = await this.parseResponseBody(response);
-            }
-            catch (error) {
-                details = {
-                    message: error instanceof Error ? error.message : "Failed to read GitLab error response"
-                };
-            }
-            throw new GitLabApiError(`GitLab attachment download failed: ${response.status} ${response.statusText}`, response.status, details);
-        }
-        assertContentLengthWithinLimit(response, this.maxAttachmentBytes, "Attachment");
-        const contentType = response.headers.get("content-type") ?? "application/octet-stream";
-        const disposition = response.headers.get("content-disposition") ?? "";
-        const fileName = extractFileName(disposition) ?? `attachment-${Date.now()}`;
-        const bytes = await readResponseBytesWithLimit(response, this.maxAttachmentBytes, "Attachment");
-        return {
-            fileName,
-            contentType,
-            base64: bytes.toString("base64")
-        };
     }
-    // graphql
-    executeGraphql(query, variables, options = {}) {
-        const requestConfig = this.resolveRequestConfig(options);
-        const endpoint = buildGraphqlEndpoint(requestConfig.apiUrl);
-        return this.rawRequest(endpoint, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(options.headers ?? {})
-            },
-            body: JSON.stringify({ query, variables }),
-            token: requestConfig.token,
-            authHeader: requestConfig.authHeader
-        });
+    async toDownloadError(response, label) {
+        let details;
+        try {
+            details = await this.parseResponseBody(response);
+        }
+        catch (error) {
+            details = {
+                message: error instanceof Error ? error.message : "Failed to read GitLab error response"
+            };
+        }
+        return new GitLabApiError(`GitLab ${label.toLowerCase()} download failed: ${response.status} ${response.statusText}`, response.status, details);
     }
     // generic methods
     get(path, options = {}) {
@@ -920,6 +1062,10 @@ export class GitLabClient {
             headers.set("Authorization", `Bearer ${token}`);
             return;
         }
+        if (authHeader === "job-token") {
+            headers.set("JOB-TOKEN", token);
+            return;
+        }
         headers.set("PRIVATE-TOKEN", token);
     }
 }
@@ -969,6 +1115,149 @@ function extractFileName(contentDisposition) {
     }
     return decodeURIComponent(quoted[1] ?? "");
 }
+function resolveDownloadedFileName(contentDisposition, fallbackFileName) {
+    const extracted = extractFileName(contentDisposition);
+    const sanitized = sanitizeDownloadedFileName(extracted);
+    return sanitized ?? sanitizeDownloadedFileName(fallbackFileName) ?? "downloaded-file";
+}
+function sanitizeDownloadedFileName(fileName) {
+    if (!fileName) {
+        return undefined;
+    }
+    const normalized = fileName.replace(/\\/g, "/");
+    const basename = path.posix.basename(normalized).trim();
+    if (!basename || basename === "." || basename === "..") {
+        return undefined;
+    }
+    return basename;
+}
+async function commitDownloadedFile(tempFilePath, baseDirectory, fileName) {
+    const parsed = path.parse(fileName);
+    try {
+        for (let suffix = 0; suffix < 10_000; suffix += 1) {
+            const candidateName = suffix === 0 ? fileName : `${parsed.name || "downloaded-file"}-${suffix}${parsed.ext}`;
+            const candidatePath = path.join(baseDirectory, candidateName);
+            try {
+                await fs.link(tempFilePath, candidatePath);
+                return candidatePath;
+            }
+            catch (error) {
+                if (isFileExistsError(error)) {
+                    continue;
+                }
+                if (!supportsAtomicLinkFallback(error)) {
+                    throw error;
+                }
+                try {
+                    await fs.copyFile(tempFilePath, candidatePath, fsConstants.COPYFILE_EXCL);
+                    return candidatePath;
+                }
+                catch (copyError) {
+                    if (isFileExistsError(copyError)) {
+                        continue;
+                    }
+                    throw copyError;
+                }
+            }
+        }
+        throw new Error(`Unable to find an available local file name for '${fileName}'`);
+    }
+    finally {
+        await fs.rm(tempFilePath, { force: true });
+    }
+}
+function buildTemporaryDownloadPath(baseDirectory, fileName) {
+    return path.join(baseDirectory, `.${fileName}.${randomUUID()}.tmp`);
+}
+function isFileExistsError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "EEXIST");
+}
+function supportsAtomicLinkFallback(error) {
+    if (typeof error !== "object" || error === null || !("code" in error)) {
+        return false;
+    }
+    return ["EMLINK", "ENOTSUP", "EPERM"].includes(String(error.code));
+}
+const TEXT_CONTENT_TYPE_HINTS = [
+    "application/json",
+    "application/ld+json",
+    "application/problem+json",
+    "application/graphql",
+    "application/javascript",
+    "application/typescript",
+    "application/xml",
+    "application/xhtml+xml",
+    "application/yaml",
+    "application/x-yaml",
+    "application/toml",
+    "application/csv",
+    "application/sql"
+];
+const TEXT_FILE_EXTENSIONS = new Set([
+    ".c",
+    ".cc",
+    ".cfg",
+    ".conf",
+    ".cpp",
+    ".cs",
+    ".css",
+    ".csv",
+    ".dockerfile",
+    ".env",
+    ".go",
+    ".graphql",
+    ".h",
+    ".hpp",
+    ".html",
+    ".ini",
+    ".java",
+    ".js",
+    ".json",
+    ".jsx",
+    ".kt",
+    ".kts",
+    ".log",
+    ".md",
+    ".mjs",
+    ".php",
+    ".properties",
+    ".py",
+    ".rb",
+    ".rs",
+    ".scss",
+    ".sh",
+    ".sql",
+    ".svg",
+    ".swift",
+    ".toml",
+    ".ts",
+    ".tsx",
+    ".txt",
+    ".xml",
+    ".yaml",
+    ".yml"
+]);
+function isTextLikeContent(contentType, fileName) {
+    const normalizedContentType = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+    if (normalizedContentType.startsWith("text/")) {
+        return true;
+    }
+    if (TEXT_CONTENT_TYPE_HINTS.includes(normalizedContentType)) {
+        return true;
+    }
+    return isTextLikeFileName(fileName);
+}
+function isTextLikeFileName(fileName) {
+    const normalizedFileName = fileName.trim().toLowerCase();
+    if (normalizedFileName === "dockerfile" || normalizedFileName.endsWith(".gitignore")) {
+        return true;
+    }
+    const extension = path.extname(normalizedFileName);
+    return extension.length > 0 && TEXT_FILE_EXTENSIONS.has(extension);
+}
 function parseContentLength(value) {
     if (!value) {
         return undefined;
@@ -1022,4 +1311,53 @@ async function readResponseBytesWithLimit(response, maxBytes, label) {
     }
     return Buffer.concat(chunks, total);
 }
+async function writeResponseToFileWithLimit(response, filePath, maxBytes, label) {
+    if (!response.body) {
+        const bytes = Buffer.from(await response.arrayBuffer());
+        if (bytes.length > maxBytes) {
+            throw new Error(`${label} size ${bytes.length} bytes exceeds limit ${maxBytes} bytes`);
+        }
+        await fs.writeFile(filePath, bytes);
+        return bytes.length;
+    }
+    const fileHandle = await fs.open(filePath, "w");
+    const reader = response.body.getReader();
+    let total = 0;
+    let success = false;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                success = true;
+                return total;
+            }
+            if (!value) {
+                continue;
+            }
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw new Error(`${label} size ${total} bytes exceeds limit ${maxBytes} bytes`);
+            }
+            await writeBufferToFile(fileHandle, Buffer.from(value), total - value.byteLength);
+        }
+    }
+    finally {
+        reader.releaseLock();
+        await fileHandle.close();
+        if (!success) {
+            await fs.rm(filePath, { force: true });
+        }
+    }
+}
+async function writeBufferToFile(fileHandle, buffer, startPosition) {
+    let offset = 0;
+    while (offset < buffer.length) {
+        const { bytesWritten } = await fileHandle.write(buffer, offset, buffer.length - offset, startPosition + offset);
+        if (bytesWritten <= 0) {
+            throw new Error("Failed to write download chunk");
+        }
+        offset += bytesWritten;
+    }
+}
 //# sourceMappingURL=gitlab-client.js.map