@cyanheads/git-mcp-server 2.2.2 → 2.2.3

package/dist/mcp-server/transports/http/httpTransport.js

@@ -0,0 +1,254 @@
+/**
+ * @fileoverview Configures and starts the HTTP MCP transport using Hono.
+ * This file has been refactored to correctly integrate Hono's streaming
+ * capabilities with the Model Context Protocol SDK's transport layer.
+ * @module src/mcp-server/transports/http/httpTransport
+ */
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { stream } from "hono/streaming";
+import http from "http";
+import { config } from "../../../config/index.js";
+import { logger, rateLimiter, requestContextService, } from "../../../utils/index.js";
+import { createAuthMiddleware, createAuthStrategy } from "../auth/index.js";
+import { StatefulTransportManager } from "../core/statefulTransportManager.js";
+import { StatelessTransportManager } from "../core/statelessTransportManager.js";
+import { httpErrorHandler } from "./httpErrorHandler.js";
+import { mcpTransportMiddleware } from "./mcpTransportMiddleware.js";
+const HTTP_PORT = config.mcpHttpPort;
+const HTTP_HOST = config.mcpHttpHost;
+const MCP_ENDPOINT_PATH = config.mcpHttpEndpointPath;
+/**
+ * Converts a Fetch API Headers object to Node.js IncomingHttpHeaders.
+ * Hono uses Fetch API Headers, but the underlying transport managers expect
+ * Node's native IncomingHttpHeaders.
+ * @param headers - The Headers object to convert.
+ * @returns An object compatible with IncomingHttpHeaders.
+ */
+async function isPortInUse(port, host, parentContext) {
+    const context = { ...parentContext, operation: "isPortInUse", port, host };
+    logger.debug(`Checking if port ${port} is in use...`, context);
+    return new Promise((resolve) => {
+        const tempServer = http.createServer();
+        tempServer
+            .once("error", (err) => {
+            const inUse = err.code === "EADDRINUSE";
+            logger.debug(`Port check resulted in error: ${err.code}. Port in use: ${inUse}`, context);
+            resolve(inUse);
+        })
+            .once("listening", () => {
+            logger.debug(`Successfully bound to port ${port} temporarily. Port is not in use.`, context);
+            tempServer.close(() => resolve(false));
+        })
+            .listen(port, host);
+    });
+}
+function startHttpServerWithRetry(app, initialPort, host, maxRetries, parentContext) {
+    const startContext = {
+        ...parentContext,
+        operation: "startHttpServerWithRetry",
+    };
+    logger.info(`Attempting to start HTTP server on port ${initialPort} with ${maxRetries} retries.`, startContext);
+    return new Promise((resolve, reject) => {
+        const tryBind = (port, attempt) => {
+            const attemptContext = { ...startContext, port, attempt };
+            if (attempt > maxRetries + 1) {
+                const error = new Error(`Failed to bind to any port after ${maxRetries} retries.`);
+                logger.fatal(error.message, attemptContext);
+                return reject(error);
+            }
+            isPortInUse(port, host, attemptContext)
+                .then((inUse) => {
+                if (inUse) {
+                    logger.warning(`Port ${port} is in use, retrying on port ${port + 1}...`, attemptContext);
+                    setTimeout(() => tryBind(port + 1, attempt + 1), config.mcpHttpPortRetryDelayMs);
+                    return;
+                }
+                try {
+                    const serverInstance = serve({ fetch: app.fetch, port, hostname: host }, (info) => {
+                        const serverAddress = `http://${info.address}:${info.port}${MCP_ENDPOINT_PATH}`;
+                        logger.info(`HTTP transport listening at ${serverAddress}`, {
+                            ...attemptContext,
+                            address: serverAddress,
+                            sessionMode: config.mcpSessionMode,
+                        });
+                        if (process.stdout.isTTY) {
+                            console.log(`\n🚀 MCP Server running at: ${serverAddress}`);
+                            console.log(`   Session Mode: ${config.mcpSessionMode}\n`);
+                        }
+                    });
+                    resolve(serverInstance);
+                }
+                catch (err) {
+                    if (err &&
+                        typeof err === "object" &&
+                        "code" in err &&
+                        err.code !== "EADDRINUSE") {
+                        const errorToLog = err instanceof Error ? err : new Error(String(err));
+                        logger.error("An unexpected error occurred while starting the server.", { ...attemptContext, error: errorToLog });
+                        return reject(err);
+                    }
+                    logger.warning(`Encountered EADDRINUSE race condition on port ${port}, retrying...`, attemptContext);
+                    setTimeout(() => tryBind(port + 1, attempt + 1), config.mcpHttpPortRetryDelayMs);
+                }
+            })
+                .catch((err) => {
+                logger.fatal("Failed to check if port is in use.", {
+                    ...attemptContext,
+                    error: err,
+                });
+                reject(err);
+            });
+        };
+        tryBind(initialPort, 1);
+    });
+}
+function createTransportManager(createServerInstanceFn, sessionMode, context) {
+    const opContext = {
+        ...context,
+        operation: "createTransportManager",
+        sessionMode,
+    };
+    logger.info(`Creating transport manager for session mode: ${sessionMode}`, opContext);
+    switch (sessionMode) {
+        case "stateless":
+            return new StatelessTransportManager(createServerInstanceFn);
+        case "stateful":
+            return new StatefulTransportManager(createServerInstanceFn);
+        case "auto":
+        default:
+            logger.info("Defaulting to 'auto' mode (stateful with stateless fallback).", opContext);
+            return new StatefulTransportManager(createServerInstanceFn);
+    }
+}
+export function createHttpApp(transportManager, createServerInstanceFn, parentContext) {
+    const app = new Hono();
+    const transportContext = {
+        ...parentContext,
+        component: "HttpTransportSetup",
+    };
+    logger.info("Creating Hono HTTP application.", transportContext);
+    app.use("*", cors({
+        origin: config.mcpAllowedOrigins || [],
+        allowMethods: ["GET", "POST", "DELETE", "OPTIONS"],
+        allowHeaders: [
+            "Content-Type",
+            "Mcp-Session-Id",
+            "Last-Event-ID",
+            "Authorization",
+        ],
+        credentials: true,
+    }));
+    app.use("*", async (c, next) => {
+        c.env.outgoing.setHeader("X-Content-Type-Options", "nosniff");
+        await next();
+    });
+    app.use(MCP_ENDPOINT_PATH, async (c, next) => {
+        const clientIp = c.req.header("x-forwarded-for")?.split(",")[0].trim() || "unknown_ip";
+        const context = requestContextService.createRequestContext({
+            operation: "httpRateLimitCheck",
+            ipAddress: clientIp,
+        });
+        try {
+            rateLimiter.check(clientIp, context);
+            logger.debug("Rate limit check passed.", context);
+        }
+        catch (error) {
+            logger.warning("Rate limit check failed.", {
+                ...context,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+        await next();
+    });
+    const authStrategy = createAuthStrategy();
+    if (authStrategy) {
+        logger.info("Authentication strategy found, enabling auth middleware.", transportContext);
+        app.use(MCP_ENDPOINT_PATH, createAuthMiddleware(authStrategy));
+    }
+    else {
+        logger.info("No authentication strategy found, auth middleware disabled.", transportContext);
+    }
+    app.onError(httpErrorHandler);
+    app.get("/healthz", (c) => {
+        return c.json({
+            status: "ok",
+            timestamp: new Date().toISOString(),
+        });
+    });
+    app.get(MCP_ENDPOINT_PATH, (c) => {
+        const sessionId = c.req.header("mcp-session-id");
+        if (sessionId) {
+            return c.text("GET requests to existing sessions are not supported.", 405);
+        }
+        return c.json({
+            status: "ok",
+            mode: "stateless",
+            message: "Server is running. Provide a Mcp-Session-Id header to stream from a session.",
+        });
+    });
+    app.post(MCP_ENDPOINT_PATH, mcpTransportMiddleware(transportManager, createServerInstanceFn), (c) => {
+        const response = c.get("mcpResponse");
+        if (response.sessionId) {
+            c.header("Mcp-Session-Id", response.sessionId);
+        }
+        response.headers.forEach((value, key) => {
+            c.header(key, value);
+        });
+        c.status(response.statusCode);
+        if (response.stream) {
+            return stream(c, async (s) => {
+                if (response.stream) {
+                    await s.pipe(response.stream);
+                }
+            });
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return c.json(response.body);
+        }
+    });
+    app.delete(MCP_ENDPOINT_PATH, async (c) => {
+        const sessionId = c.req.header("mcp-session-id");
+        const context = requestContextService.createRequestContext({
+            ...transportContext,
+            operation: "handleDeleteRequest",
+            sessionId,
+        });
+        if (sessionId) {
+            if (transportManager instanceof StatefulTransportManager) {
+                const response = await transportManager.handleDeleteRequest(sessionId, context);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return c.json(response.body, response.statusCode);
+            }
+            else {
+                return c.json({
+                    error: "Method Not Allowed",
+                    message: "DELETE operations are not supported in this mode.",
+                }, 405);
+            }
+        }
+        else {
+            return c.json({
+                status: "stateless_mode",
+                message: "No sessions to delete in stateless mode",
+            });
+        }
+    });
+    logger.info("Hono application setup complete.", transportContext);
+    return app;
+}
+export async function startHttpTransport(createServerInstanceFn, parentContext) {
+    const transportContext = {
+        ...parentContext,
+        component: "HttpTransportStart",
+    };
+    logger.info("Starting HTTP transport.", transportContext);
+    const transportManager = createTransportManager(createServerInstanceFn, config.mcpSessionMode, transportContext);
+    const app = createHttpApp(transportManager, createServerInstanceFn, transportContext);
+    const server = await startHttpServerWithRetry(app, HTTP_PORT, HTTP_HOST, config.mcpHttpMaxPortRetries, transportContext);
+    logger.info("HTTP transport started successfully.", transportContext);
+    return { app, server, transportManager };
+}

package/dist/mcp-server/transports/http/httpTypes.js

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Defines custom types for the Hono HTTP transport layer.
+ * @module src/mcp-server/transports/http/httpTypes
+ */
+export {};

package/dist/mcp-server/transports/http/index.js

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Barrel file for the HTTP transport module.
+ * @module src/mcp-server/transports/http/index
+ */
+export { createHttpApp, startHttpTransport } from "./httpTransport.js";
+export { httpErrorHandler } from "./httpErrorHandler.js";

package/dist/mcp-server/transports/http/mcpTransportMiddleware.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Hono middleware for handling MCP transport logic.
+ * This middleware encapsulates the logic for processing MCP requests,
+ * delegating to the appropriate transport manager, and preparing the
+ * response for Hono to send.
+ * @module src/mcp-server/transports/http/mcpTransportMiddleware
+ */
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { createMiddleware } from "hono/factory";
+import { config } from "../../../config/index.js";
+import { requestContextService } from "../../../utils/index.js";
+import { StatelessTransportManager } from "../core/statelessTransportManager.js";
+/**
+ * Converts a Fetch API Headers object to Node.js IncomingHttpHeaders.
+ * @param headers - The Headers object to convert.
+ * @returns An object compatible with IncomingHttpHeaders.
+ */
+function toIncomingHttpHeaders(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+}
+/**
+ * Handles a stateless request by creating an ephemeral transport manager.
+ * @param createServerInstanceFn - Function to create an McpServer instance.
+ * @param headers - The request headers.
+ * @param body - The request body.
+ * @param context - The request context.
+ * @returns A promise resolving with the transport response.
+ */
+async function handleStatelessRequest(createServerInstanceFn, headers, body, context) {
+    const statelessManager = new StatelessTransportManager(createServerInstanceFn);
+    return statelessManager.handleRequest(toIncomingHttpHeaders(headers), body, context);
+}
+export const mcpTransportMiddleware = (transportManager, createServerInstanceFn) => createMiddleware(async (c, next) => {
+    const sessionId = c.req.header("mcp-session-id");
+    const context = requestContextService.createRequestContext({
+        operation: "mcpTransportMiddleware",
+        sessionId,
+    });
+    const body = await c.req.json();
+    let response;
+    if (isInitializeRequest(body)) {
+        if (config.mcpSessionMode === "stateless") {
+            response = await handleStatelessRequest(createServerInstanceFn, c.req.raw.headers, body, context);
+        }
+        else {
+            response = await transportManager.initializeAndHandle(toIncomingHttpHeaders(c.req.raw.headers), body, context);
+        }
+    }
+    else {
+        if (sessionId) {
+            response = await transportManager.handleRequest(toIncomingHttpHeaders(c.req.raw.headers), body, context, sessionId);
+        }
+        else {
+            response = await handleStatelessRequest(createServerInstanceFn, c.req.raw.headers, body, context);
+        }
+    }
+    c.set("mcpResponse", response);
+    await next();
+});

package/dist/mcp-server/transports/stdio/index.js

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview Barrel file for the Stdio transport module.
+ * @module src/mcp-server/transports/stdio/index
+ */
+export { startStdioTransport } from "./stdioTransport.js";

package/dist/mcp-server/transports/{stdioTransport.js → stdio/stdioTransport.js}

@@ -18,7 +18,7 @@
  * @module src/mcp-server/transports/stdioTransport
  */
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ErrorHandler, logger } from "../../utils/index.js";
+import { ErrorHandler, logger } from "../../../utils/index.js";
 /**
  * Connects a given `McpServer` instance to the Stdio transport.
  * This function initializes the SDK's `StdioServerTransport`, which manages
@@ -39,13 +39,13 @@ import { ErrorHandler, logger } from "../../utils/index.js";
  * @returns A promise that resolves when the Stdio transport is successfully connected.
  * @throws {Error} If the connection fails during setup.
  */
-export async function connectStdioTransport(server, parentContext) {
+export async function startStdioTransport(server, parentContext) {
     const operationContext = {
         ...parentContext,
         operation: "connectStdioTransport",
         transportType: "Stdio",
     };
-    logger.debug("Attempting to connect stdio transport...", operationContext);
+    logger.info("Attempting to connect stdio transport...", operationContext);
     try {
         logger.debug("Creating StdioServerTransport instance...", operationContext);
         const transport = new StdioServerTransport();
@@ -57,7 +57,12 @@ export async function connectStdioTransport(server, parentContext) {
         }
     }
     catch (err) {
-        ErrorHandler.handleError(err, { ...operationContext, critical: true });
-        throw err; // Re-throw after handling to allow caller to react if necessary
+        // Let the ErrorHandler log the error with all context, then rethrow.
+        throw ErrorHandler.handleError(err, {
+            operation: "connectStdioTransport",
+            context: operationContext,
+            critical: true,
+            rethrow: true,
+        });
     }
 }

package/dist/types-global/errors.js

@@ -1,7 +1,16 @@
+/**
+ * @fileoverview Defines standardized error codes, a custom error class, and related schemas
+ * for handling errors within the Model Context Protocol (MCP) server and its components.
+ * This module provides a structured way to represent and communicate errors, ensuring
+ * consistency and clarity for both server-side operations and client-side error handling.
+ * @module src/types-global/errors
+ */
 import { z } from "zod";
 /**
- * Defines a set of standardized error codes for common issues within MCP servers or tools.
- * These codes help clients understand the nature of an error programmatically.
+ * Defines a comprehensive set of standardized error codes for common issues encountered
+ * within MCP servers, tools, or related operations. These codes are designed to help
+ * clients and developers programmatically understand the nature of an error, facilitating
+ * more precise error handling and debugging.
  */
 export var BaseErrorCode;
 (function (BaseErrorCode) {
@@ -15,6 +24,8 @@ export var BaseErrorCode;
     BaseErrorCode["CONFLICT"] = "CONFLICT";
     /** The request failed due to invalid input parameters or data. */
     BaseErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    /** The provided input is invalid for the operation. */
+    BaseErrorCode["INVALID_INPUT"] = "INVALID_INPUT";
     /** An error occurred while parsing input data (e.g., date string, JSON). */
     BaseErrorCode["PARSING_ERROR"] = "PARSING_ERROR";
     /** The request was rejected because the client has exceeded rate limits. */
@@ -29,45 +40,90 @@ export var BaseErrorCode;
     BaseErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
     /** An error occurred during the loading or validation of configuration data. */
     BaseErrorCode["CONFIGURATION_ERROR"] = "CONFIGURATION_ERROR";
+    /** An error occurred during the initialization phase of a service or module. */
+    BaseErrorCode["INITIALIZATION_FAILED"] = "INITIALIZATION_FAILED";
+    /** A service was used before it was properly initialized. */
+    BaseErrorCode["SERVICE_NOT_INITIALIZED"] = "SERVICE_NOT_INITIALIZED";
+    /** A generic error occurred during a database operation. */
+    BaseErrorCode["DATABASE_ERROR"] = "DATABASE_ERROR";
+    /** An error occurred while loading or interacting with an extension. */
+    BaseErrorCode["EXTENSION_ERROR"] = "EXTENSION_ERROR";
+    /** An error occurred during the shutdown phase of a service or module. */
+    BaseErrorCode["SHUTDOWN_ERROR"] = "SHUTDOWN_ERROR";
+    /** A generic error occurred during the execution of an agent's task. */
+    BaseErrorCode["AGENT_EXECUTION_ERROR"] = "AGENT_EXECUTION_ERROR";
 })(BaseErrorCode || (BaseErrorCode = {}));
 /**
- * Custom error class for MCP-specific errors.
- * Encapsulates a `BaseErrorCode`, a descriptive message, and optional details.
- * Provides a method to format the error into a standard MCP tool response.
+ * Custom error class for MCP-specific errors, extending the built-in `Error` class.
+ * It standardizes error reporting by encapsulating a `BaseErrorCode`, a descriptive
+ * human-readable message, and optional structured details for more context.
+ *
+ * This class is central to error handling within the MCP framework, allowing for
+ * consistent error creation and propagation.
  */
 export class McpError extends Error {
+    /**
+     * The standardized error code from {@link BaseErrorCode}.
+     */
     code;
+    /**
+     * Optional additional details or context about the error.
+     * This can be any structured data that helps in understanding or debugging the error.
+     */
     details;
     /**
      * Creates an instance of McpError.
-     * @param {BaseErrorCode} code - The standardized error code.
-     * @param {string} message - A human-readable description of the error.
-     * @param {Record<string, unknown>} [details] - Optional additional details about the error.
+     *
+     * @param code - The standardized error code that categorizes the error.
+     * @param message - A human-readable description of the error.
+     * @param details - Optional. A record containing additional structured details about the error.
      */
     constructor(code, message, details) {
         super(message);
         this.code = code;
         this.details = details;
-        // Set the error name for identification
         this.name = "McpError";
-        // Ensure the prototype chain is correct
+        // Maintain a proper prototype chain.
         Object.setPrototypeOf(this, McpError.prototype);
+        // Capture the stack trace, excluding the constructor call from it, if available.
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, McpError);
+        }
     }
 }
 /**
- * Zod schema for validating error objects, potentially used for parsing
- * error responses or validating error structures internally.
+ * Zod schema for validating error objects. This schema can be used for:
+ * - Validating error structures when parsing error responses from external services.
+ * - Ensuring consistency when creating or handling error objects internally.
+ * - Generating TypeScript types for error objects.
+ *
+ * The schema enforces the presence of a `code` (from {@link BaseErrorCode}) and a `message`,
+ * and allows for optional `details`.
  */
 export const ErrorSchema = z
     .object({
-    /** The error code, corresponding to BaseErrorCode enum values. */
-    code: z.nativeEnum(BaseErrorCode).describe("Standardized error code"),
-    /** A human-readable description of the error. */
-    message: z.string().describe("Detailed error message"),
-    /** Optional additional details or context about the error. */
+    /**
+     * The error code, corresponding to one of the {@link BaseErrorCode} enum values.
+     * This field is required and helps in programmatically identifying the error type.
+     */
+    code: z
+        .nativeEnum(BaseErrorCode)
+        .describe("Standardized error code from BaseErrorCode enum"),
+    /**
+     * A human-readable, descriptive message explaining the error.
+     * This field is required and provides context to developers or users.
+     */
+    message: z
+        .string()
+        .min(1, "Error message cannot be empty.")
+        .describe("Detailed human-readable error message"),
+    /**
+     * Optional. A record containing additional structured details or context about the error.
+     * This can include things like invalid field names, specific values that caused issues, or other relevant data.
+     */
     details: z
         .record(z.unknown())
         .optional()
-        .describe("Optional structured error details"),
+        .describe("Optional structured details providing more context about the error"),
 })
-    .describe("Schema for validating structured error objects.");
+    .describe("Schema for validating structured error objects, ensuring consistency in error reporting.");

package/dist/utils/internal/errorHandler.js

@@ -133,28 +133,26 @@ export class ErrorHandler {
         const { context, operation, input, rethrow = false, errorCode: explicitErrorCode, includeStack = true, critical = false, } = options;
         // If it's already an McpError, use it directly but apply additional context
         if (error instanceof McpError) {
-            // Add any additional context
-            if (context && Object.keys(context).length > 0) {
-                // Ensure details is an object before spreading
-                const existingDetails = typeof error.details === "object" && error.details !== null
-                    ? error.details
-                    : {};
-                error.details = { ...existingDetails, ...context };
-            }
+            const existingDetails = typeof error.details === "object" && error.details !== null
+                ? error.details
+                : {};
+            const newDetails = { ...existingDetails, ...context };
+            // Create a new error to avoid mutating a readonly property
+            const updatedError = new McpError(error.code, error.message, newDetails);
             // Log the error with sanitized input
-            logger.error(`Error ${operation}: ${error.message}`, {
-                errorCode: error.code,
+            logger.error(`Error ${operation}: ${updatedError.message}`, {
+                errorCode: updatedError.code,
                 requestId: context?.requestId,
                 input: input ? sanitizeInputForLogging(input) : undefined,
-                stack: includeStack ? error.stack : undefined,
+                stack: includeStack ? updatedError.stack : undefined,
                 critical,
                 ...context,
             });
             if (rethrow) {
-                throw error;
+                throw updatedError;
             }
             // Ensure the function returns an Error type
-            return error;
+            return updatedError;
         }
         // Sanitize input for logging
         const sanitizedInput = input ? sanitizeInputForLogging(input) : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyanheads/git-mcp-server",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "An MCP (Model Context Protocol) server enabling LLMs and AI agents to interact with Git repositories. Provides tools for comprehensive Git operations including clone, commit, branch, diff, log, status, push, pull, merge, rebase, worktree, tag management, and more, via the MCP standard. STDIO & HTTP.",
   "main": "dist/index.js",
   "files": [
@@ -32,19 +32,22 @@
     "format": "prettier --write \"**/*.{ts,js,json,md,html,css}\"",
     "inspector": "npx @modelcontextprotocol/inspector --config mcp.json --server git-mcp-server",
     "inspector:http": "npx @modelcontextprotocol/inspector --config mcp.json --server git-mcp-server-http",
-    "clean": "ts-node --esm scripts/clean.ts"
+    "clean": "ts-node --esm scripts/clean.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "@hono/node-server": "^1.17.1",
-    "@modelcontextprotocol/sdk": "^1.16.0",
-    "@types/node": "^24.0.15",
+    "@modelcontextprotocol/sdk": "^1.17.0",
+    "@types/node": "^24.1.0",
     "@types/sanitize-html": "^2.16.0",
     "@types/validator": "^13.15.2",
     "chrono-node": "2.8.0",
     "dotenv": "16.6.1",
-    "hono": "^4.8.5",
+    "hono": "^4.8.10",
     "jose": "^6.0.12",
-    "openai": "^5.10.1",
+    "openai": "^5.10.2",
     "partial-json": "^0.1.7",
     "sanitize-html": "^2.17.0",
     "tiktoken": "^1.0.21",
@@ -105,8 +108,16 @@
     "node": ">=20.0.0"
   },
   "devDependencies": {
+    "@anatine/zod-mock": "^3.14.0",
+    "@faker-js/faker": "^9.9.0",
+    "@types/supertest": "^6.0.3",
+    "@vitest/coverage-v8": "^3.2.4",
+    "msw": "^2.10.4",
     "prettier": "^3.6.2",
-    "typedoc": "^0.28.7"
+    "supertest": "^7.1.4",
+    "typedoc": "^0.28.8",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.2.4"
   },
   "publishConfig": {
     "access": "public"

package/dist/mcp-server/transports/auth/core/authTypes.js

@@ -1,5 +0,0 @@
-/**
- * @fileoverview Shared types for authentication middleware.
- * @module src/mcp-server/transports/auth/core/auth.types
- */
-export {};