surf-cli 2.5.2 → 2.7.0

package/native/host.cjs

@@ -10,9 +10,14 @@ 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 aistudioClient = require("./aistudio-client.cjs");
+const aistudioBuild = require("./aistudio-build.cjs");
 const { mapToolToMessage, mapComputerAction, formatToolContent } = require("./host-helpers.cjs");
 
-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 {} }
 
 // Cross-platform image resize (macOS: sips, Linux: ImageMagick)
 function resizeImage(filePath, maxSize) {
@@ -27,12 +32,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;
@@ -73,7 +79,7 @@ async function processAiQueue() {
     setTimeout(processAiQueue, 2000);
   }
 }
-const LOG_FILE = "/tmp/surf-host.log";
+const LOG_FILE = path.join(SURF_TMP, "surf-host.log");
 const AUTH_FILE = path.join(os.homedir(), ".pi", "agent", "auth.json");
 
 const DEFAULT_RETRY_OPTIONS = {
@@ -288,9 +294,7 @@ const log = (msg) => {
 
 log("Host starting...");
 
-try {
-  fs.unlinkSync(SOCKET_PATH);
-} catch {}
+if (!IS_WIN) { try { fs.unlinkSync(SOCKET_PATH); } catch {} }
 
 const pendingRequests = new Map();
 const pendingToolRequests = new Map();
@@ -693,6 +697,57 @@ function handleToolRequest(msg, socket) {
           });
           writeMessage({ type: "GET_GOOGLE_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: "GEMINI_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: "GEMINI_CLOSE_TAB", tabId: tabIdToClose, id: tabCloseId });
+        }),
+        jsEval: (tabId, code) => new Promise((resolve) => {
+          const jsId = ++requestCounter;
+          pendingToolRequests.set(jsId, {
+            socket: null,
+            originalId: null,
+            tool: "js_eval",
+            onComplete: (r) => resolve(r)
+          });
+          log(`[gemini] Sending EXECUTE_JAVASCRIPT id=${jsId} tabId=${tabId} code=${code.length} chars`);
+          writeMessage({ type: "EXECUTE_JAVASCRIPT", tabId, code, id: jsId });
+        }),
+        uploadFile: (tabId, filePaths) => new Promise((resolve) => {
+          const uploadId = ++requestCounter;
+          pendingToolRequests.set(uploadId, {
+            socket: null,
+            originalId: null,
+            tool: "upload_file",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "UPLOAD_FILE_TO_TAB", tabId, filePaths, id: uploadId });
+        }),
+        fetchUrl: (url) => new Promise((resolve) => {
+          const fetchId = ++requestCounter;
+          pendingToolRequests.set(fetchId, {
+            socket: null,
+            originalId: null,
+            tool: "fetch_url",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage({ type: "GEMINI_FETCH_URL", url, id: fetchId });
+        }),
         log: (msg) => log(`[gemini] ${msg}`)
       });
       
@@ -910,6 +965,198 @@ function handleToolRequest(msg, socket) {
     
     return;
   }
+
+  if (extensionMsg.type === "AISTUDIO_QUERY") {
+    const { query, model, withPage, timeout } = extensionMsg;
+    
+    queueAiRequest(async () => {
+      const EXT_CALL_TIMEOUT_MS = 30000;
+
+      const callExtension = (toolName, msg, timeoutMs = EXT_CALL_TIMEOUT_MS) => new Promise((resolve, reject) => {
+        const id = ++requestCounter;
+
+        if (msg && msg.type === "AISTUDIO_NEW_TAB") {
+          log(`[aistudio] Opening tab: ${(msg.url || "https://aistudio.google.com/prompts/new_chat")}`);
+        }
+
+        const timeoutId = setTimeout(() => {
+          pendingToolRequests.delete(id);
+          reject(new Error(`Timeout waiting for extension: ${toolName}`));
+        }, timeoutMs);
+
+        pendingToolRequests.set(id, {
+          socket: null,
+          originalId: null,
+          tool: toolName,
+          onComplete: (r) => {
+            clearTimeout(timeoutId);
+            resolve(r);
+          }
+        });
+
+        writeMessage({ ...msg, id });
+      });
+
+      // 1. Get page context if requested
+      let pageContext = null;
+      if (withPage) {
+        const pageResult = await callExtension(
+          "get_page_text",
+          { type: "GET_PAGE_TEXT", tabId: extensionMsg.tabId },
+          45000
+        );
+
+        if (pageResult && !pageResult.error) {
+          pageContext = {
+            url: pageResult.url,
+            text: pageResult.text || pageResult.pageContent || ""
+          };
+        }
+      }
+
+      // 2. Build full prompt
+      let fullPrompt = query || "";
+      if (pageContext) {
+        const MAX_PAGE_CONTEXT_CHARS = 20000;
+        const pageText = String(pageContext.text || "");
+        const truncated = pageText.length > MAX_PAGE_CONTEXT_CHARS
+          ? pageText.slice(0, MAX_PAGE_CONTEXT_CHARS) + "\n\n[...truncated...]"
+          : pageText;
+
+        fullPrompt = `Page: ${pageContext.url}\n\n${truncated}\n\n---\n\n${fullPrompt}`;
+      }
+
+      // 3. Call AI Studio client
+      const result = await aistudioClient.query({
+        prompt: fullPrompt,
+        model: model || undefined,
+        timeout: timeout || 300000,
+        getCookies: () => callExtension("get_cookies", { type: "GET_GOOGLE_COOKIES" }, 45000),
+        createTab: (url) => callExtension(
+          "create_tab",
+          { type: "AISTUDIO_NEW_TAB", url },
+          45000
+        ),
+        closeTab: (tabIdToClose) => callExtension(
+          "close_tab",
+          { type: "AISTUDIO_CLOSE_TAB", tabId: tabIdToClose },
+          45000
+        ),
+        cdpEvaluate: (tabId, expression) => callExtension(
+          "cdp_evaluate",
+          { type: "AISTUDIO_EVALUATE", tabId, expression }
+        ),
+        cdpCommand: (tabId, method, params) => callExtension(
+          "cdp_command",
+          { type: "AISTUDIO_CDP_COMMAND", tabId, method, params }
+        ),
+        readNetworkEntries: (tabIdToRead) => callExtension(
+          "read_network_entries",
+          {
+            type: "READ_NETWORK_REQUESTS",
+            tabId: tabIdToRead,
+            full: true,
+            limit: 100,
+            urlPattern: "MakerSuiteService/GenerateContent"
+          },
+          45000
+        ),
+        log: (msg) => log(`[aistudio] ${msg}`)
+      });
+
+      return result;
+    }).then((result) => {
+      const payload = {
+        response: result.response,
+        model: result.model,
+        thinkingTime: result.thinkingTime,
+        tookMs: result.tookMs
+      };
+
+      sendToolResponse(socket, originalId, { output: JSON.stringify(payload) }, null);
+    }).catch((err) => {
+      sendToolResponse(socket, originalId, null, err.message);
+    });
+    
+    return;
+  }
+
+  if (extensionMsg.type === "AISTUDIO_BUILD") {
+    const { query, model, output, keepOpen, timeout } = extensionMsg;
+
+    queueAiRequest(async () => {
+      const EXT_CALL_TIMEOUT_MS = 30000;
+
+      const callExtension = (toolName, msg, timeoutMs = EXT_CALL_TIMEOUT_MS) => new Promise((resolve, reject) => {
+        const id = ++requestCounter;
+
+        if (msg && msg.type === "AISTUDIO_NEW_TAB") {
+          log(`[aistudio] Opening tab: ${(msg.url || "https://aistudio.google.com/apps")}`);
+        }
+
+        const timeoutId = setTimeout(() => {
+          pendingToolRequests.delete(id);
+          reject(new Error(`Timeout waiting for extension: ${toolName}`));
+        }, timeoutMs);
+
+        pendingToolRequests.set(id, {
+          socket: null,
+          originalId: null,
+          tool: toolName,
+          onComplete: (r) => {
+            clearTimeout(timeoutId);
+            resolve(r);
+          }
+        });
+
+        writeMessage({ ...msg, id });
+      });
+
+      const result = await aistudioBuild.build({
+        prompt: query,
+        model: model || undefined,
+        output,
+        keepOpen,
+        timeout: timeout || 600000,
+        getCookies: () => callExtension("get_cookies", { type: "GET_GOOGLE_COOKIES" }, 45000),
+        createTab: (url) => callExtension(
+          "create_tab",
+          { type: "AISTUDIO_NEW_TAB", url },
+          45000
+        ),
+        closeTab: (tabIdToClose) => callExtension(
+          "close_tab",
+          { type: "AISTUDIO_CLOSE_TAB", tabId: tabIdToClose },
+          45000
+        ),
+        cdpEvaluate: (tabId, expression) => callExtension(
+          "cdp_evaluate",
+          { type: "AISTUDIO_EVALUATE", tabId, expression }
+        ),
+        cdpCommand: (tabId, method, params) => callExtension(
+          "cdp_command",
+          { type: "AISTUDIO_CDP_COMMAND", tabId, method, params }
+        ),
+        searchDownloads: async (params) => {
+          const result = await callExtension(
+            "downloads_search",
+            { type: "DOWNLOADS_SEARCH", searchParams: params },
+            10000
+          );
+          return result?.downloads || [];
+        },
+        log: (msg) => log(`[aistudio:build] ${msg}`)
+      });
+
+      return result;
+    }).then((result) => {
+      sendToolResponse(socket, originalId, { output: JSON.stringify(result) }, null);
+    }).catch((err) => {
+      sendToolResponse(socket, originalId, null, err.message);
+    });
+
+    return;
+  }
   
   if (extensionMsg.type === "EXECUTE_KEY_REPEAT") {
     const { key, repeat, tabId: tid } = extensionMsg;
@@ -1204,15 +1451,15 @@ function processInput() {
           } else if (autoScreenshot && tabId && !msg.error && !msg.base64) {
             
             const screenshotId = ++requestCounter;
-            const screenshotPath = `/tmp/pi-auto-${Date.now()}.png`;
+            const screenshotPath = path.join(SURF_TMP, `pi-auto-${Date.now()}.png`);
             
-            const autoFiles = fs.readdirSync("/tmp")
+            const autoFiles = fs.readdirSync(SURF_TMP)
               .filter(f => f.startsWith("pi-auto-") && f.endsWith(".png"))
               .map(f => ({ name: f, time: parseInt(f.match(/pi-auto-(\d+)\.png/)?.[1] || "0", 10) }))
               .sort((a, b) => b.time - a.time);
             if (autoFiles.length >= 10) {
               autoFiles.slice(9).forEach(f => {
-                try { fs.unlinkSync(path.join("/tmp", f.name)); } catch (e) {}
+                try { fs.unlinkSync(path.join(SURF_TMP, f.name)); } catch (e) {}
               });
             }
             pendingToolRequests.set(screenshotId, {
@@ -1440,7 +1687,7 @@ const server = net.createServer((socket) => {
 
 server.listen(SOCKET_PATH, () => {
   log("Socket server listening on " + SOCKET_PATH);
-  fs.chmodSync(SOCKET_PATH, 0o600);
+  if (!IS_WIN) { try { fs.chmodSync(SOCKET_PATH, 0o600); } catch {} }
   writeMessage({ type: "HOST_READY" });
   log("Sent HOST_READY to extension");
 });
@@ -1452,14 +1699,14 @@ server.on("error", (err) => {
 process.on("SIGTERM", () => {
   log("SIGTERM received");
   server.close();
-  try { fs.unlinkSync(SOCKET_PATH); } catch {}
+  if (!IS_WIN) { try { fs.unlinkSync(SOCKET_PATH); } catch {} }
   process.exit(0);
 });
 
 process.on("SIGINT", () => {
   log("SIGINT received");
   server.close();
-  try { fs.unlinkSync(SOCKET_PATH); } catch {}
+  if (!IS_WIN) { try { fs.unlinkSync(SOCKET_PATH); } catch {} }
   process.exit(0);
 });
 

package/native/mcp-server.cjs

@@ -4,7 +4,7 @@ const { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
 const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
 const { z } = require("zod");
 
-const SOCKET_PATH = "/tmp/surf.sock";
+const SOCKET_PATH = process.platform === "win32" ? "//./pipe/surf" : "/tmp/surf.sock";
 const REQUEST_TIMEOUT = 30000;
 
 const TOOL_SCHEMAS = {

package/native/network-store.cjs

@@ -13,7 +13,9 @@ const crypto = require("crypto");
 const readline = require("readline");
 
 // Configuration
-const DEFAULT_BASE = "/tmp/surf";
+const DEFAULT_BASE = process.platform === "win32"
+  ? require("path").join(require("os").tmpdir(), "surf")
+  : "/tmp/surf";
 const DEFAULT_TTL = 24 * 60 * 60 * 1000;  // 24 hours
 const DEFAULT_MAX_SIZE = 200 * 1024 * 1024; // 200MB
 const AUTO_CLEANUP_INTERVAL = 60 * 60 * 1000; // 1 hour

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "surf-cli",
-  "version": "2.5.2",
+  "version": "2.7.0",
   "description": "CLI for AI agents to control Chrome. Zero config, agent-agnostic, battle-tested.",
   "keywords": [
     "chrome",
@@ -30,6 +30,7 @@
     "native/",
     "scripts/",
     "dist/",
+    "skills/",
     "README.md",
     "LICENSE"
   ],
@@ -50,21 +51,21 @@
   },
   "dependencies": {
     "@google/generative-ai": "^0.24.1",
-    "@modelcontextprotocol/sdk": "^1.7.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "buffer": "^6.0.3",
     "crypto-browserify": "^3.12.1",
     "events": "^3.3.0",
     "stream-browserify": "^3.0.0",
-    "vite-plugin-node-polyfills": "^0.24.0",
-    "zod": "^4.3.5"
+    "vite-plugin-node-polyfills": "^0.25.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.11",
-    "@types/chrome": "^0.0.287",
-    "@vitest/coverage-v8": "^4.0.16",
-    "@vitest/ui": "^4.0.16",
+    "@biomejs/biome": "^2.4.4",
+    "@types/chrome": "^0.1.37",
+    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/ui": "^4.0.18",
     "typescript": "^5.7.2",
     "vite": "^7.3.1",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.18"
   }
 }

package/scripts/install-native-host.cjs

@@ -39,6 +39,12 @@ const BROWSERS = {
     linux: null,
     win32: null,
   },
+  helium: {
+    name: "Helium",
+    darwin: "Library/Application Support/net.imput.helium/NativeMessagingHosts",
+    linux: null,
+    win32: null,
+  },
 };
 
 const NODE_PATHS = {
@@ -58,6 +64,9 @@ const NODE_PATHS = {
 };
 
 function findNode() {
+  if (process.env.SURF_NODE_PATH && fs.existsSync(process.env.SURF_NODE_PATH)) {
+    return process.env.SURF_NODE_PATH;
+  }
   const platform = process.platform;
   const paths = NODE_PATHS[platform] || [];
   for (const p of paths) {
@@ -95,6 +104,9 @@ function getWrapperDir() {
 }
 
 function getHostPath() {
+  if (process.env.SURF_HOST_PATH && fs.existsSync(process.env.SURF_HOST_PATH)) {
+    return process.env.SURF_HOST_PATH;
+  }
   const npmRoot = findNpmGlobalRoot();
   if (npmRoot) {
     const globalPath = path.join(npmRoot, "surf-cli/native/host.cjs");
@@ -218,7 +230,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:
@@ -233,7 +245,7 @@ function main() {
 
   if (!extensionId) {
     console.error("Error: Extension ID required");
-    console.error("Usage: install-native-host.cjs <extension-id> [--browser chrome|brave|edge|all]");
+    console.error("Usage: install-native-host.cjs <extension-id> [--browser chrome|chromium|brave|edge|arc|helium|all]");
     console.error("\nFind your extension ID at chrome://extensions (enable Developer Mode)");
     process.exit(1);
   }

package/scripts/uninstall-native-host.cjs

@@ -37,6 +37,12 @@ const BROWSERS = {
     linux: null,
     win32: null,
   },
+  helium: {
+    name: "Helium",
+    darwin: "Library/Application Support/net.imput.helium/NativeMessagingHosts",
+    linux: null,
+    win32: null,
+  },
 };
 
 function getWrapperDir() {
@@ -137,7 +143,7 @@ Usage: uninstall-native-host.cjs [options]
 
 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:

package/skills/README.md

@@ -0,0 +1,21 @@
+# Surf Skills
+
+This directory contains skill files for AI coding agents.
+
+## Pi Agent
+
+To use the surf skill with [Pi coding agent](https://github.com/badlogic/pi-mono):
+
+```bash
+# Option 1: Symlink (auto-updates)
+ln -s "$(pwd)/skills/surf" ~/.agents/skills/surf
+
+# Option 2: Copy
+cp -r skills/surf ~/.agents/skills/
+```
+
+The skill will be available when pi detects browser automation tasks.
+
+## Other Agents
+
+The `SKILL.md` file is a comprehensive reference that can be adapted for other AI coding agents or used as documentation for LLM prompts.