botversion-sdk 1.0.3 → 1.0.5

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,25 +234,25 @@ 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("");
   }
 
@@ -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,7 +11,6 @@ const url = require("url");
  */
 function BotVersionClient(options) {
   this.apiKey = options.apiKey;
-  this.chatbotId = options.chatbotId;
   this.platformUrl = options.platformUrl || "http://localhost:3000";
   this.debug = options.debug || false;
   this.timeout = options.timeout || 30000;
@@ -19,13 +18,26 @@ function BotVersionClient(options) {
   // Batch queue for endpoint registration
   this._queue = [];
   this._flushTimer = null;
-  this._flushDelay = options.flushDelay || 3000; // batch every 3 seconds
+  this._flushDelay = options.flushDelay || 3000;
+  this._ws = null;
+  this._executor = null;
   var self = this;
   process.on("beforeExit", function () {
     if (self._queue.length > 0) self._flush();
   });
 }
 
+/**
+ * Register the executor function — called by interceptor
+ * So WebSocket can forward calls to user's backend
+ */
+BotVersionClient.prototype.setExecutor = function (executorFn) {
+  this._executor = executorFn;
+  if (this.debug) {
+    console.log("[BotVersion SDK] ✅ Executor registered");
+  }
+};
+
 /**
  * Register multiple endpoints at once (batched)
  */
@@ -42,10 +54,8 @@ BotVersionClient.prototype.registerEndpoints = function (endpoints) {
     );
   }
 
-  // Add to queue
   self._queue = self._queue.concat(endpoints);
 
-  // Schedule flush
   if (!self._flushTimer) {
     self._flushTimer = setTimeout(function () {
       self._flush();
@@ -55,6 +65,37 @@ 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) {
+      if (self.debug) {
+        console.log(
+          "[BotVersion SDK] ✅ Registered",
+          endpoints.length,
+          "endpoints immediately",
+        );
+      }
+      return data;
+    })
+    .catch(function (err) {
+      console.warn(
+        "[BotVersion SDK] ⚠ Failed to register endpoints:",
+        err.message,
+      );
+    });
+};
+
 /**
  * Flush the queue — send all batched endpoints at once
  */
@@ -115,6 +156,33 @@ BotVersionClient.prototype.updateEndpoint = function (endpoint) {
   });
 };
 
+BotVersionClient.prototype.registerRoutePatterns = function (patterns) {
+  var self = this;
+  if (!patterns || patterns.length === 0) return Promise.resolve();
+
+  if (self.debug) {
+    console.log(
+      "[BotVersion SDK] Sending",
+      patterns.length,
+      "route patterns to platform",
+    );
+  }
+
+  return self
+    ._post("/api/sdk/register-route-patterns", {
+      workspaceKey: self.apiKey,
+      patterns: patterns,
+    })
+    .catch(function (err) {
+      if (self.debug) {
+        console.warn(
+          "[BotVersion SDK] Failed to register route patterns:",
+          err.message,
+        );
+      }
+    });
+};
+
 /**
  * Get all registered endpoints for this workspace
  */
@@ -126,37 +194,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
  */
@@ -176,7 +213,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,
@@ -287,4 +324,145 @@ BotVersionClient.prototype._get = function (path) {
   });
 };
 
+/**
+ * Connect to platform via WebSocket — establishes persistent connection
+ * Auto-reconnects every 5 seconds if connection drops
+ */
+BotVersionClient.prototype.connect = function () {
+  var self = this;
+  // Run in next tick so it doesn't block initialization
+  setImmediate(function () {
+    self._wsLoop();
+  });
+};
+
+BotVersionClient.prototype._wsLoop = function () {
+  var self = this;
+
+  var wsUrl = self.platformUrl
+    .replace("https://", "wss://")
+    .replace("http://", "ws://")
+    .replace(":3000", ":3001");
+  wsUrl = wsUrl + "?apiKey=" + encodeURIComponent(self.apiKey);
+
+  var WebSocket;
+  try {
+    WebSocket = require("ws");
+  } catch (e) {
+    console.error(
+      "[BotVersion SDK] ❌ 'ws' package not installed. Run: npm install ws",
+    );
+    return;
+  }
+
+  function attempt() {
+    var ws = new WebSocket(wsUrl);
+    self._ws = ws;
+
+    ws.on("open", function () {
+      if (self.debug) {
+        console.log("[BotVersion SDK] ✅ WebSocket connected to platform");
+      }
+      // Identify this SDK to the platform
+      ws.send(
+        JSON.stringify({
+          type: "IDENTIFY",
+          apiKey: self.apiKey,
+        }),
+      );
+    });
+
+    ws.on("message", function (data) {
+      try {
+        var msg = JSON.parse(data.toString());
+
+        if (msg.type === "EXECUTE_CALL") {
+          self._handleExecuteCall(msg);
+        }
+      } catch (e) {
+        if (self.debug) {
+          console.warn("[BotVersion SDK] ⚠ Error parsing message:", e.message);
+        }
+      }
+    });
+
+    ws.on("error", function (err) {
+      if (self.debug) {
+        console.warn("[BotVersion SDK] ⚠ WebSocket error:", err.message);
+      }
+    });
+
+    ws.on("close", function () {
+      if (self.debug) {
+        console.log(
+          "[BotVersion SDK] WebSocket closed — reconnecting in 5s...",
+        );
+      }
+      self._ws = null;
+      // Auto-reconnect after 5 seconds
+      setTimeout(attempt, 5000);
+    });
+  }
+
+  attempt();
+};
+
+BotVersionClient.prototype._handleExecuteCall = function (data) {
+  var self = this;
+
+  var callId = data.callId;
+  var method = data.method;
+  var path = data.path;
+  var body = data.body;
+  var cookies = data.cookies || "";
+  var headers = data.headers || {};
+  var baseUrl = data.baseUrl || "http://127.0.0.1:3000";
+
+  if (!self._executor) {
+    self._sendCallResult(callId, {
+      status: 500,
+      ok: false,
+      data: { error: "No executor registered" },
+    });
+    return;
+  }
+
+  self
+    ._executor(method, path, body, cookies, headers, baseUrl)
+    .then(function (result) {
+      self._sendCallResult(callId, result);
+    })
+    .catch(function (err) {
+      self._sendCallResult(callId, {
+        status: 500,
+        ok: false,
+        data: { error: err.message },
+      });
+    });
+};
+
+BotVersionClient.prototype._sendCallResult = function (callId, result) {
+  var self = this;
+  try {
+    if (self._ws && self._ws.readyState === 1) {
+      // 1 = OPEN
+      self._ws.send(
+        JSON.stringify({
+          type: "CALL_RESULT",
+          callId: callId,
+          result: result,
+        }),
+      );
+    } else if (self.debug) {
+      console.warn(
+        "[BotVersion SDK] ⚠ WebSocket not open — could not send CALL_RESULT",
+      );
+    }
+  } catch (e) {
+    if (self.debug) {
+      console.warn("[BotVersion SDK] ⚠ Failed to send CALL_RESULT:", e.message);
+    }
+  }
+};
+
 module.exports = BotVersionClient;