botversion-sdk 2.3.2 → 2.3.4

package/core.js

@@ -18,6 +18,20 @@ function pickOptions(appOrOptions, optionsArg) {
 }
 
 function startUndo(options) {
+  // DEBUG: debug logs for Undo, on only with debug:true or env BOTVERSION_DEBUG=1
+  global._botVersionDebug =
+    !!(options && options.debug) || process.env.BOTVERSION_DEBUG === "1";
+  if (global._botVersionDebug)
+    console.log("[bv-undo-debug] startUndo called", {
+      hasOptions: !!options,
+      undoSetToFalse: !!options && options.undo === false,
+      hasApiKey: !!(options && options.apiKey),
+      alreadyStarted: !!global._botVersionUndoStarted,
+      onVercel: !!process.env.VERCEL,
+      nextRuntime: process.env.NEXT_RUNTIME || null,
+      pid: process.pid,
+      node: process.version,
+    });
   try {
     if (!options || options.undo === false || !options.apiKey) {
       return;
@@ -35,7 +49,13 @@ function startUndo(options) {
     } else {
     }
     undo.setApiKey(options.apiKey);
-  } catch (e) {}
+    if (global._botVersionDebug)
+      console.log("[bv-undo-debug] startUndo finished without errors");
+  } catch (e) {
+    // DEBUG: this error used to be swallowed silently
+    if (global._botVersionDebug)
+      console.log("[bv-undo-debug] startUndo FAILED:", e && e.message);
+  }
 }
 
 function init(appOrOptions, optionsArg) {

package/package.json

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

package/scanner-sdk/bin/scan-backend.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 "use strict";
 
 var path = require("path");
@@ -29,7 +29,7 @@ var BotVersionClient = require("../client");
 
 var apiKey = process.env.BOTVERSION_API_KEY;
 var platformUrl =
-  process.env.BOTVERSION_PLATFORM_URL || "https://console.botversion.com";
+  process.env.BOTVERSION_PLATFORM_URL || "http://localhost:3000";
 
 if (!apiKey) {
   console.error(

package/scanner-sdk/bin/scan-frontend.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 "use strict";
 
 var path = require("path");
@@ -30,7 +30,7 @@ var sdk = require("../index");
 
 var apiKey = process.env.BOTVERSION_API_KEY;
 var platformUrl =
-  process.env.BOTVERSION_PLATFORM_URL || "https://console.botversion.com";
+  process.env.BOTVERSION_PLATFORM_URL || "http://localhost:3000";
 
 if (!apiKey) {
   console.error(

package/scanner-sdk/client.js

@@ -11,7 +11,7 @@ const url = require("url");
  */
 function BotVersionClient(options) {
   this.apiKey = options.apiKey;
-  this.platformUrl = options.platformUrl || "https://console.botversion.com";
+  this.platformUrl = options.platformUrl || "http://localhost:3000";
   this.debug = options.debug || false;
   this.timeout = options.timeout || 30000;
 

package/scanner-sdk/index.js

@@ -439,7 +439,7 @@ var BotVersion = {
 
     this._client = new BotVersionClient({
       apiKey: options.apiKey,
-      platformUrl: options.platformUrl || "https://console.botversion.com",
+      platformUrl: options.platformUrl || "http://localhost:3000",
       debug: options.debug || false,
       timeout: options.timeout || 30000,
     });

package/undo/index.js

@@ -27,6 +27,18 @@ const { printReport } = require("./lib/report");
 
 let started = false;
 
+// DEBUG: prints only when debug is on
+const dbg = (...a) => {
+  if (global._botVersionDebug) console.log("[bv-undo-debug]", ...a);
+};
+const brief = (v) => {
+  try {
+    return String(JSON.stringify(v)).slice(0, 150);
+  } catch (_) {
+    return String(v).slice(0, 150);
+  }
+};
+
 /**
  * @param {object} [options]
  * @param {string}  [options.testHeader] header that marks a request as an "AI request" (default x-botversion-action-id)
@@ -35,7 +47,11 @@ let started = false;
  */
 function init(options) {
   try {
-    if (started) return { ok: true, alreadyStarted: true };
+    if (started) {
+      dbg("undo init skipped: already started in this process");
+      return { ok: true, alreadyStarted: true };
+    }
+    dbg("undo init running", { pid: process.pid });
     started = true;
 
     const opts = options && typeof options === "object" ? options : {};
@@ -46,9 +62,21 @@ function init(options) {
 
     // 1. Request tagger (framework independent).
     const taggerTargets = tagger.install();
+    dbg("request listener installed on:", taggerTargets, {
+      signedIds: tagger.hasApiKey(),
+      header: tagger.getHeaderName(),
+    });
 
     // 2. Look at the host project.
     const scan = scanner.scan();
+    dbg("project scan", {
+      hostRoot: scan.hostRoot,
+      hasPrisma: !!scan.prisma,
+      prismaProvider:
+        scan.prisma && scan.prisma.database
+          ? scan.prisma.database.provider
+          : null,
+    });
 
     // 3. Database hooks. Only the ones that match what the host has..
     //    (Final SDK: more hooks are added to this same list.)
@@ -65,6 +93,16 @@ function init(options) {
         : null,
     );
 
+    dbg("database hooks attached:", {
+      pg: brief(pgCopies),
+      mysql2: brief(mysql2Copies),
+      mongodb: brief(mongodbCopies),
+      betterSqlite: brief(betterSqliteCopies),
+      sqlite3: brief(sqlite3Copies),
+      mssql: brief(mssqlCopies),
+      prisma: brief(prismaState),
+    });
+
     // Database structure (schema only). Runs AFTER the hooks attach so loading Prisma here cannot make the Prisma hook miss it.
     scan.structure = scan.prisma
       ? schemaReader.readPrismaStructure(scan.hostRoot)
@@ -84,8 +122,10 @@ function init(options) {
       prismaState,
     });
 
+    dbg("undo init finished without errors");
     return { ok: true };
   } catch (e) {
+    dbg("undo init FAILED:", e && e.message);
     return { ok: false };
   }
 }

package/undo/lib/tagger.js

@@ -26,6 +26,14 @@ let counter = 0;
 let signingKey = null; // derived from the host's API key; the raw key is never kept
 let lastIgnoredLog = 0;
 
+// DEBUG: prints only when debug is on
+const dbg = (...a) => {
+  if (global._botVersionDebug) console.log("[bv-undo-debug]", ...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 {
     signingKey = actionId.deriveSigningKey(key);
@@ -43,6 +51,7 @@ function noteIgnored(message) {
   const now = Date.now();
   if (now - lastIgnoredLog < 60000) return;
   lastIgnoredLog = now;
+  dbg("request ignored:", message);
 }
 
 function setHeaderName(name) {
@@ -146,6 +155,19 @@ function buildStore(req, res) {
       res.once("close", () => {
         try {
           const ms = Date.now() - store.startedAt;
+          // DEBUG: end-of-request summary, shows whether the database hooks saw the queries
+          dbg("AI request finished:", {
+            id: String(store.actionId).slice(0, 6),
+            method: store.method,
+            path: store.path,
+            status: res.statusCode,
+            ms,
+            queries: store.queries,
+            writes: store.writes,
+            savedSnapshots: store.savedIds.length,
+            unsaved: store.unsaved,
+            blocked: !!store.blocked,
+          });
         } catch (_) {
           /* never break the host */
         }
@@ -269,7 +291,44 @@ function wrapEmit(proto) {
   const original = proto.emit;
   const wrapper = function emit(event, req, res) {
     let store = null;
+    // DEBUG: notes each distinct server event once (shows whether this server emits through the patched method)
+    if (
+      global._botVersionDebug &&
+      typeof event === "string" &&
+      seenEvents.size < 15 &&
+      !seenEvents.has(event)
+    ) {
+      seenEvents.add(event);
+      dbg("server event seen:", event, { pid: process.pid });
+    }
     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++;
+          const hn = Object.keys((req && req.headers) || {}).filter(
+            (k) => k.indexOf("x-botversion-") === 0,
+          );
+          const p = String((req && req.url) || "")
+            .split("?")[0]
+            .slice(0, 120);
+          bvSeen = hn.length > 0 || p.indexOf("botversion") !== -1;
+          if (seenRequests <= 3 || bvSeen)
+            dbg("request seen:", {
+              n: seenRequests,
+              method: req && req.method,
+              path: p,
+              botversionHeaders: hn,
+              hasSigningKey: !!signingKey,
+              pid: process.pid,
+            });
+        }
+      } catch (_) {}
       try {
         // The Undo route is answered here, before the host's framework sees the request.
         if (
@@ -284,6 +343,13 @@ function wrapEmit(proto) {
       guardPreflight(req, res); // never throws; only touches preflight requests that ask for our headers
       try {
         store = buildStore(req, res);
+        // DEBUG: shows whether this request was accepted as an AI request
+        if (bvSeen)
+          dbg(
+            "accepted as AI request:",
+            !!store,
+            store ? { visual: store.visual, confirmed: store.confirmed } : "",
+          );
       } catch (_) {
         store = null; // tagging problems must never affect the host
       }
@@ -298,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],
@@ -328,7 +502,9 @@ function install() {
       for (const proto of protos) {
         if (wrapEmit(proto) && !wrapped.includes(name)) wrapped.push(name);
       }
-    } catch (e) {}
+    } catch (e) {
+      dbg("could not wrap", name, ":", e && e.message);
+    }
   }
   return wrapped;
 }

package/undo/lib/undo-route.js

@@ -15,6 +15,11 @@ const undoMssql = require("./undo-mssql");
 const PATH = "/botversion-undo";
 const NOTE = "Emails, payments and other outside actions cannot be undone.";
 
+// DEBUG: prints only when debug is on
+const dbg = (...a) => {
+  if (global._botVersionDebug) console.log("[bv-undo-debug]", ...a);
+};
+
 const STATUS_PATH = "/botversion-undo-status";
 
 // true only when something saved for this action can still be undone by this browser session.
@@ -33,6 +38,7 @@ async function statusOf(id, hash) {
     ]) {
       try {
         const ok = await u.statusAction(id, hash);
+        dbg("status check", name, "->", ok);
         if (ok) return true;
       } catch (e) {
         if (!(e instanceof undoPrisma.Refuse && e.code === "no-client"))
@@ -57,6 +63,11 @@ const CORS = {
 function send(res, status, obj) {
   try {
     res.statusCode = status;
+    dbg(
+      "undo route answered:",
+      status,
+      String((obj && (obj.code || obj.message)) || "").slice(0, 100),
+    );
     for (const k of Object.keys(CORS)) res.setHeader(k, CORS[k]);
     res.setHeader("Content-Type", "application/json");
     // marker lets the widget tell our answer apart from the host's own JSON
@@ -76,6 +87,11 @@ function handle(req, res, isValidId) {
     req.method === "POST" && (label === "status" || label === "undo");
   const isStatus = byLabel ? label === "status" : urlPath === STATUS_PATH;
   if (!byLabel && urlPath !== PATH && !isStatus) return false;
+  dbg("undo route matched:", {
+    method: req.method,
+    path: urlPath,
+    label: label || null,
+  });
   // Browser permission check (preflight) for cross-domain hosts.
   if (req.method === "OPTIONS") {
     try {