@browsercash/chase 1.0.0

package/dist/index.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { loadConfig } from './config.js';
+import { runClaudeForScriptGeneration } from './claude-runner.js';
+import { runIterativeTest } from './iterative-tester.js';
+import { writeScript } from './codegen/bash-generator.js';
+import * as path from 'path';
+async function main() {
+    // Parse command line arguments
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+        printHelp();
+        process.exit(0);
+    }
+    // Extract options
+    const outputIndex = args.findIndex(a => a === '--output' || a === '-o');
+    let customOutput;
+    if (outputIndex !== -1 && args[outputIndex + 1]) {
+        customOutput = args[outputIndex + 1];
+    }
+    const skipRun = args.includes('--skip-run');
+    // Get the task prompt (everything that's not a flag)
+    const taskPrompt = args
+        .filter((a, i) => {
+        if (a.startsWith('--') || a.startsWith('-'))
+            return false;
+        if (outputIndex !== -1 && i === outputIndex + 1)
+            return false;
+        return true;
+    })
+        .join(' ');
+    if (!taskPrompt) {
+        console.error('Error: Please provide a task description');
+        console.error('Usage: npx claude-gen "Your task description"');
+        process.exit(1);
+    }
+    try {
+        // Load configuration with task for validation threshold inference
+        const config = loadConfig(taskPrompt);
+        console.log('');
+        console.log('='.repeat(60));
+        console.log('  Claude-Gen: Browser Automation Script Generator');
+        console.log('='.repeat(60));
+        console.log('');
+        console.log(`Task: ${taskPrompt}`);
+        console.log(`Model: ${config.model}`);
+        console.log(`CDP URL: ${config.cdpUrl.substring(0, 50)}...`);
+        console.log('');
+        // Run Claude Code to generate the script
+        console.log('[claude-gen] Running Claude Code to generate script...');
+        console.log('-'.repeat(60));
+        const result = await runClaudeForScriptGeneration(taskPrompt, config);
+        console.log('-'.repeat(60));
+        if (!result.success || !result.script) {
+            console.error(`\n[claude-gen] Failed to generate script`);
+            if (result.error) {
+                console.error(`[claude-gen] Error: ${result.error}`);
+            }
+            if (!result.script) {
+                console.error('[claude-gen] Could not extract a valid script from Claude\'s output.');
+                console.error('[claude-gen] Make sure Claude outputs a bash script in a code block.');
+            }
+            process.exit(1);
+        }
+        console.log(`\n[claude-gen] Successfully generated script`);
+        // Show a preview of the script
+        const scriptLines = result.script.split('\n');
+        const previewLines = scriptLines.slice(0, 15);
+        console.log('\n[claude-gen] Script preview:');
+        console.log('---');
+        previewLines.forEach(line => console.log(`  ${line}`));
+        if (scriptLines.length > 15) {
+            console.log(`  ... (${scriptLines.length - 15} more lines)`);
+        }
+        console.log('---');
+        let finalScriptPath;
+        let testResult = null;
+        if (!skipRun) {
+            // Run iterative testing: test script, fix if needed, repeat
+            const iterResult = await runIterativeTest(result.script, taskPrompt, config, customOutput);
+            finalScriptPath = iterResult.finalScriptPath;
+            testResult = {
+                success: iterResult.success,
+                iterations: iterResult.iterations,
+                skippedDueToStaleCdp: iterResult.skippedDueToStaleCdp,
+            };
+            if (iterResult.success) {
+                console.log(`\n[claude-gen] Script passed after ${iterResult.iterations} iteration(s)!`);
+            }
+            else if (iterResult.skippedDueToStaleCdp) {
+                console.log(`\n[claude-gen] Testing skipped - CDP connection unavailable.`);
+                console.log(`[claude-gen] Script was generated but needs testing with a fresh CDP_URL.`);
+            }
+            else {
+                console.log(`\n[claude-gen] Script did not pass after ${iterResult.iterations} attempts.`);
+                if (iterResult.lastError) {
+                    console.log(`[claude-gen] Last error: ${iterResult.lastError.substring(0, 300)}...`);
+                }
+            }
+        }
+        else {
+            // Skip testing, just write the script
+            finalScriptPath = writeScript(result.script, {
+                cdpUrl: config.cdpUrl,
+                outputDir: config.outputDir,
+                filename: customOutput,
+            });
+            console.log(`\n[claude-gen] Generated script (testing skipped): ${finalScriptPath}`);
+        }
+        // Final output
+        console.log('\n' + '='.repeat(60));
+        if (testResult?.success) {
+            console.log('  Script generated and validated successfully!');
+        }
+        else if (testResult?.skippedDueToStaleCdp) {
+            console.log('  Script generated (testing skipped - CDP unavailable)');
+        }
+        else if (testResult) {
+            console.log('  Script generated (validation failed after ' + testResult.iterations + ' attempts)');
+        }
+        else {
+            console.log('  Script generated successfully!');
+        }
+        console.log('='.repeat(60));
+        console.log('');
+        console.log(`Script location: ${path.resolve(finalScriptPath)}`);
+        console.log('');
+        console.log('To run the script:');
+        console.log(`  ${finalScriptPath}`);
+        console.log('');
+        console.log('Or with a custom CDP URL:');
+        console.log(`  CDP_URL="wss://..." ${finalScriptPath}`);
+        console.log('');
+    }
+    catch (error) {
+        console.error('\nFatal error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+function printHelp() {
+    console.log(`
+Claude-Gen: Browser Automation Script Generator
+
+Generate repeatable bash scripts from natural language prompts using
+Claude Code + agent-browser CLI.
+
+Usage:
+  npx claude-gen "Your task description"
+
+Examples:
+  npx claude-gen "Go to example.com and get the page title"
+  npx claude-gen "Search for 'laptop' on amazon.com and list the first 5 results"
+  npx claude-gen "Go to canadagoose.com and extract details of all mens parkas"
+
+Options:
+  --output, -o <name>   Custom output filename (without .sh extension)
+  --skip-run            Skip automatic script validation
+  --help, -h            Show this help message
+
+Environment Variables:
+  CDP_URL               WebSocket URL for browser connection (required)
+  MODEL                 Claude model to use (default: claude-opus-4-5-20251101)
+  MAX_TURNS             Max Claude turns (default: 15)
+  OUTPUT_DIR            Directory for generated scripts (default: ./generated)
+  SESSIONS_DIR          Directory for session logs (default: ./sessions)
+  MAX_FIX_ITERATIONS    Max attempts to fix failing scripts (default: 5)
+  FIX_TIMEOUT           Timeout for script execution in ms (default: 300000)
+  FIX_REQUEST_TIMEOUT   Timeout for Claude fix requests in ms (default: 300000)
+
+How it works:
+  1. Your prompt is sent to Claude Code with agent-browser instructions
+  2. Claude uses snapshots to understand the page structure
+  3. Claude outputs a complete bash script using replay-safe patterns
+  4. The script is tested and iteratively fixed if needed
+  5. Final script uses only: open, eval, scroll, sleep (no @eN refs)
+
+Note: Ensure 'agent-browser' and 'claude' CLIs are installed globally.
+`);
+}
+main();

package/dist/iterative-tester.js

@@ -0,0 +1,407 @@
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { writeScript, normalizeScriptCdp } from './codegen/bash-generator.js';
+import { runScript, formatErrorOutput, checkCdpConnectivity } from './script-runner.js';
+import { getFixPrompt, parseFixedScript } from './prompts/fix-prompt.js';
+import { createIterationHistory, addAttemptToHistory, } from './types/iteration-history.js';
+/**
+ * Run iterative testing loop: test script, if fails ask Claude to fix, repeat
+ */
+export async function runIterativeTest(scriptContent, originalTask, config, customOutput) {
+    const maxIterations = config.maxFixIterations;
+    console.log(`\n[claude-gen] Starting iterative testing (max ${maxIterations} attempts)...`);
+    // Normalize the script's CDP references
+    let normalizedScript = normalizeScriptCdp(scriptContent, config.cdpUrl);
+    // Check CDP connectivity before starting
+    console.log(`[claude-gen] Checking CDP connectivity...`);
+    const cdpCheck = await checkCdpConnectivity(config.cdpUrl);
+    if (!cdpCheck.connected) {
+        console.log(`[claude-gen] WARNING: CDP connection appears stale or unavailable.`);
+        console.log(`[claude-gen] Error: ${cdpCheck.error}`);
+        console.log(`[claude-gen] Skipping iterative testing - you'll need to test with a fresh CDP_URL.`);
+        // Write script anyway but skip testing
+        const scriptPath = writeScript(normalizedScript, {
+            cdpUrl: config.cdpUrl,
+            outputDir: config.outputDir,
+            filename: customOutput,
+        });
+        return {
+            success: false,
+            iterations: 0,
+            finalScriptPath: scriptPath,
+            scriptContent: normalizedScript,
+            lastError: `CDP connection unavailable: ${cdpCheck.error}`,
+            skippedDueToStaleCdp: true,
+        };
+    }
+    console.log(`[claude-gen] CDP connection OK`);
+    // Write initial script
+    let scriptPath = writeScript(normalizedScript, {
+        cdpUrl: config.cdpUrl,
+        outputDir: config.outputDir,
+        filename: customOutput,
+    });
+    let currentScript = normalizedScript;
+    let lastResult = null;
+    // Initialize iteration history for tracking what was tried
+    const history = createIterationHistory(originalTask);
+    for (let iteration = 1; iteration <= maxIterations; iteration++) {
+        console.log(`\n[claude-gen] Iteration ${iteration}/${maxIterations}: Testing script...`);
+        // Re-check CDP connectivity before each iteration
+        const iterationCdpCheck = await checkCdpConnectivity(config.cdpUrl);
+        if (!iterationCdpCheck.connected) {
+            console.log(`[claude-gen] CDP connection became unavailable during testing.`);
+            console.log(`[claude-gen] Returning current script - test with a fresh CDP_URL.`);
+            return {
+                success: false,
+                iterations: iteration - 1,
+                finalScriptPath: scriptPath,
+                scriptContent: currentScript,
+                lastError: `CDP connection lost: ${iterationCdpCheck.error}`,
+                skippedDueToStaleCdp: true,
+            };
+        }
+        // Run the script
+        const result = await runScript(scriptPath, config.cdpUrl, config.fixTimeout, originalTask);
+        lastResult = result;
+        // Validate data quality even if script "succeeded"
+        const dataValidation = validateExtractedData(result.stdout || '', originalTask, config);
+        if (result.success && dataValidation.valid) {
+            console.log(`[claude-gen] Script passed on iteration ${iteration}!`);
+            return {
+                success: true,
+                iterations: iteration,
+                finalScriptPath: scriptPath,
+                scriptContent: currentScript,
+            };
+        }
+        // Script failed or has data quality issues
+        let errorOutput = formatErrorOutput(result);
+        // Include validation issues in error output
+        if (!dataValidation.valid) {
+            const validationError = `[DATA QUALITY ISSUES]\n${dataValidation.issues.join('\n')}\n\n`;
+            errorOutput = validationError + errorOutput;
+            console.log(`[claude-gen] Data quality issues on iteration ${iteration}:`);
+            dataValidation.issues.forEach(issue => console.log(`  - ${issue}`));
+        }
+        else {
+            console.log(`[claude-gen] Script failed on iteration ${iteration}`);
+            console.log(`[claude-gen] Error: ${errorOutput.substring(0, 300)}...`);
+        }
+        // If this was the last iteration, don't try to fix
+        if (iteration === maxIterations) {
+            console.log(`[claude-gen] Max iterations reached. Returning last attempt.`);
+            break;
+        }
+        // Add this attempt to history before asking for fix
+        addAttemptToHistory(history, iteration, currentScript, errorOutput);
+        // Ask Claude to fix the script with retry for syntax errors
+        console.log(`[claude-gen] Asking Claude to fix the script...`);
+        const maxSyntaxRetries = 2;
+        let fixedScript = null;
+        let syntaxRetryError = '';
+        for (let syntaxRetry = 0; syntaxRetry <= maxSyntaxRetries; syntaxRetry++) {
+            // Include syntax error from previous retry in the error output
+            const errorWithSyntax = syntaxRetryError
+                ? `[SYNTAX ERROR IN YOUR PREVIOUS FIX]\n${syntaxRetryError}\n\nPlease fix the bash syntax error and try again.\n\n${errorOutput}`
+                : errorOutput;
+            const attemptedFix = await askClaudeToFix(originalTask, currentScript, errorWithSyntax, result.failedLineNumber, config, history);
+            if (!attemptedFix) {
+                console.log(`[claude-gen] Could not parse fixed script from Claude's response.`);
+                break;
+            }
+            // Validate bash syntax
+            const syntaxError = await validateBashSyntax(attemptedFix);
+            if (!syntaxError) {
+                // Syntax is valid
+                fixedScript = attemptedFix;
+                break;
+            }
+            // Syntax error - retry with error feedback
+            syntaxRetryError = syntaxError;
+            console.log(`[claude-gen] Fixed script has syntax error (retry ${syntaxRetry + 1}/${maxSyntaxRetries}): ${syntaxError}`);
+            if (syntaxRetry < maxSyntaxRetries) {
+                console.log(`[claude-gen] Asking Claude to fix the syntax error...`);
+            }
+        }
+        if (!fixedScript) {
+            console.log(`[claude-gen] Could not get a syntactically valid fix. Continuing with current script.`);
+            continue;
+        }
+        // Update script content and file
+        currentScript = fixedScript;
+        // Generate new filename for the fixed version
+        const fixedFilename = customOutput
+            ? `${customOutput.replace('.sh', '')}-fix${iteration}.sh`
+            : `script-fix${iteration}-${Date.now()}.sh`;
+        scriptPath = path.join(config.outputDir, fixedFilename);
+        fs.writeFileSync(scriptPath, currentScript);
+        fs.chmodSync(scriptPath, '755');
+        console.log(`[claude-gen] Updated script: ${scriptPath}`);
+    }
+    // Return last attempt even if failed
+    return {
+        success: false,
+        iterations: maxIterations,
+        finalScriptPath: scriptPath,
+        scriptContent: currentScript,
+        lastError: lastResult ? formatErrorOutput(lastResult) : undefined,
+    };
+}
+/**
+ * Ask Claude to fix a failing script
+ */
+async function askClaudeToFix(originalTask, scriptContent, errorOutput, failedLineNumber, config, history) {
+    const fixPrompt = getFixPrompt(originalTask, scriptContent, errorOutput, failedLineNumber, config.cdpUrl, history);
+    // Write prompt to temp file
+    const promptFile = `/tmp/claude-gen-fix-prompt-${Date.now()}.txt`;
+    fs.writeFileSync(promptFile, fixPrompt);
+    return new Promise((resolve) => {
+        let output = '';
+        let resolved = false;
+        const cleanup = (promptPath) => {
+            try {
+                fs.unlinkSync(promptPath);
+            }
+            catch {
+                // Ignore
+            }
+        };
+        const safeResolve = (value) => {
+            if (!resolved) {
+                resolved = true;
+                clearTimeout(timeoutId);
+                resolve(value);
+            }
+        };
+        // Call Claude to fix the script - allow Bash so it can inspect the DOM
+        const shellCmd = `cat "${promptFile}" | claude -p --model ${config.model} --max-turns 5 --allowedTools "Bash" --output-format stream-json --verbose`;
+        const claude = spawn('bash', ['-c', shellCmd], {
+            env: { ...process.env, CDP_URL: config.cdpUrl },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        claude.stdout?.on('data', (data) => {
+            output += data.toString();
+        });
+        claude.stderr?.on('data', (data) => {
+            process.stderr.write(`[fix] ${data.toString()}`);
+        });
+        claude.on('close', (code) => {
+            cleanup(promptFile);
+            if (code !== 0) {
+                console.log(`[claude-gen] Claude fix request failed with code ${code}`);
+                safeResolve(null);
+                return;
+            }
+            // Extract text from stream-json format
+            const textContent = extractTextFromStreamJson(output);
+            // Debug: log if we got no text content
+            if (!textContent || textContent.trim().length < 50) {
+                console.log(`[claude-gen] Warning: Fix response appears empty or too short (${textContent?.length || 0} chars)`);
+            }
+            // Parse the fixed script from Claude's response
+            const fixedScript = parseFixedScript(textContent);
+            // Debug: log if parsing failed
+            if (!fixedScript && textContent && textContent.length > 100) {
+                console.log(`[claude-gen] Warning: Could not parse script from response. Response preview:`);
+                console.log(`[claude-gen]   ${textContent.substring(0, 200).replace(/\n/g, '\\n')}...`);
+            }
+            safeResolve(fixedScript);
+        });
+        claude.on('error', (err) => {
+            cleanup(promptFile);
+            console.log(`[claude-gen] Claude fix request error: ${err.message}`);
+            safeResolve(null);
+        });
+        // Timeout for fix request
+        const fixRequestTimeout = config.fixRequestTimeout;
+        const timeoutId = setTimeout(() => {
+            claude.kill();
+            cleanup(promptFile);
+            console.log(`[claude-gen] Fix request timed out after ${fixRequestTimeout / 1000}s`);
+            safeResolve(null);
+        }, fixRequestTimeout);
+    });
+}
+/**
+ * Validate bash script syntax without executing it
+ */
+async function validateBashSyntax(script) {
+    return new Promise((resolve) => {
+        const tempPath = `/tmp/claude-gen-syntax-check-${Date.now()}.sh`;
+        fs.writeFileSync(tempPath, script);
+        const proc = spawn('bash', ['-n', tempPath], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                // Ignore
+            }
+            if (code === 0) {
+                resolve(null);
+            }
+            else {
+                resolve(stderr.trim() || `Syntax check failed with code ${code}`);
+            }
+        });
+        proc.on('error', (err) => {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                // Ignore
+            }
+            resolve(err.message);
+        });
+        setTimeout(() => {
+            proc.kill();
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                // Ignore
+            }
+            resolve('Syntax check timed out');
+        }, 5000);
+    });
+}
+/**
+ * Extract text content from stream-json format output
+ */
+function extractTextFromStreamJson(output) {
+    const lines = output.split('\n');
+    const textParts = [];
+    for (const line of lines) {
+        if (!line.trim().startsWith('{'))
+            continue;
+        try {
+            const json = JSON.parse(line);
+            // Extract text from assistant messages
+            if (json.type === 'assistant' && json.message?.content) {
+                for (const block of json.message.content) {
+                    if (block.type === 'text') {
+                        textParts.push(block.text);
+                    }
+                }
+            }
+            // Also check for result messages (final output)
+            if (json.type === 'result' && json.result) {
+                textParts.push(json.result);
+            }
+            // Handle content_block_delta for streaming responses
+            if (json.type === 'content_block_delta' && json.delta?.text) {
+                textParts.push(json.delta.text);
+            }
+        }
+        catch {
+            // Not valid JSON, might be raw text - only add if it looks like script content
+            if (line.includes('#!/bin/bash') || line.includes('agent-browser') || line.includes('```')) {
+                textParts.push(line);
+            }
+        }
+    }
+    return textParts.join('\n');
+}
+/**
+ * Validate extracted data quality
+ * Uses configurable thresholds - can be set via config or env vars
+ */
+function validateExtractedData(output, taskDescription, config) {
+    const issues = [];
+    // Get validation thresholds from config or use defaults
+    const thresholds = config?.validation ?? {
+        minPriceRate: 0.9,
+        minRatingRate: 0.8,
+        minItemCount: 1,
+        requirePrices: true,
+        requireRatings: true,
+    };
+    try {
+        // Try to find JSON in output - handle both regular and double-encoded JSON
+        let jsonMatch = output.match(/\{[\s\S]*"items"[\s\S]*\}/);
+        // If no match, try to handle double-encoded JSON (from agent-browser eval)
+        // The output looks like: "{\n  \"totalExtracted\": 22,\n  \"items\": [..."
+        if (!jsonMatch) {
+            // Look for escaped JSON pattern
+            const escapedMatch = output.match(/"(\{[\s\S]*\\?"items\\?"[\s\S]*\})"/);
+            if (escapedMatch) {
+                // Parse the outer JSON string to get the inner JSON
+                try {
+                    const innerJson = JSON.parse('"' + escapedMatch[1] + '"');
+                    jsonMatch = [innerJson];
+                }
+                catch {
+                    // If that fails, try simple unescape
+                    const unescaped = escapedMatch[1]
+                        .replace(/\\n/g, '\n')
+                        .replace(/\\"/g, '"')
+                        .replace(/\\\\/g, '\\');
+                    jsonMatch = [unescaped];
+                }
+            }
+        }
+        if (!jsonMatch)
+            return { valid: true, issues: [] }; // Can't validate, assume OK
+        const data = JSON.parse(jsonMatch[0]);
+        const items = data.items || [];
+        // Fail validation if zero items
+        if (items.length === 0) {
+            issues.push('No items extracted');
+            return { valid: false, issues };
+        }
+        // Check minimum item count
+        if (items.length < thresholds.minItemCount) {
+            issues.push(`Only ${items.length} items extracted (need ${thresholds.minItemCount}+). Check if your selector targets the main product grid (not ads/carousel).`);
+        }
+        // Check for placeholder values (N/A, empty, etc.)
+        const invalidValues = ['', 'N/A', 'n/a', 'TBD', 'null', 'undefined'];
+        // Price validation - only if prices are required
+        if (thresholds.requirePrices) {
+            const invalidPrices = items.filter((i) => {
+                const price = (i.price || '').trim();
+                return invalidValues.includes(price) || !price;
+            }).length;
+            const priceRate = (items.length - invalidPrices) / items.length;
+            if (priceRate < thresholds.minPriceRate) {
+                issues.push(`Only ${Math.round(priceRate * 100)}% of items have valid prices (need ${Math.round(thresholds.minPriceRate * 100)}%+)`);
+            }
+        }
+        // Rating validation - only if ratings are required
+        if (thresholds.requireRatings) {
+            const invalidRatings = items.filter((i) => {
+                const rating = (i.rating || '').trim();
+                return invalidValues.includes(rating) || !rating;
+            }).length;
+            const ratingRate = (items.length - invalidRatings) / items.length;
+            if (ratingRate < thresholds.minRatingRate) {
+                issues.push(`Only ${Math.round(ratingRate * 100)}% of items have valid ratings (need ${Math.round(thresholds.minRatingRate * 100)}%+)`);
+            }
+        }
+        return { valid: issues.length === 0, issues };
+    }
+    catch {
+        return { valid: true, issues: [] }; // Can't parse, don't fail validation
+    }
+}
+// Legacy function signature for backwards compatibility
+export async function runIterativeTestFromCommands(commands, originalTask, config, customOutput) {
+    // Import the legacy generator
+    const { generateBashScript } = await import('./codegen/bash-generator.js');
+    // Generate script from commands
+    const scriptPath = generateBashScript(commands, {
+        cdpUrl: config.cdpUrl,
+        outputDir: config.outputDir,
+        filename: customOutput,
+    });
+    const scriptContent = fs.readFileSync(scriptPath, 'utf-8');
+    // Run the iterative test
+    return runIterativeTest(scriptContent, originalTask, config, customOutput);
+}

package/dist/logger/command-log.js

@@ -0,0 +1,38 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Read captured commands from a session log file
+ */
+export function readCommandLog(sessionId, sessionsDir) {
+    const sessionFile = path.join(sessionsDir, `${sessionId}.jsonl`);
+    if (!fs.existsSync(sessionFile)) {
+        return [];
+    }
+    const content = fs.readFileSync(sessionFile, 'utf-8');
+    const lines = content.trim().split('\n').filter(line => line.trim());
+    return lines.map(line => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    }).filter((entry) => entry !== null);
+}
+/**
+ * Get only successful agent-browser commands
+ */
+export function getSuccessfulCommands(entries) {
+    return entries
+        .filter(entry => entry.success && entry.command.includes('agent-browser'))
+        .map(entry => entry.command);
+}
+/**
+ * Clean up session file after script generation
+ */
+export function cleanupSession(sessionId, sessionsDir) {
+    const sessionFile = path.join(sessionsDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionFile)) {
+        fs.unlinkSync(sessionFile);
+    }
+}