openfox 1.6.64 → 1.6.66

package/dist/{auto-compaction-XYMFQXXX.js → auto-compaction-ASDCDWKT.js}

@@ -2,7 +2,8 @@ import {
   maybeAutoCompactContext,
   performManualContextCompaction,
   resolveCompactionStatsIdentity
-} from "./chunk-7TMH3MPE.js";
+} from "./chunk-PU4AOT3E.js";
+import "./chunk-NRUMWHLX.js";
 import "./chunk-NBU6KIOD.js";
 import "./chunk-574HZVLE.js";
 import "./chunk-7JPKRM6M.js";
@@ -23,4 +24,4 @@ export {
   performManualContextCompaction,
   resolveCompactionStatsIdentity
 };
-//# sourceMappingURL=auto-compaction-XYMFQXXX.js.map
+//# sourceMappingURL=auto-compaction-ASDCDWKT.js.map

package/dist/{chat-handler-24P6R3SB.js → chat-handler-647QWEHP.js}

@@ -8,8 +8,9 @@ import {
 } from "./chunk-ENAZTRCR.js";
 import {
   runChatTurn
-} from "./chunk-YF3ERP7E.js";
-import "./chunk-7TMH3MPE.js";
+} from "./chunk-7XO4OW2P.js";
+import "./chunk-PU4AOT3E.js";
+import "./chunk-NRUMWHLX.js";
 import "./chunk-NBU6KIOD.js";
 import "./chunk-574HZVLE.js";
 import "./chunk-7JPKRM6M.js";
@@ -60,7 +61,7 @@ async function startChatSession(sessionId, content, deps, options) {
   sessionManager.setRunning(sessionId, true);
   broadcastForSession(sessionId, createSessionRunningMessage(true));
   try {
-    const { maybeAutoCompactContext } = await import("./auto-compaction-XYMFQXXX.js");
+    const { maybeAutoCompactContext } = await import("./auto-compaction-ASDCDWKT.js");
     await maybeAutoCompactContext({
       sessionManager,
       sessionId,
@@ -169,4 +170,4 @@ export {
   startChatSession,
   stopSessionExecution
 };
-//# sourceMappingURL=chat-handler-24P6R3SB.js.map
+//# sourceMappingURL=chat-handler-647QWEHP.js.map

package/dist/{chunk-YF3ERP7E.js → chunk-7XO4OW2P.js}

@@ -13,7 +13,7 @@ import {
   getToolRegistryForAgent,
   loadAllAgentsDefault,
   runTopLevelAgentLoop
-} from "./chunk-7TMH3MPE.js";
+} from "./chunk-PU4AOT3E.js";
 import {
   getCurrentContextWindowId,
   getEventStore
@@ -293,4 +293,4 @@ export {
   runBuilderTurn,
   runVerifierTurn
 };
-//# sourceMappingURL=chunk-YF3ERP7E.js.map
+//# sourceMappingURL=chunk-7XO4OW2P.js.map

package/dist/{chunk-JY7BGPTB.js → chunk-GFE5Y2UE.js}

@@ -2,7 +2,7 @@ import {
   createVerifierNudgeConfig,
   runBuilderTurn,
   runChatTurn
-} from "./chunk-YF3ERP7E.js";
+} from "./chunk-7XO4OW2P.js";
 import {
   TurnMetrics,
   agentExists,
@@ -38,7 +38,7 @@ import {
   setSkillEnabled,
   skillExists,
   spawnShellProcess
-} from "./chunk-7TMH3MPE.js";
+} from "./chunk-PU4AOT3E.js";
 import {
   getPathSeparator,
   getPlatformShell,
@@ -5058,7 +5058,7 @@ function createTerminalRoutes() {
 }
 
 // src/constants.ts
-var VERSION = "1.6.64";
+var VERSION = "1.6.66";
 
 // src/server/index.ts
 var __dirname2 = dirname5(fileURLToPath4(import.meta.url));
@@ -5361,7 +5361,7 @@ async function createServerHandle(config) {
     if (!callId || approved === void 0) {
       return res.status(400).json({ error: "callId and approved are required" });
     }
-    const { providePathConfirmation: providePathConfirmation2 } = await import("./tools-TSGPRFT2.js");
+    const { providePathConfirmation: providePathConfirmation2 } = await import("./tools-AQEL6ZJG.js");
     const result = providePathConfirmation2(callId, approved, alwaysAllow);
     if (!result.found) {
       return res.status(404).json({ error: "No pending path confirmation with that ID" });
@@ -5386,7 +5386,7 @@ async function createServerHandle(config) {
     if (!callId || !answer) {
       return res.status(400).json({ error: "callId and answer are required" });
     }
-    const { provideAnswer: provideAnswer2 } = await import("./tools-TSGPRFT2.js");
+    const { provideAnswer: provideAnswer2 } = await import("./tools-AQEL6ZJG.js");
     const found = provideAnswer2(callId, answer);
     if (!found) {
       return res.status(404).json({ error: "No pending question with that ID" });
@@ -5422,8 +5422,8 @@ async function createServerHandle(config) {
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { stopSessionExecution } = await import("./chat-handler-24P6R3SB.js");
-    const { cancelQuestionsForSession: cancelQuestionsForSession2, cancelPathConfirmationsForSession: cancelPathConfirmationsForSession2 } = await import("./tools-TSGPRFT2.js");
+    const { stopSessionExecution } = await import("./chat-handler-647QWEHP.js");
+    const { cancelQuestionsForSession: cancelQuestionsForSession2, cancelPathConfirmationsForSession: cancelPathConfirmationsForSession2 } = await import("./tools-AQEL6ZJG.js");
     stopSessionExecution(sessionId, sessionManager);
     abortSession(sessionId);
     cancelQuestionsForSession2(sessionId, "Session stopped by user");
@@ -5816,6 +5816,11 @@ async function createServerHandle(config) {
         }
       })
     );
+    app.use("/__inspect__.js", (req, res) => {
+      res.set("Access-Control-Allow-Origin", "*");
+      res.set("Content-Type", "application/javascript");
+      readFile3(join5(webDir, "public", "__inspect__.js")).then((content) => res.send(content)).catch(() => res.status(404).send("Not found"));
+    });
     app.get("/*path", (req, res) => {
       if (req.path.startsWith("/api/")) {
         return;
@@ -5858,6 +5863,16 @@ async function createServerHandle(config) {
         }
       })
     );
+    app.use("/__inspect__.js", (req, res) => {
+      res.set("Access-Control-Allow-Origin", "*");
+      res.set("Content-Type", "application/javascript");
+      readFile3(join5(distWebDir, "__inspect__.js")).then((content) => res.send(content)).catch(() => res.status(404).send("Not found"));
+    });
+    app.use("/__inspect__.js", (req, res) => {
+      res.set("Access-Control-Allow-Origin", "*");
+      res.set("Content-Type", "application/javascript");
+      readFile3(join5(distWebDir, "__inspect__.js")).then((content) => res.send(content)).catch(() => res.status(404).send("Not found"));
+    });
     app.get("/", (_req, res) => {
       readFile3(join5(distWebDir, "index.html"), "utf-8").then((content) => res.send(content)).catch(() => {
         res.status(404).send("Web UI not built. Run `npm run build:web`");
@@ -5882,7 +5897,7 @@ async function createServerHandle(config) {
     providerManager
   );
   const wss = wssExports.wss;
-  const { QueueProcessor } = await import("./processor-GSMNLIRM.js");
+  const { QueueProcessor } = await import("./processor-TSSCNWED.js");
   const queueProcessor = new QueueProcessor({
     sessionManager,
     providerManager,
@@ -5920,6 +5935,8 @@ async function createServerHandle(config) {
       logger.info("Shutting down...");
       void (async () => {
         await devServerManager.stopAll();
+        const { stopAllInspectProxies } = await import("./inspect-proxy-M5222JOC.js");
+        stopAllInspectProxies();
         const { cleanupAllProcesses } = await import("./store-2IF3ZSLD.js");
         cleanupAllProcesses();
         viteServer?.close();
@@ -5955,4 +5972,4 @@ export {
   createServerHandle,
   createServer
 };
-//# sourceMappingURL=chunk-JY7BGPTB.js.map
+//# sourceMappingURL=chunk-GFE5Y2UE.js.map

package/dist/chunk-NRUMWHLX.js

@@ -0,0 +1,294 @@
+import {
+  logger
+} from "./chunk-PNBH3RAX.js";
+
+// src/server/dev-server/inspect-proxy.ts
+import net from "net";
+import zlib from "zlib";
+var OPENFOX_BASE_PORT = Number(process.env["OPENFOX_PORT"] ?? 10369);
+var INJECT_SCRIPT = `<script src="http://127.0.0.1:${OPENFOX_BASE_PORT}/__inspect__.js"></script>`;
+var proxyPool = /* @__PURE__ */ new Map();
+var nextOffset = 0;
+function getAvailablePort() {
+  const base = Number(process.env["OPENFOX_PORT"] ?? 10369);
+  const used = /* @__PURE__ */ new Set();
+  for (const instance of proxyPool.values()) {
+    const addr = instance.server.address();
+    if (addr && typeof addr === "object") used.add(addr.port);
+  }
+  for (let port = base + 1; port < base + 200; port++) {
+    if (!used.has(port)) return port;
+  }
+  return base + (nextOffset++ % 200 + 1);
+}
+function parseReqHeaders(str) {
+  const lines = str.split("\r\n");
+  const method = lines[0].split(" ")[0];
+  const url = lines[0].split(" ")[1];
+  const headers = parseHeaderLines(lines);
+  return { method, url, headers };
+}
+function parseResHeaders(str) {
+  const lines = str.split("\r\n");
+  const status = parseInt(lines[0].split(" ")[1] || "200");
+  const headers = parseHeaderLines(lines);
+  return { status, headers };
+}
+function parseHeaderLines(lines) {
+  const headers = {};
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) break;
+    const ci = line.indexOf(":");
+    if (ci < 0) continue;
+    headers[line.slice(0, ci).toLowerCase()] = line.slice(ci + 1).trim();
+  }
+  return headers;
+}
+function buildResponse(status, headers, body) {
+  const statusLine = `HTTP/1.1 ${status} ${status === 200 ? "OK" : status === 404 ? "Not Found" : "Error"}`;
+  const headerLines = Object.entries(headers).map(([k, v]) => `${k}: ${v}`).join("\r\n");
+  const head = Buffer.from(`${statusLine}\r
+${headerLines}\r
+\r
+`, "utf8");
+  return Buffer.concat([head, body]);
+}
+function dechunk(buf) {
+  const str = buf.toString("utf8");
+  const parts = [];
+  let pos = 0;
+  while (pos < str.length) {
+    const nlIdx = str.indexOf("\r\n", pos);
+    if (nlIdx < 0) break;
+    const sizeStr = str.slice(pos, nlIdx);
+    const size = parseInt(sizeStr, 16);
+    if (isNaN(size) || size < 0) break;
+    if (size === 0) break;
+    const chunkStart = nlIdx + 2;
+    const chunkEnd = chunkStart + size;
+    if (chunkEnd > str.length) break;
+    parts.push(str.slice(chunkStart, chunkEnd));
+    pos = chunkEnd + 2;
+  }
+  return Buffer.from(parts.join(""), "utf8");
+}
+function startInspectProxy(target, sessionManager) {
+  const port = getAvailablePort();
+  const server = net.createServer((client) => {
+    let clientHead = "";
+    let clientParsed = false;
+    let targetSocket;
+    client.on("data", (chunk) => {
+      if (clientParsed) {
+        targetSocket?.write(chunk);
+        return;
+      }
+      clientHead += chunk.toString("utf8");
+      const he = clientHead.indexOf("\r\n\r\n");
+      if (he < 0) return;
+      const { method, url, headers } = parseReqHeaders(clientHead);
+      const isWS = headers["upgrade"] === "websocket";
+      clientParsed = true;
+      if (url === "/__openfox_feedback" && method === "POST") {
+        const contentLength = parseInt(headers["content-length"] || "0", 10);
+        let bodyData = chunk.slice(he + 4);
+        let bodyTotal = bodyData.length;
+        const handleFeedback = () => {
+          try {
+            const { sessionId, element, annotation, pageUrl } = JSON.parse(bodyData.toString("utf8"));
+            if (sessionId) {
+              const elementDesc = element ? `${element.tag}${element.id ? "#" + element.id : ""}` : "unknown";
+              const htmlSnippet = element?.outerHTML ? `
+Html: ${element.outerHTML.slice(0, 300)}` : "";
+              const textSnippet = element?.textContent ? `
+Text (SVG-stripped): ${element.textContent.slice(0, 500)}` : "";
+              const content = `# User feedback from page inspection on dev_server
+
+## Context
+
+Page: ${pageUrl || ""}
+Element: ${elementDesc}
+xPath: ${element?.xpath || ""}${htmlSnippet}${textSnippet}
+
+## Feedback
+
+${annotation || "(none)"}`;
+              sessionManager.queueMessage(sessionId, "asap", content, [], "ui_feedback");
+            }
+            client.write(buildResponse(200, { "Content-Type": "application/json" }, Buffer.from('{"success":true}')));
+          } catch {
+            client.write(buildResponse(400, { "Content-Type": "application/json" }, Buffer.from('{"error":"Invalid request"}')));
+          }
+          client.end();
+        };
+        if (bodyTotal >= contentLength) {
+          handleFeedback();
+          return;
+        }
+        client.on("data", (more) => {
+          bodyData = Buffer.concat([bodyData, more]);
+          bodyTotal += more.length;
+          if (bodyTotal < contentLength) return;
+          handleFeedback();
+        });
+        return;
+      }
+      const targetParts = target.replace(/^https?:\/\//, "").split(":");
+      const targetHost = targetParts[0] ?? "127.0.0.1";
+      const targetPort = parseInt(targetParts[1] ?? "80");
+      if (isWS) {
+        targetSocket = net.connect(targetPort, targetHost);
+        targetSocket.on("error", () => client.destroy());
+        client.on("error", () => targetSocket.destroy());
+        targetSocket.write(clientHead);
+        targetSocket.pipe(client);
+        client.pipe(targetSocket);
+        return;
+      }
+      targetSocket = net.connect(targetPort, targetHost);
+      targetSocket.on("error", () => client.destroy());
+      client.on("error", () => targetSocket.destroy());
+      client.on("data", (chunk2) => targetSocket.write(chunk2));
+      client.on("end", () => targetSocket.end());
+      const connClose = "\r\nConnection: close";
+      const reqEnd = clientHead.indexOf("\r\n\r\n");
+      const forwardHead = clientHead.slice(0, reqEnd) + connClose + clientHead.slice(reqEnd);
+      targetSocket.write(forwardHead);
+      targetSocket.on("close", () => {
+        if (!client.destroyed) client.end();
+      });
+      let serverHeadBuf = "";
+      let serverParsed = false;
+      let isHtml = false;
+      let enc = null;
+      let status = 200;
+      let resHeaders = {};
+      let bodyBuf = [];
+      let headEnd = -1;
+      targetSocket.on("data", (sChunk) => {
+        if (!serverParsed) {
+          serverHeadBuf += sChunk.toString("utf8");
+          const sHe = serverHeadBuf.indexOf("\r\n\r\n");
+          if (sHe < 0) return;
+          headEnd = sHe + 4;
+          const p = parseResHeaders(serverHeadBuf.slice(0, sHe));
+          status = p.status;
+          resHeaders = p.headers;
+          isHtml = (resHeaders["content-type"] || "").includes("text/html");
+          enc = resHeaders["content-encoding"] || null;
+          const isChunked = (resHeaders["transfer-encoding"] || "").toLowerCase() === "chunked";
+          serverParsed = true;
+          if (isHtml && enc) {
+            bodyBuf.push(sChunk.slice(headEnd));
+            return;
+          }
+          if (isHtml && isChunked) {
+            bodyBuf.push(sChunk.slice(headEnd));
+            return;
+          }
+          if (isHtml) {
+            bodyBuf.push(sChunk.slice(headEnd));
+            return;
+          }
+          client.write(sChunk);
+          return;
+        }
+        if (isHtml && enc) {
+          bodyBuf.push(sChunk);
+          return;
+        }
+        if (isHtml) {
+          bodyBuf.push(sChunk);
+          return;
+        }
+        client.write(sChunk);
+      });
+      targetSocket.on("end", () => {
+        if (!serverParsed) {
+          client.end();
+          return;
+        }
+        if (isHtml && enc) {
+          const fullBody = Buffer.concat(bodyBuf);
+          let text;
+          try {
+            if (enc === "gzip") text = zlib.gunzipSync(fullBody).toString("utf8");
+            else if (enc === "deflate") text = zlib.inflateSync(fullBody).toString("utf8");
+            else text = fullBody.toString("utf8");
+          } catch {
+            client.end();
+            return;
+          }
+          const bi = text.indexOf("</body>");
+          const hi = text.indexOf("</head>");
+          let modified;
+          if (bi >= 0) modified = text.slice(0, bi) + INJECT_SCRIPT + text.slice(bi);
+          else if (hi >= 0) modified = text.slice(0, hi) + INJECT_SCRIPT + text.slice(hi);
+          else {
+            client.end();
+            return;
+          }
+          let compressed;
+          if (enc === "gzip") compressed = zlib.gzipSync(Buffer.from(modified, "utf8"));
+          else if (enc === "deflate") compressed = zlib.deflateSync(Buffer.from(modified, "utf8"));
+          else compressed = Buffer.from(modified, "utf8");
+          const newH = { ...resHeaders };
+          delete newH["content-length"];
+          newH["connection"] = "close";
+          const headStr = `HTTP/1.1 ${status} OK\r
+` + Object.entries(newH).map(([k, v]) => `${k}: ${v}`).join("\r\n") + "\r\n\r\n";
+          client.write(Buffer.from(headStr, "utf8"));
+          client.write(compressed);
+        } else if (isHtml && bodyBuf.length > 0) {
+          const fullBody = Buffer.concat(bodyBuf);
+          const isChunked = (resHeaders["transfer-encoding"] || "").toLowerCase() === "chunked";
+          const dechunks = isChunked ? dechunk(fullBody) : fullBody;
+          const bi = dechunks.indexOf("</body>");
+          const hi = dechunks.indexOf("</head>");
+          let modified;
+          if (bi >= 0) modified = Buffer.concat([dechunks.slice(0, bi), Buffer.from(INJECT_SCRIPT, "utf8"), dechunks.slice(bi)]);
+          else if (hi >= 0) modified = Buffer.concat([dechunks.slice(0, hi), Buffer.from(INJECT_SCRIPT, "utf8"), dechunks.slice(hi)]);
+          else {
+            client.end();
+            return;
+          }
+          const newH = { ...resHeaders, "content-type": "text/html; charset=utf-8" };
+          delete newH["content-length"];
+          delete newH["transfer-encoding"];
+          newH["connection"] = "close";
+          newH["content-length"] = Buffer.byteLength(modified).toString();
+          const headStr = `HTTP/1.1 ${status} OK\r
+` + Object.entries(newH).map(([k, v]) => `${k}: ${v}`).join("\r\n") + "\r\n\r\n";
+          client.write(Buffer.from(headStr, "utf8"));
+          client.write(modified);
+        }
+        client.end();
+      });
+    });
+    client.on("error", () => {
+    });
+  });
+  server.listen(port, "0.0.0.0", () => {
+    logger.debug("Inspect proxy listening", { port, target });
+  });
+  proxyPool.set(target, { server, target });
+  const cleanup = () => {
+    server.close();
+    proxyPool.delete(target);
+    logger.debug("Inspect proxy stopped", { port, target });
+  };
+  return { port, cleanup };
+}
+function stopAllInspectProxies() {
+  for (const instance of proxyPool.values()) {
+    instance.server.close();
+  }
+  proxyPool.clear();
+}
+
+export {
+  startInspectProxy,
+  stopAllInspectProxies
+};
+//# sourceMappingURL=chunk-NRUMWHLX.js.map

package/dist/{chunk-OXQGLKLE.js → chunk-PCCYGUYA.js}

@@ -179,7 +179,7 @@ async function runCli(options) {
       if (!configExists) {
         await runNetworkSetup(mode);
       }
-      const { runServe } = await import("./serve-55UYT2JO.js");
+      const { runServe } = await import("./serve-QTGMR7OM.js");
       await runServe({
         mode,
         port: values.port ? parseInt(values.port) : void 0,
@@ -192,4 +192,4 @@ async function runCli(options) {
 export {
   runCli
 };
-//# sourceMappingURL=chunk-OXQGLKLE.js.map
+//# sourceMappingURL=chunk-PCCYGUYA.js.map