surf-cli 2.2.0 → 2.4.0

package/native/chatgpt-client.cjs

@@ -150,22 +150,23 @@ async function selectModel(cdp, desiredModel, timeoutMs = 8000) {
     })()`
   );
   await delay(300);
+  // Select from menu - loop in Node.js to avoid CDP timeout issues
   const normalizedModel = desiredModel.toLowerCase().replace(/[^a-z0-9]/g, "");
-  const result = await evaluate(
-    cdp,
-    `(async () => {
-      ${buildClickDispatcher()}
-      const TIMEOUT_MS = ${timeoutMs};
-      const targetModel = ${JSON.stringify(normalizedModel)};
-      const menuSelector = '${SELECTORS.menuContainer}';
-      const itemSelector = '${SELECTORS.menuItem}';
-      const normalize = (text) => (text || '').toLowerCase().replace(/[^a-z0-9]/g, '');
-      const deadline = Date.now() + TIMEOUT_MS;
-      while (Date.now() < deadline) {
+  const deadline = Date.now() + timeoutMs;
+  
+  while (Date.now() < deadline) {
+    const result = await evaluate(
+      cdp,
+      `(() => {
+        ${buildClickDispatcher()}
+        const targetModel = ${JSON.stringify(normalizedModel)};
+        const menuSelector = '${SELECTORS.menuContainer}';
+        const itemSelector = '${SELECTORS.menuItem}';
+        const normalize = (text) => (text || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+        
         const menu = document.querySelector(menuSelector);
         if (!menu) {
-          await new Promise(r => setTimeout(r, 100));
-          continue;
+          return { found: false, waiting: true };
         }
         const items = Array.from(menu.querySelectorAll(itemSelector));
         let bestMatch = null;
@@ -183,18 +184,24 @@ async function selectModel(cdp, desiredModel, timeoutMs = 8000) {
         }
         if (bestMatch) {
           dispatchClickSequence(bestMatch);
-          await new Promise(r => setTimeout(r, 200));
-          return { success: true, label: bestMatch.textContent?.trim() };
+          return { found: true, success: true, label: 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.label;
       }
-      return { success: false, error: 'Model option not found' };
-    })()`
-  );
-  if (!result || !result.success) {
-    throw new Error(`Model not found: ${desiredModel}`);
+      throw new Error(`Model not found: ${desiredModel}`);
+    }
+    
+    await delay(100);
   }
-  return result.label;
+  
+  throw new Error(`Model not found: ${desiredModel} (timeout)`);
 }
 
 async function typePrompt(cdp, inputCdp, prompt) {

package/native/cli.cjs

@@ -5,6 +5,8 @@ const { execSync } = require("child_process");
 const { loadConfig, getConfigPath, createStarterConfig } = require("./config.cjs");
 const networkFormatters = require("./formatters/network.cjs");
 const networkStore = require("./network-store.cjs");
+const { parseDoCommands } = require("./do-parser.cjs");
+const { executeDoSteps } = require("./do-executor.cjs");
 
 const SOCKET_PATH = "/tmp/surf.sock";
 
@@ -146,6 +148,27 @@ const TOOLS = {
           { cmd: 'perplexity "latest AI news" --model sonar', desc: "Specify model (Pro)" },
         ]
       },
+      "grok": {
+        desc: "Query Grok AI with real-time X/Twitter data access (uses browser session)",
+        args: ["query"],
+        opts: {
+          "with-page": "Include current page context",
+          model: "Model: auto, fast, expert, thinking (default)",
+          "deep-search": "Enable DeepSearch for X post searching",
+          timeout: "Timeout in seconds (default: 300 for thinking models)",
+          validate: "Check Grok UI and scrape available models (no query sent)",
+          "save-models": "Save discovered models to surf.json config"
+        },
+        examples: [
+          { cmd: 'grok "what are the latest AI agent trends on X"', desc: "Search X posts" },
+          { cmd: 'grok "analyze @username recent activity"', desc: "Profile analysis" },
+          { cmd: 'grok "summarize this page" --with-page', desc: "With page context" },
+          { cmd: 'grok "find viral AI posts" --deep-search', desc: "DeepSearch mode" },
+          { cmd: 'grok "quick question" --model fast', desc: "Faster model" },
+          { cmd: 'grok --validate', desc: "Check UI and list available models" },
+          { cmd: 'grok --validate --save-models', desc: "Save discovered models to settings" },
+        ]
+      },
       "ai": { 
         desc: "Analyze page with AI (requires GOOGLE_API_KEY)", 
         args: ["query"], 
@@ -780,6 +803,27 @@ const TOOLS = {
       },
     }
   },
+  workflow: {
+    desc: "Workflow execution",
+    commands: {
+      "do": {
+        desc: "Execute multiple commands as a single workflow",
+        args: ["commands"],
+        opts: {
+          file: "Load workflow from JSON file",
+          "on-error": "stop (default) | continue",
+          "no-auto-wait": "Disable automatic waits between steps",
+          "step-delay": "Delay between steps in ms (default: 100)",
+          "dry-run": "Parse and validate without executing"
+        },
+        examples: [
+          { cmd: 'do \'go "https://example.com"\\nclick e5\\nscreenshot\'', desc: "Inline workflow" },
+          { cmd: 'do -f login.json', desc: "From JSON file" },
+          { cmd: 'do \'go "url"\\nclick e5\' --dry-run', desc: "Validate without running" },
+        ]
+      },
+    }
+  },
   zoom: {
     desc: "Zoom control",
     commands: {
@@ -1704,7 +1748,139 @@ if (args.includes("--script")) {
   return;
 }
 
-const BOOLEAN_FLAGS = ["auto-capture", "json", "stream", "dry-run", "stop-on-error", "fail-fast", "clear", "submit", "all", "case-sensitive", "hard", "annotate", "fullpage", "reset", "no-screenshot", "full", "soft-fail", "has-body", "exclude-static", "v", "vv", "request", "by-tab", "har", "jsonl", "no-save"];
+// Handle `surf do` workflow command
+// Must be parsed before general parseArgs since it uses its own arg handling
+if (args[0] === "do") {
+  const doArgs = args.slice(1);
+  let commandsInput = null;
+  let fileInput = null;
+  let dryRun = false;
+  let onError = "stop";
+  let noAutoWait = false;
+  let stepDelay = 100;
+  let wantJson = false;
+  let tabId = undefined;
+  let windowId = undefined;
+  
+  // Parse do-specific arguments
+  for (let i = 0; i < doArgs.length; i++) {
+    const arg = doArgs[i];
+    if (arg === "--file" || arg === "-f") {
+      fileInput = doArgs[i + 1];
+      i++;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--on-error") {
+      onError = doArgs[i + 1] || "stop";
+      i++;
+    } else if (arg === "--no-auto-wait") {
+      noAutoWait = true;
+    } else if (arg === "--step-delay") {
+      const parsed = parseInt(doArgs[i + 1], 10);
+      stepDelay = isNaN(parsed) ? 100 : parsed;
+      i++;
+    } else if (arg === "--json") {
+      wantJson = true;
+    } else if (arg === "--tab-id") {
+      tabId = parseInt(doArgs[i + 1], 10);
+      i++;
+    } else if (arg === "--window-id") {
+      windowId = parseInt(doArgs[i + 1], 10);
+      i++;
+    } else if (!arg.startsWith("-")) {
+      commandsInput = arg;
+    }
+  }
+  
+  if (!commandsInput && !fileInput) {
+    console.error("Error: commands string or --file required");
+    console.error('Usage: surf do \'go "url"\\nclick e5\'');
+    console.error("       surf do --file workflow.json");
+    process.exit(1);
+  }
+  
+  let steps;
+  try {
+    if (fileInput) {
+      if (!fs.existsSync(fileInput)) {
+        console.error(`Error: File not found: ${fileInput}`);
+        process.exit(1);
+      }
+      const content = fs.readFileSync(fileInput, "utf8");
+      // JSON file format (same as --script)
+      const script = JSON.parse(content);
+      if (!script.steps || !Array.isArray(script.steps)) {
+        throw new Error("JSON must have a 'steps' array");
+      }
+      // Convert --script format { tool, args } to do format { cmd, args }
+      steps = script.steps.map(s => ({ cmd: s.tool, args: s.args || {} }));
+    } else {
+      // Inline string parsing
+      steps = parseDoCommands(commandsInput);
+    }
+  } catch (e) {
+    console.error(`Error: Failed to parse workflow: ${e.message}`);
+    process.exit(1);
+  }
+  
+  if (steps.length === 0) {
+    console.error("Error: No commands found in workflow");
+    process.exit(1);
+  }
+  
+  // Validate with --dry-run
+  if (dryRun) {
+    console.log(`Would execute ${steps.length} steps:`);
+    steps.forEach((s, i) => {
+      const argStr = Object.entries(s.args || {})
+        .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+        .join(" ");
+      console.log(`  ${i + 1}. ${s.cmd} ${argStr}`);
+    });
+    process.exit(0);
+  }
+  
+  if (!wantJson) {
+    console.log(`Running workflow (${steps.length} steps)...\n`);
+  }
+  
+  const runWorkflow = async () => {
+    const result = await executeDoSteps(steps, {
+      onError,
+      autoWait: !noAutoWait,
+      stepDelay,
+      quiet: wantJson,
+      context: {
+        tabId,
+        windowId,
+      },
+    });
+    
+    // Print summary
+    if (wantJson) {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(result.status === "completed" ? 0 : 1);
+    }
+    
+    console.log("");
+    if (result.status === "completed") {
+      console.log(`Completed: ${result.completedSteps}/${result.totalSteps} steps (${result.totalMs}ms)`);
+      process.exit(0);
+    } else if (result.status === "partial") {
+      console.log(`Partial: ${result.completedSteps}/${result.totalSteps} steps completed, ${result.failed} failed`);
+      process.exit(1);
+    } else {
+      console.error(`Failed: ${result.completedSteps}/${result.totalSteps} steps completed`);
+      if (result.error) console.error(`Error: ${result.error}`);
+      process.exit(1);
+    }
+  };
+  
+  runWorkflow();
+  return;
+}
+
+const BOOLEAN_FLAGS = ["auto-capture", "json", "stream", "dry-run", "stop-on-error", "fail-fast", "clear", "submit", "all", "case-sensitive", "hard", "annotate", "fullpage", "reset", "no-screenshot", "full", "soft-fail", "has-body", "exclude-static", "v", "vv", "request", "by-tab", "har", "jsonl", "no-save", "no-auto-wait"];
 
 const AUTO_SCREENSHOT_TOOLS = ["click", "type", "key", "smart_type", "form.fill", "form_input", "drag", "hover", "scroll", "scroll.top", "scroll.bottom", "scroll.to", "dialog.accept", "dialog.dismiss", "js", "eval"];
 
@@ -1734,8 +1910,12 @@ const parseArgs = (rawArgs) => {
       result.options.v = true;
     } else if (arg === "-vv") {
       result.options.vv = true;
+    } else if (arg === "-f" && rawArgs[i + 1] && !rawArgs[i + 1].startsWith("-")) {
+      // -f takes a file path argument (for surf do -f <file>)
+      result.options.file = rawArgs[i + 1];
+      i++;
     } else if (arg.startsWith("-") && arg.length === 2) {
-      // Short flag like -n, -f
+      // Short flag like -n
       result.options[arg.slice(1)] = true;
     } else {
       result.positional.push(arg);
@@ -1802,6 +1982,7 @@ const PRIMARY_ARG_MAP = {
   gemini: "query",
   chatgpt: "query",
   perplexity: "query",
+  grok: "query",
   navigate: "url",
   go: "url",
   js: "code",
@@ -2168,7 +2349,7 @@ const socket = net.createConnection(SOCKET_PATH, () => {
   socket.write(JSON.stringify(request) + "\n");
 });
 
-const AI_TOOLS = ["smoke", "chatgpt", "gemini", "perplexity", "ai"];
+const AI_TOOLS = ["smoke", "chatgpt", "gemini", "perplexity", "grok", "ai"];
 const requestTimeout = AI_TOOLS.includes(tool) ? 300000 : 30000;
 const timeout = setTimeout(() => {
   console.error(`Error: Request timed out (${requestTimeout / 1000}s)`);

package/native/config.cjs

@@ -21,6 +21,18 @@ const STARTER_CONFIG = {
   }
 };
 
+// Grok models can be customized in surf.json if X.com UI changes:
+// {
+//   "grok": {
+//     "models": {
+//       "thinking": { "id": "thinking", "name": "Grok 4.1 Thinking" },
+//       "auto": { "id": "auto", "name": "Auto" },
+//       "fast": { "id": "fast", "name": "Fast" },
+//       "expert": { "id": "expert", "name": "Expert" }
+//     }
+//   }
+// }
+
 function findConfigPath() {
   const cwdPath = path.join(process.cwd(), CONFIG_NAME);
   if (fs.existsSync(cwdPath)) {

package/native/do-executor.cjs

@@ -0,0 +1,273 @@
+/**
+ * Executor for surf `do` workflow commands
+ * 
+ * Executes steps sequentially with auto-waits and streaming progress output.
+ * Follows the same socket communication pattern as --script mode in cli.cjs.
+ */
+
+const net = require("net");
+
+const SOCKET_PATH = "/tmp/surf.sock";
+
+// Commands that trigger auto-wait after execution
+// Note: 'type' is intentionally excluded - typing doesn't trigger navigation or DOM changes
+const AUTO_WAIT_COMMANDS = [
+  'go', 'navigate', 'click', 'key', 'form.fill', 'submit',
+  'tab.switch', 'tab.new', 'back', 'forward'
+];
+
+// Auto-wait strategies per command type
+const AUTO_WAIT_MAP = {
+  'navigate': 'wait.load',
+  'go': 'wait.load',
+  'click': 'wait.dom',
+  'key': 'wait.dom',
+  'form.fill': 'wait.dom',
+  'submit': 'wait.load',  // Form submission typically triggers navigation
+  'tab.switch': 'wait.load',
+  'tab.new': 'wait.load',
+  'back': 'wait.load',
+  'forward': 'wait.load',
+};
+
+/**
+ * Check if a command should trigger an auto-wait
+ * @param {string} cmd - Command name
+ * @returns {boolean}
+ */
+function shouldAutoWait(cmd) {
+  return AUTO_WAIT_COMMANDS.some(c => cmd === c || cmd.startsWith(c + '.'));
+}
+
+/**
+ * Get the appropriate auto-wait command for a given command
+ * @param {string} cmd - Command name
+ * @returns {string|null} - Wait command to execute, or null
+ */
+function getAutoWaitCommand(cmd) {
+  // Check exact match first
+  if (AUTO_WAIT_MAP[cmd] !== undefined) return AUTO_WAIT_MAP[cmd];
+  
+  // Check prefix match
+  for (const [prefix, waitCmd] of Object.entries(AUTO_WAIT_MAP)) {
+    if (cmd.startsWith(prefix + '.')) return waitCmd;
+  }
+  
+  return null;
+}
+
+/**
+ * Send a single tool request over socket
+ * @param {string} toolName - Tool/command name
+ * @param {object} toolArgs - Tool arguments
+ * @param {object} context - Execution context (tabId, windowId)
+ * @returns {Promise<object>} - Response from host
+ */
+function sendDoRequest(toolName, toolArgs, context = {}) {
+  return new Promise((resolve, reject) => {
+    const sock = net.createConnection(SOCKET_PATH, () => {
+      const req = {
+        type: "tool_request",
+        method: "execute_tool",
+        params: { tool: toolName, args: toolArgs },
+        id: "do-" + Date.now() + "-" + Math.random(),
+      };
+      if (context.tabId) req.tabId = context.tabId;
+      if (context.windowId) req.windowId = context.windowId;
+      sock.write(JSON.stringify(req) + "\n");
+    });
+    
+    let buf = "";
+    sock.on("data", (d) => {
+      buf += d.toString();
+      const lines = buf.split("\n");
+      buf = lines.pop();
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const resp = JSON.parse(line);
+          sock.end();
+          resolve(resp);
+        } catch {
+          sock.end();
+          reject(new Error("Invalid JSON response"));
+        }
+      }
+    });
+    
+    sock.on("error", (e) => {
+      if (e.code === "ENOENT") {
+        reject(new Error("Socket not found. Is Chrome running with the extension?"));
+      } else if (e.code === "ECONNREFUSED") {
+        reject(new Error("Connection refused. Native host not running."));
+      } else {
+        reject(e);
+      }
+    });
+    
+    const timeoutId = setTimeout(() => { 
+      sock.destroy(); 
+      reject(new Error("Request timeout")); 
+    }, 30000);
+    
+    sock.on("close", () => clearTimeout(timeoutId));
+  });
+}
+
+/**
+ * Substitute variables in arguments using %{varname} syntax
+ * @param {object} args - Arguments object
+ * @param {object} vars - Variables map
+ * @returns {object} - Arguments with variables substituted
+ */
+function substituteVars(args, vars) {
+  if (!args || typeof args !== 'object') return args;
+  
+  const result = {};
+  for (const [key, val] of Object.entries(args)) {
+    if (typeof val === 'string') {
+      result[key] = val.replace(/%\{(\w+)\}/g, (_, name) => vars[name] ?? `%{${name}}`);
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+/**
+ * Execute all workflow steps sequentially
+ * @param {Array<{ cmd: string, args: object }>} steps - Steps to execute
+ * @param {object} options - Execution options
+ * @returns {Promise<object>} - Execution result
+ */
+async function executeDoSteps(steps, options = {}) {
+  const {
+    onError = 'stop',
+    autoWait = true,
+    stepDelay = 100,
+    context = {},
+    quiet = false,  // For --json mode, suppress streaming output
+  } = options;
+  
+  const results = [];
+  const vars = context.vars || {};
+  const total = steps.length;
+  let failed = 0;
+  const startTotal = Date.now();
+  
+  for (let i = 0; i < total; i++) {
+    const step = steps[i];
+    const startTime = Date.now();
+    const stepNum = `[${i + 1}/${total}]`;
+    
+    // Build description (matches --script output format)
+    const argSummary = Object.entries(step.args || {})
+      .map(([k, v]) => typeof v === "string" && v.length > 40 
+        ? `${k}="${v.slice(0, 37)}..."` 
+        : `${k}=${JSON.stringify(v)}`)
+      .join(" ");
+    const desc = argSummary ? `${step.cmd} ${argSummary}` : step.cmd;
+    
+    // Print step prefix (streaming output)
+    if (!quiet) {
+      process.stdout.write(`${stepNum} ${desc} ... `);
+    }
+    
+    try {
+      // Substitute variables in args
+      const resolvedArgs = substituteVars(step.args, vars);
+      
+      const resp = await sendDoRequest(step.cmd, resolvedArgs, context);
+      const ms = Date.now() - startTime;
+      
+      if (resp.error) {
+        const errText = resp.error.content?.[0]?.text || JSON.stringify(resp.error);
+        
+        if (!quiet) {
+          console.log(`FAIL`);
+          console.log(`     Error: ${errText}`);
+        }
+        
+        results.push({ step: i + 1, cmd: step.cmd, status: 'error', error: errText, ms });
+        failed++;
+        
+        if (onError === 'stop') {
+          return { 
+            status: 'failed', 
+            completedSteps: i, 
+            totalSteps: total, 
+            results, 
+            error: errText,
+            totalMs: Date.now() - startTotal
+          };
+        }
+      } else {
+        if (!quiet) {
+          console.log(`OK (${ms}ms)`);
+        }
+        
+        results.push({ step: i + 1, cmd: step.cmd, status: 'ok', ms });
+        
+        // Command-specific auto-wait
+        if (autoWait) {
+          const waitCmd = getAutoWaitCommand(step.cmd);
+          if (waitCmd) {
+            const waitArgs = waitCmd === 'wait.load' 
+              ? { timeout: 10000 } 
+              : { stable: 100, timeout: 5000 };
+            try {
+              await sendDoRequest(waitCmd, waitArgs, context);
+            } catch {
+              // Ignore auto-wait failures silently
+            }
+          }
+        }
+      }
+      
+      // Fixed delay between steps
+      if (stepDelay > 0 && i < total - 1) {
+        await new Promise(r => setTimeout(r, stepDelay));
+      }
+    } catch (err) {
+      const ms = Date.now() - startTime;
+      
+      if (!quiet) {
+        console.log(`FAIL`);
+        console.log(`     Error: ${err.message}`);
+      }
+      
+      results.push({ step: i + 1, cmd: step.cmd, status: 'error', error: err.message, ms });
+      failed++;
+      
+      if (onError === 'stop') {
+        return { 
+          status: 'failed', 
+          completedSteps: i, 
+          totalSteps: total, 
+          results, 
+          error: err.message,
+          totalMs: Date.now() - startTotal
+        };
+      }
+    }
+  }
+  
+  return { 
+    status: failed > 0 ? 'partial' : 'completed', 
+    completedSteps: total - failed, 
+    totalSteps: total, 
+    results,
+    failed,
+    totalMs: Date.now() - startTotal
+  };
+}
+
+module.exports = { 
+  executeDoSteps, 
+  sendDoRequest, 
+  shouldAutoWait,
+  getAutoWaitCommand,
+  substituteVars,
+  AUTO_WAIT_COMMANDS,
+  AUTO_WAIT_MAP
+};