@zereight/mcp-gitlab 1.0.67 → 1.0.69

package/README.md

@@ -129,6 +129,34 @@ docker run -i --rm \
 }
 ```
 
+
+- streamable-http
+
+
+```shell
+docker run -i --rm \
+  -e GITLAB_PERSONAL_ACCESS_TOKEN=your_gitlab_token \
+  -e GITLAB_API_URL="https://gitlab.com/api/v4" \
+  -e GITLAB_READ_ONLY_MODE=true \
+  -e USE_GITLAB_WIKI=true \
+  -e USE_MILESTONE=true \
+  -e USE_PIPELINE=true \
+  -e STREAMABLE_HTTP=true \
+  -p 3333:3002 \
+  iwakitakuma/gitlab-mcp
+```
+
+```json
+{
+  "mcpServers": {
+    "GitLab communication server": {
+      "url": "http://localhost:3333/mcp"
+    }
+  }
+}
+```
+
+
 #### Docker Image Push
 
 ```shell
@@ -145,6 +173,8 @@ $ sh scripts/image_push.sh docker_user_name
 - `USE_MILESTONE`: When set to 'true', enables the milestone-related tools (list_milestones, get_milestone, create_milestone, edit_milestone, delete_milestone, get_milestone_issue, get_milestone_merge_requests, promote_milestone, get_milestone_burndown_events). By default, milestone features are disabled.
 - `USE_PIPELINE`: When set to 'true', enables the pipeline-related tools (list_pipelines, get_pipeline, list_pipeline_jobs, get_pipeline_job, get_pipeline_job_output, create_pipeline, retry_pipeline, cancel_pipeline). By default, pipeline features are disabled.
 - `GITLAB_AUTH_COOKIE_PATH`: Path to an authentication cookie file for GitLab instances that require cookie-based authentication. When provided, the cookie will be included in all GitLab API requests.
+- `SSE`: When set to 'true', enables the Server-Sent Events transport.
+- `STREAMABLE_HTTP`: When set to 'true', enables the Streamable HTTP transport. If both **SSE** and **STREAMABLE_HTTP** are set to 'true', the server will prioritize Streamable HTTP over SSE transport.
 
 [![Star History Chart](https://api.star-history.com/svg?repos=zereight/gitlab-mcp&type=Date)](https://www.star-history.com/#zereight/gitlab-mcp&Date)
 

package/build/index.js

@@ -2,6 +2,7 @@
 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 { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import nodeFetch from "node-fetch";
 import fetchCookie from "fetch-cookie";
@@ -28,6 +29,16 @@ 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";
+import { randomUUID } from "crypto";
+/**
+ * Available transport modes for MCP server
+ */
+var TransportMode;
+(function (TransportMode) {
+    TransportMode["STDIO"] = "stdio";
+    TransportMode["SSE"] = "sse";
+    TransportMode["STREAMABLE_HTTP"] = "streamable-http";
+})(TransportMode || (TransportMode = {}));
 /**
  * Read version from package.json
  */
@@ -60,6 +71,9 @@ const USE_GITLAB_WIKI = process.env.USE_GITLAB_WIKI === "true";
 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 || '127.0.0.1';
+const PORT = process.env.PORT || 3002;
 // Add proxy configuration
 const HTTP_PROXY = process.env.HTTP_PROXY;
 const HTTPS_PROXY = process.env.HTTPS_PROXY;
@@ -3291,51 +3305,171 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 });
 /**
- * Initialize and run the server
- * 서버 초기화 및 실행
+ *  Color constants for terminal output
  */
-async function runServer() {
-    try {
-        // Server startup banner removed - inappropriate use of console.error for logging
-        // Server version banner removed - inappropriate use of console.error for logging
-        // API URL banner removed - inappropriate use of console.error for logging
-        // Server startup banner removed - inappropriate use of console.error for logging
-        if (!SSE) {
-            const transport = new StdioServerTransport();
-            await server.connect(transport);
+const colorGreen = "\x1b[32m";
+const colorReset = "\x1b[0m";
+/**
+ * Determine the transport mode based on environment variables and availability
+ *
+ * Transport mode priority (highest to lowest):
+ * 1. STREAMABLE_HTTP
+ * 2. SSE
+ * 3. STDIO
+ */
+function determineTransportMode() {
+    // Check for streamable-http support (highest priority)
+    if (STREAMABLE_HTTP) {
+        return TransportMode.STREAMABLE_HTTP;
+    }
+    // Check for SSE support (medium priority)  
+    if (SSE) {
+        return TransportMode.SSE;
+    }
+    // Default to stdio (lowest priority)
+    return TransportMode.STDIO;
+}
+/**
+ * Start server with stdio transport
+ */
+async function startStdioServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+/**
+ * Start server with traditional SSE transport
+ */
+async function startSSEServer() {
+    const app = express();
+    const transports = {};
+    app.get("/sse", async (_, res) => {
+        const transport = new SSEServerTransport("/messages", res);
+        transports[transport.sessionId] = transport;
+        res.on("close", () => {
+            delete transports[transport.sessionId];
+        });
+        await server.connect(transport);
+    });
+    app.post("/messages", async (req, res) => {
+        const sessionId = req.query.sessionId;
+        const transport = transports[sessionId];
+        if (transport) {
+            await transport.handlePostMessage(req, res);
         }
         else {
-            const app = express();
-            const transports = {};
-            app.get("/sse", async (_, res) => {
-                const transport = new SSEServerTransport("/messages", res);
-                transports[transport.sessionId] = transport;
-                res.on("close", () => {
-                    delete transports[transport.sessionId];
+            res.status(400).send("No transport found for sessionId");
+        }
+    });
+    app.get("/health", (_, res) => {
+        res.status(200).json({
+            status: "healthy",
+            version: SERVER_VERSION,
+            transport: TransportMode.SSE
+        });
+    });
+    app.listen(Number(PORT), HOST, () => {
+        console.log(`GitLab MCP Server running with SSE transport`);
+        const colorGreen = "\x1b[32m";
+        const colorReset = "\x1b[0m";
+        console.log(`${colorGreen}Endpoint: http://${HOST}:${PORT}/sse${colorReset}`);
+    });
+}
+/**
+ * Start server with Streamable HTTP transport
+ */
+async function startStreamableHTTPServer() {
+    const app = express();
+    const streamableTransports = {};
+    // 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'];
+        try {
+            let transport;
+            if (sessionId && streamableTransports[sessionId]) {
+                // Reuse existing transport for ongoing session
+                transport = streamableTransports[sessionId];
+                await transport.handleRequest(req, res, req.body);
+            }
+            else {
+                // Create new transport for new session
+                transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: (newSessionId) => {
+                        streamableTransports[newSessionId] = transport;
+                        console.warn(`Streamable HTTP session initialized: ${newSessionId}`);
+                    }
                 });
+                // Set up cleanup handler when transport closes
+                transport.onclose = () => {
+                    const sid = transport.sessionId;
+                    if (sid && streamableTransports[sid]) {
+                        console.warn(`Streamable HTTP transport closed for session ${sid}, cleaning up`);
+                        delete streamableTransports[sid];
+                    }
+                };
+                // Connect transport to MCP server before handling the request
                 await server.connect(transport);
-            });
-            app.post("/messages", async (req, res) => {
-                const sessionId = req.query.sessionId;
-                const transport = transports[sessionId];
-                if (transport) {
-                    await transport.handlePostMessage(req, res);
-                }
-                else {
-                    res.status(400).send("No transport found for sessionId");
-                }
-            });
-            app.get("/health", (_, res) => {
-                res.status(200).json({
-                    status: "healthy",
-                    version: process.env.npm_package_version || "unknown",
-                });
-            });
-            const PORT = process.env.PORT || 3002;
-            app.listen(PORT, () => {
-                console.log(`Server is running on port ${PORT}`);
+                await transport.handleRequest(req, res, req.body);
+            }
+        }
+        catch (error) {
+            console.error('Streamable HTTP error:', error);
+            res.status(500).json({
+                error: 'Internal server error',
+                message: error instanceof Error ? error.message : 'Unknown error'
             });
         }
+    });
+    // Health check endpoint
+    app.get("/health", (_, res) => {
+        res.status(200).json({
+            status: "healthy",
+            version: SERVER_VERSION,
+            transport: TransportMode.STREAMABLE_HTTP,
+            activeSessions: Object.keys(streamableTransports).length
+        });
+    });
+    // Start server
+    app.listen(Number(PORT), HOST, () => {
+        console.log(`GitLab MCP Server running with Streamable HTTP transport`);
+        console.log(`${colorGreen}Endpoint: http://${HOST}:${PORT}/mcp${colorReset}`);
+    });
+}
+/**
+ * Initialize server with specific transport mode
+ * Handle transport-specific initialization logic
+ */
+async function initializeServerByTransportMode(mode) {
+    console.log('Initializing server with transport mode:', mode);
+    switch (mode) {
+        case TransportMode.STDIO:
+            console.warn('Starting GitLab MCP Server with stdio transport');
+            await startStdioServer();
+            break;
+        case TransportMode.SSE:
+            console.warn('Starting GitLab MCP Server with SSE transport');
+            await startSSEServer();
+            break;
+        case TransportMode.STREAMABLE_HTTP:
+            console.warn('Starting GitLab MCP Server with Streamable HTTP transport');
+            await startStreamableHTTPServer();
+            break;
+        default:
+            // This should never happen with proper enum usage, but TypeScript requires it
+            const exhaustiveCheck = mode;
+            throw new Error(`Unknown transport mode: ${exhaustiveCheck}`);
+    }
+}
+/**
+ * Initialize and run the server
+ * Main entry point for server startup
+ */
+async function runServer() {
+    try {
+        const transportMode = determineTransportMode();
+        await initializeServerByTransportMode(transportMode);
     }
     catch (error) {
         console.error("Error initializing server:", error);

package/build/schemas.js

@@ -632,7 +632,7 @@ export const GitLabDiscussionNoteSchema = z.object({
     noteable_id: z.number(),
     noteable_type: z.enum(["Issue", "MergeRequest", "Snippet", "Commit", "Epic"]),
     project_id: z.number().optional(), // Optional for group-level discussions like Epics
-    noteable_iid: z.number().nullable(),
+    noteable_iid: z.coerce.number().nullable(),
     resolvable: z.boolean().optional(),
     resolved: z.boolean().optional(),
     resolved_by: GitLabUserSchema.nullable().optional(),
@@ -809,7 +809,14 @@ export const UpdateMergeRequestSchema = GetMergeRequestSchema.extend({
     title: z.string().optional().describe("The title of the merge request"),
     description: z.string().optional().describe("The description of the merge request"),
     target_branch: z.string().optional().describe("The target branch"),
-    assignee_ids: z.array(z.number()).optional().describe("The ID of the users to assign the MR to"),
+    assignee_ids: z
+        .array(z.number())
+        .optional()
+        .describe("The ID of the users to assign the MR to"),
+    reviewer_ids: z
+        .array(z.number())
+        .optional()
+        .describe("The ID of the users to assign as reviewers of the MR"),
     labels: z.array(z.string()).optional().describe("Labels for the MR"),
     state_event: z
         .enum(["close", "reopen"])
@@ -835,7 +842,7 @@ export const CreateNoteSchema = z.object({
     noteable_type: z
         .enum(["issue", "merge_request"])
         .describe("Type of noteable (issue or merge_request)"),
-    noteable_iid: z.number().describe("IID of the issue or merge request"),
+    noteable_iid: z.coerce.number().describe("IID of the issue or merge request"),
     body: z.string().describe("Note content"),
 });
 // Issues API operation schemas

package/build/test/clients/client.js

@@ -0,0 +1,34 @@
+/**
+ * MCP Client Interface and error classes for testing
+ */
+/**
+ * Base error class for MCP client errors
+ */
+export class MCPClientError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'MCPClientError';
+    }
+}
+/**
+ * Connection error for MCP clients
+ */
+export class MCPConnectionError extends MCPClientError {
+    constructor(message, cause) {
+        super(message, cause);
+        this.name = 'MCPConnectionError';
+    }
+}
+/**
+ * Tool call error for MCP clients
+ */
+export class MCPToolCallError extends MCPClientError {
+    toolName;
+    constructor(message, toolName, cause) {
+        super(message, cause);
+        this.toolName = toolName;
+        this.name = 'MCPToolCallError';
+    }
+}

package/build/test/clients/sse-client.js

@@ -0,0 +1,95 @@
+/**
+ * SSE MCP Client for testing
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { MCPConnectionError, MCPToolCallError } from "./client.js";
+export class SSETestClient {
+    client;
+    transport = null;
+    constructor() {
+        this.client = new Client({ name: "test-client", version: "1.0.0" });
+    }
+    /**
+     * Connect to MCP server via SSE
+     */
+    async connect(url) {
+        if (this.transport) {
+            throw new MCPConnectionError('Client is already connected');
+        }
+        try {
+            this.transport = new SSEClientTransport(new URL(url));
+            await this.client.connect(this.transport);
+        }
+        catch (error) {
+            this.transport = null;
+            throw new MCPConnectionError(`Failed to connect to SSE server: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Disconnect from server
+     */
+    async disconnect() {
+        if (this.transport) {
+            try {
+                await this.transport.close();
+            }
+            catch (error) {
+                // Log but don't throw on disconnect errors
+                console.warn('Warning during disconnect:', error);
+            }
+            finally {
+                this.transport = null;
+            }
+        }
+    }
+    /**
+     * List available tools from server
+     */
+    async listTools() {
+        if (!this.transport) {
+            throw new MCPConnectionError('Client is not connected');
+        }
+        try {
+            const response = await this.client.listTools();
+            return response;
+        }
+        catch (error) {
+            throw new MCPToolCallError(`Failed to list tools: ${error instanceof Error ? error.message : String(error)}`, 'listTools', error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Call a tool on the server
+     */
+    async callTool(name, arguments_ = {}) {
+        if (!this.transport) {
+            throw new MCPConnectionError('Client is not connected');
+        }
+        try {
+            const response = await this.client.callTool({ name, arguments: arguments_ });
+            // Ensure the response conforms to CallToolResult interface
+            return response;
+        }
+        catch (error) {
+            throw new MCPToolCallError(`Failed to call tool '${name}': ${error instanceof Error ? error.message : String(error)}`, name, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Test connection by listing tools
+     */
+    async testConnection() {
+        try {
+            const tools = await this.listTools();
+            return Array.isArray(tools.tools) && tools.tools.length > 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get client connection status
+     */
+    get isConnected() {
+        return this.transport !== null;
+    }
+}

package/build/test/clients/stdio-client.js

@@ -0,0 +1,113 @@
+/**
+ * Stdio MCP Client for testing
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { MCPConnectionError, MCPToolCallError } from "./client.js";
+export class StdioTestClient {
+    client;
+    transport = null;
+    constructor() {
+        this.client = new Client({ name: "test-client", version: "1.0.0" });
+    }
+    /**
+     * Connect to MCP server via stdio
+     */
+    async connect(serverPath, env) {
+        if (this.transport) {
+            throw new MCPConnectionError('Client is already connected');
+        }
+        try {
+            const command = process.execPath;
+            const args = [serverPath];
+            // Prepare environment variables for the server process
+            const serverEnv = {};
+            // Copy process.env, filtering out undefined values
+            for (const [key, value] of Object.entries(process.env)) {
+                if (value !== undefined) {
+                    serverEnv[key] = value;
+                }
+            }
+            // Add custom environment variables
+            if (env) {
+                Object.assign(serverEnv, env);
+            }
+            this.transport = new StdioClientTransport({
+                command,
+                args,
+                env: serverEnv
+            });
+            await this.client.connect(this.transport);
+        }
+        catch (error) {
+            this.transport = null;
+            throw new MCPConnectionError(`Failed to connect to stdio server: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Disconnect from server
+     */
+    async disconnect() {
+        if (this.transport) {
+            try {
+                await this.transport.close();
+            }
+            catch (error) {
+                // Log but don't throw on disconnect errors
+                console.warn('Warning during disconnect:', error);
+            }
+            finally {
+                this.transport = null;
+            }
+        }
+    }
+    /**
+     * List available tools from server
+     */
+    async listTools() {
+        if (!this.transport) {
+            throw new MCPConnectionError('Client is not connected');
+        }
+        try {
+            const response = await this.client.listTools();
+            return response;
+        }
+        catch (error) {
+            throw new MCPToolCallError(`Failed to list tools: ${error instanceof Error ? error.message : String(error)}`, 'listTools', error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Call a tool on the server
+     */
+    async callTool(name, arguments_ = {}) {
+        if (!this.transport) {
+            throw new MCPConnectionError('Client is not connected');
+        }
+        try {
+            const response = await this.client.callTool({ name, arguments: arguments_ });
+            // Ensure the response conforms to CallToolResult interface
+            return response;
+        }
+        catch (error) {
+            throw new MCPToolCallError(`Failed to call tool '${name}': ${error instanceof Error ? error.message : String(error)}`, name, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Test connection by listing tools
+     */
+    async testConnection() {
+        try {
+            const tools = await this.listTools();
+            return Array.isArray(tools.tools) && tools.tools.length > 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get client connection status
+     */
+    get isConnected() {
+        return this.transport !== null;
+    }
+}

package/build/test/clients/streamable-http-client.js

@@ -0,0 +1,95 @@
+/**
+ * Streamable HTTP MCP Client for testing
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { MCPConnectionError, MCPToolCallError } from "./client.js";
+export class StreamableHTTPTestClient {
+    client;
+    transport = null;
+    constructor() {
+        this.client = new Client({ name: "test-client", version: "1.0.0" });
+    }
+    /**
+     * Connect to MCP server via Streamable HTTP
+     */
+    async connect(url) {
+        if (this.transport) {
+            throw new MCPConnectionError('Client is already connected');
+        }
+        try {
+            this.transport = new StreamableHTTPClientTransport(new URL(url));
+            await this.client.connect(this.transport);
+        }
+        catch (error) {
+            this.transport = null;
+            throw new MCPConnectionError(`Failed to connect to Streamable HTTP server: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Disconnect from server
+     */
+    async disconnect() {
+        if (this.transport) {
+            try {
+                await this.transport.close();
+            }
+            catch (error) {
+                // Log but don't throw on disconnect errors
+                console.warn('Warning during disconnect:', error);
+            }
+            finally {
+                this.transport = null;
+            }
+        }
+    }
+    /**
+     * List available tools from server
+     */
+    async listTools() {
+        if (!this.transport) {
+            throw new MCPConnectionError('Client is not connected');
+        }
+        try {
+            const response = await this.client.listTools();
+            return response;
+        }
+        catch (error) {
+            throw new MCPToolCallError(`Failed to list tools: ${error instanceof Error ? error.message : String(error)}`, 'listTools', error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Call a tool on the server
+     */
+    async callTool(name, arguments_ = {}) {
+        if (!this.transport) {
+            throw new MCPConnectionError('Client is not connected');
+        }
+        try {
+            const response = await this.client.callTool({ name, arguments: arguments_ });
+            // Ensure the response conforms to CallToolResult interface
+            return response;
+        }
+        catch (error) {
+            throw new MCPToolCallError(`Failed to call tool '${name}': ${error instanceof Error ? error.message : String(error)}`, name, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Test connection by listing tools
+     */
+    async testConnection() {
+        try {
+            const tools = await this.listTools();
+            return Array.isArray(tools.tools) && tools.tools.length > 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Get client connection status
+     */
+    get isConnected() {
+        return this.transport !== null;
+    }
+}

package/build/test/test-all-transport-server.js

@@ -0,0 +1,243 @@
+/**
+ * GitLab MCP Server Transport Tests
+ * Tests all three transport modes: stdio, SSE, and streamable-http
+ */
+import * as path from 'path';
+import { describe, test, after, before } from 'node:test';
+import assert from 'node:assert';
+import { launchServer, findAvailablePort, cleanupServers, TransportMode, checkHealthEndpoint, HOST } from './utils/server-launcher.js';
+import { StdioTestClient } from './clients/stdio-client.js';
+import { SSETestClient } from './clients/sse-client.js';
+import { StreamableHTTPTestClient } from './clients/streamable-http-client.js';
+console.log('🚀 GitLab MCP Server Tests');
+console.log('');
+// Configuration check
+const GITLAB_API_URL = process.env.GITLAB_API_URL || "https://gitlab.com";
+const GITLAB_TOKEN = process.env.GITLAB_TOKEN_TEST || process.env.GITLAB_TOKEN;
+const TEST_PROJECT_ID = process.env.TEST_PROJECT_ID;
+console.log('🔧 Test Configuration:');
+console.log(`  GitLab URL: ${GITLAB_API_URL}`);
+console.log(`  Token: ${GITLAB_TOKEN ? '✅ Provided' : '❌ Missing'}`);
+console.log(`  Project ID: ${TEST_PROJECT_ID || '❌ Missing'}`);
+// Validate required configuration
+if (!GITLAB_TOKEN) {
+    console.error('❌ Error: GITLAB_TOKEN_TEST or GITLAB_TOKEN environment variable is required for testing');
+    console.error('   Set one of these variables to your GitLab API token');
+    process.exit(1);
+}
+if (!TEST_PROJECT_ID) {
+    console.error('❌ Error: TEST_PROJECT_ID environment variable is required for testing');
+    console.error('   Set this variable to a valid GitLab project ID (e.g., "123" or "group/project")');
+    process.exit(1);
+}
+console.log('✅ Configuration validated');
+console.log('');
+let servers = [];
+// Cleanup function for all tests
+const cleanup = () => {
+    cleanupServers(servers);
+    servers = [];
+};
+// Handle process termination
+process.on('SIGINT', cleanup);
+process.on('SIGTERM', cleanup);
+process.on('exit', cleanup);
+describe('GitLab MCP Server - Stdio Transport', () => {
+    let client;
+    // Prepare environment variables for stdio server
+    const stdioEnv = {
+        GITLAB_PERSONAL_ACCESS_TOKEN: GITLAB_TOKEN,
+        GITLAB_API_URL: `${GITLAB_API_URL}/api/v4`,
+        GITLAB_PROJECT_ID: TEST_PROJECT_ID,
+        GITLAB_READ_ONLY_MODE: 'true',
+        // Explicitly disable other transport modes to ensure stdio mode
+        SSE: 'false',
+        STREAMABLE_HTTP: 'false'
+    };
+    before(async () => {
+        client = new StdioTestClient();
+        const serverPath = path.resolve(process.cwd(), 'build/index.js');
+        await client.connect(serverPath, stdioEnv);
+        assert.ok(client.isConnected, 'Client should be connected');
+        console.log('Client connected to stdio server');
+    });
+    after(async () => {
+        if (client && client.isConnected) {
+            await client.disconnect();
+        }
+    });
+    test('should list tools via stdio', async () => {
+        const tools = await client.listTools();
+        assert.ok(tools !== null && tools !== undefined, 'Tools response should be defined');
+        assert.ok('tools' in tools, 'Response should have tools property');
+        assert.ok(Array.isArray(tools.tools) && tools.tools.length > 0, 'Tools array should not be empty');
+        // Check for specific GitLab tools with proper typing
+        const toolNames = tools.tools.map(tool => tool.name);
+        assert.ok(toolNames.includes('list_merge_requests'), 'Should have list_merge_requests tool');
+        assert.ok(toolNames.includes('get_project'), 'Should have get_project tool');
+        // Verify tools have proper structure
+        const gitlabTools = tools.tools.filter(tool => tool.name === 'list_merge_requests' || tool.name === 'get_project');
+        assert.ok(gitlabTools.length >= 2, 'Should have at least 2 GitLab tools');
+        for (const tool of gitlabTools) {
+            assert.ok(tool.description !== null && tool.description !== undefined, `Tool ${tool.name} should have description`);
+            assert.ok('inputSchema' in tool, `Tool ${tool.name} should have input schema`);
+        }
+    });
+    test('should call list_merge_requests tool via stdio', async () => {
+        const result = await client.callTool('list_merge_requests', {
+            project_id: TEST_PROJECT_ID
+        });
+        assert.ok(result !== null && result !== undefined, 'Tool call result should be defined');
+        assert.ok('content' in result, 'Result should have content property');
+    });
+    test('should call get_project tool via stdio', async () => {
+        const result = await client.callTool('get_project', {
+            project_id: TEST_PROJECT_ID
+        });
+        // Verify proper CallToolResult structure
+        assert.ok(result !== null && result !== undefined, 'Tool call result should be defined');
+        assert.ok('content' in result, 'Result should have content property');
+        assert.ok(Array.isArray(result.content), 'Content should be an array');
+        assert.ok(result.content.length > 0, 'Content array should not be empty');
+        // Check content structure
+        const firstContent = result.content[0];
+        assert.ok(firstContent !== null && firstContent !== undefined, 'First content item should be defined');
+        assert.ok('type' in firstContent, 'Content item should have type');
+        assert.strictEqual(firstContent.type, 'text', 'Content type should be text');
+        assert.ok('text' in firstContent, 'Text content should have text property');
+        // Verify it's valid JSON containing project info
+        const projectData = JSON.parse(firstContent.text);
+        assert.ok(projectData !== null && projectData !== undefined, 'Project data should be parseable JSON');
+        assert.ok('id' in projectData, 'Project should have id');
+        assert.ok('name' in projectData, 'Project should have name');
+    });
+});
+describe('GitLab MCP Server - SSE Transport', () => {
+    let server;
+    let client;
+    let port;
+    before(async () => {
+        port = await findAvailablePort();
+        server = await launchServer({
+            mode: TransportMode.SSE,
+            port,
+            timeout: 3000,
+            env: {
+                SSE: 'true',
+                STREAMABLE_HTTP: 'false'
+            }
+        });
+        servers.push(server);
+        // Verify server started successfully
+        assert.ok(server.process.pid !== undefined, 'Server process should have PID');
+        assert.strictEqual(server.mode, TransportMode.SSE, 'Server mode should be SSE');
+        assert.strictEqual(server.port, port, 'Server should use correct port');
+        // Verify health check
+        const health = await checkHealthEndpoint(server.port);
+        assert.strictEqual(health.status, 'healthy', 'Health status should be healthy');
+        assert.strictEqual(health.transport, 'sse', 'Transport should be SSE');
+        assert.ok(health.version !== null && health.version !== undefined, 'Version should be defined');
+        // Create and connect client
+        client = new SSETestClient();
+        await client.connect(`http://${HOST}:${port}/sse`);
+        assert.ok(client.isConnected, 'Client should be connected');
+        assert.ok(await client.testConnection(), 'Connection test should pass');
+        console.log('Client connected to SSE server');
+    });
+    after(async () => {
+        if (client && client.isConnected) {
+            await client.disconnect();
+        }
+        cleanup();
+        console.log('Client disconnected from SSE server');
+    });
+    test('should list tools via SSE', async () => {
+        const tools = await client.listTools();
+        assert.ok(tools !== null && tools !== undefined, 'Tools response should be defined');
+        assert.ok('tools' in tools, 'Response should have tools property');
+        assert.ok(Array.isArray(tools.tools) && tools.tools.length > 0, 'Tools array should not be empty');
+        // Check for specific GitLab tools
+        const toolNames = tools.tools.map((tool) => tool.name);
+        assert.ok(toolNames.includes('list_merge_requests'), 'Should have list_merge_requests tool');
+        assert.ok(toolNames.includes('get_project'), 'Should have get_project tool');
+    });
+    test('should call list_merge_requests tool via SSE', async () => {
+        const result = await client.callTool('list_merge_requests', {
+            project_id: TEST_PROJECT_ID
+        });
+        assert.ok(result !== null && result !== undefined, 'Tool call result should be defined');
+        assert.ok('content' in result, 'Result should have content property');
+    });
+    test('should call get_project tool via SSE', async () => {
+        const result = await client.callTool('get_project', {
+            project_id: TEST_PROJECT_ID
+        });
+        assert.ok(result !== null && result !== undefined, 'Tool call result should be defined');
+        assert.ok('content' in result, 'Result should have content property');
+    });
+});
+describe('GitLab MCP Server - Streamable HTTP Transport', () => {
+    let server;
+    let client;
+    let port;
+    before(async () => {
+        port = await findAvailablePort();
+        server = await launchServer({
+            mode: TransportMode.STREAMABLE_HTTP,
+            port,
+            timeout: 3000,
+            env: {
+                SSE: 'false',
+                STREAMABLE_HTTP: 'true'
+            }
+        });
+        servers.push(server);
+        // Verify server started successfully
+        assert.ok(server.process.pid !== undefined, 'Server process should have PID');
+        assert.strictEqual(server.mode, TransportMode.STREAMABLE_HTTP, 'Server mode should be streamable-http');
+        assert.strictEqual(server.port, port, 'Server should use correct port');
+        // Verify health check
+        const health = await checkHealthEndpoint(server.port);
+        assert.strictEqual(health.status, 'healthy', 'Health status should be healthy');
+        assert.strictEqual(health.transport, 'streamable-http', 'Transport should be streamable-http');
+        assert.ok(health.version !== null && health.version !== undefined, 'Version should be defined');
+        assert.ok(health.activeSessions !== null && health.activeSessions !== undefined, 'Active sessions should be defined');
+        // Create and connect client
+        client = new StreamableHTTPTestClient();
+        await client.connect(`http://${HOST}:${port}/mcp`);
+        assert.ok(client.isConnected, 'Client should be connected');
+        assert.ok(await client.testConnection(), 'Connection test should pass');
+        console.log('Client connected to Streamable HTTP server');
+    });
+    after(async () => {
+        if (client && client.isConnected) {
+            await client.disconnect();
+        }
+        cleanup();
+        console.log('Client disconnected from Streamable HTTP server');
+    });
+    test('should list tools via Streamable HTTP', async () => {
+        const tools = await client.listTools();
+        assert.ok(tools !== null && tools !== undefined, 'Tools response should be defined');
+        assert.ok('tools' in tools, 'Response should have tools property');
+        assert.ok(Array.isArray(tools.tools) && tools.tools.length > 0, 'Tools array should not be empty');
+        // Check for specific GitLab tools
+        const toolNames = tools.tools.map((tool) => tool.name);
+        assert.ok(toolNames.includes('list_merge_requests'), 'Should have list_merge_requests tool');
+        assert.ok(toolNames.includes('get_project'), 'Should have get_project tool');
+    });
+    test('should call list_merge_requests tool via Streamable HTTP', async () => {
+        const result = await client.callTool('list_merge_requests', {
+            project_id: TEST_PROJECT_ID
+        });
+        assert.ok(result !== null && result !== undefined, 'Tool call result should be defined');
+        assert.ok('content' in result, 'Result should have content property');
+    });
+    test('should call get_project tool via Streamable HTTP', async () => {
+        const result = await client.callTool('get_project', {
+            project_id: TEST_PROJECT_ID
+        });
+        assert.ok(result !== null && result !== undefined, 'Tool call result should be defined');
+        assert.ok('content' in result, 'Result should have content property');
+    });
+});

package/build/test/utils/server-launcher.js

@@ -0,0 +1,205 @@
+/**
+ * Server launcher utility for testing different transport modes
+ * Manages server processes and provides clean shutdown
+ */
+import { spawn } from 'child_process';
+import * as path from 'path';
+export const HOST = process.env.HOST || '127.0.0.1';
+export var TransportMode;
+(function (TransportMode) {
+    TransportMode["STDIO"] = "stdio";
+    TransportMode["SSE"] = "sse";
+    TransportMode["STREAMABLE_HTTP"] = "streamable-http";
+})(TransportMode || (TransportMode = {}));
+/**
+ * Launch a server with specified configuration
+ */
+export async function launchServer(config) {
+    const { mode, port = 3002, env = {}, timeout = 3000 } = config;
+    // Prepare environment variables based on transport mode
+    // Use same configuration pattern as existing validate-api.js
+    const GITLAB_API_URL = process.env.GITLAB_API_URL || "https://gitlab.com";
+    const GITLAB_TOKEN = process.env.GITLAB_TOKEN_TEST || process.env.GITLAB_TOKEN;
+    const TEST_PROJECT_ID = process.env.TEST_PROJECT_ID;
+    // Validate that we have required configuration
+    if (!GITLAB_TOKEN) {
+        throw new Error('GITLAB_TOKEN_TEST or GITLAB_TOKEN environment variable is required for server testing');
+    }
+    if (!TEST_PROJECT_ID) {
+        throw new Error('TEST_PROJECT_ID environment variable is required for server testing');
+    }
+    const serverEnv = {
+        // Add all environment variables from the current process
+        ...process.env,
+        GITLAB_API_URL: `${GITLAB_API_URL}/api/v4`,
+        GITLAB_PROJECT_ID: TEST_PROJECT_ID,
+        GITLAB_READ_ONLY_MODE: 'true', // Use read-only mode for testing
+        ...env,
+    };
+    // Set transport-specific environment variables
+    switch (mode) {
+        case TransportMode.SSE:
+            serverEnv.SSE = 'true';
+            serverEnv.PORT = port.toString();
+            break;
+        case TransportMode.STREAMABLE_HTTP:
+            serverEnv.STREAMABLE_HTTP = 'true';
+            serverEnv.PORT = port.toString();
+            break;
+        case TransportMode.STDIO:
+            // Stdio mode doesn't need port configuration - uses process communication
+            throw new Error(`${TransportMode.STDIO} mode is not supported for server testing, because it uses process communication.`);
+    }
+    const serverPath = path.resolve(process.cwd(), 'build/index.js');
+    const serverProcess = spawn('node', [serverPath], {
+        env: serverEnv,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        detached: false
+    });
+    // Wait for server to start
+    await waitForServerStart(serverProcess, mode, port, timeout);
+    const instance = {
+        process: serverProcess,
+        port: port,
+        mode,
+        kill: () => {
+            if (!serverProcess.killed) {
+                serverProcess.kill('SIGTERM');
+                // Force kill if not terminated within 5 seconds
+                setTimeout(() => {
+                    if (!serverProcess.killed) {
+                        serverProcess.kill('SIGKILL');
+                    }
+                }, 5000);
+            }
+        }
+    };
+    return instance;
+}
+/**
+ * Wait for server to start based on transport mode
+ */
+async function waitForServerStart(process, mode, port, timeout) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`Server failed to start within ${timeout}ms for mode ${mode}`));
+        }, timeout);
+        let outputBuffer = '';
+        const onData = (data) => {
+            const output = data.toString();
+            outputBuffer += output;
+            // Check for server start messages
+            const startMessages = [
+                'Starting GitLab MCP Server with stdio transport',
+                'Starting GitLab MCP Server with SSE transport',
+                'Starting GitLab MCP Server with Streamable HTTP transport',
+                'GitLab MCP Server running',
+                `port ${port}`
+            ];
+            const hasStartMessage = startMessages.some(msg => outputBuffer.includes(msg));
+            if (hasStartMessage) {
+                clearTimeout(timer);
+                process.stdout?.removeListener('data', onData);
+                process.stderr?.removeListener('data', onData);
+                // Additional wait for HTTP servers to be fully ready
+                if (mode !== TransportMode.STDIO) {
+                    setTimeout(resolve, 1000);
+                }
+                else {
+                    resolve();
+                }
+            }
+        };
+        const onError = (error) => {
+            clearTimeout(timer);
+            reject(new Error(`Server process error: ${error.message}`));
+        };
+        const onExit = (code) => {
+            clearTimeout(timer);
+            reject(new Error(`Server process exited with code ${code} before starting`));
+        };
+        process.stdout?.on('data', onData);
+        process.stderr?.on('data', onData);
+        process.on('error', onError);
+        process.on('exit', onExit);
+    });
+}
+/**
+ * Find an available port starting from a base port
+ */
+export async function findAvailablePort(basePort = 3002) {
+    const net = await import('net');
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.listen(basePort, () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : basePort;
+            server.close(() => resolve(port));
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                // Port is in use, try next one
+                resolve(findAvailablePort(basePort + 1));
+            }
+            else {
+                reject(err);
+            }
+        });
+    });
+}
+/**
+ * Clean shutdown for multiple server instances
+ */
+export function cleanupServers(servers) {
+    servers.forEach(server => {
+        try {
+            server.kill();
+        }
+        catch (error) {
+            console.warn(`Failed to kill server process: ${error}`);
+        }
+    });
+}
+/**
+ * Create AbortController with timeout
+ */
+export function createTimeoutController(timeout) {
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), timeout);
+    return controller;
+}
+/**
+ * Check if a health endpoint is responding
+ */
+export async function checkHealthEndpoint(port, maxRetries = 5) {
+    let lastError;
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            const controller = createTimeoutController(5000);
+            const response = await fetch(`http://${HOST}:${port}/health`, {
+                method: 'GET',
+                signal: controller.signal
+            });
+            if (response.ok) {
+                const healthData = await response.json();
+                return healthData;
+            }
+            else {
+                throw new Error(`Health check failed with status ${response.status}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                lastError = new Error('Request timeout after 5000ms');
+            }
+            else {
+                lastError = error instanceof Error ? error : new Error(String(error));
+            }
+            if (i < maxRetries - 1) {
+                // Wait before retry
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+        }
+    }
+    throw lastError;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "1.0.67",
+  "version": "1.0.69",
   "description": "MCP server for using the GitLab API",
   "license": "MIT",
   "author": "zereight",
@@ -18,19 +18,21 @@
   "scripts": {
     "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
     "prepare": "npm run build",
+    "dev": "npm run build && node build/index.js",
     "watch": "tsc --watch",
     "deploy": "npm publish --access public",
     "generate-tools": "npx ts-node scripts/generate-tools-readme.ts",
     "changelog": "auto-changelog -p",
-    "test": "node test/validate-api.js",
+    "test": "node test/validate-api.js && npm run test:server",
     "test:integration": "node test/validate-api.js",
+    "test:server": "npm run build && node build/test/test-all-transport-server.js",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
     "format": "prettier --write \"**/*.{js,ts,json,md}\"",
     "format:check": "prettier --check \"**/*.{js,ts,json,md}\""
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.8.0",
+    "@modelcontextprotocol/sdk": "^1.10.0",
     "@types/node-fetch": "^2.6.12",
     "express": "^5.1.0",
     "fetch-cookie": "^3.1.0",