@zereight/mcp-gitlab 2.0.30 → 2.0.32

package/build/oauth.js

@@ -1,4 +1,5 @@
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 import * as http from "http";
 import * as net from "net";
@@ -82,7 +83,7 @@ export class GitLabOAuth {
     constructor(config) {
         this.config = config;
         this.tokenStoragePath =
-            config.tokenStoragePath || path.join(process.env.HOME || "", ".gitlab-mcp-token.json");
+            config.tokenStoragePath || path.join(os.homedir(), ".gitlab-mcp-token.json");
     }
     /**
      * Get the authorization URL for OAuth flow
@@ -505,9 +506,11 @@ export class GitLabOAuth {
     }
 }
 /**
- * Initialize OAuth authentication for GitLab MCP server
+ * Create and initialize a GitLabOAuth client.
+ * Performs initial authentication (triggers browser flow if needed).
+ * Returns the client instance and the initial access token.
  */
-export async function initializeOAuth(gitlabUrl = "https://gitlab.com") {
+export async function initializeOAuthClient(gitlabUrl = "https://gitlab.com") {
     const clientId = process.env.GITLAB_OAUTH_CLIENT_ID;
     const clientSecret = process.env.GITLAB_OAUTH_CLIENT_SECRET;
     const redirectUri = process.env.GITLAB_OAUTH_REDIRECT_URI || "http://127.0.0.1:8888/callback";
@@ -523,5 +526,14 @@ export async function initializeOAuth(gitlabUrl = "https://gitlab.com") {
         scopes: ["api"],
         tokenStoragePath,
     });
-    return await oauth.getAccessToken();
+    // Single call: triggers browser flow if needed, or reads cached token
+    const accessToken = await oauth.getAccessToken();
+    return { client: oauth, accessToken };
+}
+/**
+ * Initialize OAuth authentication for GitLab MCP server
+ */
+export async function initializeOAuth(gitlabUrl = "https://gitlab.com") {
+    const { accessToken } = await initializeOAuthClient(gitlabUrl);
+    return accessToken;
 }

package/build/schemas.js

@@ -62,6 +62,8 @@ export const GitLabPipelineJobSchema = z.object({
     started_at: z.string().nullable().optional(),
     finished_at: z.string().nullable().optional(),
     duration: z.number().nullable().optional(),
+    queued_duration: z.number().nullable().optional(),
+    failure_reason: z.string().nullable().optional(),
     user: z
         .object({
         id: z.coerce.string(),
@@ -89,6 +91,19 @@ export const GitLabPipelineJobSchema = z.object({
     })
         .optional(),
     web_url: z.string().optional(),
+    allow_failure: z.boolean().optional(),
+    retried: z.boolean().optional(),
+    tag_list: z.array(z.string()).optional(),
+    runner: z
+        .object({
+        id: z.coerce.string().optional(),
+        description: z.string().nullable().optional(),
+        active: z.boolean().optional(),
+        is_shared: z.boolean().optional(),
+        runner_type: z.string().optional(),
+    })
+        .nullable()
+        .optional(),
 });
 // Pipeline trigger job (bridge) schema
 export const GitLabPipelineTriggerJobSchema = z.object({
@@ -247,6 +262,126 @@ export const ListPipelineTriggerJobsSchema = z
         .describe("The scope of trigger jobs to show"),
 })
     .merge(PaginationOptionsSchema);
+// Deployment related schemas
+export const GitLabDeploymentSchema = z.object({
+    id: z.coerce.string(),
+    iid: z.coerce.string().optional(),
+    status: z.string(),
+    ref: z.string().optional(),
+    sha: z.string(),
+    created_at: z.string(),
+    updated_at: z.string().optional(),
+    finished_at: z.string().nullable().optional(),
+    environment: z
+        .object({
+        id: z.coerce.string().optional(),
+        name: z.string(),
+        slug: z.string().optional(),
+        external_url: z.string().nullable().optional(),
+        state: z.string().optional(),
+        tier: z.string().optional(),
+    })
+        .optional(),
+    deployable: z
+        .object({
+        id: z.coerce.string().optional(),
+        name: z.string().optional(),
+        status: z.string().optional(),
+        stage: z.string().optional(),
+        web_url: z.string().optional(),
+        pipeline: z
+            .object({
+            id: z.coerce.string().optional(),
+            status: z.string().optional(),
+            ref: z.string().optional(),
+            sha: z.string().optional(),
+            web_url: z.string().optional(),
+        })
+            .optional(),
+    })
+        .nullable()
+        .optional(),
+    user: z
+        .object({
+        id: z.coerce.string().optional(),
+        username: z.string().optional(),
+        name: z.string().optional(),
+        avatar_url: z.string().nullable().optional(),
+    })
+        .optional(),
+    web_url: z.string().optional(),
+});
+export const ListDeploymentsSchema = z
+    .object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    environment: z.string().optional().describe("Filter by environment name"),
+    ref: z.string().optional().describe("Filter by ref"),
+    sha: z
+        .string()
+        .optional()
+        .describe("Filter by commit SHA (if supported by your GitLab version)"),
+    status: z.string().optional().describe("Filter by deployment status"),
+    updated_after: z
+        .string()
+        .optional()
+        .describe("Return deployments updated after the specified date"),
+    updated_before: z
+        .string()
+        .optional()
+        .describe("Return deployments updated before the specified date"),
+    order_by: z
+        .enum(["id", "iid", "created_at", "updated_at", "ref", "status", "environment"])
+        .optional()
+        .describe("Order deployments by"),
+    sort: z.enum(["asc", "desc"]).optional().describe("Sort deployments"),
+})
+    .merge(PaginationOptionsSchema);
+export const GetDeploymentSchema = z.object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    deployment_id: z.coerce.string().describe("The ID of the deployment"),
+});
+// Environment related schemas
+const GitLabEnvironmentLastDeploymentSchema = z.object({
+    id: z.coerce.string().optional(),
+    iid: z.coerce.string().optional(),
+    status: z.string().optional(),
+    ref: z.string().optional(),
+    sha: z.string().optional(),
+    created_at: z.string().optional(),
+    updated_at: z.string().optional(),
+    web_url: z.string().optional(),
+});
+export const GitLabEnvironmentSchema = z.object({
+    id: z.coerce.string(),
+    name: z.string(),
+    slug: z.string().optional(),
+    external_url: z.string().nullable().optional(),
+    state: z.string().optional(),
+    tier: z.string().optional(),
+    environment_type: z.string().optional(),
+    created_at: z.string().optional(),
+    updated_at: z.string().optional(),
+    auto_stop_at: z.string().nullable().optional(),
+    enable_advanced_logs_querying: z.boolean().optional(),
+    logs_api_path: z.string().optional(),
+    web_url: z.string().optional(),
+    last_deployment: GitLabEnvironmentLastDeploymentSchema.nullable().optional(),
+});
+export const ListEnvironmentsSchema = z
+    .object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    name: z.string().optional().describe("Return environments with this exact name"),
+    search: z.string().optional().describe("Search environments by name"),
+    states: z
+        .enum(["available", "stopped"])
+        .optional()
+        .describe("Filter environments by state"),
+})
+    .merge(PaginationOptionsSchema);
+export const GetEnvironmentSchema = z.object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    environment_id: z.coerce.string().describe("The ID of the environment"),
+});
 // Schema for creating a new pipeline
 export const CreatePipelineSchema = z.object({
     project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
@@ -258,6 +393,10 @@ export const CreatePipelineSchema = z.object({
     }))
         .optional()
         .describe("An array of variables to use for the pipeline"),
+    inputs: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe("Input parameters for the pipeline (key-value pairs for spec:inputs)"),
 });
 // Schema for retrying a pipeline
 export const RetryPipelineSchema = z.object({
@@ -436,17 +575,17 @@ export const GitLabRepositorySchema = z.object({
 export const GitLabProjectSchema = GitLabRepositorySchema;
 // File content schemas
 export const GitLabFileContentSchema = z.object({
-    file_name: z.string(), // Changed from name to match GitLab API
-    file_path: z.string(), // Changed from path to match GitLab API
-    size: z.number(),
+    file_name: z.string().optional(),
+    file_path: z.string(),
+    size: z.coerce.number().optional(),
     encoding: z.string(),
     content: z.string(),
-    content_sha256: z.string(), // Changed from sha to match GitLab API
-    ref: z.string(), // Added as GitLab requires branch reference
-    blob_id: z.string(), // Added to match GitLab API
-    commit_id: z.string(), // ID of the current file version
-    last_commit_id: z.string(), // Added to match GitLab API
-    execute_filemode: z.boolean().optional(), // Added to match GitLab API
+    content_sha256: z.string().optional(),
+    ref: z.string().optional(),
+    blob_id: z.string().optional(),
+    commit_id: z.string().optional(),
+    last_commit_id: z.string().optional(),
+    execute_filemode: z.boolean().optional(),
 });
 export const GitLabDirectoryContentSchema = z.object({
     name: z.string(),
@@ -713,6 +852,15 @@ export const GitLabMergeRequestSchema = z.object({
     allow_collaboration: z.boolean().optional(),
     allow_maintainer_to_push: z.boolean().optional(),
     changes_count: z.string().nullable().optional(),
+    diverged_commits_count: z.coerce
+        .number()
+        .nullable()
+        .optional()
+        .describe("Number of commits the source branch is behind the target branch"),
+    rebase_in_progress: z
+        .boolean()
+        .optional()
+        .describe("Whether rebase is currently in progress for this merge request"),
     merge_when_pipeline_succeeds: z.boolean().optional(),
     squash: z.boolean().optional(),
     labels: z.array(z.string()).optional(),
@@ -953,10 +1101,43 @@ export const CreateRepositorySchema = z.object({
         .describe("Repository visibility level"),
     initialize_with_readme: z.boolean().optional().describe("Initialize with README.md"),
 });
-export const GetFileContentsSchema = ProjectParamsSchema.extend({
-    file_path: z.string().describe("Path to the file or directory"),
+export const GetFileContentsSchema = z
+    .object({
+    project_id: z.coerce
+        .string()
+        .optional()
+        .describe("Project ID or URL-encoded path (optional; falls back to env)"),
+    file_path: z
+        .string()
+        .optional()
+        .describe("Path to the file or directory. Takes precedence over 'path' when both are provided"),
+    path: z.string().optional().describe("Alias of file_path"),
     ref: z.string().optional().describe("Branch/tag/commit to get contents from"),
-});
+})
+    .superRefine((data, ctx) => {
+    const fp = data.file_path?.trim();
+    const p = data.path?.trim();
+    if (!fp && !p) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Either 'file_path' or 'path' must be provided",
+            path: ["file_path"],
+        });
+    }
+    const finalPath = fp && fp.length > 0 ? fp : p ?? "";
+    if (finalPath.trim().length === 0) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "file_path cannot be empty or whitespace",
+            path: ["file_path"],
+        });
+    }
+})
+    .transform(data => ({
+    project_id: (data.project_id ?? "").trim() || undefined,
+    file_path: ((data.file_path ?? "").trim() || (data.path ?? "").trim()).trim(),
+    ref: (data.ref ?? "").trim() || undefined,
+}));
 export const PushFilesSchema = ProjectParamsSchema.extend({
     branch: z.string().describe("Branch to push to"),
     files: z
@@ -1129,9 +1310,25 @@ export const GitLabApprovalRuleSchema = z.object({
         .optional(),
     approved: z.boolean().optional(),
 });
+export const GitLabMergeRequestApprovalsResponseSchema = z.object({
+    approved: z.boolean().optional(),
+    user_has_approved: z.boolean().optional(),
+    user_can_approve: z.boolean().optional(),
+    approved_by: z
+        .array(z.object({
+        user: GitLabApprovalUserSchema,
+    }))
+        .optional(),
+});
 export const GitLabMergeRequestApprovalStateSchema = z.object({
     approval_rules_overwritten: z.boolean().optional(),
     rules: z.array(GitLabApprovalRuleSchema).optional(),
+    approved: z.boolean().optional(),
+    user_has_approved: z.boolean().optional(),
+    user_can_approve: z.boolean().optional(),
+    approved_by: z.array(GitLabApprovalUserSchema).optional(),
+    approved_by_usernames: z.array(z.string()).optional(),
+    source_endpoint: z.enum(["approval_state", "approvals"]).optional(),
 });
 export const GetMergeRequestApprovalStateSchema = ProjectParamsSchema.extend({
     merge_request_iid: z.coerce.string().describe("The IID of the merge request"),
@@ -2210,6 +2407,41 @@ export const CreateReleaseEvidenceSchema = z.object({
     project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
     tag_name: z.string().describe("The Git tag the release is associated with"),
 });
+// Job Artifacts schemas
+export const ListJobArtifactsSchema = z.object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    job_id: z.coerce.string().describe("The ID of the job"),
+    path: z
+        .string()
+        .optional()
+        .describe("Directory path within the artifacts archive (defaults to root)"),
+    recursive: z
+        .boolean()
+        .optional()
+        .describe("Whether to list artifacts recursively"),
+});
+export const GitLabArtifactEntrySchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    type: z.enum(["file", "directory"]),
+    size: z.number().optional(),
+    mode: z.string().optional(),
+});
+export const DownloadJobArtifactsSchema = z.object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    job_id: z.coerce.string().describe("The ID of the job"),
+    local_path: z
+        .string()
+        .optional()
+        .describe("Local directory to save the artifact archive (defaults to current directory)"),
+});
+export const GetJobArtifactFileSchema = z.object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    job_id: z.coerce.string().describe("The ID of the job"),
+    artifact_path: z
+        .string()
+        .describe("Path to the file within the artifacts archive"),
+});
 export const DownloadReleaseAssetSchema = z.object({
     project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
     tag_name: z.string().describe("The Git tag the release is associated with"),

package/build/test/schema-tests.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env ts-node
+import { GetFileContentsSchema, GitLabFileContentSchema, CreatePipelineSchema } from '../schemas.js';
+function runGetFileContentsSchemaTests() {
+    console.log('🧪 Testing GetFileContentsSchema...');
+    const cases = [
+        {
+            name: 'schema:get_file_contents:path-only',
+            input: { path: 'package.json' },
+            expected: { file_path: 'package.json', project_id: undefined, ref: undefined }
+        },
+        {
+            name: 'schema:get_file_contents:file-path-precedence',
+            input: { file_path: ' README.md ', path: 'package.json' },
+            expected: { file_path: 'README.md', project_id: undefined, ref: undefined }
+        },
+        {
+            name: 'schema:get_file_contents:project-id-trim',
+            input: { project_id: ' 123 ', file_path: 'a.txt' },
+            expected: { project_id: '123', file_path: 'a.txt', ref: undefined }
+        },
+        {
+            name: 'schema:get_file_contents:ref-trim-to-undefined',
+            input: { file_path: 'a.txt', ref: '   ' },
+            expected: { file_path: 'a.txt', project_id: undefined, ref: undefined }
+        },
+        {
+            name: 'schema:get_file_contents:file-path-empty-fallback-to-path',
+            input: { file_path: '   ', path: ' src/index.ts ' },
+            expected: { file_path: 'src/index.ts', project_id: undefined, ref: undefined }
+        },
+        {
+            name: 'schema:get_file_contents:project-id-omitted-remains-undefined',
+            input: { file_path: 'README.md' },
+            expected: { file_path: 'README.md', project_id: undefined, ref: undefined }
+        },
+        {
+            name: 'schema:get_file_contents:reject-empty-path',
+            input: { path: '   ' },
+            shouldFail: true
+        },
+        {
+            name: 'schema:get_file_contents:reject-both-empty-after-trim',
+            input: { file_path: '   ', path: '   ' },
+            shouldFail: true
+        }
+    ];
+    let passed = 0;
+    let failed = 0;
+    cases.forEach(testCase => {
+        const result = {
+            name: testCase.name,
+            status: 'failed'
+        };
+        const parsed = GetFileContentsSchema.safeParse(testCase.input);
+        if (testCase.shouldFail) {
+            if (parsed.success) {
+                result.error = 'Expected schema validation to fail';
+            }
+            else {
+                result.status = 'passed';
+            }
+        }
+        else if (parsed.success) {
+            const { project_id, file_path, ref } = parsed.data;
+            const expected = testCase.expected || {};
+            const matches = project_id === expected.project_id && file_path === expected.file_path && ref === expected.ref;
+            if (matches) {
+                result.status = 'passed';
+            }
+            else {
+                result.error = `Unexpected parsed result: ${JSON.stringify(parsed.data)}`;
+            }
+        }
+        else {
+            result.error = parsed.error?.message || 'Schema validation failed';
+        }
+        if (result.status === 'passed') {
+            passed++;
+            console.log(`✅ ${result.name}`);
+        }
+        else {
+            failed++;
+            console.log(`❌ ${result.name}: ${result.error}`);
+        }
+    });
+    console.log(`\nResults: ${passed} passed, ${failed} failed`);
+    return { passed, failed };
+}
+function runGitLabFileContentSchemaTests() {
+    console.log('\n🧪 Testing GitLabFileContentSchema...');
+    const cases = [
+        {
+            name: 'schema:gitlab_file_content:minimal-required-fields',
+            input: {
+                file_path: 'README.md',
+                encoding: 'base64',
+                content: 'IyBSRUFETUU='
+            },
+            expected: {
+                file_path: 'README.md',
+                encoding: 'base64',
+                content: 'IyBSRUFETUU='
+            }
+        },
+        {
+            name: 'schema:gitlab_file_content:optional-size-coerces-to-number',
+            input: {
+                file_name: 'README.md',
+                file_path: 'README.md',
+                size: '42',
+                encoding: 'base64',
+                content: 'IyBSRUFETUU=',
+                ref: 'main'
+            },
+            expected: {
+                file_name: 'README.md',
+                file_path: 'README.md',
+                size: 42,
+                encoding: 'base64',
+                content: 'IyBSRUFETUU=',
+                ref: 'main'
+            }
+        },
+        {
+            name: 'schema:gitlab_file_content:reject-missing-content',
+            input: {
+                file_path: 'README.md',
+                encoding: 'base64'
+            },
+            shouldFail: true
+        },
+        {
+            name: 'schema:gitlab_file_content:reject-missing-encoding',
+            input: {
+                file_path: 'README.md',
+                content: 'IyBSRUFETUU='
+            },
+            shouldFail: true
+        },
+        {
+            name: 'schema:gitlab_file_content:reject-missing-file-path',
+            input: {
+                encoding: 'base64',
+                content: 'IyBSRUFETUU='
+            },
+            shouldFail: true
+        }
+    ];
+    let passed = 0;
+    let failed = 0;
+    cases.forEach(testCase => {
+        const result = {
+            name: testCase.name,
+            status: 'failed'
+        };
+        const parsed = GitLabFileContentSchema.safeParse(testCase.input);
+        if (testCase.shouldFail) {
+            if (parsed.success) {
+                result.error = 'Expected schema validation to fail';
+            }
+            else {
+                result.status = 'passed';
+            }
+        }
+        else if (parsed.success) {
+            const expected = testCase.expected || {};
+            const matches = Object.entries(expected).every(([key, value]) => {
+                return parsed.data[key] === value;
+            });
+            if (matches) {
+                result.status = 'passed';
+            }
+            else {
+                result.error = `Unexpected parsed result: ${JSON.stringify(parsed.data)}`;
+            }
+        }
+        else {
+            result.error = parsed.error?.message || 'Schema validation failed';
+        }
+        if (result.status === 'passed') {
+            passed++;
+            console.log(`✅ ${result.name}`);
+        }
+        else {
+            failed++;
+            console.log(`❌ ${result.name}: ${result.error}`);
+        }
+    });
+    console.log(`\nResults: ${passed} passed, ${failed} failed`);
+    return { passed, failed };
+}
+function runCreatePipelineSchemaTests() {
+    console.log('\n🧪 Testing CreatePipelineSchema...');
+    const cases = [
+        {
+            name: 'schema:create_pipeline:minimal-required-fields',
+            input: { project_id: 'my/project', ref: 'main' },
+            expected: { project_id: 'my/project', ref: 'main' }
+        },
+        {
+            name: 'schema:create_pipeline:with-variables-only',
+            input: {
+                project_id: 'my/project',
+                ref: 'main',
+                variables: [{ key: 'ENV', value: 'production' }]
+            },
+            expected: {
+                project_id: 'my/project',
+                ref: 'main',
+                variables: [{ key: 'ENV', value: 'production' }]
+            }
+        },
+        {
+            name: 'schema:create_pipeline:with-inputs-only',
+            input: {
+                project_id: 'my/project',
+                ref: 'main',
+                inputs: { deploy_target: 'staging', version: '1.0.0' }
+            },
+            expected: {
+                project_id: 'my/project',
+                ref: 'main',
+                inputs: { deploy_target: 'staging', version: '1.0.0' }
+            }
+        },
+        {
+            name: 'schema:create_pipeline:with-variables-and-inputs',
+            input: {
+                project_id: 'my/project',
+                ref: 'develop',
+                variables: [{ key: 'CI', value: 'true' }],
+                inputs: { env: 'test' }
+            },
+            expected: {
+                project_id: 'my/project',
+                ref: 'develop',
+                variables: [{ key: 'CI', value: 'true' }],
+                inputs: { env: 'test' }
+            }
+        },
+        {
+            name: 'schema:create_pipeline:project-id-coercion',
+            input: { project_id: 123, ref: 'main' },
+            expected: { project_id: '123', ref: 'main' }
+        },
+        {
+            name: 'schema:create_pipeline:reject-missing-ref',
+            input: { project_id: 'my/project' },
+            shouldFail: true
+        },
+        {
+            name: 'schema:create_pipeline:reject-invalid-inputs-type',
+            input: { project_id: 'my/project', ref: 'main', inputs: 'not-an-object' },
+            shouldFail: true
+        }
+    ];
+    let passed = 0;
+    let failed = 0;
+    cases.forEach(testCase => {
+        const result = {
+            name: testCase.name,
+            status: 'failed'
+        };
+        const parsed = CreatePipelineSchema.safeParse(testCase.input);
+        if (testCase.shouldFail) {
+            if (parsed.success) {
+                result.error = 'Expected schema validation to fail';
+            }
+            else {
+                result.status = 'passed';
+            }
+        }
+        else if (parsed.success) {
+            const expected = testCase.expected || {};
+            const matches = Object.entries(expected).every(([key, value]) => {
+                const actual = parsed.data[key];
+                return JSON.stringify(actual) === JSON.stringify(value);
+            });
+            if (matches) {
+                result.status = 'passed';
+            }
+            else {
+                result.error = `Unexpected parsed result: ${JSON.stringify(parsed.data)}`;
+            }
+        }
+        else {
+            result.error = parsed.error?.message || 'Schema validation failed';
+        }
+        if (result.status === 'passed') {
+            passed++;
+            console.log(`✅ ${result.name}`);
+        }
+        else {
+            failed++;
+            console.log(`❌ ${result.name}: ${result.error}`);
+        }
+    });
+    console.log(`\nResults: ${passed} passed, ${failed} failed`);
+    return { passed, failed };
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const getFileContentsResult = runGetFileContentsSchemaTests();
+    const fileContentResult = runGitLabFileContentSchemaTests();
+    const createPipelineResult = runCreatePipelineSchemaTests();
+    const totalPassed = getFileContentsResult.passed + fileContentResult.passed + createPipelineResult.passed;
+    const totalFailed = getFileContentsResult.failed + fileContentResult.failed + createPipelineResult.failed;
+    console.log(`\nTotal Results: ${totalPassed} passed, ${totalFailed} failed`);
+    if (totalFailed > 0) {
+        process.exit(1);
+    }
+}