surf-cli 2.8.0 → 2.10.0

package/native/listener.cjs

@@ -0,0 +1,20 @@
+const net = require("net");
+
+function parseListenEndpoint(value) {
+  const v6 = typeof value === "string" && value.match(/^\[([^\]]+)\]:(\d+)$/);
+  const v4 = typeof value === "string" && value.match(/^([^:]+):(\d+)$/);
+  const host = v6 ? v6[1] : v4?.[1];
+  const port = Number(v6 ? v6[2] : v4?.[2]);
+  if (!host || !Number.isInteger(port) || port < 1 || port > 65535) throw new Error("SURF_LISTEN must be a Tailnet IP and port 1..65535");
+  if (v6) {
+    if (net.isIP(host) !== 6) throw new Error("SURF_LISTEN must use a Tailscale IPv6 address");
+    const canonical = new URL(`http://[${host}]`).hostname.slice(1, -1);
+    if (!canonical.startsWith("fd7a:115c:a1e0:")) throw new Error("SURF_LISTEN must use a Tailscale IPv6 address");
+    return { host: canonical, port, display: `[${canonical}]:${port}` };
+  }
+  const parts = host.split(".").map(Number);
+  if (net.isIP(host) !== 4 || parts[0] !== 100 || parts[1] < 64 || parts[1] > 127) throw new Error("SURF_LISTEN must use a Tailscale IPv4 address");
+  return { host, port, display: `${host}:${port}` };
+}
+
+module.exports = { parseListenEndpoint };

package/native/mcp-server.cjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-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 REQUEST_TIMEOUT = 30000;
+const { formatSocketError } = require("./socket-path.cjs");
+const { selectEndpoint } = require("./endpoint.cjs");
+const { openClientTransport } = require("./client-transport.cjs");
+const { resolveRequestDeadlineMs } = require("./host-sessions.cjs");
+const { prepareRemoteTool, validateLocalToolPaths } = require("./file-transfer.cjs");
 
 const TOOL_SCHEMAS = {
   navigate: {
@@ -263,63 +264,56 @@ const TOOL_SCHEMAS = {
       query: z.string().describe("Question about the page"),
       mode: z.enum(["find", "summary", "extract"]).optional().describe("Query mode")
     }
+  },
+  chatgpt: {
+    desc: "Ask ChatGPT through the browser session",
+    schema: {
+      query: z.string().describe("Question or prompt"),
+      model: z.string().optional().describe("ChatGPT model"),
+      "with-page": z.boolean().optional().describe("Include current page context"),
+      file: z.string().optional().describe("One attachment path"),
+      timeout: z.number().optional().describe("Timeout in seconds")
+    }
+  },
+  gemini: {
+    desc: "Ask Gemini or generate/edit one image",
+    schema: {
+      query: z.string().optional().describe("Question or image prompt"),
+      model: z.string().optional().describe("Gemini model"),
+      "with-page": z.boolean().optional().describe("Include current page context"),
+      file: z.string().optional().describe("One attachment path"),
+      "edit-image": z.string().optional().describe("One image input path"),
+      "generate-image": z.string().optional().describe("One generated image output path"),
+      output: z.string().optional().describe("Edited image output path"),
+      youtube: z.string().optional().describe("YouTube URL"),
+      "aspect-ratio": z.string().optional().describe("Image aspect ratio"),
+      timeout: z.number().optional().describe("Timeout in seconds")
+    }
+  },
+  "network.export": {
+    desc: "Export captured network requests",
+    schema: {
+      output: z.string().optional().describe("Output file path"),
+      jsonl: z.boolean().optional().describe("Write JSONL"),
+      har: z.boolean().optional().describe("Write HAR 1.2")
+    }
   }
 };
 
-function sendSocketRequest(tool, args = {}) {
-  return new Promise((resolve, reject) => {
-    const sock = net.createConnection(SOCKET_PATH, () => {
-      const req = {
-        type: "tool_request",
-        method: "execute_tool",
-        params: { tool, args },
-        id: "mcp-" + Date.now() + "-" + Math.random()
-      };
-      sock.write(JSON.stringify(req) + "\n");
-    });
-
-    let buf = "";
-    let settled = false;
-    const timeout = setTimeout(() => {
-      settled = true;
-      sock.destroy();
-      reject(new Error("Request timeout"));
-    }, REQUEST_TIMEOUT);
-
-    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 {
-          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"));
-        }
-      }
-    });
-
-    sock.on("error", (e) => {
-      settled = true;
-      clearTimeout(timeout);
-      reject(new Error(formatSocketError(e)));
-    });
-
-    sock.on("close", () => {
-      clearTimeout(timeout);
-      if (!settled) {
-        reject(new Error(`Socket closed unexpectedly\nAttempted socket: ${SOCKET_PATH}`));
-      }
-    });
-  });
+async function sendSocketRequest(tool, args = {}, endpoint = selectEndpoint([]).endpoint) {
+  const requestTimeoutMs = resolveRequestDeadlineMs(tool, args);
+  const transport = await openClientTransport(endpoint, { requestTimeoutMs });
+  try {
+    const prepared = endpoint.kind === "remote" ? prepareRemoteTool(tool, args) : (() => { const normalized = validateLocalToolPaths(tool, args); return { args: normalized, uploads: [], downloads: [] }; })();
+    return await transport.request({
+      type: "tool_request",
+      method: "execute_tool",
+      params: { tool, args: prepared.args },
+      id: "mcp-" + Date.now() + "-" + Math.random(),
+    }, requestTimeoutMs, prepared);
+  } finally {
+    await transport.close();
+  }
 }
 
 function formatResult(resp) {
@@ -351,7 +345,8 @@ function formatResult(resp) {
 }
 
 class PiChromeMcpServer {
-  constructor() {
+  constructor(endpoint = selectEndpoint([]).endpoint) {
+    this.endpoint = endpoint;
     this.server = new McpServer({
       name: "surf",
       version: "1.0.0"
@@ -373,7 +368,7 @@ class PiChromeMcpServer {
         schemaObj,
         async (args) => {
           try {
-            const resp = await sendSocketRequest(name, args);
+            const resp = await sendSocketRequest(name, args, this.endpoint);
             return formatResult(resp);
           } catch (err) {
             return {
@@ -392,7 +387,7 @@ class PiChromeMcpServer {
       "page://current",
       async (uri) => {
         try {
-          const resp = await sendSocketRequest("page.read", {});
+          const resp = await sendSocketRequest("page.read", {}, this.endpoint);
           const text = resp.result?.content?.[0]?.text || "No content";
           return {
             contents: [{
@@ -418,7 +413,7 @@ class PiChromeMcpServer {
       "tabs://list",
       async (uri) => {
         try {
-          const resp = await sendSocketRequest("tab.list", {});
+          const resp = await sendSocketRequest("tab.list", {}, this.endpoint);
           const text = resp.result?.content?.[0]?.text || "[]";
           return {
             contents: [{
@@ -444,7 +439,7 @@ class PiChromeMcpServer {
       "console://messages",
       async (uri) => {
         try {
-          const resp = await sendSocketRequest("console", {});
+          const resp = await sendSocketRequest("console", {}, this.endpoint);
           const text = resp.result?.content?.[0]?.text || "No messages";
           return {
             contents: [{
@@ -470,7 +465,7 @@ class PiChromeMcpServer {
       "network://requests",
       async (uri) => {
         try {
-          const resp = await sendSocketRequest("network", {});
+          const resp = await sendSocketRequest("network", {}, this.endpoint);
           const text = resp.result?.content?.[0]?.text || "No requests";
           return {
             contents: [{
@@ -511,4 +506,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { PiChromeMcpServer };
+module.exports = { PiChromeMcpServer, TOOL_SCHEMAS };

package/native/network-export.cjs

@@ -0,0 +1,116 @@
+const fs = require("fs");
+const path = require("path");
+const { version: PACKAGE_VERSION } = require("../package.json");
+const { atomicWriteFile } = require("./private-state.cjs");
+
+const MAX_NETWORK_EXPORT_FILE_BYTES = 256 * 1024 * 1024;
+const INTERNAL_FIELDS = new Set(["_requestId", "_responseReceived", "_loadingFinished"]);
+
+function publicEntry(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    throw new Error("network export entries must be objects");
+  }
+  const result = Object.create(null);
+  for (const [key, value] of Object.entries(entry)) {
+    if (!INTERNAL_FIELDS.has(key)) result[key] = value;
+  }
+  return result;
+}
+
+function headerList(headers) {
+  if (!headers || typeof headers !== "object" || Array.isArray(headers)) return [];
+  return Object.entries(headers).map(([name, value]) => ({ name, value: String(value) }));
+}
+
+function headerValue(headers, name) {
+  if (!headers || typeof headers !== "object") return "";
+  const match = Object.entries(headers).find(([key]) => key.toLowerCase() === name);
+  return match ? String(match[1]) : "";
+}
+
+function queryList(url) {
+  try {
+    return [...new URL(url).searchParams.entries()].map(([name, value]) => ({ name, value }));
+  } catch {
+    return [];
+  }
+}
+
+function harEntry(entry) {
+  const requestBody = entry.requestBody;
+  const responseBody = entry.responseBody;
+  const requestHeaders = entry.requestHeaders;
+  const responseHeaders = entry.responseHeaders;
+  const duration = Number.isFinite(entry.duration) ? Math.max(0, entry.duration) : 0;
+  const ttfb = Number.isFinite(entry.ttfb) ? Math.max(0, entry.ttfb) : duration;
+  return {
+    startedDateTime: new Date(Number(entry.ts) || Date.now()).toISOString(),
+    time: duration,
+    request: {
+      method: entry.method || "GET",
+      url: entry.url || "",
+      httpVersion: "HTTP/1.1",
+      headers: headerList(requestHeaders),
+      queryString: queryList(entry.url || ""),
+      cookies: [],
+      headersSize: -1,
+      bodySize: Number.isFinite(entry.requestBodySize) ? entry.requestBodySize : requestBody ? Buffer.byteLength(String(requestBody)) : -1,
+      ...(requestBody !== undefined ? { postData: { mimeType: headerValue(requestHeaders, "content-type") || "application/octet-stream", text: String(requestBody) } } : {}),
+    },
+    response: {
+      status: Number.isFinite(entry.status) ? entry.status : 0,
+      statusText: entry.statusText || "",
+      httpVersion: "HTTP/1.1",
+      headers: headerList(responseHeaders),
+      cookies: [],
+      content: {
+        size: Number.isFinite(entry.responseBodySize) ? entry.responseBodySize : responseBody ? Buffer.byteLength(String(responseBody)) : 0,
+        mimeType: entry.mimeType || "",
+        ...(responseBody !== undefined ? { text: String(responseBody) } : {}),
+        ...(entry.responseBodyEncoding === "base64" ? { encoding: "base64" } : {}),
+        _surfBodyCapture: entry.bodyCapture || { mode: "none", complete: responseBody === undefined ? false : true },
+      },
+      redirectURL: "",
+      headersSize: -1,
+      bodySize: Number.isFinite(entry.responseBodySize) ? entry.responseBodySize : responseBody ? Buffer.byteLength(String(responseBody)) : -1,
+    },
+    cache: {},
+    timings: { send: 0, wait: ttfb, receive: Math.max(0, duration - ttfb) },
+    ...(entry.comment ? { comment: String(entry.comment) } : {}),
+  };
+}
+
+function serializeNetworkExport(entries, format = "json") {
+  if (!Array.isArray(entries)) throw new Error("network export entries must be an array");
+  if (format !== "json" && format !== "jsonl" && format !== "har") throw new Error(`unsupported network export format: ${format}`);
+  const publicEntries = entries.map(publicEntry);
+  if (format === "jsonl") return `${publicEntries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
+  if (format === "har") {
+    return JSON.stringify({
+      log: {
+        version: "1.2",
+        creator: { name: "surf-cli", version: PACKAGE_VERSION },
+        entries: publicEntries.map(harEntry),
+      },
+    });
+  }
+  return JSON.stringify(publicEntries, null, 2);
+}
+
+function writeNetworkExport(outputPath, entries, format = "json") {
+  if (typeof outputPath !== "string" || !path.isAbsolute(outputPath)) throw new Error("network export output must be an absolute path");
+  const content = serializeNetworkExport(entries, format);
+  const bytes = Buffer.byteLength(content);
+  if (bytes > MAX_NETWORK_EXPORT_FILE_BYTES) throw new Error("network export exceeds the 256 MiB file limit");
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  atomicWriteFile(outputPath, content, { encoding: "utf8" });
+  return { path: outputPath, format, count: entries.length, bytes };
+}
+
+module.exports = {
+  INTERNAL_FIELDS,
+  MAX_NETWORK_EXPORT_FILE_BYTES,
+  publicEntry,
+  serializeNetworkExport,
+  writeNetworkExport,
+};

package/native/network-store.cjs

@@ -11,11 +11,17 @@ const fs = require("fs");
 const path = require("path");
 const crypto = require("crypto");
 const readline = require("readline");
+const {
+  appendPrivateJsonLine,
+  assertNotSymlink,
+  atomicWriteFile,
+  atomicWriteJson,
+  ensurePrivateDir,
+  privateStatePath,
+} = require("./private-state.cjs");
 
 // Configuration
-const DEFAULT_BASE = process.platform === "win32"
-  ? require("path").join(require("os").tmpdir(), "surf")
-  : "/tmp/surf";
+const DEFAULT_BASE = privateStatePath("network");
 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
@@ -23,36 +29,26 @@ const AUTO_CLEANUP_INTERVAL = 60 * 60 * 1000; // 1 hour
 // Lock file for concurrent access
 let writeLock = Promise.resolve();
 
-// Runtime override for base path (set via CLI --network-path)
-let runtimeBasePath = null;
-
-/**
- * Set base path at runtime (from CLI --network-path flag)
- */
-function setBasePath(newPath) {
-  runtimeBasePath = newPath;
-}
-
 /**
  * Get base path for network storage
- * Priority: runtime override > SURF_NETWORK_PATH env var > default
+ * Priority: SURF_NETWORK_PATH env var > default
  */
-function getBasePath() {
-  return runtimeBasePath || process.env.SURF_NETWORK_PATH || DEFAULT_BASE;
+function getBasePath(basePath) {
+  return basePath || process.env.SURF_NETWORK_PATH || DEFAULT_BASE;
 }
 
 /**
  * Get path to requests.jsonl
  */
-function getRequestsPath() {
-  return path.join(getBasePath(), "requests.jsonl");
+function getRequestsPath(basePath) {
+  return path.join(getBasePath(basePath), "requests.jsonl");
 }
 
 /**
  * Get path to bodies directory
  */
-function getBodiesPath() {
-  return path.join(getBasePath(), "bodies");
+function getBodiesPath(basePath) {
+  return path.join(getBasePath(basePath), "bodies");
 }
 
 /**
@@ -65,16 +61,11 @@ function getMetaPath() {
 /**
  * Ensure all required directories exist
  */
-function ensureDirectories() {
-  const base = getBasePath();
-  const bodies = getBodiesPath();
-  
-  if (!fs.existsSync(base)) {
-    fs.mkdirSync(base, { recursive: true });
-  }
-  if (!fs.existsSync(bodies)) {
-    fs.mkdirSync(bodies, { recursive: true });
-  }
+function ensureDirectories(basePath) {
+  const base = getBasePath(basePath);
+  const bodies = getBodiesPath(basePath);
+  ensurePrivateDir(base, base);
+  ensurePrivateDir(bodies, base);
 }
 
 /**
@@ -84,6 +75,7 @@ function readMeta() {
   const metaPath = getMetaPath();
   try {
     if (fs.existsSync(metaPath)) {
+      assertNotSymlink(metaPath, false);
       return JSON.parse(fs.readFileSync(metaPath, "utf-8"));
     }
   } catch (err) {
@@ -98,7 +90,7 @@ function readMeta() {
 function writeMeta(meta) {
   const metaPath = getMetaPath();
   ensureDirectories();
-  fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+  atomicWriteJson(metaPath, meta, { root: getBasePath() });
 }
 
 /**
@@ -124,7 +116,7 @@ function storeBody(content, isRequest = false) {
   
   // Only write if doesn't exist (dedup)
   if (!fs.existsSync(bodyPath)) {
-    fs.writeFileSync(bodyPath, buffer);
+    atomicWriteFile(bodyPath, buffer, { root: getBasePath() });
   }
   
   return hash;
@@ -142,6 +134,7 @@ function readBody(hash, isRequest = false) {
   
   try {
     if (fs.existsSync(bodyPath)) {
+      assertNotSymlink(bodyPath, false);
       return fs.readFileSync(bodyPath);
     }
   } catch (err) {
@@ -186,10 +179,7 @@ async function appendEntry(entry) {
       ...entry
     };
     
-    const line = JSON.stringify(fullEntry) + "\n";
-    
-    // Atomic append using flag 'a'
-    fs.appendFileSync(getRequestsPath(), line, { flag: "a" });
+    appendPrivateJsonLine(getRequestsPath(), fullEntry, { root: getBasePath() });
     
     return fullEntry;
   } finally {
@@ -202,8 +192,8 @@ async function appendEntry(entry) {
  * @param {Object} entry - Network entry to append
  * @returns {Object} The entry with assigned ID
  */
-function appendEntrySync(entry) {
-  ensureDirectories();
+function appendEntrySync(entry, basePath) {
+  ensureDirectories(basePath);
   
   const id = entry.id || generateId();
   const timestamp = entry.timestamp || Date.now();
@@ -214,15 +204,14 @@ function appendEntrySync(entry) {
     ...entry
   };
   
-  const line = JSON.stringify(fullEntry) + "\n";
-  
   // Use a simple lock file for synchronous operations
-  const lockPath = path.join(getBasePath(), ".lock");
+  const lockPath = path.join(getBasePath(basePath), ".lock");
   let lockFd;
   
   try {
     // Try to acquire lock
-    lockFd = fs.openSync(lockPath, "wx");
+    assertNotSymlink(lockPath, true);
+    lockFd = fs.openSync(lockPath, "wx", 0o600);
   } catch (err) {
     // Lock exists - check if stale and remove, otherwise proceed without lock
     try {
@@ -230,7 +219,7 @@ function appendEntrySync(entry) {
       if (Date.now() - stat.mtimeMs > 5000) {
         fs.unlinkSync(lockPath);
         try {
-          lockFd = fs.openSync(lockPath, "wx");
+          lockFd = fs.openSync(lockPath, "wx", 0o600);
         } catch (e) {
           // Still can't get lock, proceed without it
         }
@@ -241,13 +230,13 @@ function appendEntrySync(entry) {
     
     if (lockFd === undefined) {
       // Proceed without lock as fallback
-      fs.appendFileSync(getRequestsPath(), line, { flag: "a" });
+      appendPrivateJsonLine(getRequestsPath(basePath), fullEntry, { root: getBasePath(basePath) });
       return fullEntry;
     }
   }
   
   try {
-    fs.appendFileSync(getRequestsPath(), line, { flag: "a" });
+    appendPrivateJsonLine(getRequestsPath(basePath), fullEntry, { root: getBasePath(basePath) });
   } finally {
     if (lockFd !== undefined) {
       fs.closeSync(lockFd);
@@ -385,6 +374,7 @@ async function readEntries(filters = {}) {
   if (!fs.existsSync(requestsPath)) {
     return [];
   }
+  assertNotSymlink(requestsPath, false);
   
   const { last } = filters;
   const entries = [];
@@ -433,6 +423,7 @@ function readEntriesSync(filters = {}) {
   if (!fs.existsSync(requestsPath)) {
     return [];
   }
+  assertNotSymlink(requestsPath, false);
   
   const { last } = filters;
   const entries = [];
@@ -682,10 +673,8 @@ async function cleanup(options = {}) {
   
   if (deletedEntries > 0 || entries.length === 0) {
     // Atomic write: write to temp then rename
-    const tempPath = requestsPath + ".tmp";
     const content = entries.map(e => JSON.stringify(e)).join("\n") + (entries.length > 0 ? "\n" : "");
-    fs.writeFileSync(tempPath, content);
-    fs.renameSync(tempPath, requestsPath);
+    atomicWriteFile(requestsPath, content, { root: getBasePath(), encoding: "utf8" });
   }
   
   // 6. Update meta
@@ -777,10 +766,8 @@ async function clear(options = {}) {
   
   // Rewrite entries file
   if (deletedEntries > 0) {
-    const tempPath = requestsPath + ".tmp";
     const content = remaining.map(e => JSON.stringify(e)).join("\n") + (remaining.length > 0 ? "\n" : "");
-    fs.writeFileSync(tempPath, content);
-    fs.renameSync(tempPath, requestsPath);
+    atomicWriteFile(requestsPath, content, { root: getBasePath(), encoding: "utf8" });
   }
   
   return { deletedEntries, deletedBodies };
@@ -807,9 +794,6 @@ function maybeAutoCleanup() {
   }
 }
 
-// Run auto-cleanup check on module load
-maybeAutoCleanup();
-
 module.exports = {
   // Configuration
   getBasePath,
@@ -841,10 +825,6 @@ module.exports = {
   clear,
   maybeAutoCleanup,
   
-  // Configuration
-  setBasePath,
-  getBasePath,
-  
   // Constants
   DEFAULT_BASE,
   DEFAULT_TTL,