@zereight/mcp-gitlab 1.0.75 → 1.0.77

package/build/index.js

@@ -1,40 +1,41 @@
 #!/usr/bin/env node
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import nodeFetch from "node-fetch";
+import express from "express";
 import fetchCookie from "fetch-cookie";
-import { CookieJar, parse as parseCookie } from "tough-cookie";
-import { SocksProxyAgent } from "socks-proxy-agent";
-import { HttpsProxyAgent } from "https-proxy-agent";
+import fs from "fs";
 import { HttpProxyAgent } from "http-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import nodeFetch from "node-fetch";
+import path, { dirname } from "path";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { CookieJar, parse as parseCookie } from "tough-cookie";
+import { fileURLToPath } from "url";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { fileURLToPath } from "url";
-import { dirname } from "path";
-import fs from "fs";
-import path from "path";
-import express from "express";
 // Add type imports for proxy agents
 import { Agent } from "http";
 import { Agent as HttpsAgent } from "https";
 import { URL } from "url";
-import { GitLabForkSchema, GitLabReferenceSchema, GitLabRepositorySchema, GitLabIssueSchema, GitLabMergeRequestSchema, GitLabContentSchema, GitLabCreateUpdateFileResponseSchema, GitLabSearchResponseSchema, GitLabTreeSchema, GitLabCommitSchema, GitLabNamespaceSchema, GitLabNamespaceExistsResponseSchema, GitLabProjectSchema, GitLabUserSchema, GitLabUsersResponseSchema, GetUsersSchema, CreateOrUpdateFileSchema, SearchRepositoriesSchema, CreateRepositorySchema, GetFileContentsSchema, PushFilesSchema, CreateIssueSchema, CreateMergeRequestSchema, ForkRepositorySchema, CreateBranchSchema, GitLabDiffSchema, GetMergeRequestSchema, GetMergeRequestDiffsSchema, UpdateMergeRequestSchema, ListIssuesSchema, GetIssueSchema, UpdateIssueSchema, DeleteIssueSchema, GitLabIssueLinkSchema, GitLabIssueWithLinkDetailsSchema, ListIssueLinksSchema, ListIssueDiscussionsSchema, GetIssueLinkSchema, CreateIssueLinkSchema, DeleteIssueLinkSchema, ListNamespacesSchema, GetNamespaceSchema, VerifyNamespaceSchema, GetProjectSchema, ListProjectsSchema, ListLabelsSchema, GetLabelSchema, CreateLabelSchema, UpdateLabelSchema, DeleteLabelSchema, CreateNoteSchema, CreateMergeRequestThreadSchema, ListGroupProjectsSchema, ListWikiPagesSchema, GetWikiPageSchema, CreateWikiPageSchema, UpdateWikiPageSchema, DeleteWikiPageSchema, GitLabWikiPageSchema, GetRepositoryTreeSchema, GitLabTreeItemSchema, GitLabPipelineSchema, GetPipelineSchema, ListPipelinesSchema, ListPipelineJobsSchema, CreatePipelineSchema, RetryPipelineSchema, CancelPipelineSchema, 
+import { BulkPublishDraftNotesSchema, CancelPipelineSchema, CreateBranchSchema, CreateDraftNoteSchema, CreateIssueLinkSchema, CreateIssueNoteSchema, CreateIssueSchema, CreateLabelSchema, // Added
+CreateMergeRequestNoteSchema, CreateMergeRequestSchema, CreateMergeRequestThreadSchema, CreateNoteSchema, CreateOrUpdateFileSchema, CreatePipelineSchema, CreateProjectMilestoneSchema, CreateRepositorySchema, CreateWikiPageSchema, DeleteDraftNoteSchema, DeleteIssueLinkSchema, DeleteIssueSchema, DeleteLabelSchema, DeleteProjectMilestoneSchema, DeleteWikiPageSchema, EditProjectMilestoneSchema, ForkRepositorySchema, GetBranchDiffsSchema, GetCommitDiffSchema, GetCommitSchema, GetDraftNoteSchema, GetFileContentsSchema, GetIssueLinkSchema, GetIssueSchema, GetLabelSchema, GetMergeRequestDiffsSchema, GetMergeRequestSchema, GetMilestoneBurndownEventsSchema, GetMilestoneIssuesSchema, GetMilestoneMergeRequestsSchema, GetNamespaceSchema, 
 // pipeline job schemas
-GetPipelineJobOutputSchema, GitLabPipelineJobSchema, 
+GetPipelineJobOutputSchema, GetPipelineSchema, GetProjectMilestoneSchema, GetProjectSchema, GetRepositoryTreeSchema, GetUsersSchema, GetWikiPageSchema, GitLabCommitSchema, GitLabCompareResultSchema, GitLabContentSchema, GitLabCreateUpdateFileResponseSchema, GitLabDiffSchema, 
 // Discussion Schemas
 GitLabDiscussionNoteSchema, // Added
-GitLabDiscussionSchema, PaginatedDiscussionsResponseSchema, UpdateMergeRequestNoteSchema, // Added
-CreateMergeRequestNoteSchema, // Added
-ListMergeRequestDiscussionsSchema, UpdateIssueNoteSchema, CreateIssueNoteSchema, ListMergeRequestsSchema, GitLabMilestonesSchema, ListProjectMilestonesSchema, GetProjectMilestoneSchema, CreateProjectMilestoneSchema, EditProjectMilestoneSchema, DeleteProjectMilestoneSchema, GetMilestoneIssuesSchema, GetMilestoneMergeRequestsSchema, PromoteProjectMilestoneSchema, GetMilestoneBurndownEventsSchema, GitLabCompareResultSchema, GetBranchDiffsSchema, ListCommitsSchema, GetCommitSchema, GetCommitDiffSchema, ListMergeRequestDiffsSchema, } from "./schemas.js";
+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, ListNamespacesSchema, ListPipelineJobsSchema, ListPipelinesSchema, ListPipelineTriggerJobsSchema, ListProjectMembersSchema, ListProjectMilestonesSchema, ListProjectsSchema, ListWikiPagesSchema, MarkdownUploadSchema, DownloadAttachmentSchema, MergeMergeRequestSchema, MyIssuesSchema, PaginatedDiscussionsResponseSchema, PromoteProjectMilestoneSchema, PublishDraftNoteSchema, PushFilesSchema, RetryPipelineSchema, SearchRepositoriesSchema, UpdateDraftNoteSchema, UpdateIssueNoteSchema, UpdateIssueSchema, UpdateLabelSchema, UpdateMergeRequestNoteSchema, UpdateMergeRequestSchema, UpdateWikiPageSchema, VerifyNamespaceSchema } from "./schemas.js";
 import { randomUUID } from "crypto";
-import { pino } from 'pino';
+import { pino } from "pino";
 const logger = pino({
-    level: process.env.LOG_LEVEL || 'info',
+    level: process.env.LOG_LEVEL || "info",
     transport: {
-        target: 'pino-pretty',
+        target: "pino-pretty",
         options: {
             colorize: true,
             levelFirst: true,
@@ -84,7 +85,7 @@ const USE_MILESTONE = process.env.USE_MILESTONE === "true";
 const USE_PIPELINE = process.env.USE_PIPELINE === "true";
 const SSE = process.env.SSE === "true";
 const STREAMABLE_HTTP = process.env.STREAMABLE_HTTP === "true";
-const HOST = process.env.HOST || '0.0.0.0';
+const HOST = process.env.HOST || "0.0.0.0";
 const PORT = process.env.PORT || 3002;
 // Add proxy configuration
 const HTTP_PROXY = process.env.HTTP_PROXY;
@@ -172,13 +173,13 @@ async function ensureSessionForRequest() {
     const baseUrl = `${apiUrl.protocol}//${apiUrl.hostname}`;
     // Check if we already have GitLab session cookies
     const gitlabCookies = cookieJar.getCookiesSync(baseUrl);
-    const hasSessionCookie = gitlabCookies.some(cookie => cookie.key === '_gitlab_session' || cookie.key === 'remember_user_token');
+    const hasSessionCookie = gitlabCookies.some(cookie => cookie.key === "_gitlab_session" || cookie.key === "remember_user_token");
     if (!hasSessionCookie) {
         try {
             // Establish session with a lightweight request
             await fetch(`${GITLAB_API_URL}/user`, {
                 ...DEFAULT_FETCH_CONFIG,
-                redirect: 'follow'
+                redirect: "follow",
             }).catch(() => {
                 // Ignore errors - the important thing is that cookies get set during redirects
             });
@@ -213,6 +214,11 @@ const DEFAULT_FETCH_CONFIG = {
 };
 // Define all available tools
 const allTools = [
+    {
+        name: "merge_merge_request",
+        description: "Merge a merge request in a GitLab project",
+        inputSchema: zodToJsonSchema(MergeMergeRequestSchema),
+    },
     {
         name: "create_or_update_file",
         description: "Create or update a single file in a GitLab project",
@@ -308,6 +314,41 @@ const allTools = [
         description: "Add a new note to an existing merge request thread",
         inputSchema: zodToJsonSchema(CreateMergeRequestNoteSchema),
     },
+    {
+        name: "get_draft_note",
+        description: "Get a single draft note from a merge request",
+        inputSchema: zodToJsonSchema(GetDraftNoteSchema),
+    },
+    {
+        name: "list_draft_notes",
+        description: "List draft notes for a merge request",
+        inputSchema: zodToJsonSchema(ListDraftNotesSchema),
+    },
+    {
+        name: "create_draft_note",
+        description: "Create a draft note for a merge request",
+        inputSchema: zodToJsonSchema(CreateDraftNoteSchema),
+    },
+    {
+        name: "update_draft_note",
+        description: "Update an existing draft note",
+        inputSchema: zodToJsonSchema(UpdateDraftNoteSchema),
+    },
+    {
+        name: "delete_draft_note",
+        description: "Delete a draft note",
+        inputSchema: zodToJsonSchema(DeleteDraftNoteSchema),
+    },
+    {
+        name: "publish_draft_note",
+        description: "Publish a single draft note",
+        inputSchema: zodToJsonSchema(PublishDraftNoteSchema),
+    },
+    {
+        name: "bulk_publish_draft_notes",
+        description: "Publish all draft notes for a merge request",
+        inputSchema: zodToJsonSchema(BulkPublishDraftNotesSchema),
+    },
     {
         name: "update_issue_note",
         description: "Modify an existing issue thread note",
@@ -323,6 +364,11 @@ const allTools = [
         description: "List issues (default: created by current user only; use scope='all' for all accessible issues)",
         inputSchema: zodToJsonSchema(ListIssuesSchema),
     },
+    {
+        name: "my_issues",
+        description: "List issues assigned to the authenticated user (defaults to open issues)",
+        inputSchema: zodToJsonSchema(MyIssuesSchema),
+    },
     {
         name: "get_issue",
         description: "Get details of a specific issue in a GitLab project",
@@ -388,6 +434,11 @@ const allTools = [
         description: "List projects accessible by the current user",
         inputSchema: zodToJsonSchema(ListProjectsSchema),
     },
+    {
+        name: "list_project_members",
+        description: "List members of a GitLab project",
+        inputSchema: zodToJsonSchema(ListProjectMembersSchema),
+    },
     {
         name: "list_labels",
         description: "List labels for a project",
@@ -463,6 +514,11 @@ const allTools = [
         description: "List all jobs in a specific pipeline",
         inputSchema: zodToJsonSchema(ListPipelineJobsSchema),
     },
+    {
+        name: "list_pipeline_trigger_jobs",
+        description: "List all trigger jobs (bridges) in a specific pipeline that trigger downstream pipelines",
+        inputSchema: zodToJsonSchema(ListPipelineTriggerJobsSchema),
+    },
     {
         name: "get_pipeline_job",
         description: "Get details of a GitLab pipeline job number",
@@ -558,6 +614,21 @@ const allTools = [
         description: "Get changes/diffs of a specific commit",
         inputSchema: zodToJsonSchema(GetCommitDiffSchema),
     },
+    {
+        name: "list_group_iterations",
+        description: "List group iterations with filtering options",
+        inputSchema: zodToJsonSchema(ListGroupIterationsSchema),
+    },
+    {
+        name: "upload_markdown",
+        description: "Upload a file to a GitLab project for use in markdown content",
+        inputSchema: zodToJsonSchema(MarkdownUploadSchema),
+    },
+    {
+        name: "download_attachment",
+        description: "Download an uploaded file from a GitLab project by secret and filename",
+        inputSchema: zodToJsonSchema(DownloadAttachmentSchema),
+    },
 ];
 // Define which tools are read-only
 const readOnlyTools = [
@@ -568,6 +639,7 @@ const readOnlyTools = [
     "get_branch_diffs",
     "mr_discussions",
     "list_issues",
+    "my_issues",
     "list_merge_requests",
     "get_issue",
     "list_issue_links",
@@ -577,12 +649,14 @@ const readOnlyTools = [
     "get_namespace",
     "verify_namespace",
     "get_project",
+    "list_projects",
+    "list_project_members",
     "get_pipeline",
     "list_pipelines",
     "list_pipeline_jobs",
+    "list_pipeline_trigger_jobs",
     "get_pipeline_job",
     "get_pipeline_job_output",
-    "list_projects",
     "list_labels",
     "get_label",
     "list_group_projects",
@@ -598,6 +672,9 @@ const readOnlyTools = [
     "list_commits",
     "get_commit",
     "get_commit_diff",
+    "list_group_iterations",
+    "get_group_iteration",
+    "download_attachment",
 ];
 // Define which tools are related to wiki and can be toggled by USE_GITLAB_WIKI
 const wikiToolNames = [
@@ -625,6 +702,7 @@ const pipelineToolNames = [
     "list_pipelines",
     "get_pipeline",
     "list_pipeline_jobs",
+    "list_pipeline_trigger_jobs",
     "get_pipeline_job",
     "get_pipeline_job_output",
     "create_pipeline",
@@ -653,6 +731,7 @@ function normalizeGitLabApiUrl(url) {
 // Use the normalizeGitLabApiUrl function to handle various URL formats
 const GITLAB_API_URL = normalizeGitLabApiUrl(process.env.GITLAB_API_URL || "");
 const GITLAB_PROJECT_ID = process.env.GITLAB_PROJECT_ID;
+const GITLAB_ALLOWED_PROJECT_IDS = process.env.GITLAB_ALLOWED_PROJECT_IDS?.split(',').map(id => id.trim()).filter(Boolean) || [];
 if (!GITLAB_PERSONAL_ACCESS_TOKEN) {
     logger.error("GITLAB_PERSONAL_ACCESS_TOKEN environment variable is not set");
     process.exit(1);
@@ -682,8 +761,24 @@ async function handleGitLabError(response) {
 /**
  * @param {string} projectId - The project ID parameter passed to the function
  * @returns {string} The project ID to use for the API call
+ * @throws {Error} If GITLAB_ALLOWED_PROJECT_IDS is set and the requested project is not in the whitelist
  */
 function getEffectiveProjectId(projectId) {
+    if (GITLAB_ALLOWED_PROJECT_IDS.length > 0) {
+        // If there's only one allowed project, use it as default
+        if (GITLAB_ALLOWED_PROJECT_IDS.length === 1 && !projectId) {
+            return GITLAB_ALLOWED_PROJECT_IDS[0];
+        }
+        // If a project ID is provided, check if it's in the whitelist
+        if (projectId && !GITLAB_ALLOWED_PROJECT_IDS.includes(projectId)) {
+            throw new Error(`Access denied: Project ${projectId} is not in the allowed project list: ${GITLAB_ALLOWED_PROJECT_IDS.join(', ')}`);
+        }
+        // If no project ID provided but we have multiple allowed projects, require an explicit choice
+        if (!projectId && GITLAB_ALLOWED_PROJECT_IDS.length > 1) {
+            throw new Error(`Multiple projects allowed (${GITLAB_ALLOWED_PROJECT_IDS.join(', ')}). Please specify a project ID.`);
+        }
+        return projectId || GITLAB_ALLOWED_PROJECT_IDS[0];
+    }
     return GITLAB_PROJECT_ID || projectId;
 }
 /**
@@ -1616,6 +1711,26 @@ async function updateMergeRequest(projectId, options, mergeRequestIid, branchNam
     await handleGitLabError(response);
     return GitLabMergeRequestSchema.parse(await response.json());
 }
+/**
+ * Merge a merge request
+ * マージリクエストをマージする
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {number} mergeRequestIid - The internal ID of the merge request
+ * @param {Object} options - Options for merging the merge request
+ * @returns {Promise<GitLabMergeRequest>} The merged merge request
+ */
+async function mergeMergeRequest(projectId, options, mergeRequestIid) {
+    projectId = decodeURIComponent(projectId); // Decode project ID
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/merge`);
+    const response = await fetch(url.toString(), {
+        ...DEFAULT_FETCH_CONFIG,
+        method: "PUT",
+        body: JSON.stringify(options),
+    });
+    await handleGitLabError(response);
+    return GitLabMergeRequestSchema.parse(await response.json());
+}
 /**
  * Create a new note (comment) on an issue or merge request
  * 📦 새로운 함수: createNote - 이슈 또는 병합 요청에 노트(댓글)를 추가하는 함수
@@ -1644,6 +1759,208 @@ noteableIid, body) {
     }
     return await response.json();
 }
+/**
+ * List draft notes for a merge request
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {number|string} mergeRequestIid - The internal ID of the merge request
+ * @returns {Promise<GitLabDraftNote[]>} Array of draft notes
+ */
+async function getDraftNote(project_id, merge_request_iid, draft_note_id) {
+    const response = await fetch(`/projects/${encodeURIComponent(project_id)}/merge_requests/${merge_request_iid}/draft_notes/${draft_note_id}`);
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+    const data = await response.json();
+    return GitLabDraftNoteSchema.parse(data);
+}
+async function listDraftNotes(projectId, mergeRequestIid) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/draft_notes`);
+    const response = await fetch(url.toString(), {
+        ...DEFAULT_FETCH_CONFIG,
+        method: "GET",
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+    const data = await response.json();
+    return z.array(GitLabDraftNoteSchema).parse(data);
+}
+/**
+ * Create a draft note for a merge request
+ * @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 {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) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/draft_notes`);
+    const requestBody = { note: body };
+    if (position) {
+        requestBody.position = position;
+    }
+    if (resolveDiscussion !== undefined) {
+        requestBody.resolve_discussion = resolveDiscussion;
+    }
+    const response = await fetch(url.toString(), {
+        ...DEFAULT_FETCH_CONFIG,
+        method: "POST",
+        body: JSON.stringify(requestBody),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+    const data = await response.json();
+    return GitLabDraftNoteSchema.parse(data);
+}
+/**
+ * Update an existing draft note
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {number|string} mergeRequestIid - The internal ID of the merge request
+ * @param {number|string} draftNoteId - The ID of the draft note
+ * @param {string} [body] - The updated content of the draft note
+ * @param {MergeRequestThreadPosition} [position] - Updated position information
+ * @param {boolean} [resolveDiscussion] - Whether to resolve the discussion when publishing
+ * @returns {Promise<GitLabDraftNote>} The updated draft note
+ */
+async function updateDraftNote(projectId, mergeRequestIid, draftNoteId, body, position, resolveDiscussion) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/draft_notes/${draftNoteId}`);
+    const requestBody = {};
+    if (body !== undefined) {
+        requestBody.note = body;
+    }
+    if (position) {
+        requestBody.position = position;
+    }
+    if (resolveDiscussion !== undefined) {
+        requestBody.resolve_discussion = resolveDiscussion;
+    }
+    const response = await fetch(url.toString(), {
+        ...DEFAULT_FETCH_CONFIG,
+        method: "PUT",
+        body: JSON.stringify(requestBody),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+    const data = await response.json();
+    return GitLabDraftNoteSchema.parse(data);
+}
+/**
+ * Delete a draft note
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {number|string} mergeRequestIid - The internal ID of the merge request
+ * @param {number|string} draftNoteId - The ID of the draft note
+ * @returns {Promise<void>}
+ */
+async function deleteDraftNote(projectId, mergeRequestIid, draftNoteId) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/draft_notes/${draftNoteId}`);
+    const response = await fetch(url.toString(), {
+        ...DEFAULT_FETCH_CONFIG,
+        method: "DELETE",
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+}
+/**
+ * Publish a single draft note
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {number|string} mergeRequestIid - The internal ID of the merge request
+ * @param {number|string} draftNoteId - The ID of the draft note
+ * @returns {Promise<GitLabDiscussionNote>} The published note
+ */
+async function publishDraftNote(projectId, mergeRequestIid, draftNoteId) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/draft_notes/${draftNoteId}/publish`);
+    const response = await fetch(url.toString(), {
+        ...DEFAULT_FETCH_CONFIG,
+        method: "PUT",
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+    // Handle empty response (204 No Content) or successful response
+    const responseText = await response.text();
+    if (!responseText || responseText.trim() === '') {
+        // Return a success indicator for empty responses
+        return {
+            id: draftNoteId.toString(),
+            body: "Draft note published successfully",
+            author: { id: "unknown", username: "unknown" },
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            system: false,
+            noteable_id: mergeRequestIid.toString(),
+            noteable_type: "MergeRequest"
+        };
+    }
+    try {
+        const data = JSON.parse(responseText);
+        return GitLabDiscussionNoteSchema.parse(data);
+    }
+    catch (parseError) {
+        // If JSON parsing fails but the operation was successful (2xx status),
+        // return a success indicator
+        console.warn(`JSON parse error for successful publish operation: ${parseError}`);
+        return {
+            id: draftNoteId.toString(),
+            body: "Draft note published successfully (response parse error)",
+            author: { id: "unknown", username: "unknown" },
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            system: false,
+            noteable_id: mergeRequestIid.toString(),
+            noteable_type: "MergeRequest"
+        };
+    }
+}
+/**
+ * Publish all draft notes for a merge request
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {number|string} mergeRequestIid - The internal ID of the merge request
+ * @returns {Promise<GitLabDiscussionNote[]>} Array of published notes
+ */
+async function bulkPublishDraftNotes(projectId, mergeRequestIid) {
+    projectId = decodeURIComponent(projectId);
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/merge_requests/${mergeRequestIid}/draft_notes/bulk_publish`);
+    const response = await fetch(url.toString(), {
+        ...DEFAULT_FETCH_CONFIG,
+        method: "POST", // Changed from PUT to POST
+        body: JSON.stringify({}), // Send empty body for POST request
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GitLab API error: ${response.status} ${response.statusText}\n${errorText}`);
+    }
+    // Handle empty response (204 No Content) or successful response
+    const responseText = await response.text();
+    if (!responseText || responseText.trim() === '') {
+        // Return empty array for successful bulk publish with no content
+        return [];
+    }
+    try {
+        const data = JSON.parse(responseText);
+        return z.array(GitLabDiscussionNoteSchema).parse(data);
+    }
+    catch (parseError) {
+        // If JSON parsing fails but the operation was successful (2xx status),
+        // return empty array indicating successful bulk publish
+        console.warn(`JSON parse error for successful bulk publish operation: ${parseError}`);
+        return [];
+    }
+}
 /**
  * Create a new thread on a merge request
  * 📦 새로운 함수: createMergeRequestThread - 병합 요청에 새로운 스레드(토론)를 생성하는 함수
@@ -2123,6 +2440,38 @@ async function listPipelineJobs(projectId, pipelineId, options = {}) {
     const data = await response.json();
     return z.array(GitLabPipelineJobSchema).parse(data);
 }
+/**
+ * List all trigger jobs (bridges) in a specific pipeline
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {number} pipelineId - The ID of the pipeline
+ * @param {Object} options - Options for filtering trigger jobs
+ * @returns {Promise<GitLabPipelineTriggerJob[]>} List of pipeline trigger jobs
+ */
+async function listPipelineTriggerJobs(projectId, pipelineId, options = {}) {
+    projectId = decodeURIComponent(projectId); // Decode project ID
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/pipelines/${pipelineId}/bridges`);
+    // Add all query parameters
+    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(), {
+        ...DEFAULT_FETCH_CONFIG,
+    });
+    if (response.status === 404) {
+        throw new Error(`Pipeline not found`);
+    }
+    await handleGitLabError(response);
+    const data = await response.json();
+    return z.array(GitLabPipelineTriggerJobSchema).parse(data);
+}
 async function getPipelineJob(projectId, jobId) {
     projectId = decodeURIComponent(projectId); // Decode project ID
     const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(getEffectiveProjectId(projectId))}/jobs/${jobId}`);
@@ -2162,14 +2511,14 @@ async function getPipelineJobOutput(projectId, jobId, limit, offset) {
     const fullTrace = await response.text();
     // Apply client-side pagination to limit context window usage
     if (limit !== undefined || offset !== undefined) {
-        const lines = fullTrace.split('\n');
+        const lines = fullTrace.split("\n");
         const startOffset = offset || 0;
         const maxLines = limit || 1000;
         // Return lines from the end, skipping offset lines and limiting to maxLines
         const startIndex = Math.max(0, lines.length - startOffset - maxLines);
         const endIndex = lines.length - startOffset;
         const selectedLines = lines.slice(startIndex, endIndex);
-        const result = selectedLines.join('\n');
+        const result = selectedLines.join("\n");
         // Add metadata about truncation
         if (startIndex > 0 || endIndex < lines.length) {
             const totalLines = lines.length;
@@ -2580,6 +2929,175 @@ async function getCommitDiff(projectId, sha) {
     const data = await response.json();
     return z.array(GitLabDiffSchema).parse(data);
 }
+/**
+ * Get the current authenticated user
+ * 현재 인증된 사용자 가져오기
+ *
+ * @returns {Promise<GitLabUser>} The current user
+ */
+async function getCurrentUser() {
+    const response = await fetch(`${GITLAB_API_URL}/user`, DEFAULT_FETCH_CONFIG);
+    await handleGitLabError(response);
+    const data = await response.json();
+    return GitLabUserSchema.parse(data);
+}
+/**
+ * List issues assigned to the current authenticated user
+ * 현재 인증된 사용자에게 할당된 이슈 목록 조회
+ *
+ * @param {MyIssuesOptions} options - Options for filtering issues
+ * @returns {Promise<GitLabIssue[]>} List of issues assigned to the current user
+ */
+async function myIssues(options = {}) {
+    // Get current user to find their username
+    const currentUser = await getCurrentUser();
+    // Use getEffectiveProjectId to handle project ID resolution
+    const effectiveProjectId = getEffectiveProjectId(options.project_id || "");
+    // Use listIssues with assignee_username filter
+    let listIssuesOptions = {
+        state: options.state || "opened", // Default to "opened" if not specified
+        labels: options.labels,
+        milestone: options.milestone,
+        search: options.search,
+        created_after: options.created_after,
+        created_before: options.created_before,
+        updated_after: options.updated_after,
+        updated_before: options.updated_before,
+        per_page: options.per_page,
+        page: options.page,
+    };
+    if (currentUser.username) {
+        listIssuesOptions.assignee_username = [currentUser.username];
+    }
+    else {
+        listIssuesOptions.assignee_id = currentUser.id;
+    }
+    return listIssues(effectiveProjectId, listIssuesOptions);
+}
+/**
+ * List members of a GitLab project
+ * GitLab 프로젝트 멤버 목록 조회
+ *
+ * @param {string} projectId - Project ID or URL-encoded path
+ * @param {Omit<ListProjectMembersOptions, "project_id">} options - Options for filtering members
+ * @returns {Promise<GitLabProjectMember[]>} List of project members
+ */
+async function listProjectMembers(projectId, options = {}) {
+    projectId = decodeURIComponent(projectId);
+    const effectiveProjectId = getEffectiveProjectId(projectId);
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(effectiveProjectId)}/members`);
+    // Add query parameters
+    if (options.query)
+        url.searchParams.append("query", options.query);
+    if (options.user_ids) {
+        options.user_ids.forEach(id => url.searchParams.append("user_ids[]", id.toString()));
+    }
+    if (options.skip_users) {
+        options.skip_users.forEach(id => url.searchParams.append("skip_users[]", id.toString()));
+    }
+    if (options.per_page)
+        url.searchParams.append("per_page", options.per_page.toString());
+    if (options.page)
+        url.searchParams.append("page", options.page.toString());
+    const response = await fetch(url.toString(), DEFAULT_FETCH_CONFIG);
+    await handleGitLabError(response);
+    const data = await response.json();
+    return z.array(GitLabProjectMemberSchema).parse(data);
+}
+/**
+ * list group iterations
+ *
+ * @param {string} groupId
+ * @param {Omit<ListGroupIterationsOptions, "group_id">} options
+ * @returns {Promise<GetIt[]>}
+ */
+async function listGroupIterations(groupId, options = {}) {
+    groupId = decodeURIComponent(groupId);
+    const url = new URL(`${GITLAB_API_URL}/groups/${encodeURIComponent(groupId)}/iterations`);
+    // クエリパラメータの追加
+    if (options.state)
+        url.searchParams.append("state", options.state);
+    if (options.search)
+        url.searchParams.append("search", options.search);
+    if (options.in)
+        url.searchParams.append("in", options.in.join(","));
+    if (options.include_ancestors !== undefined)
+        url.searchParams.append("include_ancestors", options.include_ancestors.toString());
+    if (options.include_descendants !== undefined)
+        url.searchParams.append("include_descendants", options.include_descendants.toString());
+    if (options.updated_before)
+        url.searchParams.append("updated_before", options.updated_before);
+    if (options.updated_after)
+        url.searchParams.append("updated_after", options.updated_after);
+    if (options.page)
+        url.searchParams.append("page", options.page.toString());
+    if (options.per_page)
+        url.searchParams.append("per_page", options.per_page.toString());
+    const response = await fetch(url.toString(), DEFAULT_FETCH_CONFIG);
+    if (!response.ok) {
+        await handleGitLabError(response);
+    }
+    const data = await response.json();
+    return z.array(GroupIteration).parse(data);
+}
+/**
+ * Upload a file to a GitLab project for use in markdown content
+ *
+ * @param {string} projectId - The ID or URL-encoded path of the project
+ * @param {string} filePath - Path to the local file to upload
+ * @returns {Promise<GitLabMarkdownUpload>} The upload response
+ */
+async function markdownUpload(projectId, filePath) {
+    projectId = decodeURIComponent(projectId);
+    const effectiveProjectId = getEffectiveProjectId(projectId);
+    // Check if file exists
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    // Read the file
+    const fileBuffer = fs.readFileSync(filePath);
+    const fileName = path.basename(filePath);
+    // Create form data
+    const FormData = (await import("form-data")).default;
+    const form = new FormData();
+    form.append("file", fileBuffer, {
+        filename: fileName,
+        contentType: "application/octet-stream",
+    });
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(effectiveProjectId)}/uploads`);
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers: {
+            ...DEFAULT_HEADERS,
+            // Remove Content-Type header to let form-data set it with boundary
+            "Content-Type": undefined,
+        },
+        body: form,
+    });
+    if (!response.ok) {
+        await handleGitLabError(response);
+    }
+    const data = await response.json();
+    return GitLabMarkdownUploadSchema.parse(data);
+}
+async function downloadAttachment(projectId, secret, filename, localPath) {
+    const effectiveProjectId = getEffectiveProjectId(projectId);
+    const url = new URL(`${GITLAB_API_URL}/projects/${encodeURIComponent(effectiveProjectId)}/uploads/${secret}/${filename}`);
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: DEFAULT_HEADERS,
+    });
+    if (!response.ok) {
+        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;
+}
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     // Apply read-only filter first
     const tools0 = GITLAB_READ_ONLY_MODE
@@ -2798,6 +3316,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: "text", text: JSON.stringify(mergeRequest, null, 2) }],
                 };
             }
+            case "merge_merge_request": {
+                const args = MergeMergeRequestSchema.parse(request.params.arguments);
+                const { project_id, merge_request_iid, ...options } = args;
+                const mergeRequest = await mergeMergeRequest(project_id, options, merge_request_iid);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(mergeRequest, null, 2) }],
+                };
+            }
             case "mr_discussions": {
                 const args = ListMergeRequestDiscussionsSchema.parse(request.params.arguments);
                 const { project_id, merge_request_iid, ...options } = args;
@@ -2877,6 +3403,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: "text", text: JSON.stringify(projects, null, 2) }],
                 };
             }
+            case "list_project_members": {
+                const args = ListProjectMembersSchema.parse(request.params.arguments);
+                const { project_id, ...options } = args;
+                const members = await listProjectMembers(project_id, options);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(members, null, 2) }],
+                };
+            }
             case "get_users": {
                 const args = GetUsersSchema.parse(request.params.arguments);
                 const usersMap = await getUsers(args.usernames);
@@ -2892,6 +3426,62 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: "text", text: JSON.stringify(note, null, 2) }],
                 };
             }
+            case "get_draft_note": {
+                const args = GetDraftNoteSchema.parse(request.params.arguments);
+                const { project_id, merge_request_iid, draft_note_id } = args;
+                const draftNote = await getDraftNote(project_id, merge_request_iid, draft_note_id);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(draftNote, null, 2) }],
+                };
+            }
+            case "list_draft_notes": {
+                const args = ListDraftNotesSchema.parse(request.params.arguments);
+                const { project_id, merge_request_iid } = args;
+                const draftNotes = await listDraftNotes(project_id, merge_request_iid);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(draftNotes, null, 2) }],
+                };
+            }
+            case "create_draft_note": {
+                const args = CreateDraftNoteSchema.parse(request.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);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(draftNote, null, 2) }],
+                };
+            }
+            case "update_draft_note": {
+                const args = UpdateDraftNoteSchema.parse(request.params.arguments);
+                const { project_id, merge_request_iid, draft_note_id, body, position, resolve_discussion } = args;
+                const draftNote = await updateDraftNote(project_id, merge_request_iid, draft_note_id, body, position, resolve_discussion);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(draftNote, null, 2) }],
+                };
+            }
+            case "delete_draft_note": {
+                const args = DeleteDraftNoteSchema.parse(request.params.arguments);
+                const { project_id, merge_request_iid, draft_note_id } = args;
+                await deleteDraftNote(project_id, merge_request_iid, draft_note_id);
+                return {
+                    content: [{ type: "text", text: "Draft note deleted successfully" }],
+                };
+            }
+            case "publish_draft_note": {
+                const args = PublishDraftNoteSchema.parse(request.params.arguments);
+                const { project_id, merge_request_iid, draft_note_id } = args;
+                const publishedNote = await publishDraftNote(project_id, merge_request_iid, draft_note_id);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(publishedNote, null, 2) }],
+                };
+            }
+            case "bulk_publish_draft_notes": {
+                const args = BulkPublishDraftNotesSchema.parse(request.params.arguments);
+                const { project_id, merge_request_iid } = args;
+                const publishedNotes = await bulkPublishDraftNotes(project_id, merge_request_iid);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(publishedNotes, null, 2) }],
+                };
+            }
             case "create_merge_request_thread": {
                 const args = CreateMergeRequestThreadSchema.parse(request.params.arguments);
                 const { project_id, merge_request_iid, body, position, created_at } = args;
@@ -2908,6 +3498,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: "text", text: JSON.stringify(issues, null, 2) }],
                 };
             }
+            case "my_issues": {
+                const args = MyIssuesSchema.parse(request.params.arguments);
+                const issues = await myIssues(args);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(issues, null, 2) }],
+                };
+            }
             case "get_issue": {
                 const args = GetIssueSchema.parse(request.params.arguments);
                 const issue = await getIssue(args.project_id, args.issue_iid);
@@ -3029,7 +3626,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             case "list_wiki_pages": {
                 const { project_id, page, per_page, with_content } = ListWikiPagesSchema.parse(request.params.arguments);
-                const wikiPages = await listWikiPages(project_id, { page, per_page, with_content });
+                const wikiPages = await listWikiPages(project_id, {
+                    page,
+                    per_page,
+                    with_content,
+                });
                 return {
                     content: [{ type: "text", text: JSON.stringify(wikiPages, null, 2) }],
                 };
@@ -3109,6 +3710,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "list_pipeline_trigger_jobs": {
+                const { project_id, pipeline_id, ...options } = ListPipelineTriggerJobsSchema.parse(request.params.arguments);
+                const triggerJobs = await listPipelineTriggerJobs(project_id, pipeline_id, options);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(triggerJobs, null, 2),
+                        },
+                    ],
+                };
+            }
             case "get_pipeline_job": {
                 const { project_id, job_id } = GetPipelineJobOutputSchema.parse(request.params.arguments);
                 const jobDetails = await getPipelineJob(project_id, job_id);
@@ -3308,6 +3921,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: "text", text: JSON.stringify(diff, null, 2) }],
                 };
             }
+            case "list_group_iterations": {
+                const args = ListGroupIterationsSchema.parse(request.params.arguments);
+                const iterations = await listGroupIterations(args.group_id, args);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(iterations, null, 2) }],
+                };
+            }
+            case "upload_markdown": {
+                const args = MarkdownUploadSchema.parse(request.params.arguments);
+                const upload = await markdownUpload(args.project_id, args.file_path);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(upload, null, 2) }],
+                };
+            }
+            case "download_attachment": {
+                const args = DownloadAttachmentSchema.parse(request.params.arguments);
+                const filePath = await downloadAttachment(args.project_id, args.secret, args.filename, args.local_path);
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ success: true, file_path: filePath }, null, 2) }],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${request.params.name}`);
         }
@@ -3340,7 +3974,7 @@ function determineTransportMode() {
     if (STREAMABLE_HTTP) {
         return TransportMode.STREAMABLE_HTTP;
     }
-    // Check for SSE support (medium priority)  
+    // Check for SSE support (medium priority)
     if (SSE) {
         return TransportMode.SSE;
     }
@@ -3382,7 +4016,7 @@ async function startSSEServer() {
         res.status(200).json({
             status: "healthy",
             version: SERVER_VERSION,
-            transport: TransportMode.SSE
+            transport: TransportMode.SSE,
         });
     });
     app.listen(Number(PORT), HOST, () => {
@@ -3401,8 +4035,8 @@ async function startStreamableHTTPServer() {
     // Configure Express middleware
     app.use(express.json());
     // Streamable HTTP endpoint - handles both session creation and message handling
-    app.post('/mcp', async (req, res) => {
-        const sessionId = req.headers['mcp-session-id'];
+    app.post("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
         try {
             let transport;
             if (sessionId && streamableTransports[sessionId]) {
@@ -3417,7 +4051,7 @@ async function startStreamableHTTPServer() {
                     onsessioninitialized: (newSessionId) => {
                         streamableTransports[newSessionId] = transport;
                         logger.warn(`Streamable HTTP session initialized: ${newSessionId}`);
-                    }
+                    },
                 });
                 // Set up cleanup handler when transport closes
                 transport.onclose = () => {
@@ -3433,10 +4067,10 @@ async function startStreamableHTTPServer() {
             }
         }
         catch (error) {
-            logger.error('Streamable HTTP error:', error);
+            logger.error("Streamable HTTP error:", error);
             res.status(500).json({
-                error: 'Internal server error',
-                message: error instanceof Error ? error.message : 'Unknown error'
+                error: "Internal server error",
+                message: error instanceof Error ? error.message : "Unknown error",
             });
         }
     });
@@ -3446,7 +4080,7 @@ async function startStreamableHTTPServer() {
             status: "healthy",
             version: SERVER_VERSION,
             transport: TransportMode.STREAMABLE_HTTP,
-            activeSessions: Object.keys(streamableTransports).length
+            activeSessions: Object.keys(streamableTransports).length,
         });
     });
     // Start server
@@ -3460,18 +4094,18 @@ async function startStreamableHTTPServer() {
  * Handle transport-specific initialization logic
  */
 async function initializeServerByTransportMode(mode) {
-    logger.info('Initializing server with transport mode:', mode);
+    logger.info("Initializing server with transport mode:", mode);
     switch (mode) {
         case TransportMode.STDIO:
-            logger.warn('Starting GitLab MCP Server with stdio transport');
+            logger.warn("Starting GitLab MCP Server with stdio transport");
             await startStdioServer();
             break;
         case TransportMode.SSE:
-            logger.warn('Starting GitLab MCP Server with SSE transport');
+            logger.warn("Starting GitLab MCP Server with SSE transport");
             await startSSEServer();
             break;
         case TransportMode.STREAMABLE_HTTP:
-            logger.warn('Starting GitLab MCP Server with Streamable HTTP transport');
+            logger.warn("Starting GitLab MCP Server with Streamable HTTP transport");
             await startStreamableHTTPServer();
             break;
         default:
@@ -3494,6 +4128,7 @@ async function runServer() {
         process.exit(1);
     }
 }
+// 下記の２行を追記
 runServer().catch(error => {
     logger.error("Fatal error in main():", error);
     process.exit(1);