@browsercash/chase 1.0.0

package/dist/browser-cash.js

@@ -0,0 +1,128 @@
+/**
+ * Browser.cash API Client
+ *
+ * Handles creating, managing, and stopping browser sessions via the Browser.cash API.
+ */
+const BROWSER_CASH_API_URL = process.env.BROWSER_CASH_API_URL || 'https://api.browser.cash';
+/**
+ * Create a new browser session
+ */
+export async function createBrowserSession(apiKey, options = {}) {
+    const response = await fetch(`${BROWSER_CASH_API_URL}/v1/browser/session`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(options),
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Browser.cash API error: ${error.error || response.statusText}`);
+    }
+    return response.json();
+}
+/**
+ * Get an existing browser session
+ */
+export async function getBrowserSession(apiKey, sessionId) {
+    const response = await fetch(`${BROWSER_CASH_API_URL}/v1/browser/session?sessionId=${encodeURIComponent(sessionId)}`, {
+        method: 'GET',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Browser.cash API error: ${error.error || response.statusText}`);
+    }
+    return response.json();
+}
+/**
+ * Stop a browser session
+ */
+export async function stopBrowserSession(apiKey, sessionId) {
+    const response = await fetch(`${BROWSER_CASH_API_URL}/v1/browser/session?sessionId=${encodeURIComponent(sessionId)}`, {
+        method: 'DELETE',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Browser.cash API error: ${error.error || response.statusText}`);
+    }
+    return response.json();
+}
+/**
+ * Wait for a session to become active and return its CDP URL
+ */
+export async function waitForSessionReady(apiKey, sessionId, timeoutMs = 30000, pollIntervalMs = 1000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        const session = await getBrowserSession(apiKey, sessionId);
+        if (session.status === 'active' && session.cdpUrl) {
+            return session.cdpUrl;
+        }
+        if (session.status === 'error') {
+            throw new Error('Browser session failed to start');
+        }
+        if (session.status === 'completed') {
+            throw new Error('Browser session already completed');
+        }
+        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error(`Timeout waiting for browser session to become ready`);
+}
+/**
+ * Create a browser session and wait for it to be ready
+ */
+export async function createAndWaitForSession(apiKey, options = {}, timeoutMs = 30000) {
+    const session = await createBrowserSession(apiKey, options);
+    // If session is already active with CDP URL, return immediately
+    if (session.status === 'active' && session.cdpUrl) {
+        return { session, cdpUrl: session.cdpUrl };
+    }
+    // Otherwise wait for it to be ready
+    const cdpUrl = await waitForSessionReady(apiKey, session.sessionId, timeoutMs);
+    const updatedSession = await getBrowserSession(apiKey, session.sessionId);
+    return { session: updatedSession, cdpUrl };
+}
+/**
+ * Helper to manage a browser session lifecycle for script execution
+ */
+export class BrowserSessionManager {
+    apiKey;
+    session = null;
+    cdpUrl = null;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async start(options = {}) {
+        const result = await createAndWaitForSession(this.apiKey, options);
+        this.session = result.session;
+        this.cdpUrl = result.cdpUrl;
+        return this.cdpUrl;
+    }
+    async stop() {
+        if (this.session) {
+            try {
+                await stopBrowserSession(this.apiKey, this.session.sessionId);
+            }
+            catch {
+                // Ignore errors when stopping - session may already be stopped
+            }
+            this.session = null;
+            this.cdpUrl = null;
+        }
+    }
+    getSessionId() {
+        return this.session?.sessionId || null;
+    }
+    getCdpUrl() {
+        return this.cdpUrl;
+    }
+    isActive() {
+        return this.session?.status === 'active' && this.cdpUrl !== null;
+    }
+}

package/dist/claude-runner.js

@@ -0,0 +1,285 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import { getSystemPrompt } from './prompts/system-prompt.js';
+/**
+ * Generate a unique session ID
+ */
+function generateSessionId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `session-${timestamp}-${random}`;
+}
+/**
+ * Run Claude Code CLI to generate a browser automation script.
+ *
+ * Claude will:
+ * 1. Use snapshot commands to understand the page (for its own understanding)
+ * 2. Output a complete bash script in a code block
+ *
+ * We extract the script from Claude's output, not by capturing individual commands.
+ */
+export async function runClaudeForScriptGeneration(taskPrompt, config) {
+    const sessionId = generateSessionId();
+    // Ensure sessions directory exists
+    if (!fs.existsSync(config.sessionsDir)) {
+        fs.mkdirSync(config.sessionsDir, { recursive: true });
+    }
+    // Get the system prompt and combine with task
+    const systemPrompt = getSystemPrompt(config.cdpUrl);
+    const fullPrompt = `${systemPrompt}
+
+## Your Task
+
+${taskPrompt}`;
+    // Write full prompt to a file
+    const promptFile = path.join(config.sessionsDir, `${sessionId}-prompt.txt`);
+    fs.writeFileSync(promptFile, fullPrompt);
+    return new Promise((resolve) => {
+        let output = '';
+        let errorOutput = '';
+        const env = {
+            ...process.env,
+            CDP_URL: config.cdpUrl,
+        };
+        console.log(`\n[claude-gen] Starting Claude Code...`);
+        console.log(`[claude-gen] Session ID: ${sessionId}`);
+        // Use stream-json for verbose output, allow Bash for snapshots
+        const shellCmd = `cat "${promptFile}" | claude -p --model ${config.model} --max-turns ${config.maxTurns} --allowedTools "Bash" --output-format stream-json --verbose`;
+        const claude = spawn('bash', ['-c', shellCmd], {
+            env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: false,
+        });
+        claude.stdout?.on('data', (data) => {
+            const text = data.toString();
+            output += text;
+            process.stdout.write(text);
+        });
+        claude.stderr?.on('data', (data) => {
+            const text = data.toString();
+            errorOutput += text;
+            process.stderr.write(text);
+        });
+        claude.on('close', (code) => {
+            // Clean up temp files
+            cleanup(promptFile);
+            // Extract the script from Claude's output
+            const script = extractScriptFromOutput(output);
+            if (script) {
+                console.log(`\n[claude-gen] Successfully extracted script from Claude's output`);
+            }
+            else {
+                console.log(`\n[claude-gen] WARNING: Could not extract script from Claude's output`);
+            }
+            resolve({
+                success: code === 0 && script !== null,
+                sessionId,
+                output,
+                script,
+                error: code !== 0 ? (errorOutput || `Exit code: ${code}`) : undefined,
+            });
+        });
+        claude.on('error', (err) => {
+            cleanup(promptFile);
+            resolve({
+                success: false,
+                sessionId,
+                output,
+                script: null,
+                error: err.message,
+            });
+        });
+    });
+}
+function cleanup(...files) {
+    for (const file of files) {
+        try {
+            if (fs.existsSync(file)) {
+                fs.unlinkSync(file);
+            }
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+/**
+ * Extract a bash script from Claude's output.
+ * Looks for code blocks containing agent-browser commands.
+ */
+function extractScriptFromOutput(output) {
+    // First, try to extract text content from stream-json format
+    const textContent = extractTextFromStreamJson(output);
+    // Look for bash code blocks in the extracted text
+    // Use new RegExp to avoid backtick escaping issues
+    const codeBlockPatterns = [
+        new RegExp('```bash\\n([\\s\\S]*?)```', 'g'),
+        new RegExp('```sh\\n([\\s\\S]*?)```', 'g'),
+        new RegExp('```shell\\n([\\s\\S]*?)```', 'g'),
+        new RegExp('```\\n(#!/bin/bash[\\s\\S]*?)```', 'g'),
+    ];
+    let bestScript = null;
+    let bestScore = 0;
+    for (const pattern of codeBlockPatterns) {
+        let match;
+        while ((match = pattern.exec(textContent)) !== null) {
+            const script = match[1].trim();
+            const score = scoreScript(script);
+            if (score > bestScore) {
+                bestScore = score;
+                bestScript = script;
+            }
+        }
+    }
+    if (bestScript) {
+        // Ensure it has shebang
+        if (!bestScript.startsWith('#!/')) {
+            bestScript = '#!/bin/bash\nset -e\n\nCDP="${CDP_URL:?Required}"\n\n' + bestScript;
+        }
+        return bestScript;
+    }
+    // Fallback: look for agent-browser commands and construct a script
+    const commands = extractAgentBrowserCommands(textContent);
+    if (commands.length > 0) {
+        // Filter out snapshot commands
+        const replayableCommands = commands.filter(cmd => !cmd.includes('snapshot'));
+        if (replayableCommands.length > 0) {
+            return constructScriptFromCommands(replayableCommands);
+        }
+    }
+    return null;
+}
+/**
+ * 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
+            if (json.type === 'result' && json.result) {
+                textParts.push(json.result);
+            }
+        }
+        catch {
+            // Not valid JSON, might be raw text
+            textParts.push(line);
+        }
+    }
+    return textParts.join('\n');
+}
+/**
+ * Score a script based on how complete it looks
+ */
+function scoreScript(script) {
+    let score = 0;
+    // Must have agent-browser commands
+    if (!script.includes('agent-browser'))
+        return 0;
+    // Bonus for having shebang
+    if (script.includes('#!/bin/bash'))
+        score += 10;
+    // Bonus for having CDP variable
+    if (script.includes('CDP=') || script.includes('$CDP'))
+        score += 10;
+    // Bonus for having open command
+    if (script.includes('open "http'))
+        score += 20;
+    // Bonus for having eval command (data extraction)
+    if (script.includes('eval "'))
+        score += 20;
+    // Bonus for having FINAL RESULTS section
+    if (script.includes('FINAL RESULTS') || script.includes('echo "$'))
+        score += 10;
+    // Penalty for snapshot commands (shouldn't be in final script)
+    const snapshotCount = (script.match(/snapshot/g) || []).length;
+    score -= snapshotCount * 5;
+    // Penalty for @eN refs (shouldn't be in final script)
+    const refCount = (script.match(/@e\d+/g) || []).length;
+    score -= refCount * 10;
+    // Count useful commands
+    const openCount = (script.match(/\bopen\s+"/g) || []).length;
+    const evalCount = (script.match(/\beval\s+"/g) || []).length;
+    score += openCount * 5 + evalCount * 10;
+    return score;
+}
+/**
+ * Extract agent-browser commands from text
+ */
+function extractAgentBrowserCommands(text) {
+    const commands = [];
+    const lines = text.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip comment lines
+        if (trimmed.startsWith('#'))
+            continue;
+        // Look for agent-browser commands
+        if (trimmed.includes('agent-browser') && trimmed.includes('--cdp')) {
+            // Extract the command portion
+            const match = trimmed.match(/(agent-browser\s+--cdp\s+[^\n]+)/);
+            if (match && !commands.includes(match[1])) {
+                commands.push(match[1]);
+            }
+        }
+    }
+    return commands;
+}
+/**
+ * Construct a script from extracted commands (fallback)
+ */
+function constructScriptFromCommands(commands) {
+    const lines = [
+        '#!/bin/bash',
+        'set -e',
+        '',
+        '# Generated by claude-gen (fallback mode)',
+        'CDP="${CDP_URL:?Required: CDP_URL}"',
+        '',
+    ];
+    for (const cmd of commands) {
+        // Normalize CDP variable
+        let normalized = cmd
+            .replace(/"\$CDP_URL"/g, '"$CDP"')
+            .replace(/\$CDP_URL/g, '$CDP');
+        lines.push(normalized);
+        // Add sleep after navigation
+        if (cmd.includes(' open ')) {
+            lines.push('sleep 2');
+        }
+    }
+    lines.push('');
+    lines.push('echo "Script completed"');
+    return lines.join('\n');
+}
+// Keep the old function for backwards compatibility, but have it use the new one
+export async function runClaudeWithOutputParsing(taskPrompt, config) {
+    const result = await runClaudeForScriptGeneration(taskPrompt, config);
+    // Extract commands from script for backwards compatibility
+    const commands = [];
+    if (result.script) {
+        const lines = result.script.split('\n');
+        for (const line of lines) {
+            if (line.includes('agent-browser') && !line.trim().startsWith('#')) {
+                commands.push(line.trim());
+            }
+        }
+    }
+    return {
+        ...result,
+        commands,
+    };
+}

package/dist/cli-install.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * Chase CLI Installer
+ *
+ * Usage:
+ *   npx chase-install          # Install skill + show MCP setup
+ *   npx chase-install --skill  # Install skill only
+ *   npx chase-install --mcp    # Show MCP setup only
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as os from 'os';
+const SKILL_URL = 'https://raw.githubusercontent.com/alexander-spring/chase/main/skill/SKILL.md';
+const MCP_URL = 'https://chase-api-gth2quoxyq-uc.a.run.app/mcp';
+function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                // Follow redirect
+                https.get(response.headers.location, (res) => {
+                    res.pipe(file);
+                    file.on('finish', () => { file.close(); resolve(); });
+                }).on('error', reject);
+            }
+            else {
+                response.pipe(file);
+                file.on('finish', () => { file.close(); resolve(); });
+            }
+        }).on('error', reject);
+    });
+}
+async function installSkill() {
+    const skillDir = path.join(os.homedir(), '.claude', 'skills', 'chase');
+    const skillPath = path.join(skillDir, 'SKILL.md');
+    console.log('Installing chase skill...');
+    // Create directory
+    fs.mkdirSync(skillDir, { recursive: true });
+    // Download skill
+    await downloadFile(SKILL_URL, skillPath);
+    console.log(`✓ Skill installed to ${skillPath}`);
+}
+function showMcpSetup() {
+    console.log(`
+MCP Server Setup
+================
+
+Option 1: Hosted HTTP (Recommended)
+-----------------------------------
+claude mcp add --transport http chase ${MCP_URL} -H "x-api-key: YOUR_API_KEY"
+
+Option 2: Local stdio
+---------------------
+git clone https://github.com/alexander-spring/chase.git
+cd chase/mcp-server && npm install && npm run build
+claude mcp add chase node ./dist/index.js -e BROWSER_CASH_API_KEY=YOUR_KEY
+
+Claude Desktop Config
+---------------------
+Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
+
+{
+  "mcpServers": {
+    "chase": {
+      "transport": "http",
+      "url": "${MCP_URL}",
+      "headers": {
+        "x-api-key": "YOUR_API_KEY"
+      }
+    }
+  }
+}
+`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const skillOnly = args.includes('--skill');
+    const mcpOnly = args.includes('--mcp');
+    console.log(`
+╔═══════════════════════════════════════════╗
+║       Chase Browser Automation       ║
+╚═══════════════════════════════════════════╝
+`);
+    if (!mcpOnly) {
+        try {
+            await installSkill();
+        }
+        catch (err) {
+            console.error('Failed to install skill:', err instanceof Error ? err.message : err);
+        }
+    }
+    if (!skillOnly) {
+        showMcpSetup();
+    }
+    console.log(`
+Get your API key at: https://browser.cash
+
+Quick Start:
+  export BROWSER_CASH_API_KEY="your-key"
+  # Then ask Claude to extract data from any website!
+`);
+}
+main().catch(console.error);