surf-cli 2.2.0 → 2.4.0

package/native/host-helpers.cjs

@@ -51,12 +51,51 @@ function formatToolContent(result, log = () => {}) {
     return text(output);
   }
   
-  // Handle ChatGPT/Gemini responses
+  // Handle Grok validation results
+  if (result.authenticated !== undefined && result.models !== undefined && result.expectedModels !== undefined) {
+    let output = "## Grok Validation Results\n\n";
+    output += `**Authenticated:** ${result.authenticated ? 'Yes' : 'No'}\n`;
+    output += `**Premium:** ${result.premium ? 'Yes' : 'No'}\n`;
+    output += `**Input Field:** ${result.inputFound ? 'Found' : 'Not Found'}\n`;
+    output += `**Send Button:** ${result.sendButtonFound ? 'Found' : 'Not Found'}\n\n`;
+    
+    output += `**Available Models:** ${result.models.length > 0 ? result.models.join(', ') : 'None found'}\n`;
+    output += `**Expected Models:** ${result.expectedModels.join(', ')}\n`;
+    output += `**Model Mismatch:** ${result.modelMismatch ? 'Yes' : 'No'}\n\n`;
+    
+    if (result.errors && result.errors.length > 0) {
+      output += `**Errors:**\n${result.errors.map(e => `- ${e}`).join('\n')}\n\n`;
+    }
+    
+    if (result.savedModels) {
+      if (result.savedModels.success) {
+        output += `**Models saved to:** ${result.savedModels.path}\n`;
+      } else {
+        output += `**Failed to save models:** ${result.savedModels.error}\n`;
+      }
+    }
+    
+    output += `\n*Config: ${result.configPath}*\n`;
+    output += `*Completed in ${result.tookMs}ms*`;
+    
+    return text(output);
+  }
+  
+  // Handle ChatGPT/Gemini/Grok responses
   if (result.response !== undefined && result.model !== undefined && result.tookMs !== undefined) {
     let output = result.response;
     if (result.imagePath) {
       output += `\n\n*Image saved to: ${result.imagePath}*`;
     }
+    if (result.thinkingTime) {
+      output += `\n\n*Grok thought for ${result.thinkingTime}s*`;
+    }
+    if (result.partial) {
+      output += `\n\n*Warning: Response was truncated due to timeout*`;
+    }
+    if (result.warnings && result.warnings.length > 0) {
+      output += `\n\n**Warnings:**\n${result.warnings.map(w => `- ${w}`).join('\n')}`;
+    }
     return text(output);
   }
   
@@ -1013,6 +1052,24 @@ function mapToolToMessage(tool, args, tabId) {
         timeout: a.timeout ? parseInt(a.timeout, 10) * 1000 : 120000,
         ...baseMsg
       };
+    case "grok":
+      if (a.validate) {
+        return {
+          type: "GROK_VALIDATE",
+          saveModels: a["save-models"] || a.saveModels || false,
+          ...baseMsg
+        };
+      }
+      if (!a.query) throw new Error("query required");
+      return {
+        type: "GROK_QUERY",
+        query: a.query,
+        model: a.model,
+        deepSearch: a["deep-search"] || a.deepSearch || false,
+        withPage: a["with-page"],
+        timeout: a.timeout ? parseInt(a.timeout, 10) * 1000 : 300000,
+        ...baseMsg
+      };
     case "window.new":
       return { 
         type: "WINDOW_NEW", 

package/native/host.cjs

@@ -9,6 +9,7 @@ const { GoogleGenerativeAI } = require("@google/generative-ai");
 const chatgptClient = require("./chatgpt-client.cjs");
 const geminiClient = require("./gemini-client.cjs");
 const perplexityClient = require("./perplexity-client.cjs");
+const grokClient = require("./grok-client.cjs");
 const { mapToolToMessage, mapComputerAction, formatToolContent } = require("./host-helpers.cjs");
 
 const SOCKET_PATH = "/tmp/surf.sock";
@@ -713,6 +714,203 @@ function handleToolRequest(msg, socket) {
     return;
   }
   
+  if (extensionMsg.type === "GROK_QUERY") {
+    const { query, model, deepSearch, withPage, timeout } = extensionMsg;
+    
+    queueAiRequest(async () => {
+      // 1. Get page context if requested
+      let pageContext = null;
+      if (withPage) {
+        const pageResult = await new Promise((resolve) => {
+          const pageId = ++requestCounter;
+          pendingToolRequests.set(pageId, {
+            socket: null,
+            originalId: null,
+            tool: "get_page_text",
+            onComplete: resolve
+          });
+          writeMessage({ type: "GET_PAGE_TEXT", tabId: extensionMsg.tabId, id: pageId });
+        });
+        if (pageResult && !pageResult.error) {
+          pageContext = {
+            url: pageResult.url,
+            text: pageResult.text || pageResult.pageContent || ""
+          };
+        }
+      }
+      
+      // 2. Build full prompt
+      let fullPrompt = query || "";
+      if (pageContext) {
+        fullPrompt = `Page: ${pageContext.url}\n\n${pageContext.text}\n\n---\n\n${fullPrompt}`;
+      }
+      
+      // 3. Call Grok client
+      const result = await grokClient.query({
+        prompt: fullPrompt,
+        model: model,
+        deepSearch: deepSearch || false,
+        timeout: timeout || 300000,
+        getCookies: () => new Promise((resolve) => {
+          const cookieId = ++requestCounter;
+          pendingToolRequests.set(cookieId, {
+            socket: null,
+            originalId: null,
+            tool: "get_cookies",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GET_TWITTER_COOKIES", id: cookieId });
+        }),
+        createTab: () => new Promise((resolve) => {
+          const tabCreateId = ++requestCounter;
+          pendingToolRequests.set(tabCreateId, {
+            socket: null,
+            originalId: null,
+            tool: "create_tab",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GROK_NEW_TAB", id: tabCreateId });
+        }),
+        closeTab: (tabIdToClose) => new Promise((resolve) => {
+          const tabCloseId = ++requestCounter;
+          pendingToolRequests.set(tabCloseId, {
+            socket: null,
+            originalId: null,
+            tool: "close_tab",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GROK_CLOSE_TAB", tabId: tabIdToClose, id: tabCloseId });
+        }),
+        cdpEvaluate: (tabId, expression) => new Promise((resolve) => {
+          const evalId = ++requestCounter;
+          pendingToolRequests.set(evalId, {
+            socket: null,
+            originalId: null,
+            tool: "cdp_evaluate",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GROK_EVALUATE", tabId, expression, id: evalId });
+        }),
+        cdpCommand: (tabId, method, params) => new Promise((resolve) => {
+          const cmdId = ++requestCounter;
+          pendingToolRequests.set(cmdId, {
+            socket: null,
+            originalId: null,
+            tool: "cdp_command",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GROK_CDP_COMMAND", tabId, method, params, id: cmdId });
+        }),
+        log: (msg) => log(`[grok] ${msg}`)
+      });
+      
+      return result;
+    }).then((result) => {
+      const response = { 
+        response: result.response, 
+        model: result.model, 
+        tookMs: result.tookMs 
+      };
+      if (result.thinkingTime) {
+        response.thinkingTime = result.thinkingTime;
+      }
+      if (result.deepSearch) {
+        response.deepSearch = result.deepSearch;
+      }
+      if (result.partial) {
+        response.partial = true;
+      }
+      if (result.warnings && result.warnings.length > 0) {
+        response.warnings = result.warnings;
+      }
+      if (result.modelSelectionFailed) {
+        response.modelSelectionFailed = true;
+      }
+      sendToolResponse(socket, originalId, response, null);
+    }).catch((err) => {
+      sendToolResponse(socket, originalId, null, err.message);
+    });
+    
+    return;
+  }
+  
+  if (extensionMsg.type === "GROK_VALIDATE") {
+    const { saveModels } = extensionMsg;
+    
+    queueAiRequest(async () => {
+      const result = await grokClient.validate({
+        getCookies: () => new Promise((resolve) => {
+          const cookieId = ++requestCounter;
+          pendingToolRequests.set(cookieId, {
+            socket: null,
+            originalId: null,
+            tool: "get_cookies",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GET_TWITTER_COOKIES", id: cookieId });
+        }),
+        createTab: () => new Promise((resolve) => {
+          const tabCreateId = ++requestCounter;
+          pendingToolRequests.set(tabCreateId, {
+            socket: null,
+            originalId: null,
+            tool: "create_tab",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GROK_NEW_TAB", id: tabCreateId });
+        }),
+        closeTab: (tabIdToClose) => new Promise((resolve) => {
+          const tabCloseId = ++requestCounter;
+          pendingToolRequests.set(tabCloseId, {
+            socket: null,
+            originalId: null,
+            tool: "close_tab",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GROK_CLOSE_TAB", tabId: tabIdToClose, id: tabCloseId });
+        }),
+        cdpEvaluate: (tabId, expression) => new Promise((resolve) => {
+          const evalId = ++requestCounter;
+          pendingToolRequests.set(evalId, {
+            socket: null,
+            originalId: null,
+            tool: "cdp_evaluate",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GROK_EVALUATE", tabId, expression, id: evalId });
+        }),
+        log: (msg) => log(`[grok:validate] ${msg}`)
+      });
+      
+      return result;
+    }).then((result) => {
+      // If --save-models flag was passed and we found models, save them
+      if (saveModels && result.models && result.models.length > 0) {
+        // Convert scraped model names to our format
+        const modelMap = {};
+        result.models.forEach(name => {
+          const nameLower = name.toLowerCase();
+          // Match known model keywords to generate consistent short IDs
+          let shortId;
+          if (nameLower.includes('thinking')) shortId = 'thinking';
+          else if (nameLower.includes('expert')) shortId = 'expert';
+          else if (nameLower.includes('fast')) shortId = 'fast';
+          else if (nameLower.includes('auto')) shortId = 'auto';
+          else shortId = nameLower.replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+          
+          modelMap[shortId] = { id: shortId, name: name, desc: "" };
+        });
+        const saveResult = grokClient.saveModels(modelMap);
+        result.savedModels = saveResult;
+      }
+      sendToolResponse(socket, originalId, result, null);
+    }).catch((err) => {
+      sendToolResponse(socket, originalId, null, err.message);
+    });
+    
+    return;
+  }
+  
   if (extensionMsg.type === "EXECUTE_KEY_REPEAT") {
     const { key, repeat, tabId: tid } = extensionMsg;
     let completed = 0;

package/native/perplexity-client.cjs

@@ -193,22 +193,21 @@ async function selectModel(cdp, model, timeoutMs = 8000) {
   
   await delay(500);
   
-  // Select from menu
+  // Select from menu - loop in Node.js to avoid CDP timeout issues
   const normalizedModel = model.toLowerCase().replace(/[^a-z0-9]/g, '');
+  const deadline = Date.now() + timeoutMs;
   
-  const result = await evaluate(cdp, `(async () => {
-    ${buildClickDispatcher()}
-    
-    const targetModel = ${JSON.stringify(normalizedModel)};
-    const normalize = (text) => (text || '').toLowerCase().replace(/[^a-z0-9]/g, '');
-    const deadline = Date.now() + ${timeoutMs};
-    
-    while (Date.now() < deadline) {
+  while (Date.now() < deadline) {
+    const result = await evaluate(cdp, `(() => {
+      ${buildClickDispatcher()}
+      
+      const targetModel = ${JSON.stringify(normalizedModel)};
+      const normalize = (text) => (text || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+      
       const menuItems = document.querySelectorAll('[role=menuitem], [role=menuitemradio], [role=option]');
       
       if (menuItems.length === 0) {
-        await new Promise(r => setTimeout(r, 100));
-        continue;
+        return { found: false, waiting: true };
       }
       
       let bestMatch = null;
@@ -229,23 +228,28 @@ async function selectModel(cdp, model, timeoutMs = 8000) {
       
       if (bestMatch) {
         dispatchClickSequence(bestMatch);
-        await new Promise(r => setTimeout(r, 200));
-        return { success: true, model: bestMatch.textContent?.trim() };
+        return { found: true, success: true, model: bestMatch.textContent?.trim() };
       }
       
-      await new Promise(r => setTimeout(r, 100));
+      return { found: true, success: false, error: 'No matching model in menu' };
+    })()`);
+    
+    if (result && result.found) {
+      if (result.success) {
+        await delay(200);
+        return result.model;
+      }
+      // Items found but no match - close menu and throw
+      await evaluate(cdp, `document.body.click()`);
+      throw new Error(`Failed to select model: ${result?.error}`);
     }
     
-    // Close menu by clicking elsewhere
-    document.body.click();
-    return { success: false, error: 'Model not found in menu' };
-  })()`);
-  
-  if (!result || !result.success) {
-    throw new Error(`Failed to select model: ${result?.error}`);
+    await delay(100);
   }
   
-  return result.model;
+  // Timeout - close menu
+  await evaluate(cdp, `document.body.click()`);
+  throw new Error(`Failed to select model: timeout waiting for menu`);
 }
 
 // ============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "surf-cli",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "CLI for AI agents to control Chrome. Zero config, agent-agnostic, battle-tested.",
   "keywords": [
     "chrome",

package/native/CHANGELOG.md

@@ -1,136 +0,0 @@
-# Changelog
-
-All notable changes to surf CLI will be documented in this file.
-
-## [2.2.0] - 2026-01-07
-
-### Added
-- Network capture: `network`, `network.stats`, `network.origins`, `network.get`, `network.clear`, `network.export`
-- Filtering by method, status, URL, content-type
-- Export formats: curl, raw JSON, URL list
-- Persistence to `/tmp/surf/` (configurable via `SURF_NETWORK_PATH`)
-
-## [2.1.0] - 2025-12-30
-
-### Added
-
-**ChatGPT Integration**
-- `chatgpt <query>` - Send prompt to ChatGPT using browser cookies (no API key)
-  - `--with-page` - Include current page context
-  - `--model` - Specify model (gpt-4o, o1, etc.)
-  - `--timeout` - Custom timeout (default: 45 minutes)
-  - File attachments coming soon
-
-**Gemini Integration (Coming Soon)**
-- `gemini <query>` - Command structure ready, implementation pending
-
-**Request Queue**
-- AI requests are queued sequentially with 2s minimum delay between requests
-- Prevents rate limiting when making multiple AI queries
-
-### Technical Changes
-- New `chatgpt-client.cjs` module for ChatGPT browser automation
-- Extension: `GET_CHATGPT_COOKIES`, `GET_GOOGLE_COOKIES` handlers
-- Extension: `CHATGPT_NEW_TAB`, `CHATGPT_CLOSE_TAB`, `CHATGPT_CDP_COMMAND`, `CHATGPT_EVALUATE` handlers
-- CDP controller: Added public `sendCommand()` method
-
-## [2.0.0] - 2025-12-27
-
-### Breaking Changes
-- Removed snake_case command aliases (use dot-notation instead)
-  - `read_page` -> `page.read`
-  - `list_tabs` -> `tab.list`
-  - `wait_for_element` -> `wait.element`
-  - `javascript_tool` -> `js`
-  - And others (see REMOVED_COMMANDS in cli.cjs for full list)
-- Removed all single-letter short flags for consistency
-  - Use `--output` instead of `-o`
-  - Use `--ref` instead of `-r`
-  - Use `--annotate` instead of `-a`
-  - Use `--fullpage` instead of `-f`
-- Migration hints shown when using old command names
-
-### Added
-
-**Navigation**
-- `back` - Go back in browser history
-- `forward` - Go forward in browser history
-- `tab.reload` - Reload tab (with `--hard` for cache bypass)
-
-**Tab Groups**
-- `tab.group` - Create or add to tab group
-- `tab.ungroup` - Remove tabs from group
-- `tab.groups` - List all tab groups
-
-**Zoom Control**
-- `zoom` - Get current zoom level
-- `zoom <level>` - Set zoom (e.g., `zoom 1.5` for 150%)
-- `zoom --reset` - Reset to default zoom
-
-**Cookies**
-- `cookie.list` - List cookies for current domain
-- `cookie.get` - Get specific cookie by name
-- `cookie.set` - Set a cookie
-- `cookie.clear` - Clear specific cookie or all (`--all`)
-
-**Search**
-- `search <term>` - Search for text in page (alias: `find`)
-- Returns match refs, context, and element associations
-
-**Batch Execution**
-- `batch --actions '[...]'` - Execute multiple actions
-- `batch --file workflow.json` - Load actions from file
-
-**Bookmarks**
-- `bookmark.add` - Bookmark current page
-- `bookmark.remove` - Remove bookmark for current page
-- `bookmark.list` - List bookmarks
-
-**History**
-- `history.list` - Recent browser history
-- `history.search <query>` - Search history
-
-**Screenshot Enhancements**
-- `--annotate` - Draw element labels on screenshot
-- `--fullpage` - Capture entire scrollable page
-- `--max-height` - Limit fullpage capture height (default: 4000px)
-- Extension UI automatically hidden during capture
-
-**Aliases**
-- `snap` -> `screenshot` (auto-saves to /tmp if no output specified)
-- `read` -> `page.read`
-- `find` -> `search`
-- `go` -> `navigate`
-
-**Discovery Features**
-- `--find <query>` - Fuzzy search for commands
-- `--about <topic>` - Learn about a topic
-
-**Help System**
-- `--help` - Basic help with common commands
-- `--help-full` - Complete command reference
-- `--help-topic <topic>` - Topic-specific guide
-- Command-level help with examples
-
-**Other**
-- `--version` - Show version
-- `click 100 200` - Positional coordinates for click
-- `click --selector ".btn" --index 2` - Click nth element matching selector
-
-### Changed
-- Primary argument support for commands:
-  - `wait.element <selector>` (was `--selector`)
-  - `wait.url <pattern>` (was `--pattern`)
-  - `click <ref>` with e-prefix detection (e.g., `click e5`)
-- Help output includes usage examples for all commands
-- `dialog.dismiss --all` for repeatedly dismissing dialogs
-- Fullpage screenshot delay increased to 300ms for lazy-loaded content
-- Error messages standardized to terse format for AI consumption
-
-### Fixed
-- `--limit 0` now correctly returns empty results (was defaulting to max)
-- Screenshot always hides extension UI (was conditional on `--clean` flag)
-
-## [1.x] - Previous Releases
-
-See git history for changes before v2.0.0.

package/native/README.md

@@ -1,141 +0,0 @@
-# Surf Native Host
-
-Native messaging host that bridges CLI commands to the Chrome extension via Unix socket.
-
-## Architecture
-
-```
-CLI (surf) → Unix Socket (/tmp/surf.sock) → Native Host → Chrome Extension → CDP
-```
-
-## Files
-
-| File | Purpose |
-|------|---------|
-| `host.cjs` | Main native host with socket server and tool handling |
-| `cli.cjs` | CLI tool for browser automation |
-| `chatgpt-client.cjs` | ChatGPT browser automation client |
-| `protocol.cjs` | Chrome native messaging protocol helpers |
-| `host-wrapper.py` | Python wrapper for native host execution |
-| `host.sh` | Shell script to start the host |
-
-## Setup
-
-1. Install the native host manifest:
-```bash
-npm run install:native <extension-id>
-```
-
-Or manually:
-```bash
-mkdir -p ~/Library/Application\ Support/Google/Chrome/NativeMessagingHosts
-cat > ~/Library/Application\ Support/Google/Chrome/NativeMessagingHosts/com.anthropic.pi_chrome.json << EOF
-{
-  "name": "com.anthropic.pi_chrome",
-  "description": "Surf CLI Native Host",
-  "path": "$PWD/host-wrapper.py",
-  "type": "stdio",
-  "allowed_origins": ["chrome-extension://YOUR_EXTENSION_ID/"]
-}
-EOF
-```
-
-2. Start the native host:
-```bash
-node host.cjs
-```
-
-The host creates a Unix socket at `/tmp/surf.sock`.
-
-## CLI Reference
-
-See the main [README](../README.md) for full CLI documentation.
-
-### Quick Reference
-
-```bash
-surf go "https://example.com"       # Navigate
-surf read                           # Get accessibility tree
-surf click e5                       # Click element
-surf type "hello" --submit          # Type and submit
-surf snap                           # Screenshot to /tmp
-surf chatgpt "explain this"         # Query ChatGPT
-```
-
-### Global Options
-
-```bash
---tab-id <id>     # Target specific tab
---json            # Output raw JSON
---soft-fail       # Warn instead of error on restricted pages
---no-screenshot   # Skip auto-screenshot after actions
---full            # Full resolution screenshots
-```
-
-## Protocol
-
-### Tool Request
-
-```json
-{
-  "type": "tool_request",
-  "method": "execute_tool",
-  "params": {
-    "tool": "TOOL_NAME",
-    "args": { ... },
-    "tabId": 123
-  },
-  "id": "unique-request-id"
-}
-```
-
-### Tool Response (Success)
-
-```json
-{
-  "type": "tool_response",
-  "id": "unique-request-id",
-  "result": {
-    "content": [
-      { "type": "text", "text": "Result message" }
-    ]
-  }
-}
-```
-
-### Tool Response (With Image)
-
-```json
-{
-  "type": "tool_response",
-  "id": "unique-request-id",
-  "result": {
-    "content": [
-      { "type": "text", "text": "Screenshot captured" },
-      { "type": "image", "data": "base64...", "mimeType": "image/png" }
-    ]
-  }
-}
-```
-
-### Tool Response (Error)
-
-```json
-{
-  "type": "tool_response",
-  "id": "unique-request-id",
-  "error": {
-    "content": [{ "type": "text", "text": "Error message" }]
-  }
-}
-```
-
-## Troubleshooting
-
-| Issue | Solution |
-|-------|----------|
-| Socket not found | Ensure `node host.cjs` is running |
-| No response | Check extension is loaded in Chrome |
-| "Content script not loaded" | Navigate to a page first |
-| "Cannot control this page" | Page is restricted (chrome://, extensions) - use `--soft-fail` |
-| Slow first operation | Normal - CDP debugger attachment takes ~100-500ms |