surf-cli 2.5.2 → 2.6.0

package/native/aistudio-response.cjs

@@ -0,0 +1,336 @@
+/**
+ * AI Studio response extraction for surf-cli
+ *
+ * Two extraction strategies:
+ *   1. Network-first: intercept GenerateContent RPC responses (structured, reliable)
+ *   2. DOM fallback: walk the page DOM for rendered response text (when network fails)
+ */
+
+const {
+  cleanAiStudioResponse,
+  delay,
+  parseAiStudioRpcError,
+  parseAiStudioGenerateContentText,
+  extractGenerateEntries,
+  doesGenerateEntryMatchPrompt,
+} = require("./aistudio-parser.cjs");
+
+async function evaluate(cdp, expression) {
+  const result = await cdp(expression);
+  if (result.exceptionDetails) {
+    const desc = result.exceptionDetails.exception?.description ||
+                 result.exceptionDetails.text ||
+                 "Evaluation failed";
+    throw new Error(desc);
+  }
+  if (result.error) {
+    throw new Error(result.error);
+  }
+  return result.result?.value;
+}
+
+async function waitForGenerateResponseFromNetwork(params) {
+  const {
+    tabId,
+    readNetworkEntries,
+    timeoutMs = 300000,
+    baselineEntryIds = new Set(),
+    prompt = '',
+    log = () => {},
+  } = params;
+
+  const deadline = Date.now() + timeoutMs;
+  let lastSeenCount = -1;
+  const parseErrorCounts = new Map();
+
+  while (Date.now() < deadline) {
+    const network = await readNetworkEntries(tabId);
+
+    if (network?.error) {
+      throw new Error(String(network.error));
+    }
+
+    const allEntries = Array.isArray(network?.entries)
+      ? network.entries
+      : Array.isArray(network?.requests)
+        ? network.requests
+        : [];
+
+    const generateEntries = extractGenerateEntries(allEntries);
+
+    if (generateEntries.length !== lastSeenCount) {
+      lastSeenCount = generateEntries.length;
+      log(`GenerateContent network entries seen: ${generateEntries.length}`);
+    }
+
+    const freshEntries = generateEntries.filter((entry) => !baselineEntryIds.has(entry.id));
+
+    for (const entry of freshEntries) {
+      if (!doesGenerateEntryMatchPrompt(entry, prompt)) {
+        log(`Skipping GenerateContent entry ${entry?.id || 'unknown'} (prompt mismatch)`);
+        continue;
+      }
+
+      const status = Number(entry?.status || 0);
+      const body = typeof entry?.responseBody === 'string' ? entry.responseBody : '';
+
+      if (status >= 400) {
+        const rpcError = parseAiStudioRpcError(body);
+        const msg = rpcError?.message || `HTTP ${status}`;
+        throw new Error(`AI Studio GenerateContent failed (${status}): ${msg}`);
+      }
+
+      if (status !== 200 || !body) {
+        continue;
+      }
+
+      let parsedText = '';
+      try {
+        parsedText = parseAiStudioGenerateContentText(body);
+      } catch (e) {
+        const requestId = entry.id || 'unknown';
+        const parseErrorCount = (parseErrorCounts.get(requestId) || 0) + 1;
+        parseErrorCounts.set(requestId, parseErrorCount);
+
+        log(`GenerateContent parse error (${requestId} #${parseErrorCount}): ${e.message || e}`);
+
+        if (parseErrorCount >= 3) {
+          throw new Error(`GenerateContent body for ${requestId} is not parseable; falling back to DOM`);
+        }
+
+        continue;
+      }
+
+      if (parsedText && parsedText.length > 0) {
+        return {
+          text: parsedText,
+          requestId: entry.id,
+          status,
+        };
+      }
+    }
+
+    await delay(350);
+  }
+
+  throw new Error('Timed out waiting for AI Studio GenerateContent network response');
+}
+
+async function waitForResponse(cdp, timeoutMs = 300000, userPrompt = '', log = () => {}) {
+  const deadline = Date.now() + timeoutMs;
+
+  await delay(1000);
+
+  let doneStreak = 0;
+
+  while (Date.now() < deadline) {
+    const status = await evaluate(cdp, `(function() {
+      var buttons = Array.from(document.querySelectorAll('button'));
+
+      var bodyText = (document.body && document.body.innerText ? document.body.innerText : '').toLowerCase();
+
+      var rateLimitMsg = null;
+      if (bodyText.indexOf("you've reached your rate limit") !== -1) {
+        rateLimitMsg = "You've reached your rate limit. Please try again later.";
+      } else if (bodyText.indexOf('failed to generate content: user has exceeded quota') !== -1) {
+        rateLimitMsg = "Failed to generate content: user has exceeded quota. Please try again later.";
+      }
+      var rateLimited = rateLimitMsg !== null;
+
+      var hasRatingBtns = buttons.some(function(b) {
+        return (b.getAttribute('aria-label') || b.textContent || '').toLowerCase().indexOf('good response') !== -1;
+      });
+
+      var hasStopBtn = buttons.some(function(b) {
+        var label = (b.getAttribute('aria-label') || '').toLowerCase();
+        var text = (b.textContent || '').toLowerCase();
+        return text.indexOf('stop') !== -1 || label.indexOf('stop') !== -1 || text.indexOf('running') !== -1;
+      });
+
+      return {
+        done: hasRatingBtns && !hasStopBtn,
+        hasStopBtn: hasStopBtn,
+        rateLimited: rateLimited,
+        rateLimitMsg: rateLimitMsg
+      };
+    })()`);
+
+    if (status && status.rateLimited) {
+      const msg = status.rateLimitMsg || "You've reached your rate limit. Please try again later.";
+      throw new Error(
+        `AI Studio rate limited: ${msg} ` +
+        "(Tip: use `surf gemini` / another provider as a fallback.)"
+      );
+    }
+
+    if (status && status.done) {
+      doneStreak++;
+      if (doneStreak === 1) {
+        log("Completion signal detected (waiting for stability...)");
+      }
+      if (doneStreak >= 3) {
+        log("Completion signal stable");
+        break;
+      }
+    } else {
+      doneStreak = 0;
+    }
+
+    await delay(500);
+  }
+
+  if (Date.now() >= deadline) {
+    throw new Error("Response timeout - AI Studio did not complete in time");
+  }
+
+  await delay(800);
+
+  const extractScript = `(function() {
+    function stripUi(text) {
+      if (!text) return '';
+
+      var removeLabels = ['Edit', 'Rerun this turn', 'Open options', 'Good response', 'Bad response'];
+      var removeSet = {};
+      for (var i = 0; i < removeLabels.length; i++) {
+        removeSet[String(removeLabels[i]).toLowerCase()] = true;
+      }
+
+      var lines = String(text).split(/\\r?\\n/);
+      var kept = [];
+
+      for (var j = 0; j < lines.length; j++) {
+        var line = lines[j];
+        var trimmed = (line || '').trim();
+        if (!trimmed) {
+          kept.push('');
+          continue;
+        }
+
+        if (removeSet[trimmed.toLowerCase()]) continue;
+        kept.push(line);
+      }
+
+      return kept.join('\\n').trim();
+    }
+
+    var buttons = Array.from(document.querySelectorAll('button'));
+    var goodBtn = buttons.find(function(b) {
+      return (b.getAttribute('aria-label') || b.textContent || '').toLowerCase().indexOf('good response') !== -1;
+    });
+
+    if (goodBtn) {
+      var container = goodBtn.parentElement;
+      while (container && container !== document.body) {
+        try {
+          var big = Array.from(container.querySelectorAll('[class*="very-large-text-container"]'));
+          if (big && big.length) {
+            var t = (big[big.length - 1].innerText || '').trim();
+            if (t && t.length > 10) {
+              return { text: stripUi(t), method: 'good-btn-large-container' };
+            }
+          }
+        } catch {}
+
+        var text = (container.innerText || '').trim();
+        if (text.length > 50) {
+          var cleaned = stripUi(text);
+          if (cleaned.length > 20) {
+            return { text: cleaned, method: 'good-btn-walk' };
+          }
+        }
+        container = container.parentElement;
+      }
+    }
+
+    var big2 = Array.from(document.querySelectorAll('[class*="very-large-text-container"]'));
+    if (big2 && big2.length) {
+      for (var j = big2.length - 1; j >= 0; j--) {
+        var tt = (big2[j].innerText || '').trim();
+        var ll = tt.toLowerCase();
+        if (tt.length > 50 && ll.indexOf('google ai studio uses cookies') === -1) {
+          return { text: stripUi(tt), method: 'very-large-text-container' };
+        }
+      }
+    }
+
+    var promptInput = document.querySelector('[role="textbox"][placeholder*="prompt" i], textarea[placeholder*="prompt" i]');
+    if (promptInput) {
+      var parent = promptInput.parentElement;
+      while (parent && parent !== document.body) {
+        var siblings = parent.parentElement ? Array.from(parent.parentElement.children) : [];
+        var myIdx = siblings.indexOf(parent);
+        for (var s = 0; s < myIdx; s++) {
+          var sibText = (siblings[s].innerText || '').trim();
+          if (sibText.length > 50) {
+            return { text: stripUi(sibText), method: 'sibling-walk' };
+          }
+        }
+        parent = parent.parentElement;
+      }
+    }
+
+    return { text: document.body.innerText || '', method: 'body-fallback' };
+  })()`;
+
+  let bestText = '';
+  let bestRaw = '';
+  let bestExtracted = null;
+  let lastText = null;
+  let stableCount = 0;
+
+  const extractDeadline = Math.min(deadline, Date.now() + 15000);
+
+  while (Date.now() < extractDeadline) {
+    const extracted = await evaluate(cdp, extractScript);
+    const responseTextRaw = extracted
+      ? String(extracted.text || '').trim()
+      : '';
+    const responseText = cleanAiStudioResponse(responseTextRaw, userPrompt);
+
+    if (responseText.length > bestText.length) {
+      bestText = responseText;
+      bestRaw = responseTextRaw;
+      bestExtracted = extracted;
+    }
+
+    if (lastText !== null && responseText === lastText && responseText.length > 5) {
+      stableCount++;
+      if (stableCount >= 2) {
+        log(
+          'Extraction stabilized: method=' + (extracted ? extracted.method : 'none') +
+          ', raw length=' + responseTextRaw.length +
+          ', cleaned length=' + responseText.length
+        );
+        return {
+          text: responseText,
+          thinkingTime: null,
+        };
+      }
+    } else {
+      stableCount = 0;
+      lastText = responseText;
+    }
+
+    await delay(700);
+  }
+
+  log(
+    'Extraction not stable before deadline; returning best length=' + bestText.length +
+    ', raw length=' + bestRaw.length +
+    ', method=' + (bestExtracted ? bestExtracted.method : 'none')
+  );
+
+  if (!bestText || bestText.length < 5) {
+    throw new Error('Could not extract response text from AI Studio');
+  }
+
+  return {
+    text: bestText,
+    thinkingTime: null,
+  };
+}
+
+module.exports = {
+  waitForGenerateResponseFromNetwork,
+  waitForResponse,
+};

package/native/cli.cjs

@@ -9,8 +9,12 @@ 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 { version: VERSION } = require("../package.json");
 
-const SOCKET_PATH = "/tmp/surf.sock";
+const IS_WIN = process.platform === "win32";
+const SURF_TMP = IS_WIN ? path.join(os.tmpdir(), "surf") : "/tmp";
+const SOCKET_PATH = IS_WIN ? "//./pipe/surf" : "/tmp/surf.sock";
+if (IS_WIN) { try { fs.mkdirSync(SURF_TMP, { recursive: true }); } catch {} }
 
 // ============================================================================
 // Workflow Resolution and Management
@@ -268,12 +272,13 @@ function resizeImage(filePath, maxSize) {
       const height = parseInt(sizeInfo.match(/pixelHeight:\s*(\d+)/)?.[1] || "0", 10);
       return { success: true, width, height };
     } else {
-      // Linux/other: use ImageMagick (try IM6 first, then IM7)
+      // Linux/Windows: use ImageMagick (try IM6 first, then IM7)
+      const resizeArg = IS_WIN ? `"${maxSize}x${maxSize}>"` : `${maxSize}x${maxSize}\\>`;
       try {
-        execSync(`convert "${filePath}" -resize ${maxSize}x${maxSize}\\> "${filePath}"`, { stdio: "pipe" });
+        execSync(`convert "${filePath}" -resize ${resizeArg} "${filePath}"`, { stdio: "pipe" });
       } catch {
         // IM7 uses 'magick' as main command
-        execSync(`magick "${filePath}" -resize ${maxSize}x${maxSize}\\> "${filePath}"`, { stdio: "pipe" });
+        execSync(`magick "${filePath}" -resize ${resizeArg} "${filePath}"`, { stdio: "pipe" });
       }
       // Get dimensions (IM7 may need 'magick identify' instead of just 'identify')
       let sizeInfo;
@@ -290,7 +295,6 @@ function resizeImage(filePath, maxSize) {
   }
 }
 const args = process.argv.slice(2);
-const VERSION = "2.5.2";
 
 const ALIASES = {
   snap: "screenshot",
@@ -414,6 +418,35 @@ const TOOLS = {
           { cmd: 'grok --validate --save-models', desc: "Save discovered models to settings" },
         ]
       },
+      "aistudio": {
+        desc: "Query via Google AI Studio (uses browser session)",
+        args: ["query"],
+        opts: {
+          "with-page": "Include current page context",
+          model: "Model (best-effort): pass an AI Studio model id like gemini-3.1-pro-preview, gemini-3-flash-preview, gemini-flash-lite-latest. If invalid, AI Studio uses the last-selected UI model",
+          timeout: "Timeout in seconds (default: 300)"
+        },
+        examples: [
+          { cmd: 'aistudio "explain quantum computing"', desc: "Basic query" },
+          { cmd: 'aistudio "redteam this" --with-page', desc: "With page context" },
+          { cmd: 'aistudio "quick answer" --model gemini-3-flash-preview', desc: "Model selection" },
+        ]
+      },
+      "aistudio.build": {
+        desc: "Build an app via Google AI Studio App Builder (uses browser session)",
+        args: ["query"],
+        opts: {
+          model: "Model override for Advanced Settings (e.g. gemini-3.1-pro-preview)",
+          output: "Directory to extract the downloaded zip",
+          timeout: "Build timeout in seconds (default: 600)",
+          "keep-open": "Keep the AI Studio tab open after completion",
+        },
+        examples: [
+          { cmd: 'aistudio.build "build a portfolio site"', desc: "Build with defaults" },
+          { cmd: 'aistudio.build "todo app with auth" --model gemini-3.1-pro-preview', desc: "Build with model override" },
+          { cmd: 'aistudio.build "crm dashboard" --output ./out', desc: "Build and extract to directory" },
+        ]
+      },
       "ai": { 
         desc: "Analyze page with AI (requires GOOGLE_API_KEY)", 
         args: ["query"], 
@@ -1752,8 +1785,7 @@ if (args[0] === "server") {
 }
 
 if (args[0] === "extension-path" || args[0] === "path") {
-  const path = require("path");
-  const distPath = path.resolve(__dirname, "../dist");
+  const distPath = process.env.SURF_EXTENSION_PATH || path.resolve(__dirname, "../dist");
   console.log(distPath);
   process.exit(0);
 }
@@ -1775,7 +1807,7 @@ Arguments:
 
 Options:
   -b, --browser   Browser(s) to install for (default: chrome)
-                  Values: chrome, chromium, brave, edge, arc, all
+                  Values: chrome, chromium, brave, edge, arc, helium, all
                   Multiple: --browser chrome,brave
 
 Examples:
@@ -1805,7 +1837,7 @@ Remove native messaging host configuration.
 
 Options:
   -b, --browser   Browser(s) to uninstall from (default: chrome)
-                  Values: chrome, chromium, brave, edge, arc, all
+                  Values: chrome, chromium, brave, edge, arc, helium, all
   -a, --all       Uninstall from all browsers and remove wrapper
 
 Examples:
@@ -2449,7 +2481,7 @@ tool = ALIASES[tool] || tool;
 const config = loadConfig();
 const autoSaveEnabled = config.autoSaveScreenshots !== false && !options["no-save"];
 if (tool === "screenshot" && !options.output && !options.savePath && autoSaveEnabled) {
-  options.savePath = `/tmp/surf-snap-${Date.now()}.png`;
+  options.savePath = path.join(SURF_TMP, `surf-snap-${Date.now()}.png`);
 }
 
 if (tool === "smoke") {
@@ -2485,6 +2517,8 @@ const PRIMARY_ARG_MAP = {
   chatgpt: "query",
   perplexity: "query",
   grok: "query",
+  aistudio: "query",
+  "aistudio.build": "query",
   navigate: "url",
   go: "url",
   js: "code",
@@ -2618,6 +2652,9 @@ if (!noScreenshot && AUTO_SCREENSHOT_TOOLS.includes(tool)) {
 
 const outputPath = toolArgs.output;
 delete toolArgs.output;
+if (tool === "aistudio.build" && outputPath) {
+  toolArgs.output = path.resolve(outputPath);
+}
 
 if (tool === "screenshot" && outputPath) {
   if (typeof outputPath !== "string") {
@@ -2813,7 +2850,7 @@ const sendRequest = (toolName, toolArgs = {}) => {
 
 const performAutoCapture = async () => {
   const timestamp = Date.now();
-  const screenshotPath = `/tmp/surf-error-${timestamp}.png`;
+  const screenshotPath = path.join(SURF_TMP, `surf-error-${timestamp}.png`);
 
   try {
     const [screenshotResp, consoleResp] = await Promise.all([
@@ -2851,8 +2888,12 @@ const socket = net.createConnection(SOCKET_PATH, () => {
   socket.write(JSON.stringify(request) + "\n");
 });
 
-const AI_TOOLS = ["smoke", "chatgpt", "gemini", "perplexity", "grok", "ai"];
-const requestTimeout = AI_TOOLS.includes(tool) ? 300000 : 30000;
+const AI_TOOLS = ["smoke", "chatgpt", "gemini", "perplexity", "grok", "aistudio", "aistudio.build", "ai"];
+let requestTimeout = AI_TOOLS.includes(tool) ? 300000 : 30000;
+if (tool === "aistudio.build") {
+  const userTimeoutSec = parseInt(options.timeout || "600", 10);
+  requestTimeout = (userTimeoutSec * 1000) + 60000;
+}
 const timeout = setTimeout(() => {
   console.error(`Error: Request timed out (${requestTimeout / 1000}s)`);
   socket.destroy();
@@ -2934,8 +2975,12 @@ async function handleResponse(response) {
     data = result || response.result;
   }
 
+  if (tool === 'aistudio' && typeof data === 'string') {
+    data = { response: data };
+  }
+
   if (wantJson) {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(data ?? null, null, 2));
     socket.end();
     process.exit(0);
   }
@@ -3105,6 +3150,30 @@ async function handleResponse(response) {
       console.log(`\nImage saved: ${data.imagePath}`);
     }
     console.error(`\n[${data.model || 'unknown'} | ${((data.tookMs || 0) / 1000).toFixed(1)}s]`);
+  } else if (tool === "aistudio" && data?.response) {
+    console.log(data.response);
+
+    const meta = [];
+    if (data.model) meta.push(data.model);
+    if (data.thinkingTime) meta.push(`thought ${data.thinkingTime}s`);
+    if (Number.isFinite(data.tookMs)) meta.push(`${(data.tookMs / 1000).toFixed(1)}s`);
+    if (meta.length > 0) {
+      console.error(`\n[${meta.join(' | ')}]`);
+    }
+  } else if (tool === "aistudio.build" && data?.zipPath) {
+    console.error(`Downloaded: ${data.zipPath}`);
+    if (data.extractedPath) {
+      console.error(`Extracted: ${data.extractedPath}`);
+      console.error("");
+    }
+
+    const meta = [];
+    if (data.model) meta.push(data.model);
+    if (Number.isFinite(data.buildDuration)) meta.push(`built ${data.buildDuration}s`);
+    if (Number.isFinite(data.tookMs)) meta.push(`${(data.tookMs / 1000).toFixed(1)}s total`);
+    if (meta.length > 0) {
+      console.error(`[${meta.join(" | ")}]`);
+    }
   } else if (tool === "perplexity" && data?.response) {
     console.log(data.response);
     const meta = [];

package/native/do-executor.cjs

@@ -12,7 +12,7 @@
 
 const net = require("net");
 
-const SOCKET_PATH = "/tmp/surf.sock";
+const SOCKET_PATH = process.platform === "win32" ? "//./pipe/surf" : "/tmp/surf.sock";
 
 // Maximum iterations for loops (safety cap)
 const MAX_LOOP_ITERATIONS = 100;

package/native/host-helpers.cjs

@@ -2,6 +2,10 @@ const fs = require("fs");
 const networkFormatters = require("./formatters/network.cjs");
 const networkStore = require("./network-store.cjs");
 
+function normalizeModelString(model) {
+  return String(model || "").trim().toLowerCase();
+}
+
 /**
  * Format tool result content for MCP response
  * @param {*} result - The result object from the extension
@@ -1070,6 +1074,31 @@ function mapToolToMessage(tool, args, tabId) {
         timeout: a.timeout ? parseInt(a.timeout, 10) * 1000 : 300000,
         ...baseMsg
       };
+    case "aistudio": {
+      if (!a.query) throw new Error("query required");
+
+      return {
+        type: "AISTUDIO_QUERY",
+        query: a.query,
+        model: a.model ? normalizeModelString(a.model) : undefined,
+        withPage: a["with-page"],
+        timeout: a.timeout ? parseInt(a.timeout, 10) * 1000 : 300000,
+        ...baseMsg
+      };
+    }
+    case "aistudio.build": {
+      if (!a.query) throw new Error("query required");
+
+      return {
+        type: "AISTUDIO_BUILD",
+        query: a.query,
+        model: a.model ? normalizeModelString(a.model) : undefined,
+        output: a.output,
+        keepOpen: Boolean(a["keep-open"] || a.keepOpen),
+        timeout: a.timeout ? parseInt(a.timeout, 10) * 1000 : 600000,
+        ...baseMsg,
+      };
+    }
     case "window.new":
       return { 
         type: "WINDOW_NEW",