@cyanheads/git-mcp-server 2.1.0 → 2.1.2

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

@@ -1,22 +1,39 @@
-import { exec } from 'child_process';
-import fs from 'fs/promises';
-import { promisify } from 'util';
-import { z } from 'zod';
+import { exec } from "child_process";
+import fs from "fs/promises";
+import { promisify } from "util";
+import { z } from "zod";
 // Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from '../../../utils/index.js';
+import { logger } from "../../../utils/index.js";
 // Import utils from barrel (RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode, McpError } from '../../../types-global/errors.js'; // Keep direct import for types-global
+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';
+import { sanitization } from "../../../utils/index.js";
 const execAsync = promisify(exec);
 // Define the input schema for the git_clone tool using Zod
 export const GitCloneInputSchema = z.object({
-    repositoryUrl: z.string().url("Invalid repository URL format.").describe("The URL of the repository to clone (e.g., https://github.com/cyanheads/git-mcp-server, git@github.com:cyanheads/git-mcp-server.git)."),
-    targetPath: z.string().min(1).describe("The absolute path to the directory where the repository should be cloned."),
-    branch: z.string().optional().describe("Specify a specific branch to checkout after cloning."),
-    depth: z.number().int().positive().optional().describe("Create a shallow clone with a history truncated to the specified number of commits."),
+    repositoryUrl: z
+        .string()
+        .url("Invalid repository URL format.")
+        .describe("The URL of the repository to clone (e.g., https://github.com/cyanheads/git-mcp-server, git@github.com:cyanheads/git-mcp-server.git)."),
+    targetPath: z
+        .string()
+        .min(1)
+        .describe("The absolute path to the directory where the repository should be cloned."),
+    branch: z
+        .string()
+        .optional()
+        .describe("Specify a specific branch to checkout after cloning."),
+    depth: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Create a shallow clone with a history truncated to the specified number of commits."),
     // recursive: z.boolean().default(false).describe("After the clone is created, initialize all submodules within, using their default settings."), // Consider adding later
-    quiet: z.boolean().default(false).describe("Operate quietly. Progress is not reported to the standard error stream."),
+    quiet: z
+        .boolean()
+        .default(false)
+        .describe("Operate quietly. Progress is not reported to the standard error stream."),
 });
 /**
  * Executes the 'git clone' command to clone a repository.
@@ -27,19 +44,29 @@ export const GitCloneInputSchema = z.object({
  * @throws {McpError} Throws an McpError if path/URL validation fails or the git command fails unexpectedly.
  */
 export async function gitCloneLogic(input, context) {
-    const operation = 'gitCloneLogic';
+    const operation = "gitCloneLogic";
     logger.debug(`Executing ${operation}`, { ...context, input });
     let sanitizedTargetPath;
     let sanitizedRepoUrl;
     try {
         // Sanitize the target path (must be absolute)
-        sanitizedTargetPath = sanitization.sanitizePath(input.targetPath, { allowAbsolute: true }).sanitizedPath;
-        logger.debug('Sanitized target path', { ...context, operation, sanitizedTargetPath });
+        sanitizedTargetPath = sanitization.sanitizePath(input.targetPath, {
+            allowAbsolute: true,
+        }).sanitizedPath;
+        logger.debug("Sanitized target path", {
+            ...context,
+            operation,
+            sanitizedTargetPath,
+        });
         // Basic sanitization/validation for URL (Zod already checks format)
         // Further sanitization might be needed depending on how it's used in the shell command
         // For now, rely on Zod's URL validation and careful command construction.
         sanitizedRepoUrl = input.repositoryUrl; // Assume Zod validation is sufficient for now
-        logger.debug('Validated repository URL', { ...context, operation, sanitizedRepoUrl });
+        logger.debug("Validated repository URL", {
+            ...context,
+            operation,
+            sanitizedRepoUrl,
+        });
         // Check if target directory already exists and is not empty
         try {
             const stats = await fs.stat(sanitizedTargetPath);
@@ -56,9 +83,13 @@ export async function gitCloneLogic(input, context) {
         catch (error) {
             if (error instanceof McpError)
                 throw error; // Re-throw our specific validation errors
-            if (error.code !== 'ENOENT') {
+            if (error.code !== "ENOENT") {
                 // If error is not "does not exist", it's unexpected
-                logger.error(`Error checking target directory ${sanitizedTargetPath}`, { ...context, operation, error: error.message });
+                logger.error(`Error checking target directory ${sanitizedTargetPath}`, {
+                    ...context,
+                    operation,
+                    error: error.message,
+                });
                 throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to check target directory: ${error.message}`, { context, operation });
             }
             // ENOENT is expected - directory doesn't exist, which is fine for clone
@@ -66,7 +97,11 @@ export async function gitCloneLogic(input, context) {
         }
     }
     catch (error) {
-        logger.error('Path/URL validation or sanitization failed', { ...context, operation, error });
+        logger.error("Path/URL validation or sanitization failed", {
+            ...context,
+            operation,
+            error,
+        });
         if (error instanceof McpError)
             throw error;
         throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid input: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
@@ -76,7 +111,7 @@ export async function gitCloneLogic(input, context) {
         // Use placeholders and pass args safely if possible, but exec requires string command. Be careful with quoting.
         let command = `git clone`;
         if (input.quiet) {
-            command += ' --quiet';
+            command += " --quiet";
         }
         if (input.branch) {
             command += ` --branch "${input.branch.replace(/"/g, '\\"')}"`;
@@ -91,10 +126,18 @@ export async function gitCloneLogic(input, context) {
         const { stdout, stderr } = await execAsync(command, { 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)`, { ...context, operation, stderr });
+            logger.info(`Git clone command produced stderr (progress/info)`, {
+                ...context,
+                operation,
+                stderr,
+            });
         }
         if (stdout && !input.quiet) {
-            logger.info(`Git clone command produced stdout`, { ...context, operation, stdout });
+            logger.info(`Git clone command produced stdout`, {
+                ...context,
+                operation,
+                stdout,
+            });
         }
         // Verify the target directory exists after clone
         let repoDirExists = false;
@@ -108,29 +151,45 @@ export async function gitCloneLogic(input, context) {
             throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Clone command finished but target directory ${sanitizedTargetPath} not found.`, { context, operation });
         }
         const successMessage = `Repository cloned successfully into ${sanitizedTargetPath}`;
-        logger.info(`${operation} executed successfully`, { ...context, operation, path: sanitizedTargetPath });
+        logger.info(successMessage, {
+            ...context,
+            operation,
+            path: sanitizedTargetPath,
+        });
         return {
             success: true,
             message: successMessage,
             path: sanitizedTargetPath,
-            repoDirExists: repoDirExists
+            repoDirExists: repoDirExists,
         };
     }
     catch (error) {
-        const errorMessage = error.stderr || error.message || '';
-        logger.error(`Failed to execute git clone command`, { ...context, operation, path: sanitizedTargetPath, error: errorMessage, stderr: error.stderr, stdout: error.stdout });
+        const errorMessage = error.stderr || error.message || "";
+        logger.error(`Failed to execute git clone command`, {
+            ...context,
+            operation,
+            path: sanitizedTargetPath,
+            error: errorMessage,
+            stderr: error.stderr,
+            stdout: error.stdout,
+        });
         // Handle specific error cases
-        if (errorMessage.toLowerCase().includes('repository not found') || errorMessage.toLowerCase().includes('could not read from remote repository')) {
+        if (errorMessage.toLowerCase().includes("repository not found") ||
+            errorMessage
+                .toLowerCase()
+                .includes("could not read from remote repository")) {
             throw new McpError(BaseErrorCode.NOT_FOUND, `Repository not found or access denied: ${sanitizedRepoUrl}. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.toLowerCase().includes('already exists and is not an empty directory')) {
+        if (errorMessage
+            .toLowerCase()
+            .includes("already exists and is not an empty directory")) {
             // This should have been caught by our pre-check, but handle defensively
             throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Target directory already exists and is not empty: ${sanitizedTargetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.toLowerCase().includes('permission denied')) {
+        if (errorMessage.toLowerCase().includes("permission denied")) {
             throw new McpError(BaseErrorCode.FORBIDDEN, `Permission denied during clone operation for path: ${sanitizedTargetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
-        if (errorMessage.toLowerCase().includes('timeout')) {
+        if (errorMessage.toLowerCase().includes("timeout")) {
             throw new McpError(BaseErrorCode.TIMEOUT, `Git clone operation timed out for repository: ${sanitizedRepoUrl}. Error: ${errorMessage}`, { context, operation, originalError: error });
         }
         // Generic internal error for other failures

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

@@ -1,13 +1,13 @@
 // Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from '../../../utils/index.js';
+import { ErrorHandler } from "../../../utils/index.js";
 // Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from '../../../utils/index.js';
+import { logger } from "../../../utils/index.js";
 // Import utils from barrel (requestContextService from ../utils/internal/requestContext.js)
-import { requestContextService } from '../../../utils/index.js';
-import { GitCloneInputSchema, gitCloneLogic } from './logic.js';
-import { BaseErrorCode } from '../../../types-global/errors.js'; // Keep direct import for types-global
-const TOOL_NAME = 'git_clone';
-const TOOL_DESCRIPTION = 'Clones a Git repository from a given URL into a specified absolute directory path. Supports cloning specific branches and setting clone depth.';
+import { requestContextService } from "../../../utils/index.js";
+import { GitCloneInputSchema, gitCloneLogic, } from "./logic.js";
+import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
+const TOOL_NAME = "git_clone";
+const TOOL_DESCRIPTION = "Clones a Git repository from a given URL into a specified absolute directory path. Supports cloning specific branches and setting clone depth.";
 /**
  * Registers the git_clone tool with the MCP server.
  *
@@ -16,22 +16,25 @@ const TOOL_DESCRIPTION = 'Clones a Git repository from a given URL into a specif
  * @throws {Error} If registration fails.
  */
 export const registerGitCloneTool = async (server) => {
-    const operation = 'registerGitCloneTool';
+    const operation = "registerGitCloneTool";
     const context = requestContextService.createRequestContext({ operation });
     await ErrorHandler.tryCatch(async () => {
         server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitCloneInputSchema.shape, // Provide the Zod schema shape
         async (validatedArgs, callContext) => {
-            const toolOperation = 'tool:git_clone';
-            const requestContext = requestContextService.createRequestContext({ operation: toolOperation, parentContext: callContext });
+            const toolOperation = "tool:git_clone";
+            const requestContext = requestContextService.createRequestContext({
+                operation: toolOperation,
+                parentContext: callContext,
+            });
             logger.info(`Executing tool: ${TOOL_NAME}`, requestContext);
             return await ErrorHandler.tryCatch(async () => {
                 // Call the core logic function
                 const cloneResult = await gitCloneLogic(validatedArgs, requestContext);
                 // Format the result as a JSON string within TextContent
                 const resultContent = {
-                    type: 'text',
+                    type: "text",
                     text: JSON.stringify(cloneResult, null, 2), // Pretty-print JSON
-                    contentType: 'application/json',
+                    contentType: "application/json",
                 };
                 logger.info(`Tool ${TOOL_NAME} executed successfully, returning JSON`, requestContext);
                 return { content: [resultContent] };

package/dist/mcp-server/tools/gitCommit/index.js

@@ -2,6 +2,6 @@
  * @fileoverview Barrel file for the gitCommit tool.
  * Exports the registration function and state accessor initialization function.
  */
-export { initializeGitCommitStateAccessors, registerGitCommitTool } from './registration.js';
+export { initializeGitCommitStateAccessors, registerGitCommitTool, } from "./registration.js";
 // Export types if needed elsewhere, e.g.:
 // export type { GitCommitInput, GitCommitResult } from './logic.js';