@cyanheads/git-mcp-server 2.1.3 → 2.1.5

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:

package/dist/mcp-server/tools/gitReset/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 reset modes
 const ResetModeEnum = z.enum(["soft", "mixed", "hard", "merge", "keep"]);
 // Define the input schema for the git_reset tool using Zod
@@ -73,24 +73,25 @@ export async function resetGitState(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 commit ref
-    const safeCommit = input.commit?.replace(/[`$&;*()|<>]/g, "");
     try {
         // Construct the git reset command
-        let command = `git -C "${targetPath}" reset`;
+        const args = ["-C", targetPath, "reset"];
         if (input.mode) {
-            command += ` --${input.mode}`;
+            args.push(`--${input.mode}`);
         }
-        if (safeCommit) {
-            command += ` ${safeCommit}`;
+        if (input.commit) {
+            args.push(input.commit);
         }
         // Handling file paths requires careful command construction, often without a commit ref.
         // Example: `git reset HEAD -- path/to/file` or `git reset -- path/to/file` (unstages)
         // For simplicity, this initial version focuses on resetting the whole HEAD/index/tree.
         // Add file path logic here if needed, adjusting command structure.
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
         // Execute command. Reset output is often minimal on success, but stderr might indicate issues.
-        const { stdout, stderr } = await execAsync(command);
+        const { stdout, stderr } = await execFileAsync("git", args);
         logger.debug(`Git reset stdout: ${stdout}`, { ...context, operation });
         if (stderr) {
             // Log stderr as info, as it often contains the primary status message

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

@@ -1,10 +1,10 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import fs from "fs/promises";
 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"; // RequestContext (./utils/internal/requestContext.js), logger (./utils/internal/logger.js), sanitization (./utils/security/sanitization.js)
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 // Define the Zod schema for input validation
 export const GitSetWorkingDirInputSchema = z.object({
     path: z
@@ -70,7 +70,7 @@ export async function gitSetWorkingDirLogic(input, context) {
     let isGitRepo = false;
     let initializedRepo = false;
     try {
-        const { stdout } = await execAsync("git rev-parse --is-inside-work-tree", {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--is-inside-work-tree"], {
             cwd: sanitizedPath,
         });
         if (stdout.trim() === "true") {
@@ -94,7 +94,9 @@ export async function gitSetWorkingDirLogic(input, context) {
     if (!isGitRepo && input.initializeIfNotPresent) {
         logger.info(`Path is not a Git repository. Attempting to initialize (initializeIfNotPresent=true) with initial branch 'main'.`, { ...context, operation, path: sanitizedPath });
         try {
-            await execAsync("git init --initial-branch=main", { cwd: sanitizedPath });
+            await execFileAsync("git", ["init", "--initial-branch=main"], {
+                cwd: sanitizedPath,
+            });
             initializedRepo = true;
             isGitRepo = true; // Now it is a git repo
             logger.info('Successfully initialized Git repository with initial branch "main".', { ...context, operation, path: sanitizedPath });

package/dist/mcp-server/tools/gitShow/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_show tool using Zod
 // No refinements needed here, so we don't need a separate BaseSchema
 export const GitShowInputSchema = z.object({
@@ -88,15 +88,16 @@ export async function gitShowLogic(input, context) {
     }
     try {
         // Construct the refspec, combining ref and filePath if needed
-        const refSpec = input.filePath
-            ? `${input.ref}:"${input.filePath}"`
-            : `"${input.ref}"`;
+        const refSpec = input.filePath ? `${input.ref}:${input.filePath}` : input.ref;
         // Construct the command
-        const command = `git -C "${targetPath}" show ${refSpec}`;
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        const args = ["-C", targetPath, "show", refSpec];
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
         // Execute command. Note: git show might write to stderr for non-error info (like commit details before diff)
         // We primarily care about stdout for the content. Errors usually have non-zero exit code.
-        const { stdout, stderr } = await execAsync(command);
+        const { stdout, stderr } = await execFileAsync("git", args);
         if (stderr) {
             // Log stderr as debug info, as it might contain commit details etc.
             logger.debug(`Git show command produced stderr (may be informational)`, {

package/dist/mcp-server/tools/gitStash/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 BASE input schema for the git_stash tool using Zod
 export const GitStashBaseSchema = z.object({
     path: z
@@ -90,16 +90,16 @@ export async function gitStashLogic(input, context) {
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid stash reference format: ${input.stashRef}. Expected format: stash@{n}`, { context, operation });
     }
     try {
-        let command;
+        let args;
         let result;
         switch (input.mode) {
             case "list":
-                command = `git -C "${targetPath}" stash list`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "stash", "list"];
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                const { stdout: listStdout } = await execAsync(command);
+                const { stdout: listStdout } = await execFileAsync("git", args);
                 const stashes = listStdout
                     .trim()
                     .split("\n")
@@ -121,13 +121,13 @@ export async function gitStashLogic(input, context) {
             case "pop":
                 // stashRef is validated by Zod refine
                 const stashRefApplyPop = input.stashRef;
-                command = `git -C "${targetPath}" stash ${input.mode} ${stashRefApplyPop}`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "stash", input.mode, stashRefApplyPop];
+                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 conflicts = /conflict/i.test(stdout) || /conflict/i.test(stderr);
                     const message = conflicts
@@ -166,12 +166,12 @@ export async function gitStashLogic(input, context) {
             case "drop":
                 // stashRef is validated by Zod refine
                 const stashRefDrop = input.stashRef;
-                command = `git -C "${targetPath}" stash drop ${stashRefDrop}`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "stash", "drop", stashRefDrop];
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                await execAsync(command);
+                await execFileAsync("git", args);
                 result = {
                     success: true,
                     mode: "drop",
@@ -180,16 +180,15 @@ export async function gitStashLogic(input, context) {
                 };
                 break;
             case "save":
-                command = `git -C "${targetPath}" stash save`;
+                args = ["-C", targetPath, "stash", "save"];
                 if (input.message) {
-                    // Ensure message is properly quoted for the shell
-                    command += ` "${input.message.replace(/"/g, '\\"')}"`;
+                    args.push(input.message);
                 }
-                logger.debug(`Executing command: ${command}`, {
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                const { stdout: saveStdout } = await execAsync(command);
+                const { stdout: saveStdout } = await execFileAsync("git", args);
                 const stashCreated = !/no local changes to save/i.test(saveStdout);
                 const saveMessage = stashCreated
                     ? `Changes stashed successfully.` +

package/dist/mcp-server/tools/gitStatus/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_status tool using Zod
 export const GitStatusInputSchema = z.object({
     path: z
@@ -197,10 +197,12 @@ export async function getGitStatus(input, context) {
     }
     try {
         // Using --porcelain=v1 for stable, scriptable output and -b for branch info
-        // Ensure the path passed to -C is correctly quoted for the shell
-        const command = `git -C "${targetPath}" status --porcelain=v1 -b`;
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
-        const { stdout, stderr } = await execAsync(command);
+        const args = ["-C", targetPath, "status", "--porcelain=v1", "-b"];
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
+        const { stdout, stderr } = await execFileAsync("git", args);
         if (stderr) {
             // Log stderr as warning but proceed to parse stdout
             logger.warning(`Git status command produced stderr (may be informational)`, { ...context, operation, stderr });
@@ -216,8 +218,8 @@ export async function getGitStatus(input, context) {
         // This handles the case of an empty repo after init but before first commit
         if (structuredResult.is_clean && !structuredResult.current_branch) {
             try {
-                const branchCommand = `git -C "${targetPath}" rev-parse --abbrev-ref HEAD`;
-                const { stdout: branchStdout } = await execAsync(branchCommand);
+                const branchArgs = ["-C", targetPath, "rev-parse", "--abbrev-ref", "HEAD"];
+                const { stdout: branchStdout } = await execFileAsync("git", branchArgs);
                 const currentBranchName = branchStdout.trim(); // Renamed variable for clarity
                 if (currentBranchName && currentBranchName !== "HEAD") {
                     structuredResult.current_branch = currentBranchName;

package/dist/mcp-server/tools/gitTag/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 base input schema for the git_tag tool using Zod
 // We export this separately to access its .shape for registration
 export const GitTagBaseSchema = z.object({
@@ -111,16 +111,16 @@ export async function gitTagLogic(input, context) {
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid commit reference format: ${input.commitRef}`, { context, operation });
     }
     try {
-        let command;
+        let args;
         let result;
         switch (input.mode) {
             case "list":
-                command = `git -C "${targetPath}" tag --list`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "tag", "--list"];
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                const { stdout: listStdout } = await execAsync(command);
+                const { stdout: listStdout } = await execFileAsync("git", args);
                 const tags = listStdout
                     .trim()
                     .split("\n")
@@ -130,20 +130,20 @@ export async function gitTagLogic(input, context) {
             case "create":
                 // TagName is validated by Zod refine
                 const tagNameCreate = input.tagName;
-                command = `git -C "${targetPath}" tag`;
+                args = ["-C", targetPath, "tag"];
                 if (input.annotate) {
                     // Message is validated by Zod refine
-                    command += ` -a -m "${input.message.replace(/"/g, '\\"')}"`;
+                    args.push("-a", "-m", input.message);
                 }
-                command += ` "${tagNameCreate}"`;
+                args.push(tagNameCreate);
                 if (input.commitRef) {
-                    command += ` "${input.commitRef}"`;
+                    args.push(input.commitRef);
                 }
-                logger.debug(`Executing command: ${command}`, {
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                await execAsync(command);
+                await execFileAsync("git", args);
                 result = {
                     success: true,
                     mode: "create",
@@ -154,12 +154,12 @@ export async function gitTagLogic(input, context) {
             case "delete":
                 // TagName is validated by Zod refine
                 const tagNameDelete = input.tagName;
-                command = `git -C "${targetPath}" tag -d "${tagNameDelete}"`;
-                logger.debug(`Executing command: ${command}`, {
+                args = ["-C", targetPath, "tag", "-d", tagNameDelete];
+                logger.debug(`Executing command: git ${args.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                await execAsync(command);
+                await execFileAsync("git", args);
                 result = {
                     success: true,
                     mode: "delete",