botversion-sdk 2.3.3 → 2.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botversion-sdk",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "description": "BotVersion SDK: auto-detect and register your API endpoints, with undo for AI actions",
   "main": "index.js",
   "bin": {

package/undo/lib/tagger.js

@@ -32,6 +32,7 @@ const dbg = (...a) => {
 };
 const seenEvents = new Set(); // distinct server event names seen (capped)
 let seenRequests = 0;
+const listenerSeen = new WeakSet(); // DEBUG: responses the server-event listener saw
 
 function setApiKey(key) {
   try {
@@ -303,6 +304,10 @@ function wrapEmit(proto) {
     if (event === "request") {
       // DEBUG: shows whether requests reach this listener at all (first 3 requests, plus every botversion request)
       let bvSeen = false;
+      try {
+        if (global._botVersionDebug && res && typeof res === "object")
+          listenerSeen.add(res); // DEBUG: marks "the listener saw this request"
+      } catch (_) {}
       try {
         if (global._botVersionDebug) {
           seenRequests++;
@@ -359,9 +364,117 @@ function wrapEmit(proto) {
   return true;
 }
 
+// DEBUG PROBE: watches every response Node finishes, whatever way the host received the request.
+// Compares it with what the server-event listener saw. Prints only when debug is on.
+globalThis.__bvTaggerLoads = (globalThis.__bvTaggerLoads || 0) + 1;
+const PROBE = Symbol.for("botversion.undoExp.probe");
+const probeCount = { all: 0, bv: 0 };
+const probed = new WeakSet();
+
+function installResponseProbe() {
+  try {
+    if (!global._botVersionDebug) return;
+    const http = require("http");
+
+    // Startup facts: which process, which module copy, which Next.js
+    let nextVersion = null;
+    try {
+      nextVersion = require(
+        require.resolve("next/package.json", { paths: [process.cwd()] }),
+      ).version;
+    } catch (_) {}
+    dbg("probe installed", {
+      pid: process.pid,
+      uptimeSec: Math.round(process.uptime()),
+      taggerCopiesLoaded: globalThis.__bvTaggerLoads,
+      script: String(process.argv[1] || "").slice(-60),
+      cwd: process.cwd(),
+      node: process.version,
+      next: nextVersion,
+      nextRuntime: process.env.NEXT_RUNTIME || null,
+      vercelEnv: process.env.VERCEL_ENV || null,
+      region: process.env.VERCEL_REGION || null,
+      lambda: !!process.env.AWS_LAMBDA_FUNCTION_NAME,
+      emitPatched: !!(
+        http.Server &&
+        http.Server.prototype.emit &&
+        http.Server.prototype.emit[PATCHED]
+      ),
+    });
+
+    // Does this process ever start a real Node server?
+    const SP = http.Server && http.Server.prototype;
+    if (SP && typeof SP.listen === "function" && !SP.listen[PROBE]) {
+      const origListen = SP.listen;
+      const wl = function listen() {
+        try {
+          dbg("a Node server started listening in this process", {
+            pid: process.pid,
+            args: Array.prototype.slice
+              .call(arguments)
+              .filter((a) => typeof a === "number" || typeof a === "string")
+              .slice(0, 2),
+          });
+        } catch (_) {}
+        return origListen.apply(this, arguments);
+      };
+      Object.defineProperty(wl, PROBE, { value: true });
+      SP.listen = wl;
+    }
+
+    // Watches every finished response.
+    const RP = http.ServerResponse && http.ServerResponse.prototype;
+    if (!RP || typeof RP.end !== "function") {
+      dbg("probe: ServerResponse.end not found, cannot watch responses");
+      return;
+    }
+    if (RP.end[PROBE]) return;
+    const origEnd = RP.end;
+    const wrapped = function end() {
+      try {
+        if (!probed.has(this)) {
+          probed.add(this);
+          const req = this.req;
+          const h = (req && req.headers) || {};
+          const bvHeaders = Object.keys(h).filter(
+            (k) => k.indexOf("x-botversion-") === 0,
+          );
+          const p = String((req && req.url) || "")
+            .split("?")[0]
+            .slice(0, 120);
+          const isBv = bvHeaders.length > 0 || p.indexOf("botversion") !== -1;
+          const log =
+            (probeCount.all < 5 && ++probeCount.all) ||
+            (isBv && probeCount.bv < 40 && ++probeCount.bv);
+          if (log)
+            dbg("response finished", {
+              pid: process.pid,
+              uptimeSec: Math.round(process.uptime()),
+              method: req && req.method,
+              path: p,
+              status: this.statusCode,
+              botversionHeaders: bvHeaders,
+              listenerSawIt: listenerSeen.has(this),
+              insideAiRequest: !!getCurrent(),
+              hasSigningKey: !!signingKey,
+              undoStartedHere: !!global._botVersionUndoStarted,
+              taggerCopiesLoaded: globalThis.__bvTaggerLoads,
+            });
+        }
+      } catch (_) {}
+      return origEnd.apply(this, arguments);
+    };
+    Object.defineProperty(wrapped, PROBE, { value: true });
+    RP.end = wrapped;
+  } catch (e) {
+    dbg("probe could not be installed:", e && e.message);
+  }
+}
+
 // Wraps every built-in server type that exists in this Node version.
 function install() {
   const wrapped = [];
+  installResponseProbe(); // DEBUG probe, does nothing unless debug is on
   const targets = [
     ["http", (m) => m.Server && m.Server.prototype],
     ["https", (m) => m.Server && m.Server.prototype],