botversion-sdk 1.0.4 → 1.0.6

package/cli/prompts.js

@@ -89,53 +89,53 @@ async function promptEntryPoint() {
   return filePath;
 }
 
-async function promptAuthLibrary() {
-  const choices = [
-    {
-      label: "next-auth v4",
-      value: { name: "next-auth", version: "v4", supported: true },
-    },
-    {
-      label: "next-auth v5 (Auth.js)",
-      value: { name: "next-auth", version: "v5", supported: true },
-    },
-    { label: "Clerk", value: { name: "clerk", supported: true } },
-    { label: "Supabase Auth", value: { name: "supabase", supported: true } },
-    { label: "Passport.js", value: { name: "passport", supported: true } },
-    { label: "JWT (jsonwebtoken)", value: { name: "jwt", supported: true } },
-    {
-      label: "express-session",
-      value: { name: "express-session", supported: true },
-    },
-    { label: "Other / Custom", value: { name: "custom", supported: false } },
-    { label: "No auth", value: { name: null, supported: false } },
-  ];
-
-  const choice = await askChoice(
-    "We couldn't detect your auth library. Which one are you using?",
-    choices,
-  );
-
-  return choice.value;
-}
-
-async function promptNextAuthConfigPath() {
-  console.log(
-    "\n  ⚠️  We couldn't find your authOptions location automatically.",
-  );
-  const filePath = await ask(
-    "  Enter the path to your authOptions file (e.g. lib/auth.ts): ",
-  );
-  return filePath;
-}
-
 async function promptForce(conflictFile) {
   console.log(`\n  ⚠️  File already exists: ${conflictFile}`);
   return confirm("  Overwrite it? (a backup will be created)", false);
 }
 
+const CONFIG_FILES = [
+  "next.config.js",
+  "next.config.ts",
+  "vite.config.js",
+  "vite.config.ts",
+  "webpack.config.js",
+  "webpack.config.ts",
+  "nuxt.config.js",
+  "nuxt.config.ts",
+];
+
 async function promptMissingListenCall(entryPoint) {
+  const path = require("path");
+  const entryFileName = path.basename(entryPoint || "");
+  const isConfigFile = CONFIG_FILES.includes(entryFileName);
+
   console.log(`\n  ⚠️  We couldn't find app.listen() in ${entryPoint}`);
+
+  if (isConfigFile) {
+    console.log(
+      `\n  ❌  "${entryFileName}" is a config file, not a server file.`,
+    );
+    console.log("      Appending server code here would break your project.");
+    console.log("  Options:");
+
+    const choices = [
+      {
+        label: "Enter the correct server file path manually",
+        value: "manual_path",
+      },
+      { label: "Skip — I'll add it manually", value: "skip" },
+    ];
+
+    const choice = await askChoice("How would you like to proceed?", choices);
+    if (choice.value === "manual_path") {
+      const filePath = await ask("  Enter file path: ");
+      return { action: "manual_path", filePath };
+    }
+    return { action: choice.value };
+  }
+
+  // Normal flow — entry point is not a config file
   console.log("  Options:");
   const choices = [
     { label: "Append to end of file", value: "append" },
@@ -158,8 +158,6 @@ module.exports = {
   confirm,
   promptMonorepoPackage,
   promptEntryPoint,
-  promptAuthLibrary,
-  promptNextAuthConfigPath,
   promptForce,
   promptMissingListenCall,
 };

package/cli/writer.js

@@ -30,6 +30,11 @@ function injectBeforeListen(filePath, codeToInject, appVarName) {
   const lines = content.split("\n");
   const listenRegex = new RegExp(`${appVarName}\\.listen\\s*\\(`);
 
+  // Check if BotVersion already exists in file
+  if (content.includes("botversion-sdk") || content.includes("BotVersion")) {
+    return { success: false, reason: "already_exists" };
+  }
+
   let listenLineIndex = -1;
   for (let i = 0; i < lines.length; i++) {
     if (listenRegex.test(lines[i])) {
@@ -39,7 +44,6 @@ function injectBeforeListen(filePath, codeToInject, appVarName) {
   }
 
   if (listenLineIndex === -1) {
-    // app.listen not found — append to end of file
     return {
       success: false,
       reason: "no_listen",
@@ -47,22 +51,64 @@ function injectBeforeListen(filePath, codeToInject, appVarName) {
     };
   }
 
-  // Check if BotVersion already exists in file
-  if (content.includes("botversion-sdk") || content.includes("BotVersion")) {
-    return { success: false, reason: "already_exists" };
-  }
+  // ── NEW: Check if app.listen() is inside if (require.main === module) ──
+  // If so, inject before that if block instead of inside it
+  let insertIndex = listenLineIndex;
+
+  for (let i = listenLineIndex; i >= 0; i--) {
+    const trimmed = lines[i].trim();
+
+    // Found if (require.main === module) block
+    if (
+      /if\s*\(\s*require\.main\s*===?\s*module\s*\)/.test(trimmed) ||
+      /if\s*\(\s*module\s*===?\s*require\.main\s*\)/.test(trimmed)
+    ) {
+      insertIndex = i;
+      // Keep walking back to check for 404/error handlers before this
+      continue;
+    }
 
-  // Insert the code block before app.listen()
-  const before = lines.slice(0, listenLineIndex);
-  const after = lines.slice(listenLineIndex);
+    // Found a 404 handler — inject before this instead
+    if (
+      /app\.use\s*\(\s*\(req,\s*res\)\s*=>/.test(trimmed) ||
+      /app\.use\s*\(\s*function\s*\(req,\s*res\)/.test(trimmed)
+    ) {
+      insertIndex = i;
+      continue;
+    }
 
-  const injectedLines = ["", ...codeToInject.split("\n"), ""];
+    // Found a global error handler — inject before this instead
+    if (
+      /app\.use\s*\(\s*\(err,\s*req,\s*res,\s*next\)/.test(trimmed) ||
+      /app\.use\s*\(\s*function\s*\(err,\s*req,\s*res,\s*next\)/.test(trimmed)
+    ) {
+      insertIndex = i;
+      continue;
+    }
 
+    // Stop walking back if we hit a top-level non-empty statement
+    if (
+      i < listenLineIndex &&
+      trimmed !== "" &&
+      trimmed !== "}" &&
+      trimmed !== "})" &&
+      trimmed !== "});" &&
+      lines[i].match(/^[^\s]/)
+    ) {
+      break;
+    }
+  }
+
+  // Insert the code block at the correct position
+  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, lineNumber: listenLineIndex + 1, backup };
+  return { success: true, lineNumber: insertIndex + 1, backup };
 }
 
 // ─── APPEND CODE TO END OF FILE ──────────────────────────────────────────────
@@ -175,30 +221,6 @@ function injectBeforeExport(filePath, codeToInject, appVarName) {
   return { success: true, backup };
 }
 
-// ─── MERGE INTO EXISTING MIDDLEWARE (Next.js) ────────────────────────────────
-
-function mergeIntoMiddleware(middlewarePath, authName) {
-  const content = fs.readFileSync(middlewarePath, "utf8");
-
-  // If BotVersion already there, skip
-  if (content.includes("botversion")) {
-    return { success: false, reason: "already_exists" };
-  }
-
-  // We don't auto-modify complex middleware — too risky
-  // Instead return a comment to add manually
-  const comment = `
-// BotVersion: No changes needed to middleware.
-// Your auth (${authName}) is handled in pages/api/botversion/chat.js
-`;
-
-  return {
-    success: true,
-    noModification: true,
-    note: comment.trim(),
-  };
-}
-
 // ─── WRITE SUMMARY OF ALL CHANGES ────────────────────────────────────────────
 
 function writeSummary(changes) {
@@ -212,30 +234,30 @@ function writeSummary(changes) {
 
   if (changes.modified && changes.modified.length > 0) {
     lines.push("  Modified files:");
-    changes.modified.forEach((f) => lines.push(`    ✏️  ${f}`));
+    changes.modified.forEach((f) => lines.push(`    [Modified]  ${f}`));
     lines.push("");
   }
 
   if (changes.created && changes.created.length > 0) {
     lines.push("  Created files:");
-    changes.created.forEach((f) => lines.push(`    ✅  ${f}`));
+    changes.created.forEach((f) => lines.push(`    [Created]   ${f}`));
     lines.push("");
   }
 
   if (changes.backups && changes.backups.length > 0) {
     lines.push("  Backups created:");
-    changes.backups.forEach((f) => lines.push(`    💾  ${f}`));
+    changes.backups.forEach((f) => lines.push(`    [Backup]    ${f}`));
     lines.push("");
   }
 
   if (changes.manual && changes.manual.length > 0) {
-    lines.push("  ⚠️  Manual steps needed:");
-    changes.manual.forEach((m) => lines.push(`    → ${m}`));
+    lines.push("  Manual steps needed:");
+    changes.manual.forEach((m) => lines.push(`    [Manual]    ${m}`));
     lines.push("");
   }
 
   lines.push("  Next: Restart your server and test the chat widget.");
-  lines.push("  Docs: https://docs.botversion.com");
+  lines.push("  Docs: https://botversion.com/docs");
   lines.push("");
 
   return lines.join("\n");
@@ -305,7 +327,6 @@ function injectIntoNextApp(filePath, content, scriptTag, backup) {
         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"
       />`;
 
@@ -393,7 +414,6 @@ function injectIntoNextLayout(filePath, content, scriptTag, backup) {
         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"
       />`;
 
@@ -415,6 +435,19 @@ function injectIntoNextLayout(filePath, content, scriptTag, backup) {
   return { success: true, backup };
 }
 
+function injectAtTop(filePath, codeToInject) {
+  const content = fs.readFileSync(filePath, "utf8");
+
+  if (content.includes("dotenv")) {
+    return { success: false, reason: "already_exists" };
+  }
+
+  const newContent = codeToInject + "\n" + content;
+  backupFile(filePath);
+  fs.writeFileSync(filePath, newContent, "utf8");
+  return { success: true };
+}
+
 // ─── HELPER: extract attribute value from script tag string ──────────────────
 
 function extractAttr(scriptTag, attr) {
@@ -422,14 +455,57 @@ function extractAttr(scriptTag, attr) {
   return match ? match[1] : "";
 }
 
+// ─── WRITE API KEY TO .ENV FILE ───────────────────────────────────────────────
+
+function writeEnvKey(cwd, key, value, framework) {
+  const envCandidates =
+    framework === "next"
+      ? [".env.local", ".env", ".env.development", ".env.development.local"]
+      : [".env", ".env.development", ".env.local"];
+
+  let envPath = null;
+
+  // Use existing .env file if found
+  for (const candidate of envCandidates) {
+    const fullPath = path.join(cwd, candidate);
+    if (fs.existsSync(fullPath)) {
+      envPath = fullPath;
+      break;
+    }
+  }
+
+  // No .env file found — create .env
+  if (!envPath) {
+    envPath = path.join(cwd, ".env");
+    fs.writeFileSync(envPath, "", "utf8");
+  }
+
+  const content = fs.readFileSync(envPath, "utf8");
+
+  // Key already exists — skip
+  if (content.includes(key)) {
+    return { success: false, reason: "already_exists", path: envPath };
+  }
+
+  // Append key to file
+  const newLine =
+    content === "" || content.endsWith("\n")
+      ? `${key}=${value}\n`
+      : `\n${key}=${value}\n`;
+
+  fs.appendFileSync(envPath, newLine, "utf8");
+  return { success: true, path: envPath };
+}
+
 module.exports = {
   writeFile,
   backupFile,
   injectBeforeListen,
   appendToFile,
   createFile,
-  mergeIntoMiddleware,
   writeSummary,
   injectBeforeExport,
   injectScriptTag,
+  injectAtTop,
+  writeEnvKey,
 };

package/client.js

@@ -11,16 +11,14 @@ const url = require("url");
  */
 function BotVersionClient(options) {
   this.apiKey = options.apiKey;
-  this.chatbotId = options.chatbotId;
-  this.platformUrl =
-    options.platformUrl || "https://chatbusiness-two.vercel.app";
+  this.platformUrl = options.platformUrl || "https://botversion.com";
   this.debug = options.debug || false;
   this.timeout = options.timeout || 30000;
 
   // Batch queue for endpoint registration
   this._queue = [];
   this._flushTimer = null;
-  this._flushDelay = options.flushDelay || 3000; // batch every 3 seconds
+  this._flushDelay = options.flushDelay || 3000;
   var self = this;
   process.on("beforeExit", function () {
     if (self._queue.length > 0) self._flush();
@@ -35,18 +33,8 @@ BotVersionClient.prototype.registerEndpoints = function (endpoints) {
 
   if (!endpoints || endpoints.length === 0) return Promise.resolve();
 
-  if (self.debug) {
-    console.log(
-      "[BotVersion SDK] Queuing",
-      endpoints.length,
-      "endpoints for registration",
-    );
-  }
-
-  // Add to queue
   self._queue = self._queue.concat(endpoints);
 
-  // Schedule flush
   if (!self._flushTimer) {
     self._flushTimer = setTimeout(function () {
       self._flush();
@@ -56,6 +44,24 @@ BotVersionClient.prototype.registerEndpoints = function (endpoints) {
   return Promise.resolve();
 };
 
+/**
+ * Register endpoints immediately — no batching
+ * Used during initial scan
+ */
+BotVersionClient.prototype.registerEndpointsNow = function (endpoints) {
+  var self = this;
+  if (!endpoints || endpoints.length === 0) return Promise.resolve();
+
+  return self
+    ._post("/api/sdk/register-endpoints", {
+      workspaceKey: self.apiKey,
+      endpoints: endpoints,
+    })
+    .then(function (data) {
+      return data;
+    });
+};
+
 /**
  * Flush the queue — send all batched endpoints at once
  */
@@ -68,35 +74,14 @@ BotVersionClient.prototype._flush = function () {
   var toSend = self._queue.slice();
   self._queue = [];
 
-  if (self.debug) {
-    console.log(
-      "[BotVersion SDK] Flushing",
-      toSend.length,
-      "endpoints to platform",
-    );
-  }
-
   self
     ._post("/api/sdk/register-endpoints", {
       workspaceKey: self.apiKey,
       endpoints: toSend,
     })
-    .then(function (data) {
-      if (self.debug) {
-        console.log(
-          "[BotVersion SDK] Registered",
-          data.succeeded,
-          "endpoints successfully",
-        );
-      }
-    })
+    .then(function (data) {})
     .catch(function (err) {
-      if (self.debug) {
-        console.warn(
-          "[BotVersion SDK] Failed to register endpoints:",
-          err.message,
-        );
-      }
+      console.error("[botversion] flush failed:", err.message);
     });
 };
 
@@ -116,6 +101,16 @@ BotVersionClient.prototype.updateEndpoint = function (endpoint) {
   });
 };
 
+BotVersionClient.prototype.registerRoutePatterns = function (patterns) {
+  var self = this;
+  if (!patterns || patterns.length === 0) return Promise.resolve();
+
+  return self._post("/api/sdk/register-route-patterns", {
+    workspaceKey: self.apiKey,
+    patterns: patterns,
+  });
+};
+
 /**
  * Get all registered endpoints for this workspace
  */
@@ -127,37 +122,6 @@ BotVersionClient.prototype.getEndpoints = function () {
   );
 };
 
-// Send user message to agent
-BotVersionClient.prototype.agentChat = function (payload) {
-  console.log("[BotVersion] agentChat payload:", JSON.stringify(payload));
-  console.log("[BotVersion] this.chatbotId:", this.chatbotId);
-  console.log("[BotVersion] this.apiKey:", this.apiKey);
-  return this._post(
-    "/api/chatbot/widget-chat",
-    Object.assign({
-      chatbotId: payload.chatbotId, // ← use payload, not this.chatbotId
-      publicKey: payload.publicKey,
-      query: payload.message,
-      previousChats: payload.conversationHistory,
-      pageContext: payload.pageContext,
-      userContext: payload.userContext,
-    }),
-  );
-};
-
-// Send API call result back to agent
-BotVersionClient.prototype.agentToolResult = function (
-  sessionToken,
-  result,
-  sessionData,
-) {
-  return this._post("/api/sdk/agent-tool-result", {
-    sessionToken,
-    sessionData: sessionData || null,
-    result,
-  });
-};
-
 /**
  * Make a POST request to the platform
  */
@@ -177,7 +141,7 @@ BotVersionClient.prototype._post = function (path, data) {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(body),
+        "Content-Length": String(Buffer.byteLength(body)),
         "X-BotVersion-SDK": "1.0.0",
       },
       timeout: self.timeout,