@cyanheads/git-mcp-server 2.1.4 → 2.1.5

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`, {

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

@@ -1,4 +1,4 @@
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import fs from "fs/promises";
 import { promisify } from "util";
 import { z } from "zod";
@@ -8,7 +8,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_clone tool using Zod
 export const GitCloneInputSchema = z.object({
     repositoryUrl: z
@@ -108,22 +108,26 @@ export async function gitCloneLogic(input, context) {
     }
     try {
         // Construct the git clone command
-        // Use placeholders and pass args safely if possible, but exec requires string command. Be careful with quoting.
-        let command = `git clone`;
+        const args = ["clone"];
         if (input.quiet) {
-            command += " --quiet";
+            args.push("--quiet");
         }
         if (input.branch) {
-            command += ` --branch "${input.branch.replace(/"/g, '\\"')}"`;
+            args.push("--branch", input.branch);
         }
         if (input.depth) {
-            command += ` --depth ${input.depth}`;
+            args.push("--depth", String(input.depth));
         }
-        // Add repo URL and target path (ensure they are quoted)
-        command += ` "${sanitizedRepoUrl}" "${sanitizedTargetPath}"`;
-        logger.debug(`Executing command: ${command}`, { ...context, operation });
+        // Add repo URL and target path
+        args.push(sanitizedRepoUrl, sanitizedTargetPath);
+        logger.debug(`Executing command: git ${args.join(" ")}`, {
+            ...context,
+            operation,
+        });
         // Increase timeout for clone operations as they can take time
-        const { stdout, stderr } = await execAsync(command, { timeout: 300000 }); // 5 minutes timeout
+        const { stdout, stderr } = await execFileAsync("git", args, {
+            timeout: 300000,
+        }); // 5 minutes timeout
         if (stderr && !input.quiet) {
             // Stderr often contains progress info, log as info if quiet is false
             logger.info(`Git clone command produced stderr (progress/info)`, {

package/dist/mcp-server/tools/gitCommit/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 { BaseErrorCode, McpError } from "../../../types-global/errors.js"; // Keep direct import for types-global
@@ -8,7 +8,7 @@ import { logger } from "../../../utils/index.js";
 import { sanitization } from "../../../utils/index.js";
 // Import config to check signing flag
 import { config } from "../../../config/index.js";
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 // Define the input schema for the git_commit tool using Zod
 export const GitCommitInputSchema = z.object({
     path: z
@@ -108,15 +108,12 @@ export async function commitGitChanges(input, context) {
                 // Correctly pass targetPath as rootDir in options object
                 const sanitizedFiles = input.filesToStage.map((file) => sanitization.sanitizePath(file, { rootDir: targetPath })
                     .sanitizedPath); // Sanitize relative to repo root
-                const filesToAddString = sanitizedFiles
-                    .map((file) => `"${file}"`)
-                    .join(" "); // Quote paths for safety
-                const addCommand = `git -C "${targetPath}" add -- ${filesToAddString}`;
-                logger.debug(`Executing git add command: ${addCommand}`, {
+                const addArgs = ["-C", targetPath, "add", "--", ...sanitizedFiles];
+                logger.debug(`Executing git add command: git ${addArgs.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                await execAsync(addCommand);
+                await execFileAsync("git", addArgs);
                 logger.info(`Successfully staged specified files: ${sanitizedFiles.join(", ")}`, { ...context, operation });
             }
             catch (addError) {
@@ -131,42 +128,24 @@ export async function commitGitChanges(input, context) {
             }
         }
         // --- End staging files ---
-        // Escape message for shell safety
-        const escapeShellArg = (arg) => {
-            // Escape backslashes first, then other special chars
-            return arg
-                .replace(/\\/g, "\\\\")
-                .replace(/"/g, '\\"')
-                .replace(/`/g, "\\`")
-                .replace(/\$/g, "\\$");
-        };
-        const escapedMessage = escapeShellArg(input.message);
         // Construct the git commit command using the resolved targetPath
-        let command = `git -C "${targetPath}" commit -m "${escapedMessage}"`;
+        const args = ["-C", targetPath];
+        if (input.author) {
+            args.push("-c", `user.name=${input.author.name}`, "-c", `user.email=${input.author.email}`);
+        }
+        args.push("commit", "-m", input.message);
         if (input.allowEmpty) {
-            command += " --allow-empty";
+            args.push("--allow-empty");
         }
         if (input.amend) {
-            command += " --amend --no-edit";
+            args.push("--amend", "--no-edit");
         }
-        if (input.author) {
-            // Escape author details as well
-            const escapedAuthorName = escapeShellArg(input.author.name);
-            const escapedAuthorEmail = escapeShellArg(input.author.email); // Email typically safe, but escape anyway
-            // Use -c flags to override author for this commit, using the already escaped message
-            command = `git -C "${targetPath}" -c user.name="${escapedAuthorName}" -c user.email="${escapedAuthorEmail}" commit -m "${escapedMessage}"`;
-        }
-        // Append common flags (ensure they are appended to the potentially modified command from author block)
-        if (input.allowEmpty && !command.includes(" --allow-empty"))
-            command += " --allow-empty";
-        if (input.amend && !command.includes(" --amend"))
-            command += " --amend --no-edit"; // Avoid double adding if author block modified command
         // Append signing flag if configured via GIT_SIGN_COMMITS env var
         if (config.gitSignCommits) {
-            command += " -S"; // Add signing flag (-S)
+            args.push("-S"); // Add signing flag (-S)
             logger.info("Signing enabled via GIT_SIGN_COMMITS=true, adding -S flag.", { ...context, operation });
         }
-        logger.debug(`Executing initial command attempt: ${command}`, {
+        logger.debug(`Executing initial command attempt: git ${args.join(" ")}`, {
             ...context,
             operation,
         });
@@ -175,7 +154,7 @@ export async function commitGitChanges(input, context) {
         let commitResult;
         try {
             // Initial attempt (potentially with -S flag)
-            const execResult = await execAsync(command);
+            const execResult = await execFileAsync("git", args);
             stdout = execResult.stdout;
             stderr = execResult.stderr;
         }
@@ -185,34 +164,12 @@ export async function commitGitChanges(input, context) {
                 initialErrorMessage.includes("signing failed");
             if (isSigningError && input.forceUnsignedOnFailure) {
                 logger.warning("Initial commit attempt failed due to signing error. Retrying without signing as forceUnsignedOnFailure=true.", { ...context, operation, initialError: initialErrorMessage });
-                // Construct command *without* -S flag, using escaped message/author
-                const escapeShellArg = (arg) => {
-                    return arg
-                        .replace(/\\/g, "\\\\")
-                        .replace(/"/g, '\\"')
-                        .replace(/`/g, "\\`")
-                        .replace(/\$/g, "\\$");
-                };
-                const escapedMessage = escapeShellArg(input.message);
-                let unsignedCommand = `git -C "${targetPath}" commit -m "${escapedMessage}"`;
-                if (input.allowEmpty)
-                    unsignedCommand += " --allow-empty";
-                if (input.amend)
-                    unsignedCommand += " --amend --no-edit";
-                if (input.author) {
-                    const escapedAuthorName = escapeShellArg(input.author.name);
-                    const escapedAuthorEmail = escapeShellArg(input.author.email);
-                    unsignedCommand = `git -C "${targetPath}" -c user.name="${escapedAuthorName}" -c user.email="${escapedAuthorEmail}" commit -m "${escapedMessage}"`;
-                    // Re-append common flags if author block overwrote command
-                    if (input.allowEmpty && !unsignedCommand.includes(" --allow-empty"))
-                        unsignedCommand += " --allow-empty";
-                    if (input.amend && !unsignedCommand.includes(" --amend"))
-                        unsignedCommand += " --amend --no-edit";
-                }
-                logger.debug(`Executing unsigned fallback command: ${unsignedCommand}`, { ...context, operation });
+                // Construct command *without* -S flag
+                const unsignedArgs = args.filter((arg) => arg !== "-S");
+                logger.debug(`Executing unsigned fallback command: git ${unsignedArgs.join(" ")}`, { ...context, operation });
                 try {
                     // Retry commit without signing
-                    const fallbackResult = await execAsync(unsignedCommand);
+                    const fallbackResult = await execFileAsync("git", unsignedArgs);
                     stdout = fallbackResult.stdout;
                     stderr = fallbackResult.stderr;
                     // Add a note to the status message indicating signing was skipped
@@ -281,12 +238,19 @@ export async function commitGitChanges(input, context) {
         if (commitHash) {
             try {
                 // Get the list of files included in this specific commit
-                const showCommand = `git -C "${targetPath}" show --pretty="" --name-only ${commitHash}`;
-                logger.debug(`Executing git show command: ${showCommand}`, {
+                const showArgs = [
+                    "-C",
+                    targetPath,
+                    "show",
+                    "--pretty=",
+                    "--name-only",
+                    commitHash,
+                ];
+                logger.debug(`Executing git show command: git ${showArgs.join(" ")}`, {
                     ...context,
                     operation,
                 });
-                const { stdout: showStdout } = await execAsync(showCommand);
+                const { stdout: showStdout } = await execFileAsync("git", showArgs);
                 committedFiles = showStdout.trim().split("\n").filter(Boolean); // Split by newline, remove empty lines
                 logger.debug(`Retrieved committed files list for ${commitHash}`, {
                     ...context,