gd-gitlab-mcp 0.1.0

package/dist/server.js

@@ -0,0 +1,923 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const node_http_1 = __importDefault(require("node:http"));
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const gitlab_service_1 = require("./services/gitlab.service");
+const review_service_1 = require("./services/review.service");
+const utils_1 = require("./utils");
+const config_1 = __importDefault(require("./config"));
+// ─── MCP server factory ───────────────────────────────────────────────────────
+function buildMcpServer(gitlab) {
+    const reviewer = new review_service_1.ReviewService(gitlab);
+    const server = new index_js_1.Server({ name: 'gitlab-mcp-server', version: '0.1.0' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: 'search_projects',
+                description: 'Search GitLab projects by name/path and return candidate projects with IDs',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Project keyword, e.g. greatday-server' },
+                        perPage: { type: 'number', description: 'Max project results (default 20)' },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'resolve_project',
+                description: 'Resolve project query to the best matching GitLab project (returns project ID)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        queryOrId: {
+                            type: 'string',
+                            description: 'Project ID or name/path keyword, e.g. greatday-server',
+                        },
+                    },
+                    required: ['queryOrId'],
+                },
+            },
+            {
+                name: 'list_user_repositories',
+                description: 'List repositories by access scope for current authenticated user',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        perPage: { type: 'number', description: 'Max results per page (default 50, max 100)' },
+                        page: { type: 'number', description: 'Page number (default 1)' },
+                        scope: {
+                            type: 'string',
+                            enum: ['owned', 'membership', 'all_accessible'],
+                            description: 'Repository scope (default owned)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'list_merge_requests',
+                description: 'List merge requests by projectId or projectQuery with optional filters',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        state: {
+                            type: 'string',
+                            enum: ['opened', 'closed', 'locked', 'merged', 'all'],
+                            description: 'MR state filter (default opened)',
+                        },
+                        sourceBranch: { type: 'string', description: 'Filter by source branch' },
+                        targetBranch: { type: 'string', description: 'Filter by target branch' },
+                        authorUsername: { type: 'string', description: 'Filter by author username' },
+                        reviewerUsername: { type: 'string', description: 'Filter by reviewer username' },
+                        search: { type: 'string', description: 'Search term for MR title/description' },
+                        perPage: { type: 'number', description: 'Max results per page (max 100)' },
+                        page: { type: 'number', description: 'Page number' },
+                    },
+                },
+            },
+            {
+                name: 'get_merge_request_diff',
+                description: 'Get diff changes from a specific GitLab merge request by projectId or projectQuery',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        mergeRequestIid: { type: 'string', description: 'Merge request IID' },
+                    },
+                    required: ['mergeRequestIid'],
+                },
+            },
+            {
+                name: 'get_merge_request',
+                description: 'Get detailed information for a specific merge request, including approvals',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        mergeRequestIid: { type: 'string', description: 'Merge request IID' },
+                    },
+                    required: ['mergeRequestIid'],
+                },
+            },
+            {
+                name: 'merge_readiness_check',
+                description: 'Check whether a specific merge request is ready to merge',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        mergeRequestIid: { type: 'string', description: 'Merge request IID' },
+                    },
+                    required: ['mergeRequestIid'],
+                },
+            },
+            {
+                name: 'run_staging_pipeline',
+                description: 'Run pipeline for specific branch or current branch (from MR/default branch) with STAGING=1..15',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        staging: { type: 'number', description: 'Staging target number (1-15)' },
+                        ref: { type: 'string', description: 'Branch/ref to run pipeline on' },
+                        mergeRequestIid: {
+                            type: 'string',
+                            description: 'Optional MR IID to derive current branch from source branch',
+                        },
+                    },
+                    required: ['staging'],
+                },
+            },
+            {
+                name: 'check_pipeline_status',
+                description: 'Check pipeline status by pipelineId, or latest pipeline from ref/current branch',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        pipelineId: { type: 'string', description: 'Pipeline ID to check directly' },
+                        ref: { type: 'string', description: 'Branch/ref to check latest pipeline from' },
+                        mergeRequestIid: { type: 'string', description: 'Optional MR IID to derive source branch' },
+                    },
+                },
+            },
+            {
+                name: 'list_pipeline_jobs',
+                description: 'List jobs in a pipeline, optionally filtered by status scope',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        pipelineId: { type: 'string', description: 'Pipeline ID (required)' },
+                        scope: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                                enum: ['created', 'pending', 'running', 'failed', 'success', 'canceled', 'skipped', 'manual'],
+                            },
+                            description: 'Filter jobs by status scope (default: all)',
+                        },
+                    },
+                    required: ['pipelineId'],
+                },
+            },
+            {
+                name: 'retry_pipeline_job',
+                description: 'Retry a specific failed or canceled pipeline job by job ID',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        jobId: { type: 'string', description: 'Job ID to retry' },
+                    },
+                    required: ['jobId'],
+                },
+            },
+            {
+                name: 'get_mr_discussions',
+                description: 'Get all discussion threads on a merge request, optionally filtered by resolved status',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        mergeRequestIid: { type: 'string', description: 'Merge request IID' },
+                        unresolvedOnly: {
+                            type: 'boolean',
+                            description: 'Return only unresolved/blocking discussions (default false)',
+                        },
+                    },
+                    required: ['mergeRequestIid'],
+                },
+            },
+            {
+                name: 'merge_request_action',
+                description: 'Unified merge request action: comment, review, approve, merge, or reject',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        mergeRequestIid: { type: 'string', description: 'Merge request IID' },
+                        action: {
+                            type: 'string',
+                            enum: ['comment', 'review', 'approve', 'merge', 'reject'],
+                            description: 'Action to perform on the merge request',
+                        },
+                        body: { type: 'string', description: 'Comment body for comment action' },
+                        postComment: {
+                            type: 'boolean',
+                            description: 'For review action: whether to post generated review comment (default true)',
+                        },
+                        notes: {
+                            type: 'string',
+                            description: 'Optional notes for approve, required notes for reject',
+                        },
+                        sha: { type: 'string', description: 'Optional head SHA for approve safety check' },
+                        revokeOwnApproval: {
+                            type: 'boolean',
+                            description: 'For reject: revoke your own previous approval (default true)',
+                        },
+                        closeMergeRequest: {
+                            type: 'boolean',
+                            description: 'For reject: close merge request (default true)',
+                        },
+                        squash: { type: 'boolean', description: 'For merge: squash commits when merging' },
+                        shouldRemoveSourceBranch: {
+                            type: 'boolean',
+                            description: 'For merge: remove source branch after merge',
+                        },
+                        mergeWhenPipelineSucceeds: {
+                            type: 'boolean',
+                            description: 'For merge: merge automatically when pipeline succeeds',
+                        },
+                        mergeCommitMessage: { type: 'string', description: 'For merge: custom merge commit message' },
+                        squashCommitMessage: { type: 'string', description: 'For merge: custom squash commit message' },
+                    },
+                    required: ['mergeRequestIid', 'action'],
+                },
+            },
+            {
+                name: 'open_merge_request',
+                description: 'Open a new merge request from a specific source branch to a target branch',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        sourceBranch: { type: 'string', description: 'Source branch name' },
+                        targetBranch: { type: 'string', description: 'Target branch name' },
+                        title: { type: 'string', description: 'Merge request title' },
+                        description: { type: 'string', description: 'Merge request description' },
+                        removeSourceBranch: { type: 'boolean', description: 'Remove source branch when merged' },
+                        draft: { type: 'boolean', description: 'Create MR as draft' },
+                        squash: { type: 'boolean', description: 'Enable squash on MR' },
+                    },
+                    required: ['sourceBranch', 'targetBranch', 'title'],
+                },
+            },
+            {
+                name: 'merge_merge_request',
+                description: 'Merge a specific GitLab merge request',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        mergeRequestIid: { type: 'string', description: 'Merge request IID' },
+                        squash: { type: 'boolean', description: 'Squash commits when merging' },
+                        shouldRemoveSourceBranch: { type: 'boolean', description: 'Remove source branch after merge' },
+                        mergeWhenPipelineSucceeds: { type: 'boolean', description: 'Merge when pipeline succeeds' },
+                        sha: { type: 'string', description: 'Expected latest commit SHA' },
+                        mergeCommitMessage: { type: 'string', description: 'Custom merge commit message' },
+                        squashCommitMessage: { type: 'string', description: 'Custom squash commit message' },
+                    },
+                    required: ['mergeRequestIid'],
+                },
+            },
+            {
+                name: 'reject_merge_request',
+                description: 'Reject a specific GitLab merge request by posting notes and closing it',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string', description: 'GitLab project ID' },
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                        mergeRequestIid: { type: 'string', description: 'Merge request IID' },
+                        notes: { type: 'string', description: 'Rejection note/comment (required)' },
+                        revokeOwnApproval: {
+                            type: 'boolean',
+                            description: 'Revoke own approval first if exists (default true)',
+                        },
+                        closeMergeRequest: {
+                            type: 'boolean',
+                            description: 'Close merge request after rejection (default true)',
+                        },
+                    },
+                    required: ['mergeRequestIid', 'notes'],
+                },
+            },
+            {
+                name: 'check_project_merge_requests',
+                description: 'Resolve project by name/path then list opened merge requests in one call',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectQuery: { type: 'string', description: 'Project keyword/path, e.g. greatday-server' },
+                    },
+                    required: ['projectQuery'],
+                },
+            },
+        ],
+    }));
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const name = request.params.name;
+        const args = (request.params.arguments ?? {});
+        const resolveProjectId = async () => {
+            if (args.projectId)
+                return String(args.projectId);
+            if (args.projectQuery) {
+                const project = await gitlab.resolveProject(String(args.projectQuery));
+                if (!project)
+                    throw new Error(`Project not found: ${String(args.projectQuery)}`);
+                return String(project.id);
+            }
+            throw new Error('Either projectId or projectQuery is required');
+        };
+        // Wrap all tool handlers — convert GitLabApiError to user-friendly MCP error
+        try {
+            return await handleTool(name, args, resolveProjectId, gitlab, reviewer);
+        }
+        catch (err) {
+            if (err instanceof gitlab_service_1.GitLabApiError) {
+                const msg = err.detail ? `${err.message} (${err.detail})` : err.message;
+                throw new Error(`[GitLab ${err.status}] ${msg}`);
+            }
+            throw err;
+        }
+    });
+    return server;
+}
+async function handleTool(name, args, resolveProjectId, gitlab, reviewer) {
+    if (name === 'search_projects') {
+        const query = String(args.query ?? '').trim();
+        if (!query)
+            throw new Error('query is required');
+        const perPageRaw = Number(args.perPage ?? 20);
+        const perPage = Number.isFinite(perPageRaw) ? Math.max(1, Math.min(100, perPageRaw)) : 20;
+        const projects = await gitlab.searchProjects(query, perPage);
+        return { content: [{ type: 'text', text: JSON.stringify(projects, null, 2) }] };
+    }
+    if (name === 'resolve_project') {
+        const queryOrId = String(args.queryOrId ?? '').trim();
+        if (!queryOrId)
+            throw new Error('queryOrId is required');
+        const project = await gitlab.resolveProject(queryOrId);
+        return { content: [{ type: 'text', text: JSON.stringify(project, null, 2) }] };
+    }
+    if (name === 'list_user_repositories') {
+        const perPage = Number.isFinite(Number(args.perPage))
+            ? Math.max(1, Math.min(100, Math.floor(Number(args.perPage ?? 50))))
+            : 50;
+        const page = Number.isFinite(Number(args.page))
+            ? Math.max(1, Math.floor(Number(args.page ?? 1)))
+            : 1;
+        const scopeRaw = String(args.scope ?? 'owned').trim();
+        const scope = ['owned', 'membership', 'all_accessible'].includes(scopeRaw) ? scopeRaw : 'owned';
+        const repositories = await gitlab.listUserRepositories({ perPage, page, scope });
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ perPage, page, scope, repositories }, null, 2) }],
+        };
+    }
+    if (name === 'list_merge_requests') {
+        const projectId = await resolveProjectId();
+        const stateRaw = args.state === undefined ? undefined : String(args.state).trim();
+        const state = stateRaw && ['opened', 'closed', 'locked', 'merged', 'all'].includes(stateRaw)
+            ? stateRaw
+            : undefined;
+        const perPageRaw = Number(args.perPage);
+        const perPage = Number.isFinite(perPageRaw) ? Math.max(1, Math.min(100, Math.floor(perPageRaw))) : undefined;
+        const pageRaw = Number(args.page);
+        const page = Number.isFinite(pageRaw) ? Math.max(1, Math.floor(pageRaw)) : undefined;
+        const mrs = await gitlab.listMergeRequests(projectId, {
+            state,
+            sourceBranch: args.sourceBranch === undefined ? undefined : String(args.sourceBranch).trim() || undefined,
+            targetBranch: args.targetBranch === undefined ? undefined : String(args.targetBranch).trim() || undefined,
+            authorUsername: args.authorUsername === undefined ? undefined : String(args.authorUsername).trim() || undefined,
+            reviewerUsername: args.reviewerUsername === undefined ? undefined : String(args.reviewerUsername).trim() || undefined,
+            search: args.search === undefined ? undefined : String(args.search).trim() || undefined,
+            perPage,
+            page,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(mrs, null, 2) }] };
+    }
+    if (name === 'get_merge_request_diff') {
+        const projectId = await resolveProjectId();
+        const mergeRequestIid = String(args.mergeRequestIid ?? '');
+        if (!mergeRequestIid)
+            throw new Error('mergeRequestIid is required');
+        const changes = await gitlab.getMergeRequestChanges(projectId, mergeRequestIid);
+        return { content: [{ type: 'text', text: JSON.stringify(changes, null, 2) }] };
+    }
+    if (name === 'get_merge_request') {
+        const projectId = await resolveProjectId();
+        const mergeRequestIid = String(args.mergeRequestIid ?? '').trim();
+        if (!mergeRequestIid)
+            throw new Error('mergeRequestIid is required');
+        const detail = await gitlab.getMergeRequestDetail(projectId, mergeRequestIid);
+        return { content: [{ type: 'text', text: JSON.stringify(detail, null, 2) }] };
+    }
+    if (name === 'merge_readiness_check') {
+        const projectId = await resolveProjectId();
+        const mergeRequestIid = String(args.mergeRequestIid ?? '').trim();
+        if (!mergeRequestIid)
+            throw new Error('mergeRequestIid is required');
+        const readiness = await gitlab.getMergeReadiness(projectId, mergeRequestIid);
+        return { content: [{ type: 'text', text: JSON.stringify(readiness, null, 2) }] };
+    }
+    if (name === 'run_staging_pipeline') {
+        const projectId = await resolveProjectId();
+        const staging = Number(args.staging);
+        if (!Number.isInteger(staging) || staging < 1 || staging > 15) {
+            throw new Error('staging must be an integer between 1 and 15');
+        }
+        const ref = args.ref === undefined ? undefined : String(args.ref).trim() || undefined;
+        const mergeRequestIid = args.mergeRequestIid === undefined ? undefined : String(args.mergeRequestIid).trim() || undefined;
+        const result = await gitlab.runStagingPipeline(projectId, staging, { ref, mergeRequestIid });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    if (name === 'check_pipeline_status') {
+        const projectId = await resolveProjectId();
+        const pipelineId = args.pipelineId === undefined ? undefined : String(args.pipelineId).trim() || undefined;
+        const ref = args.ref === undefined ? undefined : String(args.ref).trim() || undefined;
+        const mergeRequestIid = args.mergeRequestIid === undefined ? undefined : String(args.mergeRequestIid).trim() || undefined;
+        const result = await gitlab.getPipelineStatus(projectId, { pipelineId, ref, mergeRequestIid });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }
+    if (name === 'list_pipeline_jobs') {
+        const projectId = await resolveProjectId();
+        const pipelineId = String(args.pipelineId ?? '').trim();
+        if (!pipelineId)
+            throw new Error('pipelineId is required');
+        const scope = Array.isArray(args.scope)
+            ? args.scope.filter((s) => typeof s === 'string')
+            : undefined;
+        const jobs = await gitlab.listPipelineJobs(projectId, pipelineId, scope);
+        return { content: [{ type: 'text', text: JSON.stringify({ projectId, pipelineId, total: jobs.length, jobs }, null, 2) }] };
+    }
+    if (name === 'retry_pipeline_job') {
+        const projectId = await resolveProjectId();
+        const jobId = String(args.jobId ?? '').trim();
+        if (!jobId)
+            throw new Error('jobId is required');
+        const job = await gitlab.retryJob(projectId, jobId);
+        return { content: [{ type: 'text', text: JSON.stringify({ projectId, jobId, retriedJob: job }, null, 2) }] };
+    }
+    if (name === 'get_mr_discussions') {
+        const projectId = await resolveProjectId();
+        const mergeRequestIid = String(args.mergeRequestIid ?? '').trim();
+        if (!mergeRequestIid)
+            throw new Error('mergeRequestIid is required');
+        const unresolvedOnly = Boolean(args.unresolvedOnly ?? false);
+        let discussions = await gitlab.getMergeRequestDiscussions(projectId, mergeRequestIid);
+        if (unresolvedOnly) {
+            discussions = discussions.filter((d) => d.notes?.some((n) => n.resolvable && !n.resolved && !n.system));
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ projectId, mergeRequestIid, unresolvedOnly, total: discussions.length, discussions }, null, 2),
+                },
+            ],
+        };
+    }
+    if (name === 'open_merge_request') {
+        const projectId = await resolveProjectId();
+        const sourceBranch = String(args.sourceBranch ?? '').trim();
+        const targetBranch = String(args.targetBranch ?? '').trim();
+        const title = String(args.title ?? '').trim();
+        const description = String(args.description ?? '').trim();
+        if (!sourceBranch)
+            throw new Error('sourceBranch is required');
+        if (!targetBranch)
+            throw new Error('targetBranch is required');
+        if (!title)
+            throw new Error('title is required');
+        const opened = await gitlab.createMergeRequest(projectId, {
+            sourceBranch,
+            targetBranch,
+            title,
+            description: description || undefined,
+            removeSourceBranch: args.removeSourceBranch === undefined ? undefined : Boolean(args.removeSourceBranch),
+            draft: args.draft === undefined ? undefined : Boolean(args.draft),
+            squash: args.squash === undefined ? undefined : Boolean(args.squash),
+        });
+        return { content: [{ type: 'text', text: JSON.stringify({ projectId, opened }, null, 2) }] };
+    }
+    if (name === 'merge_merge_request') {
+        const projectId = await resolveProjectId();
+        const mergeRequestIid = String(args.mergeRequestIid ?? '').trim();
+        if (!mergeRequestIid)
+            throw new Error('mergeRequestIid is required');
+        const merged = await gitlab.mergeMergeRequest(projectId, mergeRequestIid, {
+            squash: args.squash === undefined ? undefined : Boolean(args.squash),
+            shouldRemoveSourceBranch: args.shouldRemoveSourceBranch === undefined ? undefined : Boolean(args.shouldRemoveSourceBranch),
+            mergeWhenPipelineSucceeds: args.mergeWhenPipelineSucceeds === undefined ? undefined : Boolean(args.mergeWhenPipelineSucceeds),
+            sha: args.sha === undefined ? undefined : String(args.sha).trim() || undefined,
+            mergeCommitMessage: args.mergeCommitMessage === undefined ? undefined : String(args.mergeCommitMessage).trim() || undefined,
+            squashCommitMessage: args.squashCommitMessage === undefined ? undefined : String(args.squashCommitMessage).trim() || undefined,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify({ projectId, mergeRequestIid, merged }, null, 2) }] };
+    }
+    if (name === 'reject_merge_request') {
+        const projectId = await resolveProjectId();
+        const mergeRequestIid = String(args.mergeRequestIid ?? '').trim();
+        const notes = String(args.notes ?? '').trim();
+        if (!mergeRequestIid)
+            throw new Error('mergeRequestIid is required');
+        if (!notes)
+            throw new Error('notes is required');
+        const note = await gitlab.commentMergeRequest(projectId, mergeRequestIid, notes);
+        const revokeOwnApproval = args.revokeOwnApproval === undefined ? true : Boolean(args.revokeOwnApproval);
+        const closeMergeRequest = args.closeMergeRequest === undefined ? true : Boolean(args.closeMergeRequest);
+        let unapproved = null;
+        let unapproveWarning = null;
+        if (revokeOwnApproval) {
+            try {
+                unapproved = await gitlab.unapproveMergeRequest(projectId, mergeRequestIid);
+            }
+            catch (error) {
+                unapproveWarning = error instanceof Error ? error.message : 'Failed to unapprove merge request';
+            }
+        }
+        let closed = null;
+        let closeWarning = null;
+        if (closeMergeRequest) {
+            try {
+                closed = await gitlab.closeMergeRequest(projectId, mergeRequestIid);
+            }
+            catch (error) {
+                closeWarning = error instanceof Error ? error.message : 'Failed to close merge request';
+            }
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ projectId, mergeRequestIid, note, revokeOwnApproval, unapproved, unapproveWarning, closeMergeRequest, closed, closeWarning }, null, 2),
+                },
+            ],
+        };
+    }
+    if (name === 'merge_request_action') {
+        const projectId = await resolveProjectId();
+        const mergeRequestIid = String(args.mergeRequestIid ?? '').trim();
+        if (!mergeRequestIid)
+            throw new Error('mergeRequestIid is required');
+        const action = String(args.action ?? '').toLowerCase();
+        if (action === 'comment') {
+            const body = String(args.body ?? '').trim();
+            if (!body)
+                throw new Error('body is required for comment action');
+            const note = await gitlab.commentMergeRequest(projectId, mergeRequestIid, body);
+            return { content: [{ type: 'text', text: JSON.stringify({ action, projectId, mergeRequestIid, note }, null, 2) }] };
+        }
+        if (action === 'review') {
+            const changes = await gitlab.getMergeRequestChanges(projectId, mergeRequestIid);
+            const combinedDiff = (changes || []).map((c) => c.diff || '').join('\n');
+            const generated = await reviewer.analyzeDiff(combinedDiff);
+            const postComment = args.postComment === undefined ? true : Boolean(args.postComment);
+            let note = null;
+            if (postComment)
+                note = await gitlab.commentMergeRequest(projectId, mergeRequestIid, generated);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ action, projectId, mergeRequestIid, postComment, generatedComment: generated, note }, null, 2),
+                    },
+                ],
+            };
+        }
+        if (action === 'approve') {
+            const notes = String(args.notes ?? '').trim();
+            const sha = args.sha === undefined ? undefined : String(args.sha).trim();
+            if (notes)
+                await gitlab.commentMergeRequest(projectId, mergeRequestIid, notes);
+            const approved = await gitlab.approveMergeRequest(projectId, mergeRequestIid, sha || undefined);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ action, projectId, mergeRequestIid, notePosted: Boolean(notes), approved }, null, 2),
+                    },
+                ],
+            };
+        }
+        if (action === 'merge') {
+            const merged = await gitlab.mergeMergeRequest(projectId, mergeRequestIid, {
+                squash: args.squash === undefined ? undefined : Boolean(args.squash),
+                shouldRemoveSourceBranch: args.shouldRemoveSourceBranch === undefined ? undefined : Boolean(args.shouldRemoveSourceBranch),
+                mergeWhenPipelineSucceeds: args.mergeWhenPipelineSucceeds === undefined ? undefined : Boolean(args.mergeWhenPipelineSucceeds),
+                sha: args.sha === undefined ? undefined : String(args.sha).trim() || undefined,
+                mergeCommitMessage: args.mergeCommitMessage === undefined ? undefined : String(args.mergeCommitMessage).trim() || undefined,
+                squashCommitMessage: args.squashCommitMessage === undefined ? undefined : String(args.squashCommitMessage).trim() || undefined,
+            });
+            return { content: [{ type: 'text', text: JSON.stringify({ action, projectId, mergeRequestIid, merged }, null, 2) }] };
+        }
+        if (action === 'reject') {
+            const notes = String(args.notes ?? '').trim();
+            if (!notes)
+                throw new Error('notes is required for reject action');
+            const note = await gitlab.commentMergeRequest(projectId, mergeRequestIid, notes);
+            const revokeOwnApproval = args.revokeOwnApproval === undefined ? true : Boolean(args.revokeOwnApproval);
+            const closeMergeRequest = args.closeMergeRequest === undefined ? true : Boolean(args.closeMergeRequest);
+            let unapproved = null;
+            let unapproveWarning = null;
+            if (revokeOwnApproval) {
+                try {
+                    unapproved = await gitlab.unapproveMergeRequest(projectId, mergeRequestIid);
+                }
+                catch (error) {
+                    unapproveWarning = error instanceof Error ? error.message : 'Failed to unapprove merge request';
+                }
+            }
+            let closed = null;
+            let closeWarning = null;
+            if (closeMergeRequest) {
+                try {
+                    closed = await gitlab.closeMergeRequest(projectId, mergeRequestIid);
+                }
+                catch (error) {
+                    closeWarning = error instanceof Error ? error.message : 'Failed to close merge request';
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ action, projectId, mergeRequestIid, note, revokeOwnApproval, unapproved, unapproveWarning, closeMergeRequest, closed, closeWarning }, null, 2),
+                    },
+                ],
+            };
+        }
+        throw new Error('action must be one of: comment, review, approve, merge, reject');
+    }
+    if (name === 'check_project_merge_requests') {
+        const projectQuery = String(args.projectQuery ?? '').trim();
+        if (!projectQuery)
+            throw new Error('projectQuery is required');
+        const payload = await gitlab.listMergeRequestsByProjectQuery(projectQuery);
+        return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+    }
+    throw new Error(`Unknown tool: ${name}`);
+}
+// ─── HTTP helpers ─────────────────────────────────────────────────────────────
+async function parseJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0)
+        return undefined;
+    const raw = Buffer.concat(chunks).toString('utf8');
+    if (!raw.trim())
+        return undefined;
+    return JSON.parse(raw);
+}
+function getUserPatFromRequest(req) {
+    const headerKey = config_1.default.userPatHeader.toLowerCase();
+    const fromConfiguredHeader = req.headers[headerKey];
+    if (typeof fromConfiguredHeader === 'string' && fromConfiguredHeader.trim()) {
+        return fromConfiguredHeader.trim();
+    }
+    const authHeader = req.headers.authorization;
+    if (typeof authHeader === 'string') {
+        const match = authHeader.match(/^Bearer\s+(.+)$/i);
+        if (match?.[1])
+            return match[1].trim();
+    }
+    return undefined;
+}
+// ─── HTTP server ──────────────────────────────────────────────────────────────
+async function startHttp() {
+    const port = config_1.default.port;
+    const SESSION_GRACE_MS = 60000; // keep session 60s after transport close
+    const SESSION_TTL_MS = 30 * 60000; // evict idle sessions after 30 min
+    const sessions = new Map();
+    const cleanupTimer = setInterval(() => {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [sid, entry] of sessions) {
+            if (now - entry.lastActivity > SESSION_TTL_MS) {
+                if (entry.gracePeriodTimer)
+                    clearTimeout(entry.gracePeriodTimer);
+                sessions.delete(sid);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0)
+            (0, utils_1.logger)('info', `Cleaned up ${cleaned} expired session(s), active: ${sessions.size}`);
+    }, 60000);
+    cleanupTimer.unref();
+    const httpServer = node_http_1.default.createServer(async (req, res) => {
+        try {
+            if (!req.url || !req.method) {
+                res.statusCode = 400;
+                res.end('Bad request');
+                return;
+            }
+            // ── Health check ────────────────────────────────────────────────────────
+            if (req.url === '/health') {
+                const activeSessions = [...sessions.values()].filter((e) => e.alive).length;
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({
+                    status: 'ok',
+                    uptime: Math.floor(process.uptime()),
+                    sessions: { total: sessions.size, active: activeSessions },
+                }));
+                return;
+            }
+            // ── Root info ───────────────────────────────────────────────────────────
+            if (req.url === '/') {
+                const activeSessions = [...sessions.values()].filter((e) => e.alive).length;
+                res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
+                res.end([
+                    'gitlab-mcp-server http mode running',
+                    'POST /mcp  — MCP requests',
+                    'GET  /health — Health check',
+                    `PAT header: ${config_1.default.userPatHeader} (or Authorization: Bearer <PAT>)`,
+                    `Active sessions: ${activeSessions}/${sessions.size}`,
+                ].join('\n') + '\n');
+                return;
+            }
+            if (req.url !== '/mcp') {
+                res.statusCode = 404;
+                res.end('Not found');
+                return;
+            }
+            const sessionIdHeader = req.headers['mcp-session-id'];
+            const sessionId = Array.isArray(sessionIdHeader) ? sessionIdHeader[0] : sessionIdHeader;
+            // ── POST ────────────────────────────────────────────────────────────────
+            if (req.method === 'POST') {
+                const body = await parseJsonBody(req);
+                if (sessionId && sessions.has(sessionId)) {
+                    const entry = sessions.get(sessionId);
+                    entry.lastActivity = Date.now();
+                    if (!entry.alive) {
+                        res.writeHead(404, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({
+                            jsonrpc: '2.0',
+                            error: { code: -32001, message: 'Session closed, please reinitialize' },
+                            id: null,
+                        }));
+                        return;
+                    }
+                    await entry.transport.handleRequest(req, res, body);
+                    return;
+                }
+                if ((0, types_js_1.isInitializeRequest)(body)) {
+                    const userPat = getUserPatFromRequest(req);
+                    if (!userPat) {
+                        res.writeHead(401, { 'content-type': 'application/json' });
+                        res.end(JSON.stringify({
+                            jsonrpc: '2.0',
+                            error: {
+                                code: -32001,
+                                message: `User PAT required. Provide ${config_1.default.userPatHeader} header or Authorization: Bearer <PAT>`,
+                            },
+                            id: null,
+                        }));
+                        return;
+                    }
+                    const gitlab = new gitlab_service_1.GitLabService(userPat);
+                    const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                        sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
+                        onsessioninitialized: (sid) => {
+                            sessions.set(sid, { transport, lastActivity: Date.now(), alive: true });
+                            (0, utils_1.logger)('info', `Session ${sid} initialized (total: ${sessions.size})`);
+                        },
+                    });
+                    transport.onclose = () => {
+                        const sid = transport.sessionId;
+                        if (!sid)
+                            return;
+                        const entry = sessions.get(sid);
+                        if (!entry)
+                            return;
+                        entry.alive = false;
+                        if (entry.gracePeriodTimer)
+                            clearTimeout(entry.gracePeriodTimer);
+                        entry.gracePeriodTimer = setTimeout(() => {
+                            sessions.delete(sid);
+                            (0, utils_1.logger)('info', `Session ${sid} removed after grace period (total: ${sessions.size})`);
+                        }, SESSION_GRACE_MS);
+                        (0, utils_1.logger)('info', `Session ${sid} transport closed, grace period ${SESSION_GRACE_MS / 1000}s started`);
+                    };
+                    const sessionServer = buildMcpServer(gitlab);
+                    await sessionServer.connect(transport);
+                    await transport.handleRequest(req, res, body);
+                    return;
+                }
+                res.writeHead(400, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    error: { code: -32000, message: 'Bad Request: invalid or missing MCP session' },
+                    id: null,
+                }));
+                return;
+            }
+            // ── GET / DELETE ────────────────────────────────────────────────────────
+            if (req.method === 'GET' || req.method === 'DELETE') {
+                if (!sessionId || !sessions.has(sessionId)) {
+                    res.statusCode = 400;
+                    res.end('Invalid or missing session ID');
+                    return;
+                }
+                const entry = sessions.get(sessionId);
+                entry.lastActivity = Date.now();
+                await entry.transport.handleRequest(req, res);
+                return;
+            }
+            res.statusCode = 405;
+            res.end('Method not allowed');
+        }
+        catch (error) {
+            (0, utils_1.logger)('error', 'HTTP MCP handler error', error);
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.end('Internal Server Error');
+            }
+        }
+    });
+    // Prevent Node.js from closing idle connections before the proxy timeout
+    httpServer.keepAliveTimeout = 75000;
+    httpServer.headersTimeout = 80000;
+    // ── Graceful shutdown ───────────────────────────────────────────────────────
+    const shutdown = (signal) => {
+        (0, utils_1.logger)('info', `Received ${signal}, shutting down gracefully...`);
+        clearInterval(cleanupTimer);
+        for (const [, entry] of sessions) {
+            if (entry.gracePeriodTimer)
+                clearTimeout(entry.gracePeriodTimer);
+        }
+        sessions.clear();
+        httpServer.close(() => {
+            (0, utils_1.logger)('info', 'HTTP server closed');
+            process.exit(0);
+        });
+        // Force exit if graceful shutdown takes too long
+        setTimeout(() => {
+            (0, utils_1.logger)('warn', 'Forced exit after shutdown timeout');
+            process.exit(1);
+        }, 10000).unref();
+    };
+    process.once('SIGTERM', () => shutdown('SIGTERM'));
+    process.once('SIGINT', () => shutdown('SIGINT'));
+    httpServer.listen(port, () => {
+        (0, utils_1.logger)('info', `GitLab MCP server running on http://localhost:${port}/mcp`);
+    });
+}
+// ─── Stdio mode ───────────────────────────────────────────────────────────────
+async function startStdio() {
+    const token = process.env.GITLAB_TOKEN;
+    if (!token)
+        throw new Error('GITLAB_TOKEN is required in environment for stdio mode');
+    const gitlab = new gitlab_service_1.GitLabService(token);
+    const server = buildMcpServer(gitlab);
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // Keep process alive; transport handles stdin/stdout lifecycle
+    process.once('SIGTERM', () => process.exit(0));
+    process.once('SIGINT', () => process.exit(0));
+}
+// ─── Entry point ──────────────────────────────────────────────────────────────
+function validateBaseUrl() {
+    const baseUrl = process.env.GITLAB_BASE_URL;
+    if (!baseUrl)
+        throw new Error('GITLAB_BASE_URL is required in environment');
+    try {
+        const url = new URL(baseUrl);
+        if (!['http:', 'https:'].includes(url.protocol)) {
+            throw new Error('GITLAB_BASE_URL must use http or https protocol');
+        }
+    }
+    catch (err) {
+        if (err instanceof TypeError) {
+            throw new Error(`GITLAB_BASE_URL is not a valid URL: "${baseUrl}"`);
+        }
+        throw err;
+    }
+}
+async function start() {
+    const isStdio = process.argv.includes('--stdio');
+    validateBaseUrl();
+    if (isStdio) {
+        await startStdio();
+    }
+    else {
+        await startHttp();
+    }
+}
+start().catch((error) => {
+    (0, utils_1.logger)('error', 'Failed to start MCP server', error);
+    process.exit(1);
+});