@zereight/mcp-gitlab 2.1.57 → 2.1.59

package/build/schemas.js

@@ -119,6 +119,8 @@ export const GitLabPipelineJobSchema = z.object({
     web_url: z.string().optional(),
     allow_failure: z.coerce.boolean().optional(),
     retried: z.coerce.boolean().optional(),
+    when: z.string().optional(),
+    needs: z.array(z.unknown()).optional(),
     tag_list: z.array(z.string()).optional(),
     runner: z
         .object({
@@ -257,6 +259,38 @@ export const GetPipelineSchema = z.object({
     project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
     pipeline_id: z.coerce.string().describe("The ID of the pipeline"),
 });
+export const GetPipelineVariablesSchema = GetPipelineSchema.merge(PaginationOptionsSchema);
+export const UpdatePipelineMetadataSchema = GetPipelineSchema.extend({
+    name: z.string().min(1).describe("New pipeline name"),
+});
+export const DeletePipelineSchema = GetPipelineSchema;
+export const PipelineReportSchema = GetPipelineSchema.merge(PaginationOptionsSchema);
+export const PlayPipelineJobsSchema = z.object({
+    project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
+    job_ids: z
+        .array(z.coerce.string())
+        .min(1)
+        .refine((jobIds) => new Set(jobIds).size === jobIds.length, "job_ids must not contain duplicates")
+        .describe("Job IDs to play, in dependency order"),
+    job_variables_attributes: z
+        .array(z.object({ key: z.string(), value: z.string() }))
+        .optional()
+        .describe("Custom job variables to use when running each job"),
+    timeout_seconds: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(600)
+        .optional()
+        .describe("Maximum seconds to wait for each job to reach a terminal status (applied per job; total duration scales with the batch size)"),
+    poll_interval_seconds: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(30)
+        .optional()
+        .describe("Seconds between status polls while waiting for each job"),
+});
 export const GitLabMergeRequestPipelineSchema = z.object({
     id: z.coerce.string(),
     sha: z.string(),
@@ -380,6 +414,28 @@ export const GetCiCatalogResourceSchema = z.union([
     message: "Provide exactly one of id or full_path",
 });
 // Deployment related schemas
+const GitLabDeploymentApprovalUserSchema = z.object({
+    id: z.coerce.string().optional(),
+    username: z.string().optional(),
+    name: z.string().optional(),
+    state: z.string().optional(),
+    avatar_url: z.string().nullable().optional(),
+    web_url: z.string().optional(),
+});
+const GitLabDeploymentApprovalSchema = z.object({
+    user: GitLabDeploymentApprovalUserSchema.optional(),
+    status: z.string().optional(),
+    created_at: z.string().optional(),
+    comment: z.string().nullable().optional(),
+});
+const GitLabDeploymentApprovalRuleSchema = z.object({
+    user_id: z.coerce.string().nullable().optional(),
+    group_id: z.coerce.string().nullable().optional(),
+    access_level: z.coerce.number().nullable().optional(),
+    access_level_description: z.string().nullable().optional(),
+    required_approvals: z.coerce.number().optional(),
+    deployment_approvals: z.array(GitLabDeploymentApprovalSchema).optional(),
+});
 export const GitLabDeploymentSchema = z.object({
     id: z.coerce.string(),
     iid: z.coerce.string().optional(),
@@ -427,6 +483,11 @@ export const GitLabDeploymentSchema = z.object({
     })
         .optional(),
     web_url: z.string().optional(),
+    pending_approval_count: z.coerce.number().optional(),
+    approvals: z.array(GitLabDeploymentApprovalSchema).optional(),
+    approval_summary: z
+        .object({ rules: z.array(GitLabDeploymentApprovalRuleSchema).optional() })
+        .optional(),
 });
 export const ListDeploymentsSchema = z
     .object({
@@ -457,6 +518,19 @@ 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"),
 });
+export const CreateDeploymentSchema = z.object({
+    project_id: z.coerce.string(), environment: z.string(), sha: z.string(), ref: z.string(),
+    tag: z.boolean(), status: z.enum(["running", "success", "failed", "canceled"]),
+});
+export const UpdateDeploymentSchema = GetDeploymentSchema.extend({
+    status: z.enum(["running", "success", "failed", "canceled"]),
+});
+export const DeploymentApprovalSchema = GetDeploymentSchema.extend({
+    status: z.enum(["approved", "rejected"]),
+    comment: z.string().optional(),
+    represented_as: z.string().optional(),
+});
+export const ListDeploymentMergeRequestsSchema = GetDeploymentSchema.merge(PaginationOptionsSchema);
 // Environment related schemas
 const GitLabEnvironmentLastDeploymentSchema = z.object({
     id: z.coerce.string().optional(),
@@ -496,6 +570,31 @@ 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"),
 });
+export const UpdateEnvironmentSchema = GetEnvironmentSchema.extend({
+    external_url: z.string().url().nullable().optional(),
+    tier: z.enum(["production", "staging", "testing", "development", "other"]).optional(),
+    auto_stop_setting: z.enum(["always", "with_action"]).optional(),
+});
+export const StopEnvironmentSchema = GetEnvironmentSchema.extend({ force: coerceBooleanString.optional() });
+export const StopStaleEnvironmentsSchema = z.object({ project_id: z.coerce.string(), before: z.string() });
+export const DeleteReviewAppEnvironmentsSchema = z.object({
+    project_id: z.coerce.string(), before: z.string().optional(), limit: z.coerce.number().optional(),
+    dry_run: coerceBooleanString
+        .optional()
+        .describe("Preview the cleanup when true (default); set to false to schedule deletion one week later"),
+});
+export const PipelineTriggerIdSchema = z.object({ project_id: z.coerce.string(), trigger_id: z.coerce.string() });
+export const ListPipelineTriggersSchema = z.object({ project_id: z.coerce.string() });
+export const CreatePipelineTriggerSchema = z.object({ project_id: z.coerce.string(), description: z.string() });
+export const UpdatePipelineTriggerSchema = PipelineTriggerIdSchema.extend({ description: z.string() });
+export const TriggerPipelineSchema = z.object({
+    project_id: z.coerce.string(), token: z.string(), ref: z.string(),
+    variables: z.record(z.string()).optional(),
+    inputs: z
+        .record(z.unknown())
+        .optional()
+        .describe("Structured pipeline inputs; supported from GitLab 17.10 behind a feature flag and generally available from GitLab 18.1. Omit on older GitLab versions."),
+});
 // Schema for creating a new pipeline
 export const CreatePipelineSchema = z.object({
     project_id: z.coerce.string().describe("Project ID or URL-encoded path"),
@@ -771,15 +870,51 @@ export const PlayPipelineJobSchema = z.object({
     }))
         .optional()
         .describe("Custom job variables to use when running the job"),
+    job_inputs: z.record(z.unknown()).optional().describe("Typed job input values"),
 });
 // Schema for retrying a job
-export const RetryPipelineJobSchema = PipelineJobControlSchema;
+export const RetryPipelineJobSchema = PipelineJobControlSchema.extend({
+    job_inputs: z.record(z.unknown()).optional().describe("Typed job input values"),
+});
 // Schema for canceling a job
 export const CancelPipelineJobSchema = 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"),
     force: z.coerce.boolean().optional().describe("Force cancellation of the job"),
 });
+export const ErasePipelineJobSchema = PipelineJobControlSchema;
+export const WaitForPipelineSchema = GetPipelineSchema.extend({
+    timeout_seconds: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(600)
+        .optional()
+        .describe("Maximum seconds to wait for this pipeline to reach a terminal status"),
+    poll_interval_seconds: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(30)
+        .optional()
+        .describe("Seconds between status polls while waiting for this pipeline"),
+});
+export const WaitForPipelineJobSchema = PipelineJobControlSchema.extend({
+    timeout_seconds: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(600)
+        .optional()
+        .describe("Maximum seconds to wait for this job to reach a terminal status"),
+    poll_interval_seconds: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(30)
+        .optional()
+        .describe("Seconds between status polls while waiting for this job"),
+});
 // User schemas
 export const GitLabUserSchema = z.object({
     username: z.string().optional(), // Changed from login to match GitLab API
@@ -1229,6 +1364,7 @@ export const GitLabCreateUpdateFileResponseSchema = z.object({
 export const GitLabSearchResponseSchema = z.object({
     count: z.coerce.number().optional(),
     total_pages: z.coerce.number().optional(),
+    next_page: z.coerce.number().optional(),
     current_page: z.coerce.number().optional(),
     items: z.array(GitLabRepositorySchema),
 });
@@ -2359,8 +2495,7 @@ export const ListGroupMergeRequestsSchema = ListMergeRequestsSchema.omit({
     project_id: true,
 }).extend({
     group_id: z.coerce.string().describe("Group ID or URL-encoded path"),
-    non_archived: z.coerce
-        .boolean()
+    non_archived: coerceBooleanString
         .optional()
         .describe("Return merge requests from non-archived projects only. Defaults to true."),
     source_project_id: z.coerce

package/build/scripts/check-skill-sync.js

@@ -22,6 +22,11 @@ const REFERENCE_FIELD_ALLOWLIST = new Set([
     "new_file",
     "new_path",
     "old_path",
+    "name",
+    "page",
+    "per_page",
+    "pipeline_id",
+    "job_inputs",
     "project_id",
     "renamed_file",
 ]);

package/build/stateless/session-id.js

@@ -35,6 +35,9 @@ export function mintSessionId(material, input) {
         h: input.header,
         t: input.token,
         u: input.apiUrl,
+        ...(input.allowedProjectIds && input.allowedProjectIds.length > 0
+            ? { p: input.allowedProjectIds }
+            : {}),
     };
     return seal(material, STATELESS_PURPOSES.SESSION_ID, payload);
 }
@@ -51,7 +54,9 @@ export function openSessionId(material, sid, ttlSeconds, now) {
             payload.h !== "JOB-TOKEN") ||
             typeof payload.t !== "string" ||
             payload.t.length === 0 ||
-            typeof payload.u !== "string") {
+            typeof payload.u !== "string" ||
+            (payload.p !== undefined &&
+                (!Array.isArray(payload.p) || payload.p.some(id => typeof id !== "string")))) {
             return null;
         }
         return payload;

package/build/test/stateless/session-id.test.js

@@ -19,6 +19,32 @@ function load(current, previous) {
     return m;
 }
 describe("mintSessionId / openSessionId", () => {
+    test("seals and restores a narrowed project scope", () => {
+        const s = secret();
+        const a = load(s);
+        const b = load(s);
+        const sid = mintSessionId(a, {
+            header: "Private-Token",
+            token: "glpat-ABCDEFG123456789-abcdef",
+            apiUrl: "https://gitlab.example.com/api/v4",
+            allowedProjectIds: ["42", "org/theorg"],
+        });
+        const opened = openSessionId(b, sid, 3600);
+        assert.ok(opened);
+        assert.deepEqual(opened.p, ["42", "org/theorg"]);
+    });
+    test("omits the scope field when no scope was narrowed", () => {
+        const s = secret();
+        const m = load(s);
+        const sid = mintSessionId(m, {
+            header: "Private-Token",
+            token: "glpat-ABCDEFG123456789-abcdef",
+            apiUrl: "https://gitlab.example.com/api/v4",
+        });
+        const opened = openSessionId(m, sid, 3600);
+        assert.ok(opened);
+        assert.equal(opened.p, undefined);
+    });
     test("roundtrips across pods", () => {
         const s = secret();
         const a = load(s);

package/build/test/test-deployment-tools.js

@@ -62,7 +62,7 @@ async function callTool(toolName, args, env) {
             env: {
                 ...process.env,
                 ...env,
-                GITLAB_READ_ONLY_MODE: "true",
+                GITLAB_READ_ONLY_MODE: env.GITLAB_READ_ONLY_MODE ?? "true",
                 USE_PIPELINE: "true",
             },
         });
@@ -238,8 +238,62 @@ describe("deployment and environment tools", () => {
                     stage: "deploy",
                     pipeline: { id: "190349", status: "success", ref: "master", sha: "abc123" },
                 },
+                pending_approval_count: 1,
+                approvals: [
+                    {
+                        user: {
+                            id: "100",
+                            username: "security-user-1",
+                            name: "Security User",
+                            state: "active",
+                            web_url: "https://gitlab.example.com/security-user-1",
+                        },
+                        status: "approved",
+                        created_at: "2026-02-20T16:33:00.000Z",
+                        comment: "Looks good to me",
+                    },
+                ],
+                approval_summary: {
+                    rules: [
+                        {
+                            group_id: "134",
+                            access_level: null,
+                            access_level_description: "security-group",
+                            required_approvals: 2,
+                            deployment_approvals: [
+                                {
+                                    user: {
+                                        id: "100",
+                                        username: "security-user-1",
+                                        name: "Security User",
+                                        state: "active",
+                                        web_url: "https://gitlab.example.com/security-user-1",
+                                    },
+                                    status: "approved",
+                                    created_at: "2026-02-20T16:33:00.000Z",
+                                    comment: "Looks good to me",
+                                },
+                            ],
+                        },
+                    ],
+                },
             });
         });
+        mockGitLab.addMockHandler("post", `/projects/${TEST_PROJECT_ID}/deployments`, (_req, res) => {
+            res.status(201).json({ id: "created-deployment", status: "created" });
+        });
+        mockGitLab.addMockHandler("put", `/projects/${TEST_PROJECT_ID}/deployments/${TEST_DEPLOYMENT_ID}`, (_req, res) => {
+            res.json({ id: TEST_DEPLOYMENT_ID, status: "success" });
+        });
+        mockGitLab.addMockHandler("delete", `/projects/${TEST_PROJECT_ID}/deployments/${TEST_DEPLOYMENT_ID}`, (_req, res) => {
+            res.status(204).send();
+        });
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/deployments/${TEST_DEPLOYMENT_ID}/merge_requests`, (_req, res) => {
+            res.json([{ iid: TEST_MERGE_REQUEST_IID, title: "Shipped change" }]);
+        });
+        mockGitLab.addMockHandler("post", `/projects/${TEST_PROJECT_ID}/deployments/${TEST_DEPLOYMENT_ID}/approval`, (_req, res) => {
+            res.json({ id: TEST_DEPLOYMENT_ID, status: "approved" });
+        });
         mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/environments`, (req, res) => {
             res.json([
                 {
@@ -298,6 +352,35 @@ describe("deployment and environment tools", () => {
         assert.strictEqual(result.id, TEST_DEPLOYMENT_ID);
         assert.strictEqual(result.ref, "master");
         assert.strictEqual(result.status, "success");
+        assert.strictEqual(result.pending_approval_count, 1);
+        assert.strictEqual(result.approvals[0].status, "approved");
+        assert.strictEqual(result.approvals[0].user.username, "security-user-1");
+        assert.strictEqual(result.approval_summary.rules[0].group_id, "134");
+        assert.strictEqual(result.approval_summary.rules[0].deployment_approvals[0].comment, "Looks good to me");
+    });
+    test("supports deployment lifecycle and approval operations", async () => {
+        const env = {
+            GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+            GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+            GITLAB_READ_ONLY_MODE: "false",
+        };
+        const created = await callTool("create_deployment", {
+            project_id: TEST_PROJECT_ID,
+            environment: "stage",
+            sha: "abc123",
+            ref: "master",
+            tag: false,
+            status: "running",
+        }, env);
+        assert.strictEqual(created.id, "created-deployment");
+        const updated = await callTool("update_deployment", { project_id: TEST_PROJECT_ID, deployment_id: TEST_DEPLOYMENT_ID, status: "success" }, env);
+        assert.strictEqual(updated.status, "success");
+        const mergeRequests = await callTool("list_deployment_merge_requests", { project_id: TEST_PROJECT_ID, deployment_id: TEST_DEPLOYMENT_ID }, env);
+        assert.strictEqual(mergeRequests[0].iid, TEST_MERGE_REQUEST_IID);
+        const approval = await callTool("approve_deployment", { project_id: TEST_PROJECT_ID, deployment_id: TEST_DEPLOYMENT_ID, status: "approved" }, env);
+        assert.strictEqual(approval.status, "approved");
+        const deleted = await callTool("delete_deployment", { project_id: TEST_PROJECT_ID, deployment_id: TEST_DEPLOYMENT_ID }, env);
+        assert.deepStrictEqual(deleted, { success: true });
     });
     test("list_environments returns environment list", async () => {
         const result = await callTool("list_environments", { project_id: TEST_PROJECT_ID }, {