@zereight/mcp-gitlab 2.0.28 → 2.0.32

package/build/index.js

@@ -36,21 +36,21 @@ import { CookieJar, parse as parseCookie } from "tough-cookie";
 import { fileURLToPath, URL } from "node:url";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { initializeOAuth } from "./oauth.js";
+import { initializeOAuthClient } from "./oauth.js";
 import { GitLabClientPool } from "./gitlab-client-pool.js";
 // Add type imports for proxy agents
 import { Agent } from "node:http";
 import { Agent as HttpsAgent } from "node:https";
 import { BulkPublishDraftNotesSchema, CancelPipelineJobSchema, CancelPipelineSchema, CreateBranchSchema, CreateDraftNoteSchema, CreateIssueLinkSchema, CreateIssueNoteSchema, CreateIssueSchema, CreateLabelSchema, // Added
-CreateMergeRequestNoteSchema, CreateMergeRequestDiscussionNoteSchema, CreateMergeRequestSchema, CreateMergeRequestThreadSchema, CreateNoteSchema, CreateOrUpdateFileSchema, CreatePipelineSchema, CreateProjectMilestoneSchema, CreateRepositorySchema, CreateWikiPageSchema, DeleteDraftNoteSchema, DeleteIssueLinkSchema, DeleteIssueSchema, DeleteLabelSchema, DeleteProjectMilestoneSchema, DeleteWikiPageSchema, DeleteMergeRequestNoteSchema, EditProjectMilestoneSchema, ForkRepositorySchema, GetBranchDiffsSchema, GetCommitDiffSchema, GetCommitSchema, GetDraftNoteSchema, GetFileContentsSchema, GetIssueLinkSchema, GetIssueSchema, GetLabelSchema, GetMergeRequestDiffsSchema, GetMergeRequestSchema, GetMilestoneBurndownEventsSchema, GetMilestoneIssuesSchema, GetMilestoneMergeRequestsSchema, GetNamespaceSchema, 
+CreateMergeRequestNoteSchema, CreateMergeRequestDiscussionNoteSchema, CreateMergeRequestSchema, CreateMergeRequestThreadSchema, CreateNoteSchema, CreateOrUpdateFileSchema, CreatePipelineSchema, CreateProjectMilestoneSchema, CreateRepositorySchema, CreateWikiPageSchema, DeleteDraftNoteSchema, DeleteIssueLinkSchema, DeleteIssueSchema, DeleteLabelSchema, DeleteProjectMilestoneSchema, DeleteWikiPageSchema, DeleteMergeRequestNoteSchema, EditProjectMilestoneSchema, ForkRepositorySchema, GetBranchDiffsSchema, GetCommitDiffSchema, GetCommitSchema, GetDraftNoteSchema, GetFileContentsSchema, GetIssueLinkSchema, GetIssueSchema, GetLabelSchema, GetMergeRequestDiffsSchema, GetMergeRequestSchema, GetMilestoneBurndownEventsSchema, GetMilestoneIssuesSchema, GetMilestoneMergeRequestsSchema, GetDeploymentSchema, GetEnvironmentSchema, GetNamespaceSchema, 
 // pipeline job schemas
 GetPipelineJobOutputSchema, GetPipelineSchema, GetProjectMilestoneSchema, GetProjectSchema, GetRepositoryTreeSchema, GetUsersSchema, GetWikiPageSchema, GitLabCommitSchema, GitLabCompareResultSchema, GitLabContentSchema, GitLabCreateUpdateFileResponseSchema, GitLabDiffSchema, 
 // Discussion Schemas
 GitLabDiscussionNoteSchema, // Added
 GitLabDiscussionSchema, 
 // Draft Notes Schemas
-GitLabDraftNoteSchema, GitLabForkSchema, GitLabIssueLinkSchema, GitLabIssueSchema, GitLabIssueWithLinkDetailsSchema, GitLabMarkdownUploadSchema, GitLabMergeRequestSchema, GitLabMilestonesSchema, GitLabNamespaceExistsResponseSchema, GitLabNamespaceSchema, GitLabPipelineJobSchema, GitLabPipelineSchema, GitLabPipelineTriggerJobSchema, GitLabProjectMemberSchema, GitLabProjectSchema, GitLabReferenceSchema, GitLabRepositorySchema, GitLabSearchResponseSchema, GitLabTreeItemSchema, GitLabTreeSchema, GitLabUserSchema, GitLabUsersResponseSchema, GitLabWikiPageSchema, GroupIteration, ListCommitsSchema, ListDraftNotesSchema, ListGroupIterationsSchema, ListGroupProjectsSchema, ListIssueDiscussionsSchema, ListIssueLinksSchema, ListIssuesSchema, ListLabelsSchema, ListMergeRequestDiffsSchema, // Added
-ListMergeRequestDiscussionsSchema, ListMergeRequestsSchema, ListMergeRequestVersionsSchema, GetMergeRequestVersionSchema, GitLabMergeRequestVersionSchema, GitLabMergeRequestVersionDetailSchema, ListNamespacesSchema, ListPipelineJobsSchema, ListPipelinesSchema, ListPipelineTriggerJobsSchema, ListProjectMembersSchema, ListProjectMilestonesSchema, ListProjectsSchema, ListWikiPagesSchema, MarkdownUploadSchema, DownloadAttachmentSchema, MergeMergeRequestSchema, ApproveMergeRequestSchema, UnapproveMergeRequestSchema, GetMergeRequestApprovalStateSchema, GitLabMergeRequestApprovalStateSchema, MyIssuesSchema, PaginatedDiscussionsResponseSchema, PromoteProjectMilestoneSchema, PublishDraftNoteSchema, PlayPipelineJobSchema, PushFilesSchema, RetryPipelineJobSchema, RetryPipelineSchema, SearchRepositoriesSchema, UpdateDraftNoteSchema, UpdateIssueNoteSchema, UpdateIssueSchema, UpdateLabelSchema, UpdateMergeRequestNoteSchema, UpdateMergeRequestDiscussionNoteSchema, UpdateMergeRequestSchema, UpdateWikiPageSchema, VerifyNamespaceSchema, GitLabEventSchema, ListEventsSchema, GetProjectEventsSchema, ExecuteGraphQLSchema, GitLabReleaseSchema, ListReleasesSchema, GetReleaseSchema, CreateReleaseSchema, UpdateReleaseSchema, DeleteReleaseSchema, CreateReleaseEvidenceSchema, DownloadReleaseAssetSchema, GetMergeRequestNotesSchema, GetMergeRequestNoteSchema, DeleteMergeRequestDiscussionNoteSchema, ResolveMergeRequestThreadSchema, } from "./schemas.js";
+GitLabDraftNoteSchema, GitLabForkSchema, GitLabIssueLinkSchema, GitLabIssueSchema, GitLabIssueWithLinkDetailsSchema, GitLabMarkdownUploadSchema, GitLabMergeRequestSchema, GitLabMilestonesSchema, GitLabNamespaceExistsResponseSchema, GitLabNamespaceSchema, GitLabPipelineJobSchema, GitLabDeploymentSchema, GitLabEnvironmentSchema, GitLabPipelineSchema, GitLabPipelineTriggerJobSchema, GitLabProjectMemberSchema, GitLabProjectSchema, GitLabReferenceSchema, GitLabRepositorySchema, GitLabSearchResponseSchema, GitLabTreeItemSchema, GitLabTreeSchema, GitLabUserSchema, GitLabUsersResponseSchema, GitLabWikiPageSchema, GroupIteration, ListCommitsSchema, ListDraftNotesSchema, ListGroupIterationsSchema, ListGroupProjectsSchema, ListIssueDiscussionsSchema, ListIssueLinksSchema, ListIssuesSchema, ListLabelsSchema, ListMergeRequestDiffsSchema, // Added
+ListMergeRequestDiscussionsSchema, ListMergeRequestsSchema, ListMergeRequestVersionsSchema, GetMergeRequestVersionSchema, GitLabMergeRequestVersionSchema, GitLabMergeRequestVersionDetailSchema, ListNamespacesSchema, ListPipelineJobsSchema, ListPipelinesSchema, ListDeploymentsSchema, ListEnvironmentsSchema, ListPipelineTriggerJobsSchema, ListProjectMembersSchema, ListProjectMilestonesSchema, ListProjectsSchema, ListWikiPagesSchema, MarkdownUploadSchema, DownloadAttachmentSchema, DownloadJobArtifactsSchema, GetJobArtifactFileSchema, GitLabArtifactEntrySchema, ListJobArtifactsSchema, MergeMergeRequestSchema, ApproveMergeRequestSchema, UnapproveMergeRequestSchema, GetMergeRequestApprovalStateSchema, GitLabMergeRequestApprovalsResponseSchema, GitLabMergeRequestApprovalStateSchema, MyIssuesSchema, PaginatedDiscussionsResponseSchema, PromoteProjectMilestoneSchema, PublishDraftNoteSchema, PlayPipelineJobSchema, PushFilesSchema, RetryPipelineJobSchema, RetryPipelineSchema, SearchRepositoriesSchema, UpdateDraftNoteSchema, UpdateIssueNoteSchema, UpdateIssueSchema, UpdateLabelSchema, UpdateMergeRequestNoteSchema, UpdateMergeRequestDiscussionNoteSchema, UpdateMergeRequestSchema, UpdateWikiPageSchema, VerifyNamespaceSchema, GitLabEventSchema, ListEventsSchema, GetProjectEventsSchema, ExecuteGraphQLSchema, GitLabReleaseSchema, ListReleasesSchema, GetReleaseSchema, CreateReleaseSchema, UpdateReleaseSchema, DeleteReleaseSchema, CreateReleaseEvidenceSchema, DownloadReleaseAssetSchema, GetMergeRequestNotesSchema, GetMergeRequestNoteSchema, DeleteMergeRequestDiscussionNoteSchema, ResolveMergeRequestThreadSchema, } from "./schemas.js";
 import { randomUUID } from "node:crypto";
 import { pino } from "pino";
 const logger = pino({
@@ -95,6 +95,29 @@ catch {
  * cross-client data leakage (GHSA-345p-7cg4-v4c7).
  */
 function createServer() {
+    // Precompute filtered tool list once at server creation (Steps 1–5 are static)
+    // Step 1: Toolset filter — keep tools in enabled toolsets
+    const toolsAfterToolsets = allTools.filter(tool => isToolInEnabledToolset(tool.name, enabledToolsets));
+    // Step 2: Add GITLAB_TOOLS (individual tools bypass toolset filter)
+    const toolsetToolNames = new Set(toolsAfterToolsets.map(t => t.name));
+    const toolsAfterIndividual = [
+        ...toolsAfterToolsets,
+        ...allTools.filter(tool => individuallyEnabledTools.has(tool.name) && !toolsetToolNames.has(tool.name)),
+    ];
+    // Step 3: Add legacy flag overrides (USE_PIPELINE, USE_MILESTONE, USE_GITLAB_WIKI)
+    const afterIndividualNames = new Set(toolsAfterIndividual.map(t => t.name));
+    const toolsAfterLegacy = [
+        ...toolsAfterIndividual,
+        ...allTools.filter(tool => featureFlagOverrides.has(tool.name) && !afterIndividualNames.has(tool.name)),
+    ];
+    // Step 4: Read-only filter
+    const toolsAfterReadOnly = GITLAB_READ_ONLY_MODE
+        ? toolsAfterLegacy.filter(tool => readOnlyTools.has(tool.name))
+        : toolsAfterLegacy;
+    // Step 5: Regex denial filter
+    const precomputedFilteredTools = GITLAB_DENIED_TOOLS_REGEX
+        ? toolsAfterReadOnly.filter(tool => !GITLAB_DENIED_TOOLS_REGEX.test(tool.name))
+        : toolsAfterReadOnly;
     const serverInstance = new Server({
         name: "better-gitlab-mcp-server",
         version: SERVER_VERSION,
@@ -104,39 +127,25 @@ function createServer() {
         },
     });
     serverInstance.setRequestHandler(ListToolsRequestSchema, async () => {
-        // Apply read-only filter first
-        const tools0 = GITLAB_READ_ONLY_MODE
-            ? allTools.filter(tool => readOnlyTools.has(tool.name))
-            : allTools;
-        // Toggle wiki tools by USE_GITLAB_WIKI flag
-        const tools1 = USE_GITLAB_WIKI ? tools0 : tools0.filter(tool => !wikiToolNames.has(tool.name));
-        // Toggle milestone tools by USE_MILESTONE flag
-        const tools2 = USE_MILESTONE
-            ? tools1
-            : tools1.filter(tool => !milestoneToolNames.has(tool.name));
-        // Toggle pipeline tools by USE_PIPELINE flag
-        let tools = USE_PIPELINE ? tools2 : tools2.filter(tool => !pipelineToolNames.has(tool.name));
-        tools = GITLAB_DENIED_TOOLS_REGEX
-            ? tools.filter(tool => !GITLAB_DENIED_TOOLS_REGEX.test(tool.name))
-            : tools;
-        // <<< START: Gemini 호환성을 위해 $schema 제거 >>>
-        tools = tools.map(tool => {
-            // inputSchema가 존재하고 객체인지 확인
+        // Step 6: Gemini $schema cleanup (only dynamic step per request)
+        // <<< START: Remove $schema for Gemini compatibility >>>
+        const tools = precomputedFilteredTools.map(tool => {
+            // Check if inputSchema exists and is an object
             if (tool.inputSchema && typeof tool.inputSchema === "object" && tool.inputSchema !== null) {
-                // $schema 키가 존재하면 삭제
+                // Remove $schema key if present
                 if ("$schema" in tool.inputSchema) {
-                    // 불변성을 위해 새로운 객체 생성 (선택적이지만 권장)
+                    // Create a new object to preserve immutability (optional but recommended)
                     const modifiedSchema = { ...tool.inputSchema };
                     delete modifiedSchema.$schema;
                     return { ...tool, inputSchema: modifiedSchema };
                 }
             }
-            // 변경이 필요 없으면 그대로 반환
+            // Return as-is if no modification needed
             return tool;
         });
-        // <<< END: Gemini 호환성을 위해 $schema 제거 >>>
+        // <<< END: Remove $schema for Gemini compatibility >>>
         return {
-            tools, // $schema가 제거된 도구 목록 반환
+            tools, // return tool list with $schema removed
         };
     });
     serverInstance.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -234,6 +243,28 @@ function validateConfiguration() {
 }
 const GITLAB_PERSONAL_ACCESS_TOKEN = getConfig("token", "GITLAB_PERSONAL_ACCESS_TOKEN");
 let OAUTH_ACCESS_TOKEN = null;
+let oauthClient = null;
+/**
+ * Ensure the OAuth token is valid before making an API call.
+ * Refreshes the token lazily (only when a tool is actually called).
+ * This avoids background timers that cause issues with multiple instances.
+ */
+async function ensureValidOAuthToken() {
+    if (!oauthClient)
+        return;
+    if (oauthClient.hasValidToken())
+        return;
+    try {
+        logger.info("OAuth token expired or missing, refreshing...");
+        const freshToken = await oauthClient.getAccessToken();
+        OAUTH_ACCESS_TOKEN = freshToken;
+        logger.info("OAuth token refreshed successfully");
+    }
+    catch (error) {
+        logger.error("Failed to refresh OAuth token:", error);
+        throw error;
+    }
+}
 const GITLAB_AUTH_COOKIE_PATH = getConfig("cookie-path", "GITLAB_AUTH_COOKIE_PATH");
 const USE_OAUTH = getConfig("use-oauth", "GITLAB_USE_OAUTH") === "true";
 const IS_OLD = getConfig("is-old", "GITLAB_IS_OLD") === "true";
@@ -269,6 +300,8 @@ const GITLAB_DENIED_TOOLS_REGEX = (() => {
 const USE_GITLAB_WIKI = getConfig("use-wiki", "USE_GITLAB_WIKI") === "true";
 const USE_MILESTONE = getConfig("use-milestone", "USE_MILESTONE") === "true";
 const USE_PIPELINE = getConfig("use-pipeline", "USE_PIPELINE") === "true";
+const GITLAB_TOOLSETS_RAW = getConfig("toolsets", "GITLAB_TOOLSETS");
+const GITLAB_TOOLS_RAW = getConfig("tools", "GITLAB_TOOLS");
 const SSE = getConfig("sse", "SSE") === "true";
 const STREAMABLE_HTTP = getConfig("streamable-http", "STREAMABLE_HTTP") === "true";
 const REMOTE_AUTHORIZATION = getConfig("remote-auth", "REMOTE_AUTHORIZATION") === "true";
@@ -315,7 +348,7 @@ httpsAgent = httpsAgent || new HttpsAgent(sslOptions);
 httpAgent = httpAgent || new Agent();
 // Initialize the client pool for managing multiple GitLab instances
 const clientPool = new GitLabClientPool({
-    apiUrls: (process.env.GITLAB_API_URL || "https://gitlab.com")
+    apiUrls: (getConfig("api-url", "GITLAB_API_URL") || "https://gitlab.com")
         .split(",")
         .map(normalizeGitLabApiUrl),
     httpProxy: HTTP_PROXY,
@@ -446,7 +479,7 @@ const BASE_HEADERS = {
 /**
  * Build authentication headers dynamically based on context
  * In REMOTE_AUTHORIZATION mode, reads from AsyncLocalStorage session context
- * Otherwise, uses environment token
+ * Otherwise, uses environment token (OAuth token is refreshed lazily before each tool call)
  */
 function buildAuthHeaders() {
     if (REMOTE_AUTHORIZATION) {
@@ -561,7 +594,7 @@ const allTools = [
     },
     {
         name: "get_merge_request_approval_state",
-        description: "Get the approval state of a merge request including approval rules and who has approved",
+        description: "Get merge request approval details including approvers (uses approval_state when available, falls back to approvals endpoint)",
         inputSchema: toJSONSchema(GetMergeRequestApprovalStateSchema),
     },
     {
@@ -616,7 +649,7 @@ const allTools = [
     },
     {
         name: "get_merge_request",
-        description: "Get details of a merge request (Either mergeRequestIid or branchName must be provided)",
+        description: "Get details of a merge request with compact deployment, commit addition, and approval summaries (Either mergeRequestIid or branchName must be provided)",
         inputSchema: toJSONSchema(GetMergeRequestSchema),
     },
     {
@@ -904,6 +937,26 @@ const allTools = [
         description: "Get details of a specific pipeline in a GitLab project",
         inputSchema: toJSONSchema(GetPipelineSchema),
     },
+    {
+        name: "list_deployments",
+        description: "List deployments in a GitLab project with filtering options",
+        inputSchema: toJSONSchema(ListDeploymentsSchema),
+    },
+    {
+        name: "get_deployment",
+        description: "Get details of a specific deployment in a GitLab project",
+        inputSchema: toJSONSchema(GetDeploymentSchema),
+    },
+    {
+        name: "list_environments",
+        description: "List environments in a GitLab project",
+        inputSchema: toJSONSchema(ListEnvironmentsSchema),
+    },
+    {
+        name: "get_environment",
+        description: "Get details of a specific environment in a GitLab project",
+        inputSchema: toJSONSchema(GetEnvironmentSchema),
+    },
     {
         name: "list_pipeline_jobs",
         description: "List all jobs in a specific pipeline",
@@ -954,6 +1007,21 @@ const allTools = [
         description: "Cancel a running pipeline job",
         inputSchema: toJSONSchema(CancelPipelineJobSchema),
     },
+    {
+        name: "list_job_artifacts",
+        description: "List artifact files in a job's artifacts archive. Returns file names, paths, types, and sizes.",
+        inputSchema: toJSONSchema(ListJobArtifactsSchema),
+    },
+    {
+        name: "download_job_artifacts",
+        description: "Download the entire artifact archive (zip) for a job to a local path. Returns the saved file path.",
+        inputSchema: toJSONSchema(DownloadJobArtifactsSchema),
+    },
+    {
+        name: "get_job_artifact_file",
+        description: "Get the content of a single file from a job's artifacts by its path within the archive",
+        inputSchema: toJSONSchema(GetJobArtifactFileSchema),
+    },
     {
         name: "list_merge_requests",
         description: "List merge requests. Without project_id, lists MRs assigned to the authenticated user by default (use scope='all' for all accessible MRs). With project_id, lists MRs for that specific project.",
@@ -1036,7 +1104,7 @@ const allTools = [
     },
     {
         name: "download_attachment",
-        description: "Download an uploaded file from a GitLab project by secret and filename",
+        description: "Download an uploaded file from a GitLab project by secret and filename. Image files (png, jpg, gif, webp, svg, bmp, ico) are returned inline as base64 image content so the AI can view them directly. Non-image files are saved to disk. Use local_path to force saving image files to disk instead.",
         inputSchema: toJSONSchema(DownloadAttachmentSchema),
     },
     {
@@ -1111,10 +1179,17 @@ const readOnlyTools = new Set([
     "list_project_members",
     "get_pipeline",
     "list_pipelines",
+    "list_deployments",
+    "get_deployment",
+    "list_environments",
+    "get_environment",
     "list_pipeline_jobs",
     "list_pipeline_trigger_jobs",
     "get_pipeline_job",
     "get_pipeline_job_output",
+    "list_job_artifacts",
+    "download_job_artifacts",
+    "get_job_artifact_file",
     "list_labels",
     "get_label",
     "list_group_projects",
@@ -1165,6 +1240,10 @@ const milestoneToolNames = new Set([
 const pipelineToolNames = new Set([
     "list_pipelines",
     "get_pipeline",
+    "list_deployments",
+    "get_deployment",
+    "list_environments",
+    "get_environment",
     "list_pipeline_jobs",
     "list_pipeline_trigger_jobs",
     "get_pipeline_job",
@@ -1175,7 +1254,271 @@ const pipelineToolNames = new Set([
     "play_pipeline_job",
     "retry_pipeline_job",
     "cancel_pipeline_job",
+    "list_job_artifacts",
+    "download_job_artifacts",
+    "get_job_artifact_file",
 ]);
+const TOOLSET_DEFINITIONS = [
+    {
+        id: "merge_requests",
+        isDefault: true,
+        tools: new Set([
+            "merge_merge_request",
+            "approve_merge_request",
+            "unapprove_merge_request",
+            "get_merge_request_approval_state",
+            "get_merge_request",
+            "get_merge_request_diffs",
+            "list_merge_request_diffs",
+            "list_merge_request_versions",
+            "get_merge_request_version",
+            "update_merge_request",
+            "create_merge_request",
+            "list_merge_requests",
+            "get_branch_diffs",
+            "mr_discussions",
+            "create_merge_request_note",
+            "update_merge_request_note",
+            "delete_merge_request_note",
+            "get_merge_request_note",
+            "get_merge_request_notes",
+            "delete_merge_request_discussion_note",
+            "update_merge_request_discussion_note",
+            "create_merge_request_discussion_note",
+            "get_draft_note",
+            "list_draft_notes",
+            "create_draft_note",
+            "update_draft_note",
+            "delete_draft_note",
+            "publish_draft_note",
+            "bulk_publish_draft_notes",
+            "create_merge_request_thread",
+            "resolve_merge_request_thread",
+        ]),
+    },
+    {
+        id: "issues",
+        isDefault: true,
+        tools: new Set([
+            "create_issue",
+            "list_issues",
+            "my_issues",
+            "get_issue",
+            "update_issue",
+            "delete_issue",
+            "create_issue_note",
+            "update_issue_note",
+            "list_issue_links",
+            "list_issue_discussions",
+            "get_issue_link",
+            "create_issue_link",
+            "delete_issue_link",
+            "create_note",
+        ]),
+    },
+    {
+        id: "repositories",
+        isDefault: true,
+        tools: new Set([
+            "search_repositories",
+            "create_repository",
+            "get_file_contents",
+            "push_files",
+            "create_or_update_file",
+            "fork_repository",
+            "get_repository_tree",
+        ]),
+    },
+    {
+        id: "branches",
+        isDefault: true,
+        tools: new Set([
+            "create_branch",
+            "list_commits",
+            "get_commit",
+            "get_commit_diff",
+        ]),
+    },
+    {
+        id: "projects",
+        isDefault: true,
+        tools: new Set([
+            "get_project",
+            "list_projects",
+            "list_project_members",
+            "list_namespaces",
+            "get_namespace",
+            "verify_namespace",
+            "list_group_projects",
+            "list_group_iterations",
+        ]),
+    },
+    {
+        id: "labels",
+        isDefault: true,
+        tools: new Set([
+            "list_labels",
+            "get_label",
+            "create_label",
+            "update_label",
+            "delete_label",
+        ]),
+    },
+    {
+        id: "pipelines",
+        isDefault: true,
+        tools: new Set([
+            "list_pipelines",
+            "get_pipeline",
+            "list_deployments",
+            "get_deployment",
+            "list_environments",
+            "get_environment",
+            "list_pipeline_jobs",
+            "list_pipeline_trigger_jobs",
+            "get_pipeline_job",
+            "get_pipeline_job_output",
+            "create_pipeline",
+            "retry_pipeline",
+            "cancel_pipeline",
+            "play_pipeline_job",
+            "retry_pipeline_job",
+            "cancel_pipeline_job",
+            "list_job_artifacts",
+            "download_job_artifacts",
+            "get_job_artifact_file",
+        ]),
+    },
+    {
+        id: "milestones",
+        isDefault: true,
+        tools: new Set([
+            "list_milestones",
+            "get_milestone",
+            "create_milestone",
+            "edit_milestone",
+            "delete_milestone",
+            "get_milestone_issue",
+            "get_milestone_merge_requests",
+            "promote_milestone",
+            "get_milestone_burndown_events",
+        ]),
+    },
+    {
+        id: "wiki",
+        isDefault: true,
+        tools: new Set([
+            "list_wiki_pages",
+            "get_wiki_page",
+            "create_wiki_page",
+            "update_wiki_page",
+            "delete_wiki_page",
+        ]),
+    },
+    {
+        id: "releases",
+        isDefault: true,
+        tools: new Set([
+            "list_releases",
+            "get_release",
+            "create_release",
+            "update_release",
+            "delete_release",
+            "create_release_evidence",
+            "download_release_asset",
+        ]),
+    },
+    {
+        id: "users",
+        isDefault: true,
+        tools: new Set([
+            "get_users",
+            "list_events",
+            "get_project_events",
+            "upload_markdown",
+            "download_attachment",
+        ]),
+    },
+];
+// Derived lookup: tool name → toolset ID
+const TOOLSET_BY_TOOL_NAME = new Map();
+for (const def of TOOLSET_DEFINITIONS) {
+    for (const tool of def.tools) {
+        if (TOOLSET_BY_TOOL_NAME.has(tool)) {
+            logger.warn(`Tool "${tool}" is defined in multiple toolsets: "${TOOLSET_BY_TOOL_NAME.get(tool)}" and "${def.id}"`);
+        }
+        TOOLSET_BY_TOOL_NAME.set(tool, def.id);
+    }
+}
+const DEFAULT_TOOLSET_IDS = new Set(TOOLSET_DEFINITIONS.filter(d => d.isDefault).map(d => d.id));
+const ALL_TOOLSET_IDS = new Set(TOOLSET_DEFINITIONS.map(d => d.id));
+function parseEnabledToolsets(raw) {
+    if (!raw || raw.trim() === "") {
+        return DEFAULT_TOOLSET_IDS;
+    }
+    const trimmed = raw.trim().toLowerCase();
+    if (trimmed === "all") {
+        return ALL_TOOLSET_IDS;
+    }
+    const selected = new Set(trimmed
+        .split(",")
+        .map(s => s.trim())
+        .filter((s) => ALL_TOOLSET_IDS.has(s)));
+    if (selected.size === 0) {
+        logger.warn(`No valid toolsets found in configuration (${raw}). Falling back to default toolsets.`);
+        return DEFAULT_TOOLSET_IDS;
+    }
+    return selected;
+}
+function parseIndividualTools(raw) {
+    if (!raw || raw.trim() === "") {
+        return new Set();
+    }
+    const allToolNames = new Set(allTools.map((t) => t.name));
+    const parsed = raw
+        .trim()
+        .split(",")
+        .map(s => s.trim().toLowerCase())
+        .filter(Boolean);
+    const unknown = parsed.filter(name => !allToolNames.has(name));
+    if (unknown.length > 0) {
+        logger.warn(`Unknown tool names in GITLAB_TOOLS (will be ignored): ${unknown.join(", ")}`);
+    }
+    return new Set(parsed);
+}
+function buildFeatureFlagOverrides() {
+    const overrides = new Set();
+    if (USE_GITLAB_WIKI) {
+        for (const t of wikiToolNames)
+            overrides.add(t);
+    }
+    if (USE_MILESTONE) {
+        for (const t of milestoneToolNames)
+            overrides.add(t);
+    }
+    if (USE_PIPELINE) {
+        for (const t of pipelineToolNames)
+            overrides.add(t);
+    }
+    return overrides;
+}
+function isToolInEnabledToolset(toolName, enabledToolsets) {
+    const toolsetId = TOOLSET_BY_TOOL_NAME.get(toolName);
+    // Tools not in any toolset (e.g. execute_graphql) are excluded by default
+    if (toolsetId === undefined)
+        return false;
+    return enabledToolsets.has(toolsetId);
+}
+// Compute at startup
+const enabledToolsets = parseEnabledToolsets(GITLAB_TOOLSETS_RAW);
+const individuallyEnabledTools = parseIndividualTools(GITLAB_TOOLS_RAW);
+const featureFlagOverrides = buildFeatureFlagOverrides();
+// Warn about potentially confusing configuration
+if (GITLAB_TOOLSETS_RAW && (USE_PIPELINE || USE_MILESTONE || USE_GITLAB_WIKI)) {
+    logger.warn("GITLAB_TOOLSETS is set alongside legacy flags (USE_PIPELINE, USE_MILESTONE, USE_GITLAB_WIKI). " +
+        "Legacy flags add tools additively on top of the toolset selection and may produce unexpected results.");
+}
+const MERGE_REQUEST_DEPLOYMENT_SUMMARY_LIMIT = 10;
 /**
  * Smart URL handling for GitLab API
  *
@@ -1196,7 +1539,7 @@ function normalizeGitLabApiUrl(url) {
     return normalizedUrl;
 }
 // Use the normalizeGitLabApiUrl function to handle various URL formats
-const GITLAB_API_URLS = (process.env.GITLAB_API_URL || "https://gitlab.com")
+const GITLAB_API_URLS = (getConfig("api-url", "GITLAB_API_URL") || "https://gitlab.com")
     .split(",")
     .map(normalizeGitLabApiUrl);
 const GITLAB_API_URL = GITLAB_API_URLS[0];
@@ -1292,7 +1635,7 @@ async function forkProject(projectId, namespace) {
         ...getFetchConfig(),
         method: "POST",
     });
-    // 이미 존재하는 프로젝트인 경우 처리
+    // Handle case where project already exists
     if (response.status === 409) {
         throw new Error("Project already exists in the target namespace");
     }
@@ -1351,26 +1694,26 @@ async function getDefaultBranchRef(projectId) {
  * @returns {Promise<GitLabContent>} The file content
  */
 async function getFileContents(projectId, filePath, ref) {
-    projectId = decodeURIComponent(projectId); // Decode project ID
-    const effectiveProjectId = getEffectiveProjectId(projectId);
+    const decodedProjectId = projectId ? decodeURIComponent(projectId) : "";
+    const effectiveProjectId = getEffectiveProjectId(decodedProjectId);
     const encodedPath = encodeURIComponent(filePath);
-    // ref가 없는 경우 default branch를 가져옴
+    // Fall back to default branch if ref is not provided
     if (!ref) {
-        ref = await getDefaultBranchRef(projectId);
+        ref = await getDefaultBranchRef(decodedProjectId);
     }
     const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(effectiveProjectId)}/repository/files/${encodedPath}`);
     url.searchParams.append("ref", ref);
     const response = await fetch(url.toString(), {
         ...getFetchConfig(),
     });
-    // 파일을 찾을 수 없는 경우 처리
+    // Handle file not found
     if (response.status === 404) {
         throw new Error(`File not found: ${filePath}`);
     }
     await handleGitLabError(response);
     const data = await response.json();
     const parsedData = GitLabContentSchema.parse(data);
-    // Base64로 인코딩된 파일 내용을 UTF-8로 디코딩
+    // Decode Base64-encoded file content to UTF-8
     if (!Array.isArray(parsedData) && parsedData.content) {
         parsedData.content = Buffer.from(parsedData.content, "base64").toString("utf8");
         parsedData.encoding = "utf8";
@@ -1400,7 +1743,7 @@ async function createIssue(projectId, options) {
             labels: options.labels?.join(","),
         }),
     });
-    // 잘못된 요청 처리
+    // Handle bad request
     if (response.status === 400) {
         const errorBody = await response.text();
         throw new Error(`Invalid request: ${errorBody}`);
@@ -2190,6 +2533,7 @@ async function getMergeRequest(projectId, mergeRequestIid, branchName) {
     let url;
     if (mergeRequestIid) {
         url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}`);
+        url.searchParams.append("include_diverged_commits_count", "true");
     }
     else if (branchName) {
         url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests?source_branch=${encodeURIComponent(branchName)}`);
@@ -2204,10 +2548,219 @@ async function getMergeRequest(projectId, mergeRequestIid, branchName) {
     const data = await response.json();
     // If response is an array (Comes from branchName search), return the first item if exist
     if (Array.isArray(data) && data.length > 0) {
-        return GitLabMergeRequestSchema.parse(data[0]);
+        const mergeRequest = GitLabMergeRequestSchema.parse(data[0]);
+        return getMergeRequest(projectId, mergeRequest.iid, undefined);
     }
     return GitLabMergeRequestSchema.parse(data);
 }
+async function getMergeRequestSourceCommitCount(projectId, mergeRequestIid) {
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/commits`);
+    url.searchParams.append("per_page", "100");
+    let totalCount = 0;
+    let page = 1;
+    while (true) {
+        url.searchParams.set("page", String(page));
+        const response = await fetch(url.toString(), {
+            ...getFetchConfig(),
+        });
+        await handleGitLabError(response);
+        const data = await response.json();
+        if (!Array.isArray(data)) {
+            throw new Error("Unexpected merge request commits response format");
+        }
+        totalCount += data.length;
+        const nextPage = response.headers.get("x-next-page");
+        if (!nextPage) {
+            break;
+        }
+        page = Number.parseInt(nextPage, 10);
+        if (Number.isNaN(page) || page <= 0) {
+            break;
+        }
+    }
+    return totalCount;
+}
+async function getProjectMergeMethod(projectId) {
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}`);
+    const response = await fetch(url.toString(), {
+        ...getFetchConfig(),
+    });
+    await handleGitLabError(response);
+    const data = await response.json();
+    const mergeMethod = z
+        .object({
+        merge_method: z.string().nullable().optional(),
+    })
+        .parse(data).merge_method;
+    return typeof mergeMethod === "string" ? mergeMethod : null;
+}
+function estimateMergeCommitCount(mergeMethod, sourceCommitCount) {
+    if (sourceCommitCount === 0) {
+        return 0;
+    }
+    if (mergeMethod === "merge") {
+        return 1;
+    }
+    if (mergeMethod === "ff" || mergeMethod === "rebase_merge") {
+        return 0;
+    }
+    return null;
+}
+async function buildMergeRequestCommitAdditionSummary(projectId, mergeRequest) {
+    try {
+        const sourceCommitCount = await getMergeRequestSourceCommitCount(projectId, mergeRequest.iid);
+        const mergeMethod = await getProjectMergeMethod(projectId);
+        const mergeCommitCount = estimateMergeCommitCount(mergeMethod, sourceCommitCount);
+        const summary = mergeCommitCount === null
+            ? null
+            : `${sourceCommitCount} commits and ${mergeCommitCount} merge commit${mergeCommitCount === 1 ? "" : "s"} will be added to ${mergeRequest.target_branch}.`;
+        return {
+            target_branch: mergeRequest.target_branch,
+            source_commits_count: sourceCommitCount,
+            merge_method: mergeMethod,
+            merge_commit_count: mergeCommitCount,
+            summary,
+        };
+    }
+    catch (error) {
+        const unavailableReason = error instanceof Error ? error.message : String(error);
+        return {
+            target_branch: mergeRequest.target_branch,
+            source_commits_count: null,
+            merge_method: null,
+            merge_commit_count: null,
+            summary: null,
+            unavailable_reason: unavailableReason,
+        };
+    }
+}
+async function buildMergeRequestApprovalSummary(projectId, mergeRequestIid) {
+    try {
+        const approvalState = await getMergeRequestApprovalState(projectId, mergeRequestIid);
+        const approvedByUsers = approvalState.approved_by || [];
+        const approvedByUsernames = approvalState.approved_by_usernames || approvedByUsers.map(user => user.username);
+        const inferredApproved = inferMergeRequestApproved(approvalState.rules);
+        return {
+            approved: approvalState.approved ?? inferredApproved,
+            user_has_approved: approvalState.user_has_approved ?? null,
+            user_can_approve: approvalState.user_can_approve ?? null,
+            approved_by: approvedByUsers,
+            approved_by_usernames: approvedByUsernames,
+            rules_count: approvalState.rules?.length ?? null,
+            source_endpoint: approvalState.source_endpoint ?? null,
+        };
+    }
+    catch (error) {
+        const unavailableReason = error instanceof Error ? error.message : String(error);
+        return {
+            approved: null,
+            user_has_approved: null,
+            user_can_approve: null,
+            approved_by: [],
+            approved_by_usernames: [],
+            rules_count: null,
+            source_endpoint: null,
+            unavailable_reason: unavailableReason,
+        };
+    }
+}
+function toMergeRequestDeploymentSummaryRecord(deployment) {
+    return {
+        id: deployment.id,
+        status: deployment.status,
+        ref: deployment.ref,
+        sha: deployment.sha,
+        created_at: deployment.created_at,
+        updated_at: deployment.updated_at,
+        finished_at: deployment.finished_at,
+        web_url: deployment.web_url,
+        environment: deployment.environment
+            ? {
+                id: deployment.environment.id,
+                name: deployment.environment.name,
+                slug: deployment.environment.slug,
+                external_url: deployment.environment.external_url,
+                state: deployment.environment.state,
+                tier: deployment.environment.tier,
+            }
+            : undefined,
+        deployable: deployment.deployable === null
+            ? null
+            : deployment.deployable
+                ? {
+                    id: deployment.deployable.id,
+                    name: deployment.deployable.name,
+                    status: deployment.deployable.status,
+                    stage: deployment.deployable.stage,
+                    web_url: deployment.deployable.web_url,
+                    pipeline: deployment.deployable.pipeline
+                        ? {
+                            id: deployment.deployable.pipeline.id,
+                            status: deployment.deployable.pipeline.status,
+                            ref: deployment.deployable.pipeline.ref,
+                            sha: deployment.deployable.pipeline.sha,
+                            web_url: deployment.deployable.pipeline.web_url,
+                        }
+                        : undefined,
+                }
+                : undefined,
+    };
+}
+function sortDeploymentsByCreatedAtDesc(deployments) {
+    return [...deployments].sort((a, b) => {
+        const aTime = Date.parse(a.created_at);
+        const bTime = Date.parse(b.created_at);
+        if (Number.isNaN(aTime) || Number.isNaN(bTime)) {
+            return b.created_at.localeCompare(a.created_at);
+        }
+        return bTime - aTime;
+    });
+}
+async function buildMergeRequestDeploymentSummary(projectId, mergeRequest) {
+    const lookupSha = mergeRequest.merge_commit_sha ?? mergeRequest.diff_refs?.head_sha ?? null;
+    if (!lookupSha) {
+        return {
+            lookup_sha: null,
+            sort: "created_at_desc",
+            limit: MERGE_REQUEST_DEPLOYMENT_SUMMARY_LIMIT,
+            total_count: 0,
+            returned_count: 0,
+            records: [],
+        };
+    }
+    try {
+        const deployments = await listDeployments(projectId, {
+            sha: lookupSha,
+            order_by: "created_at",
+            sort: "desc",
+            per_page: 100,
+        });
+        const sortedDeployments = sortDeploymentsByCreatedAtDesc(deployments);
+        const records = sortedDeployments
+            .slice(0, MERGE_REQUEST_DEPLOYMENT_SUMMARY_LIMIT)
+            .map(toMergeRequestDeploymentSummaryRecord);
+        return {
+            lookup_sha: lookupSha,
+            sort: "created_at_desc",
+            limit: MERGE_REQUEST_DEPLOYMENT_SUMMARY_LIMIT,
+            total_count: sortedDeployments.length,
+            returned_count: records.length,
+            records,
+        };
+    }
+    catch (error) {
+        const unavailableReason = error instanceof Error ? error.message : String(error);
+        return {
+            lookup_sha: lookupSha,
+            sort: "created_at_desc",
+            limit: MERGE_REQUEST_DEPLOYMENT_SUMMARY_LIMIT,
+            total_count: 0,
+            returned_count: 0,
+            records: [],
+            unavailable_reason: unavailableReason,
+        };
+    }
+}
 /**
  * Get merge request changes/diffs
  * MR 변경사항 조회 함수 (Function to retrieve merge request changes)
@@ -2402,13 +2955,61 @@ async function unapproveMergeRequest(projectId, mergeRequestIid) {
  */
 async function getMergeRequestApprovalState(projectId, mergeRequestIid) {
     projectId = decodeURIComponent(projectId);
-    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/approval_state`);
-    const response = await fetch(url.toString(), {
+    const approvalStateUrl = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/approval_state`);
+    const approvalStateResponse = await fetch(approvalStateUrl.toString(), {
         ...getFetchConfig(),
         method: "GET",
     });
-    await handleGitLabError(response);
-    return GitLabMergeRequestApprovalStateSchema.parse(await response.json());
+    if (approvalStateResponse.status === 404) {
+        return getMergeRequestApprovalsFallback(projectId, mergeRequestIid);
+    }
+    await handleGitLabError(approvalStateResponse);
+    const parsedApprovalState = GitLabMergeRequestApprovalStateSchema.parse(await approvalStateResponse.json());
+    const approvedByUsers = getUniqueApprovalUsers((parsedApprovalState.rules || []).flatMap(rule => rule.approved_by || []));
+    const approvedByUsernames = approvedByUsers.map(user => user.username);
+    return {
+        ...parsedApprovalState,
+        approved_by: approvedByUsers,
+        approved_by_usernames: approvedByUsernames,
+        source_endpoint: "approval_state",
+    };
+}
+async function getMergeRequestApprovalsFallback(projectId, mergeRequestIid) {
+    const approvalsUrl = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/approvals`);
+    const approvalsResponse = await fetch(approvalsUrl.toString(), {
+        ...getFetchConfig(),
+        method: "GET",
+    });
+    await handleGitLabError(approvalsResponse);
+    const parsedApprovals = GitLabMergeRequestApprovalsResponseSchema.parse(await approvalsResponse.json());
+    const approvedByUsers = getUniqueApprovalUsers((parsedApprovals.approved_by || []).map(approvedByEntry => approvedByEntry.user));
+    const approvedByUsernames = approvedByUsers.map(user => user.username);
+    return GitLabMergeRequestApprovalStateSchema.parse({
+        approved: parsedApprovals.approved,
+        user_has_approved: parsedApprovals.user_has_approved,
+        user_can_approve: parsedApprovals.user_can_approve,
+        approved_by: approvedByUsers,
+        approved_by_usernames: approvedByUsernames,
+        source_endpoint: "approvals",
+    });
+}
+function getUniqueApprovalUsers(users) {
+    const uniqueUsers = new Map();
+    for (const user of users) {
+        if (!uniqueUsers.has(user.id)) {
+            uniqueUsers.set(user.id, user);
+        }
+    }
+    return [...uniqueUsers.values()];
+}
+function inferMergeRequestApproved(rules) {
+    if (!rules || rules.length === 0) {
+        return null;
+    }
+    if (rules.some(rule => typeof rule.approved !== "boolean")) {
+        return null;
+    }
+    return rules.every(rule => rule.approved === true);
 }
 /**
  * Create a new note (comment) on an issue or merge request
@@ -2421,10 +3022,10 @@ async function getMergeRequestApprovalState(projectId, mergeRequestIid) {
  * @param {string} body - The content of the note
  * @returns {Promise<any>} The created note
  */
-async function createNote(projectId, noteableType, // 'issue' 또는 'merge_request' 타입 명시
+async function createNote(projectId, noteableType, // specifies 'issue' or 'merge_request' type
 noteableIid, body) {
     projectId = decodeURIComponent(projectId); // Decode project ID
-    // ⚙️ 응답 타입은 GitLab API 문서에 따라 조정 가능
+    // ⚙️ Response type can be adjusted according to the GitLab API documentation
     const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/${noteableType}s/${noteableIid}/notes` // Using plural form (issues/merge_requests) as per GitLab API documentation
     );
     const response = await fetch(url.toString(), {
@@ -2472,14 +3073,18 @@ async function listDraftNotes(projectId, mergeRequestIid) {
  * @param {string} projectId - The ID or URL-encoded path of the project
  * @param {number|string} mergeRequestIid - The internal ID of the merge request
  * @param {string} body - The content of the draft note
+ * @param {string} [inReplyToDiscussionId] - The ID of a discussion the draft note replies to
  * @param {MergeRequestThreadPosition} [position] - Position information for diff notes
  * @param {boolean} [resolveDiscussion] - Whether to resolve the discussion when publishing
  * @returns {Promise<GitLabDraftNote>} The created draft note
  */
-async function createDraftNote(projectId, mergeRequestIid, body, position, resolveDiscussion) {
+async function createDraftNote(projectId, mergeRequestIid, body, inReplyToDiscussionId, position, resolveDiscussion) {
     projectId = decodeURIComponent(projectId);
     const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/draft_notes`);
     const requestBody = { note: body };
+    if (inReplyToDiscussionId) {
+        requestBody.in_reply_to_discussion_id = inReplyToDiscussionId;
+    }
     if (position) {
         requestBody.position = position;
     }
@@ -3141,6 +3746,90 @@ async function getPipeline(projectId, pipelineId) {
     const data = await response.json();
     return GitLabPipelineSchema.parse(data);
 }
+/**
+ * List deployments in a GitLab project
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {ListDeploymentsOptions} options - Options for filtering deployments
+ * @returns {Promise<GitLabDeployment[]>} List of deployments
+ */
+async function listDeployments(projectId, options = {}) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/deployments`);
+    Object.entries(options).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.append(key, value.toString());
+        }
+    });
+    const response = await fetch(url.toString(), {
+        ...getFetchConfig(),
+    });
+    await handleGitLabError(response);
+    const data = await response.json();
+    return z.array(GitLabDeploymentSchema).parse(data);
+}
+/**
+ * Get details of a specific deployment
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {number | string} deploymentId - The ID of the deployment
+ * @returns {Promise<GitLabDeployment>} Deployment details
+ */
+async function getDeployment(projectId, deploymentId) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/deployments/${deploymentId}`);
+    const response = await fetch(url.toString(), {
+        ...getFetchConfig(),
+    });
+    if (response.status === 404) {
+        throw new Error(`Deployment not found`);
+    }
+    await handleGitLabError(response);
+    const data = await response.json();
+    return GitLabDeploymentSchema.parse(data);
+}
+/**
+ * List environments in a GitLab project
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {ListEnvironmentsOptions} options - Options for filtering environments
+ * @returns {Promise<GitLabEnvironment[]>} List of environments
+ */
+async function listEnvironments(projectId, options = {}) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/environments`);
+    Object.entries(options).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.append(key, value.toString());
+        }
+    });
+    const response = await fetch(url.toString(), {
+        ...getFetchConfig(),
+    });
+    await handleGitLabError(response);
+    const data = await response.json();
+    return z.array(GitLabEnvironmentSchema).parse(data);
+}
+/**
+ * Get details of a specific environment
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {number | string} environmentId - The ID of the environment
+ * @returns {Promise<GitLabEnvironment>} Environment details
+ */
+async function getEnvironment(projectId, environmentId) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/environments/${environmentId}`);
+    const response = await fetch(url.toString(), {
+        ...getFetchConfig(),
+    });
+    if (response.status === 404) {
+        throw new Error(`Environment not found`);
+    }
+    await handleGitLabError(response);
+    const data = await response.json();
+    return GitLabEnvironmentSchema.parse(data);
+}
 /**
  * List all jobs in a specific pipeline
  *
@@ -3265,21 +3954,107 @@ async function getPipelineJobOutput(projectId, jobId, limit, offset) {
     }
     return fullTrace;
 }
+/**
+ * List artifact files in a job's artifacts archive
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {string} jobId - The ID of the job
+ * @param {Object} options - Options for listing artifacts
+ * @returns {Promise<GitLabArtifactEntry[]>} List of artifact entries
+ */
+async function listJobArtifacts(projectId, jobId, options = {}) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/jobs/${jobId}/artifacts/tree`);
+    Object.entries(options).forEach(([key, value]) => {
+        if (value !== undefined) {
+            if (typeof value === "boolean") {
+                url.searchParams.append(key, value ? "true" : "false");
+            }
+            else {
+                url.searchParams.append(key, value.toString());
+            }
+        }
+    });
+    const response = await fetch(url.toString(), {
+        ...getFetchConfig(),
+    });
+    if (response.status === 404) {
+        throw new Error(`Job artifacts not found. The job may not have produced artifacts or the job ID is invalid.`);
+    }
+    await handleGitLabError(response);
+    const data = await response.json();
+    return z.array(GitLabArtifactEntrySchema).parse(data);
+}
+/**
+ * Download the entire artifact archive for a job and save to disk
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {string} jobId - The ID of the job
+ * @param {string} localPath - Optional local directory to save the archive
+ * @returns {Promise<string>} The path where the artifact archive was saved
+ */
+async function downloadJobArtifacts(projectId, jobId, localPath) {
+    projectId = decodeURIComponent(projectId);
+    const effectiveProjectId = getEffectiveProjectId(projectId);
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(effectiveProjectId)}/jobs/${jobId}/artifacts`);
+    const response = await fetch(url.toString(), {
+        ...getFetchConfig(),
+    });
+    if (response.status === 404) {
+        throw new Error(`Job artifacts not found. The job may not have produced artifacts or the job ID is invalid.`);
+    }
+    await handleGitLabError(response);
+    const buffer = await response.arrayBuffer();
+    const filename = `artifacts_job_${jobId}.zip`;
+    const savePath = localPath ? path.join(localPath, filename) : filename;
+    fs.mkdirSync(path.dirname(savePath), { recursive: true });
+    fs.writeFileSync(savePath, Buffer.from(buffer));
+    return savePath;
+}
+/**
+ * Download a single file from a job's artifacts
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {string} jobId - The ID of the job
+ * @param {string} artifactPath - Path to the file within the artifacts archive
+ * @returns {Promise<string>} The file content as text
+ */
+async function getJobArtifactFile(projectId, jobId, artifactPath) {
+    projectId = decodeURIComponent(projectId);
+    const effectiveProjectId = getEffectiveProjectId(projectId);
+    const encodedArtifactPath = artifactPath
+        .split("/")
+        .map(segment => encodeURIComponent(segment))
+        .join("/");
+    const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(effectiveProjectId)}/jobs/${jobId}/artifacts/${encodedArtifactPath}`);
+    const response = await fetch(url.toString(), {
+        ...getFetchConfig(),
+    });
+    if (response.status === 404) {
+        throw new Error(`Artifact file not found: ${artifactPath}`);
+    }
+    await handleGitLabError(response);
+    return await response.text();
+}
 /**
  * Create a new pipeline
  *
  * @param {string} projectId - The ID or URL-encoded path of the project
  * @param {string} ref - The branch or tag to run the pipeline on
  * @param {Array} variables - Optional variables for the pipeline
+ * @param {Record<string, string>} inputs - Optional input parameters for the pipeline
  * @returns {Promise<GitLabPipeline>} The created pipeline
  */
-async function createPipeline(projectId, ref, variables) {
+async function createPipeline(projectId, ref, variables, inputs) {
     projectId = decodeURIComponent(projectId); // Decode project ID
     const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/pipeline`);
     const body = { ref };
     if (variables && variables.length > 0) {
         body.variables = variables;
     }
+    if (inputs && Object.keys(inputs).length > 0) {
+        body.inputs = inputs;
+    }
     const response = await fetch(url.toString(), {
         method: "POST",
         headers: {
@@ -3902,6 +4677,20 @@ async function markdownUpload(projectId, filePath) {
     const data = await response.json();
     return GitLabMarkdownUploadSchema.parse(data);
 }
+const IMAGE_MIME_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    ".ico": "image/x-icon",
+};
+function getImageMimeType(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return IMAGE_MIME_TYPES[ext] ?? null;
+}
 async function downloadAttachment(projectId, secret, filename, localPath) {
     const effectiveProjectId = getEffectiveProjectId(projectId);
     const url = new URL(`${getEffectiveApiUrl()}/projects/${encodeURIComponent(effectiveProjectId)}/uploads/${secret}/${filename}`);
@@ -3916,12 +4705,33 @@ async function downloadAttachment(projectId, secret, filename, localPath) {
         await handleGitLabError(response);
     }
     // Get the file content as buffer
-    const buffer = await response.arrayBuffer();
-    // Determine the save path
-    const savePath = localPath ? path.join(localPath, filename) : filename;
-    // Write the file to disk
-    fs.writeFileSync(savePath, Buffer.from(buffer));
-    return savePath;
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const mimeType = getImageMimeType(filename);
+    // For non-image files, always save to disk.
+    // For image files, only save to disk if local_path is explicitly provided.
+    if (!mimeType || localPath) {
+        let savePath;
+        if (localPath) {
+            const normalizedLocalPath = path.normalize(localPath);
+            if (path.isAbsolute(normalizedLocalPath) ||
+                normalizedLocalPath === ".." ||
+                normalizedLocalPath.startsWith(".." + path.sep) ||
+                normalizedLocalPath.includes(path.sep + ".." + path.sep)) {
+                throw new Error("Invalid local_path: directory traversal is not allowed.");
+            }
+            savePath = path.join(normalizedLocalPath, filename);
+        }
+        else {
+            savePath = filename;
+        }
+        const dir = path.dirname(savePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(savePath, buffer);
+        return { buffer, filename, mimeType, savedPath: savePath };
+    }
+    return { buffer, filename, mimeType };
 }
 /**
  * List all events for the currently authenticated user
@@ -4147,6 +4957,8 @@ async function handleToolCall(params) {
         if (GITLAB_AUTH_COOKIE_PATH) {
             await ensureSessionForRequest();
         }
+        // Lazy OAuth token refresh: only validate/refresh when a tool is actually called
+        await ensureValidOAuthToken();
         logger.info(params.name);
         switch (params.name) {
             case "execute_graphql": {
@@ -4375,8 +5187,22 @@ async function handleToolCall(params) {
             case "get_merge_request": {
                 const args = GetMergeRequestSchema.parse(params.arguments);
                 const mergeRequest = await getMergeRequest(args.project_id, args.merge_request_iid, args.source_branch);
+                const deploymentSummary = await buildMergeRequestDeploymentSummary(args.project_id, mergeRequest);
+                const commitAdditionSummary = await buildMergeRequestCommitAdditionSummary(args.project_id, mergeRequest);
+                const approvalSummary = await buildMergeRequestApprovalSummary(args.project_id, mergeRequest.iid);
+                const mergeRequestWithDeploymentSummary = {
+                    ...mergeRequest,
+                    deployment_summary: deploymentSummary,
+                    commit_addition_summary: commitAdditionSummary,
+                    approval_summary: approvalSummary,
+                };
                 return {
-                    content: [{ type: "text", text: JSON.stringify(mergeRequest, null, 2) }],
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(mergeRequestWithDeploymentSummary, null, 2),
+                        },
+                    ],
                 };
             }
             case "get_merge_request_diffs": {
@@ -4573,8 +5399,8 @@ async function handleToolCall(params) {
             }
             case "create_draft_note": {
                 const args = CreateDraftNoteSchema.parse(params.arguments);
-                const { project_id, merge_request_iid, body, position, resolve_discussion } = args;
-                const draftNote = await createDraftNote(project_id, merge_request_iid, body, position, resolve_discussion);
+                const { project_id, merge_request_iid, body, in_reply_to_discussion_id, position, resolve_discussion } = args;
+                const draftNote = await createDraftNote(project_id, merge_request_iid, body, in_reply_to_discussion_id, position, resolve_discussion);
                 return {
                     content: [{ type: "text", text: JSON.stringify(draftNote, null, 2) }],
                 };
@@ -4835,6 +5661,36 @@ async function handleToolCall(params) {
                     ],
                 };
             }
+            case "list_deployments": {
+                const args = ListDeploymentsSchema.parse(params.arguments);
+                const { project_id, ...options } = args;
+                const deployments = await listDeployments(project_id, options);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(deployments, null, 2) }],
+                };
+            }
+            case "get_deployment": {
+                const { project_id, deployment_id } = GetDeploymentSchema.parse(params.arguments);
+                const deployment = await getDeployment(project_id, deployment_id);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(deployment, null, 2) }],
+                };
+            }
+            case "list_environments": {
+                const args = ListEnvironmentsSchema.parse(params.arguments);
+                const { project_id, ...options } = args;
+                const environments = await listEnvironments(project_id, options);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(environments, null, 2) }],
+                };
+            }
+            case "get_environment": {
+                const { project_id, environment_id } = GetEnvironmentSchema.parse(params.arguments);
+                const environment = await getEnvironment(project_id, environment_id);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(environment, null, 2) }],
+                };
+            }
             case "list_pipeline_jobs": {
                 const { project_id, pipeline_id, ...options } = ListPipelineJobsSchema.parse(params.arguments);
                 const jobs = await listPipelineJobs(project_id, pipeline_id, options);
@@ -4884,8 +5740,8 @@ async function handleToolCall(params) {
                 };
             }
             case "create_pipeline": {
-                const { project_id, ref, variables } = CreatePipelineSchema.parse(params.arguments);
-                const pipeline = await createPipeline(project_id, ref, variables);
+                const { project_id, ref, variables, inputs } = CreatePipelineSchema.parse(params.arguments);
+                const pipeline = await createPipeline(project_id, ref, variables, inputs);
                 return {
                     content: [
                         {
@@ -4955,6 +5811,42 @@ async function handleToolCall(params) {
                     ],
                 };
             }
+            case "list_job_artifacts": {
+                const { project_id, job_id, ...options } = ListJobArtifactsSchema.parse(params.arguments);
+                const artifacts = await listJobArtifacts(project_id, job_id, options);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(artifacts, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "download_job_artifacts": {
+                const { project_id, job_id, local_path } = DownloadJobArtifactsSchema.parse(params.arguments);
+                const filePath = await downloadJobArtifacts(project_id, job_id, local_path);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({ success: true, file_path: filePath }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "get_job_artifact_file": {
+                const { project_id, job_id, artifact_path } = GetJobArtifactFileSchema.parse(params.arguments);
+                const fileContent = await getJobArtifactFile(project_id, job_id, artifact_path);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: fileContent,
+                        },
+                    ],
+                };
+            }
             case "list_merge_requests": {
                 const args = ListMergeRequestsSchema.parse(params.arguments);
                 const mergeRequests = await listMergeRequests(args.project_id, args);
@@ -5110,10 +6002,26 @@ async function handleToolCall(params) {
             }
             case "download_attachment": {
                 const args = DownloadAttachmentSchema.parse(params.arguments);
-                const filePath = await downloadAttachment(args.project_id, args.secret, args.filename, args.local_path);
+                const result = await downloadAttachment(args.project_id, args.secret, args.filename, args.local_path);
+                if (result.mimeType && !args.local_path) {
+                    // Return image inline as base64 so the AI can see it
+                    const base64 = result.buffer.toString("base64");
+                    return {
+                        content: [
+                            { type: "image", data: base64, mimeType: result.mimeType },
+                            {
+                                type: "text",
+                                text: JSON.stringify({ filename: result.filename, mimeType: result.mimeType }, null, 2),
+                            },
+                        ],
+                    };
+                }
                 return {
                     content: [
-                        { type: "text", text: JSON.stringify({ success: true, file_path: filePath }, null, 2) },
+                        {
+                            type: "text",
+                            text: JSON.stringify({ success: true, file_path: result.savedPath }, null, 2),
+                        },
                     ],
                 };
             }
@@ -5685,9 +6593,10 @@ async function runServer() {
             logger.info("Using OAuth authentication...");
             try {
                 const gitlabBaseUrl = GITLAB_API_URL.replace(/\/api\/v4$/, "");
-                OAUTH_ACCESS_TOKEN = await initializeOAuth(gitlabBaseUrl);
+                const oauthResult = await initializeOAuthClient(gitlabBaseUrl);
+                oauthClient = oauthResult.client;
+                OAUTH_ACCESS_TOKEN = oauthResult.accessToken;
                 logger.info("OAuth authentication successful");
-                // Note: Headers are automatically generated by buildAuthHeaders() using OAUTH_ACCESS_TOKEN
             }
             catch (error) {
                 logger.error("OAuth authentication failed:", error);