testchimp-runner-core 0.0.35 → 0.0.36

package/src/providers/backend-proxy-llm-provider.ts

@@ -1,91 +0,0 @@
-/**
- * Backend Proxy LLM Provider
- * Calls backend proxy API with authentication
- * Used by VS Extension and GitHub Runner
- */
-
-import axios from 'axios';
-import { LLMProvider, LLMRequest, LLMResponse } from '../llm-provider';
-import { AuthConfig, getAuthHeaders } from '../auth-config';
-
-/**
- * Default LLM provider that calls backend proxy
- * Converts camelCase requests to snake_case for backend API
- */
-export class BackendProxyLLMProvider implements LLMProvider {
-  private authConfig?: AuthConfig;
-  private backendUrl: string;
-  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
-
-  constructor(authConfig?: AuthConfig, backendUrl?: string) {
-    this.authConfig = authConfig;
-    this.backendUrl = backendUrl || 'https://featureservice.testchimp.io';
-  }
-
-  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
-    this.logger = logger;
-  }
-
-  async callLLM(request: LLMRequest): Promise<LLMResponse> {
-    if (!this.authConfig) {
-      throw new Error('Authentication required for backend proxy LLM provider');
-    }
-
-    const headers = getAuthHeaders(this.authConfig);
-    
-    // Convert camelCase to snake_case for backend API (proto format)
-    const backendRequest = {
-      model: request.model,
-      system_prompt: request.systemPrompt,
-      user_prompt: request.userPrompt,
-      image_url: request.imageUrl
-    };
-    
-    const url = `${this.backendUrl}/localagent/call_llm`;
-    
-    try {
-      const response = await axios.post(
-        url,
-        backendRequest,
-        { headers, timeout: 300000 }
-      );
-      
-      // Calculate token usage (heuristic: 4 chars = 1 token)
-      const inputText = `${request.systemPrompt || ''}\n${request.userPrompt || ''}`;
-      const inputTokens = Math.ceil(inputText.length / 4);
-      
-      // Add image tokens if present (for vision models)
-      let imageTokens = 0;
-      if (request.imageUrl) {
-        imageTokens = this.estimateImageTokens(request.imageUrl);
-      }
-      
-      const outputTokens = Math.ceil((response.data.answer || '').length / 4);
-      
-      return { 
-        answer: response.data.answer,
-        usage: {
-          inputTokens: inputTokens + imageTokens,
-          outputTokens
-        }
-      };
-    } catch (error: any) {
-      this.logger?.(`LLM call failed: ${error}`, 'error');
-      throw error;
-    }
-  }
-  
-  /**
-   * Estimate image token cost based on dimensions
-   * For gpt-4.1-mini: patches × 1.62, capped at 1536
-   */
-  private estimateImageTokens(imageDataUrl: string): number {
-    // For simplicity, estimate common screenshot sizes
-    // Viewport (1920x1080): ~1452 tokens (after multiplier and cap)
-    // Full page (1920x3000+): ~1536 tokens (capped)
-    
-    // Conservative estimate: assume viewport screenshot
-    return 1500;  // ~1452-1536 tokens for typical screenshot
-  }
-}
-

package/src/providers/local-llm-provider.ts

@@ -1,38 +0,0 @@
-/**
- * Local LLM Provider
- * Calls LLM directly via callback (not via backend proxy)
- * For future use by Script Service (Phase 2)
- */
-
-import { LLMProvider, LLMRequest, LLMResponse } from '../llm-provider';
-
-/**
- * Local LLM provider that calls LLM directly via callback
- * Allows Script Service to use its own OpenAI integration
- */
-export class LocalLLMProvider implements LLMProvider {
-  private llmCallback: (request: LLMRequest) => Promise<string>;
-  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
-
-  /**
-   * @param llmCallback Function that calls LLM (provided by environment)
-   */
-  constructor(llmCallback: (request: LLMRequest) => Promise<string>) {
-    this.llmCallback = llmCallback;
-  }
-
-  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
-    this.logger = logger;
-  }
-
-  async callLLM(request: LLMRequest): Promise<LLMResponse> {
-    try {
-      const answer = await this.llmCallback(request);
-      return { answer };
-    } catch (error) {
-      this.logger?.(`Local LLM call failed: ${error}`, 'error');
-      throw error;
-    }
-  }
-}
-

package/src/scenario-service.ts

@@ -1,252 +0,0 @@
-import { EventEmitter } from 'events';
-import dotenv from 'dotenv';
-import { ScenarioJob, ScenarioRunJob, ScenarioResponse, PlaywrightConfig } from './types';
-import { ScenarioWorker } from './scenario-worker-class';
-import { FileHandler, NoOpFileHandler } from './file-handler';
-import { AuthConfig } from './auth-config';
-import { CreditUsageService } from './credit-usage-service';
-import { LLMProvider } from './llm-provider';
-import { ProgressReporter } from './progress-reporter';
-import { AgentConfig } from './orchestrator';
-
-// Load environment variables
-dotenv.config();
-
-/**
- * Service for processing scenarios using LLM + Playwright
- */
-export class ScenarioService extends EventEmitter {
-  private workers: ScenarioWorker[] = [];
-  private jobQueue: ScenarioRunJob[] = [];
-  private busyWorkers: Set<ScenarioWorker> = new Set();
-  private maxWorkers: number;
-  private fileHandler: FileHandler;
-  private authConfig: AuthConfig | null;
-  private backendUrl?: string;
-  private creditUsageService: CreditUsageService;
-  private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
-  private llmProvider?: LLMProvider;
-  private progressReporter?: ProgressReporter;
-  private useOrchestrator: boolean;
-  private orchestratorConfig?: Partial<AgentConfig>;
-  private debugMode: boolean;
-  private outputChannel?: any;  // VS Code OutputChannel type
-
-  constructor(
-    maxWorkers: number = 2,
-    fileHandler?: FileHandler,
-    llmProvider?: LLMProvider,
-    progressReporter?: ProgressReporter,
-    authConfig?: AuthConfig,
-    backendUrl?: string,
-    options?: {
-      useOrchestrator?: boolean;
-      orchestratorConfig?: Partial<AgentConfig>;
-      debugMode?: boolean;
-    }
-  ) {
-    super();
-    this.maxWorkers = maxWorkers;
-    this.fileHandler = fileHandler || new NoOpFileHandler();
-    this.llmProvider = llmProvider;
-    this.progressReporter = progressReporter;
-    this.authConfig = authConfig || null;
-    this.backendUrl = backendUrl;
-    this.creditUsageService = new CreditUsageService(authConfig, backendUrl);
-    this.useOrchestrator = options?.useOrchestrator || false;
-    this.orchestratorConfig = options?.orchestratorConfig;
-    this.debugMode = options?.debugMode || false;
-  }
-
-  /**
-   * Set a logger callback for capturing execution logs
-   */
-  setLogger(logger: (message: string, level?: 'log' | 'error' | 'warn') => void): void {
-    this.logger = logger;
-  }
-  
-  /**
-   * Set output channel for worker logs (VS Code OutputChannel)
-   */
-  setOutputChannel(outputChannel: any): void {
-    this.outputChannel = outputChannel;
-  }
-
-  /**
-   * Log a message using the configured logger
-   */
-  private log(message: string, level: 'log' | 'error' | 'warn' = 'log'): void {
-    if (this.logger) {
-      this.logger(message, level);
-    }
-    // No console fallback - logs are routed to consumer
-  }
-
-  private async initializeWorkers(): Promise<void> {
-    for (let i = 0; i < this.maxWorkers; i++) {
-      await this.createWorker();
-    }
-  }
-
-  private async createWorker(): Promise<void> {
-    // Pass providers and orchestrator options to worker
-    const worker = new ScenarioWorker(
-      this.fileHandler,
-      this.llmProvider,
-      this.progressReporter,
-      this.authConfig || undefined,
-      this.backendUrl,
-      {
-        useOrchestrator: this.useOrchestrator,
-        orchestratorConfig: this.orchestratorConfig,
-        debugMode: this.debugMode
-      },
-      this.outputChannel  // Pass outputChannel for log routing
-    );
-    await worker.initialize();
-    
-    // Forward log events from worker to service listeners
-    worker.on('log', (jobId: string, message: string) => {
-      this.emit('jobLog', jobId, message);
-    });
-    
-    this.workers.push(worker);
-    // Internal initialization - no need to log worker details
-  }
-
-  async initialize(): Promise<void> {
-    // Wait for workers to be initialized
-    await this.initializeWorkers();
-    // Internal initialization - consumer doesn't need to see this
-  }
-
-  processScenario(
-    scenario: string, 
-    testName?: string, 
-    config?: PlaywrightConfig, 
-    model?: string, 
-    scenarioFileName?: string,
-    existingBrowser?: any,
-    existingContext?: any,
-    existingPage?: any
-  ): string {
-    const jobId = `scenario_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    
-    // Add job to queue
-    const job: ScenarioRunJob = {
-      id: jobId,
-      scenario,
-      testName,
-      playwrightConfig: config,
-      model,
-      scenarioFileName,
-      existingBrowser,
-      existingContext,
-      existingPage
-    };
-
-    this.jobQueue.push(job);
-    this.processNextJob();
-    
-    return jobId; // Return job ID for tracking
-  }
-
-  private async processNextJob(): Promise<void> {
-    if (this.jobQueue.length === 0) {
-      return;
-    }
-
-    this.log(`[ScenarioService] Processing next job. Queue length: ${this.jobQueue.length}, Workers: ${this.workers.length}, Busy workers: ${this.busyWorkers.size}`);
-
-    // Find available worker (proper load balancing)
-    const availableWorker = this.workers.find(worker => !this.busyWorkers.has(worker));
-    if (!availableWorker) {
-      this.log('[ScenarioService] No available workers, waiting...');
-      return; // All workers busy, wait for one to become available
-    }
-
-    const job = this.jobQueue.shift();
-    if (!job) {
-      return;
-    }
-
-    this.log(`[ScenarioService] Processing job ${job.id} with worker`);
-
-    // Mark worker as busy
-    this.busyWorkers.add(availableWorker);
-    
-    try {
-      // Process job directly with worker
-      const result = await availableWorker.processScenarioJob(job);
-      this.log(`[ScenarioService] Job ${job.id} completed with result: ${JSON.stringify(result)}`);
-      this.handleJobResult(job.id, result);
-    } catch (error) {
-      this.log(`Error processing job with worker: ${error}`, 'error');
-      this.emit('jobError', job.id, error);
-      // Put job back in queue if it failed
-      this.jobQueue.unshift(job);
-    } finally {
-      // Mark worker as available again
-      this.busyWorkers.delete(availableWorker);
-      // Process next job
-      this.processNextJob();
-    }
-  }
-
-  private handleJobResult(jobId: string, result: ScenarioResponse): void {
-    // Report credit usage for successful script generation
-    if (result.success) {
-      this.creditUsageService.reportScriptGenerationCredit(jobId).catch(error => {
-        this.log(`Failed to report credit usage for script generation (job: ${jobId}): ${error}`, 'warn');
-      });
-    }
-    
-    // Emit result event
-    this.emit('jobComplete', jobId, result);
-    
-    // Mark worker as available and process next job
-    this.busyWorkers.clear(); // Simple approach - clear all busy workers
-    this.processNextJob();
-  }
-
-  private handleJobError(jobId: string, error: string): void {
-    // Emit error event
-    this.emit('jobError', jobId, new Error(error));
-    
-    // Mark worker as available and process next job
-    this.busyWorkers.clear(); // Simple approach - clear all busy workers
-    this.processNextJob();
-  }
-
-  /**
-   * Execute exploration mode using orchestrator
-   * Requires orchestrator to be enabled via useOrchestrator option
-   */
-  async executeExploration(page: any, explorationConfig: any, jobId: string): Promise<any> {
-    if (!this.useOrchestrator) {
-      throw new Error('Exploration mode requires orchestrator to be enabled');
-    }
-    
-    // Get an available worker (or create one if needed)
-    let worker = this.workers.find(w => !this.busyWorkers.has(w));
-    if (!worker) {
-      await this.createWorker();
-      worker = this.workers[this.workers.length - 1];
-    }
-    
-    // Execute exploration via worker's orchestrator
-    return worker.executeExploration(page, explorationConfig, jobId);
-  }
-
-  async shutdown(): Promise<void> {
-    this.log('Shutting down scenario service...');
-    
-    // Cleanup all workers
-    const cleanupPromises = this.workers.map(worker => worker.cleanup());
-    await Promise.all(cleanupPromises);
-    
-    this.workers = [];
-    this.busyWorkers.clear();
-    this.log('Scenario service shutdown complete');
-  }
-}