botversion-sdk 2.3.0 → 2.3.1

package/package.json

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

package/undo/index.js

@@ -50,7 +50,7 @@ function init(options) {
     // 2. Look at the host project.
     const scan = scanner.scan();
 
-    // 3. Database hooks. Only the ones that match what the host has.
+    // 3. Database hooks. Only the ones that match what the host has..
     //    (Final SDK: more hooks are added to this same list.)
     const pgCopies = pgHook.attach(scan.hostRoot);
     const mysql2Copies = mysql2Hook.attach(scan.hostRoot);

package/undo/lib/capture-mysql.js

@@ -602,13 +602,6 @@ async function runCapture(client, run, stmt, ref, kind, st, execHost) {
   let phase = "before"; // "before" = the write has not run yet, so it can still be blocked
   let failedWhy = null;
   const notSaved = (why) => {
-    log.debug(
-      "mysql notSaved:",
-      "table=" + name,
-      "phase=" + phase,
-      "reason=" + why,
-      "confirmed=" + st.confirmed,
-    );
     if (phase === "before") failedWhy = failedWhy || why;
     if (phase !== "before" || st.confirmed) st.unsaved = true; // the write runs (or already ran) without a saved snapshot
   };
@@ -640,17 +633,6 @@ async function runCapture(client, run, stmt, ref, kind, st, execHost) {
       else plan = planInsert(stmt, pk);
     }
   } catch (e) {
-    // TEMP DEBUG: real cause behind "capture error"
-    log.debug(
-      "mysql capture threw:",
-      "table=" + name,
-      "kind=" + kind,
-      "code=" + ((e && e.code) || "none"),
-      "name=" + (e && e.name),
-      !(e && e.code)
-        ? "msg=" + String((e && e.message) || "").slice(0, 150)
-        : "",
-    );
     notSaved(
       e instanceof Skip
         ? e.message
@@ -811,12 +793,6 @@ function maybeCapture(client, args, original, queryOriginal) {
 
   // A write that cannot be saved: blocked until the user confirms (or runs unsaved if they already did).
   const refuse = (table, why) => {
-    log.debug(
-      "mysql refuse (statement shape):",
-      "table=" + table,
-      "reason=" + why,
-      "confirmed=" + st.confirmed,
-    );
     if (st.confirmed) {
       st.unsaved = true; // runs without a saved snapshot, so Undo will not cover it
       return null;

package/undo/lib/capture-prisma.js

@@ -121,6 +121,8 @@ const pkWhere = (info, row) => {
 
 // A top-level create or update whose relation fields only use connect (or disconnect, update only), and whose
 // links the database undoes by itself or that are plain columns on the written row. Anything unclear = false.
+// A top-level create or update whose relation fields only use connect (or disconnect, update only), where the
+// link is a plain column on the written row, or (create only) a hidden join table that cascades away. Anything unclear = false.
 async function nestedConnectOnly(
   base,
   model,
@@ -161,17 +163,22 @@ async function nestedConnectOnly(
         !(operation === "update" && keys[0] === "disconnect")
       )
         return false;
-      // A hidden join table is only safe for create (the database removes its rows when the new row is deleted).
-      if (
-        operation === "create" &&
-        structure.hiddenJoinIsCascade(
-          base,
-          f.relationName,
-          tableOf(model),
-          tableOf(f.type),
+      // Decided per relation: a hidden join table (or an unknown answer) is safe only for a create whose join rows cascade away.
+      const joined = structure.hasHiddenJoin(base, f.relationName);
+      if (joined !== false) {
+        if (
+          joined === true &&
+          operation === "create" &&
+          structure.hiddenJoinIsCascade(
+            base,
+            f.relationName,
+            tableOf(model),
+            tableOf(f.type),
+          )
         )
-      )
-        continue;
+          continue;
+        return false;
+      }
       const here = (g.get(f.type) || []).some((l) => l.child === model);
       const there = (g.get(model) || []).some((l) => l.child === f.type);
       if (here && !there) continue; // link is only a column on the written row
@@ -200,24 +207,6 @@ async function capture({
 }) {
   const st = tagger.getCurrent();
   if (!st) return null;
-  // TEMP DEBUG: what the Prisma hook handed to capture() (names and types only, never values)
-  log.debug(
-    "prisma capture called:",
-    "model=" + model,
-    "op=" + operation,
-    "dialect=" + String(dialect) + " (type " + typeof dialect + ")",
-    "nested=" + !!nested,
-    "internalType=" + typeof internal,
-    "internalKeys=" +
-      (internal && typeof internal === "object"
-        ? Object.keys(internal).join("|")
-        : "none"),
-    "inHostTransaction=" + !!(internal && internal.transaction),
-    "baseActiveProvider=" + String(base && base._activeProvider),
-    "baseEngineProvider=" +
-      String(base && base._engineConfig && base._engineConfig.activeProvider),
-    "baseHasDataModel=" + !!(base && base._runtimeDataModel),
-  );
   // FIX: take the database type from the live client when the hook did not supply one (a schema file read from disk can be missing or elsewhere).
   if (!dialect) dialect = dialectFromPrismaClient(base);
   // FIX: some Prisma versions carry no key markers or delete rules at runtime; ask the database (once per client) for them.
@@ -225,9 +214,7 @@ async function capture({
     const m0 = modelInfo(base, model);
     const isDelete = operation === "delete" || operation === "deleteMany";
     if ((m0 && m0.pkFields.length === 0) || (isDelete && !getGraph(base))) {
-      log.debug("prisma structure load starting:", "model=" + model);
       const loadedOk = await structure.load(base, dialect);
-      log.debug("prisma structure load result:", "ok=" + loadedOk);
     }
   }
   // TEMP DEBUG: writes only, to avoid noise. Shows the type finally used, and whether relation rules exist on the live client.
@@ -241,13 +228,6 @@ async function capture({
       rm && Array.isArray(rm.fields)
         ? rm.fields.find((f) => f.kind === "object")
         : null;
-    log.debug(
-      "prisma write seen:",
-      "model=" + model,
-      "op=" + operation,
-      "dialectUsed=" + String(dialect),
-      "relationFieldKeys=" + (rel ? Object.keys(rel).join("|") : "none"),
-    );
     // Logs the hook's nested flag next to the shape of the call (names only, never values).
     try {
       const d1 = args && args.data;
@@ -266,15 +246,6 @@ async function capture({
               )
               .map((f) => f.name)
           : [];
-      log.debug(
-        "prisma nested flag vs call shape:",
-        "model=" + model,
-        "op=" + operation,
-        "nested=" + !!nested,
-        "relationKeysInData=" + (relKeys.join("|") || "none"),
-        "hasInclude=" + !!(args && args.include),
-        "hasSelect=" + !!(args && args.select),
-      );
     } catch (_) {
       /* never break the host */
     }
@@ -285,30 +256,6 @@ async function capture({
       (f) => f.kind === "scalar" || f.kind === "enum",
     );
     const mi = modelInfo(base, model);
-    log.debug(
-      "prisma model detail:",
-      "model=" + model,
-      "modelKeys=" + (rm ? Object.keys(rm).join("|") : "none"),
-      "primaryKeyProp=" +
-        (rm && rm.primaryKey ? JSON.stringify(rm.primaryKey) : "none"),
-      "uniqueFields=" +
-        (rm && rm.uniqueFields ? JSON.stringify(rm.uniqueFields) : "none"),
-      "fieldCount=" + fields.length,
-      "scalarCount=" + scalarFields.length,
-      "fieldsMarkedIsId=" + fields.filter((f) => f.isId).length,
-      "fieldNamedId=" + (idNamed ? Object.keys(idNamed).join("|") : "none"),
-      "firstScalarKeys=" +
-        (scalarFields[0] ? Object.keys(scalarFields[0]).join("|") : "none"),
-      "modelInfoPk=" + (mi ? JSON.stringify(mi.pkFields) : "no model info"),
-    );
-    // TEMP DEBUG: also reads the delete links now, so the next possible block shows up in this same run
-    if (operation === "delete" || operation === "deleteMany") {
-      const g0 = getGraph(base);
-      log.debug(
-        "prisma delete graph:",
-        g0 ? "readOk models=" + g0.size : "COULD NOT BE READ",
-      );
-    }
     // TEMP DEBUG (once per process): primary-key detection for EVERY model, so no second model blocks the same action later
     if (!capture.audited) {
       capture.audited = true;
@@ -319,25 +266,11 @@ async function capture({
         const info2 = modelInfo(base, n);
         return !info2 || info2.pkFields.length === 0;
       });
-      log.debug(
-        "prisma model audit:",
-        "models=" + names.length,
-        "withoutPrimaryKeyDetected=" + noPk.length,
-        "names=" + noPk.slice(0, 60).join("|"),
-        "anyFieldMarkedIsId=" +
-          names.some((n) => (all[n].fields || []).some((f) => f.isId)),
-      );
     }
     // TEMP DEBUG: does the Undo side find the same primary key for this table?
     try {
       const ui = require("./undo-prisma").infoFor(mi ? mi.table : model);
-      log.debug(
-        "prisma undo-side model info:",
-        ui ? "pk=" + JSON.stringify(ui.pkFields) : "NOT FOUND",
-      );
-    } catch (e) {
-      log.debug("prisma undo-side model info failed:", "name=" + (e && e.name));
-    }
+    } catch (e) {}
   }
   if (
     UNSAVABLE.has(operation) ||
@@ -352,15 +285,10 @@ async function capture({
       );
     return null;
   }
-  if (!model || !OPS.has(operation)) return null;
+  if (!model || !OPS.has(operation)) {
+    return null;
+  }
   const skip = async (why) => {
-    log.debug(
-      "prisma skip:",
-      "model=" + model,
-      "op=" + operation,
-      "reason=" + why,
-      "confirmed=" + st.confirmed,
-    );
     if (st.confirmed) st.unsaved = true; // runs without a saved snapshot, so Undo will not cover it
     if (!st.confirmed) await gate.block(st, `${model} ${operation}`, why);
     return null;
@@ -398,12 +326,6 @@ async function capture({
               Object.keys(d[k]).some((v) => verbs.includes(v)),
           )
           .map((k) => k + ":" + Object.keys(d[k]).join("+"));
-        log.debug(
-          "prisma nested write shape:",
-          "model=" + model,
-          "op=" + operation,
-          shape.join(" | ") || "none found in data",
-        );
       } catch (_) {
         /* never break the host */
       }
@@ -432,13 +354,6 @@ async function capture({
             onOther
           );
         });
-        log.debug(
-          "prisma nested relation detail:",
-          "model=" + model,
-          "argKeys=" + Object.keys(args || {}).join("|"),
-          out.join(" | ") || "none",
-          "graphAvailable=" + !!g,
-        );
       } catch (_) {
         /* never break the host */
       }
@@ -524,47 +439,8 @@ async function capture({
             "]"
           );
         });
-        log.debug(
-          "prisma nested relation detail:",
-          "model=" + model,
-          "op=" + operation,
-          "graphAvailable=" + !!g,
-          "argKeys=" + Object.keys(args || {}).join("|"),
-          "includeKeys=" +
-            (plain(args && args.include)
-              ? Object.keys(args.include).join("|")
-              : "none"),
-          "selectKeys=" +
-            (plain(args && args.select)
-              ? Object.keys(args.select).join("|")
-              : "none"),
-        );
         lines.forEach((l) => log.debug("prisma nested relation field:", l));
-        // the call details the hook passed in, in case they explain why nested=true
-        log.debug(
-          "prisma nested hook inputs:",
-          "dataPathIsArray=" + Array.isArray(internal && internal.dataPath),
-          "dataPathLength=" +
-            (Array.isArray(internal && internal.dataPath)
-              ? internal.dataPath.length
-              : "n/a"),
-          "dataPath=" +
-            (Array.isArray(internal && internal.dataPath)
-              ? internal.dataPath.join(">")
-              : "n/a"),
-          "action=" + String(internal && internal.action),
-          "clientMethod=" + String(internal && internal.clientMethod),
-          "internalArgsKeys=" +
-            (plain(internal && internal.args)
-              ? Object.keys(internal.args).join("|")
-              : "n/a"),
-        );
-      } catch (e) {
-        log.debug(
-          "prisma nested relation detail failed:",
-          "name=" + (e && e.name),
-        );
-      }
+      } catch (e) {}
       // Logs the foreign keys of any hidden join table behind each relation field in the write (names and rules only).
       try {
         const relFields = base._runtimeDataModel.models[model].fields.filter(
@@ -576,21 +452,8 @@ async function capture({
         );
         relFields.forEach((f) => {
           const links = structure.linksOfTablesMentioning(base, f.relationName);
-          log.debug(
-            "prisma nested join table links:",
-            "field=" + f.name,
-            "relationName=" + f.relationName,
-            links.length
-              ? links.join(" ; ")
-              : "no table named like this relation has foreign keys",
-          );
         });
-      } catch (e) {
-        log.debug(
-          "prisma nested join table links failed:",
-          "name=" + (e && e.name),
-        );
-      }
+      } catch (e) {}
       if (
         !(await nestedConnectOnly(
           base,
@@ -882,16 +745,6 @@ async function capture({
 
     return { result: out };
   } catch (e) {
-    // TEMP DEBUG: real cause of a capture failure (our own messages only; database messages can contain values)
-    log.debug(
-      "prisma capture threw:",
-      "model=" + model,
-      "op=" + operation,
-      "name=" + (e && e.name),
-      "code=" + ((e && e.code) || "none"),
-      e instanceof Skip ? "msg=" + e.message : "",
-      "hostError=" + !!hostError,
-    );
     if (hostError) throw hostError; // the host's own write failed: the host must see its own error
     return skip(e instanceof Skip ? e.message : "capture error");
   }

package/undo/lib/capture-sql.js

@@ -479,13 +479,6 @@ async function runCapture(client, rawRun, stmt, values, st, hostCall) {
   let phase = "before"; // "before" = the write has not run yet, so it can still be blocked
   let failedWhy = null;
   const notSaved = (why) => {
-    log.debug(
-      "pg notSaved:",
-      "table=" + name,
-      "phase=" + phase,
-      "reason=" + why,
-      "confirmed=" + st.confirmed,
-    );
     if (phase === "before") failedWhy = failedWhy || why;
     if (phase !== "before" || st.confirmed) st.unsaved = true; // the write runs (or already ran) without a saved snapshot
   };
@@ -499,17 +492,6 @@ async function runCapture(client, rawRun, stmt, values, st, hostCall) {
     else if (stmt.type === "insert")
       await beforeInsert(rawRun, stmt, inTx, notSaved);
   } catch (e) {
-    // TEMP DEBUG: real cause behind "capture error" (message only for non-database errors, since database messages can contain values)
-    log.debug(
-      "pg capture threw:",
-      "table=" + name,
-      "type=" + stmt.type,
-      "code=" + ((e && e.code) || "none"),
-      "name=" + (e && e.name),
-      !(e && e.code)
-        ? "msg=" + String((e && e.message) || "").slice(0, 150)
-        : "",
-    );
     notSaved("capture error " + ((e && e.code) || "unknown"));
   }
 
@@ -586,12 +568,6 @@ function maybeCapture(client, args, original) {
 
   // A write that cannot be saved: blocked until the user confirms (or runs unsaved if they already did).
   const refuse = (table, why) => {
-    log.debug(
-      "pg refuse (statement shape):",
-      "table=" + table,
-      "reason=" + why,
-      "confirmed=" + st.confirmed,
-    );
     if (st.confirmed) {
       st.unsaved = true; // runs without a saved snapshot, so Undo will not cover it
       return null;

package/undo/lib/gate.js

@@ -50,11 +50,6 @@ async function rollbackAction(st) {
         (e.code === "unsupported" ||
           e.code === "no-client" ||
           e.code === "not-found");
-      log.debug(
-        "gate rollback: undoer error",
-        (e && e.code) || (e && e.name) || "unknown",
-        next ? "(moving to next database)" : "(stopping)",
-      );
       if (!next) throw e;
       if (e.code === "unsupported" && !unsupported) unsupported = e;
       if (e.code === "not-found" && !notFound) notFound = e;
@@ -66,12 +61,6 @@ async function rollbackAction(st) {
 
 // Answers the browser request itself, then silences the host so it cannot answer a second time.
 function reply(st, info) {
-  log.debug(
-    "GATE REPLY:",
-    "rolledBack=" + info.rolledBack,
-    "undone=" + info.undone,
-    "headersAlreadySent=" + !!(st.res && st.res.headersSent),
-  );
   const res = st.res;
   if (!res || res.headersSent || res.writableEnded) return;
   const body = JSON.stringify({
@@ -108,14 +97,6 @@ function reply(st, info) {
 
 // Always throws Blocked (so the host's write does not run).
 async function block(st, where, why) {
-  log.debug(
-    "GATE BLOCK:",
-    "table=" + where,
-    "reason=" + why,
-    "visual=" + st.visual,
-    "confirmed=" + st.confirmed,
-    "alreadyBlocked=" + !!st.blocked,
-  );
   try {
     if (!st.blocked) {
       const info = {
@@ -146,13 +127,6 @@ async function block(st, where, why) {
 // Only better-sqlite3 writes can be rolled back this way; writes made earlier in other databases are reported as not rolled back.
 // Always throws Blocked (so the host's write does not run).
 function blockSync(st, where, why) {
-  log.debug(
-    "GATE BLOCK (sync):",
-    "table=" + where,
-    "reason=" + why,
-    "visual=" + st.visual,
-    "confirmed=" + st.confirmed,
-  );
   try {
     if (!st.blocked) {
       const info = {

package/undo/lib/hooks/prisma.js

@@ -90,6 +90,24 @@ function hasNestedWrites(node, depth) {
   return false;
 }
 
+// True when the write's data sets a relation field of the model (read from the model itself, no word list).
+// If the model cannot be read, falls back to the old word-list check.
+function writesRelationFields(base, model, args) {
+  const d = args && typeof args === "object" ? args.data : null;
+  if (!d || typeof d !== "object") return false;
+  try {
+    const models = base._runtimeDataModel && base._runtimeDataModel.models;
+    const m = models && models[model];
+    if (m && Array.isArray(m.fields) && !Array.isArray(d))
+      return m.fields.some(
+        (f) => f.kind === "object" && d[f.name] !== undefined,
+      );
+  } catch (_) {
+    /* fall through */
+  }
+  return hasNestedWrites(d, 0);
+}
+
 function isEmptyFilter(where) {
   return (
     where === undefined ||
@@ -215,12 +233,7 @@ function extendClient(base, options) {
           /* observation problems must never affect the host's operation */
         }
         // Tagged writes run inside our own transaction together with their snapshot.
-        const nested = !!(
-          args &&
-          typeof args === "object" &&
-          args.data &&
-          hasNestedWrites(args.data, 0)
-        );
+        const nested = writesRelationFields(base, model, args);
         const handled = await guard.runUnhooked(() =>
           capturePrisma.capture({
             base,
@@ -239,7 +252,8 @@ function extendClient(base, options) {
     },
   });
   state.clients++;
-  if (state.clients === 1) return extended;
+  // hooks every client the host creates, not only the first one
+  return extended;
 }
 
 // Returns a subclass of Prisma's generated client class that hooks every new instance.

package/undo/lib/loader-watch.js

@@ -27,11 +27,6 @@ function install() {
               // TEMP DEBUG: which module requests the database hooks matched, and who asked for them
               if (!seenLoads.has(request)) {
                 seenLoads.add(request);
-                log.debug(
-                  "loader matched:",
-                  request,
-                  "from=" + (parent && parent.filename ? parent.filename : "?"),
-                );
               }
               const replacement = h.handle(exp, request, parent);
               if (replacement !== undefined) exp = replacement; // a hook may hand back a wrapped version

package/undo/lib/log.js

@@ -1,7 +1,6 @@
 // lib/log.js
 "use strict";
-// Tiny logger. Rule from the plan: logs may contain table names, operation
-// types, counts and ids only - NEVER row values or SQL text.
+// Tiny logger. Logs may contain table names, operation types, counts and ids only - NEVER row values or SQL text.
 
 const PREFIX = "[botversion-undo-exp]";
 let quiet = false;
@@ -14,6 +13,8 @@ function info(...args) {
   if (quiet) return;
 }
 
+function debug(...args) {}
+
 function warn(...args) {
   try {
     console.warn(PREFIX, "WARNING:", ...args);
@@ -22,13 +23,13 @@ function warn(...args) {
   }
 }
 
-// TEMP DEBUG: always prints (log.info is silent). Reasons, names and codes only, never row values or SQL.
-function debug(...args) {
+// TEMP DIAGNOSTIC: always prints, so we can trace why Undo is not offered. Remove after the cause is fixed.
+function diag(...args) {
   try {
-    console.log(PREFIX, "[DEBUG]", ...args);
+    console.log("[bv-diag]", ...args);
   } catch (_) {
     /* logging must never break the host */
   }
 }
 
-module.exports = { info, warn, debug, setQuiet, PREFIX };
+module.exports = { info, warn, debug, diag, setQuiet, PREFIX };

package/undo/lib/prisma-structure.js

@@ -129,10 +129,6 @@ const byOrd = (a, b) => a.ord - b.ord;
 async function read(base, dialect, st) {
   const sql = SQL[dialect];
   if (!sql) {
-    log.debug(
-      "prisma-structure: reading keys from the database is not available for",
-      String(dialect),
-    );
     return false; // stays cached: asking again would give the same answer
   }
   try {
@@ -183,22 +179,9 @@ async function read(base, dialect, st) {
     });
     st.badRule = badRule;
     st.ready = true;
-    log.debug(
-      "prisma-structure loaded:",
-      "dialect=" + dialect,
-      "tablesWithKeys=" + st.pk.size,
-      "foreignKeys=" + st.fks.length,
-      "unknownRules=" + badRule,
-    );
     return true;
   } catch (e) {
     st.promise = null; // try again on the next write
-    log.debug(
-      "prisma-structure failed:",
-      "name=" + (e && e.name),
-      "code=" + ((e && e.code) || "none"),
-      "dbCode=" + ((e && e.meta && e.meta.code) || "none"),
-    );
     return false;
   }
 }
@@ -207,11 +190,6 @@ async function read(base, dialect, st) {
 function load(base, dialect) {
   try {
     if (!base || typeof base.$queryRawUnsafe !== "function") {
-      log.debug(
-        "prisma-structure: client unusable:",
-        "hasBase=" + !!base,
-        "hasQueryRaw=" + !!(base && typeof base.$queryRawUnsafe === "function"),
-      );
       return Promise.resolve(false);
     }
     let st = cache.get(base);
@@ -228,7 +206,6 @@ function load(base, dialect) {
     if (!st.promise) st.promise = read(base, dialect, st);
     return st.promise;
   } catch (e) {
-    log.debug("prisma-structure: load threw:", "name=" + (e && e.name));
     return Promise.resolve(false);
   }
 }
@@ -300,12 +277,6 @@ function deleteGraph(base) {
     }
     if (!st.graphLogged) {
       st.graphLogged = true;
-      log.debug(
-        "prisma-structure delete links built:",
-        "parents=" + graph.size,
-        "links=" + links,
-        "skippedNoModel=" + skipped,
-      );
     }
     return graph;
   } catch (_) {
@@ -326,6 +297,17 @@ function tablesMentioning(base, text) {
   }
 }
 
+// True/false: is this relation stored in a hidden join table ("_" + relation name)? null = cannot tell.
+function hasHiddenJoin(base, relationName) {
+  try {
+    const st = cache.get(base);
+    if (!st || !st.ready || !relationName) return null;
+    return st.fks.some((fk) => fk.child === "_" + relationName);
+  } catch (_) {
+    return null;
+  }
+}
+
 // True when the relation is stored in a hidden join table whose two foreign keys both cascade on delete.
 function hiddenJoinIsCascade(base, relationName, tableA, tableB) {
   try {
@@ -394,4 +376,5 @@ module.exports = {
   tablesMentioning,
   linksOfTablesMentioning,
   hiddenJoinIsCascade,
+  hasHiddenJoin,
 };

package/undo/lib/scanner.js

@@ -197,14 +197,6 @@ function detectPrisma(hostRoot) {
       "Prisma's own engine - NOT visible to the pg hook (the Prisma hook covers it at model level)";
   }
   const ds = readPrismaDatasource(hostRoot);
-  // TEMP DEBUG: where the schema was looked for and whether a database provider was read
-  log.debug(
-    "scanner prisma schema:",
-    "hostRoot=" + hostRoot,
-    ds
-      ? "provider=" + ds.provider + " file=" + ds.file
-      : "no schema file found in the usual places",
-  );
   const database = ds
     ? {
         name: PROVIDER_LABELS[ds.provider] || ds.provider,
@@ -354,21 +346,6 @@ function scan() {
 
   const prisma = detectPrisma(hostRoot);
   const snapshotTable = detectSnapshotDialect(prisma, drivers);
-  // TEMP DEBUG: what detection found (names and paths only)
-  log.debug(
-    "scanner result:",
-    "hostRoot=" + hostRoot,
-    "prismaFound=" + !!prisma,
-    "prismaDatabase=" +
-      (prisma && prisma.database
-        ? prisma.database.provider + " from " + prisma.database.file
-        : "NOT FOUND"),
-    "snapshotDialect=" +
-      (snapshotTable
-        ? snapshotTable.dialect + " via " + snapshotTable.source
-        : "NONE"),
-    "drivers=" + drivers.map((d) => d.name).join("|"),
-  );
 
   return {
     hostRoot,

package/undo/lib/schema-reader.js

@@ -82,12 +82,6 @@ function readDeleteGraph(hostRoot) {
     const Prisma = loadPrismaNamespace(hostRoot);
     const dm = Prisma && Prisma.dmmf && Prisma.dmmf.datamodel;
     if (!dm || !Array.isArray(dm.models)) {
-      // TEMP DEBUG: why the delete links could not be read
-      log.debug(
-        "schema-reader delete graph: no data model",
-        "hasPrismaNamespace=" + !!Prisma,
-        "hasDmmf=" + !!(Prisma && Prisma.dmmf),
-      );
       return null;
     }
     const graph = new Map();
@@ -115,13 +109,6 @@ function readDeleteGraph(hostRoot) {
     }
     return graph;
   } catch (e) {
-    // TEMP DEBUG: why Prisma's data model could not be loaded
-    log.debug(
-      "schema-reader delete graph failed:",
-      "name=" + (e && e.name),
-      "code=" + ((e && e.code) || "none"),
-      "msg=" + String((e && e.message) || "").slice(0, 150),
-    );
     return null;
   }
 }

package/undo/lib/snapshot-store.js

@@ -116,14 +116,16 @@ function isOwnTable(name) {
 
 // info = { rowCount, primaryKeyColumns }. Tells a hook whether a write may be captured, before it reads anything.
 function checkCapturable(info) {
-  if (!snapshotCrypto.hasKey())
-    return { ok: false, reason: "no-encryption-key" };
-  const pk = info && info.primaryKeyColumns;
-  if (!Array.isArray(pk) || pk.length === 0)
-    return { ok: false, reason: "no-primary-key" };
-  if (!(info.rowCount <= ROW_LIMIT))
-    return { ok: false, reason: "too-many-rows" };
-  return { ok: true };
+  let r = { ok: true };
+  if (!snapshotCrypto.hasKey()) r = { ok: false, reason: "no-encryption-key" };
+  else {
+    const pk = info && info.primaryKeyColumns;
+    if (!Array.isArray(pk) || pk.length === 0)
+      r = { ok: false, reason: "no-primary-key" };
+    else if (!(info.rowCount <= ROW_LIMIT))
+      r = { ok: false, reason: "too-many-rows" };
+  }
+  return r;
 }
 
 // Order number of a write inside one AI action (1, 2, 3...). Undo reverses them last to first.
@@ -212,21 +214,12 @@ async function saveSnapshot(run, store, entry, opts) {
       await run(sqlFor(dialect).insertSql, params);
       return { ok: true };
     });
-    if (!result.ok) return result;
+    if (!result.ok) {
+      return result;
+    }
     (store.savedIds || (store.savedIds = [])).push(id); // remembered so a visual run can roll back only this request
     return { ok: true, id, seq };
   } catch (e) {
-    // TEMP DEBUG: why saving a snapshot failed (message only for non-database errors)
-    log.debug(
-      "saveSnapshot failed:",
-      "table=" + (entry && entry.table),
-      "op=" + (entry && entry.operation),
-      "code=" + ((e && e.code) || "none"),
-      "name=" + (e && e.name),
-      !(e && e.code)
-        ? "msg=" + String((e && e.message) || "").slice(0, 150)
-        : "",
-    );
     warnOnce(
       "save-failed",
       `Undo setup problem: a snapshot could not be saved (database error code ${(e && e.code) || "unknown"}). Check the snapshot table and that the login can INSERT, SELECT, UPDATE and DELETE on it.`,

package/undo/lib/tagger.js

@@ -69,6 +69,15 @@ function buildStore(req, res) {
   if (!headers) return null;
   const raw = headers[headerName];
   const first = Array.isArray(raw) ? raw[0] : raw;
+  if (
+    !first &&
+    Object.keys(headers).some((k) => k.indexOf("x-botversion-") === 0)
+  )
+    noteIgnored(
+      "request has x-botversion-* headers but not the action-id header named '" +
+        headerName +
+        "'",
+    );
   // Only a plain id shape is accepted, so odd or hostile values never reach logs or later storage.
   if (typeof first !== "string" || !/^[A-Za-z0-9_-]{8,64}$/.test(first))
     return null;

package/undo/lib/undo-prisma.js

@@ -29,14 +29,6 @@ function jsonNull() {
 let base = null; // the app's own PrismaClient (not the extended one, so our writes are never captured)
 let dialect = "postgres"; // database type of the app's Prisma client
 function remember(client, d) {
-  // TEMP DEBUG: was the Prisma client and database type remembered, and when?
-  log.debug(
-    "undoPrisma.remember called:",
-    "dialectPassed=" + String(d),
-    "hasClient=" + !!client,
-    "hasTransactionFn=" +
-      !!(client && typeof client.$transaction === "function"),
-  );
   base = client;
   // FIX: the hook's value first, then what the live client reports, then Postgres (the old default).
   dialect = d || dialectFromPrismaClient(client) || "postgres";
@@ -377,7 +369,6 @@ async function statusAction(actionId, requesterHash) {
     `SELECT requester_hash, status, ${LIVE()} AS live FROM ${TABLE} WHERE action_id = ${PH()}`,
     actionId,
   );
-  // Same safety checks as Undo itself: same browser session, still captured, still inside the window.
   return (
     rows.length > 0 &&
     rows.every(

package/undo/lib/undo-route.js

@@ -20,18 +20,20 @@ const STATUS_PATH = "/botversion-undo-status";
 // true only when something saved for this action can still be undone by this browser session.
 // Any problem answers false, so the widget simply does not draw the button.
 async function statusOf(id, hash) {
+  const tag = String(id).slice(0, 6);
   try {
     // Ask each database in turn; the first one that has something to undo answers true.
-    for (const u of [
-      undoPrisma,
-      undoPg,
-      undoMysql,
-      undoMongo,
-      undoSqlite,
-      undoMssql,
+    for (const [name, u] of [
+      ["prisma", undoPrisma],
+      ["pg", undoPg],
+      ["mysql", undoMysql],
+      ["mongo", undoMongo],
+      ["sqlite", undoSqlite],
+      ["mssql", undoMssql],
     ]) {
       try {
-        if (await u.statusAction(id, hash)) return true;
+        const ok = await u.statusAction(id, hash);
+        if (ok) return true;
       } catch (e) {
         if (!(e instanceof undoPrisma.Refuse && e.code === "no-client"))
           throw e;
@@ -104,7 +106,8 @@ function handle(req, res, isValidId) {
       } catch (_) {
         /* bad JSON */
       }
-      if (typeof id !== "string" || !isValidId(id)) {
+      const idOk = typeof id === "string" && isValidId(id);
+      if (!idOk) {
         return send(res, 403, { ok: false, message: "Invalid action id." });
       }
       // Try Prisma first; if the saved change is not a Prisma model (or Prisma is not in use), try pg.
@@ -138,11 +141,6 @@ function handle(req, res, isValidId) {
             (e.code === "unsupported" ||
               e.code === "no-client" ||
               e.code === "not-found");
-          log.debug(
-            "undo route: undoer said",
-            (e && e.code) || (e && e.name) || "unknown",
-            next ? "(trying next database)" : "(stopping)",
-          );
           if (!next) throw e;
           if (e.code === "unsupported" && !unsupported) unsupported = e;
           if (e.code === "not-found" && !notFound) notFound = e;
@@ -161,15 +159,6 @@ function handle(req, res, isValidId) {
           NOTE,
       });
     } catch (e) {
-      log.debug(
-        "undo route FINAL error:",
-        e instanceof undoPrisma.Refuse
-          ? "refuse code=" + e.code
-          : "unexpected " +
-              (e && e.name) +
-              " code=" +
-              ((e && e.code) || "none"),
-      );
       if (e instanceof undoPrisma.Refuse) {
         const status =
           e.code === "forbidden"