botversion-sdk 1.0.0 → 1.0.2

package/cli/writer.js

@@ -17,21 +17,22 @@ function writeFile(filePath, content) {
 
 function backupFile(filePath) {
   if (!fs.existsSync(filePath)) return null;
-  const backupPath = filePath + ".botversion.bak";
+  const backupPath = filePath + ".backup-before-botversion";
   fs.copyFileSync(filePath, backupPath);
   return backupPath;
 }
 
 // ─── INJECT CODE BEFORE app.listen() ────────────────────────────────────────
 
-function injectBeforeListen(filePath, codeToInject) {
+function injectBeforeListen(filePath, codeToInject, appVarName) {
+  appVarName = appVarName || "app";
   const content = fs.readFileSync(filePath, "utf8");
   const lines = content.split("\n");
+  const listenRegex = new RegExp(`${appVarName}\\.listen\\s*\\(`);
 
-  // Find app.listen() line
   let listenLineIndex = -1;
   for (let i = 0; i < lines.length; i++) {
-    if (/app\.listen\s*\(/.test(lines[i])) {
+    if (listenRegex.test(lines[i])) {
       listenLineIndex = i;
       break;
     }
@@ -58,10 +59,10 @@ function injectBeforeListen(filePath, codeToInject) {
   const injectedLines = ["", ...codeToInject.split("\n"), ""];
 
   const newContent = [...before, ...injectedLines, ...after].join("\n");
-  backupFile(filePath);
+  const backup = backupFile(filePath);
   fs.writeFileSync(filePath, newContent, "utf8");
 
-  return { success: true, lineNumber: listenLineIndex + 1 };
+  return { success: true, lineNumber: listenLineIndex + 1, backup };
 }
 
 // ─── APPEND CODE TO END OF FILE ──────────────────────────────────────────────
@@ -94,6 +95,86 @@ function createFile(filePath, content, force) {
   return { success: true, path: filePath };
 }
 
+function injectBeforeExport(filePath, codeToInject, appVarName) {
+  appVarName = appVarName || "app";
+  const content = fs.readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+
+  if (content.includes("botversion-sdk") || content.includes("BotVersion")) {
+    return { success: false, reason: "already_exists" };
+  }
+
+  let insertIndex = -1;
+
+  // Find module.exports = app
+  let exportsLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (/module\.exports\s*=\s*app/.test(lines[i])) {
+      exportsLine = i;
+      break;
+    }
+  }
+
+  if (exportsLine !== -1) {
+    // Walk backwards from module.exports to skip error handler lines
+    // Skip lines that are: blank, closing braces, or known error middleware
+    let i = exportsLine - 1;
+    while (i >= 0) {
+      const line = lines[i].trim();
+      if (
+        line === "" ||
+        line === "})" ||
+        line === "});" ||
+        line === "}," ||
+        line === "}" ||
+        line === ");" ||
+        line === "next();" ||
+        /app\.use\s*\(\s*errorHandler/.test(line) ||
+        /app\.use\s*\(\s*errorConverter/.test(line) ||
+        /app\.use\s*\(\s*\(req,\s*res,\s*next\)/.test(line) ||
+        /next\(new/.test(line) ||
+        /NOT_FOUND/.test(line) ||
+        /Not found/i.test(line) ||
+        /\/\/ (handle|convert|send back) error/.test(lines[i]) ||
+        /\/\/ send back a 404/.test(lines[i])
+      ) {
+        i--;
+      } else {
+        break;
+      }
+    }
+    insertIndex = i + 1;
+  }
+
+  // Fallback: before app.listen()
+  if (insertIndex === -1) {
+    for (let i = 0; i < lines.length; i++) {
+      const listenRegex = new RegExp(`${appVarName}\\.listen\\s*\\(`);
+      if (listenRegex.test(lines[i])) {
+        insertIndex = i;
+        break;
+      }
+    }
+  }
+
+  // Final fallback: append to end of file
+  if (insertIndex === -1) {
+    const backup = backupFile(filePath);
+    const newContent = content.trimEnd() + "\n\n" + codeToInject + "\n";
+    fs.writeFileSync(filePath, newContent, "utf8");
+    return { success: true, backup };
+  }
+
+  const before = lines.slice(0, insertIndex);
+  const after = lines.slice(insertIndex);
+  const injectedLines = ["", ...codeToInject.split("\n"), ""];
+  const newContent = [...before, ...injectedLines, ...after].join("\n");
+
+  const backup = backupFile(filePath);
+  fs.writeFileSync(filePath, newContent, "utf8");
+  return { success: true, backup };
+}
+
 // ─── MERGE INTO EXISTING MIDDLEWARE (Next.js) ────────────────────────────────
 
 function mergeIntoMiddleware(middlewarePath, authName) {
@@ -160,6 +241,187 @@ function writeSummary(changes) {
   return lines.join("\n");
 }
 
+// ─── INJECT SCRIPT TAG INTO FRONTEND FILE ────────────────────────────────────
+
+function injectScriptTag(filePath, fileType, scriptTag, force) {
+  if (!fs.existsSync(filePath)) {
+    return { success: false, reason: "file_not_found" };
+  }
+
+  const content = fs.readFileSync(filePath, "utf8");
+
+  // Already exists check
+  if (content.includes("botversion-loader")) {
+    if (!force) return { success: false, reason: "already_exists" };
+  }
+
+  const backup = backupFile(filePath);
+
+  // ── HTML file — inject before </body> ──────────────────────────────────
+  if (fileType === "html") {
+    if (!content.includes("</body>")) {
+      return { success: false, reason: "no_body_tag" };
+    }
+
+    const newContent = content.replace("</body>", `  ${scriptTag}\n</body>`);
+    fs.writeFileSync(filePath, newContent, "utf8");
+    return { success: true, backup };
+  }
+
+  // ── Next.js _app.js — inject Script component ──────────────────────────
+  if (fileType === "next") {
+    const fileName = path.basename(filePath);
+
+    // pages/_app.js
+    if (fileName.startsWith("_app")) {
+      return injectIntoNextApp(filePath, content, scriptTag, backup);
+    }
+
+    // app/layout.js
+    if (fileName.startsWith("layout")) {
+      return injectIntoNextLayout(filePath, content, scriptTag, backup);
+    }
+  }
+
+  return { success: false, reason: "unsupported_file_type" };
+}
+
+// ─── INJECT INTO NEXT.JS _app.js ─────────────────────────────────────────────
+
+function injectIntoNextApp(filePath, content, scriptTag, backup) {
+  let newContent = content;
+
+  if (!content.includes("next/script")) {
+    newContent = newContent.replace(
+      /^(import .+)/m,
+      `import Script from 'next/script';\n$1`,
+    );
+  }
+
+  const scriptComponent = `
+      <Script
+        id="botversion-loader"
+        src="${extractAttr(scriptTag, "src")}"
+        data-api-url="${extractAttr(scriptTag, "data-api-url")}"
+        data-project-id="${extractAttr(scriptTag, "data-project-id")}"
+        data-public-key="${extractAttr(scriptTag, "data-public-key")}"
+        data-proxy-url="/api/botversion/chat"
+        strategy="afterInteractive"
+      />`;
+
+  const lines = newContent.split("\n");
+
+  // Find ALL return statements and pick the one whose root JSX
+  // is a multi-child wrapper (not a simple single-element return)
+  // Strategy: find the return ( that is followed by the most lines
+  // before its closing ) — that's the main render return
+
+  let bestReturnIndex = -1;
+  let bestRootJsxIndex = -1;
+  let bestLineCount = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^\s*return\s*\(/.test(lines[i])) continue;
+
+    // Find the root JSX tag after this return
+    let rootJsx = -1;
+    for (let j = i + 1; j < lines.length; j++) {
+      const trimmed = lines[j].trim();
+      if (!trimmed) continue;
+      if (trimmed.startsWith("<")) {
+        rootJsx = j;
+        break;
+      }
+      break; // non-empty, non-JSX line means this isn't a JSX return
+    }
+
+    if (rootJsx === -1) continue;
+
+    // Find the closing ) of this return block
+    let depth = 1;
+    let closingLine = -1;
+    for (let j = rootJsx; j < lines.length; j++) {
+      for (const ch of lines[j]) {
+        if (ch === "(") depth++;
+        if (ch === ")") depth--;
+      }
+      if (depth === 0) {
+        closingLine = j;
+        break;
+      }
+    }
+
+    const lineCount = closingLine - i;
+    if (lineCount > bestLineCount) {
+      bestLineCount = lineCount;
+      bestReturnIndex = i;
+      bestRootJsxIndex = rootJsx;
+    }
+  }
+
+  if (bestRootJsxIndex !== -1) {
+    lines.splice(bestRootJsxIndex + 1, 0, scriptComponent);
+    newContent = lines.join("\n");
+  } else {
+    // Final fallback
+    newContent = newContent.replace(
+      /([ \t]*<\/div>\s*\n\s*\))/,
+      `${scriptComponent}\n$1`,
+    );
+  }
+
+  fs.writeFileSync(filePath, newContent, "utf8");
+  return { success: true, backup };
+}
+
+// ─── INJECT INTO NEXT.JS layout.js ───────────────────────────────────────────
+
+function injectIntoNextLayout(filePath, content, scriptTag, backup) {
+  let newContent = content;
+
+  if (!content.includes("next/script")) {
+    newContent = newContent.replace(
+      /^(import .+)/m,
+      `import Script from 'next/script';\n$1`,
+    );
+  }
+
+  const scriptComponent = `
+      <Script
+        id="botversion-loader"
+        src="${extractAttr(scriptTag, "src")}"
+        data-api-url="${extractAttr(scriptTag, "data-api-url")}"
+        data-project-id="${extractAttr(scriptTag, "data-project-id")}"
+        data-public-key="${extractAttr(scriptTag, "data-public-key")}"
+        data-proxy-url="/api/botversion/chat"
+        strategy="afterInteractive"
+      />`;
+
+  // Inject before </body> in layout
+  if (content.includes("</body>")) {
+    newContent = newContent.replace(
+      "</body>",
+      `${scriptComponent}\n      </body>`,
+    );
+  } else {
+    // Fallback — before last closing tag
+    newContent = newContent.replace(
+      /(<\/\w+>\s*\)[\s;]*$)/m,
+      `${scriptComponent}\n      $1`,
+    );
+  }
+
+  fs.writeFileSync(filePath, newContent, "utf8");
+  return { success: true, backup };
+}
+
+// ─── HELPER: extract attribute value from script tag string ──────────────────
+
+function extractAttr(scriptTag, attr) {
+  const match = scriptTag.match(new RegExp(`${attr}="([^"]+)"`));
+  return match ? match[1] : "";
+}
+
 module.exports = {
   writeFile,
   backupFile,
@@ -168,4 +430,6 @@ module.exports = {
   createFile,
   mergeIntoMiddleware,
   writeSummary,
+  injectBeforeExport,
+  injectScriptTag,
 };

package/client.js

@@ -20,6 +20,10 @@ function BotVersionClient(options) {
   this._queue = [];
   this._flushTimer = null;
   this._flushDelay = options.flushDelay || 3000; // batch every 3 seconds
+  var self = this;
+  process.on("beforeExit", function () {
+    if (self._queue.length > 0) self._flush();
+  });
 }
 
 /**

package/index.js

@@ -61,7 +61,7 @@ var BotVersion = {
 
     this._client = new BotVersionClient({
       apiKey: options.apiKey,
-      platformUrl: options.platformUrl || "http://localhost:3000",
+      platformUrl: options.platformUrl || "http://localhost:3000/",
       debug: options.debug || false,
       timeout: options.timeout || 30000,
     });
@@ -205,9 +205,9 @@ var BotVersion = {
           .registerEndpoints(endpoints)
           .then(function () {
             console.log(
-              "[BotVersion SDK] ✅ Static scan complete —",
+              "[BotVersion SDK] ✅ Endpoints queued —",
               endpoints.length,
-              "endpoints registered",
+              "endpoints will be sent shortly",
             );
           })
           .catch(function (err) {
@@ -571,6 +571,14 @@ BotVersion.nextHandler = function (options) {
 
 BotVersion.nextHandler = BotVersion.nextHandler.bind(BotVersion);
 
+BotVersion.appRouterHandler = function () {
+  throw new Error(
+    "[BotVersion SDK] appRouterHandler is not supported. " +
+      "Please run: npx botversion-sdk init --key YOUR_KEY --force " +
+      "to regenerate the correct route file.",
+  );
+};
+
 module.exports = BotVersion;
 module.exports.default = BotVersion;
 module.exports.init = BotVersion.init;
@@ -578,6 +586,7 @@ module.exports.getEndpoints = BotVersion.getEndpoints;
 module.exports.registerEndpoint = BotVersion.registerEndpoint;
 module.exports.chat = BotVersion.chat;
 module.exports.nextHandler = BotVersion.nextHandler;
+module.exports.appRouterHandler = BotVersion.appRouterHandler;
 
 // ── Framework detection ──────────────────────────────────────────────────────
 function detectFramework(app) {

package/interceptor.js

@@ -267,8 +267,8 @@ function makeLocalCall(req, call) {
     var lib = isHttps ? https : http;
 
     var options = {
-      hostname: req.hostname,
-      port: (req.socket && req.socket.localPort) || (isHttps ? 443 : 80),
+      hostname: "127.0.0.1",
+      port: process.env.PORT || 3000,
       path: call.path,
       method: call.method,
       headers: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botversion-sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "BotVersion SDK — auto-detect and register your API endpoints",
   "main": "index.js",
   "bin": {

package/scanner.js

@@ -8,6 +8,8 @@ function scanExpressRoutes(app) {
   const endpoints = [];
   const seen = new Set();
 
+  // Force Express to initialize its router if it hasn't yet
+  if (app.lazyrouter) app.lazyrouter();
   const router = app._router || app.router || (app.stack ? app : null);
 
   if (!router) {
@@ -325,35 +327,32 @@ function extractQueryFieldsFromFile(content) {
 function regexpToPath(regexp, keys) {
   if (!regexp) return "";
 
-  // Express stores the fast path string on the regexp object directly
-  if (regexp.source === "^\\/?(?=\\/|$)") return ""; // root mount, no prefix
+  // Express 4.x stores the original path string directly
+  if (regexp.source === "^\\/?(?=\\/|$)") return "";
 
-  // Try to extract a clean path from the regexp source
   try {
     var src = regexp.source;
 
-    // A plain string mount like app.use('/api/v1', ...) produces
-    // source: "^\\/api\\/v1\\/?(?=\\/|$)" — extract the prefix part
-    var match = src.match(/^\^\\\/(.+?)\\\/\?\(\?=\\\/\|\$\)$/);
-    if (match) {
-      return "/" + match[1].replace(/\\\//g, "/");
-    }
+    // Remove anchors and cleanup
+    src = src
+      .replace(/^\^/, "")
+      .replace(/\\\//g, "/")
+      .replace(/\/\?\(\?=\/\|\$\)$/, "")
+      .replace(/\/\?\$?$/, "")
+      .replace(/\(\?:\(\[\^\/\]\+\?\)\)/g, function (_, i) {
+        return keys && keys[i] ? ":" + keys[i].name : ":param";
+      });
 
-    // Simpler pattern: "^\\/api\\/?(?=\\/|$)"
-    var match2 = src.match(/^\^(\\.+?)\\\/\?\(\?=\\\/\|\$\)$/);
-    if (match2) {
-      return match2[1].replace(/\\\//g, "/");
-    }
-  } catch (e) {
-    // ignore
-  }
+    // Clean up any remaining regex artifacts
+    src = src.replace(/\(\?:/g, "").replace(/\)/g, "");
 
-  // If keys exist, fall back to building from keys (parameterised mount — rare)
-  if (keys && keys.length > 0) {
-    return "/:param";
-  }
+    if (!src || src === "/") return "";
+    if (!src.startsWith("/")) src = "/" + src;
 
-  return "";
+    return src;
+  } catch (e) {
+    return "";
+  }
 }
 
 module.exports = {