botversion-sdk 1.1.7 → 2.0.0

package/bin/scan-frontend.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+"use strict";
+
+var scanner = require("../scanner");
+var BotVersionClient = require("../client");
+var sdk = require("../index");
+
+var apiKey = process.env.BOTVERSION_API_KEY;
+var platformUrl =
+  process.env.BOTVERSION_PLATFORM_URL || "https://botversion.com";
+
+if (!apiKey) {
+  console.error(
+    "[BotVersion] BOTVERSION_API_KEY environment variable is not set. Skipping frontend route scan.",
+  );
+  process.exit(0);
+}
+
+var cwd = process.cwd();
+var client = new BotVersionClient({ apiKey: apiKey, platformUrl: platformUrl });
+
+var detected = sdk.detectFrameworks(cwd);
+var projectType = sdk.classifyInstallation(detected.backend, detected.frontend);
+var routePatterns = scanner.scanFrontendRoutes(cwd);
+
+client
+  .registerRoutePatterns(routePatterns, {
+    source: "cli",
+    projectType: projectType,
+    detectedBackend: detected.backend,
+    detectedFrontend: detected.frontend,
+    sdkLanguage: "javascript",
+  })
+  .then(function () {
+    console.log(
+      "[BotVersion] Reported " +
+        routePatterns.length +
+        " frontend routes. projectType=" +
+        projectType,
+    );
+    process.exit(0);
+  })
+  .catch(function (err) {
+    console.error(
+      "[BotVersion] Failed to report frontend routes:",
+      err.message,
+    );
+    process.exit(0);
+  });

package/client.js

@@ -99,14 +99,20 @@ BotVersionClient.prototype.updateEndpoint = function (endpoint) {
   });
 };
 
-BotVersionClient.prototype.registerRoutePatterns = function (patterns) {
+BotVersionClient.prototype.registerRoutePatterns = function (
+  patterns,
+  classification,
+) {
   var self = this;
-  if (!patterns || patterns.length === 0) return Promise.resolve();
-
-  return self._post("/api/sdk/register-route-patterns", {
+  var body = {
     workspaceKey: self.apiKey,
-    patterns: patterns,
-  });
+    patterns: patterns || [],
+    classification: classification || null,
+  };
+  if ((!patterns || patterns.length === 0) && !classification) {
+    return Promise.resolve();
+  }
+  return self._post("/api/sdk/register-route-patterns", body);
 };
 
 /**

package/index.js

@@ -161,6 +161,91 @@ function runBackendScanner(detectedBackend, app, options, cwd) {
   return endpoints;
 }
 
+var FULLSTACK_FRAMEWORKS = ["nextjs", "nuxt", "sveltekit", "remix"];
+var BACKEND_ONLY_FRAMEWORKS = [
+  "express",
+  "fastify",
+  "nestjs",
+  "koa",
+  "hapi",
+  "adonis",
+];
+
+function classifyInstallation(detectedBackend, detectedFrontend) {
+  if (FULLSTACK_FRAMEWORKS.indexOf(detectedBackend) !== -1) {
+    return "fullstack";
+  }
+  if (
+    BACKEND_ONLY_FRAMEWORKS.indexOf(detectedBackend) !== -1 &&
+    detectedFrontend === "unknown"
+  ) {
+    return "backend-only";
+  }
+  if (detectedBackend === "unknown" && detectedFrontend !== "unknown") {
+    return "frontend-only";
+  }
+  if (detectedBackend === "unknown" && detectedFrontend === "unknown") {
+    return "unknown";
+  }
+  return "mixed";
+}
+
+// ── Run a full scan (backend endpoints + frontend routes) and report ────────
+// This used to run automatically 3 seconds after server start. Now it only
+// runs when the BotVersion dashboard's "Scan" button sends a request to this
+// SDK's internal scan-trigger endpoint (see interceptor.js). This fixes scans
+// not happening on serverless redeploys (Vercel, etc.) since there's no
+// "restart" event to hook into there.
+function runFullScan(
+  detectedBackend,
+  detectedFrontend,
+  app,
+  options,
+  cwd,
+  client,
+) {
+  var projectType = classifyInstallation(detectedBackend, detectedFrontend);
+
+  var result = {
+    endpointCount: 0,
+    routeCount: 0,
+    projectType: projectType,
+    detectedBackend: detectedBackend,
+    detectedFrontend: detectedFrontend,
+    sdkLanguage: "javascript",
+  };
+
+  var shouldScanBackend =
+    projectType === "fullstack" ||
+    projectType === "backend-only" ||
+    projectType === "mixed";
+
+  var shouldScanFrontend =
+    projectType === "fullstack" || projectType === "frontend-only";
+
+  if (shouldScanBackend) {
+    var endpoints = runBackendScanner(detectedBackend, app, options, cwd);
+    result.endpointCount = endpoints.length;
+
+    if (endpoints.length > 0) {
+      client.registerEndpoints(endpoints);
+    }
+  }
+
+  if (shouldScanFrontend) {
+    var routePatterns = scanner.scanFrontendRoutes(cwd);
+    result.routeCount = routePatterns.length;
+
+    if (routePatterns.length > 0) {
+      client.registerRoutePatterns(routePatterns).catch(function () {
+        // silently ignore — non-critical
+      });
+    }
+  }
+
+  return result;
+}
+
 // ── Attach the right runtime interceptor ─────────────────────────────────────
 function attachRuntimeInterceptor(detectedBackend, app, client, options) {
   switch (detectedBackend) {
@@ -169,6 +254,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
         exclude: options.exclude || [],
         apiPrefix: options.apiPrefix || null,
         debug: options.debug || false,
+        scanSecret: options.scanSecret,
+        onScanRequested: options.onScanRequested,
       });
       break;
 
@@ -177,6 +264,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
         exclude: options.exclude || [],
         apiPrefix: options.apiPrefix || "/api",
         debug: options.debug || false,
+        scanSecret: options.scanSecret,
+        onScanRequested: options.onScanRequested,
       });
       break;
 
@@ -186,6 +275,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
           exclude: options.exclude || [],
           apiPrefix: options.apiPrefix || null,
           debug: options.debug || false,
+          scanSecret: options.scanSecret,
+          onScanRequested: options.onScanRequested,
         });
       }
       break;
@@ -196,6 +287,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
           exclude: options.exclude || [],
           apiPrefix: options.apiPrefix || null,
           debug: options.debug || false,
+          scanSecret: options.scanSecret,
+          onScanRequested: options.onScanRequested,
         });
       }
       break;
@@ -206,6 +299,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
           exclude: options.exclude || [],
           apiPrefix: options.apiPrefix || null,
           debug: options.debug || false,
+          scanSecret: options.scanSecret,
+          onScanRequested: options.onScanRequested,
         });
       }
       break;
@@ -215,6 +310,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
         exclude: options.exclude || [],
         apiPrefix: options.apiPrefix || "/",
         debug: options.debug || false,
+        scanSecret: options.scanSecret,
+        onScanRequested: options.onScanRequested,
       });
       break;
 
@@ -223,6 +320,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
         exclude: options.exclude || [],
         apiPrefix: options.apiPrefix || "/",
         debug: options.debug || false,
+        scanSecret: options.scanSecret,
+        onScanRequested: options.onScanRequested,
       });
       break;
 
@@ -231,6 +330,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
         exclude: options.exclude || [],
         apiPrefix: options.apiPrefix || "/api",
         debug: options.debug || false,
+        scanSecret: options.scanSecret,
+        onScanRequested: options.onScanRequested,
       });
       break;
 
@@ -239,6 +340,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
         exclude: options.exclude || [],
         apiPrefix: options.apiPrefix || "/",
         debug: options.debug || false,
+        scanSecret: options.scanSecret,
+        onScanRequested: options.onScanRequested,
       });
       break;
 
@@ -247,6 +350,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
         exclude: options.exclude || [],
         apiPrefix: options.apiPrefix || "/",
         debug: options.debug || false,
+        scanSecret: options.scanSecret,
+        onScanRequested: options.onScanRequested,
       });
       break;
 
@@ -256,6 +361,8 @@ function attachRuntimeInterceptor(detectedBackend, app, client, options) {
         exclude: options.exclude || [],
         apiPrefix: options.apiPrefix || "/",
         debug: options.debug || false,
+        scanSecret: options.scanSecret,
+        onScanRequested: options.onScanRequested,
       });
       break;
   }
@@ -289,7 +396,22 @@ var BotVersion = {
       this._initialized = true;
       const savedOptions = global._botVersionOptions || {};
       const savedFramework = global._botVersionFramework || "nextjs";
-      attachRuntimeInterceptor(savedFramework, app, this._client, savedOptions);
+      const savedFrontend = global._botVersionFrontendFramework || "unknown";
+      const savedProjectType = classifyInstallation(
+        savedFramework,
+        savedFrontend,
+      );
+      if (
+        savedProjectType !== "frontend-only" &&
+        savedProjectType !== "unknown"
+      ) {
+        attachRuntimeInterceptor(
+          savedFramework,
+          app,
+          this._client,
+          savedOptions,
+        );
+      }
       return;
     }
 
@@ -319,33 +441,36 @@ var BotVersion = {
     var detectedFrontend = options.frontendFramework || detected.frontend;
 
     global._botVersionFramework = detectedBackend;
+    global._botVersionFrontendFramework = detectedFrontend;
+
+    var projectType = classifyInstallation(detectedBackend, detectedFrontend);
 
     if (debug) {
-      // Detected: detectedBackend, detectedFrontend
+      // Detected: detectedBackend, detectedFrontend, projectType
     }
 
-    // ── Attach runtime interceptor ───────────────────────────────────────────
-    attachRuntimeInterceptor(detectedBackend, app, self._client, options);
-
-    // ── Static scan ──────────────────────────────────────────────────────────
-    setTimeout(function () {
-      // Run backend scanner
-      var endpoints = runBackendScanner(detectedBackend, app, options, cwd);
-
-      // Send endpoints to platform
-      if (endpoints.length > 0) {
-        self._client.registerEndpoints(endpoints);
-      }
-
-      // Run frontend route scanner
-      var routePatterns = scanner.scanFrontendRoutes(cwd);
+    // ── Wire up the on-demand scan trigger ───────────────────────────────────
+    // Instead of scanning automatically on restart, the interceptor now
+    // listens for a special request from the BotVersion dashboard and runs
+    // the scan only when the user clicks "Scan" there.
+    options.scanSecret = options.apiKey;
+    options.onScanRequested = function () {
+      return runFullScan(
+        detectedBackend,
+        detectedFrontend,
+        app,
+        options,
+        cwd,
+        self._client,
+      );
+    };
 
-      if (routePatterns.length > 0) {
-        self._client.registerRoutePatterns(routePatterns).catch(function () {
-          // silently ignore — non-critical
-        });
-      }
-    }, 3000);
+    // ── Attach runtime interceptor ───────────────────────────────────────────
+    // Skip for frontend-only or unknown projects — there's no backend
+    // server on this process worth intercepting live traffic on.
+    if (projectType !== "frontend-only" && projectType !== "unknown") {
+      attachRuntimeInterceptor(detectedBackend, app, self._client, options);
+    }
   },
 
   getEndpoints: function () {
@@ -377,3 +502,5 @@ module.exports.default = BotVersion;
 module.exports.init = BotVersion.init;
 module.exports.getEndpoints = BotVersion.getEndpoints;
 module.exports.registerEndpoint = BotVersion.registerEndpoint;
+module.exports.detectFrameworks = detectFrameworks;
+module.exports.classifyInstallation = classifyInstallation;

package/interceptor.js

@@ -46,6 +46,39 @@ function attachInterceptor(app, client, options) {
 
   app.use(function botVersionInterceptor(req, res, next) {
     const path = req.path || req.url || "";
+
+    // ── Scan trigger from BotVersion dashboard ───────────────────────────
+    if (path === "/__botversion/scan" && req.method === "POST") {
+      const providedKey = req.headers["x-botversion-scan-key"] || "";
+      if (
+        options.scanSecret &&
+        providedKey === options.scanSecret &&
+        typeof options.onScanRequested === "function"
+      ) {
+        Promise.resolve(options.onScanRequested())
+          .then(function (result) {
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ success: true, result: result || null }));
+          })
+          .catch(function (err) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                success: false,
+                error: String((err && err.message) || err),
+              }),
+            );
+          });
+      } else {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ success: false, error: "Unauthorized" }));
+      }
+      return;
+    }
+
     const shouldIgnore = ignorePaths.some(function (p) {
       return path.startsWith(p);
     });
@@ -248,6 +281,40 @@ function attachNextJsInterceptor(client, options) {
         const path = req.url ? req.url.split("?")[0] : "";
         const method = req.method ? req.method.toUpperCase() : "";
 
+        // ── Scan trigger from BotVersion dashboard ───────────────────────
+        if (path === "/__botversion/scan" && method === "POST") {
+          const providedKey = req.headers["x-botversion-scan-key"] || "";
+          if (
+            options.scanSecret &&
+            providedKey === options.scanSecret &&
+            typeof options.onScanRequested === "function"
+          ) {
+            Promise.resolve(options.onScanRequested())
+              .then(function (result) {
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "application/json");
+                res.end(
+                  JSON.stringify({ success: true, result: result || null }),
+                );
+              })
+              .catch(function (err) {
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(
+                  JSON.stringify({
+                    success: false,
+                    error: String((err && err.message) || err),
+                  }),
+                );
+              });
+          } else {
+            res.statusCode = 401;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ success: false, error: "Unauthorized" }));
+          }
+          return; // handled directly — don't pass through to the app
+        }
+
         const shouldIgnore = (options.exclude || [])
           .concat([
             "/health",
@@ -464,6 +531,29 @@ function attachFastifyInterceptor(fastify, client, options) {
     const path = request.url ? request.url.split("?")[0] : "";
     const method = request.method ? request.method.toUpperCase() : "";
 
+    // ── Scan trigger from BotVersion dashboard ───────────────────────────
+    if (path === "/__botversion/scan" && method === "POST") {
+      const providedKey = request.headers["x-botversion-scan-key"] || "";
+      if (
+        options.scanSecret &&
+        providedKey === options.scanSecret &&
+        typeof options.onScanRequested === "function"
+      ) {
+        try {
+          const result = await options.onScanRequested();
+          reply.code(200).send({ success: true, result: result || null });
+        } catch (err) {
+          reply.code(500).send({
+            success: false,
+            error: String((err && err.message) || err),
+          });
+        }
+      } else {
+        reply.code(401).send({ success: false, error: "Unauthorized" });
+      }
+      return reply;
+    }
+
     const shouldIgnore = ignorePaths.some(function (p) {
       return path.startsWith(p);
     });
@@ -541,11 +631,37 @@ function attachKoaInterceptor(app, client, options) {
   // IMPORTANT: This interceptor must be added AFTER koa-bodyparser middleware
   // so that ctx.request.body is already populated when we read it.
   app.use(async function botVersionKoaInterceptor(ctx, next) {
-    await next();
-
     const path = ctx.path || "";
     const method = ctx.method ? ctx.method.toUpperCase() : "";
 
+    // ── Scan trigger from BotVersion dashboard ───────────────────────────
+    if (path === "/__botversion/scan" && method === "POST") {
+      const providedKey = ctx.headers["x-botversion-scan-key"] || "";
+      if (
+        options.scanSecret &&
+        providedKey === options.scanSecret &&
+        typeof options.onScanRequested === "function"
+      ) {
+        try {
+          const result = await options.onScanRequested();
+          ctx.status = 200;
+          ctx.body = { success: true, result: result || null };
+        } catch (err) {
+          ctx.status = 500;
+          ctx.body = {
+            success: false,
+            error: String((err && err.message) || err),
+          };
+        }
+      } else {
+        ctx.status = 401;
+        ctx.body = { success: false, error: "Unauthorized" };
+      }
+      return; // handled directly — don't call next()
+    }
+
+    await next();
+
     const shouldIgnore = ignorePaths.some(function (p) {
       return path.startsWith(p);
     });
@@ -605,6 +721,38 @@ function attachHapiInterceptor(server, client, options) {
     const path = request.path || "";
     const method = request.method ? request.method.toUpperCase() : "";
 
+    // ── Scan trigger from BotVersion dashboard ───────────────────────────
+    if (path === "/__botversion/scan" && method === "POST") {
+      const providedKey =
+        (request.headers && request.headers["x-botversion-scan-key"]) || "";
+      if (
+        options.scanSecret &&
+        providedKey === options.scanSecret &&
+        typeof options.onScanRequested === "function"
+      ) {
+        return Promise.resolve(options.onScanRequested())
+          .then(function (result) {
+            return h
+              .response({ success: true, result: result || null })
+              .code(200)
+              .takeover();
+          })
+          .catch(function (err) {
+            return h
+              .response({
+                success: false,
+                error: String((err && err.message) || err),
+              })
+              .code(500)
+              .takeover();
+          });
+      }
+      return h
+        .response({ success: false, error: "Unauthorized" })
+        .code(401)
+        .takeover();
+    }
+
     const shouldIgnore = ignorePaths.some(function (p) {
       return path.startsWith(p);
     });
@@ -659,6 +807,8 @@ function attachNestJsInterceptor(client, options) {
     exclude: (options || {}).exclude || [],
     apiPrefix: (options || {}).apiPrefix || "/",
     debug: (options || {}).debug || false,
+    scanSecret: (options || {}).scanSecret,
+    onScanRequested: (options || {}).onScanRequested,
   });
 }
 
@@ -671,6 +821,8 @@ function attachSvelteKitInterceptor(client, options) {
     exclude: (options || {}).exclude || [],
     apiPrefix: (options || {}).apiPrefix || "/",
     debug: (options || {}).debug || false,
+    scanSecret: (options || {}).scanSecret,
+    onScanRequested: (options || {}).onScanRequested,
   });
 }
 
@@ -679,6 +831,8 @@ function attachNuxtInterceptor(client, options) {
     exclude: (options || {}).exclude || [],
     apiPrefix: (options || {}).apiPrefix || "/api",
     debug: (options || {}).debug || false,
+    scanSecret: (options || {}).scanSecret,
+    onScanRequested: (options || {}).onScanRequested,
   });
 }
 
@@ -687,6 +841,8 @@ function attachRemixInterceptor(client, options) {
     exclude: (options || {}).exclude || [],
     apiPrefix: (options || {}).apiPrefix || "/",
     debug: (options || {}).debug || false,
+    scanSecret: (options || {}).scanSecret,
+    onScanRequested: (options || {}).onScanRequested,
   });
 }
 
@@ -695,6 +851,8 @@ function attachAdonisInterceptor(client, options) {
     exclude: (options || {}).exclude || [],
     apiPrefix: (options || {}).apiPrefix || "/",
     debug: (options || {}).debug || false,
+    scanSecret: (options || {}).scanSecret,
+    onScanRequested: (options || {}).onScanRequested,
   });
 }
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "botversion-sdk",
-  "version": "1.1.7",
+  "version": "2.0.0",
   "description": "BotVersion SDK — auto-detect and register your API endpoints",
   "main": "index.js",
   "bin": {
-    "botversion-sdk": "bin/init.js"
+    "botversion-scan-frontend": "./bin/scan-frontend.js"
   },
   "keywords": [
     "botversion",