surf-cli 2.9.0 → 2.11.0

package/native/host.cjs

@@ -14,7 +14,8 @@ 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, buildProviderUploadMessage } = require("./host-helpers.cjs");
+const { mapToolToMessage, mapComputerAction, formatToolContent, formatToolError, buildProviderUploadMessage } = require("./host-helpers.cjs");
+const { createOracleHost } = require("./oracle-host.cjs");
 
 const IS_WIN = process.platform === "win32";
 const { SOCKET_PATH, SURF_TMP } = require("./socket-path.cjs");
@@ -22,11 +23,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)
@@ -383,6 +403,15 @@ aiQueue = new BoundedAiQueue({
     : handler(),
 });
 
+const oracleHost = createOracleHost({
+  queueAiRequest,
+  requestCallExtension,
+  buildProviderUploadMessage,
+  log,
+});
+const adoptedOracleJobs = oracleHost.adoptOrphans();
+log(`Oracle adoption: ${adoptedOracleJobs.length} job(s); ids=${adoptedOracleJobs.map((job) => job.id).join(",") || "none"}`);
+
 function sendSocket(socket, value, options = {}) {
   const writer = socketWriters.get(socket);
   return writer ? writer.send(value, options) : writeFrame(socket, value);
@@ -428,6 +457,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) {
@@ -528,8 +682,29 @@ function sendToolResponse(socket, id, result, error) {
     } catch (transferFailure) {
       finalError = transferFailure.message;
     }
-    if (finalError && request) {
-      finalError = rewriteTransferPaths(finalError, request.pathRewrites || []);
+    const formattedError = finalError ? formatToolError(finalError) : null;
+    if (formattedError && request) {
+      const rewrittenMessage = rewriteTransferPaths(
+        formattedError.content[0].text,
+        request.pathRewrites || [],
+      );
+      formattedError.content[0].text = rewrittenMessage;
+      if (formattedError.message) formattedError.message = rewrittenMessage;
+    }
+    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;
@@ -538,7 +713,7 @@ function sendToolResponse(socket, id, result, error) {
       : finalError ? "error" : "completed";
     await completeOwnedRequest(context, id, outcome);
     const response = { type: "tool_response", id };
-    if (finalError) response.error = { content: [{ type: "text", text: finalError }] };
+    if (formattedError) response.error = formattedError;
     else response.result = { content: formatToolContent(output, log, { suppressImages: Boolean(context?.isRemote) }) };
     if (!context?.closed) await sendSocket(socket, response);
   })().catch((sendError) => log(`Error sending tool_response: ${sendError.message}`));
@@ -607,6 +782,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) {
@@ -625,6 +816,13 @@ function handleToolRequest(msg, socket, requestContext = requestStorage.getStore
       .catch((error) => sendToolResponse(socket, originalId, null, error.message));
     return;
   }
+
+  if (extensionMsg.type.startsWith("ORACLE_")) {
+    Promise.resolve(oracleHost.handle(requestContext, extensionMsg))
+      .then((result) => sendToolResponse(socket, originalId, result, null))
+      .catch((error) => sendToolResponse(socket, originalId, null, error));
+    return;
+  }
   
   if (extensionMsg.type === "BATCH_EXECUTE") {
     executeBatch(extensionMsg.actions, extensionMsg.tabId, socket, originalId, requestContext);
@@ -1264,7 +1462,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 +1631,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 +1702,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);
@@ -1750,6 +1971,7 @@ const handleClient = (socket) => {
       }
       log(`Handling tool_request: ${msg.method} ${tool}${principal ? ` for ${principal.label}` : ""}`);
       try {
+        if (tool.startsWith("oracle.")) oracleHost.assertLocal(request);
         if (isRemote) {
           await applyRequestTransfers(msg, request, transferState, ensureTransferState);
         }
@@ -1757,7 +1979,7 @@ const handleClient = (socket) => {
         requestStorage.run(request, () => handleToolRequest(msg, socket, request));
       } catch (e) {
         await discardRequestTransfers(msg, transferState);
-        sendToolResponse(socket, msg.id || null, null, e.message || "Request failed");
+        sendToolResponse(socket, msg.id || null, null, e?.code ? e : e.message || "Request failed");
       }
       return;
     }

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 };
 }
 

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,