@vicoa/cli 1.3.13-win32-x64 → 1.3.13

package/bin/_internal/integrations/github/claude-code-action/src/mcp/github-inline-comment-server.ts

@@ -1,184 +0,0 @@
-#!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { createOctokit } from "../github/api/client";
-import { sanitizeContent } from "../github/utils/sanitizer";
-
-// Get repository and PR information from environment variables
-const REPO_OWNER = process.env.REPO_OWNER;
-const REPO_NAME = process.env.REPO_NAME;
-const PR_NUMBER = process.env.PR_NUMBER;
-
-if (!REPO_OWNER || !REPO_NAME || !PR_NUMBER) {
-  console.error(
-    "Error: REPO_OWNER, REPO_NAME, and PR_NUMBER environment variables are required",
-  );
-  process.exit(1);
-}
-
-// GitHub Inline Comment MCP Server - Provides inline PR comment functionality
-// Provides an inline comment tool without exposing full PR review capabilities, so that
-// Claude can't accidentally approve a PR
-const server = new McpServer({
-  name: "GitHub Inline Comment Server",
-  version: "0.0.1",
-});
-
-server.tool(
-  "create_inline_comment",
-  "Create an inline comment on a specific line or lines in a PR file",
-  {
-    path: z
-      .string()
-      .describe("The file path to comment on (e.g., 'src/index.js')"),
-    body: z
-      .string()
-      .describe(
-        "The comment text (supports markdown and GitHub code suggestion blocks). " +
-          "For code suggestions, use: ```suggestion\\nreplacement code\\n```. " +
-          "IMPORTANT: The suggestion block will REPLACE the ENTIRE line range (single line or startLine to line). " +
-          "Ensure the replacement is syntactically complete and valid - it must work as a drop-in replacement for the selected lines.",
-      ),
-    line: z
-      .number()
-      .nonnegative()
-      .optional()
-      .describe(
-        "Line number for single-line comments (required if startLine is not provided)",
-      ),
-    startLine: z
-      .number()
-      .nonnegative()
-      .optional()
-      .describe(
-        "Start line for multi-line comments (use with line parameter for the end line)",
-      ),
-    side: z
-      .enum(["LEFT", "RIGHT"])
-      .optional()
-      .default("RIGHT")
-      .describe(
-        "Side of the diff to comment on: LEFT (old code) or RIGHT (new code)",
-      ),
-    commit_id: z
-      .string()
-      .optional()
-      .describe(
-        "Specific commit SHA to comment on (defaults to latest commit)",
-      ),
-  },
-  async ({ path, body, line, startLine, side, commit_id }) => {
-    try {
-      const githubToken = process.env.GITHUB_TOKEN;
-
-      if (!githubToken) {
-        throw new Error("GITHUB_TOKEN environment variable is required");
-      }
-
-      const owner = REPO_OWNER;
-      const repo = REPO_NAME;
-      const pull_number = parseInt(PR_NUMBER, 10);
-
-      const octokit = createOctokit(githubToken).rest;
-
-      // Sanitize the comment body to remove any potential GitHub tokens
-      const sanitizedBody = sanitizeContent(body);
-
-      // Validate that either line or both startLine and line are provided
-      if (!line && !startLine) {
-        throw new Error(
-          "Either 'line' for single-line comments or both 'startLine' and 'line' for multi-line comments must be provided",
-        );
-      }
-
-      // If only line is provided, it's a single-line comment
-      // If both startLine and line are provided, it's a multi-line comment
-      const isSingleLine = !startLine;
-
-      const pr = await octokit.pulls.get({
-        owner,
-        repo,
-        pull_number,
-      });
-
-      const params: Parameters<
-        typeof octokit.rest.pulls.createReviewComment
-      >[0] = {
-        owner,
-        repo,
-        pull_number,
-        body: sanitizedBody,
-        path,
-        side: side || "RIGHT",
-        commit_id: commit_id || pr.data.head.sha,
-      };
-
-      if (isSingleLine) {
-        // Single-line comment
-        params.line = line;
-      } else {
-        // Multi-line comment
-        params.start_line = startLine;
-        params.start_side = side || "RIGHT";
-        params.line = line;
-      }
-
-      const result = await octokit.rest.pulls.createReviewComment(params);
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                success: true,
-                comment_id: result.data.id,
-                html_url: result.data.html_url,
-                path: result.data.path,
-                line: result.data.line || result.data.original_line,
-                message: `Inline comment created successfully on ${path}${isSingleLine ? ` at line ${line}` : ` from line ${startLine} to ${line}`}`,
-              },
-              null,
-              2,
-            ),
-          },
-        ],
-      };
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-
-      // Provide more helpful error messages for common issues
-      let helpMessage = "";
-      if (errorMessage.includes("Validation Failed")) {
-        helpMessage =
-          "\n\nThis usually means the line number doesn't exist in the diff or the file path is incorrect. Make sure you're commenting on lines that are part of the PR's changes.";
-      } else if (errorMessage.includes("Not Found")) {
-        helpMessage =
-          "\n\nThis usually means the PR number, repository, or file path is incorrect.";
-      }
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error creating inline comment: ${errorMessage}${helpMessage}`,
-          },
-        ],
-        error: errorMessage,
-        isError: true,
-      };
-    }
-  },
-);
-
-async function runServer() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  process.on("exit", () => {
-    server.close();
-  });
-}
-
-runServer().catch(console.error);

package/bin/_internal/integrations/github/claude-code-action/src/mcp/install-mcp-server.ts

@@ -1,201 +0,0 @@
-import * as core from "@actions/core";
-import { GITHUB_API_URL, GITHUB_SERVER_URL } from "../github/api/config";
-import type { GitHubContext } from "../github/context";
-import { isEntityContext } from "../github/context";
-import { Octokit } from "@octokit/rest";
-
-type PrepareConfigParams = {
-  githubToken: string;
-  owner: string;
-  repo: string;
-  branch: string;
-  baseBranch: string;
-  claudeCommentId?: string;
-  allowedTools: string[];
-  context: GitHubContext;
-};
-
-async function checkActionsReadPermission(
-  token: string,
-  owner: string,
-  repo: string,
-): Promise<boolean> {
-  try {
-    const client = new Octokit({ auth: token, baseUrl: GITHUB_API_URL });
-
-    // Try to list workflow runs - this requires actions:read
-    // We use per_page=1 to minimize the response size
-    await client.actions.listWorkflowRunsForRepo({
-      owner,
-      repo,
-      per_page: 1,
-    });
-
-    return true;
-  } catch (error: any) {
-    // Check if it's a permission error
-    if (
-      error.status === 403 &&
-      error.message?.includes("Resource not accessible")
-    ) {
-      return false;
-    }
-
-    // For other errors (network issues, etc), log but don't fail
-    core.debug(`Failed to check actions permission: ${error.message}`);
-    return false;
-  }
-}
-
-export async function prepareMcpConfig(
-  params: PrepareConfigParams,
-): Promise<string> {
-  const {
-    githubToken,
-    owner,
-    repo,
-    branch,
-    baseBranch,
-    claudeCommentId,
-    allowedTools,
-    context,
-  } = params;
-  try {
-    const allowedToolsList = allowedTools || [];
-
-    const hasGitHubMcpTools = allowedToolsList.some((tool) =>
-      tool.startsWith("mcp__github__"),
-    );
-
-    const hasInlineCommentTools = allowedToolsList.some((tool) =>
-      tool.startsWith("mcp__github_inline_comment__"),
-    );
-
-    const baseMcpConfig: { mcpServers: Record<string, unknown> } = {
-      mcpServers: {},
-    };
-
-    // Always include comment server for updating Claude comments
-    baseMcpConfig.mcpServers.github_comment = {
-      command: "bun",
-      args: [
-        "run",
-        `${process.env.GITHUB_ACTION_PATH}/src/mcp/github-comment-server.ts`,
-      ],
-      env: {
-        GITHUB_TOKEN: githubToken,
-        REPO_OWNER: owner,
-        REPO_NAME: repo,
-        ...(claudeCommentId && { CLAUDE_COMMENT_ID: claudeCommentId }),
-        GITHUB_EVENT_NAME: process.env.GITHUB_EVENT_NAME || "",
-        GITHUB_API_URL: GITHUB_API_URL,
-      },
-    };
-
-    // Include file ops server when commit signing is enabled
-    if (context.inputs.useCommitSigning) {
-      baseMcpConfig.mcpServers.github_file_ops = {
-        command: "bun",
-        args: [
-          "run",
-          `${process.env.GITHUB_ACTION_PATH}/src/mcp/github-file-ops-server.ts`,
-        ],
-        env: {
-          GITHUB_TOKEN: githubToken,
-          REPO_OWNER: owner,
-          REPO_NAME: repo,
-          BRANCH_NAME: branch,
-          BASE_BRANCH: baseBranch,
-          REPO_DIR: process.env.GITHUB_WORKSPACE || process.cwd(),
-          GITHUB_EVENT_NAME: process.env.GITHUB_EVENT_NAME || "",
-          IS_PR: process.env.IS_PR || "false",
-          GITHUB_API_URL: GITHUB_API_URL,
-        },
-      };
-    }
-
-    // Include inline comment server for PRs when requested via allowed tools
-    if (
-      isEntityContext(context) &&
-      context.isPR &&
-      (hasGitHubMcpTools || hasInlineCommentTools)
-    ) {
-      baseMcpConfig.mcpServers.github_inline_comment = {
-        command: "bun",
-        args: [
-          "run",
-          `${process.env.GITHUB_ACTION_PATH}/src/mcp/github-inline-comment-server.ts`,
-        ],
-        env: {
-          GITHUB_TOKEN: githubToken,
-          REPO_OWNER: owner,
-          REPO_NAME: repo,
-          PR_NUMBER: context.entityNumber?.toString() || "",
-          GITHUB_API_URL: GITHUB_API_URL,
-        },
-      };
-    }
-
-    // CI server is included when we have a workflow token and context is a PR
-    const hasWorkflowToken = !!process.env.DEFAULT_WORKFLOW_TOKEN;
-
-    if (isEntityContext(context) && context.isPR && hasWorkflowToken) {
-      // Verify the token actually has actions:read permission
-      const actuallyHasPermission = await checkActionsReadPermission(
-        process.env.DEFAULT_WORKFLOW_TOKEN || "",
-        owner,
-        repo,
-      );
-
-      if (!actuallyHasPermission) {
-        core.warning(
-          "The github_ci MCP server requires 'actions: read' permission. " +
-            "Please ensure your GitHub token has this permission. " +
-            "See: https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token",
-        );
-      }
-      baseMcpConfig.mcpServers.github_ci = {
-        command: "bun",
-        args: [
-          "run",
-          `${process.env.GITHUB_ACTION_PATH}/src/mcp/github-actions-server.ts`,
-        ],
-        env: {
-          // Use workflow github token, not app token
-          GITHUB_TOKEN: process.env.DEFAULT_WORKFLOW_TOKEN,
-          REPO_OWNER: owner,
-          REPO_NAME: repo,
-          PR_NUMBER: context.entityNumber?.toString() || "",
-          RUNNER_TEMP: process.env.RUNNER_TEMP || "/tmp",
-        },
-      };
-    }
-
-    if (hasGitHubMcpTools) {
-      baseMcpConfig.mcpServers.github = {
-        command: "docker",
-        args: [
-          "run",
-          "-i",
-          "--rm",
-          "-e",
-          "GITHUB_PERSONAL_ACCESS_TOKEN",
-          "-e",
-          "GITHUB_HOST",
-          "ghcr.io/github/github-mcp-server:sha-efef8ae", // https://github.com/github/github-mcp-server/releases/tag/v0.9.0
-        ],
-        env: {
-          GITHUB_PERSONAL_ACCESS_TOKEN: githubToken,
-          GITHUB_HOST: GITHUB_SERVER_URL,
-        },
-      };
-    }
-
-    // Return only our GitHub servers config
-    // User's config will be passed as separate --mcp-config flags
-    return JSON.stringify(baseMcpConfig, null, 2);
-  } catch (error) {
-    core.setFailed(`Install MCP server failed with error: ${error}`);
-    process.exit(1);
-  }
-}

package/bin/_internal/integrations/github/claude-code-action/src/modes/agent/index.ts

@@ -1,152 +0,0 @@
-import * as core from "@actions/core";
-import { mkdir, writeFile } from "fs/promises";
-import type { Mode, ModeOptions, ModeResult } from "../types";
-import type { PreparedContext } from "../../create-prompt/types";
-import { prepareMcpConfig } from "../../mcp/install-mcp-server";
-import { parseAllowedTools } from "./parse-tools";
-import { configureGitAuth } from "../../github/operations/git-config";
-
-/**
- * Agent mode implementation.
- *
- * This mode runs whenever an explicit prompt is provided in the workflow configuration.
- * It bypasses the standard @claude mention checking and comment tracking used by tag mode,
- * providing direct access to Claude Code for automation workflows.
- */
-export const agentMode: Mode = {
-  name: "agent",
-  description: "Direct automation mode for explicit prompts",
-
-  shouldTrigger(context) {
-    // Only trigger when an explicit prompt is provided
-    return !!context.inputs?.prompt;
-  },
-
-  prepareContext(context) {
-    // Agent mode doesn't use comment tracking or branch management
-    return {
-      mode: "agent",
-      githubContext: context,
-    };
-  },
-
-  getAllowedTools() {
-    return [];
-  },
-
-  getDisallowedTools() {
-    return [];
-  },
-
-  shouldCreateTrackingComment() {
-    return false;
-  },
-
-  async prepare({
-    context,
-    githubToken,
-    octokit,
-  }: ModeOptions): Promise<ModeResult> {
-    // Configure git authentication for agent mode (same as tag mode)
-    if (!context.inputs.useCommitSigning) {
-      try {
-        // Get the authenticated user (will be claude[bot] when using Claude App token)
-        const { data: authenticatedUser } =
-          await octokit.rest.users.getAuthenticated();
-        const user = {
-          login: authenticatedUser.login,
-          id: authenticatedUser.id,
-        };
-
-        // Use the shared git configuration function
-        await configureGitAuth(githubToken, context, user);
-      } catch (error) {
-        console.error("Failed to configure git authentication:", error);
-        // Continue anyway - git operations may still work with default config
-      }
-    }
-
-    // Create prompt directory
-    await mkdir(`${process.env.RUNNER_TEMP || "/tmp"}/claude-prompts`, {
-      recursive: true,
-    });
-
-    // Write the prompt file - use the user's prompt directly
-    const promptContent =
-      context.inputs.prompt ||
-      `Repository: ${context.repository.owner}/${context.repository.repo}`;
-
-    await writeFile(
-      `${process.env.RUNNER_TEMP || "/tmp"}/claude-prompts/claude-prompt.txt`,
-      promptContent,
-    );
-
-    // Parse allowed tools from user's claude_args
-    const userClaudeArgs = process.env.CLAUDE_ARGS || "";
-    const allowedTools = parseAllowedTools(userClaudeArgs);
-
-    // Check for branch info from environment variables (useful for auto-fix workflows)
-    const claudeBranch = process.env.CLAUDE_BRANCH || undefined;
-    const baseBranch =
-      process.env.BASE_BRANCH || context.inputs.baseBranch || "main";
-
-    // Detect current branch from GitHub environment
-    const currentBranch =
-      claudeBranch ||
-      process.env.GITHUB_HEAD_REF ||
-      process.env.GITHUB_REF_NAME ||
-      "main";
-
-    // Get our GitHub MCP servers config
-    const ourMcpConfig = await prepareMcpConfig({
-      githubToken,
-      owner: context.repository.owner,
-      repo: context.repository.repo,
-      branch: currentBranch,
-      baseBranch: baseBranch,
-      claudeCommentId: undefined, // No tracking comment in agent mode
-      allowedTools,
-      context,
-    });
-
-    // Build final claude_args with multiple --mcp-config flags
-    let claudeArgs = "";
-
-    // Add our GitHub servers config if we have any
-    const ourConfig = JSON.parse(ourMcpConfig);
-    if (ourConfig.mcpServers && Object.keys(ourConfig.mcpServers).length > 0) {
-      const escapedOurConfig = ourMcpConfig.replace(/'/g, "'\\''");
-      claudeArgs = `--mcp-config '${escapedOurConfig}'`;
-    }
-
-    // Append user's claude_args (which may have more --mcp-config flags)
-    claudeArgs = `${claudeArgs} ${userClaudeArgs}`.trim();
-
-    core.setOutput("claude_args", claudeArgs);
-
-    return {
-      commentId: undefined,
-      branchInfo: {
-        baseBranch: baseBranch,
-        currentBranch: baseBranch, // Use base branch as current when creating new branch
-        claudeBranch: claudeBranch,
-      },
-      mcpConfig: ourMcpConfig,
-    };
-  },
-
-  generatePrompt(context: PreparedContext): string {
-    // Agent mode uses prompt field
-    if (context.prompt) {
-      return context.prompt;
-    }
-
-    // Minimal fallback - repository is a string in PreparedContext
-    return `Repository: ${context.repository}`;
-  },
-
-  getSystemPrompt() {
-    // Agent mode doesn't need additional system prompts
-    return undefined;
-  },
-};

package/bin/_internal/integrations/github/claude-code-action/src/modes/agent/parse-tools.ts

@@ -1,22 +0,0 @@
-export function parseAllowedTools(claudeArgs: string): string[] {
-  // Match --allowedTools followed by the value
-  // Handle both quoted and unquoted values
-  const patterns = [
-    /--allowedTools\s+"([^"]+)"/, // Double quoted
-    /--allowedTools\s+'([^']+)'/, // Single quoted
-    /--allowedTools\s+([^\s]+)/, // Unquoted
-  ];
-
-  for (const pattern of patterns) {
-    const match = claudeArgs.match(pattern);
-    if (match && match[1]) {
-      // Don't return if the value starts with -- (another flag)
-      if (match[1].startsWith("--")) {
-        return [];
-      }
-      return match[1].split(",").map((t) => t.trim());
-    }
-  }
-
-  return [];
-}

package/bin/_internal/integrations/github/claude-code-action/src/modes/detector.ts

@@ -1,66 +0,0 @@
-import type { GitHubContext } from "../github/context";
-import {
-  isEntityContext,
-  isIssueCommentEvent,
-  isPullRequestReviewCommentEvent,
-} from "../github/context";
-import { checkContainsTrigger } from "../github/validation/trigger";
-
-export type AutoDetectedMode = "tag" | "agent";
-
-export function detectMode(context: GitHubContext): AutoDetectedMode {
-  // If prompt is provided, use agent mode for direct execution
-  if (context.inputs?.prompt) {
-    return "agent";
-  }
-
-  // Check for @claude mentions (tag mode)
-  if (isEntityContext(context)) {
-    if (
-      isIssueCommentEvent(context) ||
-      isPullRequestReviewCommentEvent(context)
-    ) {
-      if (checkContainsTrigger(context)) {
-        return "tag";
-      }
-    }
-
-    if (context.eventName === "issues") {
-      if (checkContainsTrigger(context)) {
-        return "tag";
-      }
-    }
-  }
-
-  // Default to agent mode (which won't trigger without a prompt)
-  return "agent";
-}
-
-export function getModeDescription(mode: AutoDetectedMode): string {
-  switch (mode) {
-    case "tag":
-      return "Interactive mode triggered by @claude mentions";
-    case "agent":
-      return "Direct automation mode for explicit prompts";
-    default:
-      return "Unknown mode";
-  }
-}
-
-export function shouldUseTrackingComment(mode: AutoDetectedMode): boolean {
-  return mode === "tag";
-}
-
-export function getDefaultPromptForMode(
-  mode: AutoDetectedMode,
-  context: GitHubContext,
-): string | undefined {
-  switch (mode) {
-    case "tag":
-      return undefined;
-    case "agent":
-      return context.inputs?.prompt;
-    default:
-      return undefined;
-  }
-}

package/bin/_internal/integrations/github/claude-code-action/src/modes/registry.ts

@@ -1,54 +0,0 @@
-/**
- * Mode Registry for claude-code-action v1.0
- *
- * This module provides access to all available execution modes and handles
- * automatic mode detection based on GitHub event types.
- */
-
-import type { Mode, ModeName } from "./types";
-import { tagMode } from "./tag";
-import { agentMode } from "./agent";
-import type { GitHubContext } from "../github/context";
-import { detectMode, type AutoDetectedMode } from "./detector";
-
-export const VALID_MODES = ["tag", "agent"] as const;
-
-/**
- * All available modes in v1.0
- */
-const modes = {
-  tag: tagMode,
-  agent: agentMode,
-} as const satisfies Record<AutoDetectedMode, Mode>;
-
-/**
- * Automatically detects and retrieves the appropriate mode based on the GitHub context.
- * In v1.0, modes are auto-selected based on event type.
- * @param context The GitHub context
- * @returns The appropriate mode for the context
- */
-export function getMode(context: GitHubContext): Mode {
-  const modeName = detectMode(context);
-  console.log(
-    `Auto-detected mode: ${modeName} for event: ${context.eventName}`,
-  );
-
-  const mode = modes[modeName];
-  if (!mode) {
-    throw new Error(
-      `Mode '${modeName}' not found. This should not happen. Please report this issue.`,
-    );
-  }
-
-  return mode;
-}
-
-/**
- * Type guard to check if a string is a valid mode name.
- * @param name The string to check
- * @returns True if the name is a valid mode name
- */
-export function isValidMode(name: string): name is ModeName {
-  const validModes = ["tag", "agent"];
-  return validModes.includes(name);
-}