@browsercash/chase 1.0.0 → 1.1.0

package/README.md

@@ -17,7 +17,7 @@ AI-powered browser automation - extract data from any website using natural lang
 
 ```bash
 # Install globally
-npm install -g chase-browser
+npm install -g @browsercash/chase
 
 # Set your API key
 export BROWSER_CASH_API_KEY="your-key"

package/dist/cli.js

@@ -13,7 +13,8 @@
  *   chase task <task-id>
  */
 import * as https from 'https';
-const API_BASE = 'https://chase-api-gth2quoxyq-uc.a.run.app';
+import * as http from 'http';
+const API_BASE = process.env.CHASE_API_URL || 'https://chase-api-gth2quoxyq-uc.a.run.app';
 function getApiKey() {
     const key = process.env.BROWSER_CASH_API_KEY;
     if (!key) {
@@ -57,16 +58,18 @@ function parseArgs() {
 async function streamRequest(endpoint, body, onEvent) {
     return new Promise((resolve, reject) => {
         const url = new URL(endpoint, API_BASE);
+        const isHttps = url.protocol === 'https:';
         const options = {
             hostname: url.hostname,
-            port: 443,
+            port: url.port || (isHttps ? 443 : 80),
             path: url.pathname,
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
             },
         };
-        const req = https.request(options, (res) => {
+        const transport = isHttps ? https : http;
+        const req = transport.request(options, (res) => {
             let buffer = '';
             res.on('data', (chunk) => {
                 buffer += chunk.toString();
@@ -106,16 +109,18 @@ async function streamRequest(endpoint, body, onEvent) {
 async function apiGet(endpoint, apiKey) {
     return new Promise((resolve, reject) => {
         const url = new URL(endpoint, API_BASE);
+        const isHttps = url.protocol === 'https:';
         const options = {
             hostname: url.hostname,
-            port: 443,
+            port: url.port || (isHttps ? 443 : 80),
             path: url.pathname,
             method: 'GET',
             headers: {
                 'x-api-key': apiKey,
             },
         };
-        const req = https.request(options, (res) => {
+        const transport = isHttps ? https : http;
+        const req = transport.request(options, (res) => {
             let data = '';
             res.on('data', (chunk) => (data += chunk.toString()));
             res.on('end', () => {

package/dist/config.js

@@ -100,7 +100,7 @@ export function loadConfig(taskDescriptionOrOptions) {
         cdpUrl,
         outputDir: process.env.OUTPUT_DIR || './generated',
         sessionsDir: process.env.SESSIONS_DIR || './sessions',
-        maxTurns: parseInt(process.env.MAX_TURNS || '15', 10),
+        maxTurns: parseInt(process.env.MAX_TURNS || '30', 10),
         model: process.env.MODEL || 'claude-opus-4-5-20251101',
         maxFixIterations: parseInt(process.env.MAX_FIX_ITERATIONS || '5', 10),
         // Script execution timeout (default 5 minutes for complex multi-page tasks)

package/dist/prompts/agentic-prompt.js

@@ -74,5 +74,23 @@ agent-browser --cdp "$CDP_URL" eval 'JSON.stringify(Array.from(document.querySel
 
 4. Output final JSON result
 
+## CRITICAL: Output Format Requirement
+
+Your FINAL message MUST contain a JSON code block. This is REQUIRED for the system to process your results.
+
+**For success - use EXACTLY this format:**
+\`\`\`json
+{"success": true, "data": {...}, "summary": "Brief description"}
+\`\`\`
+
+**For failure - use EXACTLY this format:**
+\`\`\`json
+{"success": false, "error": "What went wrong", "attempted": "What was tried"}
+\`\`\`
+
+Do NOT output results as plain text. Always wrap in \`\`\`json code fence.
+Do NOT use comments inside JSON. JSON must be valid and parseable.
+The JSON block should be your LAST output after completing all actions.
+
 NOW: Perform the requested task and return the results.`;
 }

package/dist/server.js

@@ -121,14 +121,21 @@ function generateTaskId() {
     return `task-${timestamp}-${random}`;
 }
 /**
- * Save a task record to GCS
+ * Save a task record to GCS (gracefully handles missing credentials for local dev)
  */
 async function saveTask(task) {
-    const bucket = storage.bucket(BUCKET_NAME);
-    const file = bucket.file(`tasks/${task.taskId}.json`);
-    await file.save(JSON.stringify(task, null, 2), {
-        contentType: 'application/json',
-    });
+    try {
+        const bucket = storage.bucket(BUCKET_NAME);
+        const file = bucket.file(`tasks/${task.taskId}.json`);
+        await file.save(JSON.stringify(task, null, 2), {
+            contentType: 'application/json',
+        });
+    }
+    catch (err) {
+        // Gracefully handle GCS errors (e.g., missing credentials in local dev)
+        // Task will still work, just won't be persisted for later retrieval
+        console.warn(`[saveTask] Could not persist task ${task.taskId} to GCS:`, err.message);
+    }
 }
 /**
  * Get a task record from GCS, verifying ownership
@@ -1405,10 +1412,23 @@ async function runAgenticAutomation(taskPrompt, config, sendEvent) {
             catch {
                 // Ignore cleanup errors
             }
+            // Check if we likely hit max turns limit
+            const assistantTurns = output.split('\n').filter((l) => l.includes('"type":"assistant"')).length;
+            if (assistantTurns >= config.maxTurns - 1) {
+                sendEvent('log', {
+                    message: `Task may have hit max turns limit (${config.maxTurns}). Consider increasing MAX_TURNS env var or --max-turns flag.`,
+                    level: 'warn',
+                });
+            }
             // Extract the JSON result from Claude's output
             const result = extractAgenticResult(output);
             if (result) {
-                sendEvent('log', { message: 'Successfully extracted result from Claude output', level: 'info' });
+                if (result.success) {
+                    sendEvent('log', { message: 'Successfully extracted result from Claude output', level: 'info' });
+                }
+                else {
+                    sendEvent('log', { message: 'Task completed with failure status', level: 'warn' });
+                }
                 resolve({
                     success: result.success,
                     result: result.data,
@@ -1417,11 +1437,17 @@ async function runAgenticAutomation(taskPrompt, config, sendEvent) {
                 });
             }
             else {
-                sendEvent('log', { message: 'Could not extract structured result from Claude output', level: 'warn' });
+                // No result could be extracted - provide context for debugging
+                const textContent = extractTextFromStreamJson(output);
+                const lastOutput = textContent.slice(-500);
+                sendEvent('log', {
+                    message: `Could not extract structured result from Claude output. Last output: ${lastOutput.substring(0, 200)}...`,
+                    level: 'warn',
+                });
                 resolve({
                     success: false,
                     result: null,
-                    error: code !== 0 ? `Exit code: ${code}` : 'Failed to extract result from output',
+                    error: code !== 0 ? `Exit code: ${code}` : 'Failed to extract result from output. Claude may not have produced JSON in expected format.',
                 });
             }
         });
@@ -1445,10 +1471,11 @@ async function runAgenticAutomation(taskPrompt, config, sendEvent) {
 /**
  * Extract the final JSON result from agentic automation output.
  * Looks for the structured JSON output format in Claude's response.
+ * Uses multiple strategies to be resilient to format variations.
  */
 function extractAgenticResult(output) {
     const textContent = extractTextFromStreamJson(output);
-    // Look for JSON code blocks with our expected format
+    // Strategy 1: Look for JSON code blocks with our expected format (```json ... ```)
     const jsonBlockPattern = /```json\s*([\s\S]*?)```/g;
     let lastValidResult = null;
     let match;
@@ -1471,22 +1498,29 @@ function extractAgenticResult(output) {
             // Not valid JSON, continue looking
         }
     }
-    // If we found a structured result, return it
     if (lastValidResult) {
         return lastValidResult;
     }
-    // Fallback: try to find any JSON that looks like extracted data
-    // This handles cases where Claude outputs data directly without our wrapper format
+    // Strategy 2: Look for any code blocks with JSON data (``` ... ```)
     const anyJsonPattern = /```(?:json)?\s*([\s\S]*?)```/g;
     while ((match = anyJsonPattern.exec(textContent)) !== null) {
         try {
             const jsonStr = match[1].trim();
-            // Skip if it doesn't look like JSON
             if (!jsonStr.startsWith('{') && !jsonStr.startsWith('['))
                 continue;
             const parsed = JSON.parse(jsonStr);
-            // If it's an array or object with data, wrap it in our format
             if (Array.isArray(parsed) || (typeof parsed === 'object' && parsed !== null)) {
+                // Check if it has success field (format we expect)
+                if ('success' in parsed) {
+                    return {
+                        success: parsed.success === true,
+                        data: parsed.data,
+                        summary: parsed.summary,
+                        error: parsed.error,
+                        attempted: parsed.attempted,
+                    };
+                }
+                // Otherwise wrap it
                 return {
                     success: true,
                     data: parsed,
@@ -1498,6 +1532,93 @@ function extractAgenticResult(output) {
             // Not valid JSON, continue looking
         }
     }
+    // Strategy 3: Look for unfenced JSON objects with success field anywhere in text
+    // This handles cases where Claude outputs JSON without code fences
+    const unfencedPattern = /\{\s*"success"\s*:\s*(true|false)[\s\S]*?\}(?=\s*$|\s*\n\s*\n|\s*[^,\]}])/g;
+    while ((match = unfencedPattern.exec(textContent)) !== null) {
+        try {
+            // Try to find the complete JSON object by balancing braces
+            const startIdx = match.index;
+            let depth = 0;
+            let endIdx = startIdx;
+            for (let i = startIdx; i < textContent.length; i++) {
+                if (textContent[i] === '{')
+                    depth++;
+                else if (textContent[i] === '}') {
+                    depth--;
+                    if (depth === 0) {
+                        endIdx = i + 1;
+                        break;
+                    }
+                }
+            }
+            const jsonStr = textContent.substring(startIdx, endIdx);
+            const parsed = JSON.parse(jsonStr);
+            if (typeof parsed === 'object' && parsed !== null && 'success' in parsed) {
+                return {
+                    success: parsed.success === true,
+                    data: parsed.data,
+                    summary: parsed.summary,
+                    error: parsed.error,
+                    attempted: parsed.attempted,
+                };
+            }
+        }
+        catch {
+            // Continue looking
+        }
+    }
+    // Strategy 4: Look for any JSON array/object in the last portion of output
+    // Sometimes Claude puts the result at the end without code fences
+    const lastChunk = textContent.slice(-3000);
+    const jsonMatches = lastChunk.match(/(\[[\s\S]*\]|\{[\s\S]*\})/g);
+    if (jsonMatches) {
+        // Try from last to first (most likely to be the result)
+        for (let i = jsonMatches.length - 1; i >= 0; i--) {
+            try {
+                const parsed = JSON.parse(jsonMatches[i]);
+                if (Array.isArray(parsed) && parsed.length > 0) {
+                    return {
+                        success: true,
+                        data: parsed,
+                        summary: `Extracted ${parsed.length} items from output`,
+                    };
+                }
+                if (typeof parsed === 'object' && parsed !== null) {
+                    if ('success' in parsed) {
+                        return {
+                            success: parsed.success === true,
+                            data: parsed.data,
+                            summary: parsed.summary,
+                            error: parsed.error,
+                            attempted: parsed.attempted,
+                        };
+                    }
+                    if (Object.keys(parsed).length > 0) {
+                        return {
+                            success: true,
+                            data: parsed,
+                            summary: 'Extracted data from output',
+                        };
+                    }
+                }
+            }
+            catch {
+                // Not valid JSON
+            }
+        }
+    }
+    // Strategy 5: If we have substantial text content but no JSON, return it as a failure with context
+    // This helps users understand what happened
+    if (textContent.trim().length > 50) {
+        return {
+            success: false,
+            error: 'Could not parse structured JSON result from output',
+            data: null,
+            summary: 'Task completed but output was not in expected format',
+            rawOutput: textContent.slice(-2000), // Last 2000 chars for debugging
+        };
+    }
     return null;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browsercash/chase",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "AI-powered browser automation - extract data from any website with natural language",
   "type": "module",
   "main": "dist/index.js",