add terrible debugging

This reverts commit 06542e382a.

.github/workflows/publish.yml

@@ -34,7 +34,7 @@ jobs:
           registry-url: "https://registry.npmjs.org"
 
       - name: Install dependencies
-        run: pnpm install --no-frozen-lockfile
+        run: pnpm install --frozen-lockfile
 
       - name: Get package version
         id: version

.husky/pre-commit

@@ -1,6 +1,10 @@
+# Ensure lockfile is up to date
+echo "🔒 Updating lockfile..."
+pnpm install --lockfile-only
+
 # Build the action before committing
 echo "🔨 Building action..."
 npm run build
 
-# Add the built files to the commit
-git add entry.cjs
+# Add the built files and lockfile to the commit
+git add entry.cjs pnpm-lock.yaml

agents/claude.ts

@@ -16,14 +16,11 @@ export class ClaudeAgent implements Agent {
     startTime: 0,
   };
 
-  // $: ExecaMethod;
-
   constructor(config: AgentConfig) {
     if (!config.apiKey) {
       throw new Error("Claude agent requires an API key");
     }
     this.apiKey = config.apiKey;
-    // Removed execa dependency - using spawn utility instead
   }
 
   /**
@@ -43,7 +40,6 @@ export class ClaudeAgent implements Agent {
    * Install Claude Code CLI
    */
   async install(): Promise<void> {
-    // Check if Claude Code is already installed
     if (await this.isClaudeInstalled()) {
       core.info("Claude Code is already installed, skipping installation");
       return;
@@ -51,21 +47,22 @@ export class ClaudeAgent implements Agent {
 
     core.info("Installing Claude Code...");
     try {
-      // Use shell execution to properly handle the pipe
       const result = await spawn({
         cmd: "bash",
-        args: ["-c", "curl -fsSL https://claude.ai/install.sh | bash -s 1.0.93"],
+        args: [
+          "-c",
+          "curl -fsSL https://claude.ai/install.sh | bash -s 1.0.93",
+        ],
         env: { ANTHROPIC_API_KEY: this.apiKey },
         timeout: 120000, // 2 minute timeout
-        onStdout: () => {
-          // no logs
-          // process.stdout.write(chunk)
-        },
+        onStdout: () => {},
         onStderr: (chunk) => process.stderr.write(chunk),
       });
 
       if (result.exitCode !== 0) {
-        throw new Error(`Installation failed with exit code ${result.exitCode}: ${result.stderr}`);
+        throw new Error(
+          `Installation failed with exit code ${result.exitCode}: ${result.stderr}`
+        );
       }
 
       core.info("Claude Code installed successfully");
@@ -79,47 +76,36 @@ export class ClaudeAgent implements Agent {
    */
   async execute(prompt: string): Promise<AgentResult> {
     core.info("Running Claude Code...");
-    // printTable([[prompt]]);
 
     try {
-      // Execute Claude Code with the prompt directly using proper headless mode
-      // core.info(`Executing Claude Code with prompt: ${prompt.substring(0, 100)}...`);
-
       const claudePath = `${process.env.HOME}/.local/bin/claude`;
-      // console.log("Using Claude Code from:", claudePath);
       console.log(boxString(prompt, { title: "Prompt" }));
       const args = [
         "--print",
         "--output-format",
         "stream-json",
         "--verbose",
+        "--debug",
         "--permission-mode",
         "bypassPermissions",
       ];
 
-      // Add MCP configuration if GitHub credentials are available
-      if (
-        process.env.GITHUB_INSTALLATION_TOKEN &&
-        process.env.REPO_OWNER &&
-        process.env.REPO_NAME
-      ) {
-        const mcpConfig = createMcpConfig(
-          process.env.GITHUB_INSTALLATION_TOKEN,
-          process.env.REPO_OWNER,
-          process.env.REPO_NAME
+      if (!process.env.GITHUB_INSTALLATION_TOKEN) {
+        throw new Error(
+          "GITHUB_INSTALLATION_TOKEN is required for GitHub integration"
         );
-        console.log("📋 MCP Config:", mcpConfig);
-        args.push("--mcp-config", mcpConfig);
       }
 
+      const mcpConfig = createMcpConfig(process.env.GITHUB_INSTALLATION_TOKEN);
+      console.log("📋 MCP Config:", mcpConfig);
+      args.push("--mcp-config", mcpConfig);
+
       const env = {
         ANTHROPIC_API_KEY: this.apiKey,
       };
 
-      // Start a collapsible log group for streaming output
       core.startGroup("🔄 Run details");
 
-      // Initialize run statistics
       this.runStats = {
         toolsUsed: 0,
         turns: 0,
@@ -129,7 +115,6 @@ export class ClaudeAgent implements Agent {
       const finalResult = "";
       const totalCost = 0;
 
-      // run Claude Code with the prompt
       const result = await spawn({
         cmd: claudePath,
         args,
@@ -137,37 +122,21 @@ export class ClaudeAgent implements Agent {
         input: prompt,
         timeout: 10 * 60 * 1000, // 10 minutes
         onStdout: (_chunk) => {
-          // console.log(chunk);
           processJSONChunk(_chunk, this);
         },
         onStderr: (_chunk) => {
           if (_chunk.trim()) {
-            // core.warning(`[warn] ${chunk}`);
             processJSONChunk(_chunk, this);
           }
         },
       });
 
-      // throw on non-zero exit code
       if (result.exitCode !== 0) {
         throw new Error(
           `Command failed with exit code ${result.exitCode}\n\nStdout: ${result.stdout}\n\nStderr: ${result.stderr}`
         );
       }
 
-      // Process the complete buffered stdout to extract final results
-      // if (result.stdout.trim()) {
-      //   const lines = result.stdout.trim().split("\n");
-      //   for (const line of lines) {
-      //     if (line.trim()) {
-      //       const chunkResult = processJsonChunk(line);
-      //       if (chunkResult.finalResult) finalResult = chunkResult.finalResult;
-      //       if (chunkResult.totalCost) totalCost = chunkResult.totalCost;
-      //     }
-      //   }
-      // }
-
-      // Log run summary
       const duration = Date.now() - this.runStats.startTime;
       core.info(
         `📊 Run Summary: ${this.runStats.toolsUsed} tools used, ${this.runStats.turns} turns, ${duration}ms duration`
@@ -187,13 +156,11 @@ export class ClaudeAgent implements Agent {
         },
       };
     } catch (error: any) {
-      // Ensure group is closed even if error occurs before group is started
       try {
         core.endGroup();
-      } catch {
-        // Group might not have been started, ignore
-      }
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      } catch {}
+      const errorMessage =
+        error instanceof Error ? error.message : "Unknown error";
       return {
         success: false,
         error: `Failed to execute Claude Code: ${errorMessage}`,
@@ -202,34 +169,11 @@ export class ClaudeAgent implements Agent {
   }
 }
 
-/**
- * Process a JSON chunk line and extract result data
- */
-// function processJsonChunk(line: string): { finalResult?: string; totalCost?: number } {
-//   try {
-//     const chunk = JSON.parse(line.trim());
-//     processJSONChunk(chunk);
-
-//     // Collect final result and cost data
-//     if (chunk.type === "result" && chunk.result) {
-//       return {
-//         finalResult: chunk.result,
-//         totalCost: chunk.total_cost_usd || 0,
-//       };
-//     }
-//     return {};
-//   } catch {
-//     core.debug(`Failed to parse JSON line: ${line}`);
-//     return {};
-//   }
-// }
-
 /**
  * Pretty print a JSON chunk based on its type
  */
 function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
   try {
-    // Parse the JSON string first
     console.log(chunk);
     const parsedChunk = JSON.parse(chunk.trim());
 
@@ -237,14 +181,17 @@ function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
       case "system":
         if (parsedChunk.subtype === "init") {
           core.info(`🚀 Starting Claude Code session...`);
-          // core.info(`📁 Working directory: ${parsedChunk.cwd}`);
-          // core.info(`🔑 Permission mode: ${parsedChunk.permissionMode}`);
           core.info(
             tableString([
               ["model", parsedChunk.model],
               ["cwd", parsedChunk.cwd],
               ["permission_mode", parsedChunk.permissionMode],
-              ["tools", parsedChunk.tools?.length ? `${parsedChunk.tools.length} tools` : "none"],
+              [
+                "tools",
+                parsedChunk.tools?.length
+                  ? `${parsedChunk.tools.length} tools`
+                  : "none",
+              ],
               [
                 "mcp_servers",
                 parsedChunk.mcp_servers?.length
@@ -264,39 +211,33 @@ function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
 
       case "assistant":
         if (parsedChunk.message?.content) {
-          // Track turns
           if (agent) {
             agent.runStats.turns++;
           }
 
           for (const content of parsedChunk.message.content) {
             if (content.type === "text") {
-              // Skip empty text content
               if (content.text.trim()) {
-                core.info(boxString(content.text.trim(), { title: "Claude Code" }));
+                core.info(
+                  boxString(content.text.trim(), { title: "Claude Code" })
+                );
               }
             } else if (content.type === "tool_use") {
-              // Track tools used
               if (agent) {
                 agent.runStats.toolsUsed++;
               }
 
-              // Enhanced tool usage logging
               const toolName = content.name;
-              // const toolId = content.id;
 
               core.info(`→ ${toolName}`);
 
-              // Log tool-specific details based on tool type
               if (content.input) {
                 const input = content.input;
 
-                // Common tool input fields
                 if (input.description) {
                   core.info(`   └─ ${input.description}`);
                 }
 
-                // Tool-specific input fields
                 if (input.command) {
                   core.info(`   └─ command: ${input.command}`);
                 }
@@ -325,7 +266,6 @@ function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
                   core.info(`   └─ url: ${input.url}`);
                 }
 
-                // For multi-edit or complex operations
                 if (input.edits && Array.isArray(input.edits)) {
                   core.info(`   └─ edits: ${input.edits.length} changes`);
                   input.edits.forEach((edit: any, index: number) => {
@@ -335,19 +275,14 @@ function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
                   });
                 }
 
-                // For task operations
                 if (input.task) {
                   core.info(`   └─ task: ${input.task}`);
                 }
 
-                // For bash operations with specific details
                 if (input.bash_command) {
                   core.info(`   └─ bash_command: ${input.bash_command}`);
                 }
               }
-
-              // Log tool ID for debugging
-              // core.debug(`   🔗 Tool ID: ${toolId}`);
             }
           }
         }
@@ -360,9 +295,6 @@ function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
               if (content.is_error) {
                 core.warning(`❌ Tool error: ${content.content}`);
               } else {
-                // Enhanced tool result logging
-                const _resultContent = content.content.trim();
-                // do nothing for now. usually useless in headless more.
               }
             }
           }
@@ -371,19 +303,12 @@ function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
 
       case "result":
         if (parsedChunk.subtype === "success") {
-          // Claude already prints something almost identical to this, so skip for now
-          // if (parsedChunk.result) {
-          //   core.info(
-          //     boxString(parsedChunk.result.trim(), {
-          //       title: "🤖 Claude Code",
-          //       maxWidth: 70,
-          //     }),
-          //   );
-          // }
-
           core.info(
             tableString([
-              ["Cost", `$${parsedChunk.total_cost_usd?.toFixed(4) || "0.0000"}`],
+              [
+                "Cost",
+                `$${parsedChunk.total_cost_usd?.toFixed(4) || "0.0000"}`,
+              ],
               ["Input Tokens", parsedChunk.usage?.input_tokens || 0],
               ["Output Tokens", parsedChunk.usage?.output_tokens || 0],
               ["Duration", `${parsedChunk.duration_ms}ms`],
@@ -396,7 +321,6 @@ function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
         break;
 
       default:
-        // Log unknown chunk types for debugging
         core.debug(`📦 Unknown chunk type: ${parsedChunk.type}`);
         break;
     }

entry.ts

@@ -7,11 +7,12 @@
 
 import * as core from "@actions/core";
 import { type ExecutionInputs, type MainParams, main } from "./main.ts";
+import packageJson from "./package.json" with { type: "json" };
 import { setupGitHubInstallationToken } from "./utils/github.ts";
 
 async function run(): Promise<void> {
   try {
-    // Get inputs from GitHub Actions
+    console.log(`🐸 Running pullfrog/action@${packageJson.version}...`);
     const prompt = core.getInput("prompt", { required: true });
     const anthropic_api_key = core.getInput("anthropic_api_key");
 
@@ -19,13 +20,11 @@ async function run(): Promise<void> {
       throw new Error("prompt is required");
     }
 
-    // Create params object with new structure
     const inputs: ExecutionInputs = {
       prompt,
       anthropic_api_key,
     };
 
-    // Add optional properties only if they exist
     const githubToken = core.getInput("github_token") || process.env.GITHUB_TOKEN;
     if (githubToken) {
       inputs.github_token = githubToken;
@@ -47,8 +46,6 @@ async function run(): Promise<void> {
 
     const result = await main(params);
 
-    // TODO: Set outputs
-
     if (!result.success) {
       throw new Error(result.error || "Agent execution failed");
     }
@@ -58,7 +55,6 @@ async function run(): Promise<void> {
   }
 }
 
-// Run the action
 run().catch((error) => {
   console.error("Action failed:", error);
   process.exit(1);

main.ts

@@ -1,7 +1,6 @@
 import * as core from "@actions/core";
 import { ClaudeAgent } from "./agents/claude.ts";
 
-// Expected environment variables that should be passed as inputs
 export const EXPECTED_INPUTS: string[] = [
   "ANTHROPIC_API_KEY",
   "GITHUB_TOKEN",
@@ -29,24 +28,19 @@ export interface MainResult {
 
 export async function main(params: MainParams): Promise<MainResult> {
   try {
-    // Extract inputs from params
     const { inputs, env, cwd } = params;
 
-    // Set working directory if different from current
     if (cwd !== process.cwd()) {
       process.chdir(cwd);
     }
 
-    // Set environment variables
     Object.assign(process.env, env);
 
     core.info(`→ Starting agent run with Claude Code`);
 
-    // Create and install the Claude agent
     const agent = new ClaudeAgent({ apiKey: inputs.anthropic_api_key });
     await agent.install();
 
-    // Execute the agent with the prompt
     const result = await agent.execute(inputs.prompt);
 
     if (!result.success) {

mcp/config.ts

@@ -1,13 +1,20 @@
 /**
  * Simple MCP configuration helper for adding our minimal GitHub comment server
  */
-const actionPath = process.env.GITHUB_ACTION_PATH || process.cwd();
+// const actionPath = process.env.GITHUB_ACTION_PATH || process.cwd();
+
+import { fromHere } from "@ark/fs";
+
+const actionPath = fromHere("..");
+
+export function createMcpConfig(githubInstallationToken: string) {
+  const githubRepository = process.env.GITHUB_REPOSITORY;
+  if (!githubRepository) {
+    throw new Error(
+      "GITHUB_REPOSITORY environment variable is required for MCP GitHub integration"
+    );
+  }
 
-export function createMcpConfig(
-  githubInstallationToken: string,
-  repoOwner: string,
-  repoName: string
-) {
   return JSON.stringify(
     {
       mcpServers: {
@@ -16,8 +23,7 @@ export function createMcpConfig(
           args: [`${actionPath}/mcp/server.ts`],
           env: {
             GITHUB_INSTALLATION_TOKEN: githubInstallationToken,
-            REPO_OWNER: repoOwner,
-            REPO_NAME: repoName,
+            GITHUB_REPOSITORY: githubRepository,
           },
         },
       },

mcp/server.ts

@@ -1,24 +1,41 @@
 #!/usr/bin/env node
+import { writeFileSync } from "node:fs";
 // Minimal GitHub Issue Comment MCP Server
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { Octokit } from "@octokit/rest";
 import { type } from "arktype";
 import { z } from "zod";
+import { resolveRepoContext } from "../utils/repo-context.ts";
 
-// Get repository information from environment variables
-const REPO_OWNER = process.env.REPO_OWNER;
-const REPO_NAME = process.env.REPO_NAME;
+// Simple error logging to file
+function logError(message: string, error?: any) {
+  const timestamp = new Date().toISOString();
+  const errorText = error ? `\nError: ${error.message}\nStack: ${error.stack}` : "";
+  const logEntry = `[${timestamp}] ${message}${errorText}\n`;
 
-if (!REPO_OWNER || !REPO_NAME) {
-  console.error("Error: REPO_OWNER and REPO_NAME environment variables are required");
-  process.exit(1);
+  try {
+    writeFileSync("/tmp/mcp-error.log", logEntry, { flag: "a" });
+    console.error(logEntry);
+  } catch (writeError) {
+    console.error(`Failed to write error log: ${writeError}`);
+    console.error(logEntry);
+  }
 }
 
-const server = new McpServer({
-  name: "Minimal GitHub Issue Comment Server",
-  version: "0.0.1",
-});
+let server: McpServer;
+
+try {
+  logError("Creating MCP server...");
+  server = new McpServer({
+    name: "Minimal GitHub Issue Comment Server",
+    version: "0.0.1",
+  });
+  logError("MCP server created successfully");
+} catch (error) {
+  logError("Failed to create MCP server", error);
+  process.exit(1);
+}
 
 // Define the schema for creating issue comments
 const Comment = type({
@@ -26,72 +43,114 @@ const Comment = type({
   body: type.string.describe("the comment body content"),
 });
 
-server.tool(
-  "create_issue_comment",
-  "Create a comment on a GitHub issue",
-  {
-    issueNumber: z.number().describe("the issue number to comment on"),
-    body: z.string().describe("the comment body content"),
-  },
-  async ({ issueNumber, body }) => {
-    try {
-      Comment.assert({ issueNumber, body });
+try {
+  logError("Registering create_issue_comment tool...");
 
-      const githubInstallationToken = process.env.GITHUB_INSTALLATION_TOKEN;
-      if (!githubInstallationToken) {
-        throw new Error("GITHUB_INSTALLATION_TOKEN environment variable is required");
+  server.tool(
+    "create_issue_comment",
+    "Create a comment on a GitHub issue",
+    {
+      issueNumber: z.number().describe("the issue number to comment on"),
+      body: z.string().describe("the comment body content"),
+    },
+    async ({ issueNumber, body }) => {
+      try {
+        Comment.assert({ issueNumber, body });
+
+        const githubInstallationToken = process.env.GITHUB_INSTALLATION_TOKEN;
+        if (!githubInstallationToken) {
+          throw new Error("GITHUB_INSTALLATION_TOKEN environment variable is required");
+        }
+
+        // Resolve repository context from environment
+        const repoContext = resolveRepoContext();
+
+        const octokit = new Octokit({
+          auth: githubInstallationToken,
+        });
+
+        const result = await octokit.rest.issues.createComment({
+          owner: repoContext.owner,
+          repo: repoContext.name,
+          issue_number: issueNumber,
+          body: body,
+        });
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  commentId: result.data.id,
+                  url: result.data.html_url,
+                  body: result.data.body,
+                },
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError("Tool execution failed", error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error creating comment: ${errorMessage}`,
+            },
+          ],
+          error: errorMessage,
+          isError: true,
+        };
       }
-
-      const octokit = new Octokit({
-        auth: githubInstallationToken,
-      });
-
-      const result = await octokit.rest.issues.createComment({
-        owner: REPO_OWNER,
-        repo: REPO_NAME,
-        issue_number: issueNumber,
-        body: body,
-      });
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                success: true,
-                commentId: result.data.id,
-                url: result.data.html_url,
-                body: result.data.body,
-              },
-              null,
-              2
-            ),
-          },
-        ],
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error creating comment: ${errorMessage}`,
-          },
-        ],
-        error: errorMessage,
-        isError: true,
-      };
     }
-  }
-);
+  );
 
-async function runServer() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  process.on("exit", () => {
-    server.close();
-  });
+  logError("Tool registered successfully");
+} catch (error) {
+  logError("Failed to register tool", error);
+  process.exit(1);
 }
 
-runServer().catch(console.error);
+async function runServer() {
+  try {
+    logError("Starting MCP server...");
+
+    const transport = new StdioServerTransport();
+    logError("Transport created, attempting connection...");
+
+    await server.connect(transport);
+    logError("MCP server connected successfully");
+
+    process.on("exit", () => {
+      logError("Process exiting, closing server...");
+      server.close();
+    });
+
+    process.on("SIGTERM", () => {
+      logError("SIGTERM received, closing server...");
+      server.close();
+      process.exit(0);
+    });
+
+    process.on("SIGINT", () => {
+      logError("SIGINT received, closing server...");
+      server.close();
+      process.exit(0);
+    });
+  } catch (error) {
+    logError("Server startup failed", error);
+    process.exit(1);
+  }
+}
+
+logError("Initializing MCP server process...");
+
+runServer().catch((error) => {
+  logError("Unhandled server error", error);
+  process.exit(1);
+});

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pullfrog/action",
-  "version": "0.0.13",
+  "version": "0.0.29",
   "type": "module",
   "files": [
     "index.js",
@@ -23,9 +23,11 @@
     "build:dev": "node esbuild.config.js",
     "prepare": "husky",
     "play": "node play.ts",
-    "upDeps": "pnpm up --latest"
+    "upDeps": "pnpm up --latest",
+    "createLockfile": "pnpm --ignore-workspace install"
   },
   "dependencies": {
+    "@ark/fs": "0.49.0",
     "@actions/core": "^1.11.1",
     "@modelcontextprotocol/sdk": "^1.17.5",
     "@octokit/rest": "^22.0.0",
@@ -33,7 +35,8 @@
     "arktype": "^2.1.22",
     "dotenv": "^17.2.2",
     "execa": "^9.6.0",
-    "table": "^6.9.0"
+    "table": "^6.9.0",
+    "zod": "^3.24.4"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
@@ -41,8 +44,7 @@
     "esbuild": "^0.25.9",
     "husky": "^9.0.0",
     "typescript": "^5.3.0",
-    "zshy": "^0.4.1",
-    "zod": "^3.24.4"
+    "zshy": "^0.4.1"
   },
   "repository": {
     "type": "git",

play.ts

@@ -1,35 +1,32 @@
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, extname, join, resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { extname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { fromHere } from "@ark/fs";
 import arg from "arg";
 import { config } from "dotenv";
 import { main } from "./main.ts";
+import packageJson from "./package.json" with { type: "json" };
 import { runAct } from "./utils/act.ts";
+import { setupGitHubInstallationToken } from "./utils/github.ts";
 import { setupTestRepo } from "./utils/setup.ts";
 
-// Load environment variables from .env file
 config();
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
 export async function run(
   prompt: string,
   options: { act?: boolean } = {}
 ): Promise<{ success: boolean; output?: string | undefined; error?: string | undefined }> {
   try {
+    console.log(`🐸 Running pullfrog/action@${packageJson.version}...`);
     if (options.act) {
-      // Use Docker/act to run the action
       console.log("🐳 Running with Docker/act...");
       runAct(prompt);
       return { success: true };
     }
 
-    // Setup test repository and run directly
     const tempDir = join(process.cwd(), ".temp");
     setupTestRepo({ tempDir, forceClean: true });
 
-    // Change to the temp directory
     const originalCwd = process.cwd();
     process.chdir(tempDir);
 
@@ -39,7 +36,6 @@ export async function run(
     console.log(prompt);
     console.log("─".repeat(50));
 
-    // Set environment variables from our .env for the action to use
     const { EXPECTED_INPUTS } = await import("./main.ts");
     EXPECTED_INPUTS.forEach((inputName) => {
       const value = process.env[inputName];
@@ -48,28 +44,31 @@ export async function run(
       }
     });
 
-    // Run main with the new params structure
     const inputs: any = {
       prompt,
       anthropic_api_key: process.env.ANTHROPIC_API_KEY || "",
     };
 
-    // Add optional properties only if they exist
     if (process.env.GITHUB_TOKEN) {
       inputs.github_token = process.env.GITHUB_TOKEN;
     }
 
-    if (process.env.GITHUB_INSTALLATION_TOKEN) {
-      inputs.github_installation_token = process.env.GITHUB_INSTALLATION_TOKEN;
-    }
+    console.log("🔑 Setting up GitHub installation token...");
+    const installationToken = await setupGitHubInstallationToken();
+    inputs.github_installation_token = installationToken;
+    console.log("✅ GitHub installation token setup successfully");
+
+    const envWithToken = {
+      ...process.env,
+      GITHUB_INSTALLATION_TOKEN: installationToken,
+    } as Record<string, string>;
 
     const result = await main({
       inputs,
-      env: process.env as Record<string, string>,
+      env: envWithToken,
       cwd: process.cwd(),
     });
 
-    // Change back to original directory
     process.chdir(originalCwd);
 
     if (result.success) {
@@ -89,7 +88,6 @@ export async function run(
   }
 }
 
-// CLI execution when run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const args = arg({
     "--help": Boolean,
@@ -125,16 +123,13 @@ Examples:
   let prompt: string;
 
   if (args["--raw"]) {
-    // Use raw prompt string
     prompt = args["--raw"];
   } else {
-    // Load prompt from file
     const filePath = args._[0] || "fixtures/basic.txt";
     const ext = extname(filePath).toLowerCase();
     let resolvedPath: string;
 
-    // First try as fixtures path
-    const fixturesPath = join(__dirname, "fixtures", filePath);
+    const fixturesPath = fromHere("fixtures", filePath);
     if (existsSync(fixturesPath)) {
       resolvedPath = fixturesPath;
     } else if (existsSync(filePath)) {
@@ -145,13 +140,11 @@ Examples:
 
     switch (ext) {
       case ".txt": {
-        // Plain text - pass directly as prompt
         prompt = readFileSync(resolvedPath, "utf8").trim();
         break;
       }
 
       case ".json": {
-        // JSON - stringify and pass as prompt
         const content = readFileSync(resolvedPath, "utf8");
         const parsed = JSON.parse(content);
         prompt = JSON.stringify(parsed, null, 2);
@@ -159,7 +152,6 @@ Examples:
       }
 
       case ".ts": {
-        // TypeScript - dynamic import and stringify default export
         const fileUrl = pathToFileURL(resolvedPath).href;
         const module = await import(fileUrl);
 
@@ -167,14 +159,11 @@ Examples:
           throw new Error(`TypeScript file ${filePath} must have a default export`);
         }
 
-        // If it's a string, use it directly
         if (typeof module.default === "string") {
           prompt = module.default;
         } else if (typeof module.default === "object" && module.default.prompt) {
-          // If it's a MainParams object with a prompt field, extract the prompt
           prompt = module.default.prompt;
         } else {
-          // Otherwise stringify it
           prompt = JSON.stringify(module.default, null, 2);
         }
         break;

pnpm-lock.yaml

@@ -11,6 +11,9 @@ importers:
       '@actions/core':
         specifier: ^1.11.1
         version: 1.11.1
+      '@ark/fs':
+        specifier: 0.49.0
+        version: 0.49.0
       '@modelcontextprotocol/sdk':
         specifier: ^1.17.5
         version: 1.19.1
@@ -32,6 +35,9 @@ importers:
       table:
         specifier: ^6.9.0
         version: 6.9.0
+      zod:
+        specifier: ^3.24.4
+        version: 3.25.76
     devDependencies:
       '@types/node':
         specifier: ^20.10.0
@@ -48,9 +54,6 @@ importers:
       typescript:
         specifier: ^5.3.0
         version: 5.9.3
-      zod:
-        specifier: ^3.24.4
-        version: 3.25.76
       zshy:
         specifier: ^0.4.1
         version: 0.4.3(typescript@5.9.3)
@@ -69,6 +72,9 @@ packages:
   '@actions/io@1.1.3':
     resolution: {integrity: sha512-wi9JjgKLYS7U/z8PPbco+PvTb/nRWjeoFlJ1Qer83k/3C5PHQi28hiVdeE2kHXmIL99mQFawx8qt/JPjZilJ8Q==}
 
+  '@ark/fs@0.49.0':
+    resolution: {integrity: sha512-AEjAQS/bu1CGIRiKK/XLaQ73cSJHixfexq28wNt+kBpQ0h1RwVIVzaGsn/+5IWw6DEbR7LB+3hil5gzrzEeyZQ==}
+
   '@ark/schema@0.49.0':
     resolution: {integrity: sha512-GphZBLpW72iS0v4YkeUtV3YIno35Gimd7+ezbPO9GwEi9kzdUrPVjvf6aXSBAfHikaFc/9pqZOpv3pOXnC71tw==}
 
@@ -902,6 +908,8 @@ snapshots:
 
   '@actions/io@1.1.3': {}
 
+  '@ark/fs@0.49.0': {}
+
   '@ark/schema@0.49.0':
     dependencies:
       '@ark/util': 0.49.0

scripts/generate-installation-token.ts

@@ -1,356 +0,0 @@
-#!/usr/bin/env tsx
-
-/**
- * GitHub App Installation Token Generator
- *
- * Generates a temporary installation token for a GitHub App to access a specific repository.
- * Uses environment variables for configuration and supports multiple installations.
- *
- * Usage:
- *   node scripts/generate-installation-token.ts [--repo owner/name] [--update-env]
- *
- * Environment variables required:
- *   GITHUB_APP_ID - GitHub App ID
- *   GITHUB_PRIVATE_KEY - GitHub App private key (PEM format)
- *   REPO_OWNER - Target repository owner (default)
- *   REPO_NAME - Target repository name (default)
- */
-
-import { createSign } from "node:crypto";
-import { readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { config } from "dotenv";
-
-// Load environment variables
-config();
-
-interface GitHubAppConfig {
-  appId: string;
-  privateKey: string;
-  repoOwner: string;
-  repoName: string;
-}
-
-interface Installation {
-  id: number;
-  account: {
-    login: string;
-    type: string;
-  };
-}
-
-interface Repository {
-  owner: {
-    login: string;
-  };
-  name: string;
-}
-
-interface InstallationTokenResponse {
-  token: string;
-  expires_at: string;
-}
-
-interface RepositoriesResponse {
-  repositories: Repository[];
-}
-
-class GitHubAppTokenGenerator {
-  private config: GitHubAppConfig;
-
-  constructor(config: GitHubAppConfig) {
-    // Process private key to handle escaped newlines
-    config.privateKey = config.privateKey.replace(/\\n/g, "\n");
-    this.config = config;
-    this.validateConfig();
-  }
-
-  private validateConfig(): void {
-    const { appId, privateKey, repoOwner, repoName } = this.config;
-
-    if (!appId) {
-      throw new Error("GITHUB_APP_ID environment variable is required");
-    }
-
-    if (!privateKey) {
-      throw new Error("GITHUB_PRIVATE_KEY environment variable is required");
-    }
-
-    if (!repoOwner || !repoName) {
-      throw new Error("REPO_OWNER and REPO_NAME environment variables are required");
-    }
-
-    if (!privateKey.includes("BEGIN") || !privateKey.includes("END")) {
-      throw new Error("GITHUB_PRIVATE_KEY must be in PEM format");
-    }
-  }
-
-  /**
-   * Generates a JWT for GitHub App authentication
-   */
-  private generateJWT(): string {
-    const now = Math.floor(Date.now() / 1000);
-    const payload = {
-      iat: now - 60, // issued 1 minute ago to account for clock skew
-      exp: now + 5 * 60, // expires in 5 minutes
-      iss: this.config.appId,
-    };
-
-    const header = {
-      alg: "RS256",
-      typ: "JWT",
-    };
-
-    const encodedHeader = this.base64UrlEncode(JSON.stringify(header));
-    const encodedPayload = this.base64UrlEncode(JSON.stringify(payload));
-    const signaturePart = `${encodedHeader}.${encodedPayload}`;
-
-    const signature = createSign("RSA-SHA256")
-      .update(signaturePart)
-      .sign(this.config.privateKey, "base64")
-      .replace(/\+/g, "-")
-      .replace(/\//g, "_")
-      .replace(/=/g, "");
-
-    return `${signaturePart}.${signature}`;
-  }
-
-  private base64UrlEncode(str: string): string {
-    return Buffer.from(str)
-      .toString("base64")
-      .replace(/\+/g, "-")
-      .replace(/\//g, "_")
-      .replace(/=/g, "");
-  }
-
-  /**
-   * Makes authenticated requests to GitHub API
-   */
-  private async githubRequest<T>(
-    path: string,
-    options: {
-      method?: string;
-      headers?: Record<string, string>;
-      body?: string;
-    } = {}
-  ): Promise<T> {
-    const { method = "GET", headers = {}, body } = options;
-
-    const url = `https://api.github.com${path}`;
-    const requestHeaders = {
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "Pullfrog-Installation-Token-Generator/1.0",
-      ...headers,
-    };
-
-    const response = await fetch(url, {
-      method,
-      headers: requestHeaders,
-      ...(body && { body }),
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(
-        `GitHub API request failed: ${response.status} ${response.statusText}\n${errorText}`
-      );
-    }
-
-    return response.json() as T;
-  }
-
-  /**
-   * Finds the installation ID for the target repository
-   */
-  private async findInstallationId(jwt: string): Promise<number> {
-    console.log("🔍 Finding GitHub App installation...");
-
-    const installations = await this.githubRequest<Installation[]>("/app/installations", {
-      headers: { Authorization: `Bearer ${jwt}` },
-    });
-
-    console.log(`📋 Found ${installations.length} installation(s)`);
-
-    // Check each installation for access to target repository
-    for (const installation of installations) {
-      console.log(`🔎 Checking installation ${installation.id} (${installation.account.login})`);
-
-      try {
-        // Create a temporary token to check repository access
-        const tempToken = await this.createInstallationToken(jwt, installation.id);
-        const hasAccess = await this.checkRepositoryAccess(tempToken);
-
-        if (hasAccess) {
-          console.log(
-            `✅ Installation ${installation.id} has access to ${this.config.repoOwner}/${this.config.repoName}`
-          );
-          return installation.id;
-        }
-      } catch (error) {
-        console.log(
-          `❌ Installation ${installation.id} check failed:`,
-          error instanceof Error ? error.message : String(error)
-        );
-      }
-    }
-
-    throw new Error(
-      `No installation found with access to ${this.config.repoOwner}/${this.config.repoName}. ` +
-        "Ensure the GitHub App is installed on the target repository."
-    );
-  }
-
-  /**
-   * Checks if the installation token has access to the target repository
-   */
-  private async checkRepositoryAccess(token: string): Promise<boolean> {
-    try {
-      const response = await this.githubRequest<RepositoriesResponse>(
-        "/installation/repositories",
-        {
-          headers: { Authorization: `token ${token}` },
-        }
-      );
-
-      return response.repositories.some(
-        (repo) => repo.owner.login === this.config.repoOwner && repo.name === this.config.repoName
-      );
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Creates an installation access token
-   */
-  private async createInstallationToken(jwt: string, installationId: number): Promise<string> {
-    const response = await this.githubRequest<InstallationTokenResponse>(
-      `/app/installations/${installationId}/access_tokens`,
-      {
-        method: "POST",
-        headers: { Authorization: `Bearer ${jwt}` },
-      }
-    );
-
-    return response.token;
-  }
-
-  /**
-   * Generates a new installation token for the configured repository
-   */
-  async generateToken(): Promise<{
-    token: string;
-    installationId: number;
-    expiresAt: string;
-  }> {
-    console.log(
-      `🚀 Generating installation token for ${this.config.repoOwner}/${this.config.repoName}`
-    );
-    console.log(`📱 App ID: ${this.config.appId}`);
-
-    // Step 1: Generate JWT for app authentication
-    const jwt = this.generateJWT();
-    console.log("🔐 Generated JWT token");
-
-    // Step 2: Find installation with repository access
-    const installationId = await this.findInstallationId(jwt);
-
-    // Step 3: Create installation access token
-    console.log(`🎫 Creating installation token for installation ${installationId}...`);
-    const token = await this.createInstallationToken(jwt, installationId);
-
-    // Calculate expiration (GitHub tokens expire after 1 hour)
-    const expiresAt = new Date(Date.now() + 60 * 60 * 1000).toISOString();
-
-    console.log("✅ Installation token generated successfully!");
-    console.log(`🎟️  Token: ${token.substring(0, 20)}...`);
-    console.log(`📅 Expires: ${expiresAt}`);
-    console.log(`🏢 Installation ID: ${installationId}`);
-
-    return { token, installationId, expiresAt };
-  }
-
-  /**
-   * Updates the .env file with the new installation token
-   */
-  updateEnvFile(token: string): void {
-    const envPath = join(process.cwd(), ".env");
-
-    try {
-      let envContent = readFileSync(envPath, "utf8");
-
-      // Update or add the installation token
-      const tokenLine = `GITHUB_INSTALLATION_TOKEN=${token}`;
-      const tokenRegex = /^GITHUB_INSTALLATION_TOKEN=.*$/m;
-
-      if (tokenRegex.test(envContent)) {
-        envContent = envContent.replace(tokenRegex, tokenLine);
-      } else {
-        envContent += `\n${tokenLine}\n`;
-      }
-
-      writeFileSync(envPath, envContent);
-      console.log(`📝 Updated ${envPath} with new installation token`);
-    } catch (error) {
-      console.error(
-        "❌ Failed to update .env file:",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-}
-
-/**
- * CLI interface
- */
-async function main(): Promise<void> {
-  try {
-    const args = process.argv.slice(2);
-    const updateEnv = args.includes("--update-env");
-
-    // Parse repository from args if provided
-    const repoArg = args.find((arg) => arg.startsWith("--repo="));
-    let repoOwner = process.env.REPO_OWNER || "pullfrogai";
-    let repoName = process.env.REPO_NAME || "scratch";
-
-    if (repoArg) {
-      const [owner, name] = repoArg.split("=")[1].split("/");
-      if (owner && name) {
-        repoOwner = owner;
-        repoName = name;
-      } else {
-        throw new Error("Invalid --repo format. Use: --repo=owner/name");
-      }
-    }
-
-    const config: GitHubAppConfig = {
-      appId: process.env.GITHUB_APP_ID!,
-      privateKey: process.env.GITHUB_PRIVATE_KEY!,
-      repoOwner,
-      repoName,
-    };
-
-    const generator = new GitHubAppTokenGenerator(config);
-    const result = await generator.generateToken();
-
-    if (updateEnv) {
-      generator.updateEnvFile(result.token);
-    }
-
-    console.log("\n🎉 Token generation complete!");
-
-    if (!updateEnv) {
-      console.log("\n💡 To automatically update your .env file, run with --update-env flag");
-    }
-  } catch (error) {
-    console.error("❌ Error:", error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  }
-}
-
-// Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  main();
-}
-
-export { GitHubAppTokenGenerator };

utils/act.ts

@@ -12,27 +12,21 @@ const tempDir = join(__dirname, "..", ".temp");
 const actionPath = join(__dirname, "..");
 const envPath = join(__dirname, "..", "..", ".env");
 
-// Environment variables that should be passed as secrets to the workflow
 const ENV_VARS = ["ANTHROPIC_API_KEY", "GITHUB_INSTALLATION_TOKEN"];
 
 export function runAct(prompt: string): void {
-  // Setup test repository
   setupTestRepo({ tempDir });
 
-  // Load environment variables
   config({ path: envPath });
 
-  // Build action bundles
   buildAction(actionPath);
 
   const workflowPath = join(tempDir, ".github", "workflows", "pullfrog.yml");
 
-  // Create minimal dist for act (avoids pnpm symlink issues)
   const distPath = join(actionPath, ".act-dist");
   console.log("📦 Creating minimal distribution for act...");
   execSync(`rm -rf "${distPath}" && mkdir -p "${distPath}"`, { shell: "/bin/bash" });
 
-  // Copy only necessary files (bundled, no node_modules needed)
   ["action.yml", "entry.cjs", "index.cjs", "package.json"].forEach((file) => {
     const src = join(actionPath, file);
     if (existsSync(src)) {
@@ -41,8 +35,6 @@ export function runAct(prompt: string): void {
   });
 
   try {
-    // Build the act command with input directly
-    // Properly escape the prompt for shell
     const escapedPrompt = prompt.replace(/'/g, "'\\''");
 
     const actCommandParts = [
@@ -56,14 +48,12 @@ export function runAct(prompt: string): void {
       `pullfrog/action@v0=${distPath}`, // Use minimal dist without symlinks
     ];
 
-    // Add environment variables as secrets that will be available to the workflow
     ENV_VARS.forEach((key) => {
       if (process.env[key]) {
         actCommandParts.push("-s", key);
       }
     });
 
-    // We only need the specific ENV_VARS, no need to add other variables
 
     const actCommand = actCommandParts.join(" ");
 
@@ -73,15 +63,12 @@ export function runAct(prompt: string): void {
     console.log("─".repeat(50));
     console.log("");
 
-    // Execute act
     execSync(actCommand, {
       stdio: "inherit",
       cwd: join(__dirname, "..", ".."),
     });
-    // Clean up
     execSync(`rm -rf "${distPath}"`);
   } catch (error) {
-    // Clean up on error
     execSync(`rm -rf "${distPath}"`);
     console.error("❌ Act execution failed:", (error as Error).message);
     process.exit(1);

utils/github.ts

@@ -1,4 +1,6 @@
+import { createSign } from "node:crypto";
 import * as core from "@actions/core";
+import { resolveRepoContext } from "./repo-context.ts";
 
 export interface InstallationToken {
   token: string;
@@ -10,62 +12,241 @@ export interface InstallationToken {
   owner?: string;
 }
 
+interface GitHubAppConfig {
+  appId: string;
+  privateKey: string;
+  repoOwner: string;
+  repoName: string;
+}
+
+interface Installation {
+  id: number;
+  account: {
+    login: string;
+    type: string;
+  };
+}
+
+interface Repository {
+  owner: {
+    login: string;
+  };
+  name: string;
+}
+
+interface InstallationTokenResponse {
+  token: string;
+  expires_at: string;
+}
+
+interface RepositoriesResponse {
+  repositories: Repository[];
+}
+
+function checkExistingToken(): string | null {
+  const inputToken = core.getInput("github_installation_token");
+  const envToken = process.env.GITHUB_INSTALLATION_TOKEN;
+  return inputToken || envToken || null;
+}
+
+function isGitHubActionsEnvironment(): boolean {
+  return Boolean(process.env.GITHUB_ACTIONS);
+}
+
+async function acquireTokenViaOIDC(): Promise<string> {
+  core.info("Generating OIDC token...");
+  
+  const oidcToken = await core.getIDToken("pullfrog-api");
+  core.info("OIDC token generated successfully");
+
+  const apiUrl = process.env.API_URL || "https://pullfrog.ai";
+
+  core.info("Exchanging OIDC token for installation token...");
+  const tokenResponse = await fetch(`${apiUrl}/api/github/installation-token`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${oidcToken}`,
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!tokenResponse.ok) {
+    const errorText = await tokenResponse.text();
+    throw new Error(
+      `Token exchange failed: ${tokenResponse.status} ${tokenResponse.statusText} - ${errorText}`
+    );
+  }
+
+  const tokenData = (await tokenResponse.json()) as InstallationToken;
+  core.info(`Installation token obtained for ${tokenData.repository || "all repositories"}`);
+
+  return tokenData.token;
+}
+
+const base64UrlEncode = (str: string): string => {
+  return Buffer.from(str)
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=/g, "");
+};
+
+const generateJWT = (appId: string, privateKey: string): string => {
+  const now = Math.floor(Date.now() / 1000);
+  const payload = {
+    iat: now - 60,
+    exp: now + 5 * 60,
+    iss: appId,
+  };
+
+  const header = {
+    alg: "RS256",
+    typ: "JWT",
+  };
+
+  const encodedHeader = base64UrlEncode(JSON.stringify(header));
+  const encodedPayload = base64UrlEncode(JSON.stringify(payload));
+  const signaturePart = `${encodedHeader}.${encodedPayload}`;
+
+  const signature = createSign("RSA-SHA256")
+    .update(signaturePart)
+    .sign(privateKey, "base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=/g, "");
+
+  return `${signaturePart}.${signature}`;
+};
+
+const githubRequest = async <T>(
+  path: string,
+  options: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+  } = {}
+): Promise<T> => {
+  const { method = "GET", headers = {}, body } = options;
+
+  const url = `https://api.github.com${path}`;
+  const requestHeaders = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "Pullfrog-Installation-Token-Generator/1.0",
+    ...headers,
+  };
+
+  const response = await fetch(url, {
+    method,
+    headers: requestHeaders,
+    ...(body && { body }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `GitHub API request failed: ${response.status} ${response.statusText}\n${errorText}`
+    );
+  }
+
+  return response.json() as T;
+};
+
+const checkRepositoryAccess = async (
+  token: string,
+  repoOwner: string,
+  repoName: string
+): Promise<boolean> => {
+  try {
+    const response = await githubRequest<RepositoriesResponse>("/installation/repositories", {
+      headers: { Authorization: `token ${token}` },
+    });
+
+    return response.repositories.some(
+      (repo) => repo.owner.login === repoOwner && repo.name === repoName
+    );
+  } catch {
+    return false;
+  }
+};
+
+const createInstallationToken = async (jwt: string, installationId: number): Promise<string> => {
+  const response = await githubRequest<InstallationTokenResponse>(
+    `/app/installations/${installationId}/access_tokens`,
+    {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}` },
+    }
+  );
+
+  return response.token;
+};
+
+const findInstallationId = async (
+  jwt: string,
+  repoOwner: string,
+  repoName: string
+): Promise<number> => {
+  const installations = await githubRequest<Installation[]>("/app/installations", {
+    headers: { Authorization: `Bearer ${jwt}` },
+  });
+
+  for (const installation of installations) {
+    try {
+      const tempToken = await createInstallationToken(jwt, installation.id);
+      const hasAccess = await checkRepositoryAccess(tempToken, repoOwner, repoName);
+
+      if (hasAccess) {
+        return installation.id;
+      }
+    } catch {}
+  }
+
+  throw new Error(
+    `No installation found with access to ${repoOwner}/${repoName}. ` +
+      "Ensure the GitHub App is installed on the target repository."
+  );
+};
+
+async function acquireTokenViaGitHubApp(): Promise<string> {
+  const repoContext = resolveRepoContext();
+
+  const config: GitHubAppConfig = {
+    appId: process.env.GITHUB_APP_ID!,
+    privateKey: process.env.GITHUB_PRIVATE_KEY?.replace(/\\n/g, "\n")!,
+    repoOwner: repoContext.owner,
+    repoName: repoContext.name,
+  };
+
+  const jwt = generateJWT(config.appId, config.privateKey);
+  const installationId = await findInstallationId(jwt, config.repoOwner, config.repoName);
+  const token = await createInstallationToken(jwt, installationId);
+
+  return token;
+}
+
+async function acquireNewToken(): Promise<string> {
+  if (isGitHubActionsEnvironment()) {
+    return await acquireTokenViaOIDC();
+  } else {
+    return await acquireTokenViaGitHubApp();
+  }
+}
+
 /**
  * Setup GitHub installation token for the action
  */
 export async function setupGitHubInstallationToken(): Promise<string> {
-  // Check if we have an installation token from inputs or environment
-  const inputToken = core.getInput("github_installation_token");
-  const envToken = process.env.GITHUB_INSTALLATION_TOKEN;
-
-  const existingToken = inputToken || envToken;
+  const existingToken = checkExistingToken();
   if (existingToken) {
-    // Mask the existing token in logs for security
     core.setSecret(existingToken);
     core.info("Using provided GitHub installation token");
     return existingToken;
   }
 
-  core.info("Generating OIDC token...");
-
-  try {
-    // Generate OIDC token for our API
-    const oidcToken = await core.getIDToken("pullfrog-api");
-    core.info("OIDC token generated successfully");
-
-    // Exchange OIDC token for installation token
-    const apiUrl = process.env.API_URL || "https://pullfrog.ai";
-
-    core.info("Exchanging OIDC token for installation token...");
-    const tokenResponse = await fetch(`${apiUrl}/api/github/installation-token`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${oidcToken}`,
-        "Content-Type": "application/json",
-      },
-    });
-
-    if (!tokenResponse.ok) {
-      const errorText = await tokenResponse.text();
-      throw new Error(
-        `Token exchange failed: ${tokenResponse.status} ${tokenResponse.statusText} - ${errorText}`
-      );
-    }
-
-    // This type is enforced by us when the response is created
-    const tokenData = (await tokenResponse.json()) as InstallationToken;
-    core.info(`Installation token obtained for ${tokenData.repository || "all repositories"}`);
-
-    // Mask the token in logs for security
-    core.setSecret(tokenData.token);
-
-    // Set the token as an environment variable for this run
-    process.env.GITHUB_INSTALLATION_TOKEN = tokenData.token;
-
-    return tokenData.token;
-  } catch (error) {
-    throw new Error(
-      `Failed to setup GitHub installation token: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
+  const token = await acquireNewToken();
+  
+  core.setSecret(token);
+  process.env.GITHUB_INSTALLATION_TOKEN = token;
+  
+  return token;
 }

utils/repo-context.ts

@@ -0,0 +1,22 @@
+export interface RepoContext {
+  owner: string;
+  name: string;
+}
+
+/**
+ * Resolve repository context from GITHUB_REPOSITORY environment variable.
+ * Throws if not available.
+ */
+export function resolveRepoContext(): RepoContext {
+  const githubRepo = process.env.GITHUB_REPOSITORY;
+  if (!githubRepo) {
+    throw new Error('GITHUB_REPOSITORY environment variable is required');
+  }
+  
+  const [owner, name] = githubRepo.split('/');
+  if (!owner || !name) {
+    throw new Error(`Invalid GITHUB_REPOSITORY format: ${githubRepo}. Expected 'owner/repo'`);
+  }
+  
+  return { owner, name };
+}

utils/setup.ts

@@ -17,13 +17,11 @@ export function setupTestRepo(options: SetupOptions): void {
     forceClean = false,
   } = options;
 
-  // Handle existing temp directory
   if (existsSync(tempDir)) {
     if (forceClean) {
       console.log("🗑️  Removing existing .temp directory...");
       rmSync(tempDir, { recursive: true, force: true });
 
-      // Clone the repository
       console.log("📦 Cloning pullfrogai/scratch into .temp...");
       execSync(`git clone ${repoUrl} ${tempDir}`, { stdio: "inherit" });
     } else {

utils/subprocess.ts

@@ -28,13 +28,11 @@ export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
   let stderrBuffer = "";
 
   return new Promise((resolve, reject) => {
-    // Spawn the child process
     const child = nodeSpawn(cmd, args, {
       env: env ? { ...process.env, ...env } : process.env,
       stdio: ["pipe", "pipe", "pipe"],
     });
 
-    // Set up timeout if specified
     let timeoutId: NodeJS.Timeout | undefined;
     let isTimedOut = false;
 
@@ -43,7 +41,6 @@ export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
         isTimedOut = true;
         child.kill("SIGTERM");
 
-        // If SIGTERM doesn't work, use SIGKILL after 5 seconds
         setTimeout(() => {
           if (!child.killed) {
             child.kill("SIGKILL");
@@ -52,7 +49,6 @@ export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
       }, timeout);
     }
 
-    // Handle stdout streaming
     if (child.stdout) {
       child.stdout.on("data", (data: Buffer) => {
         const chunk = data.toString();
@@ -61,7 +57,6 @@ export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
       });
     }
 
-    // Handle stderr streaming
     if (child.stderr) {
       child.stderr.on("data", (data: Buffer) => {
         const chunk = data.toString();
@@ -70,7 +65,6 @@ export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
       });
     }
 
-    // Handle process completion
     child.on("close", (exitCode) => {
       const durationMs = Date.now() - startTime;
 
@@ -91,15 +85,13 @@ export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
       });
     });
 
-    // Handle process errors
-    child.on("error", (error) => {
+    child.on("error", (_error) => {
       const durationMs = Date.now() - startTime;
 
       if (timeoutId) {
         clearTimeout(timeoutId);
       }
 
-      // Still return buffered output even on error
       resolve({
         stdout: stdoutBuffer,
         stderr: stderrBuffer,
@@ -108,7 +100,6 @@ export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
       });
     });
 
-    // Send input if provided
     if (input && child.stdin) {
       child.stdin.write(input);
       child.stdin.end();

utils/table.ts

@@ -22,8 +22,8 @@ export function tableString(
     },
   } = options || {};
 
-  if (options?.title) {
-    rows.unshift([options.title]);
+  if (title) {
+    rows.unshift([title]);
   }
 
   const tableOutput = table(rows, {
@@ -140,33 +140,3 @@ export function boxString(
 
   return result;
 }
-
-// /**
-//  * Create a simple two-column table for displaying key-value pairs
-//  * @param data - Array of [key, value] pairs
-//  * @param title - Optional table title
-//  * @param indent - Optional indentation string
-//  */
-// export function printKeyValueTable(
-//   data: [string, string][],
-//   title?: string,
-//   indent?: string
-// ): void {
-//   const rows: string[][] = [["Key", "Value"], ...data];
-//   const options: Parameters<typeof printTable>[1] = {};
-//   if (title !== undefined) options.title = title;
-//   if (indent !== undefined) options.indent = indent;
-//   printTable(rows, options);
-// }
-
-// /**
-//  * Create a path resolution table (specific use case)
-//  * @param pathData - Array of [location, resolvedPath] pairs
-//  * @param indent - Optional indentation string
-//  */
-// export function printPathTable(pathData: [string, string][], indent?: string): void {
-//   const rows: string[][] = [["Location", "Resolved path"], ...pathData];
-//   const options: Parameters<typeof printTable>[1] = {};
-//   if (indent !== undefined) options.indent = indent;
-//   printTable(rows, options);
-// }