@cometchat/skills-cli 2.1.0 → 2.3.0

package/dist/index.js

@@ -283,6 +283,9 @@ var init_state = __esm({
 // src/commands/detect.ts
 import { resolve } from "node:path";
 
+// src/detectors/framework.ts
+import { readdirSync } from "node:fs";
+
 // src/utils/version.ts
 function stripRange(versionRange) {
   return versionRange.replace(/^[\^~>=<\s]+/, "").trim();
@@ -309,7 +312,12 @@ var EMPTY = {
   router: null,
   bundler: null,
   ssr_strategy: null,
-  env_prefix: null
+  env_prefix: null,
+  expo_mode: null,
+  expo_version: null,
+  react_native_version: null,
+  android_version: null,
+  flutter_version: null
 };
 function allDeps(pkg) {
   return {
@@ -320,6 +328,50 @@ function allDeps(pkg) {
 function hasViteConfig(root) {
   return pathExists(p(root, "vite.config.ts")) || pathExists(p(root, "vite.config.js")) || pathExists(p(root, "vite.config.mjs")) || pathExists(p(root, "vite.config.mts"));
 }
+function detectExpo(root, deps, pkg) {
+  if (!deps["expo"]) return null;
+  const expoVersion = extractVersion(deps["expo"]);
+  const rnVersion = deps["react-native"] ? extractVersion(deps["react-native"]) : null;
+  const hasExpoRouter = !!deps["expo-router"];
+  const mainIsExpoRouter = pkg.main === "expo-router/entry" || pkg.main === "expo-router/entry.js";
+  const hasAppLayout = pathExists(p(root, "app/_layout.tsx")) || pathExists(p(root, "app/_layout.ts")) || pathExists(p(root, "app/_layout.jsx")) || pathExists(p(root, "app/_layout.js"));
+  const usingExpoRouter = hasExpoRouter && (mainIsExpoRouter || hasAppLayout);
+  const expoMode = usingExpoRouter ? "expo-router" : "managed";
+  return {
+    framework: "expo",
+    framework_version: expoVersion,
+    router: usingExpoRouter ? "expo-router" : "react-navigation",
+    bundler: "metro",
+    ssr_strategy: "native-no-ssr",
+    env_prefix: "EXPO_PUBLIC_",
+    expo_mode: expoMode,
+    expo_version: expoVersion,
+    react_native_version: rnVersion
+  };
+}
+function detectBareReactNative(root, deps) {
+  if (!deps["react-native"]) return null;
+  if (deps["expo"]) return null;
+  const hasNativeIos = pathExists(p(root, "ios")) && (pathExists(p(root, "ios/Podfile")) || pathExists(p(root, "ios/Podfile.properties.json")));
+  const hasNativeAndroid = pathExists(p(root, "android")) && pathExists(p(root, "android/build.gradle"));
+  const hasRnConfig = pathExists(p(root, "react-native.config.js")) || pathExists(p(root, "react-native.config.ts"));
+  if (!hasNativeIos && !hasNativeAndroid && !hasRnConfig) {
+    return null;
+  }
+  const rnVersion = extractVersion(deps["react-native"]);
+  return {
+    framework: "react-native",
+    framework_version: rnVersion,
+    router: "react-navigation",
+    bundler: "metro",
+    ssr_strategy: "native-no-ssr",
+    env_prefix: null,
+    // Bare RN uses react-native-dotenv or a config module — no prefix
+    expo_mode: null,
+    expo_version: null,
+    react_native_version: rnVersion
+  };
+}
 function detectNextjs(root, deps) {
   if (!deps["next"]) return null;
   const version = extractVersion(deps["next"]);
@@ -387,6 +439,144 @@ function detectAstro(_root, deps) {
     env_prefix: "PUBLIC_"
   };
 }
+function detectIOS(root) {
+  let dirEntries = [];
+  try {
+    dirEntries = readdirSync(root);
+  } catch {
+  }
+  const hasXcode = dirEntries.some(
+    (n) => n.endsWith(".xcodeproj") || n.endsWith(".xcworkspace")
+  );
+  const podfile = readFileOrNull(p(root, "Podfile"));
+  const hasIOSPodfile = !!podfile && /platform\s+:ios/.test(podfile);
+  const packageSwift = readFileOrNull(p(root, "Package.swift"));
+  const hasIOSPackage = !!packageSwift && /\.iOS\s*\(/.test(packageSwift);
+  if (!hasXcode && !hasIOSPodfile && !hasIOSPackage) return null;
+  const podfileLock = readFileOrNull(p(root, "Podfile.lock")) ?? "";
+  const packageResolved = readFileOrNull(p(root, "Package.resolved")) ?? readFileOrNull(p(root, ".swiftpm/Package.resolved")) ?? "";
+  const cocoapodSources = (podfile ?? "") + podfileLock;
+  const spmSources = (packageSwift ?? "") + packageResolved;
+  let ios_version = null;
+  if (
+    // Podfile.lock: `- CometChatUIKitSwift (5.1.12)` / Podfile: `pod 'CometChatUIKitSwift', '~> 5.0'`
+    /CometChatUIKitSwift[^,\n]*?[\s'"(]5\./.test(cocoapodSources) || // Package.resolved: `"identity" : "cometchatuikitswift", ... "version" : "5.x.x"`
+    /cometchatuikitswift[\s\S]{0,300}"version"\s*:\s*"5\./i.test(spmSources) || // Package.swift: `.package(url: "https://github.com/cometchat/...CometChatUIKitSwift", from: "5.0.0")`
+    /CometChatUIKitSwift[\s\S]{0,200}from:\s*"5\./.test(spmSources)
+  ) {
+    ios_version = "v5";
+  }
+  return {
+    framework: "ios",
+    framework_version: null,
+    // Swift / iOS deployment target isn't load-bearing for the dispatcher
+    router: null,
+    bundler: null,
+    ssr_strategy: null,
+    env_prefix: "",
+    // No public-env-prefix; Secrets.swift / xcconfig is the convention
+    ios_version
+  };
+}
+function detectFlutter(root) {
+  const pubspecRaw = readFileOrNull(p(root, "pubspec.yaml"));
+  if (!pubspecRaw) return null;
+  const isFlutter = /\n\s*flutter:\s*\n\s*sdk:\s*flutter/.test(pubspecRaw) || /\n\s*flutter:\s*$/m.test(pubspecRaw) || /\n\s*flutter:\s*\n\s*uses-material-design/.test(pubspecRaw);
+  if (!isFlutter) return null;
+  let flutter_version = null;
+  if (/cometchat_chat_uikit\s*:\s*[\^~]?6\./.test(pubspecRaw)) {
+    flutter_version = "v6";
+  } else if (/cometchat_chat_uikit\s*:\s*[\^~]?5\./.test(pubspecRaw) || /cometchat_calls_uikit\s*:\s*[\^~]?5\./.test(pubspecRaw)) {
+    flutter_version = "v5";
+  }
+  const sdkMatch = pubspecRaw.match(/\n\s*environment:\s*\n\s*sdk:\s*['"]?([^'"\n]+)/);
+  const framework_version = sdkMatch ? sdkMatch[1].trim() : null;
+  return {
+    framework: "flutter",
+    framework_version,
+    router: null,
+    // Flutter routing is in code (Navigator/GoRouter); not modeled here
+    bundler: null,
+    // Dart compiler — no JS bundler
+    ssr_strategy: null,
+    env_prefix: "",
+    // No public-env-prefix; --dart-define or .env-derived constants
+    flutter_version
+  };
+}
+function detectAndroid(root) {
+  const hasSettingsGradle = pathExists(p(root, "settings.gradle")) || pathExists(p(root, "settings.gradle.kts"));
+  const hasBuildGradle = pathExists(p(root, "build.gradle")) || pathExists(p(root, "build.gradle.kts"));
+  if (!hasSettingsGradle && !hasBuildGradle) return null;
+  const hasAppModule = pathExists(p(root, "app/build.gradle")) || pathExists(p(root, "app/build.gradle.kts"));
+  const rootGradle = readFileOrNull(p(root, "build.gradle")) ?? readFileOrNull(p(root, "build.gradle.kts")) ?? "";
+  const settingsGradle = readFileOrNull(p(root, "settings.gradle")) ?? readFileOrNull(p(root, "settings.gradle.kts")) ?? "";
+  const hasAndroidPlugin = /com\.android\.(application|library)/.test(
+    rootGradle + settingsGradle
+  );
+  if (!hasAppModule && !hasAndroidPlugin) return null;
+  const buildFiles = [
+    "build.gradle",
+    "build.gradle.kts",
+    "app/build.gradle",
+    "app/build.gradle.kts"
+  ];
+  let allBuildContent = "";
+  for (const f of buildFiles) {
+    const c = readFileOrNull(p(root, f));
+    if (c) allBuildContent += "\n" + c;
+  }
+  let android_version = null;
+  if (/com\.cometchat:chatuikit-(compose|kotlin)-android:6/.test(allBuildContent)) {
+    android_version = "v6";
+  } else if (/com\.cometchat:chat-uikit-android:5/.test(allBuildContent)) {
+    android_version = "v5";
+  }
+  let android_language = null;
+  const usesKtsGradle = pathExists(p(root, "build.gradle.kts")) || pathExists(p(root, "app/build.gradle.kts")) || pathExists(p(root, "settings.gradle.kts"));
+  const hasKotlinPlugin = /(?:apply\s+plugin\s*:\s*['"]kotlin-android['"]|id\s*\(?\s*['"]org\.jetbrains\.kotlin\.android['"]|id\s*\(?\s*['"]kotlin-android['"])/.test(
+    allBuildContent
+  );
+  if (usesKtsGradle || hasKotlinPlugin) {
+    android_language = "kotlin";
+  } else {
+    const javaDir = p(root, "app/src/main/java");
+    const kotlinDir = p(root, "app/src/main/kotlin");
+    if (pathExists(kotlinDir)) android_language = "kotlin";
+    else if (pathExists(javaDir)) android_language = "java";
+  }
+  return {
+    framework: "android",
+    framework_version: null,
+    // Gradle/AGP version isn't load-bearing for the dispatcher
+    router: null,
+    bundler: null,
+    // No JS bundler for native Android
+    ssr_strategy: null,
+    env_prefix: "",
+    // No public-env-prefix — local.properties + BuildConfig is the convention
+    android_version,
+    android_language
+  };
+}
+function detectAngular(root, deps) {
+  const hasAngularJson = pathExists(p(root, "angular.json"));
+  const hasAngularCore = !!deps["@angular/core"];
+  if (!hasAngularJson && !hasAngularCore) return null;
+  const version = extractVersion(deps["@angular/core"] ?? "");
+  return {
+    framework: "angular",
+    framework_version: version,
+    router: null,
+    // Angular Router is a separate concern; not modeled here yet
+    bundler: "webpack",
+    // Angular CLI ships with webpack; esbuild for v17+ but irrelevant to integration
+    ssr_strategy: "spa-no-ssr",
+    // Angular Universal exists but the integration path is SPA
+    env_prefix: ""
+    // No public-env-prefix — environment.ts is the convention
+  };
+}
 function detectReactjs(root, deps) {
   if (!deps["react"]) return null;
   const version = extractVersion(deps["react"]);
@@ -418,10 +608,16 @@ function detectUsesJsx(root) {
   return false;
 }
 function detectFramework(root) {
+  const flutterInfo = detectFlutter(root);
+  if (flutterInfo) return flutterInfo;
+  const iosInfo = detectIOS(root);
+  if (iosInfo) return iosInfo;
+  const androidInfo = detectAndroid(root);
+  if (androidInfo) return androidInfo;
   const pkg = readJsonOrNull(p(root, "package.json"));
   if (!pkg) return EMPTY;
   const deps = allDeps(pkg);
-  return detectNextjs(root, deps) ?? detectAstro(root, deps) ?? detectReactRouter(root, deps) ?? detectReactjs(root, deps) ?? EMPTY;
+  return detectExpo(root, deps, pkg) ?? detectBareReactNative(root, deps) ?? detectNextjs(root, deps) ?? detectAstro(root, deps) ?? detectReactRouter(root, deps) ?? detectAngular(root, deps) ?? detectReactjs(root, deps) ?? EMPTY;
 }
 
 // src/detectors/package-manager.ts
@@ -436,7 +632,7 @@ function detectPackageManager(root) {
 
 // src/detectors/credentials.ts
 init_fs();
-import { readdirSync, statSync } from "node:fs";
+import { readdirSync as readdirSync2, statSync } from "node:fs";
 import { join as join2, extname } from "node:path";
 function envVarsForPrefix(prefix) {
   const p2 = prefix ?? "";
@@ -504,7 +700,7 @@ function searchForInit(dir, maxDepth) {
   if (maxDepth < 0) return false;
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return false;
   }
@@ -556,7 +752,7 @@ function detectCredentials(root, envPrefix) {
 }
 
 // src/detectors/integration.ts
-import { readdirSync as readdirSync2 } from "node:fs";
+import { readdirSync as readdirSync3 } from "node:fs";
 init_fs();
 function getInstalledVersion(root) {
   const pkg = readJsonOrNull(p(root, "package.json"));
@@ -579,7 +775,7 @@ function findCometchatDirs(root) {
     const fullPath = p(root, dir);
     if (!pathExists(fullPath)) continue;
     try {
-      const entries = readdirSync2(fullPath);
+      const entries = readdirSync3(fullPath);
       for (const entry of entries) {
         found.push(`${dir}/${entry}`);
       }
@@ -633,10 +829,49 @@ function computeCompatibility(fw) {
     return {
       supported: false,
       warnings: [
-        "Could not detect a supported React framework. CometChat skills v2 supports: reactjs (Vite/CRA), nextjs, react-router (v6/v7), astro."
+        "Could not detect a supported React framework. CometChat skills supports: reactjs (Vite/CRA), nextjs, react-router (v6/v7), astro, expo (managed + Expo Router), and react-native (bare CLI)."
       ]
     };
   }
+  if (fw.framework === "expo") {
+    if (fw.expo_version) {
+      const expoMajor = parseInt(fw.expo_version.split(".")[0] ?? "0", 10);
+      if (expoMajor < 49) {
+        return {
+          supported: false,
+          warnings: [
+            `Expo SDK ${fw.expo_version} is older than the tested baseline (49+). CometChat React Native UI Kit v5 requires Expo SDK 49 or newer. Run \`npx expo install expo\` to upgrade.`
+          ]
+        };
+      }
+    }
+    if (fw.react_native_version) {
+      const rnMinor = parseFloat(fw.react_native_version.split(".").slice(0, 2).join("."));
+      if (!isNaN(rnMinor) && rnMinor < 0.72) {
+        warnings.push(
+          `React Native ${fw.react_native_version} is below the recommended baseline (0.72+). Some UI Kit v5 features may not work.`
+        );
+      }
+    }
+  }
+  if (fw.framework === "react-native") {
+    if (fw.react_native_version) {
+      const rnMinor = parseFloat(fw.react_native_version.split(".").slice(0, 2).join("."));
+      if (!isNaN(rnMinor) && rnMinor < 0.7) {
+        return {
+          supported: false,
+          warnings: [
+            `React Native ${fw.react_native_version} is older than the tested baseline (0.70+). CometChat React Native UI Kit v5 requires RN 0.70 or newer.`
+          ]
+        };
+      }
+      if (rnMinor < 0.72) {
+        warnings.push(
+          `React Native ${fw.react_native_version} is below the recommended baseline (0.72+). Upgrade is recommended.`
+        );
+      }
+    }
+  }
   if (fw.framework === "nextjs") {
     if (fw.router === null) {
       warnings.push(
@@ -732,6 +967,34 @@ function detectArchitectureContext(root) {
   };
 }
 
+// src/detectors/project-name.ts
+init_fs();
+function detectProjectName(root) {
+  const pkg = readJsonOrNull(p(root, "package.json"));
+  if (pkg?.name) return cleanName(pkg.name);
+  const pubspec = readFileOrNull(p(root, "pubspec.yaml"));
+  if (pubspec) {
+    const m = pubspec.match(/^\s*name\s*:\s*['"]?([A-Za-z_][A-Za-z0-9_]*)['"]?\s*$/m);
+    if (m) return cleanName(m[1]);
+  }
+  const packageSwift = readFileOrNull(p(root, "Package.swift"));
+  if (packageSwift) {
+    const m = packageSwift.match(/Package\s*\(\s*name\s*:\s*"([^"]+)"/);
+    if (m) return cleanName(m[1]);
+  }
+  for (const file of ["settings.gradle.kts", "settings.gradle"]) {
+    const content = readFileOrNull(p(root, file));
+    if (!content) continue;
+    const m = content.match(/rootProject\.name\s*=\s*['"]([^'"\n]+)['"]/);
+    if (m) return cleanName(m[1]);
+  }
+  return null;
+}
+function cleanName(raw) {
+  const trimmed = raw.trim().slice(0, 64);
+  return trimmed.length > 0 ? trimmed : null;
+}
+
 // src/detectors/index.ts
 async function runDetectors(root) {
   const fw = detectFramework(root);
@@ -740,6 +1003,7 @@ async function runDetectors(root) {
   const existing_integration = detectExistingIntegration(root);
   const compatibility = computeCompatibility(fw);
   const architecture_context = detectArchitectureContext(root);
+  const project_name = detectProjectName(root);
   return {
     project_root: root,
     framework: fw.framework,
@@ -750,6 +1014,14 @@ async function runDetectors(root) {
     env_prefix: fw.env_prefix,
     uses_jsx: fw.uses_jsx,
     react_router_mode: fw.react_router_mode,
+    expo_mode: fw.expo_mode,
+    expo_version: fw.expo_version,
+    react_native_version: fw.react_native_version,
+    android_version: fw.android_version,
+    android_language: fw.android_language,
+    flutter_version: fw.flutter_version,
+    ios_version: fw.ios_version,
+    project_name,
     package_manager,
     credentials,
     existing_integration,
@@ -826,10 +1098,23 @@ function printHumanReadable(r) {
   lines.push("");
   lines.push(`  Project:           ${r.project_root}`);
   lines.push(`  Framework:         ${r.framework ?? "unknown"}${r.framework_version ? ` (${r.framework_version})` : ""}`);
+  if (r.expo_mode && r.expo_mode !== null) lines.push(`  Expo mode:         ${r.expo_mode}`);
+  if (r.react_native_version && r.framework === "expo") {
+    lines.push(`  React Native:      ${r.react_native_version}`);
+  }
+  if (r.framework === "android") {
+    lines.push(`  Android UIKit:     ${r.android_version ?? "(none yet \u2014 greenfield)"}`);
+  }
+  if (r.framework === "flutter") {
+    lines.push(`  Flutter UIKit:     ${r.flutter_version ?? "(none yet \u2014 greenfield)"}`);
+  }
   if (r.router !== null) lines.push(`  Router:            ${r.router}`);
   if (r.bundler !== null) lines.push(`  Bundler:           ${r.bundler}`);
   if (r.ssr_strategy !== null) lines.push(`  SSR strategy:      ${r.ssr_strategy}`);
   if (r.env_prefix !== null) lines.push(`  Env var prefix:    ${r.env_prefix}`);
+  if (r.framework === "react-native" && r.env_prefix === null) {
+    lines.push(`  Env var prefix:    (none \u2014 bare RN uses react-native-dotenv or a config module)`);
+  }
   if (r.package_manager !== null) lines.push(`  Package manager:   ${r.package_manager}`);
   if (r.uses_jsx === true) {
     lines.push(`  Source language:   JavaScript (.jsx) \u2014 \u26A0 apply will refuse, the v6 templates are TypeScript-only`);
@@ -2890,6 +3175,73 @@ function checkInitBeforeLogin(root, ownedAndPatchedFiles) {
   }
   return { status: "skip", reason: "no file calling CometChatUIKit.init found" };
 }
+function checkGestureHandlerLine1(root) {
+  const entryCandidates = ["index.js", "index.ts", "App.tsx", "App.jsx", "app/_layout.tsx", "app/_layout.js"];
+  for (const e of entryCandidates) {
+    if (!pathExists(p(root, e))) continue;
+    const content = readFileOrNull(p(root, e));
+    if (!content) continue;
+    const firstLine = content.split(/\r?\n/)[0]?.trim() ?? "";
+    if (/^import\s+['"]react-native-gesture-handler['"]/.test(firstLine)) {
+      return { status: "pass" };
+    }
+    return {
+      status: "fail",
+      reason: `${e}: \`import "react-native-gesture-handler"\` is not the first line`
+    };
+  }
+  return { status: "skip", reason: "no entry file found" };
+}
+function checkFourWrapperChain(root, ownedAndPatchedFiles) {
+  const wrappers = ["GestureHandlerRootView", "SafeAreaProvider", "CometChatThemeProvider", "CometChatProvider"];
+  const hits = /* @__PURE__ */ new Set();
+  for (const file of ownedAndPatchedFiles) {
+    const content = readFileOrNull(p(root, file));
+    if (!content) continue;
+    for (const w of wrappers) {
+      if (content.includes(w)) hits.add(w);
+    }
+  }
+  const missing = wrappers.filter((w) => !hits.has(w));
+  if (missing.length === 0) return { status: "pass" };
+  return {
+    status: "fail",
+    reason: `missing wrapper(s): ${missing.join(", ")}`
+  };
+}
+function checkHideReplyInThread(root, ownedAndPatchedFiles, ownedFiles) {
+  for (const file of ownedAndPatchedFiles) {
+    const content = readFileOrNull(p(root, file));
+    if (content && content.includes("CometChatThreadHeader")) {
+      return { status: "pass" };
+    }
+  }
+  for (const file of ownedFiles) {
+    const content = readFileOrNull(p(root, file));
+    if (!content) continue;
+    const lists = (content.match(/<\s*CometChatMessageList\b/g) ?? []).length;
+    const flagged = (content.match(/hideReplyInThreadOption/g) ?? []).length;
+    if (lists > flagged) {
+      return {
+        status: "fail",
+        reason: `${file}: ${lists - flagged} MessageList without hideReplyInThreadOption`
+      };
+    }
+  }
+  return { status: "pass" };
+}
+function checkPodInstall(root) {
+  if (!pathExists(p(root, "ios/Podfile"))) {
+    return { status: "skip", reason: "no ios/Podfile (Expo managed or no iOS target)" };
+  }
+  if (pathExists(p(root, "ios/Podfile.lock"))) {
+    return { status: "pass" };
+  }
+  return {
+    status: "fail",
+    reason: "ios/Podfile.lock missing \u2014 run `cd ios && pod install && cd ..`"
+  };
+}
 function checkErrorUiVisible(root, ownedFiles) {
   for (const file of ownedFiles) {
     const content = readFileOrNull(p(root, file));
@@ -2927,7 +3279,15 @@ async function verify(args) {
     ...state2.files_owned,
     ...state2.files_patched.map((p2) => p2.path)
   ];
-  const checks = {
+  const isRn2 = state2.framework === "expo" || state2.framework === "react-native";
+  const checks = isRn2 ? {
+    gesture_handler_line_1: checkGestureHandlerLine1(root),
+    four_wrapper_chain_present: checkFourWrapperChain(root, ownedAndPatched),
+    hide_reply_in_thread_option: checkHideReplyInThread(root, ownedAndPatched, state2.files_owned),
+    no_auth_key_in_source: checkNoAuthKeyInSource(root, state2.files_owned),
+    init_before_login: checkInitBeforeLogin(root, ownedAndPatched),
+    ...state2.framework === "react-native" ? { pod_install_run: checkPodInstall(root) } : {}
+  } : {
     css_variables_imported_once: checkCssVariablesImport(root, ownedAndPatched),
     init_before_login: checkInitBeforeLogin(root, ownedAndPatched),
     render_gated_on_login_resolve: checkRenderGatedOnLogin(root, ownedAndPatched),
@@ -2963,7 +3323,7 @@ function printHumanReadable5(r) {
 // src/commands/uninstall.ts
 init_state();
 init_fs();
-import { rmSync as rmSync2, statSync as statSync3, rmdirSync, readdirSync as readdirSync3 } from "node:fs";
+import { rmSync as rmSync2, statSync as statSync3, rmdirSync, readdirSync as readdirSync4 } from "node:fs";
 import { dirname as dirname6, join as join9, resolve as resolve7 } from "node:path";
 var HELP6 = `
 cometchat uninstall \u2014 remove the CometChat integration cleanly
@@ -2997,7 +3357,7 @@ function projectPath6(args) {
 }
 function maybeRemoveEmptyDir(dir) {
   try {
-    const entries = readdirSync3(dir);
+    const entries = readdirSync4(dir);
     if (entries.length === 0) {
       rmdirSync(dir);
       maybeRemoveEmptyDir(dirname6(dir));
@@ -3074,7 +3434,7 @@ async function uninstall(args) {
   try {
     const cometchatDir = p(root, ".cometchat");
     if (statSync3(cometchatDir).isDirectory()) {
-      const entries = readdirSync3(cometchatDir);
+      const entries = readdirSync4(cometchatDir);
       if (entries.length === 0) rmdirSync(cometchatDir);
     }
   } catch {
@@ -3337,24 +3697,485 @@ function printHumanReadable7(r) {
 init_state();
 import { readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join10, resolve as resolve9 } from "node:path";
+init_config();
+
+// src/utils/rn-production-templates.ts
+var HEADER = `/**
+ * /cometchat-token \u2014 server-side endpoint that mints CometChat auth tokens.
+ *
+ * This is the production-mode replacement for client-side login({ uid }) +
+ * Auth Key. The Auth Key NEVER leaves the server. The RN app calls this
+ * endpoint to get a short-lived auth token, then passes it to
+ * CometChatUIKit.login({ authToken }).
+ *
+ * Generated by \`cometchat production-auth\`. Customize freely:
+ *   - Replace the ?uid= query param with real auth: read the session token,
+ *     extract the user ID, map it to a CometChat UID.
+ *   - Add rate limiting if exposed publicly.
+ *   - Cache tokens per UID for short windows to reduce CometChat API load.
+ *
+ * Security: this file MUST NOT use EXPO_PUBLIC_ prefixes for the Auth Key.
+ * The whole point is to keep the Auth Key out of the client bundle.
+ */`;
+var EXPRESS_TEMPLATE = `${HEADER}
+import express from "express";
+
+const app = express();
+app.use(express.json());
+
+const COMETCHAT_APP_ID = process.env.COMETCHAT_APP_ID!;
+const COMETCHAT_REGION = process.env.COMETCHAT_REGION!;
+const COMETCHAT_AUTH_KEY = process.env.COMETCHAT_AUTH_KEY!;
+
+app.get("/cometchat-token", async (req, res) => {
+  // \u26A0 Replace this with your real auth: extract the session token, verify it,
+  // and map your user record to a CometChat UID. Do not trust the query param.
+  const uid = typeof req.query.uid === "string" ? req.query.uid : "cometchat-uid-1";
+
+  if (!COMETCHAT_APP_ID || !COMETCHAT_REGION || !COMETCHAT_AUTH_KEY) {
+    return res.status(500).json({ error: "CometChat credentials not configured on the server" });
+  }
+
+  try {
+    const upstream = await fetch(
+      \`https://\${COMETCHAT_APP_ID}.api-\${COMETCHAT_REGION}.cometchat.io/v3/users/\${encodeURIComponent(uid)}/auth_tokens\`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          appid: COMETCHAT_APP_ID,
+          apikey: COMETCHAT_AUTH_KEY,
+        },
+      },
+    );
+    if (!upstream.ok) {
+      const text = await upstream.text();
+      return res.status(502).json({ error: \`CometChat token mint failed (\${upstream.status})\`, detail: text });
+    }
+    const body = (await upstream.json()) as { data?: { authToken?: string } };
+    const authToken = body.data?.authToken;
+    if (!authToken) {
+      return res.status(502).json({ error: "CometChat API returned no authToken" });
+    }
+    return res.json({ authToken });
+  } catch (err) {
+    return res.status(500).json({ error: "Upstream CometChat request failed", detail: String(err) });
+  }
+});
+
+const PORT = Number(process.env.PORT ?? 8787);
+app.listen(PORT, () => console.log(\`cometchat-token endpoint listening on :\${PORT}\`));
+`;
+var HONO_TEMPLATE = `${HEADER}
+import { Hono } from "hono";
+
+const app = new Hono();
+
+app.get("/cometchat-token", async (c) => {
+  const COMETCHAT_APP_ID = process.env.COMETCHAT_APP_ID!;
+  const COMETCHAT_REGION = process.env.COMETCHAT_REGION!;
+  const COMETCHAT_AUTH_KEY = process.env.COMETCHAT_AUTH_KEY!;
+
+  // \u26A0 Replace this with your real auth: extract the session token, verify it,
+  // and map your user record to a CometChat UID. Do not trust the query param.
+  const uid = c.req.query("uid") ?? "cometchat-uid-1";
+
+  if (!COMETCHAT_APP_ID || !COMETCHAT_REGION || !COMETCHAT_AUTH_KEY) {
+    return c.json({ error: "CometChat credentials not configured on the server" }, 500);
+  }
+
+  try {
+    const upstream = await fetch(
+      \`https://\${COMETCHAT_APP_ID}.api-\${COMETCHAT_REGION}.cometchat.io/v3/users/\${encodeURIComponent(uid)}/auth_tokens\`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          appid: COMETCHAT_APP_ID,
+          apikey: COMETCHAT_AUTH_KEY,
+        },
+      },
+    );
+    if (!upstream.ok) {
+      return c.json({ error: \`CometChat token mint failed (\${upstream.status})\` }, 502);
+    }
+    const body = (await upstream.json()) as { data?: { authToken?: string } };
+    const authToken = body.data?.authToken;
+    if (!authToken) return c.json({ error: "CometChat API returned no authToken" }, 502);
+    return c.json({ authToken });
+  } catch (err) {
+    return c.json({ error: "Upstream CometChat request failed", detail: String(err) }, 500);
+  }
+});
+
+export default app;
+`;
+var FIREBASE_TEMPLATE = `${HEADER}
+import { onRequest } from "firebase-functions/v2/https";
+import { defineSecret } from "firebase-functions/params";
+
+const COMETCHAT_APP_ID = defineSecret("COMETCHAT_APP_ID");
+const COMETCHAT_REGION = defineSecret("COMETCHAT_REGION");
+const COMETCHAT_AUTH_KEY = defineSecret("COMETCHAT_AUTH_KEY");
+
+export const cometchatToken = onRequest(
+  { secrets: [COMETCHAT_APP_ID, COMETCHAT_REGION, COMETCHAT_AUTH_KEY] },
+  async (req, res) => {
+    // \u26A0 Replace this with your real auth: verify Firebase ID token, map the
+    // Firebase uid to a CometChat UID. Do not trust the query param.
+    const uid = typeof req.query.uid === "string" ? req.query.uid : "cometchat-uid-1";
+
+    try {
+      const upstream = await fetch(
+        \`https://\${COMETCHAT_APP_ID.value()}.api-\${COMETCHAT_REGION.value()}.cometchat.io/v3/users/\${encodeURIComponent(uid)}/auth_tokens\`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            appid: COMETCHAT_APP_ID.value(),
+            apikey: COMETCHAT_AUTH_KEY.value(),
+          },
+        },
+      );
+      if (!upstream.ok) {
+        res.status(502).json({ error: \`CometChat token mint failed (\${upstream.status})\` });
+        return;
+      }
+      const body = (await upstream.json()) as { data?: { authToken?: string } };
+      const authToken = body.data?.authToken;
+      if (!authToken) {
+        res.status(502).json({ error: "CometChat API returned no authToken" });
+        return;
+      }
+      res.json({ authToken });
+    } catch (err) {
+      res.status(500).json({ error: "Upstream CometChat request failed", detail: String(err) });
+    }
+  },
+);
+`;
+var NEXTJS_API_TEMPLATE = `${HEADER}
+import { NextRequest, NextResponse } from "next/server";
+
+const COMETCHAT_APP_ID = process.env.COMETCHAT_APP_ID!;
+const COMETCHAT_REGION = process.env.COMETCHAT_REGION!;
+const COMETCHAT_AUTH_KEY = process.env.COMETCHAT_AUTH_KEY!;
+
+export async function GET(request: NextRequest) {
+  // \u26A0 Replace this with your real auth: read the session, extract the user ID,
+  // then map it to a CometChat UID. Do not trust the query param in production.
+  const uid = request.nextUrl.searchParams.get("uid") ?? "cometchat-uid-1";
+
+  if (!COMETCHAT_APP_ID || !COMETCHAT_REGION || !COMETCHAT_AUTH_KEY) {
+    return NextResponse.json(
+      { error: "CometChat credentials not configured on the server" },
+      { status: 500 },
+    );
+  }
+
+  try {
+    const upstream = await fetch(
+      \`https://\${COMETCHAT_APP_ID}.api-\${COMETCHAT_REGION}.cometchat.io/v3/users/\${encodeURIComponent(uid)}/auth_tokens\`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          appid: COMETCHAT_APP_ID,
+          apikey: COMETCHAT_AUTH_KEY,
+        },
+      },
+    );
+    if (!upstream.ok) {
+      const text = await upstream.text();
+      return NextResponse.json({ error: \`CometChat token mint failed (\${upstream.status})\`, detail: text }, { status: 502 });
+    }
+    const body = (await upstream.json()) as { data?: { authToken?: string } };
+    const authToken = body.data?.authToken;
+    if (!authToken) return NextResponse.json({ error: "CometChat API returned no authToken" }, { status: 502 });
+    return NextResponse.json({ authToken });
+  } catch (err) {
+    return NextResponse.json({ error: "Upstream CometChat request failed", detail: String(err) }, { status: 500 });
+  }
+}
+`;
+var USER_MGMT_HEADER = `/**
+ * /cometchat-user \u2014 server-side user CRUD endpoint.
+ *
+ * Proxies to the CometChat REST API to keep your AUTH_KEY out of the client.
+ * Wire this into your app's signup / profile-update / account-deletion flows
+ * so every app user has a matching CometChat user.
+ *
+ * Generated by \`cometchat add-user-mgmt\`. Ships UNAUTHENTICATED \u2014 you MUST
+ * add session checks (verify the caller's auth token / cookie) before
+ * deploying. Anyone hitting this endpoint can create/update/delete arbitrary
+ * CometChat users.
+ */`;
+var EXPRESS_USER_TEMPLATE = `${USER_MGMT_HEADER}
+import express from "express";
+
+const app = express();
+app.use(express.json());
+
+const APP_ID = process.env.COMETCHAT_APP_ID!;
+const REGION = process.env.COMETCHAT_REGION!;
+const AUTH_KEY = process.env.COMETCHAT_AUTH_KEY!;
+const BASE = \`https://\${APP_ID}.api-\${REGION}.cometchat.io/v3/users\`;
+
+async function cometchat(method: string, path: string, body?: unknown): Promise<Response> {
+  return fetch(\`\${BASE}\${path}\`, {
+    method,
+    headers: { "Content-Type": "application/json", appid: APP_ID, apikey: AUTH_KEY },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+}
+
+app.post("/cometchat-user", async (req, res) => {
+  // \u26A0 Add auth check here \u2014 verify the caller owns the uid they're creating.
+  const { uid, name, avatar, metadata } = req.body ?? {};
+  if (!uid || !name) return res.status(400).json({ error: "uid + name required" });
+  const r = await cometchat("POST", "", { uid, name, avatar, metadata });
+  return res.status(r.ok ? 201 : r.status).json(await r.json());
+});
+
+app.patch("/cometchat-user/:uid", async (req, res) => {
+  const r = await cometchat("PUT", \`/\${encodeURIComponent(req.params.uid)}\`, req.body);
+  return res.status(r.ok ? 200 : r.status).json(await r.json());
+});
+
+app.delete("/cometchat-user/:uid", async (req, res) => {
+  const r = await cometchat("DELETE", \`/\${encodeURIComponent(req.params.uid)}?permanent=true\`);
+  return res.status(r.ok ? 200 : r.status).json(r.ok ? { deleted: true } : await r.json());
+});
+
+const PORT = Number(process.env.PORT ?? 8787);
+app.listen(PORT, () => console.log(\`cometchat-user endpoint listening on :\${PORT}\`));
+`;
+var HONO_USER_TEMPLATE = `${USER_MGMT_HEADER}
+import { Hono } from "hono";
+
+const app = new Hono();
+
+async function cometchat(method: string, path: string, body?: unknown): Promise<Response> {
+  const APP_ID = process.env.COMETCHAT_APP_ID!;
+  const REGION = process.env.COMETCHAT_REGION!;
+  const AUTH_KEY = process.env.COMETCHAT_AUTH_KEY!;
+  return fetch(\`https://\${APP_ID}.api-\${REGION}.cometchat.io/v3/users\${path}\`, {
+    method,
+    headers: { "Content-Type": "application/json", appid: APP_ID, apikey: AUTH_KEY },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+}
+
+app.post("/cometchat-user", async (c) => {
+  // \u26A0 Add auth check here \u2014 verify the caller owns the uid they're creating.
+  const { uid, name, avatar, metadata } = (await c.req.json()) ?? {};
+  if (!uid || !name) return c.json({ error: "uid + name required" }, 400);
+  const r = await cometchat("POST", "", { uid, name, avatar, metadata });
+  return c.json(await r.json(), r.ok ? 201 : (r.status as 500));
+});
+
+app.patch("/cometchat-user/:uid", async (c) => {
+  const r = await cometchat("PUT", \`/\${encodeURIComponent(c.req.param("uid"))}\`, await c.req.json());
+  return c.json(await r.json(), r.ok ? 200 : (r.status as 500));
+});
+
+app.delete("/cometchat-user/:uid", async (c) => {
+  const r = await cometchat("DELETE", \`/\${encodeURIComponent(c.req.param("uid"))}?permanent=true\`);
+  return c.json(r.ok ? { deleted: true } : await r.json(), r.ok ? 200 : (r.status as 500));
+});
+
+export default app;
+`;
+var FIREBASE_USER_TEMPLATE = `${USER_MGMT_HEADER}
+import { onRequest } from "firebase-functions/v2/https";
+import { defineSecret } from "firebase-functions/params";
+
+const COMETCHAT_APP_ID = defineSecret("COMETCHAT_APP_ID");
+const COMETCHAT_REGION = defineSecret("COMETCHAT_REGION");
+const COMETCHAT_AUTH_KEY = defineSecret("COMETCHAT_AUTH_KEY");
+
+async function cometchat(method: string, path: string, body?: unknown): Promise<Response> {
+  return fetch(\`https://\${COMETCHAT_APP_ID.value()}.api-\${COMETCHAT_REGION.value()}.cometchat.io/v3/users\${path}\`, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      appid: COMETCHAT_APP_ID.value(),
+      apikey: COMETCHAT_AUTH_KEY.value(),
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+}
+
+export const cometchatUser = onRequest(
+  { secrets: [COMETCHAT_APP_ID, COMETCHAT_REGION, COMETCHAT_AUTH_KEY] },
+  async (req, res) => {
+    // \u26A0 Add auth check: verify Firebase ID token, authorize the caller.
+    const method = req.method;
+    const segs = (req.path ?? "").split("/").filter(Boolean); // ["cometchat-user"] or ["cometchat-user", "<uid>"]
+    const uid = segs.length >= 2 ? segs[1] : null;
+
+    if (method === "POST" && !uid) {
+      const { uid: newUid, name, avatar, metadata } = (req.body ?? {}) as Record<string, unknown>;
+      if (!newUid || !name) { res.status(400).json({ error: "uid + name required" }); return; }
+      const r = await cometchat("POST", "", { uid: newUid, name, avatar, metadata });
+      res.status(r.ok ? 201 : r.status).json(await r.json()); return;
+    }
+    if (method === "PATCH" && uid) {
+      const r = await cometchat("PUT", \`/\${encodeURIComponent(uid)}\`, req.body);
+      res.status(r.ok ? 200 : r.status).json(await r.json()); return;
+    }
+    if (method === "DELETE" && uid) {
+      const r = await cometchat("DELETE", \`/\${encodeURIComponent(uid)}?permanent=true\`);
+      res.status(r.ok ? 200 : r.status).json(r.ok ? { deleted: true } : await r.json()); return;
+    }
+    res.status(405).json({ error: "method/path not allowed" });
+  },
+);
+`;
+var NEXTJS_USER_TEMPLATE = `${USER_MGMT_HEADER}
+import { NextRequest, NextResponse } from "next/server";
+
+const APP_ID = process.env.COMETCHAT_APP_ID!;
+const REGION = process.env.COMETCHAT_REGION!;
+const AUTH_KEY = process.env.COMETCHAT_AUTH_KEY!;
+const BASE = \`https://\${APP_ID}.api-\${REGION}.cometchat.io/v3/users\`;
+
+async function cometchat(method: string, path: string, body?: unknown): Promise<Response> {
+  return fetch(\`\${BASE}\${path}\`, {
+    method,
+    headers: { "Content-Type": "application/json", appid: APP_ID, apikey: AUTH_KEY },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+}
+
+// POST /api/cometchat-user \u2014 create user. Wire into your signup flow.
+export async function POST(request: NextRequest) {
+  // \u26A0 Add auth check here \u2014 verify the caller's session.
+  const { uid, name, avatar, metadata } = await request.json();
+  if (!uid || !name) return NextResponse.json({ error: "uid + name required" }, { status: 400 });
+  const r = await cometchat("POST", "", { uid, name, avatar, metadata });
+  return NextResponse.json(await r.json(), { status: r.ok ? 201 : r.status });
+}
+
+// PATCH /api/cometchat-user?uid=<id> \u2014 update user.
+export async function PATCH(request: NextRequest) {
+  const uid = request.nextUrl.searchParams.get("uid");
+  if (!uid) return NextResponse.json({ error: "uid query param required" }, { status: 400 });
+  const r = await cometchat("PUT", \`/\${encodeURIComponent(uid)}\`, await request.json());
+  return NextResponse.json(await r.json(), { status: r.ok ? 200 : r.status });
+}
+
+// DELETE /api/cometchat-user?uid=<id> \u2014 permanent user delete.
+export async function DELETE(request: NextRequest) {
+  const uid = request.nextUrl.searchParams.get("uid");
+  if (!uid) return NextResponse.json({ error: "uid query param required" }, { status: 400 });
+  const r = await cometchat("DELETE", \`/\${encodeURIComponent(uid)}?permanent=true\`);
+  return NextResponse.json(r.ok ? { deleted: true } : await r.json(), { status: r.ok ? 200 : r.status });
+}
+`;
+function rnUserMgmtTemplate(backend) {
+  switch (backend) {
+    case "express":
+      return {
+        filename: "cometchat-user.ts",
+        content: EXPRESS_USER_TEMPLATE,
+        deps: ["express"],
+        runCommand: "npx tsx cometchat-user.ts",
+        label: "Express user-mgmt endpoint"
+      };
+    case "hono":
+      return {
+        filename: "cometchat-user.ts",
+        content: HONO_USER_TEMPLATE,
+        deps: ["hono"],
+        runCommand: "npx tsx cometchat-user.ts  # or bun run",
+        label: "Hono user-mgmt endpoint"
+      };
+    case "firebase-functions":
+      return {
+        filename: "cometchatUser.ts",
+        content: FIREBASE_USER_TEMPLATE,
+        deps: ["firebase-functions"],
+        runCommand: "firebase deploy --only functions",
+        label: "Firebase Functions user-mgmt endpoint"
+      };
+    case "nextjs-api":
+      return {
+        filename: "route.ts",
+        content: NEXTJS_USER_TEMPLATE,
+        deps: [],
+        runCommand: null,
+        label: "Next.js API route (drop into src/app/api/cometchat-user/route.ts)"
+      };
+  }
+}
+function rnBackendTemplate(backend) {
+  switch (backend) {
+    case "express":
+      return {
+        filename: "cometchat-token.ts",
+        content: EXPRESS_TEMPLATE,
+        deps: ["express"],
+        runCommand: "npx tsx cometchat-token.ts",
+        label: "Express server"
+      };
+    case "hono":
+      return {
+        filename: "cometchat-token.ts",
+        content: HONO_TEMPLATE,
+        deps: ["hono"],
+        runCommand: "npx tsx cometchat-token.ts  # or bun run, depending on your runtime",
+        label: "Hono router (works with Bun, Cloudflare Workers, Node, Deno)"
+      };
+    case "firebase-functions":
+      return {
+        filename: "cometchatToken.ts",
+        content: FIREBASE_TEMPLATE,
+        deps: ["firebase-functions"],
+        runCommand: "firebase deploy --only functions",
+        label: "Firebase Cloud Functions (v2)"
+      };
+    case "nextjs-api":
+      return {
+        filename: "route.ts",
+        content: NEXTJS_API_TEMPLATE,
+        deps: [],
+        runCommand: null,
+        label: "Next.js App Router API route (add to an existing Next app under src/app/api/cometchat-token/route.ts)"
+      };
+  }
+}
+var RN_BACKENDS = ["express", "hono", "firebase-functions", "nextjs-api"];
+
+// src/commands/production-auth.ts
 var HELP8 = `
 cometchat production-auth \u2014 upgrade dev integration to server-side tokens
 
-Usage:
+Usage (web \u2014 nextjs / react-router / astro):
   cometchat production-auth [--path <p>] [--json]
 
+Usage (React Native \u2014 expo / react-native):
+  cometchat production-auth --backend <express|hono|firebase-functions|nextjs-api>
+                            [--out-dir <path>] [--path <p>] [--json]
+
 What this does:
-  Replaces client-side login(UID) + setAuthKey() with a server-side token
-  endpoint so your AUTH_KEY never reaches the browser. Creates the API
-  route file and auto-rewrites the canonical client login chain into a
-  fetch('/api/cometchat-token?uid=...') \u2192 loginWithAuthToken flow. If the
-  client file was customized, the auto-patch is skipped and manual steps
-  are surfaced. Supports nextjs, react-router, and astro.
+  Web: replaces client-side login(UID) + setAuthKey() with a server-side
+       token endpoint so your AUTH_KEY never reaches the browser. Creates
+       the API route file and auto-rewrites the client login chain.
+  RN:  writes a standalone token endpoint (your choice of backend \u2014 Express,
+       Hono, Firebase Functions, or a Next.js API route file you drop into
+       an adjacent Next app). Does not patch the RN client \u2014 prints manual
+       steps to update your CometChatProvider.
 
 Flags:
-  --path <p>  Project root (defaults to cwd).
-  --json      Machine-readable JSON output.
-  --help, -h  Show this help.
+  --backend <name>  (RN only) Backend flavor. One of: express, hono,
+                    firebase-functions, nextjs-api.
+  --out-dir <path>  (RN only) Directory to write the endpoint file to
+                    (default: ./server for express/hono/nextjs-api,
+                    ./functions/src for firebase-functions).
+  --path <p>        Project root (defaults to cwd).
+  --json            Machine-readable JSON output.
+  --help, -h        Show this help.
 `;
 function isJsonMode9(args) {
   return args.flags.json === true || args.flags.json === "true";
@@ -3425,13 +4246,29 @@ async function productionAuth(args) {
     return 0;
   }
   const root = projectPath8(args);
-  if (!hasState(root)) {
+  const stateFramework = hasState(root) ? readState(root)?.framework ?? null : null;
+  const cfgFramework = readConfig(root)?.framework ?? null;
+  const resolvedFramework = stateFramework ?? cfgFramework;
+  if (!resolvedFramework) {
     const result2 = {
       status: "no-integration",
       framework: "",
       files_created: [],
       next_steps: [],
-      error: "API_ERROR: ERR_NO_INTEGRATION No integration found. Run `cometchat apply` first to create the dev integration, then run this command to upgrade to production-ready auth."
+      error: "API_ERROR: ERR_NO_INTEGRATION No integration found. Run `cometchat apply` (web) or `/cometchat` (React Native) first to create the dev integration, then re-run this command."
+    };
+    return outputResult5(args, result2, 1);
+  }
+  if (resolvedFramework === "expo" || resolvedFramework === "react-native") {
+    return productionAuthRn(args, root, resolvedFramework);
+  }
+  if (!hasState(root)) {
+    const result2 = {
+      status: "no-integration",
+      framework: resolvedFramework,
+      files_created: [],
+      next_steps: [],
+      error: "API_ERROR: ERR_NO_STATE Web production-auth requires state.json. Run `cometchat apply` first (or `cometchat state record` if your integration was hand-written)."
     };
     return outputResult5(args, result2, 1);
   }
@@ -3639,6 +4476,84 @@ function printHumanReadable8(r) {
   lines.push("");
   console.log(lines.join("\n"));
 }
+function productionAuthRn(args, root, framework) {
+  const backendFlag = args.flags.backend;
+  const outDirFlag = args.flags["out-dir"];
+  if (typeof backendFlag !== "string" || !RN_BACKENDS.includes(backendFlag)) {
+    const result2 = {
+      status: "error",
+      framework,
+      files_created: [],
+      next_steps: [],
+      error: `React Native production-auth requires --backend <${RN_BACKENDS.join("|")}>. Example: \`cometchat production-auth --backend express --out-dir ./server\`. RN apps don't have a colocated backend, so you pick which flavor to scaffold.`
+    };
+    return outputResult5(args, result2, 1);
+  }
+  const backend = backendFlag;
+  const tpl = rnBackendTemplate(backend);
+  const defaultOutDir = backend === "firebase-functions" ? "functions/src" : backend === "nextjs-api" ? "src/app/api/cometchat-token" : "server";
+  const outDir = typeof outDirFlag === "string" ? outDirFlag : defaultOutDir;
+  const filePath = join10(outDir, tpl.filename);
+  let writeResult;
+  try {
+    writeResult = applyWrites(root, [
+      { type: "create", path: filePath, content: tpl.content, owned: true }
+    ]);
+  } catch (err) {
+    return errorOut3(args, "RN production-auth apply failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+  if (writeResult.files_skipped.length > 0) {
+    const result2 = {
+      status: "already-applied",
+      framework,
+      files_created: [],
+      next_steps: [
+        `Skipped: ${filePath} already exists. Delete it to regenerate with a different --backend.`
+      ],
+      error: `API_ERROR: ERR_ALREADY_APPLIED ${filePath} already exists.`
+    };
+    return outputResult5(args, result2, 0);
+  }
+  const depsStr = tpl.deps.length > 0 ? tpl.deps.join(" ") : null;
+  const restart = framework === "expo" ? "npx expo start --clear" : "npm start -- --reset-cache";
+  const next_steps = [
+    `1. Backend deps: ${depsStr ? `\`npm install ${depsStr}\` in ${outDir.split("/")[0] ?? outDir}` : "(none \u2014 route file ships ready to deploy)"}.`,
+    `2. Set server env vars (NO EXPO_PUBLIC_ prefix):`,
+    `     COMETCHAT_APP_ID=<your-app-id>`,
+    `     COMETCHAT_REGION=<us|eu|in>`,
+    `     COMETCHAT_AUTH_KEY=<your-auth-key>   # SERVER-ONLY, keep out of the RN bundle`,
+    `3. Start the backend: ${tpl.runCommand ?? "(deploy per platform convention)"}`,
+    `4. Remove \`EXPO_PUBLIC_COMETCHAT_AUTH_KEY\` (or bare COMETCHAT_AUTH_KEY for bare RN) from your RN .env \u2014 the client no longer needs it.`,
+    `5. Client-side change in your CometChatProvider:`,
+    `   - Remove \`.setAuthKey(...)\` from UIKitSettingsBuilder (keep setAppId + setRegion).`,
+    `   - In your ensureLoggedIn() helper, replace \`login({ uid })\` with:`,
+    `       const res = await fetch(\`\${API_BASE}/cometchat-token?uid=\${uid}\`);`,
+    `       const { authToken } = await res.json();`,
+    `       await CometChatUIKit.login({ authToken });`,
+    `6. Restart Metro with \`${restart}\` and log in. The CometChat SDK never sees your Auth Key anymore.`,
+    `   See cometchat-native-production skill for auth-provider integrations (Firebase Auth, Supabase, Clerk, Auth0) and token caching.`
+  ];
+  appendAuditEntry(root, {
+    command: "production-auth",
+    summary: `Scaffolded ${tpl.label} token endpoint at ${filePath}`,
+    inputs: { framework, backend, "out-dir": outDir },
+    decisions: {
+      backend: `${tpl.label}. RN apps call out to a separate backend (not colocated), so the CLI scaffolds just the endpoint file; you wire the client-side change manually in CometChatProvider because the RN login flow structure varies across dispatchers.`,
+      file: `Wrote ${filePath} (owned). Deps: ${depsStr ?? "none"}.`
+    },
+    files_patched: [filePath],
+    next_actions: next_steps
+  });
+  const result = {
+    status: "applied",
+    framework,
+    files_created: [filePath],
+    client_patch: "n/a",
+    // RN client-side is manual — too much structural variation to auto-patch
+    next_steps
+  };
+  return outputResult5(args, result, 0);
+}
 
 // src/commands/apply-theme.ts
 init_state();
@@ -3803,6 +4718,75 @@ function buildOverrideBlock(theme) {
   }
   return { css: lines.join("\n") + "\n", variables: vars };
 }
+function isReactNativeFramework(framework) {
+  return framework === "expo" || framework === "react-native";
+}
+function buildRnThemeSource(theme, useTs) {
+  const vars = [];
+  const lightColorLines = [];
+  lightColorLines.push(`      primary: "${theme.primaryColor}",`);
+  vars.push("color.primary");
+  if (theme.textColor) {
+    lightColorLines.push(`      textPrimary: "${theme.textColor}",`);
+    vars.push("color.textPrimary");
+  }
+  if (theme.backgroundColor) {
+    lightColorLines.push(`      background1: "${theme.backgroundColor}",`);
+    vars.push("color.background1");
+  }
+  const typographyLines = [];
+  if (theme.fontFamily) {
+    typographyLines.push(`      body1: { fontFamily: "${theme.fontFamily}" },`);
+    typographyLines.push(`      heading1: { fontFamily: "${theme.fontFamily}" },`);
+    vars.push("typography.body1.fontFamily");
+    vars.push("typography.heading1.fontFamily");
+  }
+  const darkBlock = [];
+  if (theme.darkMode) {
+    darkBlock.push("  dark: {");
+    darkBlock.push("    color: {");
+    darkBlock.push(`      primary: "${theme.primaryColor}",`);
+    darkBlock.push(`      background1: "#0A0A0A",`);
+    darkBlock.push(`      background2: "#1A1A1A",`);
+    darkBlock.push(`      background3: "#2A2A2A",`);
+    darkBlock.push(`      textPrimary: "#EDEDED",`);
+    darkBlock.push("    },");
+    darkBlock.push("  },");
+    vars.push("dark.color.primary");
+    vars.push("dark.color.background1-3");
+    vars.push("dark.color.textPrimary");
+  }
+  const exportType = useTs ? ": Partial<CometChatTheme>" : "";
+  const lines = [];
+  lines.push("// CometChat theme \u2014 generated by `cometchat apply-theme`");
+  lines.push("// Pass this to <CometChatThemeProvider theme={cometchatTheme}> in your app root.");
+  lines.push("");
+  if (useTs) {
+    lines.push(`import type { CometChatTheme } from "@cometchat/chat-uikit-react-native";`);
+    lines.push("");
+  }
+  lines.push(`export const cometchatTheme${exportType} = {`);
+  lines.push("  light: {");
+  lines.push("    color: {");
+  lightColorLines.forEach((l) => lines.push(l));
+  lines.push("    },");
+  if (typographyLines.length > 0) {
+    lines.push("    typography: {");
+    typographyLines.forEach((l) => lines.push(l));
+    lines.push("    },");
+  }
+  lines.push("  },");
+  if (darkBlock.length > 0) {
+    darkBlock.forEach((l) => lines.push(l));
+  }
+  lines.push("};");
+  lines.push("");
+  return { content: lines.join("\n"), variables: vars };
+}
+function rnThemePath(root) {
+  const isTs = pathExists(p(root, "tsconfig.json"));
+  return isTs ? "providers/CometChatTheme.ts" : "providers/CometChatTheme.js";
+}
 function buildThemeOp(framework, cssBlock, root) {
   const targets = {
     reactjs: ["src/index.css", "src/main.css", "src/styles.css"],
@@ -3904,6 +4888,54 @@ async function applyTheme(args) {
       `Error: pass either --preset <name> or --primary-color <hex>. Available presets: ${listPresets().join(", ")}. Or use --primary-color #6852D6 with optional --text-color, --background-color, --font-family, --border-radius, --dark-mode.`
     );
   }
+  if (isReactNativeFramework(framework)) {
+    const themePath = rnThemePath(root);
+    const useTs = themePath.endsWith(".ts");
+    const { content, variables: rnVariables } = buildRnThemeSource(theme, useTs);
+    let writeResult2;
+    try {
+      writeResult2 = applyWrites(root, [
+        { type: "create", path: themePath, content, owned: true }
+      ]);
+    } catch (err) {
+      return errorOut4(args, "Theme apply failed: " + (err instanceof Error ? err.message : String(err)));
+    }
+    const wasSkipped2 = writeResult2.files_skipped.length > 0;
+    const wireHint = `Wire it in: import { cometchatTheme } from "./${themePath.replace(/\.(ts|js)$/, "")}"; then <CometChatThemeProvider theme={cometchatTheme}>\u2026</CometChatThemeProvider>`;
+    const result2 = {
+      status: "applied",
+      framework,
+      file_modified: themePath,
+      variables_applied: rnVariables,
+      next_steps: [
+        wasSkipped2 ? `Skipped: ${themePath} already exists. Delete it to regenerate.` : `Theme object written to ${themePath}.`,
+        wireHint,
+        framework === "expo" ? "Restart Metro with `npx expo start --clear` to pick up the new theme." : "Restart Metro with `npm start -- --reset-cache` to pick up the new theme.",
+        "To remove the theme, delete the file and drop the `theme` prop on CometChatThemeProvider."
+      ]
+    };
+    if (!wasSkipped2) {
+      const presetFlag = getStringFlag3(args, "preset");
+      appendAuditEntry(root, {
+        command: "apply-theme",
+        summary: presetFlag ? `Applied "${presetFlag}" theme preset to ${framework} integration` : `Applied custom theme overrides to ${framework} integration`,
+        inputs: {
+          framework,
+          ...presetFlag ? { preset: presetFlag } : {},
+          ...theme.primaryColor ? { "primary-color": theme.primaryColor } : {},
+          ...theme.darkMode ? { "dark-mode": true } : {}
+        },
+        decisions: {
+          target: `${framework}: wrote theme module at ${themePath} for use with <CometChatThemeProvider theme={...}>. RN uses a JS theme object, not CSS.`,
+          ...presetFlag ? { preset: `picked the "${presetFlag}" preset bundle (primary + text + background + font + dark-mode)` } : {},
+          variables_set: rnVariables.join(", ")
+        },
+        files_patched: [themePath],
+        next_actions: result2.next_steps
+      });
+    }
+    return outputResult6(args, result2, 0);
+  }
   const { css, variables } = buildOverrideBlock(theme);
   const { op, targetPath, specialHint } = buildThemeOp(framework, css, root);
   if (!op || !targetPath) {
@@ -4037,6 +5069,11 @@ async function hasSecretTool() {
   }
 }
 async function detectBackend() {
+  const override = process.env.CC_AUTH_BACKEND;
+  if (override === "file") return "file";
+  if (override === "keychain-macos") return "keychain-macos";
+  if (override === "keychain-linux") return "keychain-linux";
+  if (override === "keychain-windows") return "keychain-windows";
   if (process.platform === "darwin") return "keychain-macos";
   if (process.platform === "win32") return "keychain-windows";
   if (process.platform === "linux" && await hasSecretTool()) return "keychain-linux";
@@ -4343,8 +5380,19 @@ async function listApps(host, token) {
     const name = String(entry.name ?? id);
     const region = String(entry.region ?? "us");
     const plan = typeof entry.plan === "string" ? entry.plan : void 0;
-    const base = { id, name, region };
-    return plan ? { ...base, plan } : base;
+    const meta = entry.metadata && typeof entry.metadata === "object" ? entry.metadata : {};
+    const industry = typeof meta.industry === "string" ? meta.industry : void 0;
+    const technology = typeof meta.technology === "string" ? meta.technology : void 0;
+    const product = typeof meta.product === "string" ? meta.product : void 0;
+    const createdAtRaw = entry.createdAt ?? entry.created_at;
+    const createdAt = typeof createdAtRaw === "number" ? createdAtRaw : typeof createdAtRaw === "string" ? Number(new Date(createdAtRaw)) || void 0 : void 0;
+    const out = { id, name, region };
+    if (plan) out.plan = plan;
+    if (industry) out.industry = industry;
+    if (technology) out.technology = technology;
+    if (product) out.product = product;
+    if (createdAt !== void 0) out.createdAt = createdAt;
+    return out;
   });
 }
 async function getAppCredentials(host, token, appId) {
@@ -4371,28 +5419,105 @@ async function getAppCredentials(host, token, appId) {
   }
   return { appId: id, authKey, region };
 }
-async function listInstalledExtensions(host, token, appId) {
-  const res = await request(
-    host,
-    `/apps/${encodeURIComponent(appId)}/extensions?per_page=50`,
-    { method: "GET", headers: { Authorization: `Bearer ${token}` } }
-  );
+async function getCurrentUser(host, token) {
+  const res = await request(host, "/me", {
+    method: "GET",
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  const body = await parseBody(res);
+  if (!res.ok) {
+    const { code, message } = extractErrorCode(body);
+    if (res.status === 401) throw new Error("AUTH_FAILED");
+    throw new Error(`API_ERROR: ${code} ${message}`);
+  }
+  const data = body?.data;
+  if (!data || typeof data !== "object") {
+    throw new Error(`API_ERROR: UNEXPECTED_SHAPE ${JSON.stringify(body)}`);
+  }
+  return data;
+}
+async function getCurrentUserWithLastApp(host, token) {
+  const user = await getCurrentUser(host, token);
+  let last_app = null;
+  try {
+    const apps = await listApps(host, token);
+    if (apps.length > 0) {
+      const sorted = [...apps].sort((a, b) => {
+        const aT = a.createdAt ?? 0;
+        const bT = b.createdAt ?? 0;
+        return bT - aT;
+      });
+      last_app = sorted[0];
+    }
+  } catch {
+  }
+  return { ...user, last_app };
+}
+async function listInstalledExtensions(host, token, appId) {
+  const res = await request(
+    host,
+    `/apps/${encodeURIComponent(appId)}/extensions?per_page=50`,
+    { method: "GET", headers: { Authorization: `Bearer ${token}` } }
+  );
+  const body = await parseBody(res);
+  if (!res.ok) {
+    const { code, message } = extractErrorCode(body);
+    if (res.status === 401) throw new Error("AUTH_FAILED");
+    throw new Error(`API_ERROR: ${code} ${message}`);
+  }
+  const data = body?.data;
+  if (!Array.isArray(data)) return [];
+  return data.map((e) => e);
+}
+async function toggleExtension(host, token, appId, extensionId, action) {
+  const payload = action === "enable" ? { enabled: [extensionId] } : { disabled: [extensionId] };
+  const res = await request(host, `/apps/${encodeURIComponent(appId)}/extensions`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}` },
+    body: JSON.stringify(payload)
+  });
+  if (!res.ok) {
+    const body = await parseBody(res);
+    const { code, message } = extractErrorCode(body);
+    if (res.status === 401) throw new Error("AUTH_FAILED");
+    throw new Error(`API_ERROR: ${code} ${message}`);
+  }
+}
+async function toggleAiFeature(host, token, appId, featureKey, action) {
+  const path = `/apps/${encodeURIComponent(appId)}/features/ai.${encodeURIComponent(featureKey)}/enabled`;
+  const res = await request(host, path, {
+    method: action === "enable" ? "POST" : "DELETE",
+    headers: { Authorization: `Bearer ${token}` },
+    body: action === "enable" ? "{}" : void 0
+  });
+  if (!res.ok) {
+    const body = await parseBody(res);
+    const { code, message } = extractErrorCode(body);
+    if (res.status === 401) throw new Error("AUTH_FAILED");
+    throw new Error(`API_ERROR: ${code} ${message}`);
+  }
+}
+async function getAiSettings(host, token, appId) {
+  const res = await request(host, `/apps/${encodeURIComponent(appId)}/ai/settings`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${token}` }
+  });
   const body = await parseBody(res);
   if (!res.ok) {
     const { code, message } = extractErrorCode(body);
     if (res.status === 401) throw new Error("AUTH_FAILED");
+    if (res.status === 404) return null;
     throw new Error(`API_ERROR: ${code} ${message}`);
   }
   const data = body?.data;
-  if (!Array.isArray(data)) return [];
-  return data.map((e) => e);
+  if (!data || typeof data !== "object") return null;
+  return data;
 }
-async function toggleExtension(host, token, appId, extensionId, action) {
-  const payload = action === "enable" ? { enabled: [extensionId] } : { disabled: [extensionId] };
-  const res = await request(host, `/apps/${encodeURIComponent(appId)}/extensions`, {
-    method: "POST",
+async function updateAiSettings(host, token, appId, settings) {
+  const res = await request(host, `/apps/${encodeURIComponent(appId)}/ai/settings`, {
+    method: "PUT",
     headers: { Authorization: `Bearer ${token}` },
-    body: JSON.stringify(payload)
+    body: JSON.stringify(settings)
   });
   if (!res.ok) {
     const body = await parseBody(res);
@@ -4477,7 +5602,20 @@ function loadCatalog() {
   cachedCatalog = JSON.parse(readFileSync9(path, "utf8"));
   return cachedCatalog;
 }
-function nextStepsForFeature(feature) {
+function resolveFramework(root) {
+  if (hasState(root)) {
+    const state2 = readState(root);
+    if (state2?.framework) return state2.framework;
+  }
+  const cfg = readConfig(root);
+  if (cfg?.framework) return cfg.framework;
+  return "reactjs";
+}
+function isRn(framework) {
+  return framework === "expo" || framework === "react-native";
+}
+function nextStepsForFeature(feature, framework = "reactjs") {
+  const rn = isRn(framework);
   switch (feature.type) {
     case "default":
       return [
@@ -4486,53 +5624,96 @@ function nextStepsForFeature(feature) {
         feature.requires_dashboard_setup ? "Some features (like moderation) need rules configured in the CometChat dashboard before they activate. Check the dashboard." : "No code changes needed \u2014 it's already there.",
         ...feature.docs_topic ? [`For details, query the docs MCP for "${feature.docs_topic}" or visit https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
       ];
-    case "dashboard-toggle": {
+    case "extension": {
       const docsUrl = feature.docs_topic ? `https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}` : "https://www.cometchat.com/docs/ui-kit/react/extensions";
       const lines = [];
       if (feature.auto_wired_in_uikit) {
         lines.push(
-          `${feature.name} is in the UI Kit's defaultExtensions[] \u2014 its UI decorator is attached automatically by initiateAfterLogin(). The only thing you need to do is flip the dashboard toggle.`,
+          `${feature.name} is in the UI Kit's defaultExtensions[] \u2014 its UI decorator is attached automatically by initiateAfterLogin().`,
           "",
           "Steps to enable:",
-          `  1. Go to https://app.cometchat.com and select your app`,
-          `  2. Navigate to: ${feature.dashboard_path ?? "Extensions \u2192 " + feature.name}`,
-          `     (this is a hint \u2014 if the dashboard UI has changed, see the canonical docs link below)`,
-          `  3. Toggle the feature on (and configure any required values)`,
-          `  4. Refresh your dev server \u2014 no code changes required`,
+          `  1. Run \`cometchat apply-feature ${feature.id}\` \u2014 the CLI flips the dashboard toggle via API.`,
+          `  2. Refresh your dev server \u2014 no code changes required.`,
           "",
-          `  \u{1F4D6} Canonical docs (always-current \u2014 use this if the dashboard navigation above doesn't match what you see):`,
-          `     ${docsUrl}`,
-          `     For exact, up-to-date integration steps, query the cometchat-docs MCP for "${feature.id}".`
+          `  Manual fallback (if API isn't available): https://app.cometchat.com \u2192 ${feature.dashboard_path ?? "Extensions \u2192 " + feature.name}`,
+          `  \u{1F4D6} Canonical docs: ${docsUrl}`
         );
       } else {
         lines.push(
           `${feature.name} is a dashboard-toggle extension that ALSO requires explicit registration in your UIKitSettingsBuilder. The UI Kit only auto-attaches the 7 extensions in defaultExtensions[]; this one is not in that list.`,
           "",
           "Steps to enable:",
-          `  1. Go to https://app.cometchat.com \u2192 ${feature.dashboard_path ?? "Extensions \u2192 " + feature.name}, toggle on`,
-          `     (dashboard hint \u2014 see canonical docs link below if the navigation has changed)`,
+          `  1. Run \`cometchat apply-feature ${feature.id}\` \u2014 the CLI flips the dashboard toggle via API.`,
           `  2. Register the extension via UIKitSettingsBuilder.setExtensions([...]) in your CometChat init.`,
           `     For the exact import path + extension class name + builder syntax, query the cometchat-docs MCP for "${feature.id}" \u2014 DO NOT invent the API from memory.`,
-          `  3. Restart your dev server`,
+          `  3. Restart your dev server.`,
           "",
           `  \u{1F4D6} Canonical docs: ${docsUrl}`
         );
       }
       return lines;
     }
-    case "package-install":
+    case "ai-feature": {
+      const docsUrl = feature.docs_topic ? `https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}` : "https://www.cometchat.com/docs/ui-kit/react/ai-features";
       return [
+        `${feature.name} is an AI feature that requires an OpenAI API key on the app's AI settings.`,
+        "",
+        "Steps to enable:",
+        `  1. Run \`cometchat apply-feature ${feature.id} --openai-key sk-...\` \u2014 the CLI stores the key and flips the AI toggle via API.`,
+        `  2. Refresh your dev server.`,
+        "",
+        `  Get an OpenAI key: https://platform.openai.com/api-keys`,
+        `  \u{1F4D6} Canonical docs: ${docsUrl}`
+      ];
+    }
+    case "dashboard-only":
+      return [
+        `${feature.name} requires third-party config (API key, webhook, etc.) that only you can provide. The CLI cannot automate this.`,
+        "",
+        "Steps to enable:",
+        `  1. Open https://app.cometchat.com \u2192 ${feature.dashboard_path ?? "Extensions \u2192 " + feature.name}`,
+        `  2. Enter the required configuration values.`,
+        `  3. Toggle the feature on; refresh your dev server.`,
+        ...feature.docs_topic ? ["", `  \u{1F4D6} Canonical docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
+      ];
+    case "package-install": {
+      const pkg = rn && feature.package_native ? feature.package_native : feature.package;
+      const peers = rn ? feature.package_native_peers ?? [] : [];
+      const installCmd = framework === "expo" ? `npx expo install ${[pkg, ...peers].filter(Boolean).join(" ")}` : `npm install ${[pkg, ...peers].filter(Boolean).join(" ")}`;
+      const restartCmd = framework === "expo" ? "npx expo start --clear" : rn ? "npm start -- --reset-cache" : "npm run dev";
+      const docsPath = rn ? "react-native" : "react";
+      const baseSteps = [
         `${feature.name} requires installing an additional npm package.`,
         "",
         "Steps to enable:",
-        `  1. Install the package:`,
-        `       npm install ${feature.package}`,
-        `  2. Restart your dev server. After the next login, the UI Kit's initiateAfterLogin() automatically calls enableCalling(), which detects the calls SDK and wires up the default CallingExtension. No manual setExtensions() or setCallsExtension() needed for the default behavior.`,
-        `  3. Call buttons appear in CometChatMessageHeader; incoming calls render via the global call listener.`,
-        ...feature.components && feature.components.length > 0 ? [`  4. Components automatically enabled: ${feature.components.join(", ")}`] : [],
-        `  Note: to customize the calling UI (custom CallingExtension, group calls config, recording), pass your own instance via UIKitSettingsBuilder.setCallsExtension(new CallingExtension({...})) before init.`,
-        ...feature.docs_topic ? [`  Docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
+        `  1. Install:`,
+        `       ${installCmd}`
       ];
+      if (framework === "react-native") {
+        baseSteps.push(`  2. Run \`cd ios && pod install && cd ..\` to link the native modules.`);
+        baseSteps.push(`  3. Restart Metro with \`${restartCmd}\`. After the next login, the UI Kit's initiateAfterLogin() auto-wires the CometChat calling listeners.`);
+        baseSteps.push(`  4. Call buttons appear in CometChatMessageHeader; incoming calls render via the CometChatIncomingCall listener.`);
+      } else if (framework === "expo") {
+        baseSteps.push(`  2. Run \`npx expo prebuild --clean\` (calling requires a dev build \u2014 Expo Go cannot load WebRTC).`);
+        baseSteps.push(`  3. Restart Metro with \`${restartCmd}\`. After the next login, the UI Kit's initiateAfterLogin() auto-wires the CometChat calling listeners.`);
+        baseSteps.push(`  4. Call buttons appear in CometChatMessageHeader; incoming calls render via the CometChatIncomingCall listener.`);
+      } else {
+        baseSteps.push(`  2. Restart your dev server (\`${restartCmd}\`). After the next login, the UI Kit's initiateAfterLogin() automatically calls enableCalling(), which detects the calls SDK and wires up the default CallingExtension. No manual setExtensions() or setCallsExtension() needed for the default behavior.`);
+        baseSteps.push(`  3. Call buttons appear in CometChatMessageHeader; incoming calls render via the global call listener.`);
+      }
+      if (feature.components && feature.components.length > 0) {
+        baseSteps.push(`  Components automatically enabled: ${feature.components.join(", ")}`);
+      }
+      if (rn) {
+        baseSteps.push(`  Note: on React Native you customize calling UI via custom view templates (see cometchat-native-features skill \xA7 Calls).`);
+      } else {
+        baseSteps.push(`  Note: to customize the calling UI (custom CallingExtension, group calls config, recording), pass your own instance via UIKitSettingsBuilder.setCallsExtension(new CallingExtension({...})) before init.`);
+      }
+      if (feature.docs_topic) {
+        baseSteps.push(`  Docs: https://www.cometchat.com/docs/ui-kit/${docsPath}/${feature.docs_topic}`);
+      }
+      return baseSteps;
+    }
     case "component-swap":
       return [
         `${feature.name} is enabled by replacing one component with a variant.`,
@@ -4612,7 +5793,7 @@ async function featuresToggle(args, featureName, action) {
     if (json) {
       console.log(JSON.stringify({
         ...result2,
-        available: catalog.features.filter((f) => f.type === "dashboard-toggle").map((f) => f.id)
+        available: catalog.features.filter((f) => f.type === "extension").map((f) => f.id)
       }, null, 2));
     } else {
       console.error(`\u2717 Feature "${featureName}" not found.`);
@@ -4620,11 +5801,12 @@ async function featuresToggle(args, featureName, action) {
     }
     return 1;
   }
-  if (match.type !== "dashboard-toggle") {
+  if (match.type !== "extension") {
+    const hint = match.type === "ai-feature" ? `Use \`cometchat apply-feature ${match.id} --openai-key <sk-\u2026>\` to enable AI features.` : `Run \`cometchat features info ${match.id}\` for the right instructions.`;
     const result2 = {
       status: "unsupported-type",
       feature: match,
-      error: `"${match.name}" is type "${match.type}" \u2014 not a dashboard toggle. Run \`cometchat features info ${match.id}\` for the right instructions.`
+      error: `"${match.name}" is type "${match.type}" \u2014 not a dashboard toggle. ${hint}`
     };
     if (json) {
       console.log(JSON.stringify(result2, null, 2));
@@ -4765,7 +5947,9 @@ function featuresList(args) {
   }
   const order = [
     "default",
-    "dashboard-toggle",
+    "extension",
+    "ai-feature",
+    "dashboard-only",
     "package-install",
     "component-swap"
   ];
@@ -4811,10 +5995,12 @@ function featuresInfo(args, name) {
     }
     return 1;
   }
+  const root = projectPath10(args);
+  const framework = resolveFramework(root);
   const result = {
     status: "found",
     feature: fuzzy,
-    next_steps: nextStepsForFeature(fuzzy)
+    next_steps: nextStepsForFeature(fuzzy, framework)
   };
   if (isJsonMode11(args)) {
     console.log(JSON.stringify(result, null, 2));
@@ -4873,8 +6059,11 @@ function projectPath11(args) {
   if (typeof fromFlag === "string") return resolve12(fromFlag);
   return resolve12(process.cwd());
 }
-function runQuickVerify(root, ownedFiles, patchedFiles = []) {
+function runQuickVerify(root, ownedFiles, patchedFiles = [], framework = null) {
   if (ownedFiles.length === 0) return { status: "skip", failed: [] };
+  if (framework === "expo" || framework === "react-native") {
+    return runQuickVerifyRn(root, ownedFiles, patchedFiles, framework);
+  }
   const failed = [];
   const HEX_KEY = /[a-f0-9]{32,}/;
   const cssCandidates = /* @__PURE__ */ new Set([
@@ -4917,6 +6106,69 @@ function runQuickVerify(root, ownedFiles, patchedFiles = []) {
   if (!errorUiFound) failed.push("error_ui_visible_on_failure");
   return { status: failed.length === 0 ? "pass" : "fail", failed };
 }
+function runQuickVerifyRn(root, ownedFiles, patchedFiles, framework) {
+  const failed = [];
+  const HEX_KEY = /[a-f0-9]{32,}/;
+  const allFiles = /* @__PURE__ */ new Set([...ownedFiles, ...patchedFiles]);
+  const entryCandidates = ["index.js", "index.ts", "App.tsx", "App.jsx", "app/_layout.tsx", "app/_layout.js"];
+  let gestureHandlerLine1 = false;
+  for (const e of entryCandidates) {
+    if (!pathExists(p(root, e))) continue;
+    const content = readFileOrNull(p(root, e));
+    if (!content) continue;
+    const firstLine = content.split(/\r?\n/)[0]?.trim() ?? "";
+    if (/^import\s+['"]react-native-gesture-handler['"]/.test(firstLine)) {
+      gestureHandlerLine1 = true;
+      break;
+    }
+  }
+  if (!gestureHandlerLine1) failed.push("gesture_handler_line_1");
+  const wrappers = ["GestureHandlerRootView", "SafeAreaProvider", "CometChatThemeProvider", "CometChatProvider"];
+  const wrapperHits = /* @__PURE__ */ new Set();
+  for (const file of allFiles) {
+    const content = readFileOrNull(p(root, file));
+    if (!content) continue;
+    for (const w of wrappers) {
+      if (content.includes(w)) wrapperHits.add(w);
+    }
+  }
+  if (wrapperHits.size < wrappers.length) failed.push("four_wrapper_chain_present");
+  let hasThreadPanel = false;
+  for (const file of allFiles) {
+    const content = readFileOrNull(p(root, file));
+    if (content && content.includes("CometChatThreadHeader")) {
+      hasThreadPanel = true;
+      break;
+    }
+  }
+  if (!hasThreadPanel) {
+    for (const file of ownedFiles) {
+      const content = readFileOrNull(p(root, file));
+      if (!content) continue;
+      const lists = (content.match(/<\s*CometChatMessageList\b/g) ?? []).length;
+      const flagged = (content.match(/hideReplyInThreadOption/g) ?? []).length;
+      if (lists > flagged) {
+        failed.push("hide_reply_in_thread_option");
+        break;
+      }
+    }
+  }
+  for (const file of ownedFiles) {
+    const content = readFileOrNull(p(root, file));
+    if (!content) continue;
+    const m = content.match(HEX_KEY);
+    if (m && m[0].length >= 40) {
+      failed.push("no_auth_key_in_source");
+      break;
+    }
+  }
+  if (framework === "react-native" && pathExists(p(root, "ios/Podfile"))) {
+    if (!pathExists(p(root, "ios/Podfile.lock"))) {
+      failed.push("pod_install_run");
+    }
+  }
+  return { status: failed.length === 0 ? "pass" : "fail", failed };
+}
 function buildIssues(args) {
   const issues = [];
   if (!args.hasIntegration) {
@@ -4964,6 +6216,23 @@ function buildIssues(args) {
     error_ui_visible_on_failure: {
       msg: "No visible error UI (color: red) found in any owned file.",
       fix: "Add a `<div style={{color: 'red'}}>{error}</div>` block to your CometChatNoSSR.tsx (or equivalent) so init/login failures are visible to the user instead of silently rendering nothing."
+    },
+    // ── React Native checks ─────────────────────────────────────────────────
+    gesture_handler_line_1: {
+      msg: '`import "react-native-gesture-handler"` is not line 1 of the entry file (index.js / App.tsx / app/_layout.tsx).',
+      fix: 'Add `import "react-native-gesture-handler";` as the FIRST line of your entry file \u2014 above every other import. Gesture handler requires native setup that must happen before any React code runs, and some bundlers defer non-leading imports which breaks release builds silently.'
+    },
+    four_wrapper_chain_present: {
+      msg: "One or more of the 4 required wrappers is missing: GestureHandlerRootView \u2192 SafeAreaProvider \u2192 CometChatThemeProvider \u2192 CometChatProvider.",
+      fix: "Wrap your app root (App.tsx or app/_layout.tsx) with all 4 wrappers in that exact order. Omitting any of them breaks gestures, safe areas, theming, or login state \u2014 and it fails silently in dev. See cometchat-native-core \xA7 3."
+    },
+    hide_reply_in_thread_option: {
+      msg: "A <CometChatMessageList> was found without `hideReplyInThreadOption`, and no <CometChatThreadHeader> is wired.",
+      fix: 'Add `hideReplyInThreadOption={true}` to every <CometChatMessageList> in the integration \u2014 OR wire a full thread panel (CometChatThreadHeader + scoped list + composer with parentMessageId). Without the flag, tapping a message shows a "Reply in Thread" action that leads to a broken thread screen.'
+    },
+    pod_install_run: {
+      msg: "ios/Podfile exists but ios/Podfile.lock is missing \u2014 pod install has not been run.",
+      fix: "Run `cd ios && pod install && cd ..` to link the native modules. After a new package install, pod install must run before `npm run ios` or Xcode build will fail."
     }
   };
   for (const failed of args.verify.failed) {
@@ -5029,7 +6298,8 @@ async function doctor(args) {
     verifyResult = runQuickVerify(
       root,
       stateInfo.files_owned,
-      stateInfo.files_patched.map((p2) => p2.path)
+      stateInfo.files_patched.map((p2) => p2.path),
+      stateInfo.framework
     );
   }
   const expectedEnvVars = detected.env_prefix !== null ? [
@@ -5544,6 +6814,7 @@ function printHumanReadable12(r) {
 init_state();
 import { readFileSync as readFileSync11 } from "node:fs";
 import { join as join14, resolve as resolve15 } from "node:path";
+init_config();
 var HELP14 = `
 cometchat add-user-mgmt \u2014 create server-side user management endpoints
 
@@ -5589,13 +6860,28 @@ async function addUserMgmt(args) {
     return 0;
   }
   const root = projectPath14(args);
-  if (!hasState(root)) {
+  const stateFramework = hasState(root) ? readState(root)?.framework ?? null : null;
+  const cfgFramework = readConfig(root)?.framework ?? null;
+  const resolvedFramework = stateFramework ?? cfgFramework;
+  if (!resolvedFramework) {
     return outputResult10(args, {
       status: "no-integration",
       framework: "",
       files_created: [],
       next_steps: [],
-      error: "API_ERROR: ERR_NO_INTEGRATION No integration found. Run `cometchat apply` first to create the base integration, then run `cometchat add-user-mgmt`."
+      error: "API_ERROR: ERR_NO_INTEGRATION No integration found. Run `cometchat apply` (web) or `/cometchat` (React Native) first, then re-run `cometchat add-user-mgmt`."
+    }, 1);
+  }
+  if (resolvedFramework === "expo" || resolvedFramework === "react-native") {
+    return addUserMgmtRn(args, root, resolvedFramework);
+  }
+  if (!hasState(root)) {
+    return outputResult10(args, {
+      status: "no-integration",
+      framework: resolvedFramework,
+      files_created: [],
+      next_steps: [],
+      error: "API_ERROR: ERR_NO_STATE Web add-user-mgmt requires state.json. Run `cometchat apply` first (or `cometchat state record` if your integration was hand-written)."
     }, 1);
   }
   const state2 = readState(root);
@@ -5742,27 +7028,126 @@ function printHumanReadable13(r) {
   lines.push("");
   console.log(lines.join("\n"));
 }
+function addUserMgmtRn(args, root, framework) {
+  const backendFlag = args.flags.backend;
+  const outDirFlag = args.flags["out-dir"];
+  if (typeof backendFlag !== "string" || !RN_BACKENDS.includes(backendFlag)) {
+    return outputResult10(args, {
+      status: "error",
+      framework,
+      files_created: [],
+      next_steps: [],
+      error: `React Native add-user-mgmt requires --backend <${RN_BACKENDS.join("|")}>. Example: \`cometchat add-user-mgmt --backend express --out-dir ./server\`. Typically pair it with the same backend you chose for \`production-auth\`.`
+    }, 1);
+  }
+  const backend = backendFlag;
+  const tpl = rnUserMgmtTemplate(backend);
+  const defaultOutDir = backend === "firebase-functions" ? "functions/src" : backend === "nextjs-api" ? "src/app/api/cometchat-user" : "server";
+  const outDir = typeof outDirFlag === "string" ? outDirFlag : defaultOutDir;
+  const filePath = join14(outDir, tpl.filename);
+  let writeResult;
+  try {
+    writeResult = applyWrites(root, [
+      { type: "create", path: filePath, content: tpl.content, owned: true }
+    ]);
+  } catch (err) {
+    return errorOut7(args, "RN add-user-mgmt apply failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+  if (writeResult.files_skipped.length > 0) {
+    return outputResult10(args, {
+      status: "already-applied",
+      framework,
+      files_created: [],
+      next_steps: [
+        `Skipped: ${filePath} already exists. Delete it to regenerate.`
+      ],
+      error: `API_ERROR: ERR_ALREADY_APPLIED ${filePath} already exists.`
+    }, 0);
+  }
+  const next_steps = [
+    `1. Backend deps: ${tpl.deps.length > 0 ? `\`npm install ${tpl.deps.join(" ")}\` in ${outDir.split("/")[0] ?? outDir}` : "(none \u2014 endpoint ships ready to deploy)"}.`,
+    `2. Set server env vars (NO EXPO_PUBLIC_ prefix):`,
+    `     COMETCHAT_APP_ID=<your-app-id>`,
+    `     COMETCHAT_REGION=<us|eu|in>`,
+    `     COMETCHAT_AUTH_KEY=<your-auth-key>   # SERVER-ONLY`,
+    `3. Start the backend: ${tpl.runCommand ?? "(deploy per platform convention)"}`,
+    `4. \u26A0 Add authentication BEFORE deploying. The endpoint ships unauthenticated \u2014 anyone who hits it can create/update/delete CometChat users. Verify the caller's session / token in each handler.`,
+    `5. Wire the endpoint into your RN app's flows:`,
+    `   - On signup (after your auth provider creates a user): POST /cometchat-user with { uid, name, avatar? }`,
+    `   - On profile update: PATCH /cometchat-user/<uid> with the changed fields`,
+    `   - On account delete: DELETE /cometchat-user/<uid>`,
+    `   See cometchat-native-production skill \xA7 6 for Firebase Auth / Supabase / Clerk / Auth0 recipes.`
+  ];
+  appendAuditEntry(root, {
+    command: "add-user-mgmt",
+    summary: `Scaffolded ${tpl.label} at ${filePath}`,
+    inputs: { framework, backend, "out-dir": outDir },
+    decisions: {
+      backend: `${tpl.label}. Ships unauthenticated \u2014 caller must add session checks.`,
+      file: `Wrote ${filePath} (owned). Deps: ${tpl.deps.length > 0 ? tpl.deps.join(", ") : "none"}.`
+    },
+    files_patched: [filePath],
+    next_actions: next_steps
+  });
+  return outputResult10(args, {
+    status: "applied",
+    framework,
+    files_created: [filePath],
+    next_steps
+  }, 0);
+}
 
 // src/commands/apply-feature.ts
 init_state();
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
 import { join as join15, resolve as resolve16 } from "node:path";
 var HELP15 = `
-cometchat apply-feature \u2014 apply a component-swap feature on an integration
+cometchat apply-feature \u2014 apply a feature on top of an existing integration
 
 Usage:
-  cometchat apply-feature <feature-id> [--path <p>] [--json]
+  cometchat apply-feature <feature-id> [--app-id <id>] [--openai-key <k>] [--path <p>] [--json]
 
 What this does:
-  Applies a component-swap feature (e.g. rich-text-formatting) on top of
-  an existing integration. Walks state.files_owned, runs a word-boundary
-  regex replace of swap_from \u2192 swap_to, updates checksums, and records the
-  feature id in state.applied_features. Idempotent.
+  Dispatches by feature type from the catalog:
+    extension       Calls the dashboard API to flip the toggle. No code change.
+    ai-feature      Same, plus prompts/accepts an OpenAI key once per app.
+    component-swap  Walks files_owned and runs a word-boundary identifier
+                    swap (e.g. CometChatMessageComposer \u2192
+                    CometChatCompactMessageComposer). Updates checksums.
+    default         No-op \u2014 feature is already enabled by the UI Kit.
+    dashboard-only  Prints the dashboard path. Cannot automate (third-party
+                    keys, multi-field config).
+    package-install Prints the npm install command. Cannot automate.
+
+  In stateful mode (default for web/RN where \`cometchat apply\` was run):
+    - Reads .cometchat/state.json
+    - Resolves the App ID from the project's env file
+    - Records applied features in state.json for idempotency
+
+  In stateless mode (\`--app-id\` passed; for native iOS/Android/Flutter/Angular
+  projects that don't go through \`cometchat apply\`):
+    - Skips state.json
+    - Uses the explicit --app-id value
+    - Skips applied_features recording (server-side toggles are idempotent)
+    - component-swap is unavailable (no files_owned to walk)
 
 Flags:
-  --path <p>  Project root (defaults to cwd).
-  --json      Machine-readable JSON output.
-  --help, -h  Show this help.
+  --app-id <id>     Stateless mode \u2014 toggle the feature on this app via the
+                    dashboard API without requiring \`cometchat apply\` to
+                    have been run first. Required for native cohorts
+                    (iOS / Android / Flutter / Angular).
+  --openai-key <k>  Pre-fill the OpenAI API key for ai-feature applies. If
+                    omitted, the command checks the app's existing AI
+                    settings; if no key is set, returns an error asking
+                    the user to pass --openai-key.
+  --path <p>        Project root (defaults to cwd).
+  --json            Machine-readable JSON output.
+  --help, -h        Show this help.
+
+Auth:
+  extension and ai-feature applies require a dashboard bearer token.
+  Run \`cometchat auth login\` first if you haven't already. The token is
+  stored in the OS keychain (or ~/.cometchat-cli/credentials.json fallback).
 `;
 function isJsonMode16(args) {
   return args.flags.json === true || args.flags.json === "true";
@@ -5778,6 +7163,24 @@ function catalogPath2() {
 function loadCatalog2() {
   return JSON.parse(readFileSync12(catalogPath2(), "utf8"));
 }
+function resolveAppId2(root, state2) {
+  const envFileName = envFileNameFor(state2.framework);
+  if (!envFileName) return null;
+  const envPath = join15(root, envFileName);
+  let content;
+  try {
+    content = readFileSync12(envPath, "utf8");
+  } catch {
+    return null;
+  }
+  const pairs = parseEnvPairs(content);
+  const prefix = state2.env_var_prefix ?? "";
+  const prefixed = pairs.get(`${prefix}COMETCHAT_APP_ID`);
+  const bare = pairs.get("COMETCHAT_APP_ID");
+  const value = (prefixed ?? bare ?? "").trim();
+  if (value.length === 0 || isPlaceholder(value)) return null;
+  return value;
+}
 function swapIdentifier(content, from, to) {
   const escaped = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const re = new RegExp(`\\b${escaped}\\b`, "g");
@@ -5806,15 +7209,22 @@ async function applyFeature(args) {
     result.error = "Usage: cometchat apply-feature <feature-id>";
     return outputResult11(args, result, 1);
   }
-  if (!hasState(root)) {
+  const appIdFlag = args.flags["app-id"];
+  const explicitAppId = typeof appIdFlag === "string" ? appIdFlag.trim() : "";
+  let state2 = null;
+  let stateless = false;
+  if (explicitAppId.length > 0) {
+    stateless = true;
+  } else if (hasState(root)) {
+    state2 = readState(root);
+    if (!state2) {
+      result.status = "error";
+      result.error = "state.json exists but could not be parsed (schema mismatch?)";
+      return outputResult11(args, result, 1);
+    }
+  } else {
     result.status = "no-integration";
-    result.error = "No CometChat integration found. Run `cometchat apply` first.";
-    return outputResult11(args, result, 1);
-  }
-  const state2 = readState(root);
-  if (!state2) {
-    result.status = "error";
-    result.error = "state.json exists but could not be parsed (schema mismatch?)";
+    result.error = "No CometChat integration found. Run `cometchat apply` first, or pass `--app-id <id>` for stateless API toggles (native cohorts: iOS/Android/Flutter/Angular).";
     return outputResult11(args, result, 1);
   }
   let catalog;
@@ -5831,26 +7241,192 @@ async function applyFeature(args) {
     result.error = `Feature "${featureId}" not in the catalog. Run \`cometchat features list\` to see available features.`;
     return outputResult11(args, result, 1);
   }
-  if (feature.type !== "component-swap") {
-    result.status = "unsupported-feature-type";
-    result.error = `Feature "${featureId}" is type "${feature.type}", not "component-swap". Only component-swap features can be applied via this command.`;
+  result.feature_type = feature.type;
+  if (state2?.applied_features?.includes(featureId)) {
+    result.status = "already-applied";
+    result.next_steps = [`${feature.name} is already applied to this integration.`];
+    return outputResult11(args, result, 0);
+  }
+  switch (feature.type) {
+    case "default":
+      return applyDefault(args, result, feature);
+    case "component-swap":
+      if (stateless || !state2) {
+        result.status = "state-required";
+        result.error = `Feature "${feature.id}" is type component-swap and requires \`cometchat apply\` to have run first (so we know which files to swap). \`--app-id\` mode does not support component-swap features.`;
+        return outputResult11(args, result, 1);
+      }
+      return applyComponentSwap(args, result, root, state2, feature);
+    case "extension":
+      return applyExtensionToggle(args, result, root, state2, explicitAppId, feature);
+    case "ai-feature":
+      return applyAiFeatureToggle(args, result, root, state2, explicitAppId, feature);
+    case "dashboard-only":
+      return applyDashboardOnly(args, result, feature);
+    case "package-install":
+      return applyPackageInstall(args, result, feature);
+    default: {
+      result.status = "unsupported-feature-type";
+      result.error = `Feature "${featureId}" has unknown type "${feature.type}".`;
+      return outputResult11(args, result, 1);
+    }
+  }
+}
+function applyDefault(args, result, feature) {
+  result.status = "already-applied";
+  result.next_steps = [
+    `${feature.name} is enabled by default in the UI Kit. No action needed.`,
+    ...feature.docs_topic ? [`Docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
+  ];
+  return outputResult11(args, result, 0);
+}
+async function applyExtensionToggle(args, result, root, state2, explicitAppId, feature) {
+  const host = getApiHost();
+  const creds = await loadToken(host);
+  if (!creds) {
+    result.status = "auth-required";
+    result.error = "No dashboard bearer token found.";
     result.next_steps = [
-      feature.type === "default" ? `${feature.name} is already enabled \u2014 no action needed.` : feature.type === "dashboard-toggle" ? `${feature.name} is enabled in the CometChat dashboard, not via this command. Run \`cometchat features info ${featureId}\`.` : feature.type === "package-install" ? `${feature.name} requires \`npm install\` of an extra package. Run \`cometchat features info ${featureId}\`.` : `Run \`cometchat features info ${featureId}\` for instructions.`
+      "Run `cometchat auth login` to authorize the CLI, then re-run this command."
     ];
     return outputResult11(args, result, 1);
   }
-  if (!feature.swap_from || !feature.swap_to) {
+  const appId = explicitAppId || (state2 ? resolveAppId2(root, state2) : null);
+  if (!appId) {
     result.status = "error";
-    result.error = `Feature "${featureId}" is missing swap_from / swap_to in the catalog.`;
+    result.error = state2 ? "Could not read COMETCHAT_APP_ID from the project's env file." : "App ID is required. Pass `--app-id <id>`.";
+    result.next_steps = state2 ? [`Confirm \`${state2.env_var_prefix ?? ""}COMETCHAT_APP_ID\` is set in your env file.`] : ["Run `cometchat apply-feature <id> --app-id <your-app-id>`."];
     return outputResult11(args, result, 1);
   }
-  if (state2.applied_features?.includes(featureId)) {
-    result.status = "already-applied";
+  try {
+    await toggleExtension(host, creds.token, appId, feature.id, "enable");
+  } catch (err) {
+    return handleApiError(args, result, err, feature);
+  }
+  if (state2) {
+    state2.applied_features = [...state2.applied_features ?? [], feature.id];
+    writeState(root, state2);
+    appendAuditEntry(root, {
+      command: `apply-feature ${feature.id}`,
+      summary: `Enabled extension "${feature.name}" via dashboard API on app ${appId}`,
+      inputs: { feature: feature.id, appId },
+      decisions: {
+        api_endpoint: `POST /apps/${appId}/extensions { enabled: ["${feature.id}"] }`,
+        auto_wired: feature.auto_wired_in_uikit ? "yes" : "no"
+      },
+      files_modified: [],
+      next_actions: [`Refresh the chat in the browser. ${feature.name} is now active.`]
+    });
+  }
+  result.next_steps = [
+    `Enabled ${feature.name} on app ${appId}.`,
+    feature.auto_wired_in_uikit ? "The UI Kit's defaultExtensions[] picks this up automatically \u2014 refresh the browser." : "Refresh the chat in the browser. If the feature requires UIKitSettingsBuilder.setExtensions([...]), see the docs link below.",
+    ...feature.docs_topic ? [`Docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
+  ];
+  return outputResult11(args, result, 0);
+}
+async function applyAiFeatureToggle(args, result, root, state2, explicitAppId, feature) {
+  if (!feature.ai_key) {
+    result.status = "error";
+    result.error = `Feature "${feature.id}" is type ai-feature but has no ai_key in the catalog.`;
+    return outputResult11(args, result, 1);
+  }
+  const host = getApiHost();
+  const creds = await loadToken(host);
+  if (!creds) {
+    result.status = "auth-required";
+    result.error = "No dashboard bearer token found.";
     result.next_steps = [
-      `${feature.name} is already applied to this integration.`,
-      `Files using ${feature.swap_to}: scan with \`grep -r "${feature.swap_to}" .\`.`
+      "Run `cometchat auth login` to authorize the CLI, then re-run this command."
     ];
-    return outputResult11(args, result, 0);
+    return outputResult11(args, result, 1);
+  }
+  const appId = explicitAppId || (state2 ? resolveAppId2(root, state2) : null);
+  if (!appId) {
+    result.status = "error";
+    result.error = state2 ? "Could not read COMETCHAT_APP_ID from the project's env file." : "App ID is required. Pass `--app-id <id>`.";
+    result.next_steps = state2 ? [`Confirm \`${state2.env_var_prefix ?? ""}COMETCHAT_APP_ID\` is set in your env file.`] : ["Run `cometchat apply-feature <id> --app-id <your-app-id> --openai-key <sk-\u2026>`."];
+    return outputResult11(args, result, 1);
+  }
+  const openaiFlag = args.flags["openai-key"];
+  const explicitKey = typeof openaiFlag === "string" ? openaiFlag.trim() : "";
+  let needsKeyWrite = false;
+  if (explicitKey.length > 0) {
+    needsKeyWrite = true;
+  } else {
+    let existing;
+    try {
+      existing = await getAiSettings(host, creds.token, appId);
+    } catch (err) {
+      return handleApiError(args, result, err, feature);
+    }
+    const currentKey = (existing?.openAIKey ?? "").trim();
+    if (currentKey.length === 0) {
+      result.status = "openai-key-required";
+      result.error = `${feature.name} requires an OpenAI API key. None is set on app ${appId}.`;
+      result.next_steps = [
+        "Pass `--openai-key <sk-\u2026>` to set the key and enable the feature in one step.",
+        "Get a key from https://platform.openai.com/api-keys"
+      ];
+      return outputResult11(args, result, 1);
+    }
+  }
+  try {
+    if (needsKeyWrite) {
+      await updateAiSettings(host, creds.token, appId, { openAIKey: explicitKey });
+    }
+    await toggleAiFeature(host, creds.token, appId, feature.ai_key, "enable");
+  } catch (err) {
+    return handleApiError(args, result, err, feature);
+  }
+  if (state2) {
+    state2.applied_features = [...state2.applied_features ?? [], feature.id];
+    writeState(root, state2);
+    appendAuditEntry(root, {
+      command: `apply-feature ${feature.id}`,
+      summary: `Enabled AI feature "${feature.name}" via dashboard API on app ${appId}`,
+      inputs: { feature: feature.id, appId, openai_key_written: needsKeyWrite },
+      decisions: {
+        settings_endpoint: needsKeyWrite ? `PUT /apps/${appId}/ai/settings { openAIKey: "(redacted)" }` : "skipped (key already set)",
+        toggle_endpoint: `POST /apps/${appId}/features/ai.${feature.ai_key}/enabled`
+      },
+      files_modified: [],
+      next_actions: [`Refresh the chat. AI ${feature.name} is now active.`]
+    });
+  }
+  result.next_steps = [
+    `Enabled ${feature.name} on app ${appId}.`,
+    needsKeyWrite ? "OpenAI key stored on the app's AI settings." : "OpenAI key was already set.",
+    "Refresh the chat in the browser to see the feature in action.",
+    ...feature.docs_topic ? [`Docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
+  ];
+  return outputResult11(args, result, 0);
+}
+function applyDashboardOnly(args, result, feature) {
+  result.status = "manual-action-required";
+  result.error = `${feature.name} requires config beyond a boolean toggle (third-party API key or multi-field setup).`;
+  result.next_steps = [
+    feature.dashboard_path ? `In the dashboard at https://app.cometchat.com \u2192 ${feature.dashboard_path}` : `Open https://app.cometchat.com and configure ${feature.name} on the Extensions page.`,
+    ...feature.docs_topic ? [`Docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
+  ];
+  return outputResult11(args, result, 1);
+}
+function applyPackageInstall(args, result, feature) {
+  result.status = "manual-action-required";
+  result.error = `${feature.name} requires installing an additional package.`;
+  const pkg = feature.package ?? "the calls SDK";
+  result.next_steps = [
+    `Run \`npm install ${pkg}\` and restart your dev server.`,
+    "The UI Kit's initiateAfterLogin() detects the SDK and wires up call buttons automatically.",
+    ...feature.docs_topic ? [`Docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
+  ];
+  return outputResult11(args, result, 1);
+}
+function applyComponentSwap(args, result, root, state2, feature) {
+  if (!feature.swap_from || !feature.swap_to) {
+    result.status = "error";
+    result.error = `Feature "${feature.id}" is missing swap_from / swap_to in the catalog.`;
+    return outputResult11(args, result, 1);
   }
   const newChecksums = { ...state2.checksums };
   const modified = [];
@@ -5883,7 +7459,7 @@ async function applyFeature(args) {
   const nextState = {
     ...state2,
     checksums: newChecksums,
-    applied_features: [...state2.applied_features ?? [], featureId]
+    applied_features: [...state2.applied_features ?? [], feature.id]
   };
   writeState(root, nextState);
   result.files_modified = modified;
@@ -5894,9 +7470,9 @@ async function applyFeature(args) {
     ...feature.docs_topic ? [`Docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
   ];
   appendAuditEntry(root, {
-    command: `apply-feature ${featureId}`,
+    command: `apply-feature ${feature.id}`,
     summary: `Applied component-swap feature "${feature.name}" \u2014 replaced ${feature.swap_from} with ${feature.swap_to} in ${modified.length} owned file(s)`,
-    inputs: { feature: featureId },
+    inputs: { feature: feature.id },
     decisions: {
       swap_target: `${feature.swap_from} \u2192 ${feature.swap_to} (canonical drop-in variant from @cometchat/chat-uikit-react)`,
       file_selection: `walked state.files_owned and ran a word-boundary regex replace; only files that contained the canonical token were touched`,
@@ -5907,6 +7483,24 @@ async function applyFeature(args) {
   });
   return outputResult11(args, result, 0);
 }
+function handleApiError(args, result, err, feature) {
+  const msg = err instanceof Error ? err.message : String(err);
+  if (msg === "AUTH_FAILED") {
+    result.status = "auth-required";
+    result.error = "Bearer token rejected (expired or invalid).";
+    result.next_steps = ["Run `cometchat auth login` to refresh the token, then re-run this command."];
+    return outputResult11(args, result, 1);
+  }
+  if (msg === "NETWORK") {
+    result.status = "error";
+    result.error = "Network error reaching the dashboard API.";
+    result.next_steps = ["Check your connection and re-run."];
+    return outputResult11(args, result, 1);
+  }
+  result.status = "error";
+  result.error = `Failed to enable ${feature.name}: ${msg}`;
+  return outputResult11(args, result, 1);
+}
 function outputResult11(args, result, exitCode) {
   if (isJsonMode16(args)) {
     console.log(JSON.stringify(enrichResultWithError(result), null, 2));
@@ -5920,9 +7514,11 @@ function printHumanReadable14(r) {
   lines.push("");
   if (r.status === "applied") {
     lines.push(`  \u2713 Applied feature: ${r.feature}`);
-    lines.push("");
-    lines.push("  Files modified:");
-    for (const f of r.files_modified) lines.push(`    ${f}`);
+    if (r.files_modified.length > 0) {
+      lines.push("");
+      lines.push("  Files modified:");
+      for (const f of r.files_modified) lines.push(`    ${f}`);
+    }
   } else if (r.status === "already-applied") {
     lines.push(`  \u25E6 ${r.feature} is already applied \u2014 nothing to do.`);
   } else {
@@ -6495,6 +8091,7 @@ Usage:
   cometchat auth login  [--token <bearer>] [--json]
   cometchat auth signup [--json]
   cometchat auth status [--json]
+  cometchat auth me     [--json]
   cometchat auth logout [--json]
 
 \`auth login\` and \`auth signup\` open your browser at the CometChat
@@ -6533,6 +8130,8 @@ async function auth(args) {
       return authLogin(args);
     case "status":
       return authStatus(args);
+    case "me":
+      return authMe(args);
     case "logout":
       return authLogout(args);
     case "signup":
@@ -6691,6 +8290,81 @@ async function authStatus(args) {
   console.log("");
   return 0;
 }
+async function authMe(args) {
+  const json = isJsonMode18(args);
+  const apiHost = getApiHost();
+  const creds = await loadToken(apiHost);
+  if (!creds) {
+    return printError(json, {
+      status: "logged-out",
+      error: "No bearer token found. Run `cometchat auth login` first."
+    });
+  }
+  let user;
+  try {
+    user = await getCurrentUserWithLastApp(apiHost, creds.token);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg === "AUTH_FAILED") {
+      return printError(json, {
+        status: "auth-required",
+        error: "Bearer token rejected (expired or invalid).",
+        next_step: "Run `cometchat auth login` to refresh the token."
+      });
+    }
+    return printError(json, { status: "error", error: msg });
+  }
+  const meta = user.meta ?? {};
+  const lastApp = user.last_app ?? null;
+  const payload = {
+    status: "logged-in",
+    email: user.email ?? creds.email ?? null,
+    name: user.name ?? null,
+    role: typeof meta.role === "string" ? meta.role : null,
+    other_role: typeof meta.otherRole === "string" && meta.otherRole.length > 0 ? meta.otherRole : null,
+    intent: typeof meta.intent === "string" ? meta.intent : null,
+    last_app: lastApp ? {
+      id: lastApp.id,
+      name: lastApp.name,
+      region: lastApp.region,
+      industry: lastApp.industry ?? null,
+      technology: lastApp.technology ?? null,
+      product: lastApp.product ?? null
+    } : null
+  };
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return 0;
+  }
+  console.log("");
+  console.log(`  \u2713 ${payload.email ?? "(no email on profile)"}`);
+  if (payload.name) console.log(`    Name:   ${payload.name}`);
+  console.log(`    Role:   ${payload.role ?? "(not set)"}${payload.other_role ? ` (${payload.other_role})` : ""}`);
+  console.log(`    Intent: ${payload.intent ?? "(not set)"}`);
+  if (payload.last_app) {
+    const la = payload.last_app;
+    console.log(`    Last app: ${la.name} (${la.region})`);
+    if (la.industry || la.technology || la.product) {
+      const bits = [
+        la.industry && `industry=${la.industry}`,
+        la.technology && `tech=${la.technology}`,
+        la.product && `product=${la.product}`
+      ].filter(Boolean);
+      console.log(`              ${bits.join(", ")}`);
+    }
+  }
+  console.log("");
+  return 0;
+}
+function printError(json, payload) {
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.error(`\u2717 ${payload.error ?? payload.status}`);
+    if (payload.next_step) console.error(`  ${payload.next_step}`);
+  }
+  return 1;
+}
 async function authLogout(args) {
   const json = isJsonMode18(args);
   const verbose = args.flags.verbose === true || args.flags.verbose === "true";
@@ -6711,6 +8385,8 @@ function stripNoise(result) {
     return result;
   }
   const { apiHost: _h, backend: _b, ...rest } = result;
+  void _h;
+  void _b;
   return rest;
 }
 function emit(json, result) {
@@ -6876,7 +8552,7 @@ async function provisionSetup(args) {
     return 1;
   }
   if (!frameworkFlag) {
-    const msg = "Missing --framework. One of: reactjs, nextjs, react-router, astro.";
+    const msg = "Missing --framework. One of: reactjs, nextjs, react-router, astro, expo, react-native, angular, android, flutter, ios.";
     if (json) return emitError(true, msg);
     console.error(msg);
     return 1;
@@ -6965,7 +8641,31 @@ var ENV_PREFIX_BY_FRAMEWORK = {
   reactjs: "VITE_",
   nextjs: "NEXT_PUBLIC_",
   "react-router": "VITE_",
-  astro: "PUBLIC_"
+  astro: "PUBLIC_",
+  expo: "EXPO_PUBLIC_",
+  "react-native": "",
+  // bare RN uses react-native-dotenv — no prefix
+  angular: "",
+  // Angular reads from src/environments/environment.ts; CLI writes
+  // a no-prefix .env as a credentials handoff, and the skill
+  // migrates the values into environment.ts during integration
+  android: "",
+  // Android reads from local.properties → BuildConfig at compile
+  // time. CLI writes a no-prefix .env handoff; the skill teaches
+  // the user to mirror values into local.properties + add
+  // buildConfigField entries to app/build.gradle.
+  flutter: "",
+  // Flutter has no runtime .env. Credentials come from
+  // --dart-define flags or a generated config Dart file. CLI
+  // writes a no-prefix .env handoff; the skill teaches the
+  // integration agent how to wire creds (typically a
+  // const-class file + runner script with --dart-define).
+  ios: ""
+  // iOS has no runtime .env. Credentials live in a
+  // Secrets.swift const file (gitignored) or get injected
+  // via xcconfig build settings. CLI writes a no-prefix
+  // .env handoff for the agent; the skill teaches the
+  // Secrets.swift / xcconfig migration.
 };
 async function provisionList(args) {
   const json = isJsonMode19(args);
@@ -8437,6 +10137,14 @@ function projectPath18(args) {
   if (typeof fromFlag === "string") return resolve21(fromFlag);
   return resolve21(process.cwd());
 }
+var STATE_ENV_PREFIX_BY_FRAMEWORK = {
+  reactjs: "VITE_",
+  nextjs: "NEXT_PUBLIC_",
+  "react-router": "VITE_",
+  astro: "PUBLIC_",
+  expo: "EXPO_PUBLIC_",
+  "react-native": ""
+};
 async function state(args) {
   if (args.flags.help || args.flags.h) {
     console.log(HELP21);
@@ -8474,7 +10182,7 @@ async function stateRecord(args) {
     return 1;
   }
   if (!envPrefix) {
-    envPrefix = framework === "nextjs" ? "NEXT_PUBLIC_" : framework === "astro" ? "PUBLIC_" : "VITE_";
+    envPrefix = STATE_ENV_PREFIX_BY_FRAMEWORK[framework] ?? "VITE_";
   }
   const experienceStr = asString5(args.flags.experience) ?? "0";
   const experience = parseInt(experienceStr, 10);