surf-cli 2.7.1 → 2.8.0

package/native/host-helpers.cjs

@@ -2,6 +2,14 @@ const fs = require("fs");
 const networkFormatters = require("./formatters/network.cjs");
 const networkStore = require("./network-store.cjs");
 
+function buildProviderUploadMessage(provider, tabId, filePaths, id) {
+  const normalizedProvider = String(provider || "").toLowerCase();
+  if (!["chatgpt", "gemini"].includes(normalizedProvider)) {
+    throw new Error(`Unsupported upload provider: ${provider}`);
+  }
+  return { type: "AI_UPLOAD_FILE_TO_TAB", provider: normalizedProvider, tabId, filePaths, id };
+}
+
 function normalizeModelString(model) {
   return String(model || "").trim().toLowerCase();
 }
@@ -342,6 +350,19 @@ function formatToolContent(result, log = () => {}) {
     }
     return text(output);
   }
+
+  if (
+    result.scrollTop !== undefined &&
+    result.scrollHeight !== undefined &&
+    result.scrollPercentage === undefined
+  ) {
+    return text(`Scrolled to Y:${result.scrollTop} (page height: ${result.scrollHeight})`);
+  }
+
+  if (result.scrollY !== undefined) {
+    const pageHeight = result.pageHeight !== undefined ? ` (page height: ${result.pageHeight})` : "";
+    return text(`Scrolled to Y:${result.scrollY}${pageHeight}`);
+  }
   
   if (result.success && result.name && result.tabId !== undefined) {
     return text(`Registered tab ${result.tabId} as "${result.name}"`);
@@ -478,14 +499,15 @@ function mapComputerAction(args, tabId) {
       return { type: "FIND_AND_TYPE", text, submit: a.submit ?? false, submitKey: a.submitKey || "Enter", ...baseMsg };
     
     case "scroll": {
-      const amount = (scroll_amount || 3) * 100;
+      const direction = a.direction || scroll_direction;
+      const amount = a.scroll_pixels ?? ((a.amount ?? scroll_amount ?? 3) * 100);
       const deltas = {
         up: { deltaX: 0, deltaY: -amount },
         down: { deltaX: 0, deltaY: amount },
         left: { deltaX: -amount, deltaY: 0 },
         right: { deltaX: amount, deltaY: 0 },
       };
-      const { deltaX, deltaY } = deltas[scroll_direction] || { deltaX: 0, deltaY: 0 };
+      const { deltaX, deltaY } = deltas[direction] || { deltaX: 0, deltaY: 0 };
       return { type: "EXECUTE_SCROLL", deltaX, deltaY, x: coordinate?.[0], y: coordinate?.[1], ...baseMsg };
     }
     
@@ -575,7 +597,7 @@ function mapToolToMessage(tool, args, tabId) {
         type: "EXECUTE_SCREENSHOT", 
         savePath: a.savePath || a.output,  // Accept both savePath (CLI) and output (MCP)
         annotate: a.annotate || false,
-        fullpage: a.fullpage || false,
+        fullpage: a.fullpage || a["full-page"] || false,
         maxHeight: a["max-height"] || 4000,
         fullRes: a.full || false,
         maxSize: a["max-size"] || 1200,
@@ -583,6 +605,31 @@ function mapToolToMessage(tool, args, tabId) {
       };
     case "javascript_tool":
       return { type: "EXECUTE_JAVASCRIPT", code: a.code, ...baseMsg };
+    case "animate-audit": {
+      if (!a.selector || typeof a.selector !== "string") throw new Error("selector required");
+      if (typeof a.duration === "boolean") throw new Error("duration must be a number");
+      if (typeof a.fps === "boolean") throw new Error("fps must be a number");
+      const durationMs = a.duration !== undefined ? Number(a.duration) : 2000;
+      const fps = a.fps !== undefined ? Number(a.fps) : 10;
+      if (!Number.isFinite(durationMs) || durationMs < 100 || durationMs > 10000) {
+        throw new Error("duration must be between 100 and 10000 ms");
+      }
+      if (!Number.isFinite(fps) || fps < 1 || fps > 30) {
+        throw new Error("fps must be between 1 and 30");
+      }
+      return { type: "ANIMATE_AUDIT", selector: a.selector, durationMs, fps, ...baseMsg };
+    }
+    case "perf-audit": {
+      if (typeof a.duration === "boolean") throw new Error("duration must be a number");
+      if (a.trigger !== undefined && typeof a.trigger !== "string") {
+        throw new Error("trigger must be action:target");
+      }
+      const durationMs = a.duration !== undefined ? Number(a.duration) : 3000;
+      if (!Number.isFinite(durationMs) || durationMs < 100 || durationMs > 10000) {
+        throw new Error("duration must be between 100 and 10000 ms");
+      }
+      return { type: "PERF_AUDIT", durationMs, trigger: a.trigger, ...baseMsg };
+    }
     case "wait_for_element":
       return { 
         type: "WAIT_FOR_ELEMENT", 
@@ -1132,4 +1179,4 @@ function mapToolToMessage(tool, args, tabId) {
   }
 }
 
-module.exports = { mapToolToMessage, mapComputerAction, formatToolContent };
+module.exports = { mapToolToMessage, mapComputerAction, formatToolContent, buildProviderUploadMessage };

package/native/host.cjs

@@ -12,11 +12,10 @@ 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 { mapToolToMessage, mapComputerAction, formatToolContent, buildProviderUploadMessage } = require("./host-helpers.cjs");
 
 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";
+const { SOCKET_PATH, SURF_TMP } = require("./socket-path.cjs");
 if (IS_WIN) { try { fs.mkdirSync(SURF_TMP, { recursive: true }); } catch {} }
 
 // Cross-platform image resize (macOS: sips, Linux: ImageMagick)
@@ -534,6 +533,16 @@ function handleToolRequest(msg, socket) {
           });
           writeMessage({ type: "CHATGPT_CDP_COMMAND", tabId, method, params, id: cmdId });
         }),
+        uploadFile: (tabId, filePaths) => new Promise((resolve) => {
+          const uploadId = ++requestCounter;
+          pendingToolRequests.set(uploadId, {
+            socket: null,
+            originalId: null,
+            tool: "upload_file",
+            onComplete: (r) => resolve(r)
+          });
+          writeMessage(buildProviderUploadMessage("chatgpt", tabId, filePaths, uploadId));
+        }),
         log: (msg) => log(`[chatgpt] ${msg}`)
       });
       
@@ -736,7 +745,7 @@ function handleToolRequest(msg, socket) {
             tool: "upload_file",
             onComplete: (r) => resolve(r)
           });
-          writeMessage({ type: "UPLOAD_FILE_TO_TAB", tabId, filePaths, id: uploadId });
+          writeMessage(buildProviderUploadMessage("gemini", tabId, filePaths, uploadId));
         }),
         fetchUrl: (url) => new Promise((resolve) => {
           const fetchId = ++requestCounter;
@@ -941,19 +950,25 @@ function handleToolRequest(msg, socket) {
     }).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
+        // Convert scraped model names to selectable IDs.
         const modelMap = {};
+        const defaultModels = Object.values(grokClient.DEFAULT_GROK_MODELS || {});
         result.models.forEach(name => {
           const nameLower = name.toLowerCase();
+          const normalizedName = grokClient.normalizeGrokModelLabel(name);
+          const knownModel = defaultModels.find(model => {
+            const normalizedDefaultName = grokClient.normalizeGrokModelLabel(model.name);
+            return normalizedName.includes(normalizedDefaultName) || normalizedDefaultName.includes(normalizedName);
+          });
           // Match known model keywords to generate consistent short IDs
           let shortId;
-          if (nameLower.includes('thinking')) shortId = 'thinking';
+          if (knownModel) shortId = knownModel.id;
           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: "" };
+          modelMap[shortId] = { id: shortId, name: name, desc: knownModel?.desc || "" };
         });
         const saveResult = grokClient.saveModels(modelMap);
         result.savedModels = saveResult;

package/native/mcp-server.cjs

@@ -3,8 +3,8 @@ const net = require("net");
 const { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
 const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
 const { z } = require("zod");
+const { SOCKET_PATH, formatSocketError } = require("./socket-path.cjs");
 
-const SOCKET_PATH = process.platform === "win32" ? "//./pipe/surf" : "/tmp/surf.sock";
 const REQUEST_TIMEOUT = 30000;
 
 const TOOL_SCHEMAS = {
@@ -279,7 +279,9 @@ function sendSocketRequest(tool, args = {}) {
     });
 
     let buf = "";
+    let settled = false;
     const timeout = setTimeout(() => {
+      settled = true;
       sock.destroy();
       reject(new Error("Request timeout"));
     }, REQUEST_TIMEOUT);
@@ -291,11 +293,13 @@ function sendSocketRequest(tool, args = {}) {
       for (const line of lines) {
         if (!line.trim()) continue;
         try {
+          settled = true;
           clearTimeout(timeout);
           const resp = JSON.parse(line);
           sock.end();
           resolve(resp);
         } catch {
+          settled = true;
           clearTimeout(timeout);
           sock.end();
           reject(new Error("Invalid JSON response"));
@@ -304,17 +308,16 @@ function sendSocketRequest(tool, args = {}) {
     });
 
     sock.on("error", (e) => {
+      settled = true;
       clearTimeout(timeout);
-      if (e.code === "ENOENT") {
-        reject(new Error("Socket not found. Is Chrome running with the surf extension?"));
-      } else {
-        reject(e);
-      }
+      reject(new Error(formatSocketError(e)));
     });
 
     sock.on("close", () => {
       clearTimeout(timeout);
-      reject(new Error("Socket closed unexpectedly"));
+      if (!settled) {
+        reject(new Error(`Socket closed unexpectedly\nAttempted socket: ${SOCKET_PATH}`));
+      }
     });
   });
 }

package/native/socket-path.cjs

@@ -0,0 +1,46 @@
+const path = require("path");
+const os = require("os");
+
+const IS_WIN = process.platform === "win32";
+const DEFAULT_SOCKET_PATH = IS_WIN ? "//./pipe/surf" : "/tmp/surf.sock";
+const SOCKET_PATH = process.env.SURF_SOCKET || DEFAULT_SOCKET_PATH;
+const SURF_TMP = IS_WIN ? path.join(os.tmpdir(), "surf") : "/tmp";
+
+function getSocketTroubleshootingHint() {
+  const lines = [
+    `Attempted socket: ${SOCKET_PATH}`,
+    "Make sure the browser is running with the Surf extension enabled, then restart the browser after native host install changes.",
+    "Run `surf doctor --browser all` for detailed native host diagnostics.",
+  ];
+
+  if (process.env.SURF_SOCKET) {
+    lines.push("SURF_SOCKET is set; make sure the native host and CLI use the same value.");
+  }
+
+  if (process.platform === "linux") {
+    lines.push("On WSL2 with Windows Chrome, run `surf install <extension-id>` from WSL and restart Windows Chrome.");
+  }
+
+  return lines.join("\n");
+}
+
+function formatSocketError(error, context = "connect") {
+  let message;
+  if (error && error.code === "ENOENT") {
+    message = "Socket not found.";
+  } else if (error && error.code === "ECONNREFUSED") {
+    message = "Connection refused. Native host is not accepting connections.";
+  } else {
+    message = error && error.message ? error.message : String(error);
+  }
+
+  return `Socket ${context} failed: ${message}\n${getSocketTroubleshootingHint()}`;
+}
+
+module.exports = {
+  DEFAULT_SOCKET_PATH,
+  SOCKET_PATH,
+  SURF_TMP,
+  formatSocketError,
+  getSocketTroubleshootingHint,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "surf-cli",
-  "version": "2.7.1",
+  "version": "2.8.0",
   "description": "CLI for AI agents to control Chrome. Zero config, agent-agnostic, battle-tested.",
   "keywords": [
     "chrome",
@@ -62,10 +62,10 @@
   "devDependencies": {
     "@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",
+    "@vitest/coverage-v8": "^4.1.9",
+    "@vitest/ui": "^4.1.9",
+    "typescript": "^6.0.3",
     "vite": "^7.3.1",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.9"
   }
 }

package/scripts/install-native-host.cjs

@@ -2,7 +2,7 @@
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
-const { execSync, spawnSync } = require("child_process");
+const { execFileSync, execSync } = require("child_process");
 
 const HOST_NAME = "surf.browser.host";
 
@@ -12,12 +12,14 @@ const BROWSERS = {
     darwin: "Library/Application Support/Google/Chrome/NativeMessagingHosts",
     linux: ".config/google-chrome/NativeMessagingHosts",
     win32: "Google\\Chrome",
+    wsl: "Google/Chrome/User Data/NativeMessagingHosts",
   },
   chromium: {
     name: "Chromium",
     darwin: "Library/Application Support/Chromium/NativeMessagingHosts",
     linux: ".config/chromium/NativeMessagingHosts",
     win32: "Chromium",
+    wsl: "Chromium/User Data/NativeMessagingHosts",
   },
   brave: {
     name: "Brave",
@@ -25,12 +27,14 @@ const BROWSERS = {
       "Library/Application Support/BraveSoftware/Brave-Browser/NativeMessagingHosts",
     linux: ".config/BraveSoftware/Brave-Browser/NativeMessagingHosts",
     win32: "BraveSoftware\\Brave-Browser",
+    wsl: "BraveSoftware/Brave-Browser/User Data/NativeMessagingHosts",
   },
   edge: {
     name: "Microsoft Edge",
     darwin: "Library/Application Support/Microsoft Edge/NativeMessagingHosts",
     linux: ".config/microsoft-edge/NativeMessagingHosts",
     win32: "Microsoft\\Edge",
+    wsl: "Microsoft/Edge/User Data/NativeMessagingHosts",
   },
   arc: {
     name: "Arc",
@@ -38,12 +42,14 @@ const BROWSERS = {
       "Library/Application Support/Arc/User Data/NativeMessagingHosts",
     linux: null,
     win32: null,
+    wsl: null,
   },
   helium: {
     name: "Helium",
     darwin: "Library/Application Support/net.imput.helium/NativeMessagingHosts",
     linux: null,
     win32: null,
+    wsl: null,
   },
 };
 
@@ -63,6 +69,16 @@ const NODE_PATHS = {
   ],
 };
 
+function isWsl() {
+  if (process.platform !== "linux") return false;
+  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) return true;
+  try {
+    return /microsoft|wsl/i.test(fs.readFileSync("/proc/version", "utf8"));
+  } catch {
+    return false;
+  }
+}
+
 function findNode() {
   if (process.env.SURF_NODE_PATH && fs.existsSync(process.env.SURF_NODE_PATH)) {
     return process.env.SURF_NODE_PATH;
@@ -88,10 +104,14 @@ function findNpmGlobalRoot() {
   }
 }
 
-function getWrapperDir() {
-  const platform = process.platform;
+function getWrapperDir(target = process.platform) {
   const home = os.homedir();
-  switch (platform) {
+  if (target === "wsl-windows") {
+    const localAppData = getWindowsEnv("LOCALAPPDATA");
+    if (!localAppData) return null;
+    return path.join(windowsPathToWslPath(localAppData), "surf-cli");
+  }
+  switch (process.platform) {
     case "darwin":
       return path.join(home, "Library/Application Support/surf-cli");
     case "linux":
@@ -117,72 +137,123 @@ function getHostPath() {
   return null;
 }
 
-function createWrapper(wrapperDir, nodePath, hostPath) {
-  const platform = process.platform;
+function getWindowsEnv(name) {
+  try {
+    return execFileSync("cmd.exe", ["/c", "echo", `%${name}%`], { encoding: "utf8" })
+      .trim()
+      .replace(/\r/g, "");
+  } catch {
+    return null;
+  }
+}
+
+function windowsPathToWslPath(winPath) {
+  const normalized = winPath.replace(/\\/g, "/");
+  const match = normalized.match(/^([A-Za-z]):\/(.*)$/);
+  if (!match) return normalized;
+  return `/mnt/${match[1].toLowerCase()}/${match[2]}`;
+}
+
+function wslPathToWindowsPath(wslPath) {
+  try {
+    return execFileSync("wslpath", ["-w", wslPath], { encoding: "utf8" }).trim().replace(/\r/g, "");
+  } catch {
+    const match = wslPath.match(/^\/mnt\/([a-zA-Z])\/(.*)$/);
+    if (match) return `${match[1].toUpperCase()}:\\${match[2].replace(/\//g, "\\")}`;
+    return wslPath;
+  }
+}
+
+function createWrapper(wrapperDir, nodePath, hostPath, target = process.platform) {
   fs.mkdirSync(wrapperDir, { recursive: true });
 
-  if (platform === "win32") {
+  if (target === "wsl-windows") {
+    const cmdPath = path.join(wrapperDir, "host-wrapper-wsl.cmd");
+    const distroArg = process.env.WSL_DISTRO_NAME ? ` -d "${process.env.WSL_DISTRO_NAME}"` : "";
+    const content = `@echo off\r\nwsl.exe${distroArg} --cd "${path.dirname(hostPath)}" --exec "${nodePath}" "${hostPath}" %*\r\n`;
+    fs.writeFileSync(cmdPath, content);
+    return wslPathToWindowsPath(cmdPath);
+  }
+
+  if (process.platform === "win32") {
     const batPath = path.join(wrapperDir, "host-wrapper.bat");
-    const content = `@echo off\r\n"${nodePath}" "${hostPath}"\r\n`;
+    const content = `@echo off\r\n"${nodePath}" "${hostPath}" %*\r\n`;
     fs.writeFileSync(batPath, content);
     return batPath;
-  } else {
-    const shPath = path.join(wrapperDir, "host-wrapper.sh");
-    const hostDir = path.dirname(hostPath);
-    const content = `#!/bin/bash
+  }
+
+  const shPath = path.join(wrapperDir, "host-wrapper.sh");
+  const hostDir = path.dirname(hostPath);
+  const content = `#!/usr/bin/env bash
 cd "${hostDir}"
-exec "${nodePath}" "${hostPath}"
+exec "${nodePath}" "${hostPath}" "$@"
 `;
-    fs.writeFileSync(shPath, content);
-    fs.chmodSync(shPath, "755");
-    return shPath;
-  }
+  fs.writeFileSync(shPath, content);
+  fs.chmodSync(shPath, "755");
+  return shPath;
 }
 
-function installManifest(browser, extensionId, wrapperPath) {
-  const platform = process.platform;
-  const browserConfig = BROWSERS[browser];
-
-  if (!browserConfig || !browserConfig[platform]) {
-    return null;
-  }
-
-  if (platform === "win32") {
-    return installWindowsRegistry(browser, extensionId, wrapperPath);
-  }
+function readExistingManifest(manifestPath) {
+  if (!fs.existsSync(manifestPath)) return {};
+  return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+}
 
-  const manifestDir = path.join(os.homedir(), browserConfig[platform]);
-  fs.mkdirSync(manifestDir, { recursive: true });
+function writeManifest(manifestPath, extensionId, wrapperPath) {
+  const origin = `chrome-extension://${extensionId}/`;
+  const existing = readExistingManifest(manifestPath);
+  const allowedOrigins = Array.isArray(existing.allowed_origins) ? existing.allowed_origins : [];
 
   const manifest = {
+    ...existing,
     name: HOST_NAME,
-    description: "Surf CLI Native Host",
+    description: existing.description || "Surf CLI Native Host",
     path: wrapperPath,
     type: "stdio",
-    allowed_origins: [`chrome-extension://${extensionId}/`],
+    allowed_origins: Array.from(new Set([...allowedOrigins, origin])),
   };
 
-  const manifestPath = path.join(manifestDir, `${HOST_NAME}.json`);
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
   fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
   return manifestPath;
 }
 
+function getWslWindowsManifestDir(browserConfig) {
+  const localAppData = getWindowsEnv("LOCALAPPDATA");
+  if (!localAppData || !browserConfig.wsl) return null;
+  return path.join(windowsPathToWslPath(localAppData), browserConfig.wsl);
+}
+
+function installManifest(browser, extensionId, wrapperPath, target) {
+  const browserConfig = BROWSERS[browser];
+
+  if (!browserConfig) return null;
+
+  if (target === "wsl-windows") {
+    const manifestDir = getWslWindowsManifestDir(browserConfig);
+    if (!manifestDir) return null;
+    const manifestPath = path.join(manifestDir, `${HOST_NAME}.json`);
+    return writeManifest(manifestPath, extensionId, wrapperPath);
+  }
+
+  const platform = process.platform;
+  if (!browserConfig[platform]) return null;
+
+  if (platform === "win32") {
+    return installWindowsRegistry(browser, extensionId, wrapperPath);
+  }
+
+  const manifestDir = path.join(os.homedir(), browserConfig[platform]);
+  const manifestPath = path.join(manifestDir, `${HOST_NAME}.json`);
+  return writeManifest(manifestPath, extensionId, wrapperPath);
+}
+
 function installWindowsRegistry(browser, extensionId, wrapperPath) {
   const browserConfig = BROWSERS[browser];
   const regPath = `HKCU\\Software\\${browserConfig.win32}\\NativeMessagingHosts\\${HOST_NAME}`;
 
   const manifestDir = getWrapperDir();
   const manifestPath = path.join(manifestDir, `${HOST_NAME}.json`);
-
-  const manifest = {
-    name: HOST_NAME,
-    description: "Surf CLI Native Host",
-    path: wrapperPath,
-    type: "stdio",
-    allowed_origins: [`chrome-extension://${extensionId}/`],
-  };
-
-  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  writeManifest(manifestPath, extensionId, wrapperPath);
 
   try {
     execSync(`reg add "${regPath}" /ve /t REG_SZ /d "${manifestPath}" /f`, {
@@ -197,7 +268,7 @@ function installWindowsRegistry(browser, extensionId, wrapperPath) {
 
 function parseArgs() {
   const args = process.argv.slice(2);
-  const result = { extensionId: null, browsers: ["chrome"] };
+  const result = { extensionId: null, browsers: ["chrome"], target: "auto" };
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -208,6 +279,8 @@ function parseArgs() {
       } else {
         result.browsers = browserArg.split(",").map((b) => b.trim().toLowerCase());
       }
+    } else if (arg === "--target") {
+      result.target = args[++i];
     } else if (arg === "--help" || arg === "-h") {
       printHelp();
       process.exit(0);
@@ -232,20 +305,23 @@ Options:
   -b, --browser   Browser(s) to install for (default: chrome)
                   Values: chrome, chromium, brave, edge, arc, helium, all
                   Multiple: --browser chrome,brave
+  --target        Install target: auto, linux, windows
+                  On WSL2, auto installs for Windows Chrome. Use linux for WSLg/Linux browsers.
 
 Examples:
   node install-native-host.cjs abcdefghijklmnopabcdefghijklmnop
   node install-native-host.cjs abcdefghijklmnop --browser brave
   node install-native-host.cjs abcdefghijklmnop --browser all
+  node install-native-host.cjs abcdefghijklmnop --target linux
 `);
 }
 
 function main() {
-  const { extensionId, browsers } = parseArgs();
+  const { extensionId, browsers, target } = parseArgs();
 
   if (!extensionId) {
     console.error("Error: Extension ID required");
-    console.error("Usage: install-native-host.cjs <extension-id> [--browser chrome|chromium|brave|edge|arc|helium|all]");
+    console.error("Usage: install-native-host.cjs <extension-id> [--browser chrome|chromium|brave|edge|arc|helium|all] [--target auto|linux|windows]");
     console.error("\nFind your extension ID at chrome://extensions (enable Developer Mode)");
     process.exit(1);
   }
@@ -256,6 +332,24 @@ function main() {
     process.exit(1);
   }
 
+  if (!["auto", "linux", "windows"].includes(target)) {
+    console.error("Error: Invalid --target value. Expected auto, linux, or windows");
+    process.exit(1);
+  }
+
+  const runningInWsl = isWsl();
+  if (target === "windows" && !runningInWsl && process.platform !== "win32") {
+    console.error("Error: --target windows is only supported on Windows or WSL2");
+    process.exit(1);
+  }
+
+  if (target === "linux" && process.platform !== "linux") {
+    console.error("Error: --target linux is only supported on Linux or WSL2");
+    process.exit(1);
+  }
+
+  const effectiveTarget = runningInWsl && target !== "linux" ? "wsl-windows" : process.platform;
+
   const nodePath = findNode();
   if (!nodePath) {
     console.error("Error: Could not find Node.js");
@@ -270,19 +364,20 @@ function main() {
     process.exit(1);
   }
 
-  const wrapperDir = getWrapperDir();
+  const wrapperDir = getWrapperDir(effectiveTarget);
   if (!wrapperDir) {
-    console.error("Error: Unsupported platform");
+    console.error("Error: Unsupported platform or Windows interop unavailable");
     process.exit(1);
   }
 
-  console.log(`Platform: ${process.platform}`);
+  console.log(`Platform: ${process.platform}${runningInWsl ? " (WSL2 detected)" : ""}`);
+  console.log(`Target: ${effectiveTarget === "wsl-windows" ? "Windows browser from WSL2" : effectiveTarget}`);
   console.log(`Node: ${nodePath}`);
   console.log(`Host: ${hostPath}`);
   console.log(`Wrapper dir: ${wrapperDir}`);
   console.log("");
 
-  const wrapperPath = createWrapper(wrapperDir, nodePath, hostPath);
+  const wrapperPath = createWrapper(wrapperDir, nodePath, hostPath, effectiveTarget);
   console.log(`Created wrapper: ${wrapperPath}`);
   console.log("");
 
@@ -295,7 +390,7 @@ function main() {
       continue;
     }
 
-    const result = installManifest(browser, extensionId, wrapperPath);
+    const result = installManifest(browser, extensionId, wrapperPath, effectiveTarget);
     if (result) {
       installed.push({ browser: BROWSERS[browser].name, path: result });
     } else {
@@ -311,10 +406,17 @@ function main() {
   }
 
   if (skipped.length > 0) {
-    console.log(`\nSkipped (not supported on ${process.platform}): ${skipped.join(", ")}`);
+    console.log(`\nSkipped (not supported for ${effectiveTarget}): ${skipped.join(", ")}`);
   }
 
   console.log("\nDone! Restart your browser for changes to take effect.");
 }
 
-main();
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  createWrapper,
+  writeManifest,
+};