readme

- Add mcp_config to inputs table
- Add example section showing how to use mcp_config with sequential-thinking MCP server
- Include clear explanation that custom servers override built-in servers

Co-authored-by: ashwin-ant <ashwin-ant@users.noreply.github.com>

.github/workflows/claude.yml

@@ -36,4 +36,3 @@ jobs:
           anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
           allowed_tools: "Bash(bun install),Bash(bun test:*),Bash(bun run format),Bash(bun typecheck)"
           custom_instructions: "You have also been granted tools for editing files and running bun commands (install, run, test, typecheck) for testing your changes: bun install, bun test, bun run format, bun typecheck."
-          model: "claude-opus-4-20250514"

FAQ.md

@@ -6,7 +6,7 @@ This FAQ addresses common questions and gotchas when using the Claude Code GitHu
 
 ### Why doesn't tagging @claude from my automated workflow work?
 
-The `github-actions` user cannot trigger subsequent GitHub Actions workflows. This is a GitHub security feature to prevent infinite loops. To make this work, you need to use a Personal Access Token (PAT) instead, which will act as a regular user, or use a separate app token of your own. When posting a comment on an issue or PR from your workflow, use your PAT instead of the `GITHUB_TOKEN` generated in your workflow.
+The `github-actions` user (and other GitHub Apps/bots) cannot trigger subsequent GitHub Actions workflows. This is a GitHub security feature to prevent infinite loops. To make this work, you need to use a Personal Access Token (PAT) instead, which will act as a regular user. When posting a comment on an issue or PR from your workflow, use your PAT instead of the `GITHUB_TOKEN` generated in your workflow.
 
 ### Why does Claude say I don't have permission to trigger it?
 

README.md

@@ -82,6 +82,7 @@ jobs:
 | `allowed_tools`       | Additional tools for Claude to use (the base GitHub tools will always be included)                                   | No       | ""        |
 | `disallowed_tools`    | Tools that Claude should never use                                                                                   | No       | ""        |
 | `custom_instructions` | Additional custom instructions to include in the prompt for Claude                                                   | No       | ""        |
+| `mcp_config`          | Additional MCP configuration (JSON string) that merges with the built-in GitHub MCP servers                          | No       | ""        |
 | `assignee_trigger`    | The assignee username that triggers the action (e.g. @claude). Only used for issue assignment                        | No       | -         |
 | `trigger_phrase`      | The trigger phrase to look for in comments, issue/PR bodies, and issue titles                                        | No       | `@claude` |
 
@@ -89,6 +90,61 @@ jobs:
 
 > **Note**: This action is currently in beta. Features and APIs may change as we continue to improve the integration.
 
+### Using Custom MCP Configuration
+
+The `mcp_config` input allows you to add custom MCP (Model Context Protocol) servers to extend Claude's capabilities. These servers merge with the built-in GitHub MCP servers.
+
+#### Basic Example: Adding a Sequential Thinking Server
+
+```yaml
+- uses: anthropics/claude-code-action@beta
+  with:
+    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+    mcp_config: |
+      {
+        "mcpServers": {
+          "sequential-thinking": {
+            "command": "npx",
+            "args": [
+              "-y",
+              "@modelcontextprotocol/server-sequential-thinking"
+            ]
+          }
+        }
+      }
+    allowed_tools: "mcp__sequential-thinking__sequentialthinking" # Important: Each MCP tool from your server must be listed here, comma-separated
+    # ... other inputs
+```
+
+#### Passing Secrets to MCP Servers
+
+For MCP servers that require sensitive information like API keys or tokens, use GitHub Secrets in the environment variables:
+
+```yaml
+- uses: anthropics/claude-code-action@beta
+  with:
+    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+    mcp_config: |
+      {
+        "mcpServers": {
+          "custom-api-server": {
+            "command": "npx",
+            "args": ["-y", "@example/api-server"],
+            "env": {
+              "API_KEY": "${{ secrets.CUSTOM_API_KEY }}",
+              "BASE_URL": "https://api.example.com"
+            }
+          }
+        }
+      }
+    # ... other inputs
+```
+
+**Important**:
+
+- Always use GitHub Secrets (`${{ secrets.SECRET_NAME }}`) for sensitive values like API keys, tokens, or passwords. Never hardcode secrets directly in the workflow file.
+- Your custom servers will override any built-in servers with the same name.
+
 ## Examples
 
 ### Ways to Tag @claude

action.yml

@@ -39,6 +39,10 @@ inputs:
     description: "Direct instruction for Claude (bypasses normal trigger detection)"
     required: false
     default: ""
+  mcp_config:
+    description: "Additional MCP configuration (JSON string) that merges with the built-in GitHub MCP servers"
+    required: false
+    default: ""
 
   # Auth configuration
   anthropic_api_key:
@@ -92,6 +96,7 @@ runs:
         ALLOWED_TOOLS: ${{ inputs.allowed_tools }}
         CUSTOM_INSTRUCTIONS: ${{ inputs.custom_instructions }}
         DIRECT_PROMPT: ${{ inputs.direct_prompt }}
+        MCP_CONFIG: ${{ inputs.mcp_config }}
         OVERRIDE_GITHUB_TOKEN: ${{ inputs.github_token }}
         GITHUB_RUN_ID: ${{ github.run_id }}
 

src/create-prompt/index.ts

@@ -361,7 +361,6 @@ export function getEventTypeAndContext(envVars: PreparedContext): {
 export function generatePrompt(
   context: PreparedContext,
   githubData: FetchDataResult,
-  isReusedBranch?: boolean,
 ): string {
   const {
     contextData,
@@ -535,7 +534,7 @@ ${context.directPrompt ? `   - DIRECT INSTRUCTION: A direct instruction was prov
       - Use mcp__github_file_ops__commit_files to commit files atomically in a single commit (supports single or multiple files).
       - When pushing changes with this tool and TRIGGER_USERNAME is not "Unknown", include a "Co-authored-by: ${context.triggerUsername} <${context.triggerUsername}@users.noreply.github.com>" line in the commit message.`
           : `
-      - You are already on the correct branch (${eventData.claudeBranch || "the PR branch"}). Do not create a new branch.${isReusedBranch ? `\n      - NOTE: This branch (${eventData.claudeBranch}) was reused from a previous Claude invocation on this issue. It may already contain some work.` : ''}
+      - You are already on the correct branch (${eventData.claudeBranch || "the PR branch"}). Do not create a new branch.
       - Push changes directly to the current branch using mcp__github_file_ops__commit_files (works for both new and existing files)
       - Use mcp__github_file_ops__commit_files to commit files atomically in a single commit (supports single or multiple files).
       - When pushing changes and TRIGGER_USERNAME is not "Unknown", include a "Co-authored-by: ${context.triggerUsername} <${context.triggerUsername}@users.noreply.github.com>" line in the commit message.
@@ -642,7 +641,6 @@ export async function createPrompt(
   claudeBranch: string | undefined,
   githubData: FetchDataResult,
   context: ParsedGitHubContext,
-  isReusedBranch?: boolean,
 ) {
   try {
     const preparedContext = prepareContext(
@@ -655,7 +653,7 @@ export async function createPrompt(
     await mkdir("/tmp/claude-prompts", { recursive: true });
 
     // Generate the prompt
-    const promptContent = generatePrompt(preparedContext, githubData, isReusedBranch);
+    const promptContent = generatePrompt(preparedContext, githubData);
 
     // Log the final prompt to console
     console.log("===== FINAL PROMPT =====");

src/entrypoints/prepare.ts

@@ -81,15 +81,16 @@ async function run() {
       branchInfo.claudeBranch,
       githubData,
       context,
-      branchInfo.isReusedBranch,
     );
 
     // Step 11: Get MCP configuration
+    const additionalMcpConfig = process.env.MCP_CONFIG || "";
     const mcpConfig = await prepareMcpConfig(
       githubToken,
       context.repository.owner,
       context.repository.repo,
       branchInfo.currentBranch,
+      additionalMcpConfig,
     );
     core.setOutput("mcp_config", mcpConfig);
   } catch (error) {

src/entrypoints/update-comment-link.ts

@@ -87,29 +87,13 @@ async function run() {
     const currentBody = comment.body ?? "";
 
     // Check if we need to add branch link for new branches
-    // For issues, we don't delete branches anymore to allow reuse
-    const skipBranchDeletion = !context.isPR && claudeBranch;
-    
-    let shouldDeleteBranch = false;
-    let branchLink = "";
-    
-    if (skipBranchDeletion) {
-      // For issue branches, just add the branch link without checking for deletion
-      const branchUrl = `${GITHUB_SERVER_URL}/${owner}/${repo}/tree/${claudeBranch}`;
-      branchLink = `\n[View branch](${branchUrl})`;
-      console.log(`Keeping issue branch ${claudeBranch} for potential reuse`);
-    } else {
-      // For PR branches, use the existing cleanup logic
-      const result = await checkAndDeleteEmptyBranch(
-        octokit,
-        owner,
-        repo,
-        claudeBranch,
-        baseBranch,
-      );
-      shouldDeleteBranch = result.shouldDeleteBranch;
-      branchLink = result.branchLink;
-    }
+    const { shouldDeleteBranch, branchLink } = await checkAndDeleteEmptyBranch(
+      octokit,
+      owner,
+      repo,
+      claudeBranch,
+      baseBranch,
+    );
 
     // Check if we need to add PR URL when we have a new branch
     let prLink = "";

src/github/operations/branch.ts

@@ -17,7 +17,6 @@ export type BranchInfo = {
   baseBranch: string;
   claudeBranch?: string;
   currentBranch: string;
-  isReusedBranch?: boolean;
 };
 
 export async function setupBranch(
@@ -80,127 +79,57 @@ export async function setupBranch(
 
   // Creating a new branch for either an issue or closed/merged PR
   const entityType = isPR ? "pr" : "issue";
-  
-  // For issues, check if a Claude branch already exists
-  let branchToUse: string | null = null;
-  let isReusedBranch = false;
-  
-  if (!isPR) {
-    // Check for existing Claude branches for this issue
-    try {
-      // Use GraphQL to efficiently search for branches with a specific prefix
-      const query = `
-        query($owner: String!, $repo: String!, $prefix: String!) {
-          repository(owner: $owner, name: $repo) {
-            refs(refPrefix: "refs/heads/", query: $prefix, first: 100) {
-              nodes {
-                name
-              }
-            }
-          }
-        }
-      `;
-      
-      const response = await octokits.graphql<{
-        repository: {
-          refs: {
-            nodes: Array<{ name: string }>;
-          };
-        };
-      }>(query, {
-        owner,
-        repo,
-        prefix: `claude/issue-${entityNumber}-`,
-      });
-      
-      const branches = response.repository.refs.nodes;
-      
-      if (branches.length > 0) {
-        // Use the first matching branch (could be sorted by date in future)
-        branchToUse = branches[0].name;
-        isReusedBranch = true;
-        console.log(`Found existing Claude branch for issue #${entityNumber}: ${branchToUse}`);
-      }
-    } catch (error) {
-      console.error("Error checking for existing branches:", error);
-      // Continue with new branch creation if check fails
-    }
-  }
-  
-  // If no existing branch found or this is a PR, create a new branch
-  if (!branchToUse) {
-    console.log(
-      `Creating new branch for ${entityType} #${entityNumber} from source branch: ${sourceBranch}...`,
-    );
+  console.log(
+    `Creating new branch for ${entityType} #${entityNumber} from source branch: ${sourceBranch}...`,
+  );
 
-    const timestamp = new Date()
-      .toISOString()
-      .replace(/[:-]/g, "")
-      .replace(/\.\d{3}Z/, "")
-      .split("T")
-      .join("_");
+  const timestamp = new Date()
+    .toISOString()
+    .replace(/[:-]/g, "")
+    .replace(/\.\d{3}Z/, "")
+    .split("T")
+    .join("_");
 
-    branchToUse = `claude/${entityType}-${entityNumber}-${timestamp}`;
-  }
+  const newBranch = `claude/${entityType}-${entityNumber}-${timestamp}`;
 
   try {
-    if (isReusedBranch) {
-      // For existing branches, just checkout
-      console.log(`Checking out existing branch: ${branchToUse}`);
-      
-      // Fetch the branch with more depth to allow for context
-      await $`git fetch origin --depth=20 ${branchToUse}`;
-      await $`git checkout ${branchToUse}`;
-      
-      console.log(
-        `Successfully checked out existing branch: ${branchToUse}`,
-      );
-      console.log(
-        `Note: This is a reused branch from a previous Claude invocation on issue #${entityNumber}`,
-      );
-    } else {
-      // Get the SHA of the source branch
-      const sourceBranchRef = await octokits.rest.git.getRef({
-        owner,
-        repo,
-        ref: `heads/${sourceBranch}`,
-      });
+    // Get the SHA of the source branch
+    const sourceBranchRef = await octokits.rest.git.getRef({
+      owner,
+      repo,
+      ref: `heads/${sourceBranch}`,
+    });
 
-      const currentSHA = sourceBranchRef.data.object.sha;
+    const currentSHA = sourceBranchRef.data.object.sha;
 
-      console.log(`Current SHA: ${currentSHA}`);
+    console.log(`Current SHA: ${currentSHA}`);
 
-      // Create branch using GitHub API
-      await octokits.rest.git.createRef({
-        owner,
-        repo,
-        ref: `refs/heads/${branchToUse}`,
-        sha: currentSHA,
-      });
+    // Create branch using GitHub API
+    await octokits.rest.git.createRef({
+      owner,
+      repo,
+      ref: `refs/heads/${newBranch}`,
+      sha: currentSHA,
+    });
 
-      // Checkout the new branch (shallow fetch for performance)
-      await $`git fetch origin --depth=1 ${branchToUse}`;
-      await $`git checkout ${branchToUse}`;
+    // Checkout the new branch (shallow fetch for performance)
+    await $`git fetch origin --depth=1 ${newBranch}`;
+    await $`git checkout ${newBranch}`;
 
-      console.log(
-        `Successfully created and checked out new branch: ${branchToUse}`,
-      );
-    }
+    console.log(
+      `Successfully created and checked out new branch: ${newBranch}`,
+    );
 
     // Set outputs for GitHub Actions
-    core.setOutput("CLAUDE_BRANCH", branchToUse);
+    core.setOutput("CLAUDE_BRANCH", newBranch);
     core.setOutput("BASE_BRANCH", sourceBranch);
-    if (isReusedBranch) {
-      core.setOutput("IS_REUSED_BRANCH", "true");
-    }
     return {
       baseBranch: sourceBranch,
-      claudeBranch: branchToUse,
-      currentBranch: branchToUse,
-      isReusedBranch,
+      claudeBranch: newBranch,
+      currentBranch: newBranch,
     };
   } catch (error) {
-    console.error("Error setting up branch:", error);
+    console.error("Error creating branch:", error);
     process.exit(1);
   }
 }

src/mcp/install-mcp-server.ts

@@ -5,9 +5,10 @@ export async function prepareMcpConfig(
   owner: string,
   repo: string,
   branch: string,
+  additionalMcpConfig?: string,
 ): Promise<string> {
   try {
-    const mcpConfig = {
+    const baseMcpConfig = {
       mcpServers: {
         github: {
           command: "docker",
@@ -40,7 +41,39 @@ export async function prepareMcpConfig(
       },
     };
 
-    return JSON.stringify(mcpConfig, null, 2);
+    // Merge with additional MCP config if provided
+    if (additionalMcpConfig && additionalMcpConfig.trim()) {
+      try {
+        const additionalConfig = JSON.parse(additionalMcpConfig);
+
+        // Validate that parsed JSON is an object
+        if (typeof additionalConfig !== "object" || additionalConfig === null) {
+          throw new Error("MCP config must be a valid JSON object");
+        }
+
+        core.info(
+          "Merging additional MCP server configuration with built-in servers",
+        );
+
+        // Merge configurations with user config overriding built-in servers
+        const mergedConfig = {
+          ...baseMcpConfig,
+          ...additionalConfig,
+          mcpServers: {
+            ...baseMcpConfig.mcpServers,
+            ...additionalConfig.mcpServers,
+          },
+        };
+
+        return JSON.stringify(mergedConfig, null, 2);
+      } catch (parseError) {
+        core.warning(
+          `Failed to parse additional MCP config: ${parseError}. Using base config only.`,
+        );
+      }
+    }
+
+    return JSON.stringify(baseMcpConfig, null, 2);
   } catch (error) {
     core.setFailed(`Install MCP server failed with error: ${error}`);
     process.exit(1);

test/install-mcp-server.test.ts

@@ -0,0 +1,344 @@
+import { describe, test, expect, beforeEach, afterEach, spyOn } from "bun:test";
+import { prepareMcpConfig } from "../src/mcp/install-mcp-server";
+import * as core from "@actions/core";
+
+describe("prepareMcpConfig", () => {
+  let consoleInfoSpy: any;
+  let consoleWarningSpy: any;
+  let setFailedSpy: any;
+  let processExitSpy: any;
+
+  beforeEach(() => {
+    consoleInfoSpy = spyOn(core, "info").mockImplementation(() => {});
+    consoleWarningSpy = spyOn(core, "warning").mockImplementation(() => {});
+    setFailedSpy = spyOn(core, "setFailed").mockImplementation(() => {});
+    processExitSpy = spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("Process exit");
+    });
+  });
+
+  afterEach(() => {
+    consoleInfoSpy.mockRestore();
+    consoleWarningSpy.mockRestore();
+    setFailedSpy.mockRestore();
+    processExitSpy.mockRestore();
+  });
+
+  test("should return base config when no additional config is provided", async () => {
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.mcpServers).toBeDefined();
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.github_file_ops).toBeDefined();
+    expect(parsed.mcpServers.github.env.GITHUB_PERSONAL_ACCESS_TOKEN).toBe(
+      "test-token",
+    );
+    expect(parsed.mcpServers.github_file_ops.env.GITHUB_TOKEN).toBe(
+      "test-token",
+    );
+    expect(parsed.mcpServers.github_file_ops.env.REPO_OWNER).toBe("test-owner");
+    expect(parsed.mcpServers.github_file_ops.env.REPO_NAME).toBe("test-repo");
+    expect(parsed.mcpServers.github_file_ops.env.BRANCH_NAME).toBe(
+      "test-branch",
+    );
+  });
+
+  test("should return base config when additional config is empty string", async () => {
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      "",
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.mcpServers).toBeDefined();
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.github_file_ops).toBeDefined();
+    expect(consoleWarningSpy).not.toHaveBeenCalled();
+  });
+
+  test("should return base config when additional config is whitespace only", async () => {
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      "   \n\t  ",
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.mcpServers).toBeDefined();
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.github_file_ops).toBeDefined();
+    expect(consoleWarningSpy).not.toHaveBeenCalled();
+  });
+
+  test("should merge valid additional config with base config", async () => {
+    const additionalConfig = JSON.stringify({
+      mcpServers: {
+        custom_server: {
+          command: "custom-command",
+          args: ["arg1", "arg2"],
+          env: {
+            CUSTOM_ENV: "custom-value",
+          },
+        },
+      },
+    });
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      additionalConfig,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(consoleInfoSpy).toHaveBeenCalledWith(
+      "Merging additional MCP server configuration with built-in servers",
+    );
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.github_file_ops).toBeDefined();
+    expect(parsed.mcpServers.custom_server).toBeDefined();
+    expect(parsed.mcpServers.custom_server.command).toBe("custom-command");
+    expect(parsed.mcpServers.custom_server.args).toEqual(["arg1", "arg2"]);
+    expect(parsed.mcpServers.custom_server.env.CUSTOM_ENV).toBe("custom-value");
+  });
+
+  test("should override built-in servers when additional config has same server names", async () => {
+    const additionalConfig = JSON.stringify({
+      mcpServers: {
+        github: {
+          command: "overridden-command",
+          args: ["overridden-arg"],
+          env: {
+            OVERRIDDEN_ENV: "overridden-value",
+          },
+        },
+      },
+    });
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      additionalConfig,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(consoleInfoSpy).toHaveBeenCalledWith(
+      "Merging additional MCP server configuration with built-in servers",
+    );
+    expect(parsed.mcpServers.github.command).toBe("overridden-command");
+    expect(parsed.mcpServers.github.args).toEqual(["overridden-arg"]);
+    expect(parsed.mcpServers.github.env.OVERRIDDEN_ENV).toBe(
+      "overridden-value",
+    );
+    expect(
+      parsed.mcpServers.github.env.GITHUB_PERSONAL_ACCESS_TOKEN,
+    ).toBeUndefined();
+    expect(parsed.mcpServers.github_file_ops).toBeDefined();
+  });
+
+  test("should merge additional root-level properties", async () => {
+    const additionalConfig = JSON.stringify({
+      customProperty: "custom-value",
+      anotherProperty: {
+        nested: "value",
+      },
+      mcpServers: {
+        custom_server: {
+          command: "custom",
+        },
+      },
+    });
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      additionalConfig,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.customProperty).toBe("custom-value");
+    expect(parsed.anotherProperty).toEqual({ nested: "value" });
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.custom_server).toBeDefined();
+  });
+
+  test("should handle invalid JSON gracefully", async () => {
+    const invalidJson = "{ invalid json }";
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      invalidJson,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(consoleWarningSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Failed to parse additional MCP config:"),
+    );
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.github_file_ops).toBeDefined();
+  });
+
+  test("should handle non-object JSON values", async () => {
+    const nonObjectJson = JSON.stringify("string value");
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      nonObjectJson,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(consoleWarningSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Failed to parse additional MCP config:"),
+    );
+    expect(consoleWarningSpy).toHaveBeenCalledWith(
+      expect.stringContaining("MCP config must be a valid JSON object"),
+    );
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.github_file_ops).toBeDefined();
+  });
+
+  test("should handle null JSON value", async () => {
+    const nullJson = JSON.stringify(null);
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      nullJson,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(consoleWarningSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Failed to parse additional MCP config:"),
+    );
+    expect(consoleWarningSpy).toHaveBeenCalledWith(
+      expect.stringContaining("MCP config must be a valid JSON object"),
+    );
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.github_file_ops).toBeDefined();
+  });
+
+  test("should handle array JSON value", async () => {
+    const arrayJson = JSON.stringify([1, 2, 3]);
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      arrayJson,
+    );
+
+    const parsed = JSON.parse(result);
+    // Arrays are objects in JavaScript, so they pass the object check
+    // But they'll fail when trying to spread or access mcpServers property
+    expect(consoleInfoSpy).toHaveBeenCalledWith(
+      "Merging additional MCP server configuration with built-in servers",
+    );
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.github_file_ops).toBeDefined();
+    // The array will be spread into the config (0: 1, 1: 2, 2: 3)
+    expect(parsed[0]).toBe(1);
+    expect(parsed[1]).toBe(2);
+    expect(parsed[2]).toBe(3);
+  });
+
+  test("should merge complex nested configurations", async () => {
+    const additionalConfig = JSON.stringify({
+      mcpServers: {
+        server1: {
+          command: "cmd1",
+          env: { KEY1: "value1" },
+        },
+        server2: {
+          command: "cmd2",
+          env: { KEY2: "value2" },
+        },
+        github_file_ops: {
+          command: "overridden",
+          env: { CUSTOM: "value" },
+        },
+      },
+      otherConfig: {
+        nested: {
+          deeply: "value",
+        },
+      },
+    });
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+      additionalConfig,
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.mcpServers.server1).toBeDefined();
+    expect(parsed.mcpServers.server2).toBeDefined();
+    expect(parsed.mcpServers.github).toBeDefined();
+    expect(parsed.mcpServers.github_file_ops.command).toBe("overridden");
+    expect(parsed.mcpServers.github_file_ops.env.CUSTOM).toBe("value");
+    expect(parsed.otherConfig.nested.deeply).toBe("value");
+  });
+
+  test("should preserve GITHUB_ACTION_PATH in file_ops server args", async () => {
+    const oldEnv = process.env.GITHUB_ACTION_PATH;
+    process.env.GITHUB_ACTION_PATH = "/test/action/path";
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.mcpServers.github_file_ops.args[1]).toBe(
+      "/test/action/path/src/mcp/github-file-ops-server.ts",
+    );
+
+    process.env.GITHUB_ACTION_PATH = oldEnv;
+  });
+
+  test("should use process.cwd() when GITHUB_WORKSPACE is not set", async () => {
+    const oldEnv = process.env.GITHUB_WORKSPACE;
+    delete process.env.GITHUB_WORKSPACE;
+
+    const result = await prepareMcpConfig(
+      "test-token",
+      "test-owner",
+      "test-repo",
+      "test-branch",
+    );
+
+    const parsed = JSON.parse(result);
+    expect(parsed.mcpServers.github_file_ops.env.REPO_DIR).toBe(process.cwd());
+
+    process.env.GITHUB_WORKSPACE = oldEnv;
+  });
+});