surf-cli 2.9.0 → 2.10.0

package/native/do-parser.cjs

@@ -1,250 +1,9 @@
-/**
- * Parser for surf `do` workflow commands
- * 
- * Parses newline-separated commands into structured step arrays:
- * 
- * Input:
- *   'go "https://example.com"
- *    click e5
- *    screenshot'
- * 
- * Output:
- *   [
- *     { cmd: 'navigate', args: { url: 'https://example.com' } },
- *     { cmd: 'click', args: { ref: 'e5' } },
- *     { cmd: 'screenshot', args: {} }
- *   ]
- */
-
-// Aliases mapping (matches cli.cjs)
-const ALIASES = {
-  snap: "screenshot",
-  read: "page.read",
-  find: "search",
-  go: "navigate",
-  net: "network",
-  "network.dump": "network.get",
-};
-
-// Primary argument mapping for positional args (matches cli.cjs)
-const PRIMARY_ARG_MAP = {
-  ai: "query",
-  gemini: "query",
-  chatgpt: "query",
-  perplexity: "query",
-  grok: "query",
-  navigate: "url",
-  go: "url",
-  js: "code",
-  javascript_tool: "code",
-  key: "key",
-  wait: "duration",
-  health: "url",
-  new_tab: "url",
-  "tab.new": "url",
-  switch_tab: "tab_id",
-  "tab.switch": "id",
-  close_tab: "tab_id",
-  "tab.close": "id",
-  "tab.name": "name",
-  "tab.unname": "name",
-  scroll_to_position: "position",
-  type: "text",
-  smart_type: "text",
-  "emulate.network": "preset",
-  "emulate.cpu": "rate",
-  search: "term",
-  find: "term",
-  "wait.element": "selector",
-  "wait.url": "pattern",
-  zoom: "level",
-  "history.search": "query",
-  "network.get": "id",
-  "network.body": "id",
-  "network.curl": "id",
-  "network.path": "id",
-  "window.new": "url",
-  "window.focus": "id",
-  "window.close": "id",
-  "locate.role": "role",
-  "locate.text": "text",
-  "locate.label": "label",
-  "emulate.device": "device",
-  "frame.js": "code",
-  "element.styles": "selector",
-  "select": "selector",
-};
-
-/**
- * Tokenize a command line, respecting single and double quotes
- * @param {string} line - Single line to tokenize
- * @returns {string[]} - Array of tokens
- */
-function tokenize(line) {
-  const tokens = [];
-  let current = '';
-  let inQuote = null;
-  
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i];
-    
-    if (inQuote) {
-      if (ch === inQuote) {
-        // End of quoted string
-        inQuote = null;
-      } else {
-        current += ch;
-      }
-    } else if (ch === '"' || ch === "'") {
-      // Start of quoted string
-      inQuote = ch;
-    } else if (ch === ' ' || ch === '\t') {
-      // Whitespace separator
-      if (current) {
-        tokens.push(current);
-        current = '';
-      }
-    } else {
-      current += ch;
-    }
-  }
-  
-  // Don't forget last token
-  if (current) {
-    tokens.push(current);
-  }
-  
-  return tokens;
-}
-
-/**
- * Parse a single command line into a step object
- * @param {string} line - Single command line
- * @returns {{ cmd: string, args: object } | null}
- */
-function parseCommandLine(line) {
-  const tokens = tokenize(line);
-  if (tokens.length === 0) return null;
-  
-  // Get command and apply alias
-  let cmd = tokens[0];
-  cmd = ALIASES[cmd] || cmd;
-  
-  const args = {};
-  let i = 1;
-  
-  // Handle first positional argument based on command type
-  if (i < tokens.length && !tokens[i].startsWith('--')) {
-    const firstArg = tokens[i];
-    
-    // Special handling for click command
-    if (cmd === 'click') {
-      if (/^e\d+$/.test(firstArg)) {
-        // Element reference: e5 -> ref
-        args.ref = firstArg;
-        i++;
-      } else if (/^\d+$/.test(firstArg) && tokens[i + 1] && /^\d+$/.test(tokens[i + 1])) {
-        // Coordinates: 100 200 -> x, y
-        args.x = parseInt(firstArg, 10);
-        args.y = parseInt(tokens[i + 1], 10);
-        i += 2;
-      }
-    } else if (cmd === 'select') {
-      // Select takes selector + one or more values: select e5 "US" or select e5 "opt1" "opt2"
-      args.selector = firstArg;
-      i++;
-      // Collect remaining positional args as values
-      const values = [];
-      while (i < tokens.length && !tokens[i].startsWith('--')) {
-        values.push(tokens[i]);
-        i++;
-      }
-      // Host expects 'values' (always), matching CLI behavior
-      if (values.length === 1) {
-        args.values = values[0];  // Single value as string (host will wrap in array)
-      } 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];
-      if (primaryKey) {
-        args[primaryKey] = firstArg;
-        i++;
-      }
-    }
-  }
-  
-  // Parse --flag value pairs
-  while (i < tokens.length) {
-    const token = tokens[i];
-    if (token.startsWith('--')) {
-      const key = token.slice(2);
-      const next = tokens[i + 1];
-      if (next && !next.startsWith('--')) {
-        // Flag with value
-        let val = next;
-        // Type coercion
-        if (val === "true") val = true;
-        else if (val === "false") val = false;
-        else if (/^-?\d+$/.test(val)) val = parseInt(val, 10);
-        else if (/^-?\d+\.\d+$/.test(val)) val = parseFloat(val);
-        args[key] = val;
-        i += 2;
-      } else {
-        // Boolean flag
-        args[key] = true;
-        i++;
-      }
-    } else {
-      // Skip unrecognized positional (shouldn't happen normally)
-      i++;
-    }
-  }
-  
-  return { cmd, args };
-}
-
-/**
- * Parse a workflow string into step array
- * Supports pipe-separated (inline) or newline-separated (file) commands
- * @param {string} input - Workflow string
- * @returns {Array<{ cmd: string, args: object }>}
- */
-function parseDoCommands(input) {
-  // Determine separator: use pipe if present, otherwise newlines
-  // Pipe is preferred for inline: 'go "url" | click e5 | screenshot'
-  // Newlines for files or heredocs
-  const hasPipe = input.includes('|');
-  const separator = hasPipe ? '|' : '\n';
-  
-  // Also handle literal \n for backwards compatibility
-  const normalized = hasPipe ? input : input.replace(/\\n/g, '\n');
-  
-  return normalized
-    .split(separator)
-    .map(line => line.trim())
-    .filter(line => line && !line.startsWith('#'))
-    .map(line => parseCommandLine(line))
-    .filter(step => step !== null);
-}
-
-module.exports = { 
-  parseDoCommands, 
-  parseCommandLine, 
-  tokenize,
-  ALIASES,
-  PRIMARY_ARG_MAP
+const definition = require("./workflow-definition.cjs");
+
+module.exports = {
+  ALIASES: definition.ALIASES,
+  PRIMARY_ARG_MAP: definition.PRIMARY_ARG_MAP,
+  parseCommandLine: definition.parseCommandLine,
+  parseDoCommands: definition.parseDoCommands,
+  tokenize: definition.tokenize,
 };

package/native/host-helpers.cjs

@@ -1,6 +1,5 @@
 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();
@@ -123,19 +122,6 @@ function formatToolContent(result, log = () => {}, options = {}) {
   // Handle both requests (basic) and entries (full) formats
   const items = result.requests || result.entries;
   if (items && Array.isArray(items)) {
-    // Persist entries with full data to disk
-    if (result.entries && items.length > 0) {
-      (async () => {
-        for (const entry of items) {
-          try {
-            await networkStore.appendEntry(entry);
-          } catch (err) {
-            log(`Failed to persist network entry: ${err.message}`);
-          }
-        }
-      })();
-    }
-    
     if (items.length === 0) {
       return text("No network requests captured");
     }
@@ -679,6 +665,9 @@ function mapToolToMessage(tool, args, tabId) {
         limit: a.limit || a.last,
         format: a.format,
         verbose: a.v ? 1 : (a.vv ? 2 : 0),
+        bodyMode: a["body-mode"] || a.bodyMode,
+        perBodyBytes: a["per-body-bytes"] || a.perBodyBytes,
+        totalBodyBytes: a["total-body-bytes"] || a.totalBodyBytes,
         ...baseMsg 
       };
 
@@ -732,6 +721,9 @@ function mapToolToMessage(tool, args, tabId) {
         type: "EXPORT_NETWORK_REQUESTS",
         har: a.har,
         jsonl: a.jsonl,
+        bodyMode: a["body-mode"] || a.bodyMode,
+        perBodyBytes: a["per-body-bytes"] || a.perBodyBytes,
+        totalBodyBytes: a["total-body-bytes"] || a.totalBodyBytes,
         ...baseMsg 
       };
 

package/native/host-sessions.cjs

@@ -23,13 +23,17 @@ const PROVIDER_DEFAULT_TIMEOUT_SECONDS = {
   gemini: 300,
   grok: 300,
   perplexity: 120,
+  "playbook.run": 600,
 };
 
 function resolveRequestDeadlineMs(tool, args = {}) {
   const defaultSeconds = PROVIDER_DEFAULT_TIMEOUT_SECONDS[tool];
   if (defaultSeconds === undefined) return DEFAULT_DEADLINE_MS;
+  const rawTimeout = tool === "playbook.run" && args && typeof args === "object" && !Array.isArray(args)
+    ? args.timeout ?? args.args?.timeout
+    : args?.timeout;
   const requestedSeconds = Number(
-    args && typeof args === "object" && !Array.isArray(args) ? args.timeout : undefined,
+    rawTimeout,
   );
   const seconds = Number.isFinite(requestedSeconds) && requestedSeconds > 0
     ? requestedSeconds

package/native/host.cjs

@@ -22,11 +22,30 @@ const { parseListenEndpoint } = require("./listener.cjs");
 const { getStateDir } = require("./remote-auth.cjs");
 const { createFrameParser, createServerAuthSession, createSocketWriter, isClientAuthorized, writeFrame, MAX_FRAME_BYTES } = require("./remote-transport.cjs");
 const { HostSessionManager, resolveRequestDeadlineMs } = require("./host-sessions.cjs");
-const { abortError, throwIfAborted } = require("./abort.cjs");
+const { abortError, abortableDelay, throwIfAborted } = require("./abort.cjs");
 const { BoundedAiQueue } = require("./ai-queue.cjs");
 const { RequestPendingMap } = require("./request-pending.cjs");
 const { cleanupFilePaths, createStagingDirectory, createTransferState, materializeRemoteTool, rewriteTransferPaths, streamFileDownload, transferError } = require("./file-transfer.cjs");
 const { writeNetworkExport } = require("./network-export.cjs");
+const networkStore = require("./network-store.cjs");
+const { redactUrlSecrets } = require("./redaction.cjs");
+const { appendActivity, journalCommand } = require("./activity-journal.cjs");
+const { reserveReceipt, updateReceipt } = require("./playbook-receipts.cjs");
+const {
+  activeRecord,
+  appendRecordEvent,
+  attachNetworkTrace,
+  discardRecord,
+  markRecord,
+  pauseRecord,
+  resumeRecord,
+  startRecord,
+  stopRecord,
+  updateRecordContext,
+} = require("./playbook-records.cjs");
+const { resolveArgs, runPlaybookOp } = require("./playbook-runtime.cjs");
+const { resolveOp } = require("./playbooks.cjs");
+const { commandMetadata, redactCommandArgs } = require("./workflow-definition.cjs");
 const MAX_CLIENT_FRAME_BYTES = MAX_FRAME_BYTES;
 const TEST_REQUEST_DEADLINE_MS = process.env.SURF_TEST_MODE === "1" && Number.isFinite(Number(process.env.SURF_TEST_REQUEST_DEADLINE_MS))
   ? Number(process.env.SURF_TEST_REQUEST_DEADLINE_MS)
@@ -428,6 +447,131 @@ function requestCallExtension(request, tool, message, timeoutMs = 30000, cleanup
   });
 }
 
+async function executeMappedHostTool(request, tool, args, tabId) {
+  const extensionMsg = mapToolToMessage(tool, args, tabId);
+  if (!extensionMsg) throw new Error(`Unknown tool: ${tool}`);
+  if (extensionMsg.type === "UNSUPPORTED_ACTION") throw new Error(extensionMsg.message);
+  if (extensionMsg.type === "LOCAL_WAIT") {
+    await abortableDelay(extensionMsg.seconds * 1000, request.signal);
+    return { success: true };
+  }
+  if (extensionMsg.type === "BATCH_EXECUTE" || extensionMsg.type.endsWith("_QUERY")) {
+    throw new Error(`tool ${tool} is not available inside a host-owned workflow`);
+  }
+  return requestCallExtension(request, tool, extensionMsg, resolveRequestDeadlineMs(tool, args));
+}
+
+async function executeNativePlaybook(request, handler, args, options = {}) {
+  if (handler !== "chatgpt.ask") throw new Error(`unknown native playbook handler: ${handler}`);
+  const result = await chatgptClient.query({
+    prompt: args.prompt,
+    signal: request.signal,
+    model: args.model,
+    timeout: args.timeout ? Number(args.timeout) * 1000 : undefined,
+    getCookies: () => requestCallExtension(request, "get_cookies", { type: "GET_CHATGPT_COOKIES" }),
+    createTab: () => requestCallExtension(request, "create_tab", { type: "CHATGPT_NEW_TAB" }),
+    closeTab: (tabId) => requestCallExtension(request, "close_tab", { type: "CHATGPT_CLOSE_TAB", tabId }, 45000, true),
+    cdpEvaluate: (tabId, expression) => requestCallExtension(request, "cdp_evaluate", { type: "CHATGPT_EVALUATE", tabId, expression }),
+    cdpCommand: (tabId, method, params) => requestCallExtension(request, "cdp_command", { type: "CHATGPT_CDP_COMMAND", tabId, method, params }),
+    beforeSubmit: options.markDispatched,
+    log: (message) => log(`[playbook:chatgpt] ${message}`),
+  });
+  return { response: result.response, model: result.model, tookMs: result.tookMs };
+}
+
+async function runHostPlaybook(msg, request) {
+  const params = msg.params?.args || {};
+  const { playbook, op } = resolveOp(params.playbook, params.op, {
+    cwd: request.context?.isRemote ? process.cwd() : params.projectDir || process.cwd(),
+    pinBuiltIn: params.pinBuiltIn === true,
+  });
+  const runArgs = resolveArgs(op, params.args || {});
+  if (op.effect === "write" && op.safety.authorization === "explicit" && params.write !== true) {
+    throw new Error(`write op ${playbook.id} ${op.id} requires --write`);
+  }
+  const receipt = reserveReceipt({
+    playbookId: playbook.id,
+    op,
+    args: runArgs,
+    repeat: params.repeat === true,
+    retryAttempt: params.retryAttempt,
+    overrideInDoubt: params.overrideInDoubt === true,
+  });
+  const report = (event) => {
+    appendActivity(event);
+    appendRecordEvent(event);
+  };
+  return runPlaybookOp({
+    playbook,
+    op,
+    args: runArgs,
+    attemptId: receipt?.attemptId,
+    signal: request.signal,
+    executeTool: (tool, args) => executeMappedHostTool(request, tool, args, msg.tabId),
+    executeNative: (handler, args, options) => executeNativePlaybook(request, handler, args, options),
+    sleep: (ms) => abortableDelay(ms, request.signal),
+    onEvent: report,
+    beforeDispatch: async () => updateReceipt(receipt, "dispatched"),
+    afterDispatch: async ({ status, error }) => updateReceipt(receipt, status, { error }),
+  });
+}
+
+async function handleRecordRequest(tool, args, msg, request) {
+  if (tool === "playbook.record.start") {
+    let record = startRecord({ ...args, tabId: msg.tabId });
+    try {
+      const context = await requestCallExtension(request, tool, {
+        type: "GET_PLAYBOOK_RECORD_CONTEXT",
+        tabId: msg.tabId,
+      });
+      record = updateRecordContext({
+        tabId: context._resolvedTabId || msg.tabId,
+        origin: context.origin,
+      });
+      if (record.capture.network) {
+        const result = await requestCallExtension(request, tool, { type: "START_NETWORK_CAPTURE", tabId: record.tabId, bodyMode: "text" });
+        record = updateRecordContext({ tabId: result._resolvedTabId || record.tabId });
+      }
+      if (record.capture.watch) {
+        const result = await requestCallExtension(request, tool, { type: "START_PLAYBOOK_WATCH", tabId: record.tabId || msg.tabId, includeInputValues: record.redaction.includeInputValues });
+        record = updateRecordContext({ tabId: result._resolvedTabId || record.tabId || msg.tabId });
+      }
+      return record;
+    } catch (error) {
+      if (record?.capture.network) await requestCallExtension(request, tool, { type: "STOP_NETWORK_CAPTURE", tabId: record.tabId }, 30000, true).catch(() => {});
+      if (record?.capture.watch) await requestCallExtension(request, tool, { type: "STOP_PLAYBOOK_WATCH", tabId: record.tabId }, 30000, true).catch(() => {});
+      discardRecord();
+      throw error;
+    }
+  }
+  if (tool === "playbook.record.status") return activeRecord() || { status: "idle" };
+  if (tool === "playbook.record.mark") return markRecord(args.label);
+  if (tool === "playbook.record.pause") return pauseRecord();
+  if (tool === "playbook.record.resume") return resumeRecord();
+  if (tool === "playbook.record.discard") {
+    const record = activeRecord();
+    if (record?.capture.network) await requestCallExtension(request, tool, { type: "STOP_NETWORK_CAPTURE", tabId: record.tabId }, 30000, true).catch(() => {});
+    if (record?.capture.watch) await requestCallExtension(request, tool, { type: "STOP_PLAYBOOK_WATCH", tabId: record.tabId }, 30000, true).catch(() => {});
+    return discardRecord();
+  }
+  if (tool === "playbook.record.stop") {
+    const record = activeRecord();
+    if (!record) throw new Error("no active playbook record");
+    if (record.capture.network) {
+      try {
+        const result = await requestCallExtension(request, tool, { type: "READ_NETWORK_REQUESTS", tabId: record.tabId, full: true, limit: 500 });
+        const cutoff = Date.parse(record.startedAt);
+        attachNetworkTrace(record.id, (result.entries || []).filter((entry) => entry.ts >= cutoff));
+      } finally {
+        await requestCallExtension(request, tool, { type: "STOP_NETWORK_CAPTURE", tabId: record.tabId }, 30000, true).catch(() => {});
+      }
+    }
+    if (record.capture.watch) await requestCallExtension(request, tool, { type: "STOP_PLAYBOOK_WATCH", tabId: record.tabId }, 30000, true).catch(() => {});
+    return stopRecord({ draft: args.draft === true });
+  }
+  throw new Error(`Unknown record command: ${tool}`);
+}
+
 const sessionManager = new HostSessionManager({
   audit: auditSession,
   onTimeout(context, request) {
@@ -531,6 +675,21 @@ function sendToolResponse(socket, id, result, error) {
     if (finalError && request) {
       finalError = rewriteTransferPaths(finalError, request.pathRewrites || []);
     }
+    if (request?.tool && !request.tool.startsWith("playbook.")) {
+      const metadata = commandMetadata(request.tool);
+      if (metadata.recordable) {
+        const event = {
+          type: finalError ? "tool.failed" : "tool.completed",
+          command: metadata.name,
+          argsRedacted: redactCommandArgs(request.tool, request.args || {}),
+          startedAt: request.activityStartedAt || new Date().toISOString(),
+          endedAt: new Date().toISOString(),
+          resultSummary: finalError ? "failed" : "success",
+        };
+        appendActivity(event);
+        appendRecordEvent(event);
+      }
+    }
     await cleanupRequestTransfers(request);
     if (request?.settled) return;
     const outcome = request?.signal.aborted
@@ -607,6 +766,22 @@ function handleToolRequest(msg, socket, requestContext = requestStorage.getStore
     sendToolResponse(socket, originalId, null, "No tool specified");
     return;
   }
+
+  requestContext.args = args || {};
+  requestContext.activityStartedAt = new Date().toISOString();
+  if (!tool.startsWith("playbook.")) journalCommand(tool, args || {}, { tabId });
+  if (tool === "playbook.run") {
+    runHostPlaybook(msg, requestContext)
+      .then((result) => sendToolResponse(socket, originalId, { output: JSON.stringify(result) }, null))
+      .catch((error) => sendToolResponse(socket, originalId, null, error.message));
+    return;
+  }
+  if (tool.startsWith("playbook.record.")) {
+    handleRecordRequest(tool, args || {}, msg, requestContext)
+      .then((result) => sendToolResponse(socket, originalId, result, null))
+      .catch((error) => sendToolResponse(socket, originalId, null, error.message));
+    return;
+  }
   
   const extensionMsg = mapToolToMessage(tool, args, tabId);
   if (!extensionMsg) {
@@ -1264,7 +1439,9 @@ function handleToolRequest(msg, socket, requestContext = requestStorage.getStore
     autoScreenshot: args?.autoScreenshot === true,
     autoScreenshotOutput: args?.autoScreenshotOutput,
     networkExport: extensionMsg.type === "EXPORT_NETWORK_REQUESTS",
+    persistNetwork: extensionMsg.type === "READ_NETWORK_REQUESTS" && extensionMsg.full && args?.["no-save"] !== true,
     networkExportPath: args?.output,
+    networkPath: args?.["network-path"],
     networkExportFormat: extensionMsg.har ? "har" : extensionMsg.jsonl ? "jsonl" : "json",
     fullRes: extensionMsg.fullRes || args?.fullRes,
     maxSize: extensionMsg.maxSize || args?.maxSize,
@@ -1431,6 +1608,19 @@ function processInput() {
         handleApiRequest(msg, writeMessage);
         return;
       }
+
+      if (msg.type === "PLAYBOOK_WATCH_EVENT") {
+        appendRecordEvent({
+          type: "browser.event",
+          event: msg.event,
+          selector: msg.selector,
+          value: msg.value,
+          url: redactUrlSecrets(msg.url),
+          tabId: msg.tabId,
+          timestamp: msg.timestamp || new Date().toISOString(),
+        });
+        return;
+      }
       
       if (msg.type === "STREAM_EVENT") {
         const stream = activeStreams.get(msg.streamId);
@@ -1489,6 +1679,14 @@ function processInput() {
             } catch (error) {
               sendToolResponse(socket, originalId, null, `Failed to export network requests: ${error.message}`);
             }
+          } else if (pending.persistNetwork && Array.isArray(msg.entries)) {
+            try {
+              for (const entry of msg.entries) networkStore.appendEntrySync(entry, pending.networkPath);
+              networkStore.maybeAutoCleanup();
+              sendToolResponse(socket, originalId, msg, null);
+            } catch (error) {
+              sendToolResponse(socket, originalId, null, `Failed to persist network requests: ${error.message}`);
+            }
           } else if (savePath && msg.base64) {
             try {
               const dir = path.dirname(savePath);

package/native/network-export.cjs

@@ -1,7 +1,7 @@
-const crypto = require("crypto");
 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"]);
@@ -22,6 +22,20 @@ function headerList(headers) {
   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;
@@ -37,11 +51,11 @@ function harEntry(entry) {
       url: entry.url || "",
       httpVersion: "HTTP/1.1",
       headers: headerList(requestHeaders),
-      queryString: [],
+      queryString: queryList(entry.url || ""),
       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) } } : {}),
+      ...(requestBody !== undefined ? { postData: { mimeType: headerValue(requestHeaders, "content-type") || "application/octet-stream", text: String(requestBody) } } : {}),
     },
     response: {
       status: Number.isFinite(entry.status) ? entry.status : 0,
@@ -53,6 +67,8 @@ function harEntry(entry) {
         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,
@@ -87,20 +103,7 @@ function writeNetworkExport(outputPath, entries, format = "json") {
   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;
-  }
+  atomicWriteFile(outputPath, content, { encoding: "utf8" });
   return { path: outputPath, format, count: entries.length, bytes };
 }