testchimp-runner-core 0.0.26 → 0.0.29

package/src/index.ts

@@ -10,9 +10,9 @@ import { ScenarioWorker } from './scenario-worker-class';
 import { PlaywrightMCPService } from './playwright-mcp-service';
 import { LLMFacade } from './llm-facade';
 import { AuthConfig } from './auth-config';
-import { CreditUsageService } from './credit-usage-service';
+import { CreditUsageService, CreditUsageCallback, CreditUsage, CreditUsageReason } from './credit-usage-service';
 
-export { ExecutionService, ScenarioService, ScenarioWorker, PlaywrightMCPService, LLMFacade, CreditUsageService };
+export { ExecutionService, ScenarioService, ScenarioWorker, PlaywrightMCPService, LLMFacade, CreditUsageService, CreditUsageCallback, CreditUsage, CreditUsageReason };
 
 // File handlers
 import { FileHandler, LocalFileHandler, CIFileHandler, NoOpFileHandler } from './file-handler';
@@ -20,12 +20,12 @@ export { FileHandler, LocalFileHandler, CIFileHandler, NoOpFileHandler };
 
 // LLM Provider interfaces
 import { LLMProvider, LLMRequest, LLMResponse } from './llm-provider';
-import { ProgressReporter, StepProgress, JobProgress, StepExecutionStatus } from './progress-reporter';
+import { ProgressReporter, StepProgress, JobProgress, StepExecutionStatus, StepInfo } from './progress-reporter';
 import { BackendProxyLLMProvider } from './providers/backend-proxy-llm-provider';
 import { LocalLLMProvider } from './providers/local-llm-provider';
 
 export { LLMProvider, LLMRequest, LLMResponse };
-export { ProgressReporter, StepProgress, JobProgress, StepExecutionStatus };
+export { ProgressReporter, StepProgress, JobProgress, StepExecutionStatus, StepInfo };
 export { BackendProxyLLMProvider, LocalLLMProvider };
 
 // Orchestrator (tool-using agent)
@@ -81,6 +81,7 @@ export class TestChimpService {
   private logger?: (message: string, level?: 'log' | 'error' | 'warn') => void;
   private orchestratorOptions?: { useOrchestrator?: boolean; orchestratorConfig?: Partial<AgentConfig>; debugMode?: boolean };
   private outputChannel?: any;  // Store outputChannel to preserve it across service recreations
+  private creditUsageCallback?: CreditUsageCallback;  // Store credit callback to preserve it across service recreations
 
   constructor(
     fileHandler?: FileHandler,
@@ -89,19 +90,22 @@ export class TestChimpService {
     maxWorkers?: number,
     llmProvider?: LLMProvider,
     progressReporter?: ProgressReporter,
-    orchestratorOptions?: { useOrchestrator?: boolean; orchestratorConfig?: Partial<AgentConfig>; debugMode?: boolean }
+    orchestratorOptions?: { useOrchestrator?: boolean; orchestratorConfig?: Partial<AgentConfig>; debugMode?: boolean },
+    creditUsageCallback?: CreditUsageCallback
   ) {
     this.fileHandler = fileHandler || new NoOpFileHandler();
     this.authConfig = authConfig || null;
     this.backendUrl = backendUrl || 'https://featureservice.testchimp.io'; // Default to production
     this.progressReporter = progressReporter;
     this.orchestratorOptions = orchestratorOptions;
+    this.creditUsageCallback = creditUsageCallback;
     
     // Use provided LLM provider or default to backend proxy (backward compatible)
     this.llmProvider = llmProvider || new BackendProxyLLMProvider(authConfig, backendUrl);
     
     this.playwrightService = new PlaywrightMCPService();
-    this.creditUsageService = new CreditUsageService(this.authConfig || undefined, this.backendUrl);
+    // Pass credit callback to constructor - preserved across recreations via this.creditUsageCallback
+    this.creditUsageService = new CreditUsageService(this.authConfig || undefined, this.backendUrl, this.creditUsageCallback);
     
     // Create services with providers
     this.executionService = new ExecutionService(
@@ -189,8 +193,8 @@ export class TestChimpService {
       this.llmProvider.setLogger?.(this.logger);
     }
     
-    // Recreate services with new provider
-    this.creditUsageService = new CreditUsageService(this.authConfig || undefined, this.backendUrl);
+    // Recreate services with new provider (preserve credit callback)
+    this.creditUsageService = new CreditUsageService(this.authConfig || undefined, this.backendUrl, this.creditUsageCallback);
     this.executionService = new ExecutionService(
       this.authConfig || undefined,
       this.backendUrl,
@@ -243,6 +247,16 @@ export class TestChimpService {
     }
   }
 
+  /**
+   * Set credit usage callback
+   * Server-side: Use callback to update DB directly (no axios calls)
+   * Client-side: Don't set callback, uses auth for axios calls to backend
+   */
+  setCreditUsageCallback(callback: CreditUsageCallback): void {
+    this.creditUsageCallback = callback;  // Store for future service recreations
+    this.creditUsageService.setCreditUsageCallback(callback);
+  }
+
   /**
    * Log a message using the configured logger
    */
@@ -271,8 +285,26 @@ export class TestChimpService {
   }
 
   // Scenario generation
-  async generateScript(scenario: string, testName?: string, config?: string, model?: string, scenarioFileName?: string): Promise<string> {
-    return this.scenarioService.processScenario(scenario, testName, config, model, scenarioFileName);
+  async generateScript(
+    scenario: string, 
+    testName?: string, 
+    config?: string, 
+    model?: string, 
+    scenarioFileName?: string,
+    existingBrowser?: any,
+    existingContext?: any,
+    existingPage?: any
+  ): Promise<string> {
+    return this.scenarioService.processScenario(
+      scenario, 
+      testName, 
+      config, 
+      model, 
+      scenarioFileName,
+      existingBrowser,
+      existingContext,
+      existingPage
+    );
   }
 
   // Test execution

package/src/progress-reporter.ts

@@ -66,6 +66,16 @@ export interface TokenUsage {
   timestamp: number;
 }
 
+/**
+ * Additional step info for lifecycle callbacks
+ */
+export interface StepInfo {
+  stepId?: string;
+  stepNumber: number;
+  description: string;
+  code?: string;
+}
+
 /**
  * Progress reporter interface for external consumers
  */
@@ -105,5 +115,30 @@ export interface ProgressReporter {
    * Generic logging (for environments that don't need structured progress)
    */
   log?(message: string, level?: 'log' | 'error' | 'warn'): void;
+  
+  /**
+   * LIFECYCLE CALLBACKS (optional - used by scriptservice, ignored by local clients)
+   */
+  
+  /**
+   * Called before test execution starts
+   * - Script Service: Initialize browser context, set up DB records
+   * - VS Extension/GitHub: Not used (ignore)
+   */
+  beforeStartTest?(page: any, browser: any, context: any): Promise<void>;
+  
+  /**
+   * Called before each step execution
+   * - Script Service: Update step status to IN_PROGRESS in DB
+   * - VS Extension/GitHub: Not used (ignore)
+   */
+  beforeStepStart?(step: StepInfo, page: any): Promise<void>;
+  
+  /**
+   * Called after test execution completes (success or failure)
+   * - Script Service: Write final status to DB, cleanup resources
+   * - VS Extension/GitHub: Not used (return value is sufficient)
+   */
+  afterEndTest?(status: 'passed' | 'failed', error?: string, page?: any): Promise<void>;
 }
 

package/src/prompts.ts

@@ -757,12 +757,13 @@ ${script}
 
 YOUR TASK (MINOR ADJUSTMENTS ONLY):
 1. Remove duplicate/redundant expect() assertions (e.g., same assertion repeated twice)
-2. Remove duplicate step comments without code
-3. Fix obvious formatting issues (inconsistent spacing, etc.)
-4. Consolidate multiple identical assertions into one
-5. Remove any obviously redundant waits or checks
+2. Fix obvious formatting issues (inconsistent spacing, etc.)
+3. Consolidate multiple identical assertions into one
+4. Remove any obviously redundant waits or checks
 
 DO NOT:
+- Remove the TestChimp header comment (/* This is a TestChimp Smart Test... */) - this must be preserved
+- Remove step comments (e.g., "// Step 1: ..." or "// Navigate to...") - these are important for readability
 - Change the test logic or flow
 - Remove legitimate assertions
 - Restructure the code

package/src/scenario-service.ts

@@ -111,16 +111,25 @@ export class ScenarioService extends EventEmitter {
     });
     
     this.workers.push(worker);
-    this.log(`Scenario worker initialized${this.useOrchestrator ? ' (Orchestrator Mode)' : ''} with session: ${worker['sessionId']}`);
+    // Internal initialization - no need to log worker details
   }
 
   async initialize(): Promise<void> {
     // Wait for workers to be initialized
     await this.initializeWorkers();
-    this.log('Scenario service initialized');
+    // Internal initialization - consumer doesn't need to see this
   }
 
-  processScenario(scenario: string, testName?: string, config?: PlaywrightConfig, model?: string, scenarioFileName?: string): string {
+  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
@@ -130,7 +139,10 @@ export class ScenarioService extends EventEmitter {
       testName,
       playwrightConfig: config,
       model,
-      scenarioFileName
+      scenarioFileName,
+      existingBrowser,
+      existingContext,
+      existingPage
     };
 
     this.jobQueue.push(job);

package/src/scenario-worker-class.ts

@@ -97,8 +97,6 @@ export class ScenarioWorker extends EventEmitter {
    * Initialize orchestrator mode with tools
    */
   private initializeOrchestrator(): void {
-    this.log('🤖 Initializing Orchestrator Mode');
-    
     // Create tool registry
     this.toolRegistry = new ToolRegistry();
     
@@ -135,12 +133,12 @@ export class ScenarioWorker extends EventEmitter {
       this.debugMode  // Pass debug mode
     );
     
-    this.log(`✓ Orchestrator initialized with 5 tools${this.debugMode ? ' (DEBUG MODE)' : ''} (information-gathering only)`);
+    // Minimal initialization logging - internal details not needed by consumer
   }
 
   private log(message: string): void {
-    const timestamp = new Date().toISOString().substring(11, 23); // HH:MM:SS.mmm
-    const formattedMessage = `[${timestamp}] [ScenarioWorker] ${message}`;
+    // Let consumer add timestamps - just report the raw message
+    const formattedMessage = `[ScenarioWorker] ${message}`;
     // Always log to console for debug visibility
     console.log(formattedMessage);
     // Also route to outputChannel if provided
@@ -150,8 +148,8 @@ export class ScenarioWorker extends EventEmitter {
   }
 
   private logError(message: string): void {
-    const timestamp = new Date().toISOString().substring(11, 23); // HH:MM:SS.mmm
-    const formattedMessage = `[${timestamp}] [ScenarioWorker] ERROR: ${message}`;
+    // Let consumer add timestamps - just report the raw message
+    const formattedMessage = `[ScenarioWorker] ERROR: ${message}`;
     // Always log to console for debug visibility
     console.error(formattedMessage);
     // Also route to outputChannel if provided
@@ -246,21 +244,16 @@ export class ScenarioWorker extends EventEmitter {
 
   async initialize(): Promise<void> {
     try {
-      const RUNNER_CORE_VERSION = "v1.5.0-vision-preserve-values";
-      this.log('═══════════════════════════════════════════════════════');
-      this.log(`🚀 RUNNER-CORE VERSION: ${RUNNER_CORE_VERSION}`);
-      this.log('═══════════════════════════════════════════════════════');
-      this.log('Initializing Scenario worker...');
       this.sessionId = `scenario_worker_${Date.now()}`;
       this.initialized = true;
-      this.log(`Scenario worker initialized with session: ${this.sessionId}`);
+      // Minimal initialization - consumer doesn't need to see internal details
     } catch (error) {
       this.logError(`Scenario worker initialization error: ${error}`);
       throw error;
     }
   }
 
-  async processScenarioJob(job: ScenarioJob): Promise<ScenarioResponse> {
+  async processScenarioJob(job: ScenarioRunJob): Promise<ScenarioResponse> {
     if (!this.initialized) {
       throw new Error('Scenario worker not initialized');
     }
@@ -268,9 +261,9 @@ export class ScenarioWorker extends EventEmitter {
     // Set current job ID for progress reporting
     this.currentJobId = job.id;
 
-    // VERSION MARKER - increment this number with each significant change
-    const RUNNER_CORE_VERSION = "v1.5.0-vision-preserve-values";
-    this.log(`🚀 RUNNER-CORE VERSION: ${RUNNER_CORE_VERSION}`);
+    // Log library version once (read from package.json)
+    const packageJson = require('../package.json');
+    this.log(`testchimp-runner-core v${packageJson.version}`);
     this.log(`📋 Processing scenario: ${job.scenario}`);
 
     const startTime = Date.now();
@@ -310,16 +303,30 @@ export class ScenarioWorker extends EventEmitter {
       }
       this.emit('log', job.id, `\n## Execution Progress\n\n`);
 
-      // 2. Start a new browser session using centralized utility
-      // Default to headed mode (headless: false) for better debugging
-      // Create logger function from outputChannel for browser initialization
-      const logger = this.outputChannel ? (message: string, level?: 'log' | 'error' | 'warn') => {
-        this.outputChannel!.appendLine(`[Browser] ${message}`);
-      } : undefined;
-      const browserInstance = await initializeBrowser(job.playwrightConfig, false, undefined, logger);
-      browser = browserInstance.browser;
-      context = browserInstance.context;
-      page = browserInstance.page;
+      // 2. Start a new browser session or use existing one
+      if (job.existingBrowser && job.existingContext && job.existingPage) {
+        // Use existing browser provided by caller (e.g., scriptservice)
+        this.log('Using existing browser/page provided by caller');
+        browser = job.existingBrowser;
+        context = job.existingContext;
+        page = job.existingPage;
+      } else {
+        // Create new browser (default behavior for local clients)
+        // Default to headed mode (headless: false) for better debugging
+        // Create logger function from outputChannel for browser initialization
+        const logger = this.outputChannel ? (message: string, level?: 'log' | 'error' | 'warn') => {
+          this.outputChannel!.appendLine(`[Browser] ${message}`);
+        } : undefined;
+        const browserInstance = await initializeBrowser(job.playwrightConfig, false, undefined, logger);
+        browser = browserInstance.browser;
+        context = browserInstance.context;
+        page = browserInstance.page;
+      }
+      
+      // LIFECYCLE: Call beforeStartTest if provided
+      if (this.progressReporter?.beforeStartTest) {
+        await this.progressReporter.beforeStartTest(page, browser, context);
+      }
       
         // Set reasonable timeout for most operations
         // 5 seconds for element interactions (fast feedback on wrong selectors)
@@ -367,6 +374,17 @@ export class ScenarioWorker extends EventEmitter {
           step.stepNumber = i + 1;
           
           try {
+            // LIFECYCLE: Call beforeStepStart if provided
+            if (this.progressReporter?.beforeStepStart) {
+              await this.progressReporter.beforeStepStart(
+                {
+                  stepNumber: step.stepNumber,
+                  description: step.description
+                },
+                page
+              );
+            }
+            
             // Use orchestrator to execute this step
             const result = await this.orchestratorAgent.executeStep(
               page,
@@ -405,6 +423,18 @@ export class ScenarioWorker extends EventEmitter {
               }
             }
             
+            // REPORT FINAL STEP RESULT (after orchestrator completes all iterations)
+            // This gives the complete accumulated commands, not just one iteration
+            await this.reportStepProgress({
+              jobId: job.id,
+              stepNumber: step.stepNumber,
+              description: step.description,
+              code: step.playwrightCommands?.join('\n') || '',  // All accumulated commands
+              status: step.success ? StepExecutionStatus.SUCCESS : StepExecutionStatus.FAILURE,
+              error: step.error,
+              agentIteration: result.iterations
+            });
+            
           } catch (error: any) {
             this.logError(`Orchestrator execution failed for step ${step.stepNumber}: ${error.message}`);
             step.success = false;
@@ -858,7 +888,17 @@ export class ScenarioWorker extends EventEmitter {
       }
 
       // Generate clean script with TestChimp comment and code
+      this.log(`[ScenarioWorker] Generating script from ${steps.length} steps`);
+      steps.forEach((s, i) => {
+        this.log(`[ScenarioWorker]   Step ${i+1}: ${s.description}`);
+        this.log(`[ScenarioWorker]     Commands: ${s.playwrightCommands?.length || 0}`);
+        if (s.playwrightCommands && s.playwrightCommands.length > 0) {
+          this.log(`[ScenarioWorker]     First command: ${s.playwrightCommands[0]}`);
+        }
+      });
+      
       generatedScript = generateTestScript(testName, steps, undefined, hashtags);
+      this.log(`[ScenarioWorker] Generated script length: ${generatedScript.length}`);
 
       // Perform final cleanup pass to remove redundancies and make minor adjustments
       this.log(`[ScenarioWorker] Performing final script cleanup...`);
@@ -931,6 +971,15 @@ export class ScenarioWorker extends EventEmitter {
       
       const executionLog = logLines.join('\n');
 
+      // Report job completion
+      await this.reportJobProgress({
+        jobId: job.id,
+        status: overallSuccess ? 'completed' : 'failed',
+        testName,
+        script: generatedScript,
+        error: overallSuccess ? undefined : 'Some steps failed during execution'
+      });
+
       return {
         success: overallSuccess,
         steps,
@@ -944,6 +993,16 @@ export class ScenarioWorker extends EventEmitter {
     } catch (error: any) {
       overallSuccess = false;
       this.logError(`Overall scenario processing error: ${error}`);
+      
+      // Report job failure
+      await this.reportJobProgress({
+        jobId: job.id,
+        status: 'failed',
+        testName: job.testName || 'test',
+        script: generatedScript,
+        error: error instanceof Error ? error.message : 'Unknown error during scenario processing'
+      });
+      
       return {
         success: false,
         steps,
@@ -955,7 +1014,22 @@ export class ScenarioWorker extends EventEmitter {
         error: error instanceof Error ? error.message : 'Unknown error during scenario processing'
       };
     } finally {
-      if (browser) {
+      // LIFECYCLE: Call afterEndTest if provided
+      if (browser && this.progressReporter?.afterEndTest) {
+        try {
+          await this.progressReporter.afterEndTest(
+            overallSuccess ? 'passed' : 'failed',
+            overallSuccess ? undefined : 'Test execution had failures',
+            page
+          );
+        } catch (callbackError) {
+          this.log(`afterEndTest callback failed: ${callbackError}`);
+        }
+      }
+      
+      // Only close browser if we created it (not provided by caller)
+      const usingExternalBrowser = !!(job.existingBrowser && job.existingContext && job.existingPage);
+      if (browser && !usingExternalBrowser) {
         await browser.close();
       }
     }

package/src/types.ts

@@ -83,6 +83,11 @@ export interface ScenarioRunJob {
   playwrightConfig?: PlaywrightConfig;
   model?: string;
   scenarioFileName?: string;
+  
+  // Optional: Provide existing browser/page/context (for server-side usage)
+  existingBrowser?: any;
+  existingContext?: any;
+  existingPage?: any;
 }
 
 /**
@@ -139,6 +144,11 @@ export interface ScenarioJob {
   config?: PlaywrightConfig;
   resolve: (result: ScenarioResponse) => void;
   reject: (error: Error) => void;
+  
+  // Optional: Provide existing browser/page/context (for server-side usage)
+  existingBrowser?: any;
+  existingContext?: any;
+  existingPage?: any;
 }
 
 // ============================================================================
@@ -166,6 +176,12 @@ export interface ScriptExecutionRequest {
   model?: string;
   headless?: boolean; // defaults to false (headed)
   deflake_run_count?: number; // defaults to 1
+  
+  // Optional: Provide existing browser/page/context (for server-side usage)
+  // If not provided, runner-core will create its own
+  existingBrowser?: any; // Browser instance
+  existingContext?: any; // BrowserContext instance
+  existingPage?: any; // Page instance
 }
 
 /**