@cyanheads/git-mcp-server 2.1.4 → 2.1.6

package/dist/mcp-server/tools/gitDiff/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 without refinement
 const GitDiffInputBaseSchema = z.object({
     path: z
@@ -98,30 +98,32 @@ export async function diffGitChanges(input, context) {
     let untrackedFilesCount = 0;
     try {
         // Construct the standard git diff command
-        let standardDiffCommand = `git -C "${targetPath}" diff`;
+        const standardDiffArgs = ["-C", targetPath, "diff"];
         if (input.staged) {
-            standardDiffCommand += " --staged"; // Or --cached
+            standardDiffArgs.push("--staged"); // Or --cached
         }
         else {
             // Add commit references if not doing staged diff
             if (safeCommit1) {
-                standardDiffCommand += ` ${safeCommit1}`;
+                standardDiffArgs.push(safeCommit1);
             }
             if (safeCommit2) {
-                standardDiffCommand += ` ${safeCommit2}`;
+                standardDiffArgs.push(safeCommit2);
             }
         }
         // Add file path limiter if provided for standard diff
         // Note: `input.file` will not apply to the untracked files part unless we explicitly filter them.
         // For simplicity, `includeUntracked` will show all untracked files if `input.file` is also set.
         if (safeFile) {
-            standardDiffCommand += ` -- "${safeFile}"`; // Use '--' to separate paths from revisions
+            standardDiffArgs.push("--", safeFile); // Use '--' to separate paths from revisions
         }
-        logger.debug(`Executing standard diff command: ${standardDiffCommand}`, {
+        logger.debug(`Executing standard diff command: git ${standardDiffArgs.join(" ")}`, {
             ...context,
             operation,
         });
-        const { stdout: standardStdout, stderr: standardStderr } = await execAsync(standardDiffCommand, { maxBuffer: 1024 * 1024 * 20 });
+        const { stdout: standardStdout, stderr: standardStderr } = await execFileAsync("git", standardDiffArgs, {
+            maxBuffer: 1024 * 1024 * 20,
+        });
         if (standardStderr) {
             logger.warning(`Git diff (standard) stderr: ${standardStderr}`, {
                 ...context,
@@ -132,9 +134,15 @@ export async function diffGitChanges(input, context) {
         // Handle untracked files if requested
         if (input.includeUntracked) {
             logger.debug("Including untracked files.", { ...context, operation });
-            const listUntrackedCommand = `git -C "${targetPath}" ls-files --others --exclude-standard`;
+            const listUntrackedArgs = [
+                "-C",
+                targetPath,
+                "ls-files",
+                "--others",
+                "--exclude-standard",
+            ];
             try {
-                const { stdout: untrackedFilesStdOut } = await execAsync(listUntrackedCommand);
+                const { stdout: untrackedFilesStdOut } = await execFileAsync("git", listUntrackedArgs);
                 const untrackedFiles = untrackedFilesStdOut
                     .trim()
                     .split("\n")
@@ -152,10 +160,17 @@ export async function diffGitChanges(input, context) {
                         // Skip if file path becomes empty after sanitization (unlikely but safe)
                         if (!safeUntrackedFile)
                             continue;
-                        const untrackedDiffCommand = `git -C "${targetPath}" diff --no-index /dev/null "${safeUntrackedFile}"`;
-                        logger.debug(`Executing diff for untracked file: ${untrackedDiffCommand}`, { ...context, operation, file: safeUntrackedFile });
+                        const untrackedDiffArgs = [
+                            "-C",
+                            targetPath,
+                            "diff",
+                            "--no-index",
+                            "/dev/null",
+                            safeUntrackedFile,
+                        ];
+                        logger.debug(`Executing diff for untracked file: git ${untrackedDiffArgs.join(" ")}`, { ...context, operation, file: safeUntrackedFile });
                         try {
-                            const { stdout: untrackedFileDiffOut } = await execAsync(untrackedDiffCommand);
+                            const { stdout: untrackedFileDiffOut } = await execFileAsync("git", untrackedDiffArgs);
                             individualUntrackedDiffs += untrackedFileDiffOut;
                             untrackedFilesCount++;
                         }

package/dist/mcp-server/tools/gitFetch/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_fetch tool using Zod
 export const GitFetchInputSchema = z.object({
     path: z
@@ -76,27 +76,28 @@ export async function fetchGitRemote(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 remote name
-    const safeRemote = input.remote?.replace(/[^a-zA-Z0-9_.\-/]/g, "");
     try {
         // Construct the git fetch command
-        let command = `git -C "${targetPath}" fetch`;
+        const args = ["-C", targetPath, "fetch"];
         if (input.prune) {
-            command += " --prune";
+            args.push("--prune");
         }
         if (input.tags) {
-            command += " --tags";
+            args.push("--tags");
         }
         if (input.all) {
-            command += " --all";
+            args.push("--all");
         }
-        else if (safeRemote) {
-            command += ` ${safeRemote}`; // Fetch specific remote if 'all' is not used
+        else if (input.remote) {
+            args.push(input.remote); // Fetch specific remote if 'all' is not used
         }
         // If neither 'all' nor 'remote' is specified, git fetch defaults to 'origin' or configured upstream.
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
         // Execute command. Fetch output is primarily on stderr.
-        const { stdout, stderr } = await execAsync(command);
+        const { stdout, stderr } = await execFileAsync("git", args);
         logger.debug(`Git fetch stdout: ${stdout}`, { ...context, operation }); // stdout is usually empty
         if (stderr) {
             logger.debug(`Git fetch stderr: ${stderr}`, { ...context, operation }); // stderr contains fetch details

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

@@ -1,4 +1,4 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 import { promisify } from "util";
@@ -9,7 +9,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_init tool using Zod
 export const GitInitInputSchema = z.object({
     path: z
@@ -83,20 +83,23 @@ export async function gitInitLogic(input, context) {
     }
     try {
         // Construct the git init command
-        let command = `git init`;
+        const args = ["init"];
         if (input.quiet) {
-            command += " --quiet";
+            args.push("--quiet");
         }
         if (input.bare) {
-            command += " --bare";
+            args.push("--bare");
         }
         // Determine the initial branch name, defaulting to 'main' if not provided
         const branchNameToUse = input.initialBranch || "main";
-        command += ` -b "${branchNameToUse.replace(/"/g, '\\"')}"`;
+        args.push("-b", branchNameToUse);
         // Add the target directory path at the end
-        command += ` "${targetPath}"`;
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
-        const { stdout, stderr } = await execAsync(command);
+        args.push(targetPath);
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
+        const { stdout, stderr } = await execFileAsync("git", args);
         if (stderr && !input.quiet) {
             // Log stderr as warning but proceed, as init might still succeed (e.g., reinitializing)
             logger.warning(`Git init command produced stderr`, {

package/dist/mcp-server/tools/gitLog/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 structure for a single commit entry
 export const CommitEntrySchema = z.object({
     hash: z.string().describe("Full commit hash"),
@@ -107,53 +107,40 @@ export async function logGitHistory(input, context) {
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
     }
     try {
-        let command;
+        const args = ["-C", targetPath, "log"];
         let isRawOutput = false; // Flag to indicate if we should parse or return raw
         if (input.showSignature) {
             isRawOutput = true;
-            command = `git -C "${targetPath}" log --show-signature`;
+            args.push("--show-signature");
             logger.info("Show signature requested, returning raw output.", {
                 ...context,
                 operation,
             });
-            // Append other filters if provided
-            if (input.maxCount)
-                command += ` -n ${input.maxCount}`;
-            if (input.author)
-                command += ` --author="${input.author.replace(/[`"$&;*()|<>]/g, "")}"`;
-            if (input.since)
-                command += ` --since="${input.since.replace(/[`"$&;*()|<>]/g, "")}"`;
-            if (input.until)
-                command += ` --until="${input.until.replace(/[`"$&;*()|<>]/g, "")}"`;
-            if (input.branchOrFile)
-                command += ` ${input.branchOrFile.replace(/[`"$&;*()|<>]/g, "")}`;
         }
         else {
-            // Construct the git log command with the fixed format for parsing
-            command = `git -C "${targetPath}" log ${GIT_LOG_FORMAT}`;
-            if (input.maxCount)
-                command += ` -n ${input.maxCount}`;
+            args.push(GIT_LOG_FORMAT);
+        }
+        if (input.maxCount) {
+            args.push(`-n${input.maxCount}`);
         }
         if (input.author) {
-            // Basic sanitization for author string
-            const safeAuthor = input.author.replace(/[`"$&;*()|<>]/g, "");
-            command += ` --author="${safeAuthor}"`;
+            args.push(`--author=${input.author}`);
         }
         if (input.since) {
-            const safeSince = input.since.replace(/[`"$&;*()|<>]/g, "");
-            command += ` --since="${safeSince}"`;
+            args.push(`--since=${input.since}`);
         }
         if (input.until) {
-            const safeUntil = input.until.replace(/[`"$&;*()|<>]/g, "");
-            command += ` --until="${safeUntil}"`;
+            args.push(`--until=${input.until}`);
         }
         if (input.branchOrFile) {
-            const safeBranchOrFile = input.branchOrFile.replace(/[`"$&;*()|<>]/g, "");
-            command += ` ${safeBranchOrFile}`; // Add branch or file path at the end
+            args.push(input.branchOrFile);
         }
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
         // Increase maxBuffer if logs can be large
-        const { stdout, stderr } = await execAsync(command, {
+        const { stdout, stderr } = await execFileAsync("git", args, {
             maxBuffer: 1024 * 1024 * 10,
         }); // 10MB buffer
         if (stderr) {

package/dist/mcp-server/tools/gitMerge/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)
@@ -8,7 +8,7 @@ import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Ke
 // Import utils from barrel (sanitization from ../utils/security/sanitization.js)
 import path from "path"; // Import path module
 import { sanitization } from "../../../utils/index.js";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 // Define the input schema for the git_merge tool
 export const GitMergeInputSchema = z.object({
     path: z
@@ -107,29 +107,34 @@ export async function gitMergeLogic(input, context) {
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
     }
     // --- Construct the git merge command ---
-    let command = `git -C "${targetPath}" merge`;
+    const args = ["-C", targetPath, "merge"];
     if (input.abort) {
-        command += " --abort";
+        args.push("--abort");
     }
     else {
         // Standard merge options
-        if (input.noFf)
-            command += " --no-ff";
-        if (input.squash)
-            command += " --squash";
+        if (input.noFf) {
+            args.push("--no-ff");
+        }
+        if (input.squash) {
+            args.push("--squash");
+        }
         if (input.commitMessage && !input.squash) {
             // Commit message only relevant if not squashing (squash requires separate commit)
-            command += ` -m "${input.commitMessage.replace(/"/g, '\\"')}"`;
+            args.push("-m", input.commitMessage);
         }
         else if (input.squash && input.commitMessage) {
             logger.warning("Commit message provided with --squash, but it will be ignored. Squash requires a separate commit.", { ...context, operation });
         }
-        command += ` "${input.branch.replace(/"/g, '\\"')}"`; // Add branch to merge
+        args.push(input.branch); // Add branch to merge
     }
-    logger.debug(`Executing command: ${command}`, { ...context, operation });
+    logger.debug(`Executing command: git ${args.join(" ")}`, {
+        ...context,
+        operation,
+    });
     // --- Execute and Parse ---
     try {
-        const { stdout, stderr } = await execAsync(command);
+        const { stdout, stderr } = await execFileAsync("git", args);
         logger.debug(`Command stdout: ${stdout}`, { ...context, operation });
         if (stderr)
             logger.debug(`Command stderr: ${stderr}`, { ...context, operation }); // Log stderr even on success

package/dist/mcp-server/tools/gitPull/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_pull tool using Zod
 export const GitPullInputSchema = z.object({
     path: z
@@ -91,30 +91,29 @@ export async function pullGitChanges(input, context) {
     }
     try {
         // Construct the git pull command
-        let command = `git -C "${targetPath}" pull`;
+        const args = ["-C", targetPath, "pull"];
         if (input.rebase) {
-            command += " --rebase";
+            args.push("--rebase");
         }
         if (input.ffOnly) {
-            command += " --ff-only";
+            args.push("--ff-only");
         }
         if (input.remote) {
-            // Sanitize remote and branch names - basic alphanumeric + common chars
-            const safeRemote = input.remote.replace(/[^a-zA-Z0-9_.\-/]/g, "");
-            command += ` ${safeRemote}`;
+            args.push(input.remote);
             if (input.branch) {
-                const safeBranch = input.branch.replace(/[^a-zA-Z0-9_.\-/]/g, "");
-                command += ` ${safeBranch}`;
+                args.push(input.branch);
             }
         }
         else if (input.branch) {
             // If only branch is specified, assume 'origin' or tracked remote
-            const safeBranch = input.branch.replace(/[^a-zA-Z0-9_.\-/]/g, "");
-            command += ` origin ${safeBranch}`; // Defaulting to origin if remote not specified but branch is
+            args.push("origin", input.branch); // Defaulting to origin if remote not specified but branch is
             logger.warning(`Remote not specified, defaulting to 'origin' for branch pull`, { ...context, operation });
         }
-        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);
         logger.debug(`Git pull stdout: ${stdout}`, { ...context, operation });
         if (stderr) {
             logger.debug(`Git pull stderr: ${stderr}`, { ...context, operation });

package/dist/mcp-server/tools/gitPush/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_push tool using Zod
 export const GitPushInputSchema = z.object({
     path: z
@@ -111,45 +111,43 @@ export async function pushGitChanges(input, context) {
     }
     try {
         // Construct the git push command
-        let command = `git -C "${targetPath}" push`;
+        const args = ["-C", targetPath, "push"];
         if (input.force) {
-            command += " --force";
+            args.push("--force");
         }
         else if (input.forceWithLease) {
-            command += " --force-with-lease";
+            args.push("--force-with-lease");
         }
         if (input.setUpstream) {
-            command += " --set-upstream";
+            args.push("--set-upstream");
         }
         if (input.tags) {
-            command += " --tags";
+            args.push("--tags");
         }
         if (input.delete) {
-            command += " --delete";
+            args.push("--delete");
         }
         // Add remote and branch specification
-        const remote = input.remote
-            ? input.remote.replace(/[^a-zA-Z0-9_.\-/]/g, "")
-            : "origin"; // Default to origin
-        command += ` ${remote}`;
+        const remote = input.remote || "origin"; // Default to origin
+        args.push(remote);
         if (input.branch) {
-            const localBranch = input.branch.replace(/[^a-zA-Z0-9_.\-/]/g, "");
-            command += ` ${localBranch}`;
             if (input.remoteBranch && !input.delete) {
-                // remoteBranch only makes sense if not deleting
-                const remoteBranch = input.remoteBranch.replace(/[^a-zA-Z0-9_.\-/]/g, "");
-                command += `:${remoteBranch}`;
+                args.push(`${input.branch}:${input.remoteBranch}`);
+            }
+            else {
+                args.push(input.branch);
             }
         }
         else if (!input.tags && !input.delete) {
             // If no branch, tags, or delete specified, push the current branch by default
-            // Git might handle this automatically, but being explicit can be clearer
-            // command += ' HEAD'; // Or let git figure out the default push behavior
             logger.debug("No specific branch, tags, or delete specified. Relying on default git push behavior for current branch.", { ...context, operation });
         }
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
         // Execute command. Note: Git push often uses stderr for progress and success messages.
-        const { stdout, stderr } = await execAsync(command);
+        const { stdout, stderr } = await execFileAsync("git", args);
         logger.debug(`Git push stdout: ${stdout}`, { ...context, operation });
         if (stderr) {
             logger.debug(`Git push stderr: ${stderr}`, { ...context, operation });

package/dist/mcp-server/tools/gitRebase/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_rebase tool using Zod
 export const GitRebaseBaseSchema = z.object({
     path: z
@@ -117,39 +117,48 @@ export async function gitRebaseLogic(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}" rebase`;
+        const args = ["-C", targetPath, "rebase"];
         switch (input.mode) {
             case "start":
-                if (input.interactive)
-                    command += " -i";
-                if (input.strategy)
-                    command += ` --strategy=${input.strategy}`;
-                if (input.strategyOption)
-                    command += ` -X${input.strategyOption}`; // Note: -X for strategy options
-                if (input.onto)
-                    command += ` --onto "${input.onto.replace(/"/g, '\\"')}"`;
+                if (input.interactive) {
+                    args.push("-i");
+                }
+                if (input.strategy) {
+                    args.push(`--strategy=${input.strategy}`);
+                }
+                if (input.strategyOption) {
+                    args.push(`-X${input.strategyOption}`);
+                } // Note: -X for strategy options
+                if (input.onto) {
+                    args.push("--onto", input.onto);
+                }
                 // Upstream is required by refine unless interactive
-                if (input.upstream)
-                    command += ` "${input.upstream.replace(/"/g, '\\"')}"`;
-                if (input.branch)
-                    command += ` "${input.branch.replace(/"/g, '\\"')}"`;
+                if (input.upstream) {
+                    args.push(input.upstream);
+                }
+                if (input.branch) {
+                    args.push(input.branch);
+                }
                 break;
             case "continue":
-                command += " --continue";
+                args.push("--continue");
                 break;
             case "abort":
-                command += " --abort";
+                args.push("--abort");
                 break;
             case "skip":
-                command += " --skip";
+                args.push("--skip");
                 break;
             default:
                 // Should not happen due to Zod validation
                 throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid mode: ${input.mode}`, { context, operation });
         }
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
         try {
-            const { stdout, stderr } = await execAsync(command);
+            const { stdout, stderr } = await execFileAsync("git", args);
             const output = stdout + stderr;
             const message = `Rebase ${input.mode} executed successfully. Output: ${output.trim()}`;
             logger.info(message, { ...context, operation, path: targetPath });

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

@@ -1,9 +1,9 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { promisify } from "util";
 import { z } from "zod";
 import { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Direct import for types-global
 import { logger, sanitization } from "../../../utils/index.js"; // Logger (./utils/internal/logger.js) & RequestContext (./utils/internal/requestContext.js) & sanitization (./utils/security/sanitization.js)
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 // Define the input schema for the git_remote tool using Zod
 export const GitRemoteInputSchema = z.object({
     path: z
@@ -79,16 +79,16 @@ export async function gitRemoteLogic(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}" remote -v`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "remote", "-v"];
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                const { stdout: listStdout } = await execAsync(command);
+                const { stdout: listStdout } = await execFileAsync("git", args);
                 const remotes = [];
                 const lines = listStdout.trim().split("\n");
                 const remoteMap = new Map();
@@ -127,12 +127,12 @@ export async function gitRemoteLogic(input, context) {
                 if (!/^[a-zA-Z0-9_.-]+$/.test(input.name)) {
                     throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
                 }
-                command = `git -C "${targetPath}" remote add "${input.name}" "${input.url}"`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "remote", "add", input.name, input.url];
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                await execAsync(command);
+                await execFileAsync("git", args);
                 result = {
                     success: true,
                     mode: "add",
@@ -146,12 +146,12 @@ export async function gitRemoteLogic(input, context) {
                 if (!/^[a-zA-Z0-9_.-]+$/.test(input.name)) {
                     throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
                 }
-                command = `git -C "${targetPath}" remote remove "${input.name}"`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "remote", "remove", input.name];
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                await execAsync(command);
+                await execFileAsync("git", args);
                 result = {
                     success: true,
                     mode: "remove",
@@ -165,12 +165,12 @@ export async function gitRemoteLogic(input, context) {
                 if (!/^[a-zA-Z0-9_.-]+$/.test(input.name)) {
                     throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid remote name: ${input.name}`, { context, operation });
                 }
-                command = `git -C "${targetPath}" remote show "${input.name}"`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "remote", "show", input.name];
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                const { stdout: showStdout } = await execAsync(command);
+                const { stdout: showStdout } = await execFileAsync("git", args);
                 result = { success: true, mode: "show", details: showStdout.trim() };
                 break;
             default: