surf-cli 2.8.0 → 2.9.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,113 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { version: PACKAGE_VERSION } = require("../package.json");
+
+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 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: [],
+      cookies: [],
+      headersSize: -1,
+      bodySize: Number.isFinite(entry.requestBodySize) ? entry.requestBodySize : requestBody ? Buffer.byteLength(String(requestBody)) : -1,
+      ...(requestBody !== undefined ? { postData: { mimeType: "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) } : {}),
+      },
+      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 });
+  const temporaryPath = path.join(path.dirname(outputPath), `.${path.basename(outputPath)}.surf-${crypto.randomBytes(12).toString("hex")}.tmp`);
+  try {
+    const fd = fs.openSync(temporaryPath, "wx", 0o600);
+    try {
+      fs.writeFileSync(fd, content, "utf8");
+      fs.fchmodSync(fd, 0o600);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.renameSync(temporaryPath, outputPath);
+  } catch (error) {
+    try { fs.rmSync(temporaryPath, { force: true }); } catch {}
+    throw error;
+  }
+  return { path: outputPath, format, count: entries.length, bytes };
+}
+
+module.exports = {
+  INTERNAL_FIELDS,
+  MAX_NETWORK_EXPORT_FILE_BYTES,
+  publicEntry,
+  serializeNetworkExport,
+  writeNetworkExport,
+};

package/native/perplexity-client.cjs

@@ -5,14 +5,16 @@
  * Similar approach to the ChatGPT client.
  */
 
+const { abortableDelay, raceAbort, throwIfAborted } = require("./abort.cjs");
+
 const PERPLEXITY_URL = "https://www.perplexity.ai/";
 
 // ============================================================================
 // Helpers
 // ============================================================================
 
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+function delay(ms, signal) {
+  return abortableDelay(ms, signal);
 }
 
 function buildClickDispatcher() {
@@ -371,7 +373,27 @@ async function submitPrompt(cdp, inputCdp) {
 // Response Handling
 // ============================================================================
 
-async function waitForResponse(cdp, timeoutMs = 120000) {
+function extractPerplexityResponseText() {
+  const selectors = [
+    '[id^="markdown-content"]',
+    '[data-testid="answer"]',
+    'article',
+    '.prose',
+  ];
+
+  for (const selector of selectors) {
+    const elements = Array.from(document.querySelectorAll(selector));
+    for (let i = elements.length - 1; i >= 0; i--) {
+      const text = elements[i].innerText?.trim() || '';
+      if (text) return text;
+    }
+  }
+
+  return '';
+}
+
+async function waitForResponse(cdp, timeoutMs = 120000, signal) {
+  throwIfAborted(signal);
   const deadline = Date.now() + timeoutMs;
   let previousText = '';
   let stableCycles = 0;
@@ -386,17 +408,16 @@ async function waitForResponse(cdp, timeoutMs = 120000) {
     if (url && url.includes('/search/')) {
       break;
     }
-    await delay(200);
+    await delay(200, signal);
   }
   
   // Wait a bit for the response area to render
-  await delay(1000);
+  await delay(1000, signal);
   
   // Now poll for response completion
   while (Date.now() < deadline) {
     const snapshot = await evaluate(cdp, `(function() {
-      const prose = document.querySelector('.prose');
-      const text = prose ? prose.innerText : '';
+      const text = (${extractPerplexityResponseText.toString()})();
       const hasStop = !!document.querySelector('button[aria-label*=stop], button[aria-label*=Stop]');
       const hasCopy = !!document.querySelector('button[aria-label*=copy], button[aria-label*=Copy]');
       const hasRelated = document.body.innerText.indexOf('Related') > -1;
@@ -412,7 +433,7 @@ async function waitForResponse(cdp, timeoutMs = 120000) {
     })()`);
     
     if (!snapshot) {
-      await delay(300);
+      await delay(300, signal);
       continue;
     }
     
@@ -437,7 +458,7 @@ async function waitForResponse(cdp, timeoutMs = 120000) {
     const hasCompletionIndicators = snapshot.hasActions || snapshot.hasRelated || snapshot.hasFollowUp;
     const isDone = !snapshot.generating && (hasCompletionIndicators || isStable);
     
-    if (isDone && currentText.length > 20) {
+    if (isDone && currentText.trim().length > 0) {
       // Clean up the response text
       let cleanText = currentText;
       
@@ -454,11 +475,11 @@ async function waitForResponse(cdp, timeoutMs = 120000) {
       };
     }
     
-    await delay(300);
+    await delay(300, signal);
   }
   
   // Timeout - return whatever we have
-  if (previousText.length > 20) {
+  if (previousText.trim().length > 0) {
     return {
       text: previousText,
       sources: 0,
@@ -485,13 +506,15 @@ async function query(options) {
     cdpEvaluate,
     cdpCommand,
     log = () => {},
+    signal,
   } = options;
+  throwIfAborted(signal);
   
   const startTime = Date.now();
   log("Starting Perplexity query");
   
   // Create tab
-  const tabInfo = await createTab();
+  const tabInfo = await raceAbort(createTab, signal);
   log(`createTab returned: ${JSON.stringify(tabInfo)}`);
   const { tabId } = tabInfo || {};
   
@@ -500,8 +523,8 @@ async function query(options) {
   }
   log(`Created tab ${tabId}`);
   
-  const cdp = (expr) => cdpEvaluate(tabId, expr);
-  const inputCdp = (method, params) => cdpCommand(tabId, method, params);
+  const cdp = (expr) => raceAbort(() => cdpEvaluate(tabId, expr), signal);
+  const inputCdp = (method, params) => raceAbort(() => cdpCommand(tabId, method, params), signal);
   
   try {
     // Wait for page load
@@ -522,6 +545,7 @@ async function query(options) {
         const selectedMode = await selectMode(cdp, mode);
         log(`Mode: ${selectedMode}`);
       } catch (e) {
+        if (signal?.aborted) throw e;
         log(`Mode selection failed: ${e.message}`);
       }
     }
@@ -532,6 +556,7 @@ async function query(options) {
         const selectedModel = await selectModel(cdp, model);
         log(`Model: ${selectedModel}`);
       } catch (e) {
+        if (signal?.aborted) throw e;
         log(`Model selection failed: ${e.message}`);
       }
     }
@@ -545,7 +570,7 @@ async function query(options) {
     log("Submitted, waiting for response...");
     
     // Wait for response
-    const response = await waitForResponse(cdp, timeout);
+    const response = await waitForResponse(cdp, timeout, signal);
     log(`Response: ${response.text.length} chars, ${response.sources} sources${response.partial ? ' (partial)' : ''}`);
     
     return {
@@ -558,8 +583,12 @@ async function query(options) {
       tookMs: Date.now() - startTime,
     };
   } finally {
-    await closeTab(tabId).catch(() => {});
+    try {
+      await closeTab(tabId);
+    } catch (error) {
+      log(`Failed to close Perplexity tab ${tabId}: ${error?.message || error}`);
+    }
   }
 }
 
-module.exports = { query, PERPLEXITY_URL };
+module.exports = { query, PERPLEXITY_URL, waitForResponse, extractPerplexityResponseText };