botversion-sdk 1.0.1 → 1.0.3

package/bin/init.js

@@ -45,6 +45,22 @@ function step(msg) {
   console.log(`\n${c.bold}${c.white}  → ${msg}${c.reset}`);
 }
 
+// ─── FETCH PROJECT INFO ───────────────────────────────────────────────────────
+
+async function fetchProjectInfo(apiKey, platformUrl) {
+  const url = `${platformUrl}/api/sdk/project-info?workspaceKey=${encodeURIComponent(apiKey)}`;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error("Invalid API key or project not found");
+    }
+    return await response.json();
+    // returns { projectId, publicKey, apiUrl, cdnUrl }
+  } catch (err) {
+    throw new Error(`Could not fetch project info: ${err.message}`);
+  }
+}
+
 // ─── PARSE ARGS ───────────────────────────────────────────────────────────────
 
 function parseArgs(argv) {
@@ -93,23 +109,30 @@ async function main() {
   const cwd = args.cwd;
   const changes = { modified: [], created: [], backups: [], manual: [] };
 
+  // ── Fetch project info from platform ──────────────────────────────────────
+  step("Fetching project info from platform...");
+  let projectInfo;
+  try {
+    projectInfo = await fetchProjectInfo(args.key, "http://localhost:3000");
+    success(`Project found — ID: ${projectInfo.projectId}`);
+  } catch (err) {
+    error(err.message);
+    process.exit(1);
+  }
+
   // ── Detect environment ────────────────────────────────────────────────────
   step("Scanning your project...");
 
   // Handle monorepo
-  let workingDir = cwd;
   const monorepoInfo = detector.detectMonorepo(cwd);
   if (monorepoInfo.isMonorepo) {
-    warn("Monorepo detected.");
-    workingDir = await prompts.promptMonorepoPackage(
-      monorepoInfo.packages,
-      cwd,
+    warn(
+      "Monorepo detected — will scan all packages for frontend and backend.",
     );
-    info(`Using package: ${path.relative(cwd, workingDir) || "root"}`);
   }
 
-  // Run full detection
-  const detected = detector.detect(workingDir);
+  // Always detect from root so frontend/backend split works correctly
+  const detected = detector.detect(cwd);
 
   // ── Check if already initialized ─────────────────────────────────────────
   if (detected.alreadyInitialized && !args.force) {
@@ -174,20 +197,60 @@ async function main() {
   // FRAMEWORK: EXPRESS
   // ─────────────────────────────────────────────────────────────────────────
   if (detected.framework.name === "express") {
-    await setupExpress(detected, args, changes);
+    await setupExpress(detected, args, changes, projectInfo);
+
+    // ── Inject script tag into frontend (Express only) ──────────────────
+    // Next.js handles its own script tag injection inside setupNextJs
+    if (detected.frontendMainFile && projectInfo) {
+      const scriptTag = generator.generateScriptTag(projectInfo);
+      const result = writer.injectScriptTag(
+        detected.frontendMainFile.file,
+        detected.frontendMainFile.type,
+        scriptTag,
+        args.force,
+      );
+
+      if (result.success) {
+        success(
+          `Injected script tag into ${path.relative(detected.cwd, detected.frontendMainFile.file)}`,
+        );
+        changes.modified.push(
+          path.relative(detected.cwd, detected.frontendMainFile.file),
+        );
+        if (result.backup) changes.backups.push(result.backup);
+      } else if (result.reason === "already_exists") {
+        warn(
+          "BotVersion script tag already exists in frontend file — skipping.",
+        );
+      } else {
+        warn(
+          "Could not auto-inject script tag. Add this manually to your frontend HTML:",
+        );
+        console.log("\n" + scriptTag + "\n");
+        changes.manual.push(
+          `Add to your frontend HTML before </body>:\n\n${scriptTag}`,
+        );
+      }
+    } else if (!detected.frontendMainFile) {
+      warn("Could not find frontend main file automatically.");
+      const scriptTag = generator.generateScriptTag(projectInfo);
+      changes.manual.push(
+        `Add to your frontend HTML before </body>:\n\n${scriptTag}`,
+      );
+    }
   }
 
   // ─────────────────────────────────────────────────────────────────────────
   // FRAMEWORK: NEXT.JS
   // ─────────────────────────────────────────────────────────────────────────
   else if (detected.framework.name === "next") {
-    await setupNextJs(detected, args, changes);
+    await setupNextJs(detected, args, changes, projectInfo);
   }
 
   // ── Write API key to .env / .env.local ────────────────────────────────────
   const envFileName =
     detected.framework.name === "next" ? ".env.local" : ".env";
-  const envPath = path.join(workingDir, envFileName);
+  const envPath = path.join(detected.cwd, envFileName);
   const envLine = `BOTVERSION_API_KEY=${args.key}`;
   const envContent = fs.existsSync(envPath)
     ? fs.readFileSync(envPath, "utf8")
@@ -222,7 +285,7 @@ async function main() {
 
 // ─── EXPRESS SETUP ────────────────────────────────────────────────────────────
 
-async function setupExpress(detected, args, changes) {
+async function setupExpress(detected, args, changes, projectInfo) {
   step("Setting up Express...");
 
   // Find entry point
@@ -244,9 +307,6 @@ async function setupExpress(detected, args, changes) {
   // Generate the init code
   const generated = generator.generateExpressInit(detected, args.key);
 
-  // Find app.listen() and inject before it
-  const listenCall = detector.findListenCall(entryPoint);
-
   // PATTERN 2: Separate app file with module.exports = app
   if (detected.appFile) {
     info(`Found app file: ${path.relative(detected.cwd, detected.appFile)}`);
@@ -254,6 +314,7 @@ async function setupExpress(detected, args, changes) {
     const result = writer.injectBeforeExport(
       detected.appFile,
       generated2.initBlock,
+      detected.appVarName,
     );
 
     if (result.success) {
@@ -272,7 +333,11 @@ async function setupExpress(detected, args, changes) {
     detected.listenInsideCallback ||
     detected.createServer
   ) {
-    const result = writer.injectBeforeListen(entryPoint, generated.initBlock);
+    const result = writer.injectBeforeListen(
+      entryPoint,
+      generated.initBlock,
+      detected.appVarName,
+    );
 
     if (result.success) {
       success(`Injected BotVersion.init() before app.listen()`);
@@ -299,7 +364,11 @@ async function setupExpress(detected, args, changes) {
     } else if (response.action === "manual_path") {
       const altPath = path.resolve(detected.cwd, response.filePath);
       if (fs.existsSync(altPath)) {
-        const result = writer.injectBeforeListen(altPath, generated.initBlock);
+        const result = writer.injectBeforeListen(
+          altPath,
+          generated.initBlock,
+          detected.appVarName,
+        );
         if (result.success) {
           success(`Injected into ${response.filePath}`);
           changes.modified.push(response.filePath);
@@ -321,7 +390,7 @@ async function setupExpress(detected, args, changes) {
 
 // ─── NEXT.JS SETUP ────────────────────────────────────────────────────────────
 
-async function setupNextJs(detected, args, changes) {
+async function setupNextJs(detected, args, changes, projectInfo) {
   step("Setting up Next.js...");
 
   const nextInfo = detected.next;
@@ -366,7 +435,10 @@ async function setupNextJs(detected, args, changes) {
   }
 
   // ── 2. Patch next.config.js ───────────────────────────────────────────────
-  const configPatch = generator.generateNextConfigPatch(detected.cwd);
+  const configPatch = generator.generateNextConfigPatch(
+    detected.cwd,
+    detected.nextVersion,
+  );
 
   if (configPatch) {
     if (configPatch.alreadyPatched) {
@@ -434,6 +506,45 @@ async function setupNextJs(detected, args, changes) {
       }
     }
   }
+
+  // ── 5. Inject script tag into frontend ───────────────────────────────────
+  // For Next.js the frontend IS the same project
+  // frontendMainFile will be _app.js or layout.js
+  if (detected.frontendMainFile && projectInfo) {
+    const scriptTag = generator.generateScriptTag(projectInfo);
+    const result = writer.injectScriptTag(
+      detected.frontendMainFile.file,
+      detected.frontendMainFile.type,
+      scriptTag,
+      args.force,
+    );
+
+    if (result.success) {
+      success(
+        `Injected script tag into ${path.relative(detected.cwd, detected.frontendMainFile.file)}`,
+      );
+      changes.modified.push(
+        path.relative(detected.cwd, detected.frontendMainFile.file),
+      );
+      if (result.backup) changes.backups.push(result.backup);
+    } else if (result.reason === "already_exists") {
+      warn("BotVersion script tag already exists — skipping.");
+    } else {
+      warn(
+        "Could not auto-inject script tag. Add this manually to your frontend file:",
+      );
+      console.log("\n" + scriptTag + "\n");
+      changes.manual.push(
+        `Add to your frontend HTML before </body>:\n\n${scriptTag}`,
+      );
+    }
+  } else if (!detected.frontendMainFile) {
+    warn("Could not find frontend file automatically.");
+    const scriptTag = generator.generateScriptTag(projectInfo);
+    changes.manual.push(
+      `Add to your frontend HTML before </body>:\n\n${scriptTag}`,
+    );
+  }
 }
 
 // ─── RUN ──────────────────────────────────────────────────────────────────────

package/cli/detector.js

@@ -1,10 +1,25 @@
 // botversion-sdk/cli/detector.js
-
 "use strict";
 
 const fs = require("fs");
 const path = require("path");
 
+// ─── SKIP DIRS (used everywhere) ─────────────────────────────────────────────
+
+const SKIP_DIRS = [
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  ".cache",
+  "coverage",
+  ".turbo",
+  "out",
+  ".output",
+  ".svelte-kit",
+];
+
 // ─── PACKAGE JSON ────────────────────────────────────────────────────────────
 
 function readPackageJson(cwd) {
@@ -17,22 +32,286 @@ function readPackageJson(cwd) {
   }
 }
 
+// ─── SCAN ALL PACKAGE.JSON FILES ─────────────────────────────────────────────
+// Recursively finds ALL package.json files in the project
+
+function scanAllPackageJsons(cwd) {
+  const results = []; // [{ dir, pkg }]
+
+  function walk(currentDir, depth) {
+    if (depth > 5) return;
+
+    let entries;
+    try {
+      entries = fs.readdirSync(currentDir);
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (SKIP_DIRS.includes(entry)) continue;
+
+      const fullPath = path.join(currentDir, entry);
+      let stat;
+      try {
+        stat = fs.statSync(fullPath);
+      } catch {
+        continue;
+      }
+
+      if (stat.isDirectory()) {
+        walk(fullPath, depth + 1);
+      } else if (entry === "package.json") {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(fullPath, "utf8"));
+          results.push({ dir: currentDir, pkg });
+        } catch {
+          continue;
+        }
+      }
+    }
+  }
+
+  walk(cwd, 0);
+  return results;
+}
+
+// ─── CLASSIFY PACKAGE.JSON ────────────────────────────────────────────────────
+
+const BACKEND_PACKAGES = [
+  "express",
+  "fastify",
+  "koa",
+  "@nestjs/core",
+  "@hapi/hapi",
+  "restify",
+  "polka",
+  "micro",
+];
+
+const FULLSTACK_PACKAGES = ["next", "@sveltejs/kit"];
+
+const FRONTEND_PACKAGES = [
+  "react",
+  "react-dom",
+  "vue",
+  "@angular/core",
+  "svelte",
+  "@sveltejs/kit",
+  "solid-js",
+  "preact",
+];
+
+function classifyPackageJson(pkg) {
+  if (!pkg) return "unknown";
+
+  const deps = {
+    ...(pkg.dependencies || {}),
+    ...(pkg.devDependencies || {}),
+  };
+
+  const isFullstack = FULLSTACK_PACKAGES.some((p) => !!deps[p]);
+  if (isFullstack) return "fullstack";
+
+  const isBackend = BACKEND_PACKAGES.some((p) => !!deps[p]);
+  const isFrontend = FRONTEND_PACKAGES.some((p) => !!deps[p]);
+
+  if (isBackend && isFrontend) return "fullstack";
+  if (isBackend) return "backend";
+  if (isFrontend) return "frontend";
+  return "unknown";
+}
+
+// ─── DETECT FRONTEND FRAMEWORK ───────────────────────────────────────────────
+
+function detectFrontendFramework(pkg) {
+  if (!pkg) return null;
+
+  const deps = {
+    ...(pkg.dependencies || {}),
+    ...(pkg.devDependencies || {}),
+  };
+
+  if (deps["next"]) return "next";
+  if (deps["@sveltejs/kit"]) return "sveltekit";
+  if (deps["svelte"]) return "svelte";
+  if (deps["@angular/core"]) return "angular";
+  if (deps["vue"]) return "vue";
+  if (deps["react-dom"] || deps["react"]) {
+    // Distinguish CRA vs Vite
+    if (deps["vite"] || deps["@vitejs/plugin-react"]) return "react-vite";
+    return "react-cra";
+  }
+  if (deps["solid-js"]) return "solid";
+  if (deps["preact"]) return "preact";
+
+  return null;
+}
+
+// ─── FIND MAIN FRONTEND FILE ──────────────────────────────────────────────────
+// Returns { file, type } or null
+
+function findMainFrontendFile(dir, pkg) {
+  const framework = detectFrontendFramework(pkg);
+
+  // ── Next.js ───────────────────────────────────────────────────────────────
+  // For Next.js we inject into _app.js (Pages) or layout.js (App Router)
+  if (framework === "next") {
+    const candidates = [
+      "pages/_app.js",
+      "pages/_app.tsx",
+      "pages/_app.ts",
+      "src/pages/_app.js",
+      "src/pages/_app.tsx",
+      "src/pages/_app.ts",
+      "app/layout.js",
+      "app/layout.tsx",
+      "src/app/layout.js",
+      "src/app/layout.tsx",
+    ];
+    for (const candidate of candidates) {
+      const fullPath = path.join(dir, candidate);
+      if (fs.existsSync(fullPath)) {
+        return { file: fullPath, type: "next" };
+      }
+    }
+    return null;
+  }
+
+  // ── Angular ───────────────────────────────────────────────────────────────
+  if (framework === "angular") {
+    const candidate = path.join(dir, "src", "index.html");
+    if (fs.existsSync(candidate)) {
+      return { file: candidate, type: "html" };
+    }
+    return null;
+  }
+
+  // ── React Vite / Vue Vite / Svelte / SvelteKit / Solid / Preact ──────────
+  // All Vite-based projects have index.html in root of the project folder
+  if (
+    framework === "react-vite" ||
+    framework === "vue" ||
+    framework === "svelte" ||
+    framework === "sveltekit" ||
+    framework === "solid" ||
+    framework === "preact"
+  ) {
+    // Check root index.html first
+    const rootHtml = path.join(dir, "index.html");
+    if (fs.existsSync(rootHtml)) {
+      return { file: rootHtml, type: "html" };
+    }
+
+    // Fallback: public/index.html
+    const publicHtml = path.join(dir, "public", "index.html");
+    if (fs.existsSync(publicHtml)) {
+      return { file: publicHtml, type: "html" };
+    }
+
+    return null;
+  }
+
+  // ── React CRA ─────────────────────────────────────────────────────────────
+  if (framework === "react-cra") {
+    // CRA always puts index.html in public/
+    const publicHtml = path.join(dir, "public", "index.html");
+    if (fs.existsSync(publicHtml)) {
+      return { file: publicHtml, type: "html" };
+    }
+
+    // Fallback: root index.html (custom CRA config)
+    const rootHtml = path.join(dir, "index.html");
+    if (fs.existsSync(rootHtml)) {
+      return { file: rootHtml, type: "html" };
+    }
+
+    return null;
+  }
+
+  // ── Unknown frontend — scan for any index.html ────────────────────────────
+  const htmlCandidates = [
+    "index.html",
+    "public/index.html",
+    "src/index.html",
+    "static/index.html",
+    "www/index.html",
+  ];
+
+  for (const candidate of htmlCandidates) {
+    const fullPath = path.join(dir, candidate);
+    if (fs.existsSync(fullPath)) {
+      const content = fs.readFileSync(fullPath, "utf8");
+      // Make sure it's a real HTML file with a body tag
+      if (content.includes("<body") || content.includes("<html")) {
+        return { file: fullPath, type: "html" };
+      }
+    }
+  }
+
+  // Last resort — deep scan for any .html file
+  const found = findHtmlFile(dir);
+  if (found) return { file: found, type: "html" };
+
+  return null;
+}
+
+// ─── DEEP SCAN FOR HTML FILE ─────────────────────────────────────────────────
+
+function findHtmlFile(dir) {
+  function walk(currentDir, depth) {
+    if (depth > 3) return null;
+
+    let entries;
+    try {
+      entries = fs.readdirSync(currentDir);
+    } catch {
+      return null;
+    }
+
+    for (const entry of entries) {
+      if (SKIP_DIRS.includes(entry)) continue;
+
+      const fullPath = path.join(currentDir, entry);
+      let stat;
+      try {
+        stat = fs.statSync(fullPath);
+      } catch {
+        continue;
+      }
+
+      if (stat.isDirectory()) {
+        const result = walk(fullPath, depth + 1);
+        if (result) return result;
+      } else if (entry.endsWith(".html")) {
+        try {
+          const content = fs.readFileSync(fullPath, "utf8");
+          if (content.includes("<body") || content.includes("<html")) {
+            return fullPath;
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  return walk(dir, 0);
+}
+
 // ─── MONOREPO DETECTION ──────────────────────────────────────────────────────
 
 function detectMonorepo(cwd) {
-  const entries = fs.readdirSync(cwd);
-
-  // Check for workspaces in root package.json
   const rootPkg = readPackageJson(cwd);
   if (rootPkg && rootPkg.workspaces) {
-    // Find all workspace package.json files
     const workspaceDirs = [];
     const patterns = Array.isArray(rootPkg.workspaces)
       ? rootPkg.workspaces
       : rootPkg.workspaces.packages || [];
 
     patterns.forEach((pattern) => {
-      // Handle simple patterns like "packages/*"
       const base = pattern.replace(/\/\*$/, "");
       const fullBase = path.join(cwd, base);
       if (fs.existsSync(fullBase)) {
@@ -94,17 +373,12 @@ function detectFramework(pkg) {
     ...(pkg.devDependencies || {}),
   };
 
-  // Check unsupported first so we can warn clearly
   for (const fw of UNSUPPORTED_FRAMEWORKS) {
-    if (deps[fw]) {
-      return { name: fw, supported: false };
-    }
+    if (deps[fw]) return { name: fw, supported: false };
   }
 
   for (const fw of SUPPORTED_FRAMEWORKS) {
-    if (deps[fw]) {
-      return { name: fw, supported: true };
-    }
+    if (deps[fw]) return { name: fw, supported: true };
   }
 
   return { name: null, supported: false };
@@ -131,7 +405,6 @@ function readTsConfig(cwd) {
   if (!fs.existsSync(tsconfigPath)) return null;
   try {
     const raw = fs.readFileSync(tsconfigPath, "utf8");
-    // Strip comments — tsconfig supports JSON with comments
     const stripped = raw
       .replace(/\/\/.*$/gm, "")
       .replace(/\/\*[\s\S]*?\*\//g, "");
@@ -141,11 +414,6 @@ function readTsConfig(cwd) {
   }
 }
 
-// Decide whether to generate .ts or .js files
-// - Not TypeScript → always .js
-// - TypeScript + allowJs: true (Next.js default) → .js is fine
-// - TypeScript + allowJs: false (manually set by user) → must use .ts
-// - TypeScript + allowJs not set → Next.js default is true → .js is fine
 function shouldGenerateTs(cwd, isTypeScript) {
   if (!isTypeScript) return false;
   const tsconfig = readTsConfig(cwd);
@@ -179,7 +447,6 @@ function detectNextRouter(cwd) {
     pagesRouter: hasPages,
     appRouter: hasApp,
     srcDir: hasSrc,
-    // Resolve the actual base directory
     baseDir: hasSrc ? path.join(cwd, "src") : cwd,
   };
 }
@@ -209,7 +476,6 @@ function detectExpressEntry(cwd, pkg) {
     const scripts = [pkg.scripts.start, pkg.scripts.dev, pkg.scripts.serve];
     for (const script of scripts) {
       if (!script) continue;
-      // e.g. "node server.js" or "nodemon src/index.js" or "ts-node index.ts"
       const match = script.match(
         /(?:node|nodemon|ts-node|tsx)\s+([^\s]+\.(js|ts))/,
       );
@@ -220,7 +486,7 @@ function detectExpressEntry(cwd, pkg) {
     }
   }
 
-  // Strategy 3: common file names in root and src/
+  // Strategy 3: common file names
   const candidates = [
     "server.js",
     "server.ts",
@@ -243,7 +509,6 @@ function detectExpressEntry(cwd, pkg) {
   for (const candidate of candidates) {
     const filePath = path.join(cwd, candidate);
     if (fs.existsSync(filePath)) {
-      // Verify it actually contains express
       const content = fs.readFileSync(filePath, "utf8");
       if (content.includes("express") || content.includes("app.listen")) {
         return filePath;
@@ -252,17 +517,19 @@ function detectExpressEntry(cwd, pkg) {
   }
 
   // Strategy 4: any .js/.ts file containing app.listen()
-  return findFileWithContent(cwd, "app.listen", [".js", ".ts"], 2);
+  return findFileWithContent(cwd, ".listen(", [".js", ".ts"], 2);
 }
 
 // ─── app.listen() LOCATION ───────────────────────────────────────────────────
 
-function findListenCall(filePath) {
+function findListenCall(filePath, appVarName) {
+  appVarName = appVarName || "app";
   const content = fs.readFileSync(filePath, "utf8");
   const lines = content.split("\n");
+  const regex = new RegExp(`${appVarName}\\.listen\\s*\\(`);
 
   for (let i = 0; i < lines.length; i++) {
-    if (/app\.listen\s*\(/.test(lines[i])) {
+    if (regex.test(lines[i])) {
       return { lineIndex: i, lineNumber: i + 1, content: lines[i] };
     }
   }
@@ -280,12 +547,14 @@ function findModuleExportsApp(filePath) {
   return null;
 }
 
-function findListenInsideCallback(filePath) {
+function findListenInsideCallback(filePath, appVarName) {
+  appVarName = appVarName || "app";
   const content = fs.readFileSync(filePath, "utf8");
   const lines = content.split("\n");
+  const regex = new RegExp(`${appVarName}\\.listen\\s*\\(`);
+
   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)
+    if (regex.test(lines[i])) {
       const indentation = lines[i].match(/^(\s*)/)[1].length;
       if (indentation > 0) {
         return { lineIndex: i, lineNumber: i + 1, insideCallback: true };
@@ -392,12 +661,7 @@ function detectAuth(pkg) {
         "jwt",
         "express-session",
       ].includes(lib.name);
-      return {
-        name: lib.name,
-        version,
-        package: pkg2,
-        supported,
-      };
+      return { name: lib.name, version, package: pkg2, supported };
     }
   }
 
@@ -407,7 +671,6 @@ function detectAuth(pkg) {
 // ─── NEXT-AUTH CONFIG LOCATION ───────────────────────────────────────────────
 
 function findNextAuthConfig(cwd) {
-  // Common locations for authOptions
   const candidates = [
     "pages/api/auth/[...nextauth].js",
     "pages/api/auth/[...nextauth].ts",
@@ -424,7 +687,7 @@ function findNextAuthConfig(cwd) {
     "utils/auth.js",
     "utils/auth.ts",
     "auth.js",
-    "auth.ts", // next-auth v5
+    "auth.ts",
   ];
 
   for (const candidate of candidates) {
@@ -434,13 +697,9 @@ function findNextAuthConfig(cwd) {
     }
   }
 
-  // Search for authOptions in files
   const found = findFileWithContent(cwd, "authOptions", [".js", ".ts"], 3);
   if (found) {
-    return {
-      path: found,
-      relativePath: path.relative(cwd, found),
-    };
+    return { path: found, relativePath: path.relative(cwd, found) };
   }
 
   return null;
@@ -471,16 +730,6 @@ function findFileWithContent(dir, searchString, extensions, maxDepth) {
   function walk(currentDir, depth) {
     if (depth > maxDepth) return null;
 
-    // Skip node_modules, .git, .next, dist, build
-    const skipDirs = [
-      "node_modules",
-      ".git",
-      ".next",
-      "dist",
-      "build",
-      ".cache",
-    ];
-
     let entries;
     try {
       entries = fs.readdirSync(currentDir);
@@ -489,7 +738,7 @@ function findFileWithContent(dir, searchString, extensions, maxDepth) {
     }
 
     for (const entry of entries) {
-      if (skipDirs.includes(entry)) continue;
+      if (SKIP_DIRS.includes(entry)) continue;
 
       const fullPath = path.join(currentDir, entry);
       let stat;
@@ -523,7 +772,7 @@ function detectAppVarName(filePath) {
     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) {
+  } catch {
     return "app";
   }
 }
@@ -533,18 +782,90 @@ function detectAppVarName(filePath) {
 function detect(cwd) {
   const pkg = readPackageJson(cwd);
   const monorepo = detectMonorepo(cwd);
-  const framework = detectFramework(pkg);
-  const moduleSystem = detectModuleSystem(pkg);
-  const isTypeScript = detectTypeScript(cwd);
-  const hasSrc = detectSrcDir(cwd);
-  const auth = detectAuth(pkg);
-  const packageManager = detectPackageManager(cwd);
+  let framework = detectFramework(pkg);
+
+  // ── If framework not found in root, scan ALL package.json files ───────────
+  let backendDir = cwd;
+  let frontendDir = null;
+  let frontendPkg = null;
+
+  if (!framework.name) {
+    const allPackages = scanAllPackageJsons(cwd);
+
+    for (const { dir, pkg: subPkg } of allPackages) {
+      // Skip the root package.json — already checked
+      if (dir === cwd) continue;
+
+      const classification = classifyPackageJson(subPkg);
+
+      // AFTER
+      if (
+        (classification === "backend" || classification === "fullstack") &&
+        !framework.name
+      ) {
+        framework = detectFramework(subPkg);
+        backendDir = dir;
+      }
 
-  const generateTs = shouldGenerateTs(cwd, isTypeScript);
+      if (
+        (classification === "frontend" || classification === "fullstack") &&
+        !frontendDir &&
+        dir !== backendDir
+      ) {
+        frontendDir = dir;
+        frontendPkg = subPkg;
+      }
+    }
+  } else {
+    // Framework found in root — scan for separate frontend folder
+    const allPackages = scanAllPackageJsons(cwd);
+    for (const { dir, pkg: subPkg } of allPackages) {
+      if (dir === cwd) continue;
+      if (dir === backendDir) continue;
+      const classification = classifyPackageJson(subPkg);
+      if (classification === "frontend" || classification === "fullstack") {
+        frontendDir = dir;
+        frontendPkg = subPkg;
+        break;
+      }
+    }
+  }
+
+  // ── Use backendDir for all backend-specific detection ─────────────────────
+  // Guard: if frontendDir ended up being the same as backendDir
+  // (e.g. a fullstack Next.js folder detected as both), clear frontendDir
+  // so we don't try to inject script tag into the wrong place
+  if (frontendDir && frontendDir === backendDir) {
+    frontendDir = null;
+    frontendPkg = null;
+  }
+  const backendPkg = readPackageJson(backendDir) || pkg;
+  const moduleSystem = detectModuleSystem(backendPkg);
+  const isTypeScript = detectTypeScript(backendDir);
+  const hasSrc = detectSrcDir(backendDir);
+  const auth = detectAuth(backendPkg);
+  const generateTs = shouldGenerateTs(backendDir, isTypeScript);
+
+  // ── Find frontend main file ───────────────────────────────────────────────
+  let frontendMainFile = null;
+  if (frontendDir && frontendPkg) {
+    frontendMainFile = findMainFrontendFile(frontendDir, frontendPkg);
+  } else if (framework.name === "next") {
+    frontendMainFile = findMainFrontendFile(backendDir, backendPkg);
+  } else if (framework.name === "express" && !frontendDir) {
+    // Express + frontend in same root folder (e.g. public/index.html)
+    frontendMainFile = findMainFrontendFile(backendDir, backendPkg);
+  }
+
+  const packageManager =
+    detectPackageManager(backendDir) !== "npm"
+      ? detectPackageManager(backendDir)
+      : detectPackageManager(cwd);
 
   const result = {
-    cwd,
-    pkg,
+    cwd: backendDir, // use backend dir as working dir
+    rootCwd: cwd, // keep original root for reference
+    pkg: backendPkg,
     monorepo,
     framework,
     moduleSystem,
@@ -553,30 +874,34 @@ function detect(cwd) {
     hasSrc,
     auth,
     packageManager,
-    // generateTs: true means user has allowJs:false — must use .ts
-    // generateTs: false means .js files are fine (most users)
     ext: generateTs ? ".ts" : ".js",
+    // Frontend info
+    frontendDir,
+    frontendPkg,
+    frontendMainFile,
   };
 
-  // Framework-specific detection
+  // ── Framework-specific detection ──────────────────────────────────────────
   if (framework.name === "next") {
-    result.next = detectNextRouter(cwd);
-    result.nextVersion = detectNextVersion(pkg);
+    result.next = detectNextRouter(backendDir);
+    result.nextVersion = detectNextVersion(backendPkg);
     if (auth.name === "next-auth") {
-      result.nextAuthConfig = findNextAuthConfig(cwd);
+      result.nextAuthConfig = findNextAuthConfig(backendDir);
     }
   }
 
   if (framework.name === "express") {
-    result.entryPoint = detectExpressEntry(cwd, pkg);
+    result.entryPoint = detectExpressEntry(backendDir, backendPkg);
     if (result.entryPoint) {
-      result.listenCall = findListenCall(result.entryPoint);
+      result.appVarName = detectAppVarName(result.entryPoint); // detect FIRST
+      result.listenCall = findListenCall(result.entryPoint, result.appVarName);
+      result.listenInsideCallback = findListenInsideCallback(
+        result.entryPoint,
+        result.appVarName,
+      );
       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",
@@ -584,7 +909,7 @@ function detect(cwd) {
         "app.ts",
       ];
       for (const candidate of appFileCandidates) {
-        const fullPath = path.join(cwd, candidate);
+        const fullPath = path.join(backendDir, candidate);
         if (fs.existsSync(fullPath) && fullPath !== result.entryPoint) {
           const exportCall = findModuleExportsApp(fullPath);
           if (exportCall) {
@@ -597,13 +922,14 @@ function detect(cwd) {
     }
   }
 
+  // ── Already initialized check ─────────────────────────────────────────────
   result.alreadyInitialized =
     detectExistingBotVersion(result.entryPoint) ||
     (framework.name === "next" &&
-      (fs.existsSync(path.join(cwd, "instrumentation.js")) ||
-        fs.existsSync(path.join(cwd, "instrumentation.ts")) ||
-        fs.existsSync(path.join(cwd, "src", "instrumentation.js")) ||
-        fs.existsSync(path.join(cwd, "src", "instrumentation.ts"))));
+      (fs.existsSync(path.join(backendDir, "instrumentation.js")) ||
+        fs.existsSync(path.join(backendDir, "instrumentation.ts")) ||
+        fs.existsSync(path.join(backendDir, "src", "instrumentation.js")) ||
+        fs.existsSync(path.join(backendDir, "src", "instrumentation.ts"))));
 
   return result;
 }
@@ -611,6 +937,10 @@ function detect(cwd) {
 module.exports = {
   detect,
   readPackageJson,
+  scanAllPackageJsons,
+  classifyPackageJson,
+  detectFrontendFramework,
+  findMainFrontendFile,
   detectMonorepo,
   detectFramework,
   detectModuleSystem,

package/cli/generator.js

@@ -366,7 +366,7 @@ export async function POST(req${typeAnnotation}) {
     };
 
     // Forward to BotVersion platform directly
-    const response = await fetch(\`\${process.env.BOTVERSION_PLATFORM_URL || 'https://chatbusiness-two.vercel.app'}/api/chatbot/widget-chat\`, {
+    const response = await fetch(\`\${process.env.BOTVERSION_PLATFORM_URL || 'http://localhost:3000'}/api/chatbot/widget-chat\`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
@@ -405,7 +405,7 @@ export async function POST(req${typeAnnotation}) {
     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\`, {
+    const response = await fetch(\`\${process.env.BOTVERSION_PLATFORM_URL || 'http://localhost:3000'}/api/chatbot/widget-chat\`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
@@ -444,7 +444,7 @@ export async function POST(req${typeAnnotation}) {
     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\`, {
+    const response = await fetch(\`\${process.env.BOTVERSION_PLATFORM_URL || 'http://localhost:3000'}/api/chatbot/widget-chat\`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
@@ -491,7 +491,7 @@ export async function POST(req${typeAnnotation}) {
     // 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\`, {
+    const response = await fetch(\`\${process.env.BOTVERSION_PLATFORM_URL || 'http://localhost:3000'}/api/chatbot/widget-chat\`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
@@ -516,7 +516,7 @@ export async function POST(req${typeAnnotation}) {
 
 // ─── NEXT.JS CONFIG PATCH ─────────────────────────────────────────────────────
 
-function generateNextConfigPatch(cwd) {
+function generateNextConfigPatch(cwd, nextVersion) {
   const candidates = ["next.config.js", "next.config.mjs", "next.config.ts"];
 
   let configPath = null;
@@ -533,6 +533,17 @@ function generateNextConfigPatch(cwd) {
 
   if (!configPath) return null;
 
+  // Skip instrumentationHook for Next.js 14.1+ (enabled by default)
+  if (nextVersion && nextVersion.major >= 14) {
+    // Check minor version too
+    const rawVersion = nextVersion.raw || "";
+    const match = rawVersion.match(/(\d+)\.(\d+)/);
+    const minor = match ? parseInt(match[2], 10) : 0;
+    if (nextVersion.major > 14 || (nextVersion.major === 14 && minor >= 1)) {
+      return { path: configPath, alreadyPatched: true };
+    }
+  }
+
   if (configContent.includes("instrumentationHook")) {
     return { path: configPath, alreadyPatched: true };
   }
@@ -610,6 +621,19 @@ Visit https://docs.botversion.com for manual setup instructions.
   );
 }
 
+// ─── SCRIPT TAG GENERATION ────────────────────────────────────────────────────
+
+function generateScriptTag(projectInfo) {
+  return `<script
+  id="botversion-loader"
+  src="${projectInfo.cdnUrl}"
+  data-api-url="${projectInfo.apiUrl}"
+  data-project-id="${projectInfo.projectId}"
+  data-public-key="${projectInfo.publicKey}"
+  data-proxy-url="/api/botversion/chat"
+></script>`;
+}
+
 module.exports = {
   generateExpressInit,
   generateInstrumentationFile,
@@ -617,4 +641,5 @@ module.exports = {
   generateNextAppChatRoute,
   generateManualInstructions,
   generateNextConfigPatch,
+  generateScriptTag,
 };

package/cli/writer.js

@@ -24,14 +24,15 @@ function backupFile(filePath) {
 
 // ─── INJECT CODE BEFORE app.listen() ────────────────────────────────────────
 
-function injectBeforeListen(filePath, codeToInject) {
+function injectBeforeListen(filePath, codeToInject, appVarName) {
+  appVarName = appVarName || "app";
   const content = fs.readFileSync(filePath, "utf8");
   const lines = content.split("\n");
+  const listenRegex = new RegExp(`${appVarName}\\.listen\\s*\\(`);
 
-  // Find app.listen() line
   let listenLineIndex = -1;
   for (let i = 0; i < lines.length; i++) {
-    if (/app\.listen\s*\(/.test(lines[i])) {
+    if (listenRegex.test(lines[i])) {
       listenLineIndex = i;
       break;
     }
@@ -94,7 +95,8 @@ function createFile(filePath, content, force) {
   return { success: true, path: filePath };
 }
 
-function injectBeforeExport(filePath, codeToInject) {
+function injectBeforeExport(filePath, codeToInject, appVarName) {
+  appVarName = appVarName || "app";
   const content = fs.readFileSync(filePath, "utf8");
   const lines = content.split("\n");
 
@@ -147,7 +149,8 @@ function injectBeforeExport(filePath, codeToInject) {
   // Fallback: before app.listen()
   if (insertIndex === -1) {
     for (let i = 0; i < lines.length; i++) {
-      if (/app\.listen\s*\(/.test(lines[i])) {
+      const listenRegex = new RegExp(`${appVarName}\\.listen\\s*\\(`);
+      if (listenRegex.test(lines[i])) {
         insertIndex = i;
         break;
       }
@@ -238,6 +241,187 @@ function writeSummary(changes) {
   return lines.join("\n");
 }
 
+// ─── INJECT SCRIPT TAG INTO FRONTEND FILE ────────────────────────────────────
+
+function injectScriptTag(filePath, fileType, scriptTag, force) {
+  if (!fs.existsSync(filePath)) {
+    return { success: false, reason: "file_not_found" };
+  }
+
+  const content = fs.readFileSync(filePath, "utf8");
+
+  // Already exists check
+  if (content.includes("botversion-loader")) {
+    if (!force) return { success: false, reason: "already_exists" };
+  }
+
+  const backup = backupFile(filePath);
+
+  // ── HTML file — inject before </body> ──────────────────────────────────
+  if (fileType === "html") {
+    if (!content.includes("</body>")) {
+      return { success: false, reason: "no_body_tag" };
+    }
+
+    const newContent = content.replace("</body>", `  ${scriptTag}\n</body>`);
+    fs.writeFileSync(filePath, newContent, "utf8");
+    return { success: true, backup };
+  }
+
+  // ── Next.js _app.js — inject Script component ──────────────────────────
+  if (fileType === "next") {
+    const fileName = path.basename(filePath);
+
+    // pages/_app.js
+    if (fileName.startsWith("_app")) {
+      return injectIntoNextApp(filePath, content, scriptTag, backup);
+    }
+
+    // app/layout.js
+    if (fileName.startsWith("layout")) {
+      return injectIntoNextLayout(filePath, content, scriptTag, backup);
+    }
+  }
+
+  return { success: false, reason: "unsupported_file_type" };
+}
+
+// ─── INJECT INTO NEXT.JS _app.js ─────────────────────────────────────────────
+
+function injectIntoNextApp(filePath, content, scriptTag, backup) {
+  let newContent = content;
+
+  if (!content.includes("next/script")) {
+    newContent = newContent.replace(
+      /^(import .+)/m,
+      `import Script from 'next/script';\n$1`,
+    );
+  }
+
+  const scriptComponent = `
+      <Script
+        id="botversion-loader"
+        src="${extractAttr(scriptTag, "src")}"
+        data-api-url="${extractAttr(scriptTag, "data-api-url")}"
+        data-project-id="${extractAttr(scriptTag, "data-project-id")}"
+        data-public-key="${extractAttr(scriptTag, "data-public-key")}"
+        data-proxy-url="/api/botversion/chat"
+        strategy="afterInteractive"
+      />`;
+
+  const lines = newContent.split("\n");
+
+  // Find ALL return statements and pick the one whose root JSX
+  // is a multi-child wrapper (not a simple single-element return)
+  // Strategy: find the return ( that is followed by the most lines
+  // before its closing ) — that's the main render return
+
+  let bestReturnIndex = -1;
+  let bestRootJsxIndex = -1;
+  let bestLineCount = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^\s*return\s*\(/.test(lines[i])) continue;
+
+    // Find the root JSX tag after this return
+    let rootJsx = -1;
+    for (let j = i + 1; j < lines.length; j++) {
+      const trimmed = lines[j].trim();
+      if (!trimmed) continue;
+      if (trimmed.startsWith("<")) {
+        rootJsx = j;
+        break;
+      }
+      break; // non-empty, non-JSX line means this isn't a JSX return
+    }
+
+    if (rootJsx === -1) continue;
+
+    // Find the closing ) of this return block
+    let depth = 1;
+    let closingLine = -1;
+    for (let j = rootJsx; j < lines.length; j++) {
+      for (const ch of lines[j]) {
+        if (ch === "(") depth++;
+        if (ch === ")") depth--;
+      }
+      if (depth === 0) {
+        closingLine = j;
+        break;
+      }
+    }
+
+    const lineCount = closingLine - i;
+    if (lineCount > bestLineCount) {
+      bestLineCount = lineCount;
+      bestReturnIndex = i;
+      bestRootJsxIndex = rootJsx;
+    }
+  }
+
+  if (bestRootJsxIndex !== -1) {
+    lines.splice(bestRootJsxIndex + 1, 0, scriptComponent);
+    newContent = lines.join("\n");
+  } else {
+    // Final fallback
+    newContent = newContent.replace(
+      /([ \t]*<\/div>\s*\n\s*\))/,
+      `${scriptComponent}\n$1`,
+    );
+  }
+
+  fs.writeFileSync(filePath, newContent, "utf8");
+  return { success: true, backup };
+}
+
+// ─── INJECT INTO NEXT.JS layout.js ───────────────────────────────────────────
+
+function injectIntoNextLayout(filePath, content, scriptTag, backup) {
+  let newContent = content;
+
+  if (!content.includes("next/script")) {
+    newContent = newContent.replace(
+      /^(import .+)/m,
+      `import Script from 'next/script';\n$1`,
+    );
+  }
+
+  const scriptComponent = `
+      <Script
+        id="botversion-loader"
+        src="${extractAttr(scriptTag, "src")}"
+        data-api-url="${extractAttr(scriptTag, "data-api-url")}"
+        data-project-id="${extractAttr(scriptTag, "data-project-id")}"
+        data-public-key="${extractAttr(scriptTag, "data-public-key")}"
+        data-proxy-url="/api/botversion/chat"
+        strategy="afterInteractive"
+      />`;
+
+  // Inject before </body> in layout
+  if (content.includes("</body>")) {
+    newContent = newContent.replace(
+      "</body>",
+      `${scriptComponent}\n      </body>`,
+    );
+  } else {
+    // Fallback — before last closing tag
+    newContent = newContent.replace(
+      /(<\/\w+>\s*\)[\s;]*$)/m,
+      `${scriptComponent}\n      $1`,
+    );
+  }
+
+  fs.writeFileSync(filePath, newContent, "utf8");
+  return { success: true, backup };
+}
+
+// ─── HELPER: extract attribute value from script tag string ──────────────────
+
+function extractAttr(scriptTag, attr) {
+  const match = scriptTag.match(new RegExp(`${attr}="([^"]+)"`));
+  return match ? match[1] : "";
+}
+
 module.exports = {
   writeFile,
   backupFile,
@@ -247,4 +431,5 @@ module.exports = {
   mergeIntoMiddleware,
   writeSummary,
   injectBeforeExport,
+  injectScriptTag,
 };

package/index.js

@@ -61,8 +61,7 @@ var BotVersion = {
 
     this._client = new BotVersionClient({
       apiKey: options.apiKey,
-      platformUrl:
-        options.platformUrl || "https://chatbusiness-two.vercel.app/",
+      platformUrl: options.platformUrl || "http://localhost:3000/",
       debug: options.debug || false,
       timeout: options.timeout || 30000,
     });

package/package.json

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