@vicoa/cli 0.1.3 → 0.1.4-darwin-arm64

package/bin/_internal/integrations/github/claude-code-action/src/github/operations/comments/update-claude-comment.ts

@@ -0,0 +1,70 @@
+import { Octokit } from "@octokit/rest";
+
+export type UpdateClaudeCommentParams = {
+  owner: string;
+  repo: string;
+  commentId: number;
+  body: string;
+  isPullRequestReviewComment: boolean;
+};
+
+export type UpdateClaudeCommentResult = {
+  id: number;
+  html_url: string;
+  updated_at: string;
+};
+
+/**
+ * Updates a Claude comment on GitHub (either an issue/PR comment or a PR review comment)
+ *
+ * @param octokit - Authenticated Octokit instance
+ * @param params - Parameters for updating the comment
+ * @returns The updated comment details
+ * @throws Error if the update fails
+ */
+export async function updateClaudeComment(
+  octokit: Octokit,
+  params: UpdateClaudeCommentParams,
+): Promise<UpdateClaudeCommentResult> {
+  const { owner, repo, commentId, body, isPullRequestReviewComment } = params;
+
+  let response;
+
+  try {
+    if (isPullRequestReviewComment) {
+      // Try PR review comment API first
+      response = await octokit.rest.pulls.updateReviewComment({
+        owner,
+        repo,
+        comment_id: commentId,
+        body,
+      });
+    } else {
+      // Use issue comment API (works for both issues and PR general comments)
+      response = await octokit.rest.issues.updateComment({
+        owner,
+        repo,
+        comment_id: commentId,
+        body,
+      });
+    }
+  } catch (error: any) {
+    // If PR review comment update fails with 404, fall back to issue comment API
+    if (isPullRequestReviewComment && error.status === 404) {
+      response = await octokit.rest.issues.updateComment({
+        owner,
+        repo,
+        comment_id: commentId,
+        body,
+      });
+    } else {
+      throw error;
+    }
+  }
+
+  return {
+    id: response.data.id,
+    html_url: response.data.html_url,
+    updated_at: response.data.updated_at,
+  };
+}

package/bin/_internal/integrations/github/claude-code-action/src/github/operations/comments/update-with-branch.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env bun
+
+/**
+ * Update the initial tracking comment with branch link
+ * This happens after the branch is created for issues
+ */
+
+import {
+  createJobRunLink,
+  createBranchLink,
+  createCommentBody,
+} from "./common";
+import { type Octokits } from "../../api/client";
+import {
+  isPullRequestReviewCommentEvent,
+  type ParsedGitHubContext,
+} from "../../context";
+import { updateClaudeComment } from "./update-claude-comment";
+
+export async function updateTrackingComment(
+  octokit: Octokits,
+  context: ParsedGitHubContext,
+  commentId: number,
+  branch?: string,
+) {
+  const { owner, repo } = context.repository;
+
+  const jobRunLink = createJobRunLink(owner, repo, context.runId);
+
+  // Add branch link for issues (not PRs)
+  let branchLink = "";
+  if (branch && !context.isPR) {
+    branchLink = createBranchLink(owner, repo, branch);
+  }
+
+  const updatedBody = createCommentBody(jobRunLink, branchLink);
+
+  // Update the existing comment with the branch link
+  try {
+    const isPRReviewComment = isPullRequestReviewCommentEvent(context);
+
+    await updateClaudeComment(octokit.rest, {
+      owner,
+      repo,
+      commentId,
+      body: updatedBody,
+      isPullRequestReviewComment: isPRReviewComment,
+    });
+
+    console.log(
+      `✅ Updated ${isPRReviewComment ? "PR review" : "issue"} comment ${commentId} with branch link`,
+    );
+  } catch (error) {
+    console.error("Error updating comment with branch link:", error);
+    throw error;
+  }
+}

package/bin/_internal/integrations/github/claude-code-action/src/github/operations/git-config.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env bun
+
+/**
+ * Configure git authentication for non-signing mode
+ * Sets up git user and authentication to work with GitHub App tokens
+ */
+
+import { $ } from "bun";
+import type { GitHubContext } from "../context";
+import { GITHUB_SERVER_URL } from "../api/config";
+
+type GitUser = {
+  login: string;
+  id: number;
+};
+
+export async function configureGitAuth(
+  githubToken: string,
+  context: GitHubContext,
+  user: GitUser | null,
+) {
+  console.log("Configuring git authentication for non-signing mode");
+
+  // Determine the noreply email domain based on GITHUB_SERVER_URL
+  const serverUrl = new URL(GITHUB_SERVER_URL);
+  const noreplyDomain =
+    serverUrl.hostname === "github.com"
+      ? "users.noreply.github.com"
+      : `users.noreply.${serverUrl.hostname}`;
+
+  // Configure git user based on the comment creator
+  console.log("Configuring git user...");
+  if (user) {
+    const botName = user.login;
+    const botId = user.id;
+    console.log(`Setting git user as ${botName}...`);
+    await $`git config user.name "${botName}"`;
+    await $`git config user.email "${botId}+${botName}@${noreplyDomain}"`;
+    console.log(`✓ Set git user as ${botName}`);
+  } else {
+    console.log("No user data in comment, using default bot user");
+    await $`git config user.name "github-actions[bot]"`;
+    await $`git config user.email "41898282+github-actions[bot]@${noreplyDomain}"`;
+  }
+
+  // Remove the authorization header that actions/checkout sets
+  console.log("Removing existing git authentication headers...");
+  try {
+    await $`git config --unset-all http.${GITHUB_SERVER_URL}/.extraheader`;
+    console.log("✓ Removed existing authentication headers");
+  } catch (e) {
+    console.log("No existing authentication headers to remove");
+  }
+
+  // Update the remote URL to include the token for authentication
+  console.log("Updating remote URL with authentication...");
+  const remoteUrl = `https://x-access-token:${githubToken}@${serverUrl.host}/${context.repository.owner}/${context.repository.repo}.git`;
+  await $`git remote set-url origin ${remoteUrl}`;
+  console.log("✓ Updated remote URL with authentication token");
+
+  console.log("Git authentication configured successfully");
+}

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

@@ -0,0 +1,108 @@
+#!/usr/bin/env bun
+
+import * as core from "@actions/core";
+import { retryWithBackoff } from "../utils/retry";
+
+async function getOidcToken(): Promise<string> {
+  try {
+    const oidcToken = await core.getIDToken("claude-code-github-action");
+
+    return oidcToken;
+  } catch (error) {
+    console.error("Failed to get OIDC token:", error);
+    throw new Error(
+      "Could not fetch an OIDC token. Did you remember to add `id-token: write` to your workflow permissions?",
+    );
+  }
+}
+
+async function exchangeForAppToken(oidcToken: string): Promise<string> {
+  const response = await fetch(
+    "https://api.anthropic.com/api/github/github-app-token-exchange",
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${oidcToken}`,
+      },
+    },
+  );
+
+  if (!response.ok) {
+    const responseJson = (await response.json()) as {
+      error?: {
+        message?: string;
+        details?: {
+          error_code?: string;
+        };
+      };
+      type?: string;
+      message?: string;
+    };
+
+    // Check for specific workflow validation error codes that should skip the action
+    const errorCode = responseJson.error?.details?.error_code;
+
+    if (errorCode === "workflow_not_found_on_default_branch") {
+      const message =
+        responseJson.message ??
+        responseJson.error?.message ??
+        "Workflow validation failed";
+      core.warning(`Skipping action due to workflow validation: ${message}`);
+      console.log(
+        "Action skipped due to workflow validation error. This is expected when adding Claude Code workflows to new repositories or on PRs with workflow changes. If you're seeing this, your workflow will begin working once you merge your PR.",
+      );
+      core.setOutput("skipped_due_to_workflow_validation_mismatch", "true");
+      process.exit(0);
+    }
+
+    console.error(
+      `App token exchange failed: ${response.status} ${response.statusText} - ${responseJson?.error?.message ?? "Unknown error"}`,
+    );
+    throw new Error(`${responseJson?.error?.message ?? "Unknown error"}`);
+  }
+
+  const appTokenData = (await response.json()) as {
+    token?: string;
+    app_token?: string;
+  };
+  const appToken = appTokenData.token || appTokenData.app_token;
+
+  if (!appToken) {
+    throw new Error("App token not found in response");
+  }
+
+  return appToken;
+}
+
+export async function setupGitHubToken(): Promise<string> {
+  try {
+    // Check if GitHub token was provided as override
+    const providedToken = process.env.OVERRIDE_GITHUB_TOKEN;
+
+    if (providedToken) {
+      console.log("Using provided GITHUB_TOKEN for authentication");
+      core.setOutput("GITHUB_TOKEN", providedToken);
+      return providedToken;
+    }
+
+    console.log("Requesting OIDC token...");
+    const oidcToken = await retryWithBackoff(() => getOidcToken());
+    console.log("OIDC token successfully obtained");
+
+    console.log("Exchanging OIDC token for app token...");
+    const appToken = await retryWithBackoff(() =>
+      exchangeForAppToken(oidcToken),
+    );
+    console.log("App token successfully obtained");
+
+    console.log("Using GITHUB_TOKEN from OIDC");
+    core.setOutput("GITHUB_TOKEN", appToken);
+    return appToken;
+  } catch (error) {
+    // Only set failed if we get here - workflow validation errors will exit(0) before this
+    core.setFailed(
+      `Failed to setup GitHub token: ${error}\n\nIf you instead wish to use this action with a custom GitHub token or custom GitHub app, provide a \`github_token\` in the \`uses\` section of the app in your workflow yml file.`,
+    );
+    process.exit(1);
+  }
+}

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

@@ -0,0 +1,98 @@
+// Types for GitHub GraphQL query responses
+export type GitHubAuthor = {
+  login: string;
+  name?: string;
+};
+
+export type GitHubComment = {
+  id: string;
+  databaseId: string;
+  body: string;
+  author: GitHubAuthor;
+  createdAt: string;
+  isMinimized?: boolean;
+};
+
+export type GitHubReviewComment = GitHubComment & {
+  path: string;
+  line: number | null;
+};
+
+export type GitHubCommit = {
+  oid: string;
+  message: string;
+  author: {
+    name: string;
+    email: string;
+  };
+};
+
+export type GitHubFile = {
+  path: string;
+  additions: number;
+  deletions: number;
+  changeType: string;
+};
+
+export type GitHubReview = {
+  id: string;
+  databaseId: string;
+  author: GitHubAuthor;
+  body: string;
+  state: string;
+  submittedAt: string;
+  comments: {
+    nodes: GitHubReviewComment[];
+  };
+};
+
+export type GitHubPullRequest = {
+  title: string;
+  body: string;
+  author: GitHubAuthor;
+  baseRefName: string;
+  headRefName: string;
+  headRefOid: string;
+  createdAt: string;
+  additions: number;
+  deletions: number;
+  state: string;
+  commits: {
+    totalCount: number;
+    nodes: Array<{
+      commit: GitHubCommit;
+    }>;
+  };
+  files: {
+    nodes: GitHubFile[];
+  };
+  comments: {
+    nodes: GitHubComment[];
+  };
+  reviews: {
+    nodes: GitHubReview[];
+  };
+};
+
+export type GitHubIssue = {
+  title: string;
+  body: string;
+  author: GitHubAuthor;
+  createdAt: string;
+  state: string;
+  comments: {
+    nodes: GitHubComment[];
+  };
+};
+
+export type PullRequestQueryResponse = {
+  repository: {
+    pullRequest: GitHubPullRequest;
+  };
+};
+
+export type IssueQueryResponse = {
+  repository: {
+    issue: GitHubIssue;
+  };
+};

package/bin/_internal/integrations/github/claude-code-action/src/github/utils/image-downloader.ts

@@ -0,0 +1,246 @@
+import fs from "fs/promises";
+import path from "path";
+import type { Octokits } from "../api/client";
+import { GITHUB_SERVER_URL } from "../api/config";
+
+const escapedUrl = GITHUB_SERVER_URL.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const IMAGE_REGEX = new RegExp(
+  `!\\[[^\\]]*\\]\\((${escapedUrl}\\/user-attachments\\/assets\\/[^)]+)\\)`,
+  "g",
+);
+
+const HTML_IMG_REGEX = new RegExp(
+  `<img[^>]+src=["']([^"']*${escapedUrl}\\/user-attachments\\/assets\\/[^"']+)["'][^>]*>`,
+  "gi",
+);
+
+type IssueComment = {
+  type: "issue_comment";
+  id: string;
+  body: string;
+};
+
+type ReviewComment = {
+  type: "review_comment";
+  id: string;
+  body: string;
+};
+
+type ReviewBody = {
+  type: "review_body";
+  id: string;
+  pullNumber: string;
+  body: string;
+};
+
+type IssueBody = {
+  type: "issue_body";
+  issueNumber: string;
+  body: string;
+};
+
+type PullRequestBody = {
+  type: "pr_body";
+  pullNumber: string;
+  body: string;
+};
+
+export type CommentWithImages =
+  | IssueComment
+  | ReviewComment
+  | ReviewBody
+  | IssueBody
+  | PullRequestBody;
+
+export async function downloadCommentImages(
+  octokits: Octokits,
+  owner: string,
+  repo: string,
+  comments: CommentWithImages[],
+): Promise<Map<string, string>> {
+  const urlToPathMap = new Map<string, string>();
+  const downloadsDir = "/tmp/github-images";
+
+  await fs.mkdir(downloadsDir, { recursive: true });
+
+  const commentsWithImages: Array<{
+    comment: CommentWithImages;
+    urls: string[];
+  }> = [];
+
+  for (const comment of comments) {
+    // Extract URLs from Markdown format
+    const markdownMatches = [...comment.body.matchAll(IMAGE_REGEX)];
+    const markdownUrls = markdownMatches.map((match) => match[1] as string);
+
+    // Extract URLs from HTML format
+    const htmlMatches = [...comment.body.matchAll(HTML_IMG_REGEX)];
+    const htmlUrls = htmlMatches.map((match) => match[1] as string);
+
+    // Combine and deduplicate URLs
+    const urls = [...new Set([...markdownUrls, ...htmlUrls])];
+
+    if (urls.length > 0) {
+      commentsWithImages.push({ comment, urls });
+      const id =
+        comment.type === "issue_body"
+          ? comment.issueNumber
+          : comment.type === "pr_body"
+            ? comment.pullNumber
+            : comment.id;
+      console.log(`Found ${urls.length} image(s) in ${comment.type} ${id}`);
+    }
+  }
+
+  // Process each comment with images
+  for (const { comment, urls } of commentsWithImages) {
+    try {
+      let bodyHtml: string | undefined;
+
+      // Get the HTML version based on comment type
+      switch (comment.type) {
+        case "issue_comment": {
+          const response = await octokits.rest.issues.getComment({
+            owner,
+            repo,
+            comment_id: parseInt(comment.id),
+            mediaType: {
+              format: "full+json",
+            },
+          });
+          bodyHtml = response.data.body_html;
+          break;
+        }
+        case "review_comment": {
+          const response = await octokits.rest.pulls.getReviewComment({
+            owner,
+            repo,
+            comment_id: parseInt(comment.id),
+            mediaType: {
+              format: "full+json",
+            },
+          });
+          bodyHtml = response.data.body_html;
+          break;
+        }
+        case "review_body": {
+          const response = await octokits.rest.pulls.getReview({
+            owner,
+            repo,
+            pull_number: parseInt(comment.pullNumber),
+            review_id: parseInt(comment.id),
+            mediaType: {
+              format: "full+json",
+            },
+          });
+          bodyHtml = response.data.body_html;
+          break;
+        }
+        case "issue_body": {
+          const response = await octokits.rest.issues.get({
+            owner,
+            repo,
+            issue_number: parseInt(comment.issueNumber),
+            mediaType: {
+              format: "full+json",
+            },
+          });
+          bodyHtml = response.data.body_html;
+          break;
+        }
+        case "pr_body": {
+          const response = await octokits.rest.pulls.get({
+            owner,
+            repo,
+            pull_number: parseInt(comment.pullNumber),
+            mediaType: {
+              format: "full+json",
+            },
+          });
+          // Type here seems to be wrong
+          bodyHtml = (response.data as any).body_html;
+          break;
+        }
+      }
+      if (!bodyHtml) {
+        const id =
+          comment.type === "issue_body"
+            ? comment.issueNumber
+            : comment.type === "pr_body"
+              ? comment.pullNumber
+              : comment.id;
+        console.warn(`No HTML body found for ${comment.type} ${id}`);
+        continue;
+      }
+
+      // Extract signed URLs from HTML
+      const signedUrlRegex =
+        /https:\/\/private-user-images\.githubusercontent\.com\/[^"]+\?jwt=[^"]+/g;
+      const signedUrls = bodyHtml.match(signedUrlRegex) || [];
+
+      // Download each image
+      for (let i = 0; i < Math.min(signedUrls.length, urls.length); i++) {
+        const signedUrl = signedUrls[i];
+        const originalUrl = urls[i];
+
+        if (!signedUrl || !originalUrl) {
+          continue;
+        }
+
+        // Check if we've already downloaded this URL
+        if (urlToPathMap.has(originalUrl)) {
+          continue;
+        }
+
+        const fileExtension = getImageExtension(originalUrl);
+        const filename = `image-${Date.now()}-${i}${fileExtension}`;
+        const localPath = path.join(downloadsDir, filename);
+
+        try {
+          console.log(`Downloading ${originalUrl}...`);
+
+          const imageResponse = await fetch(signedUrl);
+          if (!imageResponse.ok) {
+            throw new Error(
+              `HTTP ${imageResponse.status}: ${imageResponse.statusText}`,
+            );
+          }
+
+          const arrayBuffer = await imageResponse.arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+
+          await fs.writeFile(localPath, buffer);
+          console.log(`✓ Saved: ${localPath}`);
+
+          urlToPathMap.set(originalUrl, localPath);
+        } catch (error) {
+          console.error(`✗ Failed to download ${originalUrl}:`, error);
+        }
+      }
+    } catch (error) {
+      const id =
+        comment.type === "issue_body"
+          ? comment.issueNumber
+          : comment.type === "pr_body"
+            ? comment.pullNumber
+            : comment.id;
+      console.error(
+        `Failed to process images for ${comment.type} ${id}:`,
+        error,
+      );
+    }
+  }
+
+  return urlToPathMap;
+}
+
+function getImageExtension(url: string): string {
+  const urlParts = url.split("/");
+  const filename = urlParts[urlParts.length - 1];
+  if (!filename) {
+    throw new Error("Invalid URL: No filename found");
+  }
+
+  const match = filename.match(/\.(png|jpg|jpeg|gif|webp|svg)$/i);
+  return match ? match[0] : ".png";
+}