@cyanheads/git-mcp-server 2.1.3 → 2.1.5

package/README.md

@@ -2,7 +2,7 @@
 
 [![TypeScript](https://img.shields.io/badge/TypeScript-^5.8.3-blue.svg)](https://www.typescriptlang.org/)
 [![Model Context Protocol](https://img.shields.io/badge/MCP%20SDK-^1.13.0-green.svg)](https://modelcontextprotocol.io/)
-[![Version](https://img.shields.io/badge/Version-2.1.3-blue.svg)](./CHANGELOG.md)
+[![Version](https://img.shields.io/badge/Version-2.1.4-blue.svg)](./CHANGELOG.md)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Status](https://img.shields.io/badge/Status-Stable-green.svg)](https://github.com/cyanheads/git-mcp-server/issues)
 [![GitHub](https://img.shields.io/github/stars/cyanheads/git-mcp-server?style=social)](https://github.com/cyanheads/git-mcp-server)
@@ -29,10 +29,9 @@ This server equips your AI with a comprehensive suite of tools to interact with
 
 ## Table of Contents
 
-| [Overview](#overview)           | [Features](#features)                   | [Installation](#installation) |
-| :------------------------------ | :-------------------------------------- | :---------------------------- | ------------------- |
+| [Overview](#overview) | [Features](#features) | [Installation](#installation) |
 | [Configuration](#configuration) | [Project Structure](#project-structure) |
-| [Tools](#tools)                 | [Resources](#resources)                 | [Development](#development)   | [License](#license) |
+| [Tools](#tools) | [Resources](#resources) | [Development](#development) | [License](#license) |
 
 ## Overview
 
@@ -61,7 +60,7 @@ Leverages the robust utilities provided by the `mcp-ts-template`:
 - **Input Validation/Sanitization**: Uses `zod` for schema validation and custom sanitization logic (crucial for paths).
 - **Request Context**: Tracking and correlation of operations via unique request IDs using `AsyncLocalStorage`.
 - **Type Safety**: Strong typing enforced by TypeScript and Zod schemas.
-- **HTTP Transport**: High-performance HTTP server using **Hono**, featuring session management with garbage collection, CORS, and IP-based rate limiting.
+- **HTTP Transport**: High-performance HTTP server using **Hono**, featuring session management, CORS, and authentication support.
 - **Deployment**: Multi-stage `Dockerfile` for creating small, secure production images with native dependency support.
 
 ### Git Integration
@@ -100,7 +99,7 @@ Add the following to your MCP client's configuration file (e.g., `cline_mcp_sett
 }
 ```
 
-### If running manually (not via MCP client for development or testing)
+### If running manually (not via MCP client) for development or testing
 
 #### Install via npm
 
@@ -143,7 +142,10 @@ Configure the server using environment variables. These environmental variables
 | `MCP_ALLOWED_ORIGINS` | Comma-separated list of allowed origins for CORS (if `MCP_TRANSPORT_TYPE=http`).                                                      | (none)      |
 | `MCP_LOG_LEVEL`       | Logging level (`debug`, `info`, `notice`, `warning`, `error`, `crit`, `alert`, `emerg`). Inherited from template.                     | `info`      |
 | `GIT_SIGN_COMMITS`    | Set to `"true"` to enable signing attempts for commits made by the `git_commit` tool. Requires server-side Git/key setup (see below). | `false`     |
-| `MCP_AUTH_SECRET_KEY` | Secret key for signing/verifying authentication tokens (required if auth is enabled in the future).                                   | `''`        |
+| `MCP_AUTH_MODE`       | Authentication mode: `jwt`, `oauth`, or `none`.                                                                                       | `none`      |
+| `MCP_AUTH_SECRET_KEY` | Secret key for JWT validation (if `MCP_AUTH_MODE=jwt`).                                                                               | `''`        |
+| `OAUTH_ISSUER_URL`    | OIDC issuer URL for OAuth validation (if `MCP_AUTH_MODE=oauth`).                                                                      | `''`        |
+| `OAUTH_AUDIENCE`      | Audience claim for OAuth validation (if `MCP_AUTH_MODE=oauth`).                                                                       | `''`        |
 
 ## Project Structure
 
@@ -201,7 +203,7 @@ _Note: The `path` parameter for most tools defaults to the session's working dir
 
 ## Resources
 
-**MCP Resources are not implemented in this version (v2.1.2).**
+**MCP Resources are not implemented in this version (v2.1.4).**
 
 This version focuses on the refactored Git tools implementation based on the latest `mcp-ts-template` and MCP SDK v1.13.0. Resource capabilities, previously available, have been temporarily removed during this major update.
 

package/dist/config/index.js

@@ -40,14 +40,22 @@ export const config = {
     mcpAllowedOrigins: process.env.MCP_ALLOWED_ORIGINS?.split(",") || [],
     /** Flag to enable GPG signing for commits made by the git_commit tool. Requires server-side GPG setup. */
     gitSignCommits: process.env.GIT_SIGN_COMMITS === "true",
+    /** The authentication mode ('jwt', 'oauth', or 'none'). Defaults to 'none'. */
+    mcpAuthMode: process.env.MCP_AUTH_MODE || "none",
+    /** Secret key for signing/verifying JWTs. Required if mcpAuthMode is 'jwt'. */
+    mcpAuthSecretKey: process.env.MCP_AUTH_SECRET_KEY,
+    /** The OIDC issuer URL for OAuth token validation. Required if mcpAuthMode is 'oauth'. */
+    oauthIssuerUrl: process.env.OAUTH_ISSUER_URL,
+    /** The audience claim for OAuth token validation. Required if mcpAuthMode is 'oauth'. */
+    oauthAudience: process.env.OAUTH_AUDIENCE,
+    /** The JWKS URI for fetching public keys for OAuth. Optional, can be derived from issuer URL. */
+    oauthJwksUri: process.env.OAUTH_JWKS_URI,
     /** Security-related configurations. */
     security: {
         // Placeholder for security settings
         // Example: authRequired: process.env.AUTH_REQUIRED === 'true'
         /** Indicates if authentication is required for server operations. */
         authRequired: false,
-        /** Secret key for signing/verifying authentication tokens (required if authRequired is true). */
-        mcpAuthSecretKey: process.env.MCP_AUTH_SECRET_KEY || "", // Default to empty string, validation should happen elsewhere
     },
     // Note: mcpClient configuration is now loaded separately from mcp-config.json
 };

package/dist/mcp-server/server.js

@@ -43,9 +43,9 @@ import { initializeGitStatusStateAccessors, registerGitStatusTool, } from "./too
 import { initializeGitTagStateAccessors, registerGitTagTool, } from "./tools/gitTag/index.js";
 import { initializeGitWorktreeStateAccessors, registerGitWorktreeTool, } from "./tools/gitWorktree/index.js";
 import { initializeGitWrapupInstructionsStateAccessors, registerGitWrapupInstructionsTool, } from "./tools/gitWrapupInstructions/index.js";
-// Import transport setup functions AND state accessors
-import { getHttpSessionWorkingDirectory, setHttpSessionWorkingDirectory, startHttpTransport, } from "./transports/httpTransport.js";
-import { connectStdioTransport, getStdioWorkingDirectory, setStdioWorkingDirectory, } from "./transports/stdioTransport.js";
+// Import transport setup functions
+import { startHttpTransport } from "./transports/httpTransport.js";
+import { connectStdioTransport } from "./transports/stdioTransport.js";
 /**
  * Creates and configures a new instance of the McpServer.
  *
@@ -79,7 +79,9 @@ import { connectStdioTransport, getStdioWorkingDirectory, setStdioWorkingDirecto
  */
 // Removed sessionId parameter, it will be retrieved from context within tool handlers
 async function createMcpServerInstance() {
-    const context = { operation: "createMcpServerInstance" };
+    const context = requestContextService.createRequestContext({
+        operation: "createMcpServerInstance",
+    });
     logger.info("Initializing MCP server instance", context);
     // Configure the request context service (used for correlating logs/errors).
     requestContextService.configure({
@@ -110,6 +112,9 @@ async function createMcpServerInstance() {
             tools: { listChanged: true },
         },
     });
+    // Each server instance is isolated per session. This variable will hold the
+    // working directory for the duration of this session.
+    let sessionWorkingDirectory = undefined;
     // --- Define Unified State Accessor Functions ---
     // These functions abstract away the transport type to get/set session state.
     /** Gets the session ID from the tool's execution context. */
@@ -117,34 +122,21 @@ async function createMcpServerInstance() {
         // The RequestContext created by the tool registration wrapper should contain the sessionId.
         return toolContext?.sessionId;
     };
-    /** Gets the working directory based on transport type and session ID. */
+    /** Gets the working directory for the current session. */
     const getWorkingDirectory = (sessionId) => {
-        if (config.mcpTransportType === "http") {
-            if (!sessionId) {
-                logger.warning("Attempted to get HTTP working directory without session ID", { ...context, caller: "getWorkingDirectory" });
-                return undefined;
-            }
-            return getHttpSessionWorkingDirectory(sessionId);
-        }
-        else {
-            // For stdio, there's only one implicit session, ID is not needed.
-            return getStdioWorkingDirectory();
-        }
+        // The working directory is now stored in a variable scoped to this server instance.
+        // The sessionId is kept for potential logging or more complex future state management.
+        return sessionWorkingDirectory;
     };
-    /** Sets the working directory based on transport type and session ID. */
+    /** Sets the working directory for the current session. */
     const setWorkingDirectory = (sessionId, dir) => {
-        if (config.mcpTransportType === "http") {
-            if (!sessionId) {
-                logger.error("Attempted to set HTTP working directory without session ID", { ...context, caller: "setWorkingDirectory", dir });
-                // Optionally throw an error or just log
-                return;
-            }
-            setHttpSessionWorkingDirectory(sessionId, dir);
-        }
-        else {
-            // For stdio, set the single session's directory.
-            setStdioWorkingDirectory(dir);
-        }
+        // The working directory is now stored in a variable scoped to this server instance.
+        logger.debug("Setting session working directory", {
+            ...context,
+            sessionId,
+            newDirectory: dir,
+        });
+        sessionWorkingDirectory = dir;
     };
     // --- Initialize Tool State Accessors BEFORE Registration ---
     // Pass the defined unified accessor functions to the initializers.
@@ -254,7 +246,10 @@ async function createMcpServerInstance() {
 async function startTransport() {
     // Determine the transport type from the validated configuration.
     const transportType = config.mcpTransportType;
-    const context = { operation: "startTransport", transport: transportType };
+    const context = requestContextService.createRequestContext({
+        operation: "startTransport",
+        transport: transportType,
+    });
     logger.info(`Starting transport: ${transportType}`, context);
     // --- HTTP Transport Setup ---
     if (transportType === "http") {
@@ -294,7 +289,9 @@ async function startTransport() {
  * @returns {Promise<void | McpServer>} Resolves upon successful startup (void for http, McpServer for stdio). Rejects on critical failure.
  */
 export async function initializeAndStartServer() {
-    const context = { operation: "initializeAndStartServer" };
+    const context = requestContextService.createRequestContext({
+        operation: "initializeAndStartServer",
+    });
     logger.info("MCP Server initialization sequence started.", context);
     try {
         // Initiate the transport setup based on configuration.
@@ -310,7 +307,11 @@ export async function initializeAndStartServer() {
             stack: err instanceof Error ? err.stack : undefined,
         });
         // Use the centralized error handler for consistent critical error reporting.
-        ErrorHandler.handleError(err, { ...context, critical: true });
+        ErrorHandler.handleError(err, {
+            ...context,
+            operation: "initializeAndStartServer_Catch",
+            critical: true,
+        });
         // Exit the process with a non-zero code to indicate failure.
         logger.info("Exiting process due to critical initialization error.", context);
         process.exit(1);

package/dist/mcp-server/tools/gitAdd/logic.js

@@ -1,4 +1,4 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
 // Import utils from barrel (logger from ../utils/internal/logger.js)
@@ -7,7 +7,7 @@ import { logger } from "../../../utils/index.js";
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
 // Import utils from barrel (sanitization from ../utils/security/sanitization.js)
 import { sanitization } from "../../../utils/index.js";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 // Define the input schema for the git_add tool using Zod
 export const GitAddInputSchema = z.object({
     path: z
@@ -76,52 +76,25 @@ export async function addGitFiles(input, context) {
         }
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
     }
-    // Prepare the files argument for the command, ensuring proper quoting
-    let filesArg;
-    const filesToStage = input.files; // Keep original for reporting
-    try {
-        if (Array.isArray(filesToStage)) {
-            if (filesToStage.length === 0) {
-                logger.warning("Empty array provided for files, defaulting to staging all changes.", { ...context, operation });
-                filesArg = "."; // Default to staging all if array is empty
-            }
-            else {
-                // Quote each file path individually
-                filesArg = filesToStage
-                    .map((file) => {
-                    const sanitizedFile = file.startsWith("-") ? `./${file}` : file; // Prefix with './' if it starts with a dash
-                    return `"${sanitizedFile.replace(/"/g, '\\"')}"`; // Escape quotes within path
-                })
-                    .join(" ");
-            }
-        }
-        else {
-            // Single string case
-            const sanitizedFile = filesToStage.startsWith("-")
-                ? `./${filesToStage}`
-                : filesToStage; // Prefix with './' if it starts with a dash
-            filesArg = `"${sanitizedFile.replace(/"/g, '\\"')}"`;
-        }
+    const filesToStage = Array.isArray(input.files)
+        ? input.files
+        : [input.files];
+    if (filesToStage.length === 0) {
+        filesToStage.push("."); // Default to staging all if array is empty
     }
-    catch (err) {
-        logger.error("File path validation/quoting failed", {
+    try {
+        const args = ["-C", targetPath, "add", "--"];
+        filesToStage.forEach((file) => {
+            // Sanitize each file path. Although execFile is safer,
+            // this prevents arguments like "-v" from being treated as flags by git.
+            const sanitizedFile = file.startsWith("-") ? `./${file}` : file;
+            args.push(sanitizedFile);
+        });
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
             ...context,
             operation,
-            files: filesToStage,
-            error: err,
         });
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid file path/pattern provided: ${err instanceof Error ? err.message : String(err)}`, { context, operation, originalError: err });
-    }
-    // This check should ideally not be needed now due to the logic above
-    if (!filesArg) {
-        logger.error("Internal error: filesArg is unexpectedly empty after processing.", { ...context, operation });
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, "Internal error preparing git add command.", { context, operation });
-    }
-    try {
-        // Use the resolved targetPath
-        const command = `git -C "${targetPath}" add -- ${filesArg}`;
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
-        const { stdout, stderr } = await execAsync(command);
+        const { stdout, stderr } = await execFileAsync("git", args);
         if (stderr) {
             // Log stderr as warning, as 'git add' can produce warnings but still succeed.
             logger.warning(`Git add command produced stderr`, {
@@ -162,7 +135,7 @@ export async function addGitFiles(input, context) {
         }
         if (errorMessage.toLowerCase().includes("did not match any files")) {
             // Still throw an error, but return structured info in the catch block of the registration
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Specified files/patterns did not match any files in ${targetPath}: ${filesArg}`, { context, operation, originalError: error, filesStaged: filesToStage });
+            throw new McpError(BaseErrorCode.NOT_FOUND, `Specified files/patterns did not match any files in ${targetPath}: ${filesToStage.join(", ")}`, { context, operation, originalError: error, filesStaged: filesToStage });
         }
         // Throw generic error for other cases
         throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to stage files for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error, filesStaged: filesToStage });

package/dist/mcp-server/tools/gitBranch/logic.js

@@ -1,4 +1,4 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
 // Import utils from barrel (logger from ../utils/internal/logger.js)
@@ -7,7 +7,7 @@ import { logger } from "../../../utils/index.js";
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
 // Import utils from barrel (sanitization from ../utils/security/sanitization.js)
 import { sanitization } from "../../../utils/index.js";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 // Define the BASE input schema for the git_branch tool using Zod
 export const GitBranchBaseSchema = z.object({
     path: z
@@ -115,21 +115,23 @@ export async function gitBranchLogic(input, context) {
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
     }
     try {
-        let command;
+        let args;
         let result;
         switch (input.mode) {
             case "list":
-                command = `git -C "${targetPath}" branch --list --no-color`; // Start with basic list
-                if (input.all)
-                    command += " -a"; // Add -a if requested
-                else if (input.remote)
-                    command += " -r"; // Add -r if requested (exclusive with -a)
-                command += " --verbose"; // Add verbose for commit info
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "branch", "--list", "--no-color"]; // Start with basic list
+                if (input.all) {
+                    args.push("-a"); // Add -a if requested
+                }
+                else if (input.remote) {
+                    args.push("-r"); // Add -r if requested (exclusive with -a)
+                }
+                args.push("--verbose"); // Add verbose for commit info
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                const { stdout: listStdout } = await execAsync(command);
+                const { stdout: listStdout } = await execFileAsync("git", args);
                 const branches = listStdout
                     .trim()
                     .split("\n")
@@ -157,17 +159,19 @@ export async function gitBranchLogic(input, context) {
                 break;
             case "create":
                 // branchName is validated by Zod refine
-                command = `git -C "${targetPath}" branch `;
-                if (input.force)
-                    command += "-f ";
-                command += `"${input.branchName}"`; // branchName is guaranteed by refine
-                if (input.startPoint)
-                    command += ` "${input.startPoint}"`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "branch"];
+                if (input.force) {
+                    args.push("-f");
+                }
+                args.push(input.branchName); // branchName is guaranteed by refine
+                if (input.startPoint) {
+                    args.push(input.startPoint);
+                }
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                await execAsync(command);
+                await execFileAsync("git", args);
                 result = {
                     success: true,
                     mode: "create",
@@ -177,16 +181,17 @@ export async function gitBranchLogic(input, context) {
                 break;
             case "delete":
                 // branchName is validated by Zod refine
-                command = `git -C "${targetPath}" branch `;
-                if (input.remote)
-                    command += "-r ";
-                command += input.force ? "-D " : "-d ";
-                command += `"${input.branchName}"`; // branchName is guaranteed by refine
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "branch"];
+                if (input.remote) {
+                    args.push("-r");
+                }
+                args.push(input.force ? "-D" : "-d");
+                args.push(input.branchName); // branchName is guaranteed by refine
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                const { stdout: deleteStdout } = await execAsync(command);
+                const { stdout: deleteStdout } = await execFileAsync("git", args);
                 result = {
                     success: true,
                     mode: "delete",
@@ -198,14 +203,14 @@ export async function gitBranchLogic(input, context) {
                 break;
             case "rename":
                 // branchName and newBranchName validated by Zod refine
-                command = `git -C "${targetPath}" branch `;
-                command += input.force ? "-M " : "-m ";
-                command += `"${input.branchName}" "${input.newBranchName}"`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "branch"];
+                args.push(input.force ? "-M" : "-m");
+                args.push(input.branchName, input.newBranchName);
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                await execAsync(command);
+                await execFileAsync("git", args);
                 result = {
                     success: true,
                     mode: "rename",
@@ -215,13 +220,13 @@ export async function gitBranchLogic(input, context) {
                 };
                 break;
             case "show-current":
-                command = `git -C "${targetPath}" branch --show-current`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "branch", "--show-current"];
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
                 try {
-                    const { stdout: currentStdout } = await execAsync(command);
+                    const { stdout: currentStdout } = await execFileAsync("git", args);
                     const currentBranchName = currentStdout.trim();
                     result = {
                         success: true,

package/dist/mcp-server/tools/gitCheckout/logic.js

@@ -1,4 +1,4 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
 // Import utils from barrel (logger from ../utils/internal/logger.js)
@@ -7,7 +7,7 @@ import { logger } from "../../../utils/index.js";
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
 // Import utils from barrel (sanitization from ../utils/security/sanitization.js)
 import { sanitization } from "../../../utils/index.js";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 // Define the input schema for the git_checkout tool using Zod
 export const GitCheckoutInputSchema = z.object({
     path: z
@@ -75,22 +75,22 @@ export async function checkoutGit(input, context) {
             throw error;
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
     }
-    // Basic sanitization for branch/path argument
-    const safeBranchOrPath = input.branchOrPath.replace(/[`$&;*()|<>]/g, ""); // Remove potentially dangerous characters
     try {
         // Construct the git checkout command
-        let command = `git -C "${targetPath}" checkout`;
+        const args = ["-C", targetPath, "checkout"];
         if (input.force) {
-            command += " --force";
+            args.push("--force");
         }
         if (input.newBranch) {
-            const safeNewBranch = input.newBranch.replace(/[^a-zA-Z0-9_.\-/]/g, ""); // Sanitize new branch name
-            command += ` -b ${safeNewBranch}`;
+            args.push("-b", input.newBranch);
         }
-        command += ` ${safeBranchOrPath}`; // Add the target branch/path
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        args.push(input.branchOrPath); // Add the target branch/path
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
         // Execute command. Checkout often uses stderr for status messages.
-        const { stdout, stderr } = await execAsync(command);
+        const { stdout, stderr } = await execFileAsync("git", args);
         const message = stderr.trim() || stdout.trim();
         logger.debug(`Git checkout stdout: ${stdout}`, { ...context, operation });
         if (stderr) {
@@ -99,7 +99,12 @@ export async function checkoutGit(input, context) {
         // Get the current branch name after the checkout operation
         let currentBranch;
         try {
-            const { stdout: branchStdout } = await execAsync(`git -C "${targetPath}" branch --show-current`);
+            const { stdout: branchStdout } = await execFileAsync("git", [
+                "-C",
+                targetPath,
+                "branch",
+                "--show-current",
+            ]);
             currentBranch = branchStdout.trim();
         }
         catch (e) {

package/dist/mcp-server/tools/gitCherryPick/logic.js

@@ -1,4 +1,4 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
 // Import utils from barrel (logger from ../utils/internal/logger.js)
@@ -7,7 +7,7 @@ import { logger } from "../../../utils/index.js";
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
 // Import utils from barrel (sanitization from ../utils/security/sanitization.js)
 import { sanitization } from "../../../utils/index.js";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 // Define the input schema for the git_cherry-pick tool using Zod
 export const GitCherryPickInputSchema = z.object({
     path: z
@@ -95,20 +95,27 @@ export async function gitCherryPickLogic(input, context) {
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
     }
     try {
-        let command = `git -C "${targetPath}" cherry-pick`;
-        if (input.mainline)
-            command += ` -m ${input.mainline}`;
-        if (input.strategy)
-            command += ` -X${input.strategy}`; // Note: -X for strategy options
-        if (input.noCommit)
-            command += " --no-commit";
-        if (input.signoff)
-            command += " --signoff";
-        // Add the commit reference(s) - ensure it's treated as a single argument potentially containing special chars like '..'
-        command += ` "${input.commitRef.replace(/"/g, '\\"')}"`;
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        const args = ["-C", targetPath, "cherry-pick"];
+        if (input.mainline) {
+            args.push("-m", String(input.mainline));
+        }
+        if (input.strategy) {
+            args.push(`-X${input.strategy}`);
+        } // Note: -X for strategy options
+        if (input.noCommit) {
+            args.push("--no-commit");
+        }
+        if (input.signoff) {
+            args.push("--signoff");
+        }
+        // Add the commit reference(s)
+        args.push(input.commitRef);
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
         try {
-            const { stdout, stderr } = await execAsync(command);
+            const { stdout, stderr } = await execFileAsync("git", args);
             // Check stdout/stderr for conflict messages, although exit code 0 usually means success
             const output = stdout + stderr;
             const conflicts = /conflict/i.test(output);

package/dist/mcp-server/tools/gitClean/logic.js

@@ -1,4 +1,4 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
 // Import utils from barrel (logger from ../utils/internal/logger.js)
@@ -7,7 +7,7 @@ import { logger } from "../../../utils/index.js";
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
 // Import utils from barrel (sanitization from ../utils/security/sanitization.js)
 import { sanitization } from "../../../utils/index.js";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 // Define the input schema for the git_clean tool using Zod
 // No refinements needed here, but the 'force' check is critical in the logic
 export const GitCleanInputSchema = z.object({
@@ -102,18 +102,21 @@ export async function gitCleanLogic(input, context) {
     try {
         // Construct the command
         // Force (-f) is always added because the logic checks input.force
-        let command = `git -C "${targetPath}" clean -f`;
+        const args = ["-C", targetPath, "clean", "-f"];
         if (input.dryRun) {
-            command += " -n";
+            args.push("-n");
         }
         if (input.directories) {
-            command += " -d";
+            args.push("-d");
         }
         if (input.ignored) {
-            command += " -x";
+            args.push("-x");
         }
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
-        const { stdout, stderr } = await execAsync(command);
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
+        const { stdout, stderr } = await execFileAsync("git", args);
         if (stderr) {
             // Log stderr as warning, as git clean might report non-fatal issues here
             logger.warning(`Git clean command produced stderr`, {