@cyanheads/git-mcp-server 2.1.8 → 2.2.1

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

@@ -1,6 +1,5 @@
 /**
  * @fileoverview Barrel file for the gitFetch tool.
+ * @module src/mcp-server/tools/gitFetch/index
  */
-export { registerGitFetchTool, initializeGitFetchStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitFetchInput, GitFetchResult } from './logic.js';
+export { registerGitFetchTool } from "./registration.js";

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

@@ -1,149 +1,51 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_fetch tool.
+ * @module src/mcp-server/tools/gitFetch/logic
+ */
 import { execFile } from "child_process";
 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 utils from barrel (RequestContext from ../utils/internal/requestContext.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";
+import { logger, sanitization } from "../../../utils/index.js";
+import { McpError, BaseErrorCode } from "../../../types-global/errors.js";
 const execFileAsync = promisify(execFile);
-// Define the input schema for the git_fetch tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitFetchInputSchema = z.object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .default(".")
-        .describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
-    remote: z
-        .string()
-        .optional()
-        .describe("The remote repository to fetch from (e.g., 'origin'). If omitted, fetches from 'origin' or the default configured remote."),
-    prune: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Before fetching, remove any remote-tracking references that no longer exist on the remote."),
-    tags: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe("Fetch all tags from the remote (in addition to whatever else is fetched)."),
-    all: z.boolean().optional().default(false).describe("Fetch all remotes."),
-    // Add options like --depth, specific refspecs if needed
+    path: z.string().default(".").describe("Path to the Git repository. Defaults to the directory set via `git_set_working_dir` for the session; set 'git_set_working_dir' if not set."),
+    remote: z.string().optional().describe("The remote repository to fetch from (e.g., 'origin')."),
+    prune: z.boolean().default(false).describe("Remove remote-tracking references that no longer exist on the remote."),
+    tags: z.boolean().default(false).describe("Fetch all tags from the remote."),
+    all: z.boolean().default(false).describe("Fetch all remotes."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitFetchOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
 });
 /**
- * Executes the 'git fetch' command and returns structured JSON output.
- *
- * @param {GitFetchInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitFetchResult>} A promise that resolves with the structured fetch result.
- * @throws {McpError} Throws an McpError if path resolution, validation, or the git command fails unexpectedly.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function fetchGitRemote(input, context) {
+export async function fetchGitRemote(params, context) {
     const operation = "fetchGitRemote";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Resolve and sanitize the target path
-        if (input.path && input.path !== ".") {
-            targetPath = input.path;
-        }
-        else {
-            const workingDir = context.getWorkingDirectory();
-            if (!workingDir) {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No path provided and no working directory set for the session.", { context, operation });
-            }
-            targetPath = workingDir;
-        }
-        targetPath = sanitization.sanitizePath(targetPath, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPath: targetPath,
-        });
-    }
-    catch (error) {
-        logger.error("Path resolution or sanitization failed", {
-            ...context,
-            operation,
-            error,
-        });
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const workingDir = context.getWorkingDirectory();
+    if (params.path === "." && !workingDir) {
+        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "No session working directory set. Please specify a 'path' or use 'git_set_working_dir' first.");
     }
-    try {
-        // Construct the git fetch command
-        const args = ["-C", targetPath, "fetch"];
-        if (input.prune) {
-            args.push("--prune");
-        }
-        if (input.tags) {
-            args.push("--tags");
-        }
-        if (input.all) {
-            args.push("--all");
-        }
-        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: git ${args.join(" ")}`, {
-            ...context,
-            operation,
-        });
-        // Execute command. Fetch output is primarily on stderr.
-        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
-        }
-        // Analyze stderr for success/summary
-        const message = "Fetch successful.";
-        const summary = stderr.trim() || "No changes detected.";
-        logger.info(message, {
-            ...context,
-            operation,
-            path: targetPath,
-            summary,
-        });
-        return { success: true, message, summary };
+    const targetPath = sanitization.sanitizePath(params.path === "." ? workingDir : params.path, { allowAbsolute: true }).sanitizedPath;
+    const args = ["-C", targetPath, "fetch"];
+    if (params.prune)
+        args.push("--prune");
+    if (params.tags)
+        args.push("--tags");
+    if (params.all) {
+        args.push("--all");
     }
-    catch (error) {
-        logger.error(`Failed to execute git fetch command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: error.message,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        const errorMessage = error.stderr || error.stdout || error.message || "";
-        // Handle specific error cases
-        if (errorMessage.toLowerCase().includes("not a git repository")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Path is not a Git repository: ${targetPath}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("resolve host") ||
-            errorMessage.includes("Could not read from remote repository") ||
-            errorMessage.includes("Connection timed out")) {
-            throw new McpError(BaseErrorCode.SERVICE_UNAVAILABLE, `Failed to connect to remote repository '${input.remote || "default"}'. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("fatal: ") &&
-            errorMessage.includes("couldn't find remote ref")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Remote ref not found. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("Authentication failed") ||
-            errorMessage.includes("Permission denied")) {
-            throw new McpError(BaseErrorCode.UNAUTHORIZED, `Authentication failed for remote repository '${input.remote || "default"}'. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        if (errorMessage.includes("does not appear to be a git repository")) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, `Remote '${input.remote || "default"}' does not appear to be a git repository. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to git fetch for path: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+    else if (params.remote) {
+        args.push(params.remote);
     }
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stderr } = await execFileAsync("git", args);
+    const message = stderr.trim() || "Fetch successful.";
+    return { success: true, message };
 }

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

@@ -1,76 +1,64 @@
-// Import utils from barrel (ErrorHandler from ../utils/internal/errorHandler.js)
-import { ErrorHandler } from "../../../utils/index.js";
-// Import utils from barrel (logger from ../utils/internal/logger.js)
-import { logger } from "../../../utils/index.js";
-// Import utils from barrel (requestContextService, RequestContext from ../utils/internal/requestContext.js)
-import { BaseErrorCode } from "../../../types-global/errors.js"; // Keep direct import for types-global
-import { requestContextService } from "../../../utils/index.js";
-import { fetchGitRemote, GitFetchInputSchema, } from "./logic.js";
-let _getWorkingDirectory;
-let _getSessionId;
 /**
- * Initializes the state accessors needed by the tool registration.
- * This should be called once during server setup.
- * @param getWdFn - Function to get the working directory for a session.
- * @param getSidFn - Function to get the session ID from context.
+ * @fileoverview Handles registration and error handling for the git_fetch tool.
+ * @module src/mcp-server/tools/gitFetch/registration
  */
-export function initializeGitFetchStateAccessors(getWdFn, getSidFn) {
-    _getWorkingDirectory = getWdFn;
-    _getSessionId = getSidFn;
-    logger.info("State accessors initialized for git_fetch tool registration.");
-}
+import { ErrorHandler, logger, requestContextService } from "../../../utils/index.js";
+import { fetchGitRemote, GitFetchInputSchema, GitFetchOutputSchema, } from "./logic.js";
 const TOOL_NAME = "git_fetch";
-const TOOL_DESCRIPTION = "Downloads objects and refs from one or more other repositories. Can fetch specific remotes or all, prune stale branches, and fetch tags.";
+const TOOL_DESCRIPTION = "Downloads objects and refs from one or more repositories. Can fetch specific remotes or all, prune stale branches, and fetch tags.";
 /**
- * Registers the git_fetch tool with the MCP server.
- *
- * @param {McpServer} server - The MCP server instance.
- * @throws {Error} If state accessors are not initialized.
+ * Registers the git_fetch tool with the MCP server instance.
+ * @param server The MCP server instance.
+ * @param getWorkingDirectory Function to get the session's working directory.
+ * @param getSessionId Function to get the session ID from context.
  */
-export async function registerGitFetchTool(server) {
-    if (!_getWorkingDirectory || !_getSessionId) {
-        throw new Error("State accessors for git_fetch must be initialized before registration.");
-    }
+export const registerGitFetchTool = async (server, getWorkingDirectory, getSessionId) => {
     const operation = "registerGitFetchTool";
     const context = requestContextService.createRequestContext({ operation });
-    await ErrorHandler.tryCatch(async () => {
-        server.tool(TOOL_NAME, TOOL_DESCRIPTION, GitFetchInputSchema.shape, // Provide the Zod schema shape
-        async (validatedArgs, callContext) => {
-            const toolOperation = "tool:git_fetch";
-            const requestContext = requestContextService.createRequestContext({
-                operation: toolOperation,
-                parentContext: callContext,
+    server.registerTool(TOOL_NAME, {
+        title: "Git Fetch",
+        description: TOOL_DESCRIPTION,
+        inputSchema: GitFetchInputSchema.shape,
+        outputSchema: GitFetchOutputSchema.shape,
+        annotations: {
+            readOnlyHint: false, // Modifies local refs
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true, // Interacts with remote repositories
+        },
+    }, async (params, callContext) => {
+        const handlerContext = requestContextService.createRequestContext({
+            toolName: TOOL_NAME,
+            parentContext: callContext,
+        });
+        try {
+            const sessionId = getSessionId(handlerContext);
+            const result = await fetchGitRemote(params, {
+                ...handlerContext,
+                getWorkingDirectory: () => getWorkingDirectory(sessionId),
             });
-            const sessionId = _getSessionId(requestContext);
-            const getWorkingDirectoryForSession = () => {
-                return _getWorkingDirectory(sessionId);
-            };
-            const logicContext = {
-                ...requestContext,
-                sessionId: sessionId,
-                getWorkingDirectory: getWorkingDirectoryForSession,
+            return {
+                structuredContent: result,
+                content: [{ type: "text", text: `Success: ${JSON.stringify(result, null, 2)}` }],
             };
-            logger.info(`Executing tool: ${TOOL_NAME}`, logicContext);
-            return await ErrorHandler.tryCatch(async () => {
-                // Call the core logic function
-                const fetchResult = await fetchGitRemote(validatedArgs, logicContext);
-                // Format the result as a JSON string within TextContent
-                const resultContent = {
-                    type: "text",
-                    // Stringify the entire GitFetchResult object
-                    text: JSON.stringify(fetchResult, null, 2), // Pretty-print JSON
-                    contentType: "application/json",
-                };
-                logger.info(`Tool ${TOOL_NAME} executed successfully: ${fetchResult.message}`, logicContext);
-                // Success is determined by the logic function and included in the result object
-                return { content: [resultContent] };
-            }, {
-                operation: toolOperation,
-                context: logicContext,
-                input: validatedArgs,
-                errorCode: BaseErrorCode.INTERNAL_ERROR, // Default if unexpected error in logic
+        }
+        catch (error) {
+            logger.error(`Error in ${TOOL_NAME} handler`, { error, ...handlerContext });
+            const mcpError = ErrorHandler.handleError(error, {
+                operation: `tool:${TOOL_NAME}`,
+                context: handlerContext,
+                input: params,
             });
-        });
-        logger.info(`Tool registered: ${TOOL_NAME}`, context);
-    }, { operation, context, critical: true });
-}
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Error: ${mcpError.message}` }],
+                structuredContent: {
+                    code: mcpError.code,
+                    message: mcpError.message,
+                    details: mcpError.details,
+                },
+            };
+        }
+    });
+    logger.info(`Tool '${TOOL_NAME}' registered successfully.`, context);
+};

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

@@ -1,7 +1,5 @@
 /**
- * @fileoverview Barrel file for the git_init tool.
- * Exports the registration function and the state accessor initializer.
+ * @fileoverview Barrel file for the gitInit tool.
+ * @module src/mcp-server/tools/gitInit/index
  */
-export { registerGitInitTool, initializeGitInitStateAccessors, } from "./registration.js";
-// Export types if needed elsewhere, e.g.:
-// export type { GitInitInput, GitInitResult } from './logic.js';
+export { registerGitInitTool } from "./registration.js";

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

@@ -1,175 +1,53 @@
+/**
+ * @fileoverview Defines the core logic, schemas, and types for the git_init tool.
+ * @module src/mcp-server/tools/gitInit/logic
+ */
 import { execFile } from "child_process";
 import fs from "fs/promises";
 import path from "path";
 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 utils from barrel (RequestContext from ../utils/internal/requestContext.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";
+import { logger, sanitization } from "../../../utils/index.js";
 const execFileAsync = promisify(execFile);
-// Define the input schema for the git_init tool using Zod
+// 1. DEFINE the Zod input schema.
 export const GitInitInputSchema = z.object({
-    path: z
-        .string()
-        .min(1)
-        .optional()
-        .default(".")
-        .describe("Path where the new Git repository should be initialized. Can be relative or absolute. If relative or '.', it resolves against the directory set via `git_set_working_dir` for the session. If absolute, it's used directly. If omitted, defaults to '.' (resolved against session git working directory)."),
-    initialBranch: z
-        .string()
-        .optional()
-        .describe("Optional name for the initial branch (e.g., 'main'). Uses Git's default if not specified."),
-    bare: z
-        .boolean()
-        .default(false)
-        .describe("Create a bare repository (no working directory)."),
-    quiet: z
-        .boolean()
-        .default(false)
-        .describe("Only print error and warning messages; all other output will be suppressed."),
+    path: z.string().default(".").describe("Path where the new Git repository should be initialized."),
+    initialBranch: z.string().optional().describe("The name for the initial branch (e.g., 'main')."),
+    bare: z.boolean().default(false).describe("Create a bare repository with no working directory."),
+    quiet: z.boolean().default(false).describe("Suppress all output except for errors and warnings."),
+});
+// 2. DEFINE the Zod response schema.
+export const GitInitOutputSchema = z.object({
+    success: z.boolean().describe("Indicates if the command was successful."),
+    message: z.string().describe("A summary message of the result."),
+    path: z.string().describe("The path where the repository was initialized."),
+    gitDirExists: z.boolean().describe("Confirms the .git directory was created."),
 });
 /**
- * Executes the 'git init' command to initialize a new Git repository.
- *
- * @param {GitInitInput} input - The validated input object.
- * @param {RequestContext} context - The request context for logging and error handling.
- * @returns {Promise<GitInitResult>} A promise that resolves with the structured init result.
- * @throws {McpError} Throws an McpError if path validation fails or the git command fails unexpectedly.
+ * 4. IMPLEMENT the core logic function.
+ * @throws {McpError} If the logic encounters an unrecoverable issue.
  */
-export async function gitInitLogic(input, context) {
+export async function gitInitLogic(params, context) {
     const operation = "gitInitLogic";
-    logger.debug(`Executing ${operation}`, { ...context, input });
-    let targetPath;
-    try {
-        // Sanitize the provided absolute path
-        targetPath = sanitization.sanitizePath(input.path, {
-            allowAbsolute: true,
-        }).sanitizedPath;
-        logger.debug("Sanitized path", {
-            ...context,
-            operation,
-            sanitizedPath: targetPath,
-        });
-        // Ensure the target directory exists before trying to init inside it
-        // git init creates the directory if it doesn't exist, but we might want to ensure the parent exists
-        const parentDir = path.dirname(targetPath);
-        try {
-            await fs.access(parentDir, fs.constants.W_OK); // Check write access in parent
-        }
-        catch (accessError) {
-            logger.error(`Parent directory check failed for ${targetPath}`, {
-                ...context,
-                operation,
-                error: accessError.message,
-            });
-            if (accessError.code === "ENOENT") {
-                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Parent directory does not exist: ${parentDir}`, { context, operation });
-            }
-            throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Cannot access parent directory: ${parentDir}. Error: ${accessError.message}`, { context, operation });
-        }
-    }
-    catch (error) {
-        logger.error("Path validation or sanitization failed", {
-            ...context,
-            operation,
-            error,
-        });
-        if (error instanceof McpError)
-            throw error;
-        throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Invalid path: ${error instanceof Error ? error.message : String(error)}`, { context, operation, originalError: error });
-    }
-    try {
-        // Construct the git init command
-        const args = ["init"];
-        if (input.quiet) {
-            args.push("--quiet");
-        }
-        if (input.bare) {
-            args.push("--bare");
-        }
-        // Determine the initial branch name, defaulting to 'main' if not provided
-        const branchNameToUse = input.initialBranch || "main";
-        args.push("-b", branchNameToUse);
-        // Add the target directory path at the end
-        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`, {
-                ...context,
-                operation,
-                stderr,
-            });
-        }
-        if (stdout && !input.quiet) {
-            // Log stdout at debug level for cleaner info logs
-            logger.debug(`Git init command produced stdout`, {
-                ...context,
-                operation,
-                stdout,
-            });
-        }
-        // Verify .git directory exists (or equivalent for bare repo)
-        const gitDirPath = input.bare ? targetPath : path.join(targetPath, ".git");
-        let gitDirExists = false;
-        try {
-            await fs.access(gitDirPath);
-            gitDirExists = true;
-        }
-        catch (e) {
-            logger.warning(`Could not verify existence of ${gitDirPath} after git init`, { ...context, operation });
-        }
-        const successMessage = `Successfully initialized Git repository in ${targetPath}`;
-        logger.info(successMessage, {
-            ...context,
-            operation,
-            path: targetPath,
-            bare: input.bare,
-            initialBranch: input.initialBranch || "default",
-        });
-        return {
-            success: true,
-            message: stdout.trim() || successMessage, // Return stdout to user if available
-            path: targetPath,
-            gitDirExists: gitDirExists,
-        };
-    }
-    catch (error) {
-        const errorMessage = error.stderr || error.message || "";
-        logger.error(`Failed to execute git init command`, {
-            ...context,
-            operation,
-            path: targetPath,
-            error: errorMessage,
-            stderr: error.stderr,
-            stdout: error.stdout,
-        });
-        // Handle specific error cases
-        if (errorMessage.toLowerCase().includes("already exists") &&
-            errorMessage.toLowerCase().includes("git repository")) {
-            // Reinitializing is often okay, treat as success but mention it.
-            logger.info(`Repository already exists, reinitialized: ${targetPath}`, {
-                ...context,
-                operation,
-            });
-            return {
-                success: true, // Treat reinitialization as success
-                message: `Reinitialized existing Git repository in ${targetPath}`,
-                path: targetPath,
-                gitDirExists: true, // Assume it exists if reinit message appears
-            };
-        }
-        if (errorMessage.toLowerCase().includes("permission denied")) {
-            throw new McpError(BaseErrorCode.FORBIDDEN, `Permission denied to initialize repository at: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
-        }
-        // Generic internal error for other failures
-        throw new McpError(BaseErrorCode.INTERNAL_ERROR, `Failed to initialize repository at: ${targetPath}. Error: ${errorMessage}`, { context, operation, originalError: error });
+    logger.debug(`Executing ${operation}`, { ...context, params });
+    const targetPath = sanitization.sanitizePath(params.path, { allowAbsolute: true }).sanitizedPath;
+    const parentDir = path.dirname(targetPath);
+    await fs.access(parentDir, fs.constants.W_OK);
+    const args = ["init"];
+    if (params.quiet)
+        args.push("--quiet");
+    if (params.bare)
+        args.push("--bare");
+    args.push(`--initial-branch=${params.initialBranch || 'main'}`);
+    args.push(targetPath);
+    logger.debug(`Executing command: git ${args.join(" ")}`, { ...context, operation });
+    const { stdout, stderr } = await execFileAsync("git", args);
+    // Re-initializing is not an error, so we check for it and return a success response.
+    if ((stderr || stdout).toLowerCase().includes("reinitialized existing git repository")) {
+        return { success: true, message: `Reinitialized existing Git repository in ${targetPath}`, path: targetPath, gitDirExists: true };
     }
+    const gitDirPath = params.bare ? targetPath : path.join(targetPath, ".git");
+    const gitDirExists = await fs.access(gitDirPath).then(() => true).catch(() => false);
+    const successMessage = stdout.trim() || `Successfully initialized Git repository in ${targetPath}`;
+    return { success: true, message: successMessage, path: targetPath, gitDirExists };
 }