botversion-sdk 1.0.0 → 1.0.1

package/bin/init.js

@@ -29,6 +29,9 @@ function log(msg) {
 function info(msg) {
   console.log(`${c.cyan}  ℹ${c.reset}  ${msg}`);
 }
+function info2(msg) {
+  console.log(`${c.cyan}  ℹ${c.reset}  ${msg}`);
+}
 function success(msg) {
   console.log(`${c.green}  ✔${c.reset}  ${msg}`);
 }
@@ -106,10 +109,10 @@ async function main() {
   }
 
   // Run full detection
-  const info2 = detector.detect(workingDir);
+  const detected = detector.detect(workingDir);
 
   // ── Check if already initialized ─────────────────────────────────────────
-  if (info2.alreadyInitialized && !args.force) {
+  if (detected.alreadyInitialized && !args.force) {
     warn("BotVersion SDK is already initialized in this project.");
     log(`\n  To reinitialize, run with --force flag:\n`);
     log(`  npx botversion-sdk init --key ${args.key} --force\n`);
@@ -119,68 +122,71 @@ async function main() {
   // ── Framework check ───────────────────────────────────────────────────────
   step("Detecting framework...");
 
-  if (!info2.framework.name) {
+  if (!detected.framework.name) {
     error("Could not detect a supported framework.");
     log(`\n  Supported: Express.js, Next.js`);
     log(`  Make sure you have them listed in package.json\n`);
     process.exit(1);
   }
 
-  if (!info2.framework.supported) {
+  if (!detected.framework.supported) {
     warn(
-      `Detected: ${info2.framework.name} (not yet supported for auto-setup)`,
+      `Detected: ${detected.framework.name} (not yet supported for auto-setup)`,
     );
     log("");
-    log(generator.generateManualInstructions(info2.framework.name, args.key));
+    log(
+      generator.generateManualInstructions(detected.framework.name, args.key),
+    );
     process.exit(0);
   }
 
-  success(`Framework: ${info2.framework.name}`);
+  success(`Framework: ${detected.framework.name}`);
   info(
-    `Module system: ${info2.moduleSystem === "esm" ? "ES Modules" : "CommonJS"}`,
+    `Module system: ${detected.moduleSystem === "esm" ? "ES Modules" : "CommonJS"}`,
   );
-  info(`Language: ${info2.isTypeScript ? "TypeScript" : "JavaScript"}`);
+  info(`Language: ${detected.isTypeScript ? "TypeScript" : "JavaScript"}`);
 
   // ── Auth detection ────────────────────────────────────────────────────────
   step("Detecting auth library...");
 
-  let auth = info2.auth;
+  let auth = detected.auth;
 
   if (!auth.name) {
     warn("No auth library detected automatically.");
     auth = await prompts.promptAuthLibrary();
-    info2.auth = auth;
+    detected.auth = auth;
   } else if (!auth.supported) {
     warn(`Detected auth: ${auth.name} (not yet supported for auto-setup)`);
     warn("Will set up without user context — you can add it manually later.");
     const proceed = await prompts.confirm("Continue without auth?", true);
     if (!proceed) process.exit(0);
     auth = { name: auth.name, supported: false };
-    info2.auth = auth;
+    detected.auth = auth;
   } else {
     const versionLabel = auth.version ? ` (${auth.version})` : "";
     success(`Auth: ${auth.name}${versionLabel}`);
   }
 
   // ── Package manager ───────────────────────────────────────────────────────
-  info(`Package manager: ${info2.packageManager}`);
+  info(`Package manager: ${detected.packageManager}`);
 
   // ─────────────────────────────────────────────────────────────────────────
   // FRAMEWORK: EXPRESS
   // ─────────────────────────────────────────────────────────────────────────
-  if (info2.framework.name === "express") {
-    await setupExpress(info2, args, changes);
+  if (detected.framework.name === "express") {
+    await setupExpress(detected, args, changes);
   }
 
   // ─────────────────────────────────────────────────────────────────────────
   // FRAMEWORK: NEXT.JS
   // ─────────────────────────────────────────────────────────────────────────
-  else if (info2.framework.name === "next") {
-    await setupNextJs(info2, args, changes);
+  else if (detected.framework.name === "next") {
+    await setupNextJs(detected, args, changes);
   }
 
   // ── Write API key to .env / .env.local ────────────────────────────────────
-  const envFileName = info2.framework.name === "next" ? ".env.local" : ".env";
+  const envFileName =
+    detected.framework.name === "next" ? ".env.local" : ".env";
   const envPath = path.join(workingDir, envFileName);
   const envLine = `BOTVERSION_API_KEY=${args.key}`;
   const envContent = fs.existsSync(envPath)
@@ -216,16 +222,16 @@ async function main() {
 
 // ─── EXPRESS SETUP ────────────────────────────────────────────────────────────
 
-async function setupExpress(info, args, changes) {
+async function setupExpress(detected, args, changes) {
   step("Setting up Express...");
 
   // Find entry point
-  let entryPoint = info.entryPoint;
+  let entryPoint = detected.entryPoint;
 
   if (!entryPoint || !fs.existsSync(entryPoint)) {
     warn("Could not find your server entry point automatically.");
     const manualPath = await prompts.promptEntryPoint();
-    entryPoint = path.resolve(info.cwd, manualPath);
+    entryPoint = path.resolve(detected.cwd, manualPath);
 
     if (!fs.existsSync(entryPoint)) {
       error(`File not found: ${entryPoint}`);
@@ -233,40 +239,65 @@ async function setupExpress(info, args, changes) {
     }
   }
 
-  success(`Entry point: ${path.relative(info.cwd, entryPoint)}`);
+  success(`Entry point: ${path.relative(detected.cwd, entryPoint)}`);
 
   // Generate the init code
-  const generated = generator.generateExpressInit(info, args.key);
+  const generated = generator.generateExpressInit(detected, args.key);
 
   // Find app.listen() and inject before it
   const listenCall = detector.findListenCall(entryPoint);
 
-  if (listenCall) {
-    info(`Found app.listen() at line ${listenCall.lineNumber}`);
+  // PATTERN 2: Separate app file with module.exports = app
+  if (detected.appFile) {
+    info(`Found app file: ${path.relative(detected.cwd, detected.appFile)}`);
+    const generated2 = generator.generateExpressInit(detected, args.key);
+    const result = writer.injectBeforeExport(
+      detected.appFile,
+      generated2.initBlock,
+    );
+
+    if (result.success) {
+      success(
+        `Injected BotVersion.init() into ${path.relative(detected.cwd, detected.appFile)}`,
+      );
+      changes.modified.push(path.relative(detected.cwd, detected.appFile));
+    } else if (result.reason === "already_exists") {
+      warn("BotVersion already found — skipping injection.");
+    }
+  }
+
+  // PATTERN 1 & 3 & 4: app.listen() or server.listen() in entry file
+  else if (
+    detected.listenCall ||
+    detected.listenInsideCallback ||
+    detected.createServer
+  ) {
     const result = writer.injectBeforeListen(entryPoint, generated.initBlock);
 
     if (result.success) {
       success(`Injected BotVersion.init() before app.listen()`);
-      changes.modified.push(path.relative(info.cwd, entryPoint));
+      changes.modified.push(path.relative(detected.cwd, entryPoint));
       if (result.backup) changes.backups.push(result.backup);
     } else if (result.reason === "already_exists") {
       warn("BotVersion already found in entry point — skipping injection.");
     }
-  } else {
-    // app.listen() not found
-    warn("Could not find app.listen() in entry point.");
+  }
+
+  // LAST RESORT: ask the user
+  else {
+    warn("Could not find the right place to inject automatically.");
     const response = await prompts.promptMissingListenCall(
-      path.relative(info.cwd, entryPoint),
+      path.relative(detected.cwd, entryPoint),
     );
 
     if (response.action === "append") {
       const result = writer.appendToFile(entryPoint, generated.initBlock);
       if (result.success) {
         success("Appended BotVersion setup to end of file.");
-        changes.modified.push(path.relative(info.cwd, entryPoint));
+        changes.modified.push(path.relative(detected.cwd, entryPoint));
       }
     } else if (response.action === "manual_path") {
-      const altPath = path.resolve(info.cwd, response.filePath);
+      const altPath = path.resolve(detected.cwd, response.filePath);
       if (fs.existsSync(altPath)) {
         const result = writer.injectBeforeListen(altPath, generated.initBlock);
         if (result.success) {
@@ -280,7 +311,6 @@ async function setupExpress(info, args, changes) {
         );
       }
     } else {
-      // skip — print manual instructions
       changes.manual.push(
         `Add this to your server file before app.listen():\n\n${generated.initBlock}`,
       );
@@ -291,10 +321,10 @@ async function setupExpress(info, args, changes) {
 
 // ─── NEXT.JS SETUP ────────────────────────────────────────────────────────────
 
-async function setupNextJs(info, args, changes) {
+async function setupNextJs(detected, args, changes) {
   step("Setting up Next.js...");
 
-  const nextInfo = info.next;
+  const nextInfo = detected.next;
   const baseDir = nextInfo.baseDir;
 
   info2(
@@ -302,20 +332,23 @@ async function setupNextJs(info, args, changes) {
   );
 
   // ── next-auth config location ─────────────────────────────────────────────
-  if (info.auth.name === "next-auth" && !info.nextAuthConfig) {
+  if (detected.auth.name === "next-auth" && !detected.nextAuthConfig) {
     warn("Could not find authOptions location automatically.");
     const configPath = await prompts.promptNextAuthConfigPath();
-    info.nextAuthConfig = {
-      path: path.resolve(info.cwd, configPath),
+    detected.nextAuthConfig = {
+      path: path.resolve(detected.cwd, configPath),
       relativePath: configPath,
     };
   }
 
   // ── 1. Create instrumentation.js ──────────────────────────────────────────
-  const instrExt = info.generateTs ? ".ts" : ".js";
-  const instrFile = path.join(info.cwd, `instrumentation${instrExt}`);
+  const instrExt = detected.generateTs ? ".ts" : ".js";
+  const instrFile = path.join(detected.cwd, `instrumentation${instrExt}`);
 
-  const instrContent = generator.generateInstrumentationFile(info, args.key);
+  const instrContent = generator.generateInstrumentationFile(
+    detected,
+    args.key,
+  );
   const instrResult = writer.createFile(instrFile, instrContent, args.force);
 
   if (instrResult.success) {
@@ -333,15 +366,15 @@ async function setupNextJs(info, args, changes) {
   }
 
   // ── 2. Patch next.config.js ───────────────────────────────────────────────
-  const configPatch = generator.generateNextConfigPatch(info.cwd);
+  const configPatch = generator.generateNextConfigPatch(detected.cwd);
 
   if (configPatch) {
     if (configPatch.alreadyPatched) {
       info("next.config.js already has instrumentationHook — skipping.");
     } else {
       fs.writeFileSync(configPatch.path, configPatch.content, "utf8");
-      success(`Updated ${path.relative(info.cwd, configPatch.path)}`);
-      changes.modified.push(path.relative(info.cwd, configPatch.path));
+      success(`Updated ${path.relative(detected.cwd, configPatch.path)}`);
+      changes.modified.push(path.relative(detected.cwd, configPatch.path));
     }
   } else {
     warn("Could not find next.config.js — please add this manually:");
@@ -356,7 +389,7 @@ async function setupNextJs(info, args, changes) {
     const chatDir = path.join(pagesBase, "api", "botversion");
     const chatFile = path.join(chatDir, `chat${instrExt}`);
 
-    const chatContent = generator.generateNextPagesChatRoute(info);
+    const chatContent = generator.generateNextPagesChatRoute(detected);
     const chatResult = writer.createFile(chatFile, chatContent, args.force);
 
     const relPath = `${nextInfo.srcDir ? "src/" : ""}pages/api/botversion/chat${instrExt}`;
@@ -382,7 +415,7 @@ async function setupNextJs(info, args, changes) {
     const chatDir = path.join(appBase, "api", "botversion", "chat");
     const chatFile = path.join(chatDir, `route${instrExt}`);
 
-    const chatContent = generator.generateNextAppChatRoute(info);
+    const chatContent = generator.generateNextAppChatRoute(detected);
     const relPath = `${nextInfo.srcDir ? "src/" : ""}app/api/botversion/chat/route${instrExt}`;
 
     const chatResult = writer.createFile(chatFile, chatContent, args.force);
@@ -403,11 +436,6 @@ async function setupNextJs(info, args, changes) {
   }
 }
 
-// ─── helper used inside setupNextJs ──────────────────────────────────────────
-function info2(msg) {
-  console.log(`${c.cyan}  ℹ${c.reset}  ${msg}`);
-}
-
 // ─── RUN ──────────────────────────────────────────────────────────────────────
 
 main().catch((err) => {

package/cli/detector.js

@@ -269,6 +269,43 @@ function findListenCall(filePath) {
   return null;
 }
 
+function findModuleExportsApp(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (/module\.exports\s*=\s*app/.test(lines[i])) {
+      return { lineIndex: i, lineNumber: i + 1, content: lines[i] };
+    }
+  }
+  return null;
+}
+
+function findListenInsideCallback(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (/app\.listen\s*\(/.test(lines[i])) {
+      // Check if it's inside a callback (indented or preceded by .then)
+      const indentation = lines[i].match(/^(\s*)/)[1].length;
+      if (indentation > 0) {
+        return { lineIndex: i, lineNumber: i + 1, insideCallback: true };
+      }
+    }
+  }
+  return null;
+}
+
+function findCreateServer(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (/createServer\s*\(\s*app\s*\)/.test(lines[i])) {
+      return { lineIndex: i, lineNumber: i + 1, content: lines[i] };
+    }
+  }
+  return null;
+}
+
 // ─── AUTH DETECTION ──────────────────────────────────────────────────────────
 
 const AUTH_LIBS = [
@@ -481,6 +518,16 @@ function findFileWithContent(dir, searchString, extensions, maxDepth) {
   return walk(dir, 0);
 }
 
+function detectAppVarName(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const match = content.match(/(?:const|let|var)\s+(\w+)\s*=\s*express\s*\(/);
+    return match ? match[1] : "app";
+  } catch (e) {
+    return "app";
+  }
+}
+
 // ─── MAIN DETECT FUNCTION ────────────────────────────────────────────────────
 
 function detect(cwd) {
@@ -524,6 +571,29 @@ function detect(cwd) {
     result.entryPoint = detectExpressEntry(cwd, pkg);
     if (result.entryPoint) {
       result.listenCall = findListenCall(result.entryPoint);
+      result.moduleExportsApp = findModuleExportsApp(result.entryPoint);
+      result.listenInsideCallback = findListenInsideCallback(result.entryPoint);
+      result.createServer = findCreateServer(result.entryPoint);
+      result.appVarName = detectAppVarName(result.entryPoint);
+
+      // Also check for app file separately (pattern 2)
+      const appFileCandidates = [
+        "src/app.js",
+        "src/app.ts",
+        "app.js",
+        "app.ts",
+      ];
+      for (const candidate of appFileCandidates) {
+        const fullPath = path.join(cwd, candidate);
+        if (fs.existsSync(fullPath) && fullPath !== result.entryPoint) {
+          const exportCall = findModuleExportsApp(fullPath);
+          if (exportCall) {
+            result.appFile = fullPath;
+            result.appFileExport = exportCall;
+            break;
+          }
+        }
+      }
     }
   }
 
@@ -555,4 +625,8 @@ module.exports = {
   detectExistingBotVersion,
   findFileWithContent,
   findListenCall,
+  findModuleExportsApp,
+  findListenInsideCallback,
+  findCreateServer,
+  detectAppVarName,
 };

package/cli/generator.js

@@ -1,15 +1,18 @@
 // botversion-sdk/cli/generator.js
-
 "use strict";
 
 const path = require("path");
+const fs = require("fs");
 
-// ─── EXPRESS CODE GENERATION ─────────────────────────────────────────────────
+// ─── EXPRESS CODE GENERATION ──────────────────────────────────────────────────
 
 function generateExpressInit(info, apiKey) {
   const { moduleSystem, isTypeScript, auth } = info;
   const isESM = moduleSystem === "esm";
 
+  // FIX #2: Detect the actual app variable name used in the entry file
+  const appVarName = info.appVarName || "app";
+
   const importLine = isESM
     ? `import BotVersion from 'botversion-sdk';`
     : `const BotVersion = require('botversion-sdk');`;
@@ -20,11 +23,11 @@ function generateExpressInit(info, apiKey) {
 // BotVersion AI Agent — auto-added by botversion-sdk init
 ${importLine}
 
-BotVersion.init(app, {
-  apiKey: '${apiKey}',${getUserContext.option}
+BotVersion.init(${appVarName}, {
+  apiKey: process.env.BOTVERSION_API_KEY,
 });
 
-app.post('/api/botversion/chat', (req, res) => {
+${appVarName}.post('/api/botversion/chat', (req, res) => {
   BotVersion.chat(req, res);
 });
 `;
@@ -96,30 +99,54 @@ function generateExpressUserContext(auth) {
   }
 }
 
-// ─── NEXT.JS LIB FILE GENERATION ─────────────────────────────────────────────
+// ─── NEXT.JS INSTRUMENTATION FILE ────────────────────────────────────────────
+
 function generateInstrumentationFile(info, apiKey) {
-  const pagesDir = info.next?.srcDir
-    ? `path.join(process.cwd(), 'src', 'pages')`
-    : `path.join(process.cwd(), 'pages')`;
+  const { next, moduleSystem } = info;
+
+  // FIX #3: Only include pagesDir if Pages Router actually exists
+  // FIX #8: Use dynamic import instead of require() to support ESM projects
+  const hasPagesRouter = next?.pagesRouter;
+  const hasAppRouter = next?.appRouter;
+
+  const pagesDirLine = hasPagesRouter
+    ? next?.srcDir
+      ? `path.join(process.cwd(), 'src', 'pages')`
+      : `path.join(process.cwd(), 'pages')`
+    : null;
+
+  const appDirLine = hasAppRouter
+    ? next?.srcDir
+      ? `path.join(process.cwd(), 'src', 'app')`
+      : `path.join(process.cwd(), 'app')`
+    : null;
+
+  // Build pagesDir option only if Pages Router exists
+  const pagesDirOption = pagesDirLine
+    ? `\n      pagesDir: ${pagesDirLine},`
+    : "";
+
+  // Build appDir option only if App Router exists (for future scanner support)
+  const appDirOption = appDirLine ? `\n      appDir: ${appDirLine},` : "";
 
   return `export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
-    const BotVersion = require('botversion-sdk');
-    const path = require('path');
+    // FIX: Use dynamic import to support both CJS and ESM projects
+    const { default: BotVersion } = await import('botversion-sdk');
+    const { default: path } = await import('path');
+
     BotVersion.init({
-      apiKey: process.env.BOTVERSION_API_KEY,
-      pagesDir: ${pagesDir},
+      apiKey: process.env.BOTVERSION_API_KEY,${pagesDirOption}${appDirOption}
     });
   }
 }
 `;
 }
 
-// ─── NEXT.JS CHAT ROUTE — PAGES ROUTER ──────────────────────────────────────
+// ─── NEXT.JS CHAT ROUTE — PAGES ROUTER ───────────────────────────────────────
 
 function generateNextPagesChatRoute(info) {
-  const { auth, isTypeScript, nextAuthConfig, moduleSystem } = info;
-  const isESM = moduleSystem === "esm";
+  const { auth } = info;
 
   switch (auth.name) {
     case "next-auth":
@@ -137,18 +164,10 @@ function generateNextAuthPagesRoute(info) {
   const { nextAuthConfig, auth, next, generateTs } = info;
   const isV5 = auth.version === "v5";
 
-  // The chat file lives at: {base}/pages/api/botversion/chat.js
-  // We need the import path relative to THAT file
-  const chatFileDir = path.join(
-    next.baseDir, // handles src/ automatically
-    "pages",
-    "api",
-    "botversion",
-  );
+  // Compute correct relative import path for authOptions
+  const chatFileDir = path.join(next.baseDir, "pages", "api", "botversion");
 
-  // Determine the import path for authOptions
   let authImportPath = "../auth/[...nextauth]";
-
   if (nextAuthConfig) {
     const rel = path
       .relative(chatFileDir, nextAuthConfig.path)
@@ -168,8 +187,7 @@ export default BotVersion.nextHandler({
 `;
   }
 
-  // generateTs: user has allowJs:false — generate proper TypeScript
-  if (info.generateTs) {
+  if (generateTs) {
     return `import BotVersion from 'botversion-sdk';
 import { getServerSession } from 'next-auth';
 import { authOptions } from '${authImportPath}';
@@ -184,7 +202,6 @@ export default BotVersion.nextHandler({
 `;
   }
 
-  // Plain JS — works for all standard Next.js projects
   return `import BotVersion from 'botversion-sdk';
 import { getServerSession } from 'next-auth';
 import { authOptions } from '${authImportPath}';
@@ -233,9 +250,7 @@ function generateAuthlessPagesRoute(info) {
 
   const comment =
     auth.name && !auth.supported
-      ? `// TODO: We detected ${auth.name} but don't have automatic support yet.
-// Add your own getSession below to pass user context to the agent.
-// See: https://docs.botversion.com/auth\n`
+      ? `// TODO: We detected ${auth.name} but don't have automatic support yet.\n// Add your own getSession below to pass user context to the agent.\n// See: https://docs.botversion.com/auth\n`
       : "";
 
   if (isTypeScript) {
@@ -269,7 +284,7 @@ export default BotVersion.nextHandler({
 // ─── NEXT.JS CHAT ROUTE — APP ROUTER ─────────────────────────────────────────
 
 function generateNextAppChatRoute(info) {
-  const { auth, isTypeScript } = info;
+  const { auth } = info;
 
   switch (auth.name) {
     case "next-auth":
@@ -284,118 +299,282 @@ function generateNextAppChatRoute(info) {
 }
 
 function generateNextAuthAppRoute(info) {
-  const { auth, isTypeScript } = info;
+  const { auth, isTypeScript, next, nextAuthConfig } = info;
   const isV5 = auth.version === "v5";
 
+  // FIX #5: Compute the correct relative import path instead of hardcoding @/lib/auth
+  const chatFileDir = path.join(
+    next.baseDir,
+    "app",
+    "api",
+    "botversion",
+    "chat",
+  );
+
+  let authImportPath = "@/lib/auth"; // fallback alias
+  if (nextAuthConfig) {
+    const rel = path
+      .relative(chatFileDir, nextAuthConfig.path)
+      .replace(/\\/g, "/")
+      .replace(/\.(js|ts)$/, "");
+    authImportPath = rel.startsWith(".") ? rel : "./" + rel;
+  }
+
+  const typeAnnotation = isTypeScript ? ": NextRequest" : "";
+  const nextRequestImport = isTypeScript
+    ? `import { NextRequest, NextResponse } from 'next/server';\n`
+    : `import { NextResponse } from 'next/server';\n`;
+
   if (isV5) {
     return `import BotVersion from 'botversion-sdk';
-import { auth } from '@/auth';
-import { NextRequest } from 'next/server';
-
-export async function POST(req${isTypeScript ? ": NextRequest" : ""}) {
-  const session = await auth();
-  const body = await req.json();
+import { auth } from '${authImportPath}';
+${nextRequestImport}
+// FIX #1: appRouterHandler is implemented here directly since App Router
+// does not support the nextHandler() Pages pattern
+export async function POST(req${typeAnnotation}) {
+  try {
+    const session = await auth();
+    const body = await req.json();
+
+    const result = await BotVersion.nextHandler({
+      apiKey: process.env.BOTVERSION_API_KEY,
+      getSession: async () => session,
+    })({ ...req, body }, { json: (d) => d, status: () => ({ json: (d) => d }) });
 
-  return BotVersion.appRouterHandler({
-    body,
-    userContext: {
-      userId: session?.user?.id,
-      email: session?.user?.email,
-      name: session?.user?.name,
-    },
-  });
+    return NextResponse.json(result);
+  } catch (err) {
+    console.error('[BotVersion] App Router handler error:', err);
+    return NextResponse.json({ error: 'Agent error' }, { status: 500 });
+  }
 }
 `;
   }
 
   return `import BotVersion from 'botversion-sdk';
 import { getServerSession } from 'next-auth';
-import { authOptions } from '@/lib/auth';
-import { NextRequest } from 'next/server';
-
-export async function POST(req${isTypeScript ? ": NextRequest" : ""}) {
-  const session = await getServerSession(authOptions);
-  const body = await req.json();
+import { authOptions } from '${authImportPath}';
+${nextRequestImport}
+export async function POST(req${typeAnnotation}) {
+  try {
+    const session = await getServerSession(authOptions);
+    const body = await req.json();
 
-  return BotVersion.appRouterHandler({
-    body,
-    userContext: {
+    const userContext = {
       userId: session?.user?.id,
       email: session?.user?.email,
       name: session?.user?.name,
-    },
-  });
+    };
+
+    // Forward to BotVersion platform directly
+    const response = await fetch(\`\${process.env.BOTVERSION_PLATFORM_URL || 'https://chatbusiness-two.vercel.app'}/api/chatbot/widget-chat\`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chatbotId: body.chatbotId,
+        publicKey: body.publicKey,
+        query: body.message,
+        previousChats: body.conversationHistory || [],
+        pageContext: body.pageContext || {},
+        userContext,
+      }),
+    });
+
+    const data = await response.json();
+    return NextResponse.json(data);
+  } catch (err) {
+    console.error('[BotVersion] App Router handler error:', err);
+    return NextResponse.json({ error: 'Agent error' }, { status: 500 });
+  }
 }
 `;
 }
 
 function generateClerkAppRoute(info) {
-  const { auth, isTypeScript } = info;
+  const { isTypeScript } = info;
+  const typeAnnotation = isTypeScript ? ": NextRequest" : "";
+  const nextRequestImport = isTypeScript
+    ? `import { NextRequest, NextResponse } from 'next/server';\n`
+    : `import { NextResponse } from 'next/server';\n`;
 
   return `import BotVersion from 'botversion-sdk';
 import { auth } from '@clerk/nextjs/server';
-import { NextRequest } from 'next/server';
-
-export async function POST(req${isTypeScript ? ": NextRequest" : ""}) {
-  const { userId } = auth();
-  const body = await req.json();
+${nextRequestImport}
+export async function POST(req${typeAnnotation}) {
+  try {
+    // FIX #6: auth() is async in Clerk v5+ — must be awaited
+    const { userId } = await auth();
+    const body = await req.json();
+
+    const response = await fetch(\`\${process.env.BOTVERSION_PLATFORM_URL || 'https://chatbusiness-two.vercel.app'}/api/chatbot/widget-chat\`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chatbotId: body.chatbotId,
+        publicKey: body.publicKey,
+        query: body.message,
+        previousChats: body.conversationHistory || [],
+        pageContext: body.pageContext || {},
+        userContext: { userId },
+      }),
+    });
 
-  return BotVersion.appRouterHandler({
-    body,
-    userContext: { userId },
-  });
+    const data = await response.json();
+    return NextResponse.json(data);
+  } catch (err) {
+    console.error('[BotVersion] App Router handler error:', err);
+    return NextResponse.json({ error: 'Agent error' }, { status: 500 });
+  }
 }
 `;
 }
 
 function generateSupabaseAppRoute(info) {
   const { isTypeScript } = info;
+  const typeAnnotation = isTypeScript ? ": NextRequest" : "";
+  const nextRequestImport = isTypeScript
+    ? `import { NextRequest, NextResponse } from 'next/server';\n`
+    : `import { NextResponse } from 'next/server';\n`;
 
-  return `import BotVersion from 'botversion-sdk';
-import { createRouteHandlerClient } from '@supabase/auth-helpers-nextjs';
+  return `import { createRouteHandlerClient } from '@supabase/auth-helpers-nextjs';
 import { cookies } from 'next/headers';
-import { NextRequest } from 'next/server';
-
-export async function POST(req${isTypeScript ? ": NextRequest" : ""}) {
-  const supabase = createRouteHandlerClient({ cookies });
-  const { data: { session } } = await supabase.auth.getSession();
-  const body = await req.json();
+${nextRequestImport}
+export async function POST(req${typeAnnotation}) {
+  try {
+    const supabase = createRouteHandlerClient({ cookies });
+    const { data: { session } } = await supabase.auth.getSession();
+    const body = await req.json();
+
+    const response = await fetch(\`\${process.env.BOTVERSION_PLATFORM_URL || 'https://chatbusiness-two.vercel.app'}/api/chatbot/widget-chat\`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chatbotId: body.chatbotId,
+        publicKey: body.publicKey,
+        query: body.message,
+        previousChats: body.conversationHistory || [],
+        pageContext: body.pageContext || {},
+        userContext: {
+          userId: session?.user?.id,
+          email: session?.user?.email,
+        },
+      }),
+    });
 
-  return BotVersion.appRouterHandler({
-    body,
-    userContext: {
-      userId: session?.user?.id,
-      email: session?.user?.email,
-    },
-  });
+    const data = await response.json();
+    return NextResponse.json(data);
+  } catch (err) {
+    console.error('[BotVersion] App Router handler error:', err);
+    return NextResponse.json({ error: 'Agent error' }, { status: 500 });
+  }
 }
 `;
 }
 
 function generateAuthlessAppRoute(info) {
   const { auth, isTypeScript } = info;
+  const typeAnnotation = isTypeScript ? ": NextRequest" : "";
+  const nextRequestImport = isTypeScript
+    ? `import { NextRequest, NextResponse } from 'next/server';\n`
+    : `import { NextResponse } from 'next/server';\n`;
 
   const comment =
     auth.name && !auth.supported
-      ? `// TODO: We detected ${auth.name} but don't have automatic support yet.
-// Add your own user context below.
-// See: https://docs.botversion.com/auth\n\n`
+      ? `// TODO: We detected ${auth.name} but don't have automatic support yet.\n// Add your own user context below.\n// See: https://docs.botversion.com/auth\n\n`
       : "";
 
-  return `${comment}import BotVersion from 'botversion-sdk';
-import { NextRequest } from 'next/server';
-
-export async function POST(req${isTypeScript ? ": NextRequest" : ""}) {
-  const body = await req.json();
+  return `${comment}${nextRequestImport}
+export async function POST(req${typeAnnotation}) {
+  try {
+    const body = await req.json();
+
+    // No auth detected — agent works without user context
+    // Add userContext here if needed:
+    // const userContext = { userId: '...', email: '...' };
+
+    const response = await fetch(\`\${process.env.BOTVERSION_PLATFORM_URL || 'https://chatbusiness-two.vercel.app'}/api/chatbot/widget-chat\`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chatbotId: body.chatbotId,
+        publicKey: body.publicKey,
+        query: body.message,
+        previousChats: body.conversationHistory || [],
+        pageContext: body.pageContext || {},
+        userContext: {},
+      }),
+    });
 
-  // No auth detected — agent works without user context
-  // Add userContext here if needed
-  return BotVersion.appRouterHandler({ body });
+    const data = await response.json();
+    return NextResponse.json(data);
+  } catch (err) {
+    console.error('[BotVersion] App Router handler error:', err);
+    return NextResponse.json({ error: 'Agent error' }, { status: 500 });
+  }
 }
 `;
 }
 
-// ─── MANUAL INSTRUCTIONS FOR UNSUPPORTED CASES ───────────────────────────────
+// ─── NEXT.JS CONFIG PATCH ─────────────────────────────────────────────────────
+
+function generateNextConfigPatch(cwd) {
+  const candidates = ["next.config.js", "next.config.mjs", "next.config.ts"];
+
+  let configPath = null;
+  let configContent = null;
+
+  for (const candidate of candidates) {
+    const fullPath = path.join(cwd, candidate);
+    if (fs.existsSync(fullPath)) {
+      configPath = fullPath;
+      configContent = fs.readFileSync(fullPath, "utf8");
+      break;
+    }
+  }
+
+  if (!configPath) return null;
+
+  if (configContent.includes("instrumentationHook")) {
+    return { path: configPath, alreadyPatched: true };
+  }
+
+  let patched = configContent;
+
+  // Add to existing experimental block
+  if (configContent.includes("experimental")) {
+    patched = configContent.replace(
+      /experimental\s*:\s*\{/,
+      "experimental: {\n    instrumentationHook: true,",
+    );
+
+    // FIX #7: Handle next.config.mjs style — export default { ... }
+  } else if (/export\s+default\s+\{/.test(configContent)) {
+    patched = configContent.replace(
+      /export\s+default\s+\{/,
+      "export default {\n  experimental: {\n    instrumentationHook: true,\n  },",
+    );
+
+    // Handle const nextConfig = { ... } style (next.config.js)
+  } else if (/const\s+nextConfig\s*=\s*\{/.test(configContent)) {
+    patched = configContent.replace(
+      /const\s+nextConfig\s*=\s*\{/,
+      "const nextConfig = {\n  experimental: {\n    instrumentationHook: true,\n  },",
+    );
+
+    // Handle module.exports = { ... } style
+  } else if (/module\.exports\s*=\s*\{/.test(configContent)) {
+    patched = configContent.replace(
+      /module\.exports\s*=\s*\{/,
+      "module.exports = {\n  experimental: {\n    instrumentationHook: true,\n  },",
+    );
+  } else {
+    // Cannot safely patch — return null so caller prompts manual step
+    return null;
+  }
+
+  return { path: configPath, content: patched, alreadyPatched: false };
+}
+
+// ─── MANUAL INSTRUCTIONS FOR UNSUPPORTED FRAMEWORKS ──────────────────────────
 
 function generateManualInstructions(framework, apiKey) {
   const instructions = {
@@ -431,49 +610,6 @@ Visit https://docs.botversion.com for manual setup instructions.
   );
 }
 
-function generateNextConfigPatch(cwd) {
-  const fs = require("fs");
-  const path = require("path");
-
-  const candidates = ["next.config.js", "next.config.mjs", "next.config.ts"];
-
-  let configPath = null;
-  let configContent = null;
-
-  for (const candidate of candidates) {
-    const fullPath = path.join(cwd, candidate);
-    if (fs.existsSync(fullPath)) {
-      configPath = fullPath;
-      configContent = fs.readFileSync(fullPath, "utf8");
-      break;
-    }
-  }
-
-  if (!configPath) return null;
-
-  // Already has instrumentationHook
-  if (configContent.includes("instrumentationHook")) {
-    return { path: configPath, alreadyPatched: true };
-  }
-
-  // Add instrumentationHook: true to experimental block if exists
-  if (configContent.includes("experimental")) {
-    const patched = configContent.replace(
-      /experimental\s*:\s*\{/,
-      "experimental: {\n    instrumentationHook: true,",
-    );
-    return { path: configPath, content: patched, alreadyPatched: false };
-  }
-
-  // Add experimental block before the closing of config object
-  const patched = configContent.replace(
-    /const nextConfig\s*=\s*\{/,
-    "const nextConfig = {\n  experimental: {\n    instrumentationHook: true,\n  },",
-  );
-
-  return { path: configPath, content: patched, alreadyPatched: false };
-}
-
 module.exports = {
   generateExpressInit,
   generateInstrumentationFile,

package/cli/writer.js

@@ -17,7 +17,7 @@ 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;
 }
@@ -58,10 +58,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 +94,84 @@ function createFile(filePath, content, force) {
   return { success: true, path: filePath };
 }
 
+function injectBeforeExport(filePath, codeToInject) {
+  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++) {
+      if (/app\.listen\s*\(/.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) {
@@ -168,4 +246,5 @@ module.exports = {
   createFile,
   mergeIntoMiddleware,
   writeSummary,
+  injectBeforeExport,
 };

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,8 @@ var BotVersion = {
 
     this._client = new BotVersionClient({
       apiKey: options.apiKey,
-      platformUrl: options.platformUrl || "http://localhost:3000",
+      platformUrl:
+        options.platformUrl || "https://chatbusiness-two.vercel.app/",
       debug: options.debug || false,
       timeout: options.timeout || 30000,
     });
@@ -205,9 +206,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 +572,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 +587,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.1",
   "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 = {