surf-cli 2.7.2 → 2.9.0

package/native/client-transport.cjs

@@ -0,0 +1,168 @@
+const { connectEndpoint } = require("./endpoint.cjs");
+const { createFrameParser, createSocketWriter } = require("./remote-transport.cjs");
+const { createClientTransferController } = require("./file-transfer.cjs");
+
+const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+
+async function openClientTransport(endpoint, { requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS } = {}) {
+  let socket;
+  let ready;
+  let readyReject;
+  let readyErrorListener;
+  ready = new Promise((resolve, reject) => {
+    readyReject = reject;
+    readyErrorListener = (error) => reject(error);
+    socket = connectEndpoint(endpoint, () => {
+      socket.removeListener("error", readyErrorListener);
+      resolve();
+    });
+    socket.once("error", readyErrorListener);
+  });
+  await ready;
+  const pending = new Map();
+  const writer = createSocketWriter(socket, { onOverflow: ({ error }) => socket.destroy(error) });
+  const transfers = endpoint.kind === "remote"
+    ? createClientTransferController({ writer, onActivity: () => {} })
+    : null;
+  let transferChain = Promise.resolve();
+  let transferCleanupPromise = null;
+  const cleanupTransfers = (error) => {
+    if (!transfers) return Promise.resolve();
+    transferCleanupPromise ||= transfers.cleanup(error);
+    return transferCleanupPromise;
+  };
+  const rejectPending = (error) => {
+    for (const entry of pending.values()) {
+      clearTimeout(entry.timer);
+      entry.reject(error);
+    }
+    pending.clear();
+  };
+  const parser = createFrameParser({
+    onFrame(message) {
+      if (transfers && message.type && message.type.startsWith("transfer_")) {
+        transferChain = transferChain.then(() => transfers.handle(message)).catch((error) => {
+          rejectPending(error);
+          return writer.send({ type: "transfer_error", version: 1, transferId: message.transferId, error: error.message }).finally(() => socket.destroy(error)).then(() => { throw error; });
+        });
+        transferChain.catch(() => undefined);
+        return;
+      }
+      if (message.type === "extension_disconnected") {
+        transferChain = transferChain.then(() => {
+          const error = new Error(message.message || "Surf extension disconnected");
+          rejectPending(error);
+          socket.end();
+        });
+        transferChain.catch(() => undefined);
+        return;
+      }
+      if (message.id === undefined || !pending.has(message.id)) return;
+      transferChain = transferChain.then(() => {
+        const entry = pending.get(message.id);
+        if (!entry) return;
+        pending.delete(message.id);
+        clearTimeout(entry.timer);
+        entry.resolve(message);
+      }).catch((error) => {
+        rejectPending(error);
+        socket.destroy(error);
+      });
+      transferChain.catch(() => undefined);
+    },
+    onError(error) {
+      rejectPending(error);
+      readyReject?.(error);
+      socket.destroy();
+    },
+  });
+  socket.on("data", (chunk) => parser.push(chunk));
+  let closed = false;
+  socket.on("close", () => {
+    parser.close();
+    const error = new Error("connection closed");
+    rejectPending(error);
+    writer.close(error);
+    cleanupTransfers(error);
+    closed = true;
+  });
+  return {
+    socket,
+    transfers,
+    async request(message, timeoutMs = requestTimeoutMs, transferPlan = {}) {
+      if (closed) throw new Error("client transport is closed");
+      if (message.id === undefined || message.id === null) throw new Error("request id is required");
+      if (pending.has(message.id)) throw new Error("duplicate request id");
+      const downloadIds = (transferPlan.downloads || []).map((download) => download.transferId);
+      const timeoutError = new Error("request timed out");
+      let rejectTimeout;
+      const timeout = new Promise((_, reject) => { rejectTimeout = reject; });
+      timeout.catch(() => undefined);
+      const timer = setTimeout(() => {
+        closed = true;
+        rejectPending(timeoutError);
+        cleanupTransfers(timeoutError).catch(() => {});
+        writer.close(timeoutError);
+        socket.destroy();
+        rejectTimeout(timeoutError);
+      }, timeoutMs);
+      const execute = async () => {
+        try {
+          if (transfers) {
+            for (const download of transferPlan.downloads || []) await transfers.expectDownload(download);
+            const uploadDescriptors = [];
+            for (const upload of transferPlan.uploads || []) {
+              const result = await transfers.upload(upload.path, upload);
+              uploadDescriptors.push({ transferId: result.transferId, field: upload.field, original: upload.original, kind: "upload" });
+            }
+            message = { ...message, _surfTransfers: { uploads: uploadDescriptors, downloads: (transferPlan.downloads || []).map(({ transferId, field, original }) => ({ transferId, field, original, kind: "download" })) }, _surfPaths: transferPlan.pathRefs || [] };
+          }
+          const response = new Promise((resolve, reject) => {
+            pending.set(message.id, { resolve, reject, timer });
+          });
+          response.catch(() => undefined);
+          try {
+            await writer.send(message);
+          } catch (error) {
+            const entry = pending.get(message.id);
+            if (entry) { pending.delete(message.id); clearTimeout(entry.timer); entry.reject(error); }
+            await transfers?.cancelDownloads(downloadIds);
+            await response.catch(() => undefined);
+            throw error;
+          }
+          const result = await response;
+          if (result.error || (transfers && downloadIds.some((id) => transfers.hasDownload(id)))) {
+            await transfers?.cancelDownloads(downloadIds);
+            if (!result.error) throw new Error("request completed without completing output download");
+          }
+          return result;
+        } catch (error) {
+          await transfers?.cancelDownloads(downloadIds);
+          throw error;
+        }
+      };
+      try {
+        return await Promise.race([execute(), timeout]);
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+    async closeAsync() {
+      if (closed) return transferCleanupPromise;
+      closed = true;
+      const error = new Error("client transport is closed");
+      parser.close();
+      rejectPending(error);
+      writer.close(error);
+      const cleanup = cleanupTransfers(error);
+      socket.end();
+      await cleanup;
+      return cleanup;
+    },
+    close() {
+      return this.closeAsync();
+    },
+  };
+}
+
+module.exports = { DEFAULT_REQUEST_TIMEOUT_MS, openClientTransport };

package/native/config.cjs

@@ -25,10 +25,10 @@ const STARTER_CONFIG = {
 // {
 //   "grok": {
 //     "models": {
-//       "thinking": { "id": "thinking", "name": "Grok 4.1 Thinking" },
 //       "auto": { "id": "auto", "name": "Auto" },
 //       "fast": { "id": "fast", "name": "Fast" },
-//       "expert": { "id": "expert", "name": "Expert" }
+//       "expert": { "id": "expert", "name": "Expert" },
+//       "grok-4.20-beta": { "id": "grok-4.20-beta", "name": "Grok 4.20 Beta" }
 //     }
 //   }
 // }

package/native/do-executor.cjs

@@ -10,9 +10,10 @@
  * Follows the same socket communication pattern as --script mode in cli.cjs.
  */
 
-const net = require("net");
-
-const SOCKET_PATH = process.platform === "win32" ? "//./pipe/surf" : "/tmp/surf.sock";
+const { selectEndpoint } = require("./endpoint.cjs");
+const { openClientTransport } = require("./client-transport.cjs");
+const { resolveRequestDeadlineMs } = require("./host-sessions.cjs");
+const { prepareRemoteTool, validateLocalToolPaths } = require("./file-transfer.cjs");
 
 // Maximum iterations for loops (safety cap)
 const MAX_LOOP_ITERATIONS = 100;
@@ -72,54 +73,27 @@ function getAutoWaitCommand(cmd) {
  * @returns {Promise<object>} - Response from host
  */
 function sendDoRequest(toolName, toolArgs, context = {}) {
-  return new Promise((resolve, reject) => {
-    const sock = net.createConnection(SOCKET_PATH, () => {
-      const req = {
-        type: "tool_request",
-        method: "execute_tool",
-        params: { tool: toolName, args: toolArgs },
-        id: "do-" + Date.now() + "-" + Math.random(),
-      };
-      if (context.tabId) req.tabId = context.tabId;
-      if (context.windowId) req.windowId = context.windowId;
-      sock.write(JSON.stringify(req) + "\n");
-    });
-    
-    let buf = "";
-    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 {
-          const resp = JSON.parse(line);
-          sock.end();
-          resolve(resp);
-        } catch {
-          sock.end();
-          reject(new Error("Invalid JSON response"));
-        }
-      }
-    });
-    
-    sock.on("error", (e) => {
-      if (e.code === "ENOENT") {
-        reject(new Error("Socket not found. Is Chrome running with the extension?"));
-      } else if (e.code === "ECONNREFUSED") {
-        reject(new Error("Connection refused. Native host not running."));
-      } else {
-        reject(e);
-      }
-    });
-    
-    const timeoutId = setTimeout(() => { 
-      sock.destroy(); 
-      reject(new Error("Request timeout")); 
-    }, 30000);
-    
-    sock.on("close", () => clearTimeout(timeoutId));
-  });
+  const request = {
+    type: "tool_request",
+    method: "execute_tool",
+    params: { tool: toolName, args: toolArgs },
+    id: "do-" + Date.now() + "-" + Math.random(),
+  };
+  if (context.tabId) request.tabId = context.tabId;
+  if (context.windowId) request.windowId = context.windowId;
+  const requestTimeoutMs = context.timeoutMs || resolveRequestDeadlineMs(toolName, toolArgs);
+  const endpoint = context.endpoint || selectEndpoint([]).endpoint;
+  const prepared = endpoint.kind === "remote" ? prepareRemoteTool(toolName, toolArgs) : (() => { const args = validateLocalToolPaths(toolName, toolArgs); return { args, uploads: [], downloads: [] }; })();
+  request.params.args = prepared.args;
+  if (context.transport) return context.transport.request(request, requestTimeoutMs, prepared);
+  return (async () => {
+    const transport = await openClientTransport(endpoint);
+    try {
+      return await transport.request(request, requestTimeoutMs, prepared);
+    } finally {
+      await transport.close();
+    }
+  })();
 }
 
 /**

package/native/do-parser.cjs

@@ -165,6 +165,18 @@ function parseCommandLine(line) {
       } else if (values.length > 1) {
         args.values = values;     // Multiple values as array
       }
+    } else if (cmd === 'scroll') {
+      if (firstArg === 'top' || firstArg === 'bottom') {
+        cmd = `scroll.${firstArg}`;
+        i++;
+      } else if (['up', 'down', 'left', 'right'].includes(firstArg)) {
+        args.direction = firstArg;
+        i++;
+        if (i < tokens.length && /^-?\d+$/.test(tokens[i])) {
+          args.scroll_pixels = parseInt(tokens[i], 10);
+          i++;
+        }
+      }
     } else {
       // Use PRIMARY_ARG_MAP for other commands
       const primaryKey = PRIMARY_ARG_MAP[cmd];