@cometchat/skills-cli 2.0.0

package/dist/index.js

@@ -0,0 +1,4395 @@
+// src/commands/detect.ts
+import { resolve } from "node:path";
+
+// src/utils/version.ts
+function stripRange(versionRange) {
+  return versionRange.replace(/^[\^~>=<\s]+/, "").trim();
+}
+function extractMajor(versionRange) {
+  if (!versionRange) return null;
+  const stripped = stripRange(versionRange);
+  const match = stripped.match(/^(\d+)/);
+  if (!match || !match[1]) return null;
+  const n = parseInt(match[1], 10);
+  return Number.isFinite(n) ? n : null;
+}
+function extractVersion(versionRange) {
+  if (!versionRange) return null;
+  const stripped = stripRange(versionRange);
+  return stripped || null;
+}
+
+// src/utils/fs.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function readFileOrNull(path) {
+  try {
+    if (!existsSync(path)) return null;
+    return readFileSync(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readJsonOrNull(path) {
+  const content = readFileOrNull(path);
+  if (content === null) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function pathExists(path) {
+  return existsSync(path);
+}
+function p(root, ...parts) {
+  return join(root, ...parts);
+}
+function parseEnvFile(content) {
+  const result = {};
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    const hash = value.indexOf(" #");
+    if (hash !== -1) value = value.slice(0, hash).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+function readAllEnvFiles(root) {
+  const merged = {};
+  const files = [".env", ".env.local", ".env.development", ".env.development.local"];
+  for (const f of files) {
+    const content = readFileOrNull(p(root, f));
+    if (content !== null) {
+      Object.assign(merged, parseEnvFile(content));
+    }
+  }
+  return merged;
+}
+
+// src/detectors/framework.ts
+var EMPTY = {
+  framework: null,
+  framework_version: null,
+  router: null,
+  bundler: null,
+  ssr_strategy: null,
+  env_prefix: null
+};
+function allDeps(pkg) {
+  return {
+    ...pkg.dependencies ?? {},
+    ...pkg.devDependencies ?? {}
+  };
+}
+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 detectNextjs(root, deps) {
+  if (!deps["next"]) return null;
+  const version = extractVersion(deps["next"]);
+  let router = null;
+  const hasAppDir = pathExists(p(root, "app")) || pathExists(p(root, "src/app"));
+  const hasPagesDir = pathExists(p(root, "pages")) || pathExists(p(root, "src/pages"));
+  if (hasAppDir) router = "app";
+  else if (hasPagesDir) router = "pages";
+  let bundler = "webpack";
+  const nextConfig = readFileOrNull(p(root, "next.config.js")) ?? readFileOrNull(p(root, "next.config.mjs")) ?? readFileOrNull(p(root, "next.config.ts"));
+  if (nextConfig && /turbopack|turbo\s*:/i.test(nextConfig)) {
+    bundler = "turbopack";
+  }
+  return {
+    framework: "nextjs",
+    framework_version: version,
+    router,
+    bundler,
+    ssr_strategy: "ssr-disabled-dynamic",
+    env_prefix: "NEXT_PUBLIC_"
+  };
+}
+function detectReactRouter(root, deps) {
+  const hasDev = !!deps["@react-router/dev"];
+  const hasReactRouter = !!deps["react-router"];
+  const hasReactRouterDom = !!deps["react-router-dom"];
+  if (!hasDev && !hasReactRouter && !hasReactRouterDom) return null;
+  let router = null;
+  let version = null;
+  if (hasDev) {
+    router = "v7";
+    version = extractVersion(deps["@react-router/dev"]);
+  } else if (hasReactRouter) {
+    const major = extractMajor(deps["react-router"]);
+    router = major !== null && major >= 7 ? "v7" : "v6";
+    version = extractVersion(deps["react-router"]);
+  } else if (hasReactRouterDom) {
+    const major = extractMajor(deps["react-router-dom"]);
+    router = major !== null && major >= 7 ? "v7" : "v6";
+    version = extractVersion(deps["react-router-dom"]);
+  }
+  const bundler = hasViteConfig(root) ? "vite" : "vite";
+  return {
+    framework: "react-router",
+    framework_version: version,
+    router,
+    bundler,
+    ssr_strategy: "client-only-component",
+    env_prefix: "VITE_"
+  };
+}
+function detectAstro(_root, deps) {
+  if (!deps["astro"]) return null;
+  const version = extractVersion(deps["astro"]);
+  return {
+    framework: "astro",
+    framework_version: version,
+    router: null,
+    // Astro has its own routing, not relevant to chat integration
+    bundler: "vite",
+    // Astro uses Vite internally
+    ssr_strategy: "client-only-island",
+    env_prefix: "PUBLIC_"
+  };
+}
+function detectReactjs(root, deps) {
+  if (!deps["react"]) return null;
+  const version = extractVersion(deps["react"]);
+  const isVite = hasViteConfig(root);
+  const isCra = !!deps["react-scripts"] || pathExists(p(root, "public/index.html"));
+  return {
+    framework: "reactjs",
+    framework_version: version,
+    router: "spa",
+    bundler: isVite ? "vite" : isCra ? "webpack" : "vite",
+    // default to vite for ambiguous
+    ssr_strategy: "spa-no-ssr",
+    env_prefix: isVite ? "VITE_" : isCra ? "REACT_APP_" : "VITE_"
+  };
+}
+function detectFramework(root) {
+  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;
+}
+
+// src/detectors/package-manager.ts
+function detectPackageManager(root) {
+  if (pathExists(p(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (pathExists(p(root, "yarn.lock"))) return "yarn";
+  if (pathExists(p(root, "bun.lockb")) || pathExists(p(root, "bun.lock"))) return "bun";
+  if (pathExists(p(root, "package-lock.json"))) return "npm";
+  return null;
+}
+
+// src/detectors/credentials.ts
+import { readdirSync, statSync } from "node:fs";
+import { join as join2, extname } from "node:path";
+function envVarsForPrefix(prefix) {
+  const p2 = prefix ?? "";
+  return {
+    appId: `${p2}COMETCHAT_APP_ID`,
+    region: `${p2}COMETCHAT_REGION`,
+    authKey: `${p2}COMETCHAT_AUTH_KEY`
+  };
+}
+function detectFromEnv(root, prefix) {
+  const env = readAllEnvFiles(root);
+  const { appId, region, authKey } = envVarsForPrefix(prefix);
+  return {
+    app_id_present: !!env[appId],
+    region_present: !!env[region],
+    auth_key_present: !!env[authKey]
+  };
+}
+function detectTokenEndpoint(root) {
+  const candidates = [
+    // Next.js App Router
+    "src/app/api/cometchat-token/route.ts",
+    "src/app/api/cometchat-token/route.js",
+    "src/app/api/cometchat-token/route.tsx",
+    "app/api/cometchat-token/route.ts",
+    "app/api/cometchat-token/route.js",
+    // Next.js Pages Router
+    "src/pages/api/cometchat-token.ts",
+    "src/pages/api/cometchat-token.js",
+    "pages/api/cometchat-token.ts",
+    "pages/api/cometchat-token.js",
+    // Astro
+    "src/pages/api/cometchat-token.ts",
+    "src/pages/api/cometchat-token.js",
+    // React Router v7 framework mode
+    "app/routes/api.cometchat-token.ts",
+    "app/routes/api.cometchat-token.tsx"
+  ];
+  for (const candidate of candidates) {
+    if (pathExists(p(root, candidate))) {
+      return "/api/cometchat-token";
+    }
+  }
+  const authCandidates = [
+    "src/app/api/auth/[...nextauth]/route.ts",
+    "app/api/auth/[...nextauth]/route.ts"
+  ];
+  for (const candidate of authCandidates) {
+    if (pathExists(p(root, candidate))) {
+      return "/api/auth";
+    }
+  }
+  return null;
+}
+function detectInferredFromSource(root) {
+  const srcDirs = ["src", "app"];
+  for (const dir of srcDirs) {
+    const fullDir = p(root, dir);
+    if (!pathExists(fullDir)) continue;
+    if (searchForInit(fullDir, 4)) return true;
+  }
+  return false;
+}
+function searchForInit(dir, maxDepth) {
+  if (maxDepth < 0) return false;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry === "node_modules" || entry.startsWith(".")) continue;
+    const full = join2(dir, entry);
+    let stat;
+    try {
+      stat = statSync(full);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      if (searchForInit(full, maxDepth - 1)) return true;
+      continue;
+    }
+    const ext = extname(entry);
+    if (![".ts", ".tsx", ".js", ".jsx", ".mjs", ".astro"].includes(ext)) continue;
+    const content = readFileOrNull(full);
+    if (!content) continue;
+    if (content.includes("CometChatUIKit.init") || content.includes("CometChatUIKit.login") || content.includes("@cometchat/chat-uikit-react")) {
+      return true;
+    }
+  }
+  return false;
+}
+function classifySource(args) {
+  if (args.tokenEndpoint !== null) return "token-endpoint";
+  if (args.hasEnv) return "env";
+  if (args.hasInferred) return "inferred";
+  return "none";
+}
+function detectCredentials(root, envPrefix) {
+  const envFlags = detectFromEnv(root, envPrefix);
+  const tokenEndpoint = detectTokenEndpoint(root);
+  const inferred = detectInferredFromSource(root);
+  const source = classifySource({
+    hasEnv: envFlags.app_id_present || envFlags.auth_key_present,
+    hasInferred: inferred,
+    tokenEndpoint
+  });
+  return {
+    source,
+    app_id_present: envFlags.app_id_present,
+    region_present: envFlags.region_present,
+    auth_key_present: envFlags.auth_key_present,
+    token_endpoint: tokenEndpoint
+  };
+}
+
+// src/detectors/integration.ts
+import { readdirSync as readdirSync2 } from "node:fs";
+function getInstalledVersion(root) {
+  const pkg = readJsonOrNull(p(root, "package.json"));
+  if (!pkg) return null;
+  const all = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  const version = all["@cometchat/chat-uikit-react"];
+  return version ? extractVersion(version) : null;
+}
+function readStateFileOwnedFiles(root) {
+  const state = readJsonOrNull(
+    p(root, ".cometchat/state.json")
+  );
+  if (!state || !Array.isArray(state.files_owned)) return null;
+  return state.files_owned;
+}
+function findCometchatDirs(root) {
+  const found = [];
+  const candidates = ["src/cometchat", "app/cometchat", "src/app/cometchat"];
+  for (const dir of candidates) {
+    const fullPath = p(root, dir);
+    if (!pathExists(fullPath)) continue;
+    try {
+      const entries = readdirSync2(fullPath);
+      for (const entry of entries) {
+        found.push(`${dir}/${entry}`);
+      }
+    } catch {
+    }
+  }
+  return found;
+}
+function findIntegrationEntryFiles(root) {
+  const checks = [
+    "src/cometchat/CometChatNoSSR.tsx",
+    "src/app/cometchat/CometChatNoSSR.tsx",
+    "app/cometchat/CometChatNoSSR.tsx",
+    "src/cometchat/CometChatSelector.tsx",
+    "src/components/cometchat/index.tsx"
+  ];
+  const found = [];
+  for (const c of checks) {
+    if (pathExists(p(root, c))) found.push(c);
+  }
+  const appTsx = readFileOrNull(p(root, "src/App.tsx"));
+  if (appTsx && appTsx.includes("@cometchat/chat-uikit-react")) {
+    found.push("src/App.tsx");
+  }
+  return found;
+}
+function detectExistingIntegration(root) {
+  const installedVersion = getInstalledVersion(root);
+  const stateFiles = readStateFileOwnedFiles(root);
+  if (stateFiles !== null) {
+    return {
+      installed: true,
+      version: installedVersion,
+      files: stateFiles
+    };
+  }
+  const dirs = findCometchatDirs(root);
+  const entries = findIntegrationEntryFiles(root);
+  const allFiles = [.../* @__PURE__ */ new Set([...dirs, ...entries])];
+  return {
+    installed: installedVersion !== null || allFiles.length > 0,
+    version: installedVersion,
+    files: allFiles
+  };
+}
+
+// src/detectors/compatibility.ts
+function computeCompatibility(fw) {
+  const warnings = [];
+  if (fw.framework === null) {
+    return {
+      supported: false,
+      warnings: [
+        "Could not detect a supported React framework. CometChat skills v2 supports: reactjs (Vite/CRA), nextjs, react-router (v6/v7), astro."
+      ]
+    };
+  }
+  if (fw.framework === "nextjs") {
+    if (fw.router === null) {
+      warnings.push(
+        "Next.js detected but neither App Router (app/) nor Pages Router (pages/) directory found. Integration may need a router setup first."
+      );
+    }
+    const major = fw.framework_version ? parseInt(fw.framework_version.split(".")[0] ?? "0", 10) : null;
+    if (major !== null && major < 13) {
+      warnings.push(
+        `Next.js ${fw.framework_version} is older than the tested baseline (13+). Integration may work but is not regression-tested.`
+      );
+    }
+  }
+  if (fw.framework === "react-router" && fw.router === "v6") {
+    warnings.push(
+      "React Router v6 detected. v7 is the recommended version for new projects; v6 is supported but receives less active maintenance."
+    );
+  }
+  if (fw.framework === "reactjs" && fw.bundler === "webpack") {
+    warnings.push(
+      "Create React App (CRA) detected. CRA is no longer actively maintained; we recommend migrating to Vite when convenient. CometChat integration still works."
+    );
+  }
+  return { supported: true, warnings };
+}
+
+// src/detectors/architecture-context.ts
+var AGENT_INSTRUCTION_CANDIDATES = [
+  "AGENTS.md",
+  // Codex / generic
+  "CLAUDE.md",
+  // Claude Code
+  "GEMINI.md",
+  // Gemini CLI
+  "CURSOR.md",
+  // Cursor
+  ".cursorrules",
+  // Cursor (legacy)
+  ".cursor/rules",
+  // Cursor (newer)
+  ".github/copilot-instructions.md",
+  // GitHub Copilot
+  ".windsurfrules",
+  // Windsurf
+  ".aider.conf.yml",
+  // Aider
+  ".kiro/agent-instructions.md",
+  // Kiro
+  "AGENT_INSTRUCTIONS.md"
+  // generic / Continue / Cline
+];
+var ARCHITECTURE_DOC_CANDIDATES = [
+  "ARCHITECTURE.md",
+  "CONTRIBUTING.md",
+  "CONVENTIONS.md",
+  "docs/architecture/",
+  "docs/adr/",
+  "docs/architecture-decisions/",
+  "docs/decisions/",
+  "ADRs/",
+  ".docs/architecture.md"
+];
+var SKILL_DIR_CANDIDATES = [
+  ".kiro/skills",
+  ".claude/skills",
+  ".cursor/skills",
+  ".windsurf/skills"
+];
+function detectArchitectureContext(root) {
+  const agent_instruction_files = [];
+  for (const candidate of AGENT_INSTRUCTION_CANDIDATES) {
+    if (pathExists(p(root, candidate))) {
+      agent_instruction_files.push(candidate);
+    }
+  }
+  const architecture_docs = [];
+  for (const candidate of ARCHITECTURE_DOC_CANDIDATES) {
+    if (pathExists(p(root, candidate))) {
+      architecture_docs.push(candidate);
+    }
+  }
+  const installed_skill_directories = [];
+  for (const candidate of SKILL_DIR_CANDIDATES) {
+    if (pathExists(p(root, candidate))) {
+      installed_skill_directories.push(candidate);
+    }
+  }
+  return {
+    agent_instruction_files,
+    architecture_docs,
+    installed_skill_directories
+  };
+}
+
+// src/detectors/index.ts
+async function runDetectors(root) {
+  const fw = detectFramework(root);
+  const package_manager = detectPackageManager(root);
+  const credentials = detectCredentials(root, fw.env_prefix);
+  const existing_integration = detectExistingIntegration(root);
+  const compatibility = computeCompatibility(fw);
+  const architecture_context = detectArchitectureContext(root);
+  return {
+    project_root: root,
+    framework: fw.framework,
+    framework_version: fw.framework_version,
+    router: fw.router,
+    bundler: fw.bundler,
+    ssr_strategy: fw.ssr_strategy,
+    env_prefix: fw.env_prefix,
+    package_manager,
+    credentials,
+    existing_integration,
+    compatibility,
+    architecture_context
+  };
+}
+
+// src/commands/detect.ts
+function isJsonMode(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath(args) {
+  const fromArg = args.positional[0];
+  return resolve(fromArg ?? process.cwd());
+}
+async function detect(args) {
+  const root = projectPath(args);
+  const result = await runDetectors(root);
+  if (isJsonMode(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.compatibility.supported ? 0 : 2;
+  }
+  printHumanReadable(result);
+  return result.compatibility.supported ? 0 : 2;
+}
+function printHumanReadable(r) {
+  const lines = [];
+  lines.push("");
+  lines.push(`  Project:           ${r.project_root}`);
+  lines.push(`  Framework:         ${r.framework ?? "unknown"}${r.framework_version ? ` (${r.framework_version})` : ""}`);
+  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.package_manager !== null) lines.push(`  Package manager:   ${r.package_manager}`);
+  lines.push("");
+  lines.push("  Credentials:");
+  lines.push(`    Source:           ${r.credentials.source}`);
+  lines.push(`    APP_ID present:   ${r.credentials.app_id_present ? "yes" : "no"}`);
+  lines.push(`    REGION present:   ${r.credentials.region_present ? "yes" : "no"}`);
+  lines.push(`    AUTH_KEY present: ${r.credentials.auth_key_present ? "yes" : "no"}`);
+  if (r.credentials.token_endpoint !== null) {
+    lines.push(`    Token endpoint:   ${r.credentials.token_endpoint}`);
+  }
+  lines.push("");
+  lines.push("  Existing CometChat integration:");
+  lines.push(`    Installed:        ${r.existing_integration.installed ? "yes" : "no"}`);
+  if (r.existing_integration.version !== null) {
+    lines.push(`    Version:          ${r.existing_integration.version}`);
+  }
+  if (r.existing_integration.files.length > 0) {
+    lines.push(`    Files:`);
+    for (const f of r.existing_integration.files) {
+      lines.push(`      - ${f}`);
+    }
+  }
+  lines.push("");
+  lines.push(`  Compatibility:     ${r.compatibility.supported ? "supported" : "NOT supported"}`);
+  if (r.compatibility.warnings.length > 0) {
+    lines.push("  Warnings:");
+    for (const w of r.compatibility.warnings) {
+      lines.push(`    - ${w}`);
+    }
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/experiences.ts
+var ALL_EXPERIENCES = [
+  {
+    id: 1,
+    slug: "conversation-list",
+    name: "Conversation List + Message View",
+    description: "Two-panel layout. Left: list of all conversations. Right: message thread for the selected conversation. Best when users browse and switch between multiple conversations.",
+    default_placement: "dedicated-route",
+    files_touched: 5,
+    components_required: [
+      "CometChatConversations",
+      "CometChatMessageHeader",
+      "CometChatMessageList",
+      "CometChatMessageComposer"
+    ],
+    supported_frameworks: ["reactjs", "nextjs", "react-router", "astro"]
+  },
+  {
+    id: 2,
+    slug: "one-to-one",
+    name: "One-to-One Chat",
+    description: "Single message window with a hardcoded user or group. No conversation list. Best for customer support widgets or matched-pair chat.",
+    default_placement: "dedicated-route",
+    files_touched: 4,
+    components_required: [
+      "CometChatMessageHeader",
+      "CometChatMessageList",
+      "CometChatMessageComposer"
+    ],
+    supported_frameworks: ["reactjs", "nextjs", "react-router", "astro"]
+  },
+  {
+    id: 3,
+    slug: "tab-based",
+    name: "Tab-Based Chat",
+    description: "Left panel has a tab bar (Chats / Calls / Users / Groups). Each tab shows the corresponding CometChat list. Right panel shows messages for selected conversation. Best for full-featured messenger-style apps.",
+    default_placement: "dedicated-route",
+    files_touched: 7,
+    components_required: [
+      "CometChatConversations",
+      "CometChatUsers",
+      "CometChatGroups",
+      "CometChatCallLogs",
+      "CometChatMessageHeader",
+      "CometChatMessageList",
+      "CometChatMessageComposer"
+    ],
+    supported_frameworks: ["reactjs", "nextjs", "react-router", "astro"]
+  }
+];
+function isJsonMode2(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function frameworkFilter(args) {
+  const f = args.flags.framework;
+  if (typeof f !== "string") return null;
+  if (f === "reactjs" || f === "nextjs" || f === "react-router" || f === "astro") {
+    return f;
+  }
+  return null;
+}
+async function experiences(args) {
+  const filter = frameworkFilter(args);
+  const list = filter ? ALL_EXPERIENCES.filter((e) => e.supported_frameworks.includes(filter)) : ALL_EXPERIENCES;
+  if (isJsonMode2(args)) {
+    console.log(JSON.stringify({ experiences: list }, null, 2));
+    return 0;
+  }
+  console.log("");
+  console.log("  Available chat experiences:");
+  console.log("");
+  for (const e of list) {
+    console.log(`  [${e.id}] ${e.name}  (slug: ${e.slug})`);
+    console.log(`      ${e.description}`);
+    console.log(
+      `      Default placement: ${e.default_placement}  \u2022  Files touched: ${e.files_touched}`
+    );
+    console.log(`      Components: ${e.components_required.join(", ")}`);
+    console.log(
+      `      Frameworks: ${e.supported_frameworks.join(", ")}`
+    );
+    console.log("");
+  }
+  return 0;
+}
+
+// src/commands/view.ts
+import { resolve as resolve3 } from "node:path";
+
+// src/utils/registry.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname, join as join3, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function findRegistryRoot() {
+  const candidates = [
+    // (1) Published install: registry bundled into the CLI's dist/
+    //     bin/cometchat.mjs imports dist/index.js → __dirname is .../dist
+    //     so dist/registry/ sits next to dist/index.js
+    resolve2(__dirname, "registry"),
+    // (2) Bundled-dev: same shape as published but inside packages/cli/dist
+    resolve2(__dirname, "../registry"),
+    // (3) Dev mode: cli/src/utils → cli → packages → registry
+    resolve2(__dirname, "../../../registry"),
+    // (4) Dev mode bundled: cli/dist → cli → packages → registry
+    resolve2(__dirname, "../../registry")
+  ];
+  for (const c of candidates) {
+    const sentinel = join3(c, "v6", "experiences", "1-conversation-list", "reactjs.template.json");
+    if (existsSync2(sentinel)) {
+      return c;
+    }
+  }
+  throw new Error(
+    "Could not locate @cometchat/skills-registry. Searched: " + candidates.join(", ")
+  );
+}
+var ROOT = findRegistryRoot();
+function experienceDir(experienceId) {
+  switch (experienceId) {
+    case 1:
+      return "1-conversation-list";
+    case 2:
+      return "2-one-to-one";
+    case 3:
+      return "3-tab-based";
+    default:
+      throw new Error(`Unknown experience id: ${experienceId}`);
+  }
+}
+function loadManifest(sdkMajor, framework, experienceId) {
+  const path = join3(
+    ROOT,
+    `v${sdkMajor}`,
+    "experiences",
+    experienceDir(experienceId),
+    `${framework}.template.json`
+  );
+  let content;
+  try {
+    content = readFileSync2(path, "utf8");
+  } catch {
+    throw new Error(
+      `No template manifest for framework=${framework} experience=${experienceId} sdkMajor=${sdkMajor} (looked at ${path})`
+    );
+  }
+  return JSON.parse(content);
+}
+function readTemplateFile(sdkMajor, framework, experienceId, templateRef) {
+  const path = join3(
+    ROOT,
+    `v${sdkMajor}`,
+    "experiences",
+    experienceDir(experienceId),
+    "templates",
+    framework,
+    templateRef
+  );
+  return readFileSync2(path, "utf8");
+}
+
+// src/utils/template.ts
+function substitute(content, subs) {
+  return content.replace(/\{\{([A-Z_][A-Z0-9_]*)\}\}/g, (match, varName) => {
+    if (varName in subs) return subs[varName];
+    return match;
+  });
+}
+function defaultSubs(envPrefix) {
+  return {
+    ENV_PREFIX: envPrefix,
+    LOGIN_UID: "cometchat-uid-1",
+    CHAT_UID: "cometchat-uid-2"
+  };
+}
+
+// src/commands/view.ts
+function isJsonMode3(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath2(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve3(fromFlag);
+  return resolve3(process.cwd());
+}
+function getNumberFlag(args, name) {
+  const v = args.flags[name];
+  if (typeof v !== "string") return null;
+  const n = parseInt(v, 10);
+  return Number.isFinite(n) ? n : null;
+}
+function getStringFlag(args, name) {
+  const v = args.flags[name];
+  return typeof v === "string" ? v : null;
+}
+function resolveExperience(experienceArg) {
+  if (experienceArg === null) return null;
+  if (experienceArg === "1" || experienceArg === "conversation-list") return 1;
+  if (experienceArg === "2" || experienceArg === "one-to-one") return 2;
+  if (experienceArg === "3" || experienceArg === "tab-based") return 3;
+  const n = parseInt(experienceArg, 10);
+  if (n >= 1 && n <= 3) return n;
+  return null;
+}
+function buildFileOutputs(manifest, subs, sdkMajor) {
+  const out = [];
+  for (const f of manifest.files) {
+    if (f.action === "create") {
+      const raw = readTemplateFile(sdkMajor, manifest.framework, manifest.experience_id, f.template_ref);
+      const content = substitute(raw, subs);
+      const path = substitute(f.path, subs);
+      out.push({
+        path,
+        action: "create",
+        content,
+        owned: f.owned ?? true
+      });
+    } else if (f.action === "patch") {
+      const path = substitute(f.path, subs);
+      const patchContent = f.patch_content ? substitute(f.patch_content, subs) : "";
+      out.push({
+        path,
+        action: "patch",
+        patch_content: patchContent,
+        patch_mode: f.patch_mode ?? "prepend",
+        owned: false
+      });
+    }
+  }
+  return out;
+}
+async function view(args) {
+  const experienceArg = getStringFlag(args, "experience");
+  const frameworkArg = getStringFlag(args, "framework");
+  const sdkMajor = getNumberFlag(args, "sdk-major") ?? 6;
+  const experienceId = resolveExperience(experienceArg);
+  if (experienceId === null) {
+    console.error("Error: --experience is required (one of: 1, 2, 3, conversation-list, one-to-one, tab-based)");
+    return 1;
+  }
+  let framework = frameworkArg;
+  let envPrefix = null;
+  const root = projectPath2(args);
+  if (!framework) {
+    const detected = await runDetectors(root);
+    if (detected.framework === null) {
+      console.error("Error: --framework not specified and no React framework detected in " + root);
+      console.error("Pass --framework reactjs|nextjs|react-router|astro");
+      return 1;
+    }
+    framework = detected.framework;
+    envPrefix = detected.env_prefix;
+  }
+  if (!envPrefix) {
+    envPrefix = framework === "nextjs" ? "NEXT_PUBLIC_" : framework === "astro" ? "PUBLIC_" : "VITE_";
+  }
+  let manifest;
+  try {
+    manifest = loadManifest(sdkMajor, framework, experienceId);
+  } catch (err) {
+    console.error("Error: " + (err instanceof Error ? err.message : String(err)));
+    return 1;
+  }
+  const subs = defaultSubs(envPrefix);
+  const files = buildFileOutputs(manifest, subs, sdkMajor);
+  const envVarsToAdd = manifest.env_vars.map((v) => ({
+    name: substitute(v.name, subs),
+    required: v.required,
+    secret: v.secret ?? false
+  }));
+  const result = {
+    template_version: manifest.version,
+    framework: manifest.framework,
+    experience_id: manifest.experience_id,
+    files,
+    deps_to_install: manifest.deps.map((d) => ({
+      name: d.name,
+      version: d.version,
+      dev: d.dev ?? false
+    })),
+    env_vars_to_add: envVarsToAdd,
+    next_steps: (manifest.next_steps ?? []).map((s) => substitute(s, subs)),
+    warnings: []
+  };
+  if (isJsonMode3(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  printHumanReadable2(result);
+  return 0;
+}
+function printHumanReadable2(r) {
+  const lines = [];
+  lines.push("");
+  lines.push(`  Preview: experience ${r.experience_id} on ${r.framework}`);
+  lines.push(`  Template version: ${r.template_version}`);
+  lines.push("");
+  lines.push("  Dependencies to install:");
+  for (const d of r.deps_to_install) {
+    const tag = d.dev ? " (dev)" : "";
+    lines.push(`    + ${d.name}@${d.version}${tag}`);
+  }
+  lines.push("");
+  lines.push("  Environment variables to add:");
+  for (const e of r.env_vars_to_add) {
+    const tag = e.secret ? " (secret)" : "";
+    lines.push(`    + ${e.name}${tag}`);
+  }
+  lines.push("");
+  lines.push("  Files to create/patch:");
+  for (const f of r.files) {
+    const action = f.action === "create" ? "create" : `patch (${f.patch_mode})`;
+    const owned = f.owned ? " [owned]" : "";
+    lines.push(`    ${action}: ${f.path}${owned}`);
+  }
+  if (r.next_steps.length > 0) {
+    lines.push("");
+    lines.push("  Next steps after apply:");
+    for (const step of r.next_steps) {
+      lines.push(`    - ${step}`);
+    }
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/apply.ts
+import { resolve as resolve4 } from "node:path";
+import { dirname as posixDirname, join as posixJoin, relative as posixRelative } from "node:path/posix";
+
+// src/utils/audit-log.ts
+import { mkdirSync, readFileSync as readFileSync3, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+var AUDIT_LOG_PATH = ".cometchat/AUDIT_LOG.md";
+function appendAuditEntry(projectRoot, entry) {
+  const filePath = join4(projectRoot, AUDIT_LOG_PATH);
+  mkdirSync(dirname2(filePath), { recursive: true });
+  let body = "";
+  if (!pathExists(filePath)) {
+    body = `# CometChat Integration Audit Log
+
+> Auto-generated by the \`cometchat\` CLI. Append-only \u2014 every command
+> writes one section here so a human reader can answer "why is this
+> integration set up this way?" without reverse-engineering state.json.
+>
+> The machine-readable source of truth lives in \`.cometchat/state.json\`.
+> This file is for humans.
+
+`;
+  } else {
+    try {
+      body = readFileSync3(filePath, "utf8");
+    } catch {
+      body = "";
+    }
+  }
+  body += renderEntry(entry);
+  writeFileSync(filePath, body, "utf8");
+}
+function renderEntry(entry) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [];
+  lines.push(`---
+`);
+  lines.push(`## ${ts}  \u2014  \`cometchat ${entry.command}\``);
+  lines.push("");
+  lines.push(`**${entry.summary}**`);
+  lines.push("");
+  if (entry.inputs && Object.keys(entry.inputs).length > 0) {
+    lines.push(`### Inputs`);
+    lines.push("");
+    for (const [key, value] of Object.entries(entry.inputs)) {
+      lines.push(`- **${key}:** \`${value}\``);
+    }
+    lines.push("");
+  }
+  if (entry.decisions && Object.keys(entry.decisions).length > 0) {
+    lines.push(`### Decisions & rationale`);
+    lines.push("");
+    for (const [decision, rationale] of Object.entries(entry.decisions)) {
+      lines.push(`- **${decision}** \u2014 ${rationale}`);
+    }
+    lines.push("");
+  }
+  if (entry.files_created && entry.files_created.length > 0) {
+    lines.push(`### Files created (${entry.files_created.length})`);
+    lines.push("");
+    for (const f of entry.files_created) lines.push(`- \`${f}\``);
+    lines.push("");
+  }
+  if (entry.files_patched && entry.files_patched.length > 0) {
+    lines.push(`### Files patched (${entry.files_patched.length})`);
+    lines.push("");
+    for (const f of entry.files_patched) lines.push(`- \`${f}\``);
+    lines.push("");
+  }
+  if (entry.files_modified && entry.files_modified.length > 0) {
+    lines.push(`### Files modified in place (${entry.files_modified.length})`);
+    lines.push("");
+    for (const f of entry.files_modified) lines.push(`- \`${f}\``);
+    lines.push("");
+  }
+  if (entry.files_skipped && entry.files_skipped.length > 0) {
+    lines.push(`### Files skipped (${entry.files_skipped.length})`);
+    lines.push("");
+    for (const f of entry.files_skipped) lines.push(`- \`${f}\``);
+    lines.push("");
+  }
+  if (entry.next_actions && entry.next_actions.length > 0) {
+    lines.push(`### Manual next actions`);
+    lines.push("");
+    for (const a of entry.next_actions) lines.push(`- ${a}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/commands/apply.ts
+import { spawnSync } from "node:child_process";
+
+// src/utils/writer.ts
+import { copyFileSync, mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync, rmSync, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname4, join as join6, relative } from "node:path";
+
+// src/state.ts
+import { createHash } from "node:crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
+var STATE_SCHEMA_VERSION = 1;
+var STATE_FILE_PATH = ".cometchat/state.json";
+function sha256(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function readState(projectRoot) {
+  const state = readJsonOrNull(p(projectRoot, STATE_FILE_PATH));
+  if (!state) return null;
+  if (state.schema_version !== STATE_SCHEMA_VERSION) {
+    return null;
+  }
+  return state;
+}
+function writeState(projectRoot, state) {
+  const filePath = join5(projectRoot, STATE_FILE_PATH);
+  mkdirSync2(dirname3(filePath), { recursive: true });
+  writeFileSync2(filePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+function hasState(projectRoot) {
+  return pathExists(p(projectRoot, STATE_FILE_PATH));
+}
+function detectDrift(projectRoot, state) {
+  const modified = [];
+  const missing = [];
+  const unchanged = [];
+  for (const file of state.files_owned) {
+    const fullPath = join5(projectRoot, file);
+    if (!pathExists(fullPath)) {
+      missing.push(file);
+      continue;
+    }
+    let content;
+    try {
+      content = readFileSync4(fullPath, "utf8");
+    } catch {
+      missing.push(file);
+      continue;
+    }
+    const currentHash = sha256(content);
+    const expectedHash = state.checksums[file];
+    if (expectedHash === void 0) {
+      modified.push(file);
+      continue;
+    }
+    if (currentHash === expectedHash) {
+      unchanged.push(file);
+    } else {
+      modified.push(file);
+    }
+  }
+  return {
+    modified_files: modified,
+    missing_files: missing,
+    unchanged_files: unchanged
+  };
+}
+function isSameIntegration(state, args) {
+  return state.experience === args.experience && state.framework === args.framework && state.placement === args.placement;
+}
+function buildState(args) {
+  return {
+    schema_version: STATE_SCHEMA_VERSION,
+    applied_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...args
+  };
+}
+
+// src/utils/writer.ts
+var STAGING_DIR = ".cometchat-staging";
+var BACKUPS_DIR = ".cometchat-staging/.backups";
+function applyWrites(projectRoot, ops) {
+  const stagingRoot = join6(projectRoot, STAGING_DIR);
+  const backupsRoot = join6(projectRoot, BACKUPS_DIR);
+  const result = {
+    files_created: [],
+    files_modified: [],
+    files_skipped: [],
+    checksums: {}
+  };
+  const committedTargets = [];
+  try {
+    cleanDir(stagingRoot);
+    cleanDir(backupsRoot);
+    const stagedOps = stageOps(projectRoot, stagingRoot, ops, result);
+    for (const staged of stagedOps) {
+      const targetPath = join6(projectRoot, staged.relPath);
+      mkdirSync3(dirname4(targetPath), { recursive: true });
+      let backupPath = null;
+      if (pathExists(targetPath)) {
+        backupPath = join6(backupsRoot, staged.relPath);
+        mkdirSync3(dirname4(backupPath), { recursive: true });
+        copyFileSync(targetPath, backupPath);
+      }
+      renameSync(staged.stagingPath, targetPath);
+      committedTargets.push({ path: targetPath, backup: backupPath });
+    }
+    safeRmRecursive(stagingRoot);
+    return result;
+  } catch (err) {
+    for (const c of committedTargets) {
+      if (c.backup) {
+        try {
+          copyFileSync(c.backup, c.path);
+        } catch {
+        }
+      } else {
+        try {
+          rmSync(c.path);
+        } catch {
+        }
+      }
+    }
+    safeRmRecursive(stagingRoot);
+    throw err;
+  }
+}
+function stageOps(projectRoot, stagingRoot, ops, result) {
+  const staged = [];
+  const patchedInMemory = /* @__PURE__ */ new Map();
+  const alreadyRecorded = /* @__PURE__ */ new Set();
+  for (const op of ops) {
+    const targetPath = join6(projectRoot, op.path);
+    const stagingPath = join6(stagingRoot, op.path);
+    if (op.type === "create") {
+      mkdirSync3(dirname4(stagingPath), { recursive: true });
+      writeFileSync3(stagingPath, op.content, "utf8");
+      const isOverwrite = pathExists(targetPath);
+      if (isOverwrite) {
+        if (!alreadyRecorded.has(op.path)) {
+          result.files_modified.push(op.path);
+          alreadyRecorded.add(op.path);
+        }
+      } else {
+        if (!alreadyRecorded.has(op.path)) {
+          result.files_created.push(op.path);
+          alreadyRecorded.add(op.path);
+        }
+      }
+      if (op.owned) {
+        result.checksums[op.path] = sha256(op.content);
+      }
+      patchedInMemory.set(op.path, op.content);
+      const existingStagedIdx2 = staged.findIndex((s) => s.relPath === op.path);
+      if (existingStagedIdx2 !== -1) {
+        staged[existingStagedIdx2] = { relPath: op.path, stagingPath, isCreate: !isOverwrite };
+      } else {
+        staged.push({ relPath: op.path, stagingPath, isCreate: !isOverwrite });
+      }
+      continue;
+    }
+    if (!pathExists(targetPath) && !patchedInMemory.has(op.path)) {
+      result.files_skipped.push({
+        path: op.path,
+        reason: `target file does not exist (cannot patch)`
+      });
+      continue;
+    }
+    const existingContent = patchedInMemory.get(op.path) ?? readFileSync5(targetPath, "utf8");
+    if (op.skip_if_exists && existingContent.includes(op.skip_if_exists)) {
+      result.files_skipped.push({
+        path: op.path,
+        reason: `already contains: ${op.skip_if_exists}`
+      });
+      continue;
+    }
+    const patched = applyPatch(existingContent, op);
+    if (patched === existingContent) {
+      result.files_skipped.push({
+        path: op.path,
+        reason: "patch produced no change"
+      });
+      continue;
+    }
+    patchedInMemory.set(op.path, patched);
+    mkdirSync3(dirname4(stagingPath), { recursive: true });
+    writeFileSync3(stagingPath, patched, "utf8");
+    if (!alreadyRecorded.has(op.path)) {
+      result.files_modified.push(op.path);
+      alreadyRecorded.add(op.path);
+    }
+    const existingStagedIdx = staged.findIndex((s) => s.relPath === op.path);
+    if (existingStagedIdx !== -1) {
+      staged[existingStagedIdx] = { relPath: op.path, stagingPath, isCreate: false };
+    } else {
+      staged.push({ relPath: op.path, stagingPath, isCreate: false });
+    }
+  }
+  return staged;
+}
+function applyPatch(existing, op) {
+  switch (op.patch_mode) {
+    case "prepend":
+      return op.patch_content + existing;
+    case "append":
+      return existing + op.patch_content;
+    case "insert-after": {
+      if (!op.anchor) return existing;
+      const idx = existing.indexOf(op.anchor);
+      if (idx === -1) return existing;
+      const insertAt = idx + op.anchor.length;
+      return existing.slice(0, insertAt) + op.patch_content + existing.slice(insertAt);
+    }
+    case "insert-before": {
+      if (!op.anchor) return existing;
+      const idx = existing.indexOf(op.anchor);
+      if (idx === -1) return existing;
+      return existing.slice(0, idx) + op.patch_content + existing.slice(idx);
+    }
+    case "replace-section": {
+      if (!op.anchor) return existing;
+      const idx = existing.indexOf(op.anchor);
+      if (idx === -1) return existing;
+      const lineEnd = existing.indexOf("\n", idx);
+      const replaceEnd = lineEnd === -1 ? existing.length : lineEnd;
+      return existing.slice(0, idx) + op.patch_content + existing.slice(replaceEnd);
+    }
+    default:
+      return existing;
+  }
+}
+function cleanDir(dir) {
+  safeRmRecursive(dir);
+  mkdirSync3(dir, { recursive: true });
+}
+function safeRmRecursive(dir) {
+  try {
+    if (statSync2(dir).isDirectory()) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+
+// src/utils/boilerplate.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+var VITE_REACT_TS_APP_MARKERS = [
+  "Vite + React",
+  "vite.svg",
+  "react.svg",
+  "count is",
+  "function App()"
+];
+var VITE_MAIN_MARKERS = [
+  "ReactDOM.createRoot",
+  "createRoot",
+  "<StrictMode>",
+  "import App from"
+];
+var VITE_APP_CSS_MARKERS = [
+  ".counter",
+  ".hero",
+  ".framework",
+  ".vite",
+  // Legacy 2023-era Vite template
+  ".logo",
+  ".card",
+  ".read-the-docs"
+];
+var NEXTJS_PAGE_MARKERS = [
+  "page.module.css",
+  "next/image",
+  "Get started by editing",
+  "Vercel logomark"
+];
+var ASTRO_INDEX_MARKERS = [
+  "Astro.generator",
+  "<title>Astro</title>"
+];
+var REACT_ROUTER_HOME_MARKERS = [
+  "react-router/dev",
+  "What's next?",
+  "Welcome to React Router"
+];
+function looksLikeDefault(content, markers) {
+  const found = markers.filter((m) => content.includes(m)).length;
+  return found >= 2;
+}
+function readFileSafe(path) {
+  try {
+    if (!pathExists(path)) return null;
+    return readFileSync6(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function checkOverwriteSafety(root, framework, filePath) {
+  const fullPath = p(root, filePath);
+  if (!pathExists(fullPath)) {
+    return {
+      path: filePath,
+      exists: false,
+      is_boilerplate: true,
+      // doesn't exist => "safe to create"
+      current_size: 0,
+      reason: "file does not exist"
+    };
+  }
+  const content = readFileSafe(fullPath) ?? "";
+  const size = content.length;
+  let markers = null;
+  if (framework === "reactjs") {
+    if (filePath.endsWith("/App.tsx") || filePath.endsWith("/App.jsx")) {
+      markers = VITE_REACT_TS_APP_MARKERS;
+    } else if (filePath.endsWith("/main.tsx") || filePath.endsWith("/main.jsx")) {
+      markers = VITE_MAIN_MARKERS;
+    } else if (filePath.endsWith("/App.css")) {
+      markers = VITE_APP_CSS_MARKERS;
+    }
+  } else if (framework === "nextjs") {
+    if (filePath.endsWith("/page.tsx") || filePath.endsWith("/page.jsx")) {
+      markers = NEXTJS_PAGE_MARKERS;
+    }
+  } else if (framework === "astro") {
+    if (filePath.endsWith("/index.astro")) {
+      markers = ASTRO_INDEX_MARKERS;
+    }
+  } else if (framework === "react-router") {
+    if (filePath.endsWith("/home.tsx") || filePath.endsWith("/welcome.tsx")) {
+      markers = REACT_ROUTER_HOME_MARKERS;
+    }
+  }
+  if (markers === null) {
+    if (size < 200) {
+      return {
+        path: filePath,
+        exists: true,
+        is_boilerplate: true,
+        current_size: size,
+        reason: "file is small (< 200 bytes), likely boilerplate or near-empty"
+      };
+    }
+    return {
+      path: filePath,
+      exists: true,
+      is_boilerplate: false,
+      current_size: size,
+      reason: `file is ${size} bytes \u2014 no framework-default markers to verify, assuming user content`
+    };
+  }
+  const isDefault = looksLikeDefault(content, markers);
+  return {
+    path: filePath,
+    exists: true,
+    is_boilerplate: isDefault,
+    current_size: size,
+    reason: isDefault ? `matches ${framework} default scaffold markers` : `does not match ${framework} default scaffold \u2014 has user content`
+  };
+}
+function checkOverwriteSafetyBatch(root, framework, filePaths) {
+  return filePaths.map((p2) => checkOverwriteSafety(root, framework, p2));
+}
+
+// src/commands/apply.ts
+function isJsonMode4(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function isForceMode(args) {
+  return args.flags.force === true || args.flags.force === "true";
+}
+function isForceOverwriteMode(args) {
+  return args.flags["force-overwrite"] === true || args.flags["force-overwrite"] === "true";
+}
+function isAutoInstallMode(args) {
+  return args.flags["auto-install"] === true || args.flags["auto-install"] === "true";
+}
+function projectPath3(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve4(fromFlag);
+  return resolve4(process.cwd());
+}
+function getStringFlag2(args, name) {
+  const v = args.flags[name];
+  return typeof v === "string" ? v : null;
+}
+function resolveExperience2(experienceArg) {
+  if (experienceArg === null) return null;
+  if (experienceArg === "1" || experienceArg === "conversation-list") return 1;
+  if (experienceArg === "2" || experienceArg === "one-to-one") return 2;
+  if (experienceArg === "3" || experienceArg === "tab-based") return 3;
+  const n = parseInt(experienceArg, 10);
+  if (n >= 1 && n <= 3) return n;
+  return null;
+}
+function experienceSlug(id) {
+  switch (id) {
+    case 1:
+      return "conversation-list";
+    case 2:
+      return "one-to-one";
+    case 3:
+      return "tab-based";
+    default:
+      return "unknown";
+  }
+}
+function buildWriteOps(manifest, subs, sdkMajor, embedPath) {
+  const ops = [];
+  const ownedPaths = [];
+  let entryPath = null;
+  const moveMap = /* @__PURE__ */ new Map();
+  if (embedPath !== null) {
+    const embedDir = posixDirname(embedPath);
+    for (const f of manifest.files) {
+      if (f.action !== "create") continue;
+      const defaultPath = substitute(f.path, subs);
+      if (f.is_entry) {
+        moveMap.set(defaultPath, embedPath);
+      } else if (f.move_with_entry) {
+        const basename = defaultPath.split("/").pop() ?? defaultPath;
+        moveMap.set(defaultPath, posixJoin(embedDir, basename));
+      }
+    }
+  }
+  for (const f of manifest.files) {
+    if (embedPath !== null && f.embed_skip) continue;
+    if (f.action === "create") {
+      const raw = readTemplateFile(sdkMajor, manifest.framework, manifest.experience_id, f.template_ref);
+      let content = substitute(raw, subs);
+      const defaultPath = substitute(f.path, subs);
+      const path = moveMap.get(defaultPath) ?? defaultPath;
+      if (embedPath !== null && moveMap.size > 0) {
+        content = rewriteImportsThroughMoveMap(content, defaultPath, path, moveMap);
+      }
+      if (f.is_entry) entryPath = path;
+      const owned = f.owned ?? true;
+      ops.push({ type: "create", path, content, owned });
+      if (owned) ownedPaths.push(path);
+    } else if (f.action === "patch") {
+      const path = substitute(f.path, subs);
+      const patchContent = f.patch_content ? substitute(f.patch_content, subs) : "";
+      ops.push({
+        type: "patch",
+        path,
+        patch_mode: f.patch_mode ?? "prepend",
+        patch_content: patchContent,
+        anchor: f.anchor,
+        skip_if_exists: f.skip_if_exists,
+        patch_id: `${manifest.experience_id}/${f.path}`
+      });
+    }
+  }
+  return { ops, ownedPaths, entryPath };
+}
+function parsePlacement(raw) {
+  if (raw.startsWith("embed:")) {
+    const path = raw.slice("embed:".length).trim();
+    return { placement: "embed", embedPath: path.length > 0 ? path : null };
+  }
+  return { placement: raw, embedPath: null };
+}
+function rewriteImportsThroughMoveMap(content, oldFilePath, newFilePath, moveMap) {
+  const oldDir = posixDirname(oldFilePath);
+  const newDir = posixDirname(newFilePath);
+  const importRe = /(\bfrom\s+["']|\bimport\s+["']|\bimport\(\s*["'])(\.{1,2}\/[^"']+)(["'])/g;
+  const tryExts = ["", ".tsx", ".ts", ".jsx", ".js"];
+  return content.replace(importRe, (_match, prefix, importPath, suffix) => {
+    const resolvedFromOld = posixJoin(oldDir, importPath);
+    let movedTarget = null;
+    let usedExt = "";
+    for (const ext of tryExts) {
+      const moved = moveMap.get(resolvedFromOld + ext);
+      if (moved !== void 0) {
+        movedTarget = moved;
+        usedExt = ext;
+        break;
+      }
+    }
+    const targetAbs = movedTarget !== null ? usedExt ? movedTarget.slice(0, movedTarget.length - usedExt.length) : movedTarget : resolvedFromOld;
+    let newRel = posixRelative(newDir, targetAbs);
+    if (newRel.length === 0) newRel = ".";
+    if (!newRel.startsWith(".")) newRel = "./" + newRel;
+    return prefix + newRel + suffix;
+  });
+}
+function embedNextSteps(framework, embedPath) {
+  switch (framework) {
+    case "reactjs":
+      return [
+        `Embed mode: the chat component was written to ${embedPath} (your existing main.tsx was NOT touched).`,
+        `Wire it up by importing it from wherever you mount your app:`,
+        `  import App from "./${embedPath.replace(/^src\//, "").replace(/\.tsx?$/, "")}";`,
+        `  // Then render <App /> from your existing root.`
+      ];
+    case "nextjs":
+      return [
+        `Embed mode: the chat page was written to ${embedPath}.`,
+        `Next.js auto-routes by file location \u2014 visit the URL that matches the path under src/app/.`,
+        `Example: ${embedPath} \u2192 ${embedPath.replace(/^src\/app/, "").replace(/\/page\.tsx?$/, "") || "/"}`
+      ];
+    case "react-router":
+      return [
+        `Embed mode: the route file was written to ${embedPath} (app/routes.ts was NOT patched).`,
+        `Add the route manually to app/routes.ts:`,
+        `  import { type RouteConfig, index, route } from "@react-router/dev/routes";`,
+        `  export default [`,
+        `    index("routes/home.tsx"),`,
+        `    route("chat", "${embedPath.replace(/^app\//, "")}"),`,
+        `  ] satisfies RouteConfig;`
+      ];
+    case "astro":
+      return [
+        `Embed mode: the page file was written to ${embedPath}.`,
+        `Astro auto-routes pages under src/pages/ \u2014 visit the URL that matches the path.`,
+        `Example: ${embedPath} \u2192 ${embedPath.replace(/^src\/pages/, "").replace(/\.astro$/, "") || "/"}`
+      ];
+    default:
+      return [`Embed mode: chat entry was written to ${embedPath}.`];
+  }
+}
+async function apply(args) {
+  const root = projectPath3(args);
+  const experienceArg = getStringFlag2(args, "experience");
+  const frameworkArg = getStringFlag2(args, "framework");
+  const placementRaw = getStringFlag2(args, "placement") ?? "spa-root";
+  const { placement, embedPath } = parsePlacement(placementRaw);
+  if (placementRaw.startsWith("embed:") && embedPath === null) {
+    return errorOut(args, "Error: --placement embed: requires a path (e.g. --placement embed:src/pages/chat.tsx)", 1);
+  }
+  const sdkMajor = 6;
+  const experienceId = resolveExperience2(experienceArg);
+  if (experienceId === null) {
+    return errorOut(args, "Error: --experience is required (1, 2, 3, or slug)", 1);
+  }
+  let framework = frameworkArg;
+  let envPrefix = null;
+  let frameworkVersion = null;
+  let credentialsSource = "none";
+  let detectedRouter = null;
+  if (!framework) {
+    const detected = await runDetectors(root);
+    if (detected.framework === null) {
+      return errorOut(
+        args,
+        "Error: --framework not specified and no React framework detected in " + root,
+        1
+      );
+    }
+    framework = detected.framework;
+    envPrefix = detected.env_prefix;
+    frameworkVersion = detected.framework_version;
+    credentialsSource = detected.credentials.source;
+    detectedRouter = detected.router ?? null;
+  } else if (framework === "nextjs") {
+    const detected = await runDetectors(root);
+    detectedRouter = detected.router ?? null;
+    if (!frameworkVersion) frameworkVersion = detected.framework_version;
+    if (credentialsSource === "none") credentialsSource = detected.credentials.source;
+  }
+  if (!envPrefix) {
+    envPrefix = framework === "nextjs" ? "NEXT_PUBLIC_" : framework === "astro" ? "PUBLIC_" : "VITE_";
+  }
+  let manifestKey = framework;
+  if (framework === "nextjs" && detectedRouter === "pages") {
+    manifestKey = "nextjs-pages";
+    if (experienceId !== 1) {
+      return errorOut(
+        args,
+        `Error: Next.js Pages Router currently supports experience 1 (Conversation List) only. Experience ${experienceId} for Pages Router lands in v2.0.1. Options: (1) use experience 1, (2) migrate your project to App Router (recommended for new Next.js projects), or (3) wait for v2.0.1.`,
+        1
+      );
+    }
+  }
+  if (hasState(root)) {
+    const existing = readState(root);
+    if (existing) {
+      if (isSameIntegration(existing, {
+        experience: experienceId,
+        framework,
+        placement
+      })) {
+        const result2 = {
+          status: "already-applied",
+          framework,
+          experience_id: experienceId,
+          experience_slug: experienceSlug(experienceId),
+          files_created: [],
+          files_modified: [],
+          files_skipped: [],
+          deps_to_install: [],
+          env_vars_to_add: [],
+          state_file: ".cometchat/state.json",
+          next_steps: [
+            "Integration is already in place \u2014 no changes made.",
+            "Run `cometchat info` to see current integration state."
+          ]
+        };
+        return outputResult(args, result2, 0);
+      }
+      if (!isForceMode(args)) {
+        const result2 = {
+          status: "conflict",
+          framework,
+          experience_id: experienceId,
+          experience_slug: experienceSlug(experienceId),
+          files_created: [],
+          files_modified: [],
+          files_skipped: [],
+          deps_to_install: [],
+          env_vars_to_add: [],
+          state_file: ".cometchat/state.json",
+          next_steps: [
+            `An existing integration is in place: experience ${existing.experience} (${existing.experience_slug}) on ${existing.framework}.`,
+            `You requested experience ${experienceId} (${experienceSlug(experienceId)}) \u2014 these conflict.`,
+            "Run with --force to replace, or run `cometchat uninstall` first."
+          ]
+        };
+        return outputResult(args, result2, 2);
+      }
+    }
+  }
+  let manifest;
+  try {
+    manifest = loadManifest(sdkMajor, manifestKey, experienceId);
+  } catch (err) {
+    return errorOut(
+      args,
+      "Error: " + (err instanceof Error ? err.message : String(err)),
+      1
+    );
+  }
+  const subs = defaultSubs(envPrefix);
+  const { ops, ownedPaths, entryPath } = buildWriteOps(manifest, subs, sdkMajor, embedPath);
+  if (embedPath !== null && entryPath === null) {
+    return errorOut(
+      args,
+      `Error: --placement embed:<path> is not supported for ${framework} experience ${experienceId} (no entry file declared in the manifest).`,
+      1
+    );
+  }
+  if (!isForceOverwriteMode(args)) {
+    const createPaths = ops.filter((o) => o.type === "create").map((o) => o.path);
+    const safetyReports = checkOverwriteSafetyBatch(root, framework, createPaths);
+    const unsafe = safetyReports.filter((r) => r.exists && !r.is_boilerplate);
+    if (unsafe.length > 0) {
+      const result2 = {
+        status: "error",
+        framework,
+        experience_id: experienceId,
+        experience_slug: experienceSlug(experienceId),
+        files_created: [],
+        files_modified: [],
+        files_skipped: unsafe.map((u) => ({
+          path: u.path,
+          reason: `would overwrite user content (${u.current_size} bytes) \u2014 ${u.reason}`
+        })),
+        deps_to_install: [],
+        env_vars_to_add: [],
+        state_file: ".cometchat/state.json",
+        next_steps: [
+          `Refusing to overwrite ${unsafe.length} file(s) that contain user code.`,
+          "Options:",
+          "  1. Run with --force-overwrite to replace these files (DESTRUCTIVE).",
+          "  2. Edit the files manually to remove the existing content first.",
+          "  3. Use --placement embed:<custom-path> to write the entry file to a different location (e.g. --placement embed:src/pages/chat.tsx)."
+        ],
+        error: `Refusing to overwrite ${unsafe.length} file(s) with user content. Use --force-overwrite to override.`
+      };
+      return outputResult(args, result2, 2);
+    }
+  }
+  let writeResult;
+  try {
+    writeResult = applyWrites(root, ops);
+  } catch (err) {
+    return errorOut(
+      args,
+      "Apply failed (rolled back): " + (err instanceof Error ? err.message : String(err)),
+      1
+    );
+  }
+  const filesPatched = manifest.files.filter((f) => f.action === "patch").map((f) => ({
+    path: substitute(f.path, subs),
+    patch_id: `${manifest.experience_id}/${f.path}`
+  }));
+  const state = buildState({
+    framework,
+    framework_version: frameworkVersion,
+    experience: experienceId,
+    experience_slug: experienceSlug(experienceId),
+    placement,
+    placement_path: embedPath ?? void 0,
+    template_version: manifest.version,
+    sdk_version: null,
+    // detected lazily — not yet integrated
+    credentials_source: credentialsSource,
+    env_var_prefix: envPrefix,
+    files_owned: ownedPaths,
+    files_patched: filesPatched,
+    checksums: writeResult.checksums,
+    // For nextjs: capture App Router vs Pages Router so consumers
+    // (production-auth, add-user-mgmt, add-widget) can pick the right
+    // file paths. Other frameworks omit this.
+    router: framework === "nextjs" ? detectedRouter === "pages" ? "pages" : "app" : void 0
+  });
+  writeState(root, state);
+  const result = {
+    status: "applied",
+    framework,
+    experience_id: experienceId,
+    experience_slug: experienceSlug(experienceId),
+    files_created: writeResult.files_created,
+    files_modified: writeResult.files_modified,
+    files_skipped: writeResult.files_skipped,
+    deps_to_install: manifest.deps.map((d) => ({
+      name: d.name,
+      version: d.version,
+      dev: d.dev ?? false
+    })),
+    env_vars_to_add: manifest.env_vars.map((v) => ({
+      name: substitute(v.name, subs),
+      required: v.required,
+      secret: v.secret ?? false
+    })),
+    state_file: ".cometchat/state.json",
+    next_steps: (manifest.next_steps ?? []).map((s) => substitute(s, subs))
+  };
+  if (embedPath !== null && entryPath !== null) {
+    const embedHints = embedNextSteps(framework, embedPath);
+    result.next_steps = [...embedHints, ...result.next_steps];
+  }
+  if (isAutoInstallMode(args) && manifest.deps.length > 0) {
+    result.install = runAutoInstall(root, manifest.deps);
+  }
+  appendAuditEntry(root, {
+    command: "apply",
+    summary: `Applied experience ${experienceId} (${experienceSlug(experienceId)}) on ${framework}${detectedRouter ? ` (${detectedRouter} router)` : ""}${embedPath ? ` with --placement embed:${embedPath}` : ""}`,
+    inputs: {
+      framework,
+      ...detectedRouter ? { router: detectedRouter } : {},
+      experience: experienceId,
+      placement: embedPath ? `embed:${embedPath}` : placement,
+      env_var_prefix: envPrefix
+    },
+    decisions: {
+      framework: frameworkArg ? `passed explicitly via --framework ${frameworkArg}` : `auto-detected from package.json + project structure`,
+      ...framework === "nextjs" && detectedRouter ? {
+        router: detectedRouter === "pages" ? `Pages Router detected (src/pages/ exists, src/app/ does not) \u2014 using nextjs-pages template variant` : `App Router detected (src/app/ exists) \u2014 using nextjs template variant`
+      } : {},
+      ...embedPath ? {
+        placement: `--placement embed:${embedPath} \u2014 entry file relocated; default wire-up files (e.g. main.tsx, routes.ts patches) skipped via embed_skip; companion files (App.css, etc.) moved alongside; relative imports rewritten via the moveMap so each one resolves to the same on-disk target`
+      } : {},
+      template_version: `loaded from @cometchat/skills-registry v${sdkMajor} \u2014 manifest version ${manifest.version}, sdk_compatibility ${manifest.sdk_compatibility}`
+    },
+    files_created: writeResult.files_created,
+    files_patched: filesPatched.map((f) => f.path),
+    files_skipped: writeResult.files_skipped.map((s) => s.path),
+    next_actions: result.next_steps
+  });
+  return outputResult(args, result, 0);
+}
+function runAutoInstall(root, deps) {
+  const pm = detectPackageManager(root) ?? "npm";
+  const args = pm === "npm" ? ["install"] : ["add"];
+  const depArgs = deps.map((d) => `${d.name}@${d.version}`);
+  const start = Date.now();
+  const proc = spawnSync(pm, [...args, ...depArgs], {
+    cwd: root,
+    stdio: "ignore",
+    encoding: "utf8"
+  });
+  const duration = Date.now() - start;
+  if (proc.error) {
+    return {
+      status: "error",
+      package_manager: pm,
+      duration_ms: duration,
+      error: proc.error.message
+    };
+  }
+  if (proc.status !== 0) {
+    return {
+      status: "error",
+      package_manager: pm,
+      duration_ms: duration,
+      error: `${pm} exited with code ${proc.status}`
+    };
+  }
+  return {
+    status: "installed",
+    package_manager: pm,
+    duration_ms: duration
+  };
+}
+function outputResult(args, result, exitCode) {
+  if (isJsonMode4(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable3(result);
+  return exitCode;
+}
+function errorOut(args, message, exitCode) {
+  if (isJsonMode4(args)) {
+    console.log(JSON.stringify({ status: "error", error: message }, null, 2));
+  } else {
+    console.error(message);
+  }
+  return exitCode;
+}
+function printHumanReadable3(r) {
+  const lines = [];
+  lines.push("");
+  if (r.status === "applied") {
+    lines.push(`  \u2713 Applied: experience ${r.experience_id} (${r.experience_slug}) on ${r.framework}`);
+  } else if (r.status === "already-applied") {
+    lines.push(`  = Already applied: experience ${r.experience_id} (${r.experience_slug}) on ${r.framework}`);
+  } else if (r.status === "conflict") {
+    lines.push(`  \u2717 Conflict: a different integration is already in place`);
+  }
+  lines.push("");
+  if (r.files_created.length > 0) {
+    lines.push("  Files created:");
+    for (const f of r.files_created) lines.push(`    + ${f}`);
+  }
+  if (r.files_modified.length > 0) {
+    lines.push("  Files modified:");
+    for (const f of r.files_modified) lines.push(`    ~ ${f}`);
+  }
+  if (r.files_skipped.length > 0) {
+    lines.push("  Files skipped:");
+    for (const f of r.files_skipped) lines.push(`    - ${f.path}  (${f.reason})`);
+  }
+  if (r.deps_to_install.length > 0) {
+    if (r.install?.status === "installed") {
+      lines.push("");
+      lines.push(
+        `  \u2713 Auto-installed ${r.deps_to_install.length} package(s) via ${r.install.package_manager} (${r.install.duration_ms}ms)`
+      );
+    } else if (r.install?.status === "error") {
+      lines.push("");
+      lines.push(
+        `  \u26A0 Auto-install FAILED via ${r.install.package_manager}: ${r.install.error ?? "unknown error"}`
+      );
+      lines.push("    You can retry with: cometchat install");
+    } else {
+      lines.push("");
+      lines.push("  Run this to install dependencies:");
+      const depList = r.deps_to_install.map((d) => `${d.name}@${d.version}`).join(" ");
+      lines.push(`    npm install ${depList}`);
+      lines.push("    (or pass --auto-install next time to do this automatically)");
+    }
+  }
+  if (r.env_vars_to_add.length > 0) {
+    lines.push("");
+    lines.push("  Add these to your .env file:");
+    for (const e of r.env_vars_to_add) {
+      const tag = e.secret ? "  # secret \u2014 do not commit" : "";
+      lines.push(`    ${e.name}=YOUR_VALUE_HERE${tag}`);
+    }
+  }
+  lines.push("");
+  lines.push(`  State file: ${r.state_file}`);
+  if (r.next_steps.length > 0) {
+    lines.push("");
+    lines.push("  Next steps:");
+    for (const s of r.next_steps) lines.push(`    - ${s}`);
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/info.ts
+import { resolve as resolve5 } from "node:path";
+function isJsonMode5(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath4(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve5(fromFlag);
+  return resolve5(process.cwd());
+}
+async function info(args) {
+  const root = projectPath4(args);
+  if (!hasState(root)) {
+    const result2 = { integrated: false };
+    return outputResult2(args, result2, 0);
+  }
+  const state = readState(root);
+  if (!state) {
+    if (isJsonMode5(args)) {
+      console.log(
+        JSON.stringify(
+          {
+            integrated: false,
+            error: "state file exists but could not be parsed (schema mismatch?)"
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error("Error: .cometchat/state.json exists but could not be parsed.");
+    }
+    return 1;
+  }
+  const drift = detectDrift(root, state);
+  const auditLogExists = pathExists(p(root, AUDIT_LOG_PATH));
+  const result = {
+    integrated: true,
+    experience: state.experience,
+    experience_slug: state.experience_slug,
+    framework: state.framework,
+    framework_version: state.framework_version,
+    applied_at: state.applied_at,
+    template_version: state.template_version,
+    placement: state.placement,
+    ...state.router ? { router: state.router } : {},
+    ...state.applied_features && state.applied_features.length > 0 ? { applied_features: state.applied_features } : {},
+    drift: {
+      modified_files: drift.modified_files,
+      missing_files: drift.missing_files,
+      unchanged_files: drift.unchanged_files,
+      has_drift: drift.modified_files.length > 0 || drift.missing_files.length > 0
+    },
+    files_owned: state.files_owned,
+    files_patched: state.files_patched,
+    audit_log: auditLogExists ? AUDIT_LOG_PATH : null
+  };
+  return outputResult2(args, result, 0);
+}
+function outputResult2(args, result, exitCode) {
+  if (isJsonMode5(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable4(result);
+  return exitCode;
+}
+function printHumanReadable4(r) {
+  const lines = [];
+  lines.push("");
+  if (!r.integrated) {
+    lines.push("  CometChat: not integrated in this project.");
+    lines.push("  Run `cometchat apply --experience N` to integrate.");
+    lines.push("");
+    console.log(lines.join("\n"));
+    return;
+  }
+  lines.push(`  \u2713 Integrated: experience ${r.experience} (${r.experience_slug}) on ${r.framework}${r.router ? ` (${r.router} router)` : ""}`);
+  if (r.framework_version) lines.push(`    Framework version: ${r.framework_version}`);
+  if (r.template_version) lines.push(`    Template version: ${r.template_version}`);
+  if (r.placement) lines.push(`    Placement: ${r.placement}`);
+  if (r.applied_at) lines.push(`    Applied at: ${r.applied_at}`);
+  if (r.applied_features && r.applied_features.length > 0) {
+    lines.push(`    Applied features: ${r.applied_features.join(", ")}`);
+  }
+  lines.push("");
+  if (r.drift) {
+    if (r.drift.has_drift) {
+      lines.push(`  \u26A0 Drift detected:`);
+      if (r.drift.modified_files.length > 0) {
+        lines.push(`    Modified by user (${r.drift.modified_files.length}):`);
+        for (const f of r.drift.modified_files) lines.push(`      ~ ${f}`);
+      }
+      if (r.drift.missing_files.length > 0) {
+        lines.push(`    Missing (${r.drift.missing_files.length}):`);
+        for (const f of r.drift.missing_files) lines.push(`      - ${f}`);
+      }
+      lines.push("");
+      lines.push("  Run `cometchat apply --force` to restore the original templates,");
+      lines.push("  or `cometchat uninstall --force` to remove the integration.");
+    } else {
+      lines.push(`  \u2713 No drift \u2014 all ${r.drift.unchanged_files.length} owned files unchanged since apply.`);
+    }
+  }
+  if (r.audit_log) {
+    lines.push("");
+    lines.push(`  Audit log: ${r.audit_log} (human-readable history of every CometChat command run)`);
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/verify.ts
+import { resolve as resolve6 } from "node:path";
+function isJsonMode6(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath5(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve6(fromFlag);
+  return resolve6(process.cwd());
+}
+function checkCssVariablesImport(root) {
+  const candidates = ["src/index.css", "src/main.css", "src/styles.css", "src/app/globals.css"];
+  let count = 0;
+  for (const c of candidates) {
+    const content = readFileOrNull(p(root, c));
+    if (content && content.includes("@cometchat/chat-uikit-react/css-variables.css")) {
+      count++;
+    }
+  }
+  if (count === 0) {
+    return {
+      status: "fail",
+      reason: "css-variables.css is not imported in any known stylesheet"
+    };
+  }
+  if (count > 1) {
+    return {
+      status: "fail",
+      reason: `css-variables.css is imported ${count} times \u2014 should be exactly once`
+    };
+  }
+  return { status: "pass" };
+}
+function checkNoAuthKeyInSource(root, ownedFiles) {
+  const HEX_KEY = /[a-f0-9]{32,}/;
+  for (const file of ownedFiles) {
+    const content = readFileOrNull(p(root, file));
+    if (!content) continue;
+    if (HEX_KEY.test(content)) {
+      const matches = content.match(HEX_KEY);
+      if (matches && matches[0].length >= 40) {
+        return {
+          status: "fail",
+          reason: `Possible hardcoded Auth Key in ${file}`,
+          details: `Found a long hex string (${matches[0].length} chars) \u2014 verify it's not a credential`
+        };
+      }
+    }
+  }
+  return { status: "pass" };
+}
+function checkRenderGatedOnLogin(root) {
+  const candidates = ["src/main.tsx", "src/main.jsx", "src/index.tsx", "src/index.jsx"];
+  for (const c of candidates) {
+    const content = readFileOrNull(p(root, c));
+    if (!content) continue;
+    const hasMount = /function\s+mount\s*\(\s*\)/.test(content);
+    const hasInit = /CometChatUIKit\.init/.test(content);
+    if (!hasInit) {
+      return { status: "skip", reason: `${c} does not contain CometChatUIKit.init` };
+    }
+    if (!hasMount) {
+      return {
+        status: "fail",
+        reason: `${c} should wrap createRoot(...).render in a mount() function called only after login resolves`
+      };
+    }
+    return { status: "pass" };
+  }
+  return { status: "skip", reason: "no entry file found" };
+}
+function checkInitBeforeLogin(root) {
+  const candidates = ["src/main.tsx", "src/main.jsx", "src/index.tsx", "src/index.jsx", "src/cometchat/CometChatNoSSR.tsx"];
+  for (const c of candidates) {
+    const content = readFileOrNull(p(root, c));
+    if (!content) continue;
+    if (!content.includes("CometChatUIKit.init")) continue;
+    const initIdx = content.indexOf("CometChatUIKit.init");
+    const loginIdx = content.indexOf("CometChatUIKit.login");
+    if (loginIdx === -1) {
+      return { status: "skip", reason: `no login call found in ${c}` };
+    }
+    if (initIdx > loginIdx) {
+      return {
+        status: "fail",
+        reason: `${c}: CometChatUIKit.login appears before CometChatUIKit.init`
+      };
+    }
+    return { status: "pass" };
+  }
+  return { status: "skip", reason: "no entry file found" };
+}
+function checkErrorUiVisible(root, ownedFiles) {
+  for (const file of ownedFiles) {
+    const content = readFileOrNull(p(root, file));
+    if (!content) continue;
+    if (/color:\s*['"]?red/.test(content)) {
+      return { status: "pass" };
+    }
+  }
+  return {
+    status: "fail",
+    reason: "No error UI (color: red) found in any owned file"
+  };
+}
+async function verify(args) {
+  const root = projectPath5(args);
+  if (!hasState(root)) {
+    if (isJsonMode6(args)) {
+      console.log(
+        JSON.stringify({ status: "fail", error: "no integration found" }, null, 2)
+      );
+    } else {
+      console.error("Error: no integration found. Run `cometchat apply` first.");
+    }
+    return 1;
+  }
+  const state = readState(root);
+  if (!state) {
+    return 1;
+  }
+  const checks = {
+    css_variables_imported_once: checkCssVariablesImport(root),
+    init_before_login: checkInitBeforeLogin(root),
+    render_gated_on_login_resolve: checkRenderGatedOnLogin(root),
+    no_auth_key_in_source: checkNoAuthKeyInSource(root, state.files_owned),
+    error_ui_visible_on_failure: checkErrorUiVisible(root, state.files_owned)
+  };
+  const anyFailed = Object.values(checks).some((c) => c.status === "fail");
+  const result = {
+    status: anyFailed ? "fail" : "pass",
+    checks
+  };
+  if (isJsonMode6(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return anyFailed ? 1 : 0;
+  }
+  printHumanReadable5(result);
+  return anyFailed ? 1 : 0;
+}
+function printHumanReadable5(r) {
+  const lines = [];
+  lines.push("");
+  lines.push(`  Verification: ${r.status === "pass" ? "\u2713 PASS" : "\u2717 FAIL"}`);
+  lines.push("");
+  for (const [name, check] of Object.entries(r.checks)) {
+    const icon = check.status === "pass" ? "\u2713" : check.status === "fail" ? "\u2717" : "\u2014";
+    lines.push(`  ${icon} ${name}${check.reason ? `  (${check.reason})` : ""}`);
+    if (check.details) lines.push(`      ${check.details}`);
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/uninstall.ts
+import { rmSync as rmSync2, statSync as statSync3, rmdirSync, readdirSync as readdirSync3 } from "node:fs";
+import { dirname as dirname5, join as join7, resolve as resolve7 } from "node:path";
+function isJsonMode7(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function isForceMode2(args) {
+  return args.flags.force === true || args.flags.force === "true";
+}
+function projectPath6(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve7(fromFlag);
+  return resolve7(process.cwd());
+}
+function maybeRemoveEmptyDir(dir) {
+  try {
+    const entries = readdirSync3(dir);
+    if (entries.length === 0) {
+      rmdirSync(dir);
+      maybeRemoveEmptyDir(dirname5(dir));
+    }
+  } catch {
+  }
+}
+async function uninstall(args) {
+  const root = projectPath6(args);
+  if (!hasState(root)) {
+    const result2 = {
+      status: "no-integration",
+      files_removed: [],
+      files_skipped: [],
+      files_patched_left_alone: [],
+      message: "No integration found in this project \u2014 nothing to uninstall."
+    };
+    return outputResult3(args, result2, 0);
+  }
+  const state = readState(root);
+  if (!state) {
+    if (isJsonMode7(args)) {
+      console.log(JSON.stringify({ status: "error", error: "could not parse state file" }));
+    } else {
+      console.error("Error: could not parse .cometchat/state.json");
+    }
+    return 1;
+  }
+  const drift = detectDrift(root, state);
+  if (drift.modified_files.length > 0 && !isForceMode2(args)) {
+    const result2 = {
+      status: "drift-detected",
+      files_removed: [],
+      files_skipped: drift.modified_files.map((path) => ({
+        path,
+        reason: "user-modified since apply (drift detected)"
+      })),
+      files_patched_left_alone: state.files_patched,
+      message: `Refusing to uninstall: ${drift.modified_files.length} file(s) have been modified since apply. Run with --force to delete them anyway.`
+    };
+    return outputResult3(args, result2, 2);
+  }
+  const removed = [];
+  const skipped = [];
+  const dirsToCheck = /* @__PURE__ */ new Set();
+  for (const file of state.files_owned) {
+    const fullPath = join7(root, file);
+    if (!pathExists(fullPath)) {
+      skipped.push({ path: file, reason: "file not found" });
+      continue;
+    }
+    try {
+      rmSync2(fullPath);
+      removed.push(file);
+      dirsToCheck.add(dirname5(fullPath));
+    } catch (err) {
+      skipped.push({
+        path: file,
+        reason: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  for (const dir of dirsToCheck) {
+    maybeRemoveEmptyDir(dir);
+  }
+  try {
+    rmSync2(p(root, STATE_FILE_PATH));
+  } catch {
+  }
+  try {
+    const cometchatDir = p(root, ".cometchat");
+    if (statSync3(cometchatDir).isDirectory()) {
+      const entries = readdirSync3(cometchatDir);
+      if (entries.length === 0) rmdirSync(cometchatDir);
+    }
+  } catch {
+  }
+  const result = {
+    status: "uninstalled",
+    files_removed: removed,
+    files_skipped: skipped,
+    files_patched_left_alone: state.files_patched,
+    message: `Removed ${removed.length} file(s). Patches in ${state.files_patched.length} file(s) were left alone \u2014 clean up manually if needed.`
+  };
+  return outputResult3(args, result, 0);
+}
+function outputResult3(args, result, exitCode) {
+  if (isJsonMode7(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable6(result);
+  return exitCode;
+}
+function printHumanReadable6(r) {
+  const lines = [];
+  lines.push("");
+  if (r.status === "no-integration") {
+    lines.push("  " + r.message);
+    lines.push("");
+    console.log(lines.join("\n"));
+    return;
+  }
+  if (r.status === "drift-detected") {
+    lines.push(`  \u26A0 ${r.message}`);
+    lines.push("");
+    if (r.files_skipped.length > 0) {
+      lines.push("  Modified files:");
+      for (const f of r.files_skipped) lines.push(`    ~ ${f.path}`);
+    }
+    lines.push("");
+    console.log(lines.join("\n"));
+    return;
+  }
+  lines.push(`  \u2713 ${r.message}`);
+  lines.push("");
+  if (r.files_removed.length > 0) {
+    lines.push(`  Removed files (${r.files_removed.length}):`);
+    for (const f of r.files_removed) lines.push(`    - ${f}`);
+  }
+  if (r.files_skipped.length > 0) {
+    lines.push("");
+    lines.push(`  Skipped (${r.files_skipped.length}):`);
+    for (const f of r.files_skipped) lines.push(`    ! ${f.path}  (${f.reason})`);
+  }
+  if (r.files_patched_left_alone.length > 0) {
+    lines.push("");
+    lines.push(`  Patches left alone (${r.files_patched_left_alone.length}) \u2014 clean up manually if needed:`);
+    for (const f of r.files_patched_left_alone) lines.push(`    ? ${f.path}  (${f.patch_id})`);
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/install.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { resolve as resolve8 } from "node:path";
+function isJsonMode8(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath7(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve8(fromFlag);
+  return resolve8(process.cwd());
+}
+function isDryRun(args) {
+  return args.flags["dry-run"] === true;
+}
+function buildInstallCommand(pm, deps) {
+  const runtime = deps.filter((d) => !d.dev).map((d) => `${d.name}@${d.version}`);
+  const dev = deps.filter((d) => d.dev).map((d) => `${d.name}@${d.version}`);
+  switch (pm) {
+    case "pnpm":
+      return { cmd: "pnpm", args: ["add", ...runtime, ...dev] };
+    case "yarn":
+      return { cmd: "yarn", args: ["add", ...runtime, ...dev] };
+    case "bun":
+      return { cmd: "bun", args: ["add", ...runtime, ...dev] };
+    case "npm":
+    default:
+      return { cmd: "npm", args: ["install", ...runtime, ...dev] };
+  }
+}
+async function install(args) {
+  const root = projectPath7(args);
+  const sdkMajor = 6;
+  if (!hasState(root)) {
+    const result2 = {
+      status: "no-integration",
+      package_manager: "",
+      command: "",
+      deps_installed: [],
+      duration_ms: 0,
+      exit_code: 1,
+      error: "No integration found. Run `cometchat apply` first."
+    };
+    return outputResult4(args, result2, 1);
+  }
+  const state = readState(root);
+  if (!state) {
+    if (isJsonMode8(args)) {
+      console.log(JSON.stringify({ status: "error", error: "could not parse state file" }));
+    } else {
+      console.error("Error: could not parse .cometchat/state.json");
+    }
+    return 1;
+  }
+  let manifest;
+  try {
+    manifest = loadManifest(sdkMajor, state.framework, state.experience);
+  } catch (err) {
+    return errorOut2(
+      args,
+      "Error loading template manifest: " + (err instanceof Error ? err.message : String(err))
+    );
+  }
+  if (!manifest.deps || manifest.deps.length === 0) {
+    const result2 = {
+      status: "no-deps",
+      package_manager: "",
+      command: "",
+      deps_installed: [],
+      duration_ms: 0,
+      exit_code: 0
+    };
+    return outputResult4(args, result2, 0);
+  }
+  const pm = detectPackageManager(root) ?? "npm";
+  const { cmd, args: cmdArgs } = buildInstallCommand(pm, manifest.deps);
+  const fullCommand = `${cmd} ${cmdArgs.join(" ")}`;
+  if (isDryRun(args)) {
+    const result2 = {
+      status: "installed",
+      package_manager: pm,
+      command: fullCommand,
+      deps_installed: manifest.deps.map((d) => `${d.name}@${d.version}`),
+      duration_ms: 0,
+      exit_code: 0,
+      stdout: "(dry run \u2014 no command executed)"
+    };
+    return outputResult4(args, result2, 0);
+  }
+  const start = Date.now();
+  const proc = spawnSync2(cmd, cmdArgs, {
+    cwd: root,
+    stdio: isJsonMode8(args) ? ["ignore", "pipe", "pipe"] : "inherit",
+    encoding: "utf8"
+  });
+  const duration = Date.now() - start;
+  if (proc.error) {
+    return errorOut2(
+      args,
+      `Failed to run ${cmd}: ${proc.error.message}. Is ${pm} installed?`
+    );
+  }
+  const result = {
+    status: proc.status === 0 ? "installed" : "error",
+    package_manager: pm,
+    command: fullCommand,
+    deps_installed: proc.status === 0 ? manifest.deps.map((d) => `${d.name}@${d.version}`) : [],
+    duration_ms: duration,
+    exit_code: proc.status ?? -1,
+    stdout: typeof proc.stdout === "string" ? proc.stdout : void 0,
+    stderr: typeof proc.stderr === "string" ? proc.stderr : void 0,
+    error: proc.status !== 0 ? `${pm} exited with code ${proc.status}` : void 0
+  };
+  return outputResult4(args, result, proc.status === 0 ? 0 : 1);
+}
+function outputResult4(args, result, exitCode) {
+  if (isJsonMode8(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable7(result);
+  return exitCode;
+}
+function errorOut2(args, message) {
+  if (isJsonMode8(args)) {
+    console.log(JSON.stringify({ status: "error", error: message }, null, 2));
+  } else {
+    console.error(message);
+  }
+  return 1;
+}
+function printHumanReadable7(r) {
+  const lines = [];
+  lines.push("");
+  switch (r.status) {
+    case "no-integration":
+      lines.push(`  \u2717 No integration found. Run \`cometchat apply\` first.`);
+      break;
+    case "no-deps":
+      lines.push(`  = No dependencies to install for this integration.`);
+      break;
+    case "installed":
+      lines.push(`  \u2713 Installed ${r.deps_installed.length} package(s) via ${r.package_manager}`);
+      lines.push(`    Command: ${r.command}`);
+      lines.push(`    Duration: ${r.duration_ms}ms`);
+      if (r.deps_installed.length > 0) {
+        lines.push(``);
+        for (const d of r.deps_installed) lines.push(`    + ${d}`);
+      }
+      break;
+    case "error":
+      lines.push(`  \u2717 Install failed (${r.error ?? "unknown error"})`);
+      lines.push(`    Command: ${r.command}`);
+      if (r.stderr) {
+        lines.push(``);
+        lines.push(`    stderr:`);
+        for (const line of r.stderr.split("\n").slice(0, 10)) {
+          lines.push(`      ${line}`);
+        }
+      }
+      break;
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/production-auth.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join8, resolve as resolve9 } from "node:path";
+function isJsonMode9(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath8(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve9(fromFlag);
+  return resolve9(process.cwd());
+}
+var SUPPORTED_FRAMEWORKS = /* @__PURE__ */ new Set(["nextjs", "react-router", "astro"]);
+function productionRoot() {
+  return join8(findRegistryRoot(), "v6", "production");
+}
+function loadProductionManifest(framework) {
+  const root = productionRoot();
+  const manifestPath = join8(root, `${framework}.template.json`);
+  const content = readFileSync7(manifestPath, "utf8");
+  return JSON.parse(content);
+}
+function readProductionTemplate(framework, ref) {
+  const root = productionRoot();
+  return readFileSync7(join8(root, framework, ref), "utf8");
+}
+function findClientLoginFile(state) {
+  const candidates = [
+    "src/app/cometchat/CometChatNoSSR.tsx",
+    // nextjs
+    "app/cometchat/CometChatNoSSR.tsx",
+    // react-router
+    "src/cometchat/ChatApp.tsx"
+    // astro
+  ];
+  for (const c of candidates) {
+    if (state.files_owned.includes(c)) return c;
+  }
+  return null;
+}
+var CANONICAL_LOGIN_RE = /(\s*)CometChatUIKit\.login\(\s*UID\s*\)\s*\n\s*\.then\(\s*setUser\s*\)\s*\n\s*\.catch\(\(\s*e\s*:\s*unknown\s*\)\s*=>\s*setError\(String\(e\)\)\s*\);?/;
+function rewriteLoginChain(content) {
+  if (!CANONICAL_LOGIN_RE.test(content)) return null;
+  return content.replace(
+    CANONICAL_LOGIN_RE,
+    (_match, indent) => `${indent}fetch("/api/cometchat-token?uid=" + encodeURIComponent(UID))
+${indent}  .then((r) => r.json())
+${indent}  .then((data) => CometChatUIKit.loginWithAuthToken(data.authToken))
+${indent}  .then(setUser)
+${indent}  .catch((e: unknown) => setError(String(e)));`
+  );
+}
+function clientPatch(root, state) {
+  const relPath = findClientLoginFile(state);
+  if (relPath === null) return { status: "n/a" };
+  const fullPath = join8(root, relPath);
+  let content;
+  try {
+    content = readFileSync7(fullPath, "utf8");
+  } catch {
+    return { status: "skipped", file: relPath };
+  }
+  const next = rewriteLoginChain(content);
+  if (next === null) return { status: "skipped", file: relPath };
+  writeFileSync4(fullPath, next, "utf8");
+  return { status: "applied", file: relPath, newChecksum: sha256(next) };
+}
+async function productionAuth(args) {
+  const root = projectPath8(args);
+  if (!hasState(root)) {
+    const result2 = {
+      status: "no-integration",
+      framework: "",
+      files_created: [],
+      next_steps: [],
+      error: "No integration found. Run `cometchat apply` first to create the dev integration, then run this command to upgrade to production-ready auth."
+    };
+    return outputResult5(args, result2, 1);
+  }
+  const state = readState(root);
+  if (!state) {
+    return errorOut3(args, "Could not parse .cometchat/state.json");
+  }
+  if (!SUPPORTED_FRAMEWORKS.has(state.framework)) {
+    const result2 = {
+      status: "unsupported-framework",
+      framework: state.framework,
+      files_created: [],
+      next_steps: [
+        `Production auth flow currently supports nextjs, react-router, and astro. Your integration is on ${state.framework}.`,
+        "Reactjs (Vite/CRA) has no built-in server, so the token endpoint needs to live in a separate backend.",
+        "Options:",
+        "  1. Run a small Express/Hono/Bun server alongside your Vite app and create the endpoint there",
+        "  2. Migrate to a framework with server support (Next.js, React Router framework mode, Astro SSR)",
+        "  3. Use a serverless function (Vercel Edge, Cloudflare Workers, AWS Lambda)",
+        "Whichever you pick, the endpoint logic is the same: POST to https://{APP_ID}.api-{REGION}.cometchat.io/v3/users/{uid}/auth_tokens with the apikey header (server-only env var) and return the authToken to the client."
+      ]
+    };
+    return outputResult5(args, result2, 2);
+  }
+  if (state.credentials_source === "token-endpoint") {
+    const result2 = {
+      status: "already-applied",
+      framework: state.framework,
+      files_created: [],
+      next_steps: [
+        "This integration is already using a server-side token endpoint.",
+        "Run `cometchat info` to see current integration state."
+      ]
+    };
+    return outputResult5(args, result2, 0);
+  }
+  let manifest;
+  try {
+    manifest = loadProductionManifest(state.framework);
+  } catch (err) {
+    return errorOut3(args, "Could not load production manifest: " + (err instanceof Error ? err.message : String(err)));
+  }
+  const ops = [];
+  const ownedPaths = [];
+  for (const f of manifest.files) {
+    if (f.action === "create") {
+      if (!f.template_ref) continue;
+      const content = readProductionTemplate(state.framework, f.template_ref);
+      const owned = f.owned ?? true;
+      ops.push({ type: "create", path: f.path, content, owned });
+      if (owned) ownedPaths.push(f.path);
+    } else if (f.action === "patch") {
+      ops.push({
+        type: "patch",
+        path: f.path,
+        patch_mode: f.patch_mode ?? "prepend",
+        patch_content: f.patch_content ?? "",
+        anchor: f.anchor,
+        skip_if_exists: f.skip_if_exists,
+        patch_id: `production/${state.framework}/${f.path}`
+      });
+    }
+  }
+  let writeResult;
+  try {
+    writeResult = applyWrites(root, ops);
+  } catch (err) {
+    return errorOut3(args, "Production-auth apply failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+  const patchResult = clientPatch(root, state);
+  const newChecksums = { ...state.checksums, ...writeResult.checksums };
+  if (patchResult.status === "applied" && patchResult.file && patchResult.newChecksum) {
+    newChecksums[patchResult.file] = patchResult.newChecksum;
+  }
+  const updatedState = {
+    ...state,
+    credentials_source: "token-endpoint",
+    files_owned: [...state.files_owned, ...ownedPaths],
+    checksums: newChecksums
+  };
+  writeState(root, updatedState);
+  const next_steps = buildNextSteps(state.framework, manifest.next_steps, patchResult);
+  const result = {
+    status: "applied",
+    framework: state.framework,
+    files_created: writeResult.files_created,
+    files_patched: patchResult.status === "applied" && patchResult.file ? [patchResult.file] : [],
+    client_patch: patchResult.status,
+    next_steps
+  };
+  appendAuditEntry(root, {
+    command: "production-auth",
+    summary: `Upgraded ${state.framework} integration from dev (Auth Key) to production (server-side token endpoint)${patchResult.status === "applied" ? " + auto-patched the client login flow" : patchResult.status === "skipped" ? " (client login auto-patch skipped \u2014 file was customized)" : ""}`,
+    inputs: {
+      framework: state.framework,
+      ...state.router ? { router: state.router } : {}
+    },
+    decisions: {
+      endpoint_path: `picked from production manifest for ${state.framework} \u2014 server-side route that proxies to https://{APP_ID}.api-{REGION}.cometchat.io/v3/users/{uid}/auth_tokens with the apikey header`,
+      auth_key_handling: `the AUTH_KEY env var is now server-only \u2014 clients receive short-lived auth tokens instead of the long-lived key. .env update is up to the user (the CLI never reads/writes secrets).`,
+      client_patch: patchResult.status === "applied" ? `auto-rewrote the canonical CometChatUIKit.login(UID).then(setUser) chain in ${patchResult.file ?? "the client file"} to fetch('/api/cometchat-token?uid=' + UID).then(loginWithAuthToken).then(setUser). The pattern matched, so the rewrite is safe.` : patchResult.status === "skipped" ? `the canonical login pattern wasn't found (the client file was customized) \u2014 the manual fallback steps in next_actions are the safety net` : `no candidate client file in state.files_owned`
+    },
+    files_created: writeResult.files_created,
+    files_modified: result.files_patched && result.files_patched.length > 0 ? result.files_patched : void 0,
+    next_actions: result.next_steps
+  });
+  return outputResult5(args, result, 0);
+}
+function buildNextSteps(_framework, manifestSteps, patchResult) {
+  if (patchResult.status === "applied" && patchResult.file) {
+    const out = [];
+    out.push(`\u2713 Client login flow auto-patched in ${patchResult.file}.`);
+    out.push("  CometChatUIKit.login(UID) \u2192 fetch('/api/cometchat-token?uid=...').then(loginWithAuthToken)");
+    out.push("");
+    let skipping = false;
+    for (const step of manifestSteps) {
+      if (skipping) {
+        if (/^\d+\./.test(step) && !step.includes("login flow:") && !step.includes("CometChatNoSSR") && !step.includes("ChatApp")) {
+          skipping = false;
+          out.push(step);
+          continue;
+        }
+        continue;
+      }
+      if (/^\d+\.\s+In\s+\S+(CometChatNoSSR|ChatApp)\.tsx,?\s+replace the login flow:?$/.test(step) || // Belt-and-suspenders for slightly different phrasings
+      /^\d+\./.test(step) && step.includes("replace the login flow")) {
+        skipping = true;
+        continue;
+      }
+      out.push(step);
+    }
+    out.push("");
+    out.push("\u26A0 The hardcoded UID constant in the patched file still points at 'cometchat-uid-1'.");
+    out.push("  Replace it with your real authenticated user's ID (from NextAuth/Clerk/your session).");
+    return out;
+  }
+  if (patchResult.status === "skipped" && patchResult.file) {
+    return [
+      `\u26A0 Auto-patch SKIPPED for ${patchResult.file}: the canonical login pattern wasn't found, likely because you customized that file.`,
+      "  Falling back to manual instructions:",
+      "",
+      ...manifestSteps
+    ];
+  }
+  return manifestSteps;
+}
+function outputResult5(args, result, exitCode) {
+  if (isJsonMode9(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable8(result);
+  return exitCode;
+}
+function errorOut3(args, message) {
+  if (isJsonMode9(args)) {
+    console.log(JSON.stringify({ status: "error", error: message }, null, 2));
+  } else {
+    console.error(message);
+  }
+  return 1;
+}
+function printHumanReadable8(r) {
+  const lines = [];
+  lines.push("");
+  switch (r.status) {
+    case "no-integration":
+      lines.push(`  \u2717 ${r.error}`);
+      break;
+    case "unsupported-framework":
+      lines.push(`  \u26A0 Framework "${r.framework}" not yet supported for production-auth (Phase 5: nextjs only).`);
+      lines.push("");
+      for (const step of r.next_steps) lines.push(`    ${step}`);
+      break;
+    case "already-applied":
+      lines.push(`  = ${r.next_steps[0] ?? "Already on production auth."}`);
+      break;
+    case "applied":
+      lines.push(`  \u2713 Upgraded to production auth (${r.framework})`);
+      lines.push("");
+      lines.push(`  Files created (${r.files_created.length}):`);
+      for (const f of r.files_created) lines.push(`    + ${f}`);
+      if (r.files_patched && r.files_patched.length > 0) {
+        lines.push("");
+        lines.push(`  Files patched (${r.files_patched.length}):`);
+        for (const f of r.files_patched) lines.push(`    ~ ${f}`);
+      }
+      lines.push("");
+      if (r.client_patch === "applied") {
+        lines.push("  \u2713 Client login flow auto-rewritten \u2014 env-var + restart-server steps still need you:");
+      } else if (r.client_patch === "skipped") {
+        lines.push("  \u26A0 Auto-patch SKIPPED \u2014 your client file was customized. Apply manually:");
+      } else {
+        lines.push("  \u26A0 MANUAL CLIENT-SIDE CHANGES REQUIRED:");
+      }
+      lines.push("");
+      for (const step of r.next_steps) lines.push(`    ${step}`);
+      break;
+    case "error":
+      lines.push(`  \u2717 ${r.error ?? "Unknown error"}`);
+      break;
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/apply-theme.ts
+import { resolve as resolve10 } from "node:path";
+function isJsonMode10(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath9(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve10(fromFlag);
+  return resolve10(process.cwd());
+}
+function getStringFlag3(args, name) {
+  const v = args.flags[name];
+  return typeof v === "string" ? v : null;
+}
+var THEME_PRESETS = {
+  slack: {
+    primaryColor: "#611f69",
+    textColor: "#1d1c1d",
+    backgroundColor: "#ffffff",
+    fontFamily: "Lato, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+    borderRadius: "8px",
+    darkMode: false
+  },
+  whatsapp: {
+    primaryColor: "#25d366",
+    textColor: "#111b21",
+    backgroundColor: "#f0f2f5",
+    fontFamily: "'Segoe UI', Helvetica, Arial, sans-serif",
+    borderRadius: "12px",
+    darkMode: false
+  },
+  imessage: {
+    primaryColor: "#007aff",
+    textColor: "#000000",
+    backgroundColor: "#ffffff",
+    fontFamily: "-apple-system, BlinkMacSystemFont, 'SF Pro Text', sans-serif",
+    borderRadius: "18px",
+    darkMode: false
+  },
+  discord: {
+    primaryColor: "#5865f2",
+    textColor: "#dcddde",
+    backgroundColor: "#36393f",
+    fontFamily: "'gg sans', 'Noto Sans', Helvetica, Arial, sans-serif",
+    borderRadius: "8px",
+    darkMode: true
+  },
+  notion: {
+    primaryColor: "#2eaadc",
+    textColor: "#37352f",
+    backgroundColor: "#ffffff",
+    fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, 'Apple Color Emoji', Arial, sans-serif",
+    borderRadius: "6px",
+    darkMode: false
+  }
+};
+function listPresets() {
+  return Object.keys(THEME_PRESETS);
+}
+function parseThemeInput(args) {
+  const preset = getStringFlag3(args, "preset");
+  if (preset) {
+    const base = THEME_PRESETS[preset.toLowerCase()];
+    if (!base) {
+      return null;
+    }
+    return {
+      primaryColor: getStringFlag3(args, "primary-color") ?? base.primaryColor,
+      textColor: getStringFlag3(args, "text-color") ?? base.textColor,
+      backgroundColor: getStringFlag3(args, "background-color") ?? base.backgroundColor,
+      fontFamily: getStringFlag3(args, "font-family") ?? base.fontFamily,
+      borderRadius: getStringFlag3(args, "border-radius") ?? base.borderRadius,
+      darkMode: args.flags["dark-mode"] === true || args.flags["dark-mode"] === "true" ? true : base.darkMode
+    };
+  }
+  const primary = getStringFlag3(args, "primary-color");
+  if (!primary) return null;
+  return {
+    primaryColor: primary,
+    textColor: getStringFlag3(args, "text-color") ?? void 0,
+    backgroundColor: getStringFlag3(args, "background-color") ?? void 0,
+    fontFamily: getStringFlag3(args, "font-family") ?? void 0,
+    borderRadius: getStringFlag3(args, "border-radius") ?? void 0,
+    darkMode: args.flags["dark-mode"] === true || args.flags["dark-mode"] === "true"
+  };
+}
+function buildOverrideBlock(theme) {
+  const lines = [];
+  const vars = [];
+  lines.push("/* CometChat theme overrides \u2014 generated by `cometchat apply-theme` */");
+  lines.push(":root {");
+  lines.push(`  --cometchat-primary-color: ${theme.primaryColor};`);
+  vars.push("--cometchat-primary-color");
+  if (theme.textColor) {
+    lines.push(`  --cometchat-text-color-primary: ${theme.textColor};`);
+    vars.push("--cometchat-text-color-primary");
+  }
+  if (theme.backgroundColor) {
+    lines.push(`  --cometchat-background-color-01: ${theme.backgroundColor};`);
+    vars.push("--cometchat-background-color-01");
+  }
+  if (theme.fontFamily) {
+    lines.push(`  --cometchat-font-family: ${theme.fontFamily};`);
+    vars.push("--cometchat-font-family");
+  }
+  if (theme.borderRadius) {
+    lines.push(`  --cometchat-radius-3: ${theme.borderRadius};`);
+    vars.push("--cometchat-radius-3");
+  }
+  lines.push("}");
+  if (theme.darkMode) {
+    lines.push("");
+    lines.push("@media (prefers-color-scheme: dark) {");
+    lines.push("  :root {");
+    lines.push(`    --cometchat-background-color-01: #0a0a0a;`);
+    lines.push(`    --cometchat-text-color-primary: #ededed;`);
+    lines.push(`    --cometchat-background-color-02: #1a1a1a;`);
+    lines.push(`    --cometchat-background-color-03: #2a2a2a;`);
+    lines.push("  }");
+    lines.push("}");
+    vars.push(
+      "--cometchat-background-color-01 (dark)",
+      "--cometchat-text-color-primary (dark)",
+      "--cometchat-background-color-02 (dark)",
+      "--cometchat-background-color-03 (dark)"
+    );
+  }
+  return { css: lines.join("\n") + "\n", variables: vars };
+}
+function buildThemeOp(framework, cssBlock, root) {
+  const targets = {
+    reactjs: ["src/index.css", "src/main.css", "src/styles.css"],
+    nextjs: ["src/app/globals.css", "app/globals.css"],
+    "react-router": ["app/app.css", "app/styles/app.css"],
+    astro: ["src/cometchat/ChatApp.tsx"]
+    // Special!
+  };
+  const candidates = targets[framework] ?? [];
+  for (const candidate of candidates) {
+    if (pathExists(p(root, candidate))) {
+      if (framework === "astro") {
+        return {
+          op: {
+            type: "patch",
+            path: candidate,
+            patch_mode: "insert-after",
+            anchor: 'import "@cometchat/chat-uikit-react/css-variables.css";',
+            patch_content: `
+// CometChat theme overrides \u2014 generated by \`cometchat apply-theme\`
+// This must live inside the React island .tsx file (not a global stylesheet)
+// because Astro's client:only islands don't pick up global CSS.
+// Wrap the CSS in a <style> tag mounted via useEffect, OR use inline style on the root div:
+/*
+${cssBlock.split("\n").map((l) => "  " + l).join("\n")}
+*/`,
+            skip_if_exists: "/* CometChat theme overrides",
+            patch_id: "theme/astro"
+          },
+          targetPath: candidate,
+          specialHint: "Astro theming requires extra steps: the override block was inserted as a comment in ChatApp.tsx. Copy it into a CSS file imported by the React island, OR pass it as inline styles on the wrapper element. Future versions of cometchat apply-theme will automate this."
+        };
+      }
+      return {
+        op: {
+          type: "patch",
+          path: candidate,
+          patch_mode: "append",
+          patch_content: "\n" + cssBlock,
+          skip_if_exists: "/* CometChat theme overrides",
+          patch_id: `theme/${framework}`
+        },
+        targetPath: candidate
+      };
+    }
+  }
+  return { op: null, targetPath: null };
+}
+async function applyTheme(args) {
+  const root = projectPath9(args);
+  if (!hasState(root)) {
+    return outputResult6(
+      args,
+      {
+        status: "no-integration",
+        framework: "",
+        file_modified: null,
+        variables_applied: [],
+        next_steps: [],
+        error: "No integration found. Run `cometchat apply` first, then `cometchat apply-theme` to customize the look."
+      },
+      1
+    );
+  }
+  const state = readState(root);
+  if (!state) {
+    return errorOut4(args, "Could not parse .cometchat/state.json");
+  }
+  const theme = parseThemeInput(args);
+  if (!theme) {
+    const requestedPreset = getStringFlag3(args, "preset");
+    if (requestedPreset) {
+      return errorOut4(
+        args,
+        `Error: unknown preset "${requestedPreset}". Available presets: ${listPresets().join(", ")}.`
+      );
+    }
+    return errorOut4(
+      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.`
+    );
+  }
+  const { css, variables } = buildOverrideBlock(theme);
+  const { op, targetPath, specialHint } = buildThemeOp(state.framework, css, root);
+  if (!op || !targetPath) {
+    return outputResult6(
+      args,
+      {
+        status: "no-target-file",
+        framework: state.framework,
+        file_modified: null,
+        variables_applied: [],
+        next_steps: [
+          `Could not find a CSS file to write theme overrides to for framework ${state.framework}.`,
+          "Expected one of:",
+          state.framework === "reactjs" ? "  src/index.css" : state.framework === "nextjs" ? "  src/app/globals.css or app/globals.css" : state.framework === "react-router" ? "  app/app.css" : "  (unknown framework)"
+        ]
+      },
+      1
+    );
+  }
+  let writeResult;
+  try {
+    writeResult = applyWrites(root, [op]);
+  } catch (err) {
+    return errorOut4(args, "Theme apply failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+  const wasSkipped = writeResult.files_skipped.length > 0;
+  const result = {
+    status: "applied",
+    framework: state.framework,
+    file_modified: targetPath,
+    variables_applied: variables,
+    next_steps: [
+      wasSkipped ? `Skipped: ${targetPath} already contains a CometChat theme override block. Remove the existing block to re-apply.` : `Theme overrides written to ${targetPath}.`,
+      ...specialHint ? [specialHint] : [],
+      "Restart your dev server (`npm run dev`) to see the new theme.",
+      "To remove the theme, delete the /* CometChat theme overrides */ block from the file."
+    ]
+  };
+  if (!wasSkipped) {
+    const presetFlag = getStringFlag3(args, "preset");
+    appendAuditEntry(root, {
+      command: "apply-theme",
+      summary: presetFlag ? `Applied "${presetFlag}" theme preset to ${state.framework} integration` : `Applied custom theme overrides to ${state.framework} integration`,
+      inputs: {
+        framework: state.framework,
+        ...presetFlag ? { preset: presetFlag } : {},
+        ...theme.primaryColor ? { "primary-color": theme.primaryColor } : {},
+        ...theme.darkMode ? { "dark-mode": true } : {}
+      },
+      decisions: {
+        css_target: state.framework === "astro" ? `Astro: theme block inserted as a comment in src/cometchat/ChatApp.tsx (the React island), because Astro's client:only="react" islands don't pick up global stylesheets` : `${state.framework}: theme block appended to ${targetPath} (the global stylesheet that the integration's css-variables.css import lives in)`,
+        ...presetFlag ? {
+          preset: `picked the "${presetFlag}" preset bundle (primary + text + background + font + radius + dark-mode in one shot); any individual flags passed alongside override the preset's value`
+        } : {},
+        variables_set: variables.join(", ")
+      },
+      files_patched: [targetPath],
+      next_actions: result.next_steps
+    });
+  }
+  return outputResult6(args, result, 0);
+}
+function outputResult6(args, result, exitCode) {
+  if (isJsonMode10(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable9(result);
+  return exitCode;
+}
+function errorOut4(args, message) {
+  if (isJsonMode10(args)) {
+    console.log(JSON.stringify({ status: "error", error: message }, null, 2));
+  } else {
+    console.error(message);
+  }
+  return 1;
+}
+function printHumanReadable9(r) {
+  const lines = [];
+  lines.push("");
+  switch (r.status) {
+    case "no-integration":
+      lines.push(`  \u2717 ${r.error}`);
+      break;
+    case "no-target-file":
+      lines.push(`  \u2717 ${r.next_steps[0] ?? "No target CSS file found"}`);
+      for (const step of r.next_steps.slice(1)) lines.push(`    ${step}`);
+      break;
+    case "applied":
+      lines.push(`  \u2713 Theme applied to ${r.framework}`);
+      if (r.file_modified) lines.push(`    File: ${r.file_modified}`);
+      lines.push("");
+      lines.push(`  CSS variables overridden (${r.variables_applied.length}):`);
+      for (const v of r.variables_applied) lines.push(`    + ${v}`);
+      lines.push("");
+      lines.push("  Next steps:");
+      for (const step of r.next_steps) lines.push(`    - ${step}`);
+      break;
+    case "error":
+      lines.push(`  \u2717 ${r.error ?? "Unknown error"}`);
+      break;
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/features.ts
+import { readFileSync as readFileSync8 } from "node:fs";
+import { join as join9 } from "node:path";
+function isJsonMode11(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function catalogPath() {
+  return join9(findRegistryRoot(), "v6", "features", "catalog.json");
+}
+var cachedCatalog = null;
+function loadCatalog() {
+  if (cachedCatalog) return cachedCatalog;
+  const path = catalogPath();
+  cachedCatalog = JSON.parse(readFileSync8(path, "utf8"));
+  return cachedCatalog;
+}
+function nextStepsForFeature(feature) {
+  switch (feature.type) {
+    case "default":
+      return [
+        `${feature.name} is already enabled in the CometChat UI Kit components your integration uses.`,
+        ...feature.components && feature.components.length > 0 ? [`It's rendered by: ${feature.components.join(", ")}`] : [],
+        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": {
+      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.`,
+          "",
+          "Steps to enable:",
+          `  1. Go to https://app.cometchat.com and select your app`,
+          `  2. Navigate to: ${feature.dashboard_path ?? "Extensions \u2192 " + feature.name}`,
+          `  3. Toggle the feature on (and configure any required values)`,
+          `  4. Refresh your dev server \u2014 no code changes required`
+        );
+      } 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`,
+          `  2. In your CometChat init (the file that calls UIKitSettingsBuilder), add the extension:`,
+          `       import { CometChatUIKit, UIKitSettingsBuilder } from "@cometchat/chat-uikit-react";`,
+          `       // Pseudocode \u2014 match your existing builder chain:`,
+          `       const settings = new UIKitSettingsBuilder()`,
+          `         .setAppId(APP_ID)`,
+          `         .setRegion(REGION)`,
+          `         .setAuthKey(AUTH_KEY)`,
+          `         .subscribePresenceForAllUsers()`,
+          `         .setExtensions([/* your extension instance here */])`,
+          `         .build();`,
+          `       CometChatUIKit.init(settings);`,
+          `  3. Restart your dev server`
+        );
+      }
+      if (feature.docs_topic) {
+        lines.push(`  Docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`);
+      }
+      return lines;
+    }
+    case "package-install":
+      return [
+        `${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}`] : []
+      ];
+    case "component-swap":
+      return [
+        `${feature.name} is enabled by replacing one component with a variant.`,
+        "",
+        "Steps to enable:",
+        `  1. In your integration files (search for ${feature.swap_from}), replace:`,
+        `       FROM: ${feature.swap_from}`,
+        `       TO:   ${feature.swap_to}`,
+        `  2. The new component is a drop-in replacement with the same props.`,
+        `  3. Restart your dev server.`,
+        ...feature.docs_topic ? [`  4. For details, see https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
+      ];
+    default:
+      return [`Unknown feature type: ${feature.type}`];
+  }
+}
+async function features(args) {
+  const sub = args.positional[0];
+  if (!sub || sub === "list") {
+    return featuresList(args);
+  }
+  const featureName = sub === "info" ? args.positional[1] : sub;
+  if (!featureName) {
+    if (isJsonMode11(args)) {
+      console.log(JSON.stringify({ status: "error", error: "Usage: cometchat features [list | info <feature> | <feature>]" }, null, 2));
+    } else {
+      console.error("Usage: cometchat features [list | info <feature> | <feature>]");
+    }
+    return 1;
+  }
+  return featuresInfo(args, featureName);
+}
+function featuresList(args) {
+  let catalog;
+  try {
+    catalog = loadCatalog();
+  } catch (err) {
+    return errorOut5(args, "Could not load features catalog: " + (err instanceof Error ? err.message : String(err)));
+  }
+  const byType = {};
+  for (const f of catalog.features) {
+    byType[f.type] = (byType[f.type] ?? 0) + 1;
+  }
+  const result = {
+    version: catalog.version,
+    total: catalog.features.length,
+    by_type: byType,
+    features: catalog.features
+  };
+  if (isJsonMode11(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  const lines = [];
+  lines.push("");
+  lines.push(`  CometChat features catalog (v${result.version})`);
+  lines.push(`  ${result.total} total \u2014 ${Object.entries(byType).map(([k, v]) => `${v} ${k}`).join(", ")}`);
+  lines.push("");
+  const groups = {};
+  for (const f of catalog.features) {
+    if (!groups[f.type]) groups[f.type] = [];
+    groups[f.type].push(f);
+  }
+  const order = [
+    "default",
+    "dashboard-toggle",
+    "package-install",
+    "component-swap"
+  ];
+  for (const type of order) {
+    const list = groups[type];
+    if (!list) continue;
+    lines.push(`  ${type.toUpperCase().replace("-", " ")} (${list.length})`);
+    lines.push(`  ${catalog.feature_types[type]}`);
+    lines.push("");
+    for (const f of list) {
+      lines.push(`    ${f.id.padEnd(28)} ${f.name}`);
+    }
+    lines.push("");
+  }
+  lines.push("  Run `cometchat features info <id>` to see how to enable a specific feature.");
+  lines.push("");
+  console.log(lines.join("\n"));
+  return 0;
+}
+function featuresInfo(args, name) {
+  let catalog;
+  try {
+    catalog = loadCatalog();
+  } catch (err) {
+    return errorOut5(args, "Could not load features catalog: " + (err instanceof Error ? err.message : String(err)));
+  }
+  const lc = name.toLowerCase();
+  const exact = catalog.features.find((f) => f.id === lc);
+  const fuzzy = exact ?? catalog.features.find(
+    (f) => f.id.toLowerCase().includes(lc) || f.name.toLowerCase().includes(lc)
+  );
+  if (!fuzzy) {
+    const result2 = {
+      status: "not-found",
+      error: `Feature "${name}" not found.`,
+      available: catalog.features.map((f) => f.id)
+    };
+    if (isJsonMode11(args)) {
+      console.log(JSON.stringify(result2, null, 2));
+    } else {
+      console.error(`\u2717 Feature "${name}" not found.`);
+      console.error(`  Run \`cometchat features list\` to see all available features.`);
+    }
+    return 1;
+  }
+  const result = {
+    status: "found",
+    feature: fuzzy,
+    next_steps: nextStepsForFeature(fuzzy)
+  };
+  if (isJsonMode11(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${fuzzy.name}  (${fuzzy.id})`);
+  lines.push(`  Type: ${fuzzy.type}`);
+  lines.push("");
+  lines.push(`  ${fuzzy.description}`);
+  lines.push("");
+  for (const step of result.next_steps ?? []) {
+    lines.push(`  ${step}`);
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+  return 0;
+}
+function errorOut5(args, message) {
+  if (isJsonMode11(args)) {
+    console.log(JSON.stringify({ status: "error", error: message }, null, 2));
+  } else {
+    console.error(message);
+  }
+  return 1;
+}
+
+// src/commands/doctor.ts
+import { resolve as resolve11 } from "node:path";
+function isJsonMode12(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath10(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve11(fromFlag);
+  return resolve11(process.cwd());
+}
+function runQuickVerify(root, ownedFiles) {
+  if (ownedFiles.length === 0) return { status: "skip", failed: [] };
+  const failed = [];
+  const HEX_KEY = /[a-f0-9]{32,}/;
+  const cssCandidates = ["src/index.css", "src/main.css", "src/styles.css", "src/app/globals.css", "app/app.css"];
+  let cssImportCount = 0;
+  for (const c of cssCandidates) {
+    const content = readFileOrNull(p(root, c));
+    if (content && content.includes("@cometchat/chat-uikit-react/css-variables.css")) {
+      cssImportCount++;
+    }
+  }
+  if (cssImportCount !== 1) failed.push("css_variables_imported_once");
+  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;
+    }
+  }
+  let errorUiFound = false;
+  for (const file of ownedFiles) {
+    const content = readFileOrNull(p(root, file));
+    if (!content) continue;
+    if (/color:\s*['"]?red/.test(content)) {
+      errorUiFound = true;
+      break;
+    }
+  }
+  if (!errorUiFound) failed.push("error_ui_visible_on_failure");
+  return { status: failed.length === 0 ? "pass" : "fail", failed };
+}
+function buildIssues(args) {
+  const issues = [];
+  if (!args.hasIntegration) {
+    issues.push({
+      severity: "info",
+      code: "no-integration",
+      message: "No CometChat integration found in this project.",
+      fix: "Run `cometchat apply --experience 1 --framework <fw>` to integrate."
+    });
+    return issues;
+  }
+  if (args.drift.modified.length > 0) {
+    issues.push({
+      severity: "warning",
+      code: "drift-modified",
+      message: `${args.drift.modified.length} owned file(s) have been modified since apply.`,
+      fix: "Run `cometchat apply --force` to restore the templates, OR run `cometchat info` to see the modified files."
+    });
+  }
+  if (args.drift.missing.length > 0) {
+    issues.push({
+      severity: "error",
+      code: "drift-missing",
+      message: `${args.drift.missing.length} owned file(s) are missing.`,
+      fix: "Run `cometchat apply --force` to recreate them."
+    });
+  }
+  const verifyFixes = {
+    css_variables_imported_once: {
+      msg: "css-variables.css is imported zero or multiple times.",
+      fix: 'Add `@import url("@cometchat/chat-uikit-react/css-variables.css");` to the top of your global stylesheet (src/index.css for Vite, src/app/globals.css for Next.js, app/app.css for React Router). For Astro, import inside the React island .tsx file. Make sure it appears exactly once.'
+    },
+    init_before_login: {
+      msg: "CometChatUIKit.login() is called before CometChatUIKit.init() resolves.",
+      fix: "Wrap login() inside init()?.then(() => login(...)). The login MUST happen after init resolves or you'll get errors."
+    },
+    render_gated_on_login_resolve: {
+      msg: "createRoot(...).render is called at top level instead of inside a mount() function.",
+      fix: "Wrap render in a `mount()` function and call it only inside `init()?.then(() => login(...).then(mount))`. For component-level integrations, use `if (!user) return null` to gate rendering."
+    },
+    no_auth_key_in_source: {
+      msg: "A long hex string (likely a hardcoded Auth Key) was found in an owned file.",
+      fix: "Move the Auth Key to your .env file (VITE_COMETCHAT_AUTH_KEY for Vite, NEXT_PUBLIC_COMETCHAT_AUTH_KEY for Next.js dev, COMETCHAT_AUTH_KEY for production server). For production, run `cometchat production-auth` to use a server-side token endpoint instead."
+    },
+    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."
+    }
+  };
+  for (const failed of args.verify.failed) {
+    const known = verifyFixes[failed];
+    if (known) {
+      issues.push({
+        severity: "error",
+        code: failed,
+        message: known.msg,
+        fix: known.fix
+      });
+    } else {
+      issues.push({
+        severity: "error",
+        code: failed,
+        message: `Verify check "${failed}" failed.`,
+        fix: "Run `cometchat verify --json` for details."
+      });
+    }
+  }
+  if (args.envMissing.length > 0) {
+    issues.push({
+      severity: "warning",
+      code: "env-missing",
+      message: `Missing environment variables: ${args.envMissing.join(", ")}`,
+      fix: "Add the missing variables to your .env file. The chat will fail to initialize without them."
+    });
+  }
+  return issues;
+}
+async function doctor(args) {
+  const root = projectPath10(args);
+  const detected = await runDetectors(root);
+  const stateInfo = hasState(root) ? readState(root) : null;
+  let drift = {
+    has_drift: false,
+    modified: [],
+    missing: []
+  };
+  let verifyResult = {
+    status: "skip",
+    failed: []
+  };
+  if (stateInfo) {
+    const driftReport = detectDrift(root, stateInfo);
+    drift = {
+      has_drift: driftReport.modified_files.length > 0 || driftReport.missing_files.length > 0,
+      modified: driftReport.modified_files,
+      missing: driftReport.missing_files
+    };
+    verifyResult = runQuickVerify(root, stateInfo.files_owned);
+  }
+  const expectedEnvVars = detected.env_prefix !== null ? [
+    `${detected.env_prefix}COMETCHAT_APP_ID`,
+    `${detected.env_prefix}COMETCHAT_REGION`,
+    `${detected.env_prefix}COMETCHAT_AUTH_KEY`
+  ] : [];
+  const envPresent = [];
+  const envMissing = [];
+  if (detected.credentials.app_id_present) envPresent.push(expectedEnvVars[0] ?? "");
+  else if (expectedEnvVars[0]) envMissing.push(expectedEnvVars[0]);
+  if (detected.credentials.region_present) envPresent.push(expectedEnvVars[1] ?? "");
+  else if (expectedEnvVars[1]) envMissing.push(expectedEnvVars[1]);
+  if (detected.credentials.token_endpoint) {
+    envPresent.push(`(server-side via ${detected.credentials.token_endpoint})`);
+  } else if (detected.credentials.auth_key_present) {
+    envPresent.push(expectedEnvVars[2] ?? "");
+  } else if (expectedEnvVars[2]) {
+    envMissing.push(expectedEnvVars[2]);
+  }
+  const issues = buildIssues({
+    drift,
+    verify: verifyResult,
+    envMissing,
+    hasIntegration: stateInfo !== null
+  });
+  const errorCount = issues.filter((i) => i.severity === "error").length;
+  const warnCount = issues.filter((i) => i.severity === "warning").length;
+  const status = errorCount > 0 ? "issues" : warnCount > 0 ? "warnings" : "healthy";
+  const result = {
+    status,
+    detect: {
+      framework: detected.framework,
+      framework_version: detected.framework_version,
+      package_manager: detected.package_manager
+    },
+    integration: {
+      integrated: stateInfo !== null,
+      experience: stateInfo?.experience ?? null,
+      framework: stateInfo?.framework ?? null,
+      template_version: stateInfo?.template_version ?? null,
+      applied_at: stateInfo?.applied_at ?? null
+    },
+    drift: {
+      has_drift: drift.has_drift,
+      modified_files: drift.modified,
+      missing_files: drift.missing
+    },
+    verify: {
+      status: verifyResult.status,
+      failed_checks: verifyResult.failed
+    },
+    environment: {
+      env_vars_present: envPresent.filter(Boolean),
+      env_vars_missing: envMissing
+    },
+    issues,
+    summary: buildSummary(status, errorCount, warnCount, stateInfo !== null)
+  };
+  return outputResult7(args, result, errorCount > 0 ? 1 : 0);
+}
+function buildSummary(status, errors, warnings, integrated) {
+  if (!integrated) return "No CometChat integration found. Run `cometchat apply` to get started.";
+  if (status === "healthy") return "\u2713 All checks pass. Integration is healthy.";
+  if (status === "warnings") return `\u26A0 ${warnings} warning(s) found. Integration works but has minor issues.`;
+  return `\u2717 ${errors} error(s) and ${warnings} warning(s) found. Integration may not work correctly.`;
+}
+function outputResult7(args, result, exitCode) {
+  if (isJsonMode12(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable10(result);
+  return exitCode;
+}
+function printHumanReadable10(r) {
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${r.summary}`);
+  lines.push("");
+  lines.push("  Project:");
+  lines.push(`    Framework: ${r.detect.framework ?? "unknown"}${r.detect.framework_version ? " " + r.detect.framework_version : ""}`);
+  lines.push(`    Package manager: ${r.detect.package_manager ?? "unknown"}`);
+  if (r.integration.integrated) {
+    lines.push("");
+    lines.push("  Integration:");
+    lines.push(`    Experience ${r.integration.experience} on ${r.integration.framework}`);
+    lines.push(`    Template version: ${r.integration.template_version ?? "unknown"}`);
+    if (r.integration.applied_at) lines.push(`    Applied at: ${r.integration.applied_at}`);
+  }
+  if (r.environment.env_vars_present.length > 0 || r.environment.env_vars_missing.length > 0) {
+    lines.push("");
+    lines.push("  Environment:");
+    for (const v of r.environment.env_vars_present) lines.push(`    \u2713 ${v}`);
+    for (const v of r.environment.env_vars_missing) lines.push(`    \u2717 ${v}  (missing)`);
+  }
+  if (r.issues.length > 0) {
+    lines.push("");
+    lines.push(`  Issues (${r.issues.length}):`);
+    for (const issue of r.issues) {
+      const icon = issue.severity === "error" ? "\u2717" : issue.severity === "warning" ? "\u26A0" : "\u2139";
+      lines.push("");
+      lines.push(`    ${icon} [${issue.code}] ${issue.message}`);
+      lines.push(`      Fix: ${issue.fix}`);
+    }
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/init.ts
+import { resolve as resolve12 } from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+function isJsonMode13(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath11(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve12(fromFlag);
+  return resolve12(process.cwd());
+}
+function getStringFlag4(args, name) {
+  const v = args.flags[name];
+  return typeof v === "string" ? v : null;
+}
+async function init(args) {
+  const root = projectPath11(args);
+  const result = {
+    status: "success",
+    framework: null,
+    experience: null,
+    steps_completed: [],
+    steps_skipped: [],
+    steps_failed: [],
+    next_actions: []
+  };
+  const detected = await runDetectors(root);
+  if (detected.framework === null) {
+    result.status = "error";
+    result.error = "Could not detect a supported React framework in " + root;
+    result.next_actions = [
+      "Make sure you're running this from a project root.",
+      "Supported frameworks: reactjs (Vite/CRA), nextjs, react-router, astro."
+    ];
+    return outputResult8(args, result, 1);
+  }
+  result.framework = detected.framework;
+  result.steps_completed.push("detect");
+  const ctx = detected.architecture_context;
+  const ctxFiles = [
+    ...ctx.agent_instruction_files,
+    ...ctx.architecture_docs,
+    ...ctx.installed_skill_directories
+  ];
+  if (ctxFiles.length > 0) {
+    result.next_actions.unshift(
+      `Found ${ctxFiles.length} architecture / agent instruction file(s) in this project \u2014 please follow what they say about code organization, conventions, and AI agent rules: ${ctxFiles.join(", ")}`
+    );
+  }
+  const experienceArg = getStringFlag4(args, "experience") ?? "1";
+  result.experience = parseInt(experienceArg, 10);
+  const applyArgs = {
+    command: "apply",
+    positional: [],
+    flags: {
+      experience: experienceArg,
+      framework: detected.framework,
+      path: root,
+      json: true,
+      ...args.flags["force-overwrite"] ? { "force-overwrite": true } : {}
+    }
+  };
+  const original = console.log;
+  let buf = "";
+  console.log = (...as) => {
+    buf += as.map(String).join(" ") + "\n";
+  };
+  let applyExit = 0;
+  try {
+    applyExit = await apply(applyArgs);
+  } finally {
+    console.log = original;
+  }
+  let applyResult = {};
+  try {
+    applyResult = JSON.parse(buf);
+  } catch {
+  }
+  if (applyExit !== 0 && applyResult.status !== "already-applied") {
+    result.status = "error";
+    result.steps_failed.push("apply");
+    result.error = applyResult.error ?? "apply failed";
+    if (applyResult.files_skipped) {
+      result.next_actions = [
+        `Apply was blocked because ${applyResult.files_skipped.length} file(s) contain user content.`,
+        ...applyResult.files_skipped.map((f) => `  - ${f.path}: ${f.reason}`),
+        "",
+        "Re-run with --force-overwrite to replace them, or remove the files first."
+      ];
+    }
+    return outputResult8(args, result, 1);
+  }
+  result.steps_completed.push("apply");
+  const wantInstall = args.flags.install === true || args.flags.install === "true";
+  if (wantInstall && applyResult.status === "applied" && applyResult.deps_to_install && applyResult.deps_to_install.length > 0) {
+    const pm = detectPackageManager(root) ?? "npm";
+    const installArgs = pm === "npm" ? ["install"] : ["add"];
+    const depArgs = applyResult.deps_to_install.map((d) => `${d.name}@${d.version}`);
+    const proc = spawnSync3(pm, [...installArgs, ...depArgs], {
+      cwd: root,
+      stdio: "ignore"
+    });
+    if (proc.status === 0) {
+      result.steps_completed.push("install");
+    } else {
+      result.steps_failed.push("install");
+      result.next_actions.push(`Install failed (${pm} exit ${proc.status}). Run \`cometchat install\` manually.`);
+    }
+  } else if (wantInstall) {
+    result.steps_skipped.push("install");
+  } else {
+    result.steps_skipped.push("install");
+  }
+  const wantVerify = args.flags.verify === true || args.flags.verify === "true";
+  if (wantVerify) {
+    result.steps_completed.push("verify");
+  } else {
+    result.steps_skipped.push("verify");
+  }
+  if (applyResult.next_steps) {
+    result.next_actions.push(...applyResult.next_steps);
+  }
+  if (!wantInstall && applyResult.deps_to_install && applyResult.deps_to_install.length > 0) {
+    result.next_actions.unshift(
+      `Run \`cometchat install\` (or pass --install next time) to install ${applyResult.deps_to_install.length} npm package(s).`
+    );
+  }
+  try {
+    const manifest = loadManifest(6, detected.framework, parseInt(experienceArg, 10));
+    if (manifest.env_vars.length > 0) {
+      const envNames = manifest.env_vars.map((v) => v.name.replace("{{ENV_PREFIX}}", detected.env_prefix ?? "")).join(", ");
+      result.next_actions.unshift(`Add these env vars to .env: ${envNames}`);
+    }
+  } catch {
+  }
+  return outputResult8(args, result, 0);
+}
+function outputResult8(args, result, exitCode) {
+  if (isJsonMode13(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable11(result);
+  return exitCode;
+}
+function printHumanReadable11(r) {
+  const lines = [];
+  lines.push("");
+  if (r.status === "error") {
+    lines.push(`  \u2717 Init failed: ${r.error ?? "unknown error"}`);
+  } else {
+    lines.push(`  \u2713 CometChat experience ${r.experience} ready in your ${r.framework} project`);
+  }
+  lines.push("");
+  if (r.steps_completed.length > 0) {
+    lines.push("  Steps completed:");
+    for (const s of r.steps_completed) lines.push(`    \u2713 ${s}`);
+  }
+  if (r.steps_skipped.length > 0) {
+    lines.push("  Steps skipped (opt-in via flag):");
+    for (const s of r.steps_skipped) lines.push(`    - ${s}  (pass --${s} to enable)`);
+  }
+  if (r.steps_failed.length > 0) {
+    lines.push("  Steps failed:");
+    for (const s of r.steps_failed) lines.push(`    \u2717 ${s}`);
+  }
+  if (r.next_actions.length > 0) {
+    lines.push("");
+    lines.push("  Next:");
+    for (const a of r.next_actions) lines.push(`    ${a}`);
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/add-widget.ts
+import { readFileSync as readFileSync9 } from "node:fs";
+import { join as join10, resolve as resolve13 } from "node:path";
+var SUPPORTED = /* @__PURE__ */ new Set(["reactjs", "nextjs", "react-router", "astro"]);
+function isJsonMode14(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath12(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve13(fromFlag);
+  return resolve13(process.cwd());
+}
+function widgetRoot() {
+  return join10(findRegistryRoot(), "v6", "widget");
+}
+function loadWidgetManifest(framework) {
+  const root = widgetRoot();
+  const path = join10(root, `${framework}.template.json`);
+  return JSON.parse(readFileSync9(path, "utf8"));
+}
+function readWidgetTemplate(framework, ref) {
+  const root = widgetRoot();
+  return readFileSync9(join10(root, framework, ref), "utf8");
+}
+async function addWidget(args) {
+  const root = projectPath12(args);
+  if (!hasState(root)) {
+    return outputResult9(args, {
+      status: "no-integration",
+      framework: "",
+      files_created: [],
+      next_steps: [],
+      error: "No integration found. Run `cometchat apply` first to create the base integration, then run `cometchat add-widget` to add the floating widget."
+    }, 1);
+  }
+  const state = readState(root);
+  if (!state) {
+    return errorOut6(args, "Could not parse .cometchat/state.json");
+  }
+  if (!SUPPORTED.has(state.framework)) {
+    return outputResult9(args, {
+      status: "unsupported-framework",
+      framework: state.framework,
+      files_created: [],
+      next_steps: [
+        `Widget overlay supports reactjs, nextjs, react-router, and astro. Your integration is on ${state.framework}.`
+      ]
+    }, 2);
+  }
+  const existing = state.files_owned.filter((f) => f.includes("CometChatWidget"));
+  if (existing.length > 0) {
+    return outputResult9(args, {
+      status: "already-applied",
+      framework: state.framework,
+      files_created: [],
+      next_steps: [
+        "Widget files are already in this project.",
+        ...existing.map((f) => `  - ${f}`),
+        "To re-create them, delete the files first then run this command again."
+      ]
+    }, 0);
+  }
+  let manifest;
+  try {
+    manifest = loadWidgetManifest(state.framework);
+  } catch (err) {
+    return errorOut6(args, "Could not load widget manifest: " + (err instanceof Error ? err.message : String(err)));
+  }
+  const ops = [];
+  const ownedPaths = [];
+  for (const f of manifest.files) {
+    const content = readWidgetTemplate(state.framework, f.template_ref);
+    ops.push({ type: "create", path: f.path, content, owned: f.owned });
+    if (f.owned) ownedPaths.push(f.path);
+  }
+  let writeResult;
+  try {
+    writeResult = applyWrites(root, ops);
+  } catch (err) {
+    return errorOut6(args, "Widget apply failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+  const updated = {
+    ...state,
+    files_owned: [...state.files_owned, ...ownedPaths],
+    checksums: { ...state.checksums, ...writeResult.checksums }
+  };
+  writeState(root, updated);
+  appendAuditEntry(root, {
+    command: "add-widget",
+    summary: `Added floating chat widget to ${state.framework} integration`,
+    inputs: { framework: state.framework },
+    decisions: {
+      ssr_pattern: state.framework === "nextjs" ? `Next.js: file starts with "use client" directive \u2014 the widget is a client component, mountable directly OR via dynamic({ssr:false}) from a server component` : state.framework === "react-router" ? `React Router v7: uses an internal mounted-check (useState(false) + useEffect \u2192 setMounted) so the SSR pass renders nothing and the client hydrates the real widget after mount` : state.framework === "astro" ? `Astro: ships as a React island; rendered via <CometChatWidget client:only="react" /> in any .astro file so Astro skips SSR entirely` : `reactjs (Vite): plain React component, no SSR concern`,
+      reuse: "the widget reuses the existing CometChatUIKit init/login from the base integration \u2014 no second init/login pair"
+    },
+    files_created: writeResult.files_created,
+    next_actions: manifest.next_steps
+  });
+  return outputResult9(args, {
+    status: "applied",
+    framework: state.framework,
+    files_created: writeResult.files_created,
+    next_steps: manifest.next_steps
+  }, 0);
+}
+function outputResult9(args, result, exitCode) {
+  if (isJsonMode14(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable12(result);
+  return exitCode;
+}
+function errorOut6(args, message) {
+  if (isJsonMode14(args)) {
+    console.log(JSON.stringify({ status: "error", error: message }, null, 2));
+  } else {
+    console.error(message);
+  }
+  return 1;
+}
+function printHumanReadable12(r) {
+  const lines = [];
+  lines.push("");
+  switch (r.status) {
+    case "no-integration":
+      lines.push(`  \u2717 ${r.error}`);
+      break;
+    case "unsupported-framework":
+      lines.push(`  \u26A0 Framework "${r.framework}" not yet supported for the widget overlay.`);
+      lines.push("");
+      for (const s of r.next_steps) lines.push(`    ${s}`);
+      break;
+    case "already-applied":
+      lines.push(`  = Widget files already exist in this project.`);
+      lines.push("");
+      for (const s of r.next_steps) lines.push(`    ${s}`);
+      break;
+    case "applied":
+      lines.push(`  \u2713 Widget added to ${r.framework}`);
+      lines.push("");
+      lines.push(`  Files created (${r.files_created.length}):`);
+      for (const f of r.files_created) lines.push(`    + ${f}`);
+      lines.push("");
+      lines.push("  Next steps:");
+      for (const s of r.next_steps) lines.push(`    ${s}`);
+      break;
+    case "error":
+      lines.push(`  \u2717 ${r.error ?? "Unknown error"}`);
+      break;
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/add-user-mgmt.ts
+import { readFileSync as readFileSync10 } from "node:fs";
+import { join as join11, resolve as resolve14 } from "node:path";
+var SUPPORTED2 = /* @__PURE__ */ new Set(["nextjs", "react-router", "astro"]);
+function isJsonMode15(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath13(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve14(fromFlag);
+  return resolve14(process.cwd());
+}
+function userMgmtRoot() {
+  return join11(findRegistryRoot(), "v6", "user-mgmt");
+}
+function loadManifest2(framework) {
+  const root = userMgmtRoot();
+  return JSON.parse(readFileSync10(join11(root, `${framework}.template.json`), "utf8"));
+}
+function readTemplate(framework, ref) {
+  const root = userMgmtRoot();
+  return readFileSync10(join11(root, framework, ref), "utf8");
+}
+async function addUserMgmt(args) {
+  const root = projectPath13(args);
+  if (!hasState(root)) {
+    return outputResult10(args, {
+      status: "no-integration",
+      framework: "",
+      files_created: [],
+      next_steps: [],
+      error: "No integration found. Run `cometchat apply` first to create the base integration, then run `cometchat add-user-mgmt`."
+    }, 1);
+  }
+  const state = readState(root);
+  if (!state) {
+    return errorOut7(args, "Could not parse .cometchat/state.json");
+  }
+  if (!SUPPORTED2.has(state.framework)) {
+    return outputResult10(args, {
+      status: "unsupported-framework",
+      framework: state.framework,
+      files_created: [],
+      next_steps: [
+        `User management endpoints currently support nextjs, react-router, and astro. Your integration is on ${state.framework}.`,
+        "Reactjs (Vite/CRA) has no built-in server. To manage users:",
+        "  1. Run a separate Express/Hono/Fastify server alongside your Vite app",
+        "  2. Create endpoints that POST/PUT/DELETE to https://{APP_ID}.api-{REGION}.cometchat.io/v3/users",
+        "  3. Use COMETCHAT_AUTH_KEY (server-only) for the apikey header",
+        "  4. Call those endpoints from your sign-up / profile-update / account-delete flows",
+        "Or migrate to a framework with server support."
+      ]
+    }, 2);
+  }
+  const existing = state.files_owned.filter((f) => f.includes("cometchat-user"));
+  if (existing.length > 0) {
+    return outputResult10(args, {
+      status: "already-applied",
+      framework: state.framework,
+      files_created: [],
+      next_steps: [
+        "User management endpoints are already in this project.",
+        ...existing.map((f) => `  - ${f}`),
+        "To re-create them, delete the files first then run this command again."
+      ]
+    }, 0);
+  }
+  let manifest;
+  try {
+    manifest = loadManifest2(state.framework);
+  } catch (err) {
+    return errorOut7(args, "Could not load user-mgmt manifest: " + (err instanceof Error ? err.message : String(err)));
+  }
+  const ops = [];
+  const ownedPaths = [];
+  for (const f of manifest.files) {
+    if (f.action === "create") {
+      if (!f.template_ref) continue;
+      const content = readTemplate(state.framework, f.template_ref);
+      const owned = f.owned ?? true;
+      ops.push({ type: "create", path: f.path, content, owned });
+      if (owned) ownedPaths.push(f.path);
+    } else if (f.action === "patch") {
+      ops.push({
+        type: "patch",
+        path: f.path,
+        patch_mode: f.patch_mode ?? "prepend",
+        patch_content: f.patch_content ?? "",
+        anchor: f.anchor,
+        skip_if_exists: f.skip_if_exists,
+        patch_id: `user-mgmt/${state.framework}/${f.path}`
+      });
+    }
+  }
+  let writeResult;
+  try {
+    writeResult = applyWrites(root, ops);
+  } catch (err) {
+    return errorOut7(args, "User-mgmt apply failed: " + (err instanceof Error ? err.message : String(err)));
+  }
+  const updated = {
+    ...state,
+    files_owned: [...state.files_owned, ...ownedPaths],
+    checksums: { ...state.checksums, ...writeResult.checksums }
+  };
+  writeState(root, updated);
+  appendAuditEntry(root, {
+    command: "add-user-mgmt",
+    summary: `Added server-side user CRUD endpoints (POST/PATCH/DELETE /api/cometchat-user) for ${state.framework}`,
+    inputs: { framework: state.framework },
+    decisions: {
+      endpoint_path: `picked from user-mgmt manifest for ${state.framework}`,
+      auth_key_handling: `endpoint reads COMETCHAT_AUTH_KEY (server-only env var, no NEXT_PUBLIC_/VITE_/PUBLIC_ prefix) and proxies to https://{APP_ID}.api-{REGION}.cometchat.io/v3/users with the apikey header. The auth key never reaches the browser.`,
+      validation: `UID validation enforces alphanumeric + hyphen + underscore + \u2264100 chars (CometChat constraint); structured 4xx/5xx error responses on bad input`,
+      security: `the endpoint is unauthenticated by design \u2014 the user must add their own session check (NextAuth, Clerk, custom JWT) before exposing it publicly`
+    },
+    files_created: writeResult.files_created,
+    next_actions: manifest.next_steps
+  });
+  return outputResult10(args, {
+    status: "applied",
+    framework: state.framework,
+    files_created: writeResult.files_created,
+    next_steps: manifest.next_steps
+  }, 0);
+}
+function outputResult10(args, result, exitCode) {
+  if (isJsonMode15(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable13(result);
+  return exitCode;
+}
+function errorOut7(args, message) {
+  if (isJsonMode15(args)) {
+    console.log(JSON.stringify({ status: "error", error: message }, null, 2));
+  } else {
+    console.error(message);
+  }
+  return 1;
+}
+function printHumanReadable13(r) {
+  const lines = [];
+  lines.push("");
+  switch (r.status) {
+    case "no-integration":
+      lines.push(`  \u2717 ${r.error}`);
+      break;
+    case "unsupported-framework":
+      lines.push(`  \u26A0 Framework "${r.framework}" not yet supported for user management.`);
+      lines.push("");
+      for (const s of r.next_steps) lines.push(`    ${s}`);
+      break;
+    case "already-applied":
+      lines.push(`  = User management endpoints already exist in this project.`);
+      lines.push("");
+      for (const s of r.next_steps) lines.push(`    ${s}`);
+      break;
+    case "applied":
+      lines.push(`  \u2713 User management added to ${r.framework}`);
+      lines.push("");
+      lines.push(`  Files created (${r.files_created.length}):`);
+      for (const f of r.files_created) lines.push(`    + ${f}`);
+      lines.push("");
+      lines.push("  \u26A0 MANUAL WIRING REQUIRED:");
+      lines.push("");
+      for (const s of r.next_steps) lines.push(`    ${s}`);
+      break;
+    case "error":
+      lines.push(`  \u2717 ${r.error ?? "Unknown error"}`);
+      break;
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/commands/apply-feature.ts
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join12, resolve as resolve15 } from "node:path";
+function isJsonMode16(args) {
+  return args.flags.json === true || args.flags.json === "true";
+}
+function projectPath14(args) {
+  const fromFlag = args.flags.path;
+  if (typeof fromFlag === "string") return resolve15(fromFlag);
+  return resolve15(process.cwd());
+}
+function catalogPath2() {
+  return join12(findRegistryRoot(), "v6", "features", "catalog.json");
+}
+function loadCatalog2() {
+  return JSON.parse(readFileSync11(catalogPath2(), "utf8"));
+}
+function swapIdentifier(content, from, to) {
+  const escaped = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`\\b${escaped}\\b`, "g");
+  let count = 0;
+  const next = content.replace(re, () => {
+    count++;
+    return to;
+  });
+  return [next, count];
+}
+async function applyFeature(args) {
+  const root = projectPath14(args);
+  const featureId = args.positional[0];
+  const result = {
+    status: "applied",
+    feature: featureId ?? "",
+    files_modified: [],
+    next_steps: []
+  };
+  if (!featureId) {
+    result.status = "error";
+    result.error = "Usage: cometchat apply-feature <feature-id>";
+    return outputResult11(args, result, 1);
+  }
+  if (!hasState(root)) {
+    result.status = "no-integration";
+    result.error = "No CometChat integration found. Run `cometchat apply` first.";
+    return outputResult11(args, result, 1);
+  }
+  const state = readState(root);
+  if (!state) {
+    result.status = "error";
+    result.error = "state.json exists but could not be parsed (schema mismatch?)";
+    return outputResult11(args, result, 1);
+  }
+  let catalog;
+  try {
+    catalog = loadCatalog2();
+  } catch (err) {
+    result.status = "error";
+    result.error = err instanceof Error ? err.message : String(err);
+    return outputResult11(args, result, 1);
+  }
+  const feature = catalog.features.find((f) => f.id === featureId);
+  if (!feature) {
+    result.status = "feature-not-found";
+    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.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.`
+    ];
+    return outputResult11(args, result, 1);
+  }
+  if (!feature.swap_from || !feature.swap_to) {
+    result.status = "error";
+    result.error = `Feature "${featureId}" is missing swap_from / swap_to in the catalog.`;
+    return outputResult11(args, result, 1);
+  }
+  if (state.applied_features?.includes(featureId)) {
+    result.status = "already-applied";
+    result.next_steps = [
+      `${feature.name} is already applied to this integration.`,
+      `Files using ${feature.swap_to}: scan with \`grep -r "${feature.swap_to}" .\`.`
+    ];
+    return outputResult11(args, result, 0);
+  }
+  const newChecksums = { ...state.checksums };
+  const modified = [];
+  let totalReplacements = 0;
+  for (const relPath of state.files_owned) {
+    const fullPath = join12(root, relPath);
+    let content;
+    try {
+      content = readFileSync11(fullPath, "utf8");
+    } catch {
+      continue;
+    }
+    const [next, count] = swapIdentifier(content, feature.swap_from, feature.swap_to);
+    if (count > 0) {
+      writeFileSync5(fullPath, next, "utf8");
+      newChecksums[relPath] = sha256(next);
+      modified.push(relPath);
+      totalReplacements += count;
+    }
+  }
+  if (modified.length === 0) {
+    result.status = "no-matches";
+    result.error = `No owned files contained "${feature.swap_from}". Nothing to swap.`;
+    result.next_steps = [
+      `Check what \`cometchat info\` reports as files_owned.`,
+      `If you customized your integration, you may need to do the swap manually.`
+    ];
+    return outputResult11(args, result, 1);
+  }
+  const nextState = {
+    ...state,
+    checksums: newChecksums,
+    applied_features: [...state.applied_features ?? [], featureId]
+  };
+  writeState(root, nextState);
+  result.files_modified = modified;
+  result.next_steps = [
+    `Swapped ${feature.swap_from} \u2192 ${feature.swap_to} in ${modified.length} file(s) (${totalReplacements} occurrence(s)).`,
+    `Restart your dev server. The composer now renders the rich text formatting toolbar (bold, italic, lists, links) by default.`,
+    `To customize: ${feature.swap_to} accepts the same props as ${feature.swap_from}, plus \`hideRichTextFormattingOptions\` and \`enableRichTextEditor\`.`,
+    ...feature.docs_topic ? [`Docs: https://www.cometchat.com/docs/ui-kit/react/${feature.docs_topic}`] : []
+  ];
+  appendAuditEntry(root, {
+    command: `apply-feature ${featureId}`,
+    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 },
+    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`,
+      checksum_update: `state.json checksums recomputed for the modified files so \`info\` doesn't report drift`
+    },
+    files_modified: modified,
+    next_actions: result.next_steps
+  });
+  return outputResult11(args, result, 0);
+}
+function outputResult11(args, result, exitCode) {
+  if (isJsonMode16(args)) {
+    console.log(JSON.stringify(result, null, 2));
+    return exitCode;
+  }
+  printHumanReadable14(result);
+  return exitCode;
+}
+function printHumanReadable14(r) {
+  const lines = [];
+  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}`);
+  } else if (r.status === "already-applied") {
+    lines.push(`  \u25E6 ${r.feature} is already applied \u2014 nothing to do.`);
+  } else {
+    lines.push(`  \u2717 apply-feature failed: ${r.error ?? r.status}`);
+  }
+  if (r.next_steps.length > 0) {
+    lines.push("");
+    lines.push("  Next:");
+    for (const s of r.next_steps) lines.push(`    ${s}`);
+  }
+  lines.push("");
+  console.log(lines.join("\n"));
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+var HELP = `
+cometchat \u2014 CLI for the CometChat skills v2 architecture
+
+Usage:
+  cometchat <command> [args] [--json]
+
+Commands:
+  detect [path]              Fingerprint the project at <path> (default: cwd).
+                             Returns framework, version, router, env prefix,
+                             credential presence, existing-integration state.
+
+  experiences [--framework F] List the available chat experiences and metadata.
+
+  view --experience N        Preview the file diffs that \`apply\` would make.
+       [--framework F]       Pure dry-run \u2014 no files are written.
+       [--path P]            Auto-detects framework from cwd if --framework omitted.
+
+  apply --experience N       Perform the integration. Transactional, idempotent.
+        [--framework F]      Writes .cometchat/state.json on success.
+        [--placement P]      --force overrides an existing integration.
+        [--force]            --force-overwrite replaces user content.
+        [--force-overwrite]  --auto-install runs npm install after a successful apply.
+        [--auto-install]     --placement embed:<path> writes the chat entry file to
+                             a custom location instead of the default
+                             (e.g. embed:src/features/chat/ChatPage.tsx).
+                             Wire-up files (main.tsx for reactjs, routes.ts
+                             patches for react-router) are skipped \u2014 the user
+                             handles those manually.
+
+  info                       Show current integration state + drift detection.
+                             Reads .cometchat/state.json.
+
+  verify                     Run build + AST checks against current integration.
+
+  install [--dry-run]        Install the npm dependencies the current
+                             integration's template manifest declares.
+                             Auto-detects pnpm/npm/yarn/bun.
+
+  uninstall [--force]        Remove all owned files. Refuses if drift detected
+                             without --force.
+
+  production-auth            Upgrade an existing dev integration to use a
+                             server-side token endpoint instead of client-side
+                             Auth Key. Currently nextjs only.
+
+  apply-theme --preset NAME    OR    --primary-color X
+              [--text-color X] [--background-color X] [--font-family X]
+              [--border-radius X] [--dark-mode]
+                             Generate CSS variable overrides matching your
+                             design system. Writes to the right CSS file per
+                             framework (Astro is special \u2014 see help).
+                             --preset accepts: slack, whatsapp, imessage,
+                             discord, notion. Individual flags passed
+                             alongside --preset override that preset's
+                             values (e.g. \`--preset slack --primary-color
+                             #ff0000\`).
+
+  features [list|info <name>|<name>]
+                             Browse the catalog of CometChat features:
+                             default (already in UI Kit), dashboard-toggle
+                             (extensions + AI), package-install (calls),
+                             component-swap (rich text). Returns dashboard
+                             walkthroughs and install instructions per type.
+
+  doctor                     Run combined detect + info + verify + known-issue
+                             diagnostics. Reports drift, failed checks,
+                             missing env vars. Each issue has a code, message,
+                             and a specific fix instruction.
+
+  init [--experience N]      Single-command setup: detect \u2192 apply \u2192 install
+       [--install]           \u2192 verify. Defaults to experience 1. Pass
+       [--verify]            --install to also run npm install.
+       [--force-overwrite]
+
+  add-widget                 Add a floating chat overlay widget to an existing
+                             integration. Creates CometChatWidget.tsx with a
+                             fixed-position button + drawer. Currently reactjs only.
+
+  add-user-mgmt              Create server-side endpoints for managing CometChat
+                             users (POST/PUT/DELETE /api/cometchat-user). Required
+                             for production sign-up flows. Currently nextjs,
+                             react-router, and astro.
+
+  apply-feature <id>         Apply a component-swap feature on top of the
+                             current integration (e.g.
+                             \`apply-feature rich-text-formatting\` swaps
+                             CometChatMessageComposer for
+                             CometChatCompactMessageComposer in every
+                             owned file). Idempotent.
+
+  --help, -h                 Show this help.
+  --version, -v              Show CLI version.
+
+All commands accept --json for machine-readable output.
+For human-readable output, omit --json.
+
+Examples:
+  cometchat detect
+  cometchat detect --json
+  cometchat detect /path/to/my-react-app --json
+  cometchat experiences --json
+  cometchat experiences --framework nextjs --json
+  cometchat view --experience 1 --framework reactjs --json
+  cometchat view --experience 3 --framework reactjs
+`;
+function parseArgs(argv) {
+  const out = { command: null, positional: [], flags: {} };
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      if (eq !== -1) {
+        out.flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+      } else {
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          out.flags[arg.slice(2)] = next;
+          i++;
+        } else {
+          out.flags[arg.slice(2)] = true;
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      out.flags[arg.slice(1)] = true;
+    } else {
+      if (out.command === null) {
+        out.command = arg;
+      } else {
+        out.positional.push(arg);
+      }
+    }
+    i++;
+  }
+  return out;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  if (args.flags.help || args.flags.h) {
+    console.log(HELP);
+    return 0;
+  }
+  if (args.flags.version || args.flags.v) {
+    console.log(VERSION);
+    return 0;
+  }
+  if (args.command === null) {
+    console.log(HELP);
+    return 0;
+  }
+  switch (args.command) {
+    case "detect":
+      return detect(args);
+    case "experiences":
+      return experiences(args);
+    case "view":
+      return view(args);
+    case "apply":
+      return apply(args);
+    case "info":
+      return info(args);
+    case "verify":
+      return verify(args);
+    case "uninstall":
+      return uninstall(args);
+    case "install":
+      return install(args);
+    case "production-auth":
+      return productionAuth(args);
+    case "apply-theme":
+      return applyTheme(args);
+    case "features":
+      return features(args);
+    case "doctor":
+      return doctor(args);
+    case "init":
+      return init(args);
+    case "add-widget":
+      return addWidget(args);
+    case "add-user-mgmt":
+      return addUserMgmt(args);
+    case "apply-feature":
+      return applyFeature(args);
+    default:
+      console.error(`Unknown command: ${args.command}`);
+      console.error("Run `cometchat --help` for usage.");
+      return 1;
+  }
+}
+var isDirectInvocation = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("src/index.ts") || process.argv[1]?.endsWith("src/index.js");
+if (isDirectInvocation) {
+  run(process.argv.slice(2)).then(
+    (code) => process.exit(code),
+    (err) => {
+      console.error(err?.stack ?? err);
+      process.exit(1);
+    }
+  );
+}
+export {
+  parseArgs,
+  run
+};