update action

This reverts commit 06542e382a.

.github/workflows/publish.yml

@@ -29,12 +29,12 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "20"
+          node-version: "24"
           cache: "pnpm"
           registry-url: "https://registry.npmjs.org"
 
       - name: Install dependencies
-        run: pnpm install
+        run: pnpm install --frozen-lockfile
 
       - name: Get package version
         id: version
@@ -60,21 +60,6 @@ jobs:
             echo "✅ Tag ${{ steps.version.outputs.tag }} does not exist - will create release"
           fi
 
-      - name: Verify built files are up to date
-        if: steps.check_tag.outputs.exists == 'false'
-        run: |
-          # Check if there are any uncommitted changes
-          if [[ -n $(git status --porcelain) ]]; then
-            echo "❌ Error: There are uncommitted changes. Built files should be committed via pre-commit hook."
-            git status
-            exit 1
-          fi
-          echo "✅ All built files are up to date"
-
-      - name: Build for npm with zshy
-        if: steps.check_tag.outputs.exists == 'false'
-        run: pnpm build:npm
-
       - name: Create and push tags
         if: steps.check_tag.outputs.exists == 'false'
         run: |
@@ -95,24 +80,14 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           tag_name: ${{ steps.version.outputs.tag }}
-          release_name: "@pullfrog/action ${{ steps.version.outputs.tag }}"
+          release_name: "${{ steps.version.outputs.tag }}"
           body: |
             ## 📦 @pullfrog/action ${{ steps.version.outputs.version }}
 
             ### Usage in GitHub Actions
 
-            Use the major version tag for automatic updates:
             ```yaml
             - uses: pullfrog/action@${{ steps.version.outputs.major_tag }}
-              with:
-                message: "Your message here"
-            ```
-
-            Or pin to this specific version:
-            ```yaml
-            - uses: pullfrog/action@${{ steps.version.outputs.tag }}
-              with:
-                message: "Your message here"
             ```
 
             ### Installation via npm
@@ -123,11 +98,11 @@ jobs:
           draft: false
           prerelease: false
 
-      - name: Publish to npm
+      # - name: Publish to npm
-        if: steps.check_tag.outputs.exists == 'false'
+      #   if: steps.check_tag.outputs.exists == 'false'
-        run: npm publish --access public
+      #   run: npm publish --access public
-        env:
+      #   env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      #     NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
 
       - name: Summary
         if: always()

.husky/pre-commit

@@ -1,6 +0,0 @@
-# Build the action before committing
-echo "🔨 Building action..."
-npm run build
-
-# Add the built files to the commit
-git add index.cjs entry.cjs

CLAUDE-ACTION.md

@@ -0,0 +1,299 @@
+# Claude Code Action Architecture & Flow
+
+This document provides a comprehensive overview of how the official (Anthropic) Claude Code Action works, from token exchange through post-run cleanup.
+
+## Overview
+
+The Claude Code Action is a sophisticated GitHub automation platform that enables Claude to interact with GitHub repositories through secure token exchange, intelligent mode detection, and comprehensive GitHub API integration.
+
+## High-Level Architecture
+
+```mermaid
+graph TD
+    Start([GitHub Action Triggered]) --> Setup[Setup Environment<br/>- Install Bun<br/>- Install Dependencies]
+    
+    Setup --> ParseContext[Parse GitHub Context<br/>- Extract event data<br/>- Parse inputs]
+    
+    ParseContext --> ModeDetection{Mode Detection}
+    
+    ModeDetection -->|Has explicit prompt| AgentMode[AGENT MODE<br/>Direct automation]
+    ModeDetection -->|@claude mention/assignment/label| TagMode[TAG MODE<br/>Interactive response]
+    ModeDetection -->|No trigger| DefaultAgent[Default to Agent<br/>(won't trigger)]
+    
+    %% Token Exchange Branch
+    AgentMode --> TokenExchange[Token Exchange Process]
+    TagMode --> TokenExchange
+    TokenExchange --> TokenMethod{Token Method}
+    
+    TokenMethod -->|Custom token provided| UseCustom[Use Custom GitHub Token]
+    TokenMethod -->|No custom token| OIDC[Generate OIDC Token<br/>core.getIDToken()]
+    
+    OIDC --> Exchange[Exchange OIDC for App Token<br/>api.anthropic.com/api/github/github-app-token-exchange]
+    Exchange --> CreateOctokit[Create Authenticated Octokit Client<br/>REST + GraphQL]
+    UseCustom --> CreateOctokit
+    
+    %% Permission Checks
+    CreateOctokit --> PermCheck[Check Write Permissions<br/>Only for entity contexts]
+    PermCheck -->|No permissions| PermFail[❌ Exit: No write access]
+    PermCheck -->|Has permissions| TriggerCheck{Check Trigger Conditions}
+    
+    %% Trigger Validation
+    TriggerCheck -->|Agent Mode| AgentTrigger{Has explicit prompt?}
+    TriggerCheck -->|Tag Mode| TagTrigger{Contains @claude mention<br/>or assignment/label?}
+    
+    AgentTrigger -->|No prompt| NoTrigger[❌ Skip: No trigger found]
+    AgentTrigger -->|Has prompt| PrepareAgent[Prepare Agent Mode]
+    TagTrigger -->|No mention| NoTrigger
+    TagTrigger -->|Has mention| PrepareTag[Prepare Tag Mode]
+    
+    %% Mode-Specific Preparation
+    PrepareAgent --> AgentPrep[Agent Mode Preparation<br/>- Create prompt file<br/>- Setup MCP servers<br/>- No tracking comment]
+    PrepareTag --> TagPrep[Tag Mode Preparation<br/>- Create tracking comment<br/>- Setup branches<br/>- Fetch GitHub data<br/>- Setup MCP servers]
+    
+    %% Data Fetching (Tag Mode)
+    TagPrep --> DataFetch[Fetch GitHub Data<br/>GraphQL + REST API]
+    DataFetch --> FetchWhat{What to fetch?}
+    
+    FetchWhat -->|Pull Request| PRData[PR Data:<br/>- Comments & reviews<br/>- Changed files + SHAs<br/>- Commit history<br/>- Author info]
+    FetchWhat -->|Issue| IssueData[Issue Data:<br/>- Comments<br/>- Issue details<br/>- Author info]
+    
+    PRData --> ProcessImages[Process Images<br/>Download & convert to base64]
+    IssueData --> ProcessImages
+    ProcessImages --> SetupBranch[Setup Branch<br/>- Create Claude branch<br/>- Configure git auth]
+    
+    %% MCP Server Setup
+    AgentPrep --> MCPSetup[Setup MCP Servers]
+    SetupBranch --> MCPSetup
+    
+    MCPSetup --> MCPServers{MCP Servers}
+    MCPServers --> GitHubActions[GitHub Actions Server<br/>- Workflow data<br/>- CI results]
+    MCPServers --> GitHubComments[GitHub Comment Server<br/>- Comment operations]
+    MCPServers --> GitHubFiles[GitHub File Ops Server<br/>- File operations<br/>- Branch management]
+    MCPServers --> GitHubInline[GitHub Inline Comment Server<br/>- PR review comments]
+    
+    GitHubActions --> PromptGen[Generate Prompt]
+    GitHubComments --> PromptGen
+    GitHubFiles --> PromptGen
+    GitHubInline --> PromptGen
+    
+    %% Prompt Generation
+    PromptGen --> PromptType{Prompt Type}
+    PromptType -->|Agent Mode| AgentPrompt[Agent Prompt:<br/>- Direct user prompt<br/>- Minimal context]
+    PromptType -->|Tag Mode| TagPrompt[Tag Prompt:<br/>- Rich GitHub context<br/>- PR/Issue details<br/>- Changed files<br/>- Comments & reviews<br/>- Commit instructions]
+    
+    AgentPrompt --> ClaudeRun[Run Claude Code]
+    TagPrompt --> ClaudeRun
+    
+    %% Claude Execution
+    ClaudeRun --> ClaudeExec[Claude Code Execution<br/>base-action/src/index.ts]
+    ClaudeExec --> ClaudeArgs[Prepare Claude Args<br/>- Prompt file path<br/>- Custom claude_args<br/>- Output format: stream-json]
+    
+    ClaudeArgs --> ClaudeProvider{Provider}
+    ClaudeProvider -->|Default| AnthropicAPI[Anthropic API<br/>ANTHROPIC_API_KEY]
+    ClaudeProvider -->|Bedrock| AWSBedrock[AWS Bedrock<br/>OIDC + AWS credentials]
+    ClaudeProvider -->|Vertex| GCPVertex[GCP Vertex AI<br/>OIDC + GCP credentials]
+    
+    AnthropicAPI --> ClaudeProcess[Spawn Claude Process<br/>- Named pipe for input<br/>- Stream JSON output]
+    AWSBedrock --> ClaudeProcess
+    GCPVertex --> ClaudeProcess
+    
+    ClaudeProcess --> ClaudeTools[Claude Tool Usage<br/>- MCP tools<br/>- File operations<br/>- GitHub API calls<br/>- Bash commands]
+    
+    ClaudeTools --> ClaudeOutput[Claude Output Processing<br/>- Capture execution log<br/>- Parse JSON stream<br/>- Extract metrics]
+    
+    %% Post-Run Actions
+    ClaudeOutput --> PostRun{Post-Run Actions}
+    
+    PostRun -->|Success| Success[✅ Success Path]
+    PostRun -->|Failure| Failure[❌ Failure Path]
+    
+    Success --> UpdateComment[Update Tracking Comment<br/>- Job run link<br/>- Branch link<br/>- PR link (if created)<br/>- Execution metrics]
+    Failure --> UpdateComment
+    
+    UpdateComment --> BranchCleanup[Branch Cleanup<br/>- Check for changes<br/>- Delete empty branches<br/>- Keep branches with commits]
+    
+    BranchCleanup --> FormatReport[Format Execution Report<br/>- Parse conversation turns<br/>- Format tool usage<br/>- Add to GitHub step summary]
+    
+    FormatReport --> RevokeToken[Revoke App Token<br/>DELETE /installation/token]
+    
+    RevokeToken --> End([Action Complete])
+```
+
+## Key Components
+
+### 1. Token Exchange Process
+
+The action uses a secure OIDC token exchange system:
+
+1. **OIDC Token Generation**: `core.getIDToken("claude-code-github-action")`
+2. **Token Exchange**: POST to `https://api.anthropic.com/api/github/github-app-token-exchange`
+3. **Authentication**: Creates authenticated Octokit clients for GitHub API access
+
+**Security Benefits:**
+- Repository-scoped access
+- Time-limited tokens
+- Permission-limited (only configured GitHub App permissions)
+- Automatic token masking in logs
+
+### 2. Mode Detection
+
+The action automatically detects the appropriate execution mode:
+
+#### **Agent Mode**
+- **Trigger**: Explicit `prompt` input provided
+- **Use Case**: Direct automation, custom workflows
+- **Behavior**: Minimal context, direct execution
+- **Tracking**: No tracking comments
+
+#### **Tag Mode**  
+- **Trigger**: @claude mentions, issue assignments, or labels
+- **Use Case**: Interactive GitHub responses
+- **Behavior**: Rich context, comprehensive GitHub data
+- **Tracking**: Creates and updates tracking comments
+
+### 3. Data Fetching (Tag Mode)
+
+When in Tag Mode, the action fetches comprehensive GitHub context:
+
+#### **Pull Request Data:**
+- Comments and reviews (including inline comments)
+- Changed files with SHAs
+- Commit history and metadata
+- Author information
+- File diff data
+
+#### **Issue Data:**
+- Issue details and metadata  
+- All comments
+- Author information
+- Labels and assignments
+
+#### **Image Processing:**
+- Downloads images from GitHub
+- Converts to base64 for Claude
+- Maps original URLs to processed content
+
+### 4. MCP Server Integration
+
+The action sets up multiple MCP (Model Context Protocol) servers to provide Claude with GitHub capabilities:
+
+#### **GitHub Actions Server**
+- Access to workflow runs and CI data
+- Build status and test results
+- Artifact information
+
+#### **GitHub Comment Server**
+- Comment creation and updates
+- Issue and PR comment management
+
+#### **GitHub File Operations Server**
+- File reading and writing
+- Branch creation and management
+- Commit operations
+
+#### **GitHub Inline Comment Server**
+- PR review comment operations
+- Line-specific feedback
+
+### 5. Prompt Generation
+
+The action generates context-rich prompts based on the detected mode:
+
+#### **Agent Mode Prompts:**
+- Direct user prompt
+- Minimal GitHub context
+- Focused on specific task
+
+#### **Tag Mode Prompts:**
+- Comprehensive GitHub context
+- PR/Issue details and history
+- Changed files and diffs
+- Comment threads and reviews
+- Commit instructions and guidelines
+
+### 6. Claude Execution
+
+The action runs Claude Code through multiple provider options:
+
+#### **Provider Support:**
+- **Anthropic API** (default): Direct API access with API key
+- **AWS Bedrock**: OIDC authentication with AWS credentials
+- **GCP Vertex AI**: OIDC authentication with GCP credentials
+
+#### **Execution Process:**
+1. **Named Pipe Setup**: Creates pipe for prompt input
+2. **Process Spawning**: Spawns Claude Code process
+3. **Stream Processing**: Captures JSON stream output
+4. **Tool Integration**: Enables MCP tools and GitHub operations
+
+### 7. Post-Run Actions
+
+After Claude execution, the action performs comprehensive cleanup and reporting:
+
+#### **Comment Updates:**
+- Updates tracking comments with results
+- Adds job run links and execution metrics
+- Includes branch and PR links when created
+
+#### **Branch Management:**
+- Checks for actual changes in Claude branches
+- Deletes empty branches to avoid clutter
+- Preserves branches with meaningful commits
+
+#### **Report Generation:**
+- Parses execution logs and conversation turns
+- Formats tool usage and results
+- Adds formatted report to GitHub step summary
+
+#### **Security Cleanup:**
+- Revokes GitHub App installation token
+- Cleans up temporary files and processes
+
+## Security Considerations
+
+### **Access Control:**
+- Repository-scoped permissions only
+- Write access validation for actors
+- Bot user controls and allowlists
+
+### **Token Management:**
+- Short-lived installation tokens
+- Automatic token revocation after use
+- Secure OIDC-based exchange
+
+### **Permission Boundaries:**
+- Limited to configured GitHub App permissions
+- No cross-repository access
+- Scoped to specific repository operations
+
+## Integration Points
+
+### **With Pullfrog:**
+The Claude Code Action can be integrated with Pullfrog's workflow system, providing:
+- Standardized agent interaction patterns
+- Consistent GitHub integration
+- Reusable authentication flows
+- Common MCP server infrastructure
+
+### **With GitHub:**
+- Native GitHub Actions integration
+- Comprehensive API coverage (REST + GraphQL)
+- Proper webhook handling
+- Standard GitHub UI integration
+
+## Development Notes
+
+### **Key Files:**
+- `src/entrypoints/prepare.ts`: Main preparation logic
+- `src/modes/`: Mode detection and handling
+- `src/github/token.ts`: OIDC token exchange
+- `src/mcp/`: MCP server implementations
+- `base-action/`: Core Claude Code execution
+
+### **Testing:**
+- Unit tests for individual components
+- Integration tests for full workflows
+- Local testing with `act` tool
+- Comprehensive fixture support
+
+This architecture provides a robust, secure, and extensible foundation for Claude-GitHub integration while maintaining clear separation of concerns and comprehensive error handling.

README.md

@@ -2,6 +2,8 @@
 
 GitHub Action for running Claude Code and other agents via Pullfrog.
 
+> **📖 Claude Code Action Architecture**: For a detailed technical overview of how the Claude Code Action works (token exchange, modes, data fetching, execution flow), see [CLAUDE-ACTION.md](./CLAUDE-ACTION.md).
+
 ## Quick Start
 
 ```bash
@@ -55,6 +57,14 @@ pnpm dev          # Watch mode
 
 The action is bundled into `entry.cjs` with all dependencies included, eliminating runtime dependency on node_modules.
 
+## Environment Variables
+
+Create `.env` in `/action`:
+
+```bash
+ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  # Claude API key
+```
+
 ## Architecture
 
 - **entry.cjs**: Bundled action entry point (self-contained)

action.yml

@@ -12,9 +12,33 @@ inputs:
     required: false
 
 runs:
-  using: "node20"
+  using: "composite"
-  main: "entry.cjs"
+  steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 1
+    - name: Setup pnpm
+      uses: pnpm/action-setup@v4
+      with:
+        version: latest
+    - name: Setup Node.js 24
+      uses: actions/setup-node@v4
+      with:
+        node-version: "24"
+        cache: "pnpm"
+    - name: Install dependencies
+      run: pnpm install
+      shell: bash
+      working-directory: ${{ github.action_path }}
+    - name: Run agent
+      run: |
+        cd $GITHUB_WORKSPACE
+        node ${{ github.action_path }}/entry.ts
+      shell: bash
+      env:
+        INPUTS_JSON: ${{ toJSON(inputs) }}
 
 branding:
   icon: "code"
-  color: "orange"
+  color: "green"

agents/claude.ts

@@ -1,28 +1,27 @@
 import { access, constants } from "node:fs/promises";
 import * as core from "@actions/core";
-import { boxString, tableString } from "../utils";
+import { createMcpConfig } from "../mcp/config.ts";
-import { spawn } from "../utils/subprocess";
+import { debugLog, isDebug } from "../utils/logging.ts";
-import type { Agent, AgentConfig, AgentResult } from "./types";
+import { spawn } from "../utils/subprocess.ts";
+import { boxString, tableString } from "../utils/table.ts";
+import { instructions } from "./shared.ts";
+import type { Agent, AgentConfig, AgentResult } from "./types.ts";
 
 /**
  * Claude Code agent implementation
  */
 export class ClaudeAgent implements Agent {
   private apiKey: string;
+  private githubInstallationToken: string;
   public runStats = {
     toolsUsed: 0,
     turns: 0,
     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
+    this.githubInstallationToken = config.githubInstallationToken;
   }
 
   /**
@@ -42,7 +41,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;
@@ -50,23 +48,17 @@ 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: [
+        args: ["-c", "curl -fsSL https://claude.ai/install.sh | bash -s 1.0.93"],
-          "-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: (chunk) => process.stdout.write(chunk),
+        onStdout: () => {},
         onStderr: (chunk) => process.stderr.write(chunk),
       });
 
       if (result.exitCode !== 0) {
-        throw new Error(
+        throw new Error(`Installation failed with exit code ${result.exitCode}: ${result.stderr}`);
-          `Installation failed with exit code ${result.exitCode}: ${result.stderr}`,
-        );
       }
 
       core.info("Claude Code installed successfully");
@@ -80,31 +72,37 @@ 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);
+
+      const env = {
+        ANTHROPIC_API_KEY: this.apiKey,
+        ...(isDebug() && { LOG_LEVEL: "debug" }),
+      };
+
       console.log(boxString(prompt, { title: "Prompt" }));
+
+      const mcpConfig = createMcpConfig(this.githubInstallationToken);
+
+      if (isDebug()) {
+        debugLog(`📋 MCP Config: ${mcpConfig}`);
+      }
+
       const args = [
         "--print",
         "--output-format",
         "stream-json",
         "--verbose",
         "--permission-mode",
-        "acceptEdits",
+        "bypassPermissions",
+        "--mcp-config",
+        mcpConfig,
+        ...(isDebug() ? ["--debug"] : []),
       ];
-      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,
@@ -114,48 +112,33 @@ export class ClaudeAgent implements Agent {
       const finalResult = "";
       const totalCost = 0;
 
-      // run Claude Code with the prompt
       const result = await spawn({
         cmd: claudePath,
         args,
         env,
-        input: prompt,
+        input: `${instructions} ${prompt}`,
         timeout: 10 * 60 * 1000, // 10 minutes
         onStdout: (_chunk) => {
-          // console.log(chunk);
+          if (_chunk.trim()) {
-          processJSONChunk(_chunk, this);
+            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}`,
+          `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`,
+        `📊 Run Summary: ${this.runStats.toolsUsed} tools used, ${this.runStats.turns} turns, ${duration}ms duration`
       );
 
       core.info("✅ Task complete.");
@@ -172,14 +155,10 @@ export class ClaudeAgent implements Agent {
         },
       };
     } catch (error: any) {
-      // Ensure group is closed even if error occurs before group is started
       try {
         core.endGroup();
-      } catch {
+      } catch {}
-        // Group might not have been started, ignore
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      }
-      const errorMessage =
-        error instanceof Error ? error.message : "Unknown error";
       return {
         success: false,
         error: `Failed to execute Claude Code: ${errorMessage}`,
@@ -188,54 +167,36 @@ 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
+    const trimmedChunk = chunk.trim();
-    console.log(chunk);
+    if (trimmedChunk.startsWith("[DEBUG]") || trimmedChunk.startsWith("[debug]")) {
-    const parsedChunk = JSON.parse(chunk.trim());
+      console.log(chunk);
+      return;
+    }
+
+    if (trimmedChunk.startsWith("[ERROR]") || trimmedChunk.startsWith("[error]")) {
+      console.error(chunk);
+      return;
+    }
+
+    debugLog(trimmedChunk);
+
+    const parsedChunk = JSON.parse(trimmedChunk);
 
     switch (parsedChunk.type) {
       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
@@ -248,48 +209,38 @@ function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
                   ? `${parsedChunk.slash_commands.length} commands`
                   : "none",
               ],
-            ]),
+            ])
           );
         }
         break;
 
       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(
+                core.info(boxString(content.text.trim(), { title: "Claude Code" }));
-                  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}`);
                 }
@@ -318,7 +269,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) => {
@@ -328,19 +278,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}`);
             }
           }
         }
@@ -353,9 +298,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.
               }
             }
           }
@@ -364,27 +306,14 @@ 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`],
               ["Turns", parsedChunk.num_turns || 1],
-            ]),
+            ])
           );
         } else {
           core.error(`❌ Failed: ${parsedChunk.error || "Unknown error"}`);
@@ -392,12 +321,11 @@ function processJSONChunk(chunk: string, agent?: ClaudeAgent): void {
         break;
 
       default:
-        // Log unknown chunk types for debugging
+        debugLog(`📦 Unknown chunk type: ${parsedChunk.type}`);
-        core.debug(`📦 Unknown chunk type: ${parsedChunk.type}`);
         break;
     }
   } catch (error) {
-    core.debug(`Failed to parse chunk: ${error}`);
+    debugLog(`Failed to parse chunk: ${error}`);
-    core.debug(`Raw chunk: ${chunk.substring(0, 200)}...`);
+    debugLog(`Raw chunk: ${chunk.substring(0, 200)}...`);
   }
 }

agents/index.ts

@@ -1,2 +0,0 @@
-export * from "./claude";
-export * from "./types";

agents/shared.ts

@@ -0,0 +1,8 @@
+import { mcpServerName } from "../mcp/config.ts";
+
+export const instructions = `- use the ${mcpServerName} MCP server to interact with github
+- if ${mcpServerName} is not available or doesn't include the functionality you need, describe why and bail
+- do not under any circumstances use the gh cli
+- if prompted by a comment to respond to create a new issue, pr or anything else, after succeeding,
+    also respond to the original comment with a very brief message containing a link to it
+`;

agents/types.ts

@@ -29,6 +29,6 @@ export interface AgentResult {
  * Configuration for agent creation
  */
 export interface AgentConfig {
-  apiKey?: string;
+  apiKey: string;
-  [key: string]: any;
+  githubInstallationToken: string;
 }

entry.ts

@@ -2,54 +2,34 @@
 
 /**
  * Entry point for GitHub Action
- * This file is bundled to entry.cjs and called directly by GitHub Actions
  */
 
 import * as core from "@actions/core";
-import { main } from "./main";
+import { type } from "arktype";
+import { Inputs, main } from "./main.ts";
+import packageJson from "./package.json" with { type: "json" };
 
 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 anthropicApiKey = core.getInput("anthropic_api_key", {
-      required: true,
-    });
 
-    if (!anthropicApiKey) {
+    const inputsJson = process.env.INPUTS_JSON;
-      throw new Error("anthropic_api_key is required");
+    if (!inputsJson) {
+      throw new Error("INPUTS_JSON environment variable not found");
     }
 
-    if (!prompt) {
+    const parsed = type("string.json.parse").assert(inputsJson);
-      throw new Error("prompt is required");
+    const inputs = Inputs.assert(parsed);
-    }
 
-    // Create params object
+    const result = await main(inputs);
-    const params = {
-      prompt,
-      anthropicApiKey,
-    };
-
-    // Run the main function
-    const result = await main(params);
-
-    // Set outputs
-    core.setOutput("status", result.success ? "success" : "failed");
-    core.setOutput("prompt", prompt);
-    core.setOutput("output", result.output || "");
 
     if (!result.success) {
       throw new Error(result.error || "Agent execution failed");
     }
   } catch (error) {
-    const errorMessage =
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-      error instanceof Error ? error.message : "Unknown error occurred";
     core.setFailed(`Action failed: ${errorMessage}`);
   }
 }
 
-// Run the action
+await run();
-run().catch((error) => {
-  console.error("Action failed:", error);
-  process.exit(1);
-});

esbuild.config.js

@@ -1,16 +0,0 @@
-import { build } from "esbuild";
-
-// Build the GitHub Action bundle only
-// For npm package builds, use zshy (pnpm build:npm)
-await build({
-  entryPoints: ["./entry.ts"],
-  bundle: true,
-  outfile: "./entry.cjs",
-  format: "cjs",
-  platform: "node",
-  target: "node20",
-  minify: false,
-  sourcemap: false,
-});
-
-console.log("✅ Build completed successfully!");

fixtures/basic.ts

@@ -1,7 +1,9 @@
-import type { MainParams } from "../main";
+import type { Inputs } from "../main.ts";
 
 const testParams = {
-  prompt: "List all files in the current directory, then create a file called dynamic-test.txt with the content 'This was loaded from a TypeScript file!', then delete it."
+  prompt:
-} satisfies MainParams;
+    "List all files in the current directory, then create a file called dynamic-test.txt with the content 'This was loaded from a TypeScript file!', then delete it.",
+  anthropic_api_key: "sk-test-key",
+} satisfies Inputs;
 
 export default testParams;

fixtures/basic.txt

@@ -1 +1 @@
-Print the list of tools available. Then create a new file called test.txt with the content "Hello from Pullfrog!".
+create a PR implementing bogosort to https://github.com/pullfrogai/scratch/

index.ts

@@ -3,6 +3,10 @@
  * This exports the main function for programmatic usage
  */
 
-export { main } from "./main";
+export { ClaudeAgent } from "./agents/claude.ts";
-export { ClaudeAgent } from "./agents";
+export type { Agent, AgentConfig, AgentResult } from "./agents/types.ts";
-export type { Agent, AgentConfig, AgentResult } from "./agents/types";
+export {
+  type Inputs as ExecutionInputs,
+  type MainResult,
+  main,
+} from "./main.ts";

main.ts

@@ -1,10 +1,15 @@
 import * as core from "@actions/core";
-import { ClaudeAgent } from "./agents";
+import { type } from "arktype";
+import { ClaudeAgent } from "./agents/claude.ts";
+import { setupGitHubInstallationToken, parseRepoContext } from "./utils/github.ts";
+import { setupGitConfig, setupGitAuth } from "./utils/setup.ts";
 
-export interface MainParams {
+export const Inputs = type({
-  prompt: string;
+  prompt: "string",
-  anthropicApiKey?: string;
+  "anthropic_api_key?": "string | undefined",
-}
+});
+
+export type Inputs = typeof Inputs.infer;
 
 export interface MainResult {
   success: boolean;
@@ -12,24 +17,25 @@ export interface MainResult {
   error?: string | undefined;
 }
 
-export async function main(params: MainParams): Promise<MainResult> {
+export async function main(inputs: Inputs): Promise<MainResult> {
   try {
-    // Use provided API key or fall back to environment variable
-    const anthropicApiKey =
-      params.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
-
-    if (!anthropicApiKey) {
-      throw new Error("anthropic_api_key is required");
-    }
-
     core.info(`→ Starting agent run with Claude Code`);
 
-    // Create and install the Claude agent
+    setupGitConfig();
-    const agent = new ClaudeAgent({ apiKey: anthropicApiKey });
+
+    const githubInstallationToken = await setupGitHubInstallationToken();
+    const repoContext = parseRepoContext();
+    
+    setupGitAuth(githubInstallationToken, repoContext);
+
+    const agent = new ClaudeAgent({
+      apiKey: inputs.anthropic_api_key!,
+      githubInstallationToken,
+    });
+
     await agent.install();
 
-    // Execute the agent with the prompt
+    const result = await agent.execute(inputs.prompt);
-    const result = await agent.execute(params.prompt);
 
     if (!result.success) {
       return {
@@ -44,8 +50,7 @@ export async function main(params: MainParams): Promise<MainResult> {
       output: result.output || "",
     };
   } catch (error) {
-    const errorMessage =
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-      error instanceof Error ? error.message : "Unknown error occurred";
     return {
       success: false,
       error: errorMessage,

mcp/comment.ts

@@ -0,0 +1,28 @@
+import { type } from "arktype";
+import { contextualize, tool } from "./shared.ts";
+
+export const Comment = type({
+  issueNumber: type.number.describe("the issue number to comment on"),
+  body: type.string.describe("the comment body content"),
+});
+
+export const CommentTool = tool({
+  name: "create_issue_comment",
+  description: "Create a comment on a GitHub issue",
+  parameters: Comment,
+  execute: contextualize(async ({ issueNumber, body }, ctx) => {
+    const result = await ctx.octokit.rest.issues.createComment({
+      owner: ctx.owner,
+      repo: ctx.name,
+      issue_number: issueNumber,
+      body: body,
+    });
+
+    return {
+      success: true,
+      commentId: result.data.id,
+      url: result.data.html_url,
+      body: result.data.body,
+    };
+  }),
+});

mcp/config.ts

@@ -0,0 +1,32 @@
+/**
+ * Simple MCP configuration helper for adding our minimal GitHub comment server
+ */
+import { fromHere } from "@ark/fs";
+import { parseRepoContext } from "../utils/github.ts";
+
+const actionPath = fromHere("..");
+
+export const mcpServerName = "gh-pullfrog";
+
+export function createMcpConfig(githubInstallationToken: string) {
+  const repoContext = parseRepoContext();
+  const githubRepository = `${repoContext.owner}/${repoContext.name}`;
+
+  return JSON.stringify(
+    {
+      mcpServers: {
+        [mcpServerName]: {
+          command: "node",
+          args: [`${actionPath}/mcp/server.ts`],
+          env: {
+            GITHUB_INSTALLATION_TOKEN: githubInstallationToken,
+            GITHUB_REPOSITORY: githubRepository,
+            LOG_LEVEL: process.env.LOG_LEVEL,
+          },
+        },
+      },
+    },
+    null,
+    2
+  );
+}

mcp/issue.ts

@@ -0,0 +1,42 @@
+import { type } from "arktype";
+import { contextualize, tool } from "./shared.ts";
+
+export const Issue = type({
+  title: type.string.describe("the title of the issue"),
+  body: type.string.describe("the body content of the issue"),
+  labels: type.string
+    .array()
+    .describe("optional array of label names to apply to the issue")
+    .optional(),
+  assignees: type.string
+    .array()
+    .describe("optional array of usernames to assign to the issue")
+    .optional(),
+});
+
+export const IssueTool = tool({
+  name: "create_issue",
+  description: "Create a new GitHub issue",
+  parameters: Issue,
+  execute: contextualize(async ({ title, body, labels, assignees }, ctx) => {
+    const result = await ctx.octokit.rest.issues.create({
+      owner: ctx.owner,
+      repo: ctx.name,
+      title: title,
+      body: body,
+      labels: labels ?? [],
+      assignees: assignees ?? [],
+    });
+
+    return {
+      success: true,
+      issueId: result.data.id,
+      number: result.data.number,
+      url: result.data.html_url,
+      title: result.data.title,
+      state: result.data.state,
+      labels: result.data.labels?.map((label) => (typeof label === "string" ? label : label.name)),
+      assignees: result.data.assignees?.map((assignee) => assignee.login),
+    };
+  }),
+});

mcp/pr.ts

@@ -0,0 +1,42 @@
+import { execSync } from "node:child_process";
+import { type } from "arktype";
+import { contextualize, tool } from "./shared.ts";
+
+export const PullRequest = type({
+  title: type.string.describe("the title of the pull request"),
+  body: type.string.describe("the body content of the pull request"),
+  base: type.string.describe("the base branch to merge into (e.g., 'main')"),
+});
+
+export const PullRequestTool = tool({
+  name: "create_pull_request",
+  description: "Create a pull request from the current branch",
+  parameters: PullRequest,
+  execute: contextualize(async ({ title, body, base }, ctx) => {
+    // Get the current branch name
+    const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf8",
+    }).trim();
+
+    console.log(`Current branch: ${currentBranch}`);
+
+    const result = await ctx.octokit.rest.pulls.create({
+      owner: ctx.owner,
+      repo: ctx.name,
+      title: title,
+      body: body,
+      head: currentBranch,
+      base: base,
+    });
+
+    return {
+      success: true,
+      pullRequestId: result.data.id,
+      number: result.data.number,
+      url: result.data.html_url,
+      title: result.data.title,
+      head: result.data.head.ref,
+      base: result.data.base.ref,
+    };
+  }),
+});

mcp/server.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// Minimal GitHub Issue Comment MCP Server
+import { FastMCP } from "fastmcp";
+import { CommentTool } from "./comment.ts";
+import { IssueTool } from "./issue.ts";
+import { PullRequestTool } from "./pr.ts";
+import { addTools } from "./shared.ts";
+
+const server = new FastMCP({
+  name: "gh-pullfrog",
+  version: "0.0.1",
+});
+
+addTools(server, [CommentTool, IssueTool, PullRequestTool]);
+
+server.start();

mcp/shared.ts

@@ -0,0 +1,76 @@
+import { cached } from "@ark/util";
+import { Octokit } from "@octokit/rest";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { FastMCP, Tool } from "fastmcp";
+import { parseRepoContext, type RepoContext } from "../utils/github.ts";
+
+export interface ToolResult {
+  content: {
+    type: "text";
+    text: string;
+  }[];
+  isError?: boolean;
+}
+
+export const getMcpContext = cached((): McpContext => {
+  const githubInstallationToken = process.env.GITHUB_INSTALLATION_TOKEN;
+  if (!githubInstallationToken) {
+    throw new Error("GITHUB_INSTALLATION_TOKEN environment variable is required");
+  }
+
+  return {
+    ...parseRepoContext(),
+    octokit: new Octokit({
+      auth: githubInstallationToken,
+    }),
+  };
+});
+
+export interface McpContext extends RepoContext {
+  octokit: Octokit;
+}
+
+export const tool = <const params>(tool: Tool<any, StandardSchemaV1<params>>) => tool;
+
+export const addTools = (server: FastMCP, tools: Tool<any, any>[]) => {
+  for (const tool of tools) {
+    server.addTool(tool);
+  }
+  return server;
+};
+
+export const contextualize =
+  <T>(executor: (params: T, ctx: McpContext) => Promise<Record<string, any>>) =>
+  async (params: T): Promise<ToolResult> => {
+    try {
+      const ctx = getMcpContext();
+      const result = await executor(params, ctx);
+      return handleToolSuccess(result);
+    } catch (error) {
+      return handleToolError(error);
+    }
+  };
+
+const handleToolSuccess = (data: Record<string, any>): ToolResult => {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2),
+      },
+    ],
+  };
+};
+
+const handleToolError = (error: unknown): ToolResult => {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: ${errorMessage}`,
+      },
+    ],
+    isError: true,
+  };
+};

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pullfrog/action",
-  "version": "0.0.7",
+  "version": "0.0.60",
   "type": "module",
   "files": [
     "index.js",
@@ -12,30 +12,30 @@
     "main.js",
     "main.d.ts"
   ],
-  "directories": {
-    "example": "examples"
-  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "node esbuild.config.js",
+    "typecheck": "tsc --noEmit",
-    "build:npm": "zshy",
+    "play": "node play.ts",
-    "build:dev": "node esbuild.config.js",
+    "upDeps": "pnpm up --latest",
-    "prepare": "husky",
+    "lock": "pnpm --ignore-workspace install"
-    "play": "tsx --env-file=../.env play.ts"
   },
   "dependencies": {
-    "@actions/core": "^1.10.1",
+    "@actions/core": "^1.11.1",
+    "@ark/fs": "0.50.0",
+    "@ark/util": "0.50.0",
+    "@octokit/rest": "^22.0.0",
+    "@octokit/webhooks-types": "^7.6.1",
+    "@standard-schema/spec": "1.0.0",
+    "arktype": "^2.1.23",
+    "dotenv": "^17.2.3",
     "execa": "^9.6.0",
+    "fastmcp": "^3.20.0",
     "table": "^6.9.0"
   },
   "devDependencies": {
-    "@types/node": "^20.10.0",
+    "@types/node": "^24.7.2",
-    "commander": "^14.0.0",
+    "arg": "^5.0.2",
-    "dotenv": "^17.2.2",
+    "typescript": "^5.9.3"
-    "esbuild": "^0.25.9",
-    "husky": "^9.0.0",
-    "typescript": "^5.3.0",
-    "zshy": "^0.4.1"
   },
   "repository": {
     "type": "git",
@@ -43,7 +43,7 @@
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/pullfrog/action/issues"
   },

play.ts

@@ -1,191 +1,160 @@
-#!/usr/bin/env tsx
+import { existsSync, readFileSync } from "node:fs";
+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 { type Inputs, main } from "./main.ts";
+import packageJson from "./package.json" with { type: "json" };
+import { runAct } from "./utils/act.ts";
+import { setupTestRepo } from "./utils/setup.ts";
 
-import { execSync } from "node:child_process";
+config();
-import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve, extname } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { Command } from "commander";
-import { main } from "./main";
-import { runAct } from "./utils/act";
 
-const __filename = fileURLToPath(import.meta.url);
+export async function run(
-const __dirname = dirname(__filename);
+  prompt: string,
-
+  options: { act?: boolean } = {}
-async function loadPrompt(filePath: string): Promise<string> {
+): Promise<{ success: boolean; output?: string | undefined; error?: string | undefined }> {
-  const ext = extname(filePath).toLowerCase();
+  try {
-
+    console.log(`🐸 Running pullfrog/action@${packageJson.version}...`);
-  // Try to resolve the file path
+    if (options.act) {
-  let resolvedPath: string;
+      console.log("🐳 Running with Docker/act...");
-
+      runAct(prompt);
-  // First try as fixtures path
+      return { success: true };
-  const fixturesPath = join(__dirname, "fixtures", filePath);
-  if (existsSync(fixturesPath)) {
-    resolvedPath = fixturesPath;
-  } else if (existsSync(filePath)) {
-    resolvedPath = resolve(filePath);
-  } else {
-    throw new Error(`File not found: ${filePath}`);
-  }
-
-  switch (ext) {
-    case ".txt": {
-      // Plain text - pass directly as prompt
-      return readFileSync(resolvedPath, "utf8").trim();
     }
 
-    case ".json": {
+    const tempDir = join(process.cwd(), ".temp");
-      // JSON - stringify and pass as prompt
+    setupTestRepo({ tempDir, forceClean: true });
-      const content = readFileSync(resolvedPath, "utf8");
+
-      const parsed = JSON.parse(content);
+    const originalCwd = process.cwd();
-      return JSON.stringify(parsed, null, 2);
+    process.chdir(tempDir);
+
+    console.log("🚀 Running action with prompt...");
+    console.log("─".repeat(50));
+    console.log("Prompt:");
+    console.log(prompt);
+    console.log("─".repeat(50));
+
+    const inputs: Inputs = {
+      prompt,
+      anthropic_api_key: process.env.ANTHROPIC_API_KEY,
+    };
+
+    const result = await main(inputs);
+
+    process.chdir(originalCwd);
+
+    if (result.success) {
+      console.log("✅ Action completed successfully");
+      if (result.output) {
+        console.log("Output:", result.output);
+      }
+      return { success: true, output: result.output || undefined, error: undefined };
+    } else {
+      console.error("❌ Action failed:", result.error);
+      return { success: false, error: result.error || undefined, output: undefined };
     }
-
+  } catch (error) {
-    case ".ts": {
+    const errorMessage = (error as Error).message;
-      // TypeScript - dynamic import and stringify default export
+    console.error("❌ Error:", errorMessage);
-      const fileUrl = pathToFileURL(resolvedPath).href;
+    return { success: false, error: errorMessage, output: undefined };
-      const module = await import(fileUrl);
-
-      if (!module.default) {
-        throw new Error(
-          `TypeScript file ${filePath} must have a default export`,
-        );
-      }
-
-      // If it's a string, use it directly
-      if (typeof module.default === "string") {
-        return module.default;
-      }
-
-      // If it's a MainParams object with a prompt field, extract the prompt
-      if (typeof module.default === "object" && module.default.prompt) {
-        return module.default.prompt;
-      }
-
-      // Otherwise stringify it
-      return JSON.stringify(module.default, null, 2);
-    }
-
-    default:
-      throw new Error(
-        `Unsupported file type: ${ext}. Supported types: .txt, .json, .ts`,
-      );
   }
 }
 
-async function runPlay(
+if (import.meta.url === `file://${process.argv[1]}`) {
-  filePath: string,
+  const args = arg({
-  options: { act?: boolean },
+    "--help": Boolean,
-): Promise<void> {
+    "--act": Boolean,
-  try {
+    "--raw": String,
-    // Load the prompt from the specified file
+    "-h": "--help",
-    const prompt = await loadPrompt(filePath);
+  });
 
-    if (options.act) {
+  if (args["--help"]) {
-      // Use Docker/act to run the action
+    console.log(`
-      console.log("🐳 Running with Docker/act...");
+Usage: tsx play.ts [file] [options]
-      runAct(prompt);
+
+Test the Pullfrog action with various prompts.
+
+Arguments:
+  file                    Prompt file to use (.txt, .json, or .ts) [default: fixtures/basic.txt]
+
+Options:
+  --act                   Use Docker/act to run the action instead of running directly
+  --raw [prompt]          Use raw string as prompt instead of loading from file
+  -h, --help              Show this help message
+
+Examples:
+  tsx play.ts                        # Use default fixture
+  tsx play.ts fixtures/basic.txt     # Use specific text file
+  tsx play.ts custom.json            # Use JSON file
+  tsx play.ts --act fixtures/test.ts # Use TypeScript file with Docker/act
+  tsx play.ts --raw "Hello world"    # Use raw string as prompt
+    `);
+    process.exit(0);
+  }
+
+  let prompt: string;
+
+  if (args["--raw"]) {
+    prompt = args["--raw"];
+  } else {
+    const filePath = args._[0] || "fixtures/basic.txt";
+    const ext = extname(filePath).toLowerCase();
+    let resolvedPath: string;
+
+    const fixturesPath = fromHere("fixtures", filePath);
+    if (existsSync(fixturesPath)) {
+      resolvedPath = fixturesPath;
+    } else if (existsSync(filePath)) {
+      resolvedPath = resolve(filePath);
     } else {
-      // Clone the test repository and run directly
+      throw new Error(`File not found: ${filePath}`);
-      const tempDir = join(process.cwd(), ".temp");
+    }
-      const repoUrl = "git@github.com:pullfrogai/scratch.git";
 
-      // Remove existing temp directory if it exists
+    switch (ext) {
-      if (existsSync(tempDir)) {
+      case ".txt": {
-        console.log("🗑️  Removing existing .temp directory...");
+        prompt = readFileSync(resolvedPath, "utf8").trim();
-        rmSync(tempDir, { recursive: true, force: true });
+        break;
       }
 
-      // Clone the repository
+      case ".json": {
-      console.log("📦 Cloning pullfrogai/scratch into .temp...");
+        const content = readFileSync(resolvedPath, "utf8");
-      execSync(`git clone ${repoUrl} ${tempDir}`, { stdio: "inherit" });
+        const parsed = JSON.parse(content);
+        prompt = JSON.stringify(parsed, null, 2);
+        break;
+      }
 
-      // List of environment variables to copy to .temp
+      case ".ts": {
-      const envVarsToCopy = [
+        const fileUrl = pathToFileURL(resolvedPath).href;
-        "ANTHROPIC_API_KEY",
+        const module = await import(fileUrl);
-        "GITHUB_TOKEN",
-        // Add more environment variables here as needed
-      ];
 
-      // Build .env content from the list
+        if (!module.default) {
-      const envLines = envVarsToCopy
+          throw new Error(`TypeScript file ${filePath} must have a default export`);
-        .map((varName) => `${varName}=${process.env[varName] || ""}`)
-        .join("\n");
-
-      const envPath = join(tempDir, ".env");
-      writeFileSync(envPath, envLines + "\n");
-      console.log("📝 Created .env file in .temp directory with:");
-
-      let hasRequiredVars = true;
-      envVarsToCopy.forEach((varName) => {
-        const hasValue = !!process.env[varName];
-        console.log(`   - ${varName}: ${hasValue ? "✓" : "✗ (missing)"}`);
-
-        // Check for required variables
-        if (varName === "ANTHROPIC_API_KEY" && !hasValue) {
-          hasRequiredVars = false;
         }
-      });
 
-      if (!hasRequiredVars) {
+        if (typeof module.default === "string") {
-        console.warn("\n⚠️  Warning: ANTHROPIC_API_KEY is not set or empty.");
+          prompt = module.default;
-        console.warn(
+        } else if (typeof module.default === "object" && module.default.prompt) {
-          "   Please ensure you have a valid API key in your .env file.",
+          prompt = module.default.prompt;
-        );
+        } else {
-        console.warn(
+          prompt = JSON.stringify(module.default, null, 2);
-          "   Get your API key from: https://console.anthropic.com/api-keys\n",
-        );
-      }
-
-      // Change to the temp directory
-      process.chdir(tempDir);
-
-      console.log("🚀 Running test in .temp directory...");
-      console.log("─".repeat(50));
-      console.log(`Prompt from ${filePath}:`);
-      console.log(prompt);
-      console.log("─".repeat(50));
-
-      // Run main with the params object
-      const result = await main({ prompt });
-
-      if (result.success) {
-        console.log("✅ Test completed successfully");
-        if (result.output) {
-          console.log("Output:", result.output);
         }
-      } else {
+        break;
-        console.error("❌ Test failed:", result.error);
-        process.exit(1);
       }
+
+      default:
+        throw new Error(`Unsupported file type: ${ext}. Supported types: .txt, .json, .ts`);
+    }
+  }
+
+  try {
+    const result = await run(prompt, { act: args["--act"] || false });
+
+    if (!result.success) {
+      process.exit(1);
     }
   } catch (error) {
     console.error("❌ Error:", (error as Error).message);
     process.exit(1);
   }
 }
-
-// Set up CLI
-const program = new Command();
-
-program
-  .name("play")
-  .description("Test the Pullfrog action with various prompts")
-  .version("1.0.0")
-  .argument(
-    "[file]",
-    "Prompt file to use (.txt, .json, or .ts)",
-    "fixtures/basic.txt",
-  )
-  .option(
-    "--act",
-    "Use Docker/act to run the action instead of running directly",
-  )
-  .action(async (file: string, options: { act?: boolean }) => {
-    await runPlay(file, options);
-  });
-
-// Parse arguments and run
-program.parseAsync(process.argv).catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
-});

tsconfig.json

@@ -1,45 +1,23 @@
 {
-  // Visit https://aka.ms/tsconfig to read more about this file
   "compilerOptions": {
-    // File Layout
-    // "rootDir": "./src",
     "outDir": "./dist",
-
+    "module": "NodeNext",
-    // Environment Settings
+	"target": "ESNext",
-    // See also https://aka.ms/tsconfig/module
+	"moduleResolution": "NodeNext",
-    "module": "esnext",
+	"lib": ["ESNext"],
-    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
-    "target": "esnext",
+	"rewriteRelativeImportExtensions": true,
-    "types": [],
+	"skipLibCheck": true,
-    // For nodejs:
+	"strict": true,
-    // "lib": ["esnext"],
+	"noUncheckedSideEffectImports": true,
-    // "types": ["node"],
+	"declaration": true,
-    // and npm install -D @types/node
+	"verbatimModuleSyntax": true,
-
+	"esModuleInterop": true,
-    // Other Outputs
+	"resolveJsonModule": true,
-    "sourceMap": true,
+	"exactOptionalPropertyTypes": true,
-    "declaration": true,
+	"forceConsistentCasingInFileNames": true,
-    "declarationMap": true,
+	"stripInternal": true,
-
-    // Stricter Typechecking Options
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
-
-    // Style Options
-    // "noImplicitReturns": true,
-    // "noImplicitOverride": true,
-    // "noUnusedLocals": true,
-    // "noUnusedParameters": true,
-    // "noFallthroughCasesInSwitch": true,
-    // "noPropertyAccessFromIndexSignature": true,
-
-    // Recommended Options
-    "strict": true,
-    "jsx": "react-jsx",
-    "verbatimModuleSyntax": true,
-    "isolatedModules": true,
-    "noUncheckedSideEffectImports": true,
     "moduleDetection": "force",
-    "skipLibCheck": true
+	"useUnknownInCatchVariables": true
   }
 }

utils/act.ts

@@ -1,61 +1,30 @@
 import { execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { config, parse } from "dotenv";
+import { config } from "dotenv";
+import { setupTestRepo } from "./setup.ts";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+const tempDir = join(__dirname, "..", ".temp");
+const actionPath = join(__dirname, "..");
+const envPath = join(__dirname, "..", "..", ".env");
+
+const ENV_VARS = ["ANTHROPIC_API_KEY", "GITHUB_INSTALLATION_TOKEN"];
+
 export function runAct(prompt: string): void {
-  // First, ensure the scratch repo is cloned
+  setupTestRepo({ tempDir });
-  const tempDir = join(__dirname, "..", ".temp");
 
-  // Check if .temp exists and either reset it or clone it
-  if (existsSync(tempDir)) {
-    console.log("📦 Resetting existing .temp repository...");
-    execSync("git reset --hard HEAD && git clean -fd", {
-      cwd: tempDir,
-      stdio: "inherit",
-    });
-  } else {
-    console.log("📦 Cloning pullfrogai/scratch into .temp...");
-    const repoUrl = "git@github.com:pullfrogai/scratch.git";
-    execSync(`git clone ${repoUrl} ${tempDir}`, { stdio: "inherit" });
-  }
-
-  const workflowPath = join(tempDir, ".github", "workflows", "pullfrog.yml");
-  const envPath = join(__dirname, "..", "..", ".env");
-
-  // Load environment variables into process
   config({ path: envPath });
 
-  // Parse environment variables from .env file to get keys
+  const workflowPath = join(tempDir, ".github", "workflows", "pullfrog.yml");
-  let envVars: string[] = [];
-  try {
-    const content = readFileSync(envPath, "utf8");
-    const parsed = parse(content);
-    envVars = Object.keys(parsed);
-  } catch (error) {
-    console.warn(
-      `Warning: Could not read .env file: ${(error as Error).message}`,
-    );
-  }
 
-  // Build fresh bundles with esbuild
-  const actionPath = join(__dirname, "..");
-  console.log("🔨 Building fresh bundles with esbuild...");
-  execSync("node esbuild.config.js", {
-    cwd: actionPath,
-    stdio: "inherit",
-  });
-
-  // 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: true });
+  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)) {
@@ -64,8 +33,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 = [
@@ -79,9 +46,10 @@ export function runAct(prompt: string): void {
       `pullfrog/action@v0=${distPath}`, // Use minimal dist without symlinks
     ];
 
-    // Add all environment variables as secrets (without values)
+    ENV_VARS.forEach((key) => {
-    envVars.forEach((key) => {
+      if (process.env[key]) {
-      actCommandParts.push("-s", key);
+        actCommandParts.push("-s", key);
+      }
     });
 
     const actCommand = actCommandParts.join(" ");
@@ -92,15 +60,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

@@ -0,0 +1,273 @@
+import { createSign } from "node:crypto";
+import * as core from "@actions/core";
+
+export interface InstallationToken {
+  token: string;
+  expires_at: string;
+  installation_id: number;
+  repository: string;
+  ref: string;
+  runner_environment: string;
+  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 = parseRepoContext();
+
+  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> {
+  const existingToken = checkExistingToken();
+  if (existingToken) {
+    core.setSecret(existingToken);
+    core.info("Using provided GitHub installation token");
+    return existingToken;
+  }
+
+  const token = await acquireNewToken();
+
+  core.setSecret(token);
+  process.env.GITHUB_INSTALLATION_TOKEN = token;
+
+  return token;
+}
+
+export interface RepoContext {
+  owner: string;
+  name: string;
+}
+
+/**
+ * Parse repository context from GITHUB_REPOSITORY environment variable.
+ */
+export function parseRepoContext(): 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/index.ts

@@ -1,3 +0,0 @@
-export * from "./files";
-export * from "./subprocess";
-export * from "./table";

utils/logging.ts

@@ -0,0 +1,30 @@
+/**
+ * Centralized debug logging utility
+ * Controls debug behavior based on LOG_LEVEL environment variable
+ */
+
+import * as core from "@actions/core";
+
+const isDebugEnabled = process.env.LOG_LEVEL === "debug";
+const isGitHubActions = !!process.env.GITHUB_ACTIONS;
+
+/**
+ * Check if debug logging is enabled
+ */
+export function isDebug(): boolean {
+  return isDebugEnabled;
+}
+
+/**
+ * Log debug message if debug is enabled
+ * Uses core.debug() in GitHub Actions, console.log() locally
+ */
+export function debugLog(message: string): void {
+  if (isDebugEnabled) {
+    if (isGitHubActions) {
+      core.debug(message);
+    } else {
+      console.log(`[DEBUG] ${message}`);
+    }
+  }
+}

utils/setup.ts

@@ -0,0 +1,68 @@
+import { execSync } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import type { RepoContext } from "./github.ts";
+
+export interface SetupOptions {
+  tempDir: string;
+  repoUrl?: string;
+  forceClean?: boolean;
+}
+
+/**
+ * Setup the test repository for running actions
+ */
+export function setupTestRepo(options: SetupOptions): void {
+  const {
+    tempDir,
+    repoUrl = "git@github.com:pullfrogai/scratch.git",
+    forceClean = false,
+  } = options;
+
+  if (existsSync(tempDir)) {
+    if (forceClean) {
+      console.log("🗑️  Removing existing .temp directory...");
+      rmSync(tempDir, { recursive: true, force: true });
+
+      console.log("📦 Cloning pullfrogai/scratch into .temp...");
+      execSync(`git clone ${repoUrl} ${tempDir}`, { stdio: "inherit" });
+    } else {
+      console.log("📦 Resetting existing .temp repository...");
+      execSync("git reset --hard HEAD && git clean -fd", {
+        cwd: tempDir,
+        stdio: "inherit",
+      });
+    }
+  } else {
+    console.log("📦 Cloning pullfrogai/scratch into .temp...");
+    execSync(`git clone ${repoUrl} ${tempDir}`, { stdio: "inherit" });
+  }
+}
+
+/**
+ * Setup git configuration to avoid identity errors
+ */
+export function setupGitConfig(): void {
+  console.log("🔧 Setting up git configuration...");
+  execSync('git config user.email "action@pullfrog.ai"', { stdio: "inherit" });
+  execSync('git config user.name "Pullfrog Action"', { stdio: "inherit" });
+}
+
+/**
+ * Setup git authentication using GitHub token
+ */
+export function setupGitAuth(githubToken: string, repoContext: RepoContext): void {
+  console.log("🔐 Setting up git authentication...");
+
+  // Remove existing git auth headers that actions/checkout might have set
+  try {
+    execSync("git config --unset-all http.https://github.com/.extraheader", { stdio: "inherit" });
+    console.log("✓ Removed existing authentication headers");
+  } catch {
+    console.log("No existing authentication headers to remove");
+  }
+
+  // Update remote URL to embed the token
+  const remoteUrl = `https://x-access-token:${githubToken}@github.com/${repoContext.owner}/${repoContext.name}.git`;
+  execSync(`git remote set-url origin "${remoteUrl}"`, { stdio: "inherit" });
+  console.log("✓ Updated remote URL with authentication token");
+}

utils/subprocess.ts

@@ -6,6 +6,7 @@ export interface SpawnOptions {
   env?: Record<string, string>;
   input?: string;
   timeout?: number;
+  cwd?: string;
   onStdout?: (chunk: string) => void;
   onStderr?: (chunk: string) => void;
 }
@@ -21,20 +22,19 @@ export interface SpawnResult {
  * Spawn a subprocess with streaming callbacks and buffered results
  */
 export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
-  const { cmd, args, env, input, timeout, onStdout, onStderr } = options;
+  const { cmd, args, env, input, timeout, cwd, onStdout, onStderr } = options;
 
   const startTime = Date.now();
   let stdoutBuffer = "";
   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"],
+      cwd: cwd || process.cwd(),
     });
 
-    // Set up timeout if specified
     let timeoutId: NodeJS.Timeout | undefined;
     let isTimedOut = false;
 
@@ -43,7 +43,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 +51,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 +59,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 +67,6 @@ export async function spawn(options: SpawnOptions): Promise<SpawnResult> {
       });
     }
 
-    // Handle process completion
     child.on("close", (exitCode) => {
       const durationMs = Date.now() - startTime;
 
@@ -91,15 +87,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 +102,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) {
+  if (title) {
-    rows.unshift([options.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);
-// }