@mushi-mushi/cli 0.18.2 → 0.19.0

package/dist/chunk-D5IDNBJO.js

@@ -0,0 +1,750 @@
+#!/usr/bin/env node
+import {
+  assertEndpoint,
+  normalizeEndpoint
+} from "./chunk-LDPFTQLE.js";
+
+// src/connect.ts
+import { appendFile, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join3, resolve } from "path";
+
+// src/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var SECURE_FILE_MODE = 384;
+var SECURE_DIR_MODE = 448;
+function resolveXdgConfigPath() {
+  const xdg = process.env["XDG_CONFIG_HOME"];
+  if (xdg && xdg.length > 0) {
+    return join(xdg, "mushi", "config.json");
+  }
+  if (process.platform === "win32") {
+    const appData = process.env["APPDATA"];
+    if (appData && appData.length > 0) {
+      return join(appData, "mushi", "config.json");
+    }
+  }
+  return join(homedir(), ".config", "mushi", "config.json");
+}
+var LEGACY_CONFIG_PATH = join(homedir(), ".mushirc");
+var CONFIG_PATH = resolveXdgConfigPath();
+function loadConfig(path = CONFIG_PATH) {
+  let file = {};
+  if (existsSync(path)) {
+    tightenPermissions(path);
+    try {
+      file = JSON.parse(readFileSync(path, "utf-8"));
+    } catch {
+    }
+  } else if (path === CONFIG_PATH && existsSync(LEGACY_CONFIG_PATH)) {
+    file = migrateLegacyConfig() ?? {};
+  }
+  const endpointFromEnv = process.env["MUSHI_API_ENDPOINT"] ?? process.env["MUSHI_ENDPOINT"] ?? void 0;
+  const fromEnv = {
+    ...process.env["MUSHI_API_KEY"] ? { apiKey: process.env["MUSHI_API_KEY"] } : {},
+    ...process.env["MUSHI_PROJECT_ID"] ? { projectId: process.env["MUSHI_PROJECT_ID"] } : {},
+    ...endpointFromEnv ? { endpoint: endpointFromEnv } : {},
+    ...process.env["MUSHI_CONSOLE_URL"] ? { consoleUrl: process.env["MUSHI_CONSOLE_URL"].trim() } : {}
+  };
+  return { ...file, ...fromEnv };
+}
+function saveConfig(config, path = CONFIG_PATH) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
+  } else {
+    tightenDirPermissions(dir);
+  }
+  writeFileSync(path, JSON.stringify(config, null, 2), { mode: SECURE_FILE_MODE });
+  tightenPermissions(path);
+}
+function migrateLegacyConfig(legacyPath = LEGACY_CONFIG_PATH, destPath = CONFIG_PATH) {
+  if (!existsSync(legacyPath)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(legacyPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  const dir = dirname(destPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: SECURE_DIR_MODE });
+  }
+  try {
+    renameSync(legacyPath, destPath);
+  } catch {
+    writeFileSync(destPath, JSON.stringify(parsed, null, 2), { mode: SECURE_FILE_MODE });
+    try {
+      unlinkSync(legacyPath);
+    } catch {
+    }
+  }
+  tightenPermissions(destPath);
+  tightenDirPermissions(dir);
+  return parsed;
+}
+function tightenPermissions(path) {
+  if (process.platform === "win32") return;
+  try {
+    const current = statSync(path).mode & 511;
+    if (current !== SECURE_FILE_MODE) chmodSync(path, SECURE_FILE_MODE);
+  } catch {
+  }
+}
+function tightenDirPermissions(path) {
+  if (process.platform === "win32") return;
+  try {
+    const current = statSync(path).mode & 511;
+    if (current !== SECURE_DIR_MODE) chmodSync(path, SECURE_DIR_MODE);
+  } catch {
+  }
+}
+
+// src/detect.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var FRAMEWORKS = {
+  next: {
+    id: "next",
+    label: "Next.js",
+    packageName: "@mushi-mushi/react",
+    needsWebPackage: false,
+    snippet: () => `// app/providers.tsx (or pages/_app.tsx for /pages router)
+'use client'
+import { MushiProvider } from '@mushi-mushi/react'
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <MushiProvider config={{
+      projectId: process.env.NEXT_PUBLIC_MUSHI_PROJECT_ID!,
+      apiKey: process.env.NEXT_PUBLIC_MUSHI_API_KEY!,
+    }}>
+      {children}
+    </MushiProvider>
+  )
+}`
+  },
+  react: {
+    id: "react",
+    label: "React",
+    packageName: "@mushi-mushi/react",
+    needsWebPackage: false,
+    snippet: () => `// src/main.tsx
+import { MushiProvider } from '@mushi-mushi/react'
+
+createRoot(document.getElementById('root')!).render(
+  <MushiProvider config={{
+    projectId: import.meta.env.VITE_MUSHI_PROJECT_ID,
+    apiKey: import.meta.env.VITE_MUSHI_API_KEY,
+  }}>
+    <App />
+  </MushiProvider>
+)`
+  },
+  vue: {
+    id: "vue",
+    label: "Vue 3",
+    packageName: "@mushi-mushi/vue",
+    needsWebPackage: false,
+    snippet: () => `// src/main.ts
+import { MushiPlugin } from '@mushi-mushi/vue'
+
+app.use(MushiPlugin, {
+  projectId: import.meta.env.VITE_MUSHI_PROJECT_ID,
+  apiKey: import.meta.env.VITE_MUSHI_API_KEY,
+})`
+  },
+  nuxt: {
+    id: "nuxt",
+    label: "Nuxt",
+    packageName: "@mushi-mushi/vue",
+    needsWebPackage: false,
+    snippet: () => `// plugins/mushi.client.ts
+import { MushiPlugin } from '@mushi-mushi/vue'
+
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.vueApp.use(MushiPlugin, {
+    projectId: import.meta.env.NUXT_PUBLIC_MUSHI_PROJECT_ID,
+    apiKey: import.meta.env.NUXT_PUBLIC_MUSHI_API_KEY,
+  })
+})`
+  },
+  svelte: {
+    id: "svelte",
+    label: "Svelte",
+    packageName: "@mushi-mushi/svelte",
+    needsWebPackage: false,
+    snippet: () => `// src/main.ts
+import { initMushi } from '@mushi-mushi/svelte'
+
+initMushi({
+  projectId: import.meta.env.VITE_MUSHI_PROJECT_ID,
+  apiKey: import.meta.env.VITE_MUSHI_API_KEY,
+})`
+  },
+  sveltekit: {
+    id: "sveltekit",
+    label: "SvelteKit",
+    packageName: "@mushi-mushi/svelte",
+    needsWebPackage: false,
+    snippet: () => `// src/routes/+layout.svelte
+<script>
+  import { onMount } from 'svelte'
+
+  onMount(async () => {
+    const { initMushi } = await import('@mushi-mushi/svelte')
+    initMushi({
+      projectId: import.meta.env.VITE_MUSHI_PROJECT_ID,
+      apiKey: import.meta.env.VITE_MUSHI_API_KEY,
+    })
+  })
+</script>`
+  },
+  angular: {
+    id: "angular",
+    label: "Angular",
+    packageName: "@mushi-mushi/angular",
+    needsWebPackage: false,
+    snippet: () => `// src/main.ts
+import { provideMushi } from '@mushi-mushi/angular'
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideMushi({
+      projectId: import.meta.env.VITE_MUSHI_PROJECT_ID,
+      apiKey: import.meta.env.VITE_MUSHI_API_KEY,
+    }),
+  ],
+})`
+  },
+  expo: {
+    id: "expo",
+    label: "Expo",
+    packageName: "@mushi-mushi/react-native",
+    needsWebPackage: false,
+    snippet: () => `// App.tsx
+import { MushiProvider } from '@mushi-mushi/react-native'
+
+export default function App() {
+  return (
+    <MushiProvider
+      projectId={process.env.EXPO_PUBLIC_MUSHI_PROJECT_ID!}
+      apiKey={process.env.EXPO_PUBLIC_MUSHI_API_KEY!}
+    >
+      <YourApp />
+    </MushiProvider>
+  )
+}`
+  },
+  "react-native": {
+    id: "react-native",
+    label: "React Native",
+    packageName: "@mushi-mushi/react-native",
+    needsWebPackage: false,
+    snippet: () => `// App.tsx
+import { MushiProvider } from '@mushi-mushi/react-native'
+
+export default function App() {
+  return (
+    <MushiProvider
+      projectId={process.env.MUSHI_PROJECT_ID!}
+      apiKey={process.env.MUSHI_API_KEY!}
+    >
+      <YourApp />
+    </MushiProvider>
+  )
+}`
+  },
+  capacitor: {
+    id: "capacitor",
+    label: "Capacitor (Ionic)",
+    packageName: "@mushi-mushi/capacitor",
+    needsWebPackage: false,
+    /* The Capacitor plugin's public API is `Mushi.configure(...)`, not
+     * `Mushi.init(...)` — see packages/capacitor/src/definitions.ts. We
+     * shipped the wrong call here for two releases and users got a runtime
+     * `TypeError: Mushi.init is not a function`. The accompanying admin
+     * console snippet (apps/admin/src/lib/sdkSnippets.ts) emits the same
+     * `Mushi.configure(...)` shape; both are pinned by tests. */
+    snippet: () => `// src/main.ts \u2014 after install, run \`npx cap sync\`
+import { Mushi } from '@mushi-mushi/capacitor'
+
+await Mushi.configure({
+  projectId: import.meta.env.VITE_MUSHI_PROJECT_ID,
+  apiKey: import.meta.env.VITE_MUSHI_API_KEY,
+})`
+  },
+  express: {
+    id: "express",
+    label: "Express",
+    packageName: "@mushi-mushi/node",
+    needsWebPackage: false,
+    snippet: () => `// src/instrument.ts \u2014 load with: node --import ./dist/instrument.js
+import { MushiNodeClient, attachUnhandledHook } from '@mushi-mushi/node'
+import { mushiExpressErrorHandler } from '@mushi-mushi/node/express'
+import type { Express } from 'express'
+
+export const mushi = new MushiNodeClient({
+  projectId: process.env.MUSHI_PROJECT_ID!,
+  apiKey: process.env.MUSHI_API_KEY!,
+  environment: process.env.NODE_ENV ?? 'production',
+})
+attachUnhandledHook({ client: mushi })
+
+export function attachMushi(app: Express) {
+  app.use(mushiExpressErrorHandler({ client: mushi }))
+}`
+  },
+  fastify: {
+    id: "fastify",
+    label: "Fastify",
+    packageName: "@mushi-mushi/node",
+    needsWebPackage: false,
+    snippet: () => `// src/instrument.ts \u2014 load with: node --import ./dist/instrument.js
+import { MushiNodeClient, attachUnhandledHook } from '@mushi-mushi/node'
+import { mushiFastifyPlugin } from '@mushi-mushi/node/fastify'
+import Fastify from 'fastify'
+
+export const mushi = new MushiNodeClient({
+  projectId: process.env.MUSHI_PROJECT_ID!,
+  apiKey: process.env.MUSHI_API_KEY!,
+  environment: process.env.NODE_ENV ?? 'production',
+})
+attachUnhandledHook({ client: mushi })
+
+const app = Fastify()
+mushiFastifyPlugin(app, { client: mushi })`
+  },
+  hono: {
+    id: "hono",
+    label: "Hono",
+    packageName: "@mushi-mushi/node",
+    needsWebPackage: false,
+    snippet: () => `// src/instrument.ts \u2014 load with: node --import ./dist/instrument.js
+import { MushiNodeClient, attachUnhandledHook } from '@mushi-mushi/node'
+import { mushiHonoErrorHandler } from '@mushi-mushi/node/hono'
+import { Hono } from 'hono'
+
+export const mushi = new MushiNodeClient({
+  projectId: process.env.MUSHI_PROJECT_ID!,
+  apiKey: process.env.MUSHI_API_KEY!,
+  environment: process.env.NODE_ENV ?? 'production',
+})
+attachUnhandledHook({ client: mushi })
+
+const app = new Hono()
+app.onError(
+  mushiHonoErrorHandler({ client: mushi }, (err, c) =>
+    c.text('Internal Server Error', 500),
+  ),
+)`
+  },
+  vanilla: {
+    id: "vanilla",
+    label: "Vanilla JS / unknown",
+    packageName: "@mushi-mushi/web",
+    needsWebPackage: false,
+    snippet: () => `// Anywhere in your client bundle
+import { Mushi } from '@mushi-mushi/web'
+
+Mushi.init({
+  projectId: import.meta.env.VITE_MUSHI_PROJECT_ID,
+  apiKey: import.meta.env.VITE_MUSHI_API_KEY,
+})`
+  }
+};
+function readPackageJson(cwd) {
+  const path = join2(cwd, "package.json");
+  if (!existsSync2(path)) return null;
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function detectFramework(cwd, pkg) {
+  const deps = collectDeps(pkg);
+  if (deps.has("next")) return FRAMEWORKS.next;
+  if (deps.has("nuxt")) return FRAMEWORKS.nuxt;
+  if (deps.has("@sveltejs/kit")) return FRAMEWORKS.sveltekit;
+  if (deps.has("@angular/core")) return FRAMEWORKS.angular;
+  if (deps.has("expo")) return FRAMEWORKS.expo;
+  if (deps.has("react-native")) return FRAMEWORKS["react-native"];
+  if (deps.has("@capacitor/core") && deps.has("react")) return FRAMEWORKS.react;
+  if (deps.has("@capacitor/core")) return FRAMEWORKS.capacitor;
+  if (deps.has("svelte")) return FRAMEWORKS.svelte;
+  if (deps.has("vue")) return FRAMEWORKS.vue;
+  if (deps.has("react")) return FRAMEWORKS.react;
+  if (deps.has("express")) return FRAMEWORKS.express;
+  if (deps.has("fastify")) return FRAMEWORKS.fastify;
+  if (deps.has("hono") || deps.has("@hono/hono")) return FRAMEWORKS.hono;
+  if (existsSync2(join2(cwd, "next.config.js")) || existsSync2(join2(cwd, "next.config.ts"))) {
+    return FRAMEWORKS.next;
+  }
+  if (existsSync2(join2(cwd, "nuxt.config.ts")) || existsSync2(join2(cwd, "nuxt.config.js"))) {
+    return FRAMEWORKS.nuxt;
+  }
+  if (existsSync2(join2(cwd, "svelte.config.js"))) return FRAMEWORKS.svelte;
+  if (existsSync2(join2(cwd, "angular.json"))) return FRAMEWORKS.angular;
+  return FRAMEWORKS.vanilla;
+}
+function detectPackageManager(cwd) {
+  if (existsSync2(join2(cwd, "bun.lockb")) || existsSync2(join2(cwd, "bun.lock"))) return "bun";
+  if (existsSync2(join2(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join2(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync2(join2(cwd, "package-lock.json"))) return "npm";
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("bun")) return "bun";
+  if (userAgent.startsWith("pnpm")) return "pnpm";
+  if (userAgent.startsWith("yarn")) return "yarn";
+  return "npm";
+}
+function installCommand(pm, packages) {
+  const verb = pm === "npm" ? "install" : "add";
+  return `${pm} ${verb} ${packages.join(" ")}`;
+}
+var SERVER_FRAMEWORK_IDS = /* @__PURE__ */ new Set(["express", "fastify", "hono"]);
+function envVarsToWrite(apiKey, projectId, framework) {
+  if (SERVER_FRAMEWORK_IDS.has(framework.id)) {
+    return [
+      `MUSHI_PROJECT_ID=${projectId}`,
+      `MUSHI_API_KEY=${apiKey}`
+    ].join("\n");
+  }
+  if (framework.id === "react-native") {
+    return [
+      `MUSHI_PROJECT_ID=${projectId}`,
+      `MUSHI_API_KEY=${apiKey}`
+    ].join("\n");
+  }
+  if (framework.id === "expo") {
+    return [
+      `EXPO_PUBLIC_MUSHI_PROJECT_ID=${projectId}`,
+      `EXPO_PUBLIC_MUSHI_API_KEY=${apiKey}`
+    ].join("\n");
+  }
+  const prefix = framework.id === "next" ? "NEXT_PUBLIC_" : framework.id === "nuxt" ? "NUXT_PUBLIC_" : "VITE_";
+  return [
+    `${prefix}MUSHI_PROJECT_ID=${projectId}`,
+    `${prefix}MUSHI_API_KEY=${apiKey}`
+  ].join("\n");
+}
+function collectDeps(pkg) {
+  if (!pkg) return /* @__PURE__ */ new Set();
+  return /* @__PURE__ */ new Set([
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.devDependencies ?? {}),
+    ...Object.keys(pkg.peerDependencies ?? {})
+  ]);
+}
+
+// src/sanitize-config.ts
+var PROJECT_ID_RE = /^(?:proj_[A-Za-z0-9_-]{10,}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+var API_KEY_RE = /^(mushi_|mush_pk_)[A-Za-z0-9_-]{10,}$/;
+function sanitizeApiKey(raw) {
+  const key = raw.replace(/[\r\n\0]/g, "");
+  if (!API_KEY_RE.test(key)) {
+    throw new Error(
+      "Invalid API key in config \u2014 run `mushi login --api-key <key>` to refresh credentials."
+    );
+  }
+  return key;
+}
+function sanitizeProjectId(raw) {
+  const id = raw.trim();
+  if (!PROJECT_ID_RE.test(id)) {
+    throw new Error(
+      "Invalid project ID in config \u2014 expected a UUID or proj_* slug from the admin console."
+    );
+  }
+  return id;
+}
+function sanitizeEndpoint(raw) {
+  return assertEndpoint(normalizeEndpoint(raw));
+}
+function sanitizeCliCredentials(config) {
+  if (!config.endpoint || !config.apiKey || !config.projectId) {
+    throw new Error("Missing endpoint, apiKey, or projectId");
+  }
+  return {
+    endpoint: sanitizeEndpoint(config.endpoint),
+    apiKey: sanitizeApiKey(config.apiKey),
+    projectId: sanitizeProjectId(config.projectId)
+  };
+}
+function apiKeyHeaders(apiKey, projectId) {
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "X-Mushi-Api-Key": apiKey
+  };
+  if (projectId) headers["X-Mushi-Project"] = projectId;
+  return headers;
+}
+
+// src/heartbeat-wait.ts
+var IngestSetupHttpError = class extends Error {
+  status;
+  constructor(status) {
+    super(`ingest-setup HTTP ${status}`);
+    this.name = "IngestSetupHttpError";
+    this.status = status;
+  }
+};
+var NON_RETRYABLE_STATUSES = /* @__PURE__ */ new Set([401, 403, 404]);
+async function fetchIngestSetup(config, doFetch = globalThis.fetch) {
+  const endpoint = sanitizeEndpoint(config.endpoint);
+  const apiKey = sanitizeApiKey(config.apiKey);
+  const projectId = config.projectId ? sanitizeProjectId(config.projectId) : void 0;
+  const res = await doFetch(`${endpoint}/v1/sync/ingest-setup`, {
+    headers: apiKeyHeaders(apiKey, projectId),
+    signal: AbortSignal.timeout(8e3)
+  });
+  if (!res.ok) {
+    if (NON_RETRYABLE_STATUSES.has(res.status)) throw new IngestSetupHttpError(res.status);
+    return null;
+  }
+  const body = await res.json();
+  return body.ok && body.data ? body.data : null;
+}
+async function waitForIngestReady(options) {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const maxAttempts = options.maxAttempts ?? 40;
+  const intervalMs = options.intervalMs ?? 3e3;
+  let lastPayload = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (options.signal?.aborted) {
+      return { ok: false, payload: lastPayload, attempts: attempt - 1, reason: "aborted" };
+    }
+    try {
+      lastPayload = await fetchIngestSetup(
+        { endpoint: options.endpoint, apiKey: options.apiKey, projectId: options.projectId },
+        doFetch
+      );
+      if (lastPayload) {
+        options.onPoll?.(lastPayload, attempt);
+        if (lastPayload.ready) {
+          return { ok: true, payload: lastPayload, attempts: attempt, reason: "ready" };
+        }
+        const sdkStep = lastPayload.steps.find((s) => s.id === "sdk_installed");
+        if (sdkStep?.complete) {
+          return { ok: true, payload: lastPayload, attempts: attempt, reason: "heartbeat" };
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (err instanceof IngestSetupHttpError) {
+        return { ok: false, payload: lastPayload, attempts: attempt, reason: "unauthorized", error: msg };
+      }
+      if (options.signal?.aborted) {
+        return { ok: false, payload: lastPayload, attempts: attempt, reason: "aborted", error: msg };
+      }
+      if (attempt === maxAttempts) {
+        return { ok: false, payload: lastPayload, attempts: attempt, reason: "fetch-error", error: msg };
+      }
+    }
+    if (attempt < maxAttempts) {
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+  }
+  return { ok: false, payload: lastPayload, attempts: maxAttempts, reason: "timeout" };
+}
+
+// src/mcp-config.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var DEFAULT_MUSHI_FEATURES = "triage,fixes,inventory,setup,docs";
+async function writeMcpServerEntry(opts) {
+  const { configPath, serverName, serverBlock, dryRun = false } = opts;
+  let merged = { mcpServers: {} };
+  let created = false;
+  try {
+    const existing = await readFile(configPath, "utf8");
+    try {
+      merged = JSON.parse(existing);
+    } catch {
+      merged = { mcpServers: {} };
+    }
+  } catch {
+    created = true;
+    merged = { mcpServers: {} };
+  }
+  const servers = merged.mcpServers ?? {};
+  servers[serverName] = serverBlock;
+  merged.mcpServers = servers;
+  const output = JSON.stringify(merged, null, 2) + "\n";
+  if (!dryRun) {
+    await mkdir(dirname2(configPath), { recursive: true });
+    await writeFile(configPath, output, "utf8");
+  }
+  return { created, path: configPath };
+}
+function buildMcpServerBlock(opts) {
+  return {
+    command: "npx",
+    args: ["-y", "@mushi-mushi/mcp@latest"],
+    env: {
+      MUSHI_API_ENDPOINT: opts.endpoint,
+      MUSHI_PROJECT_ID: opts.projectId,
+      MUSHI_API_KEY: opts.apiKey,
+      MUSHI_FEATURES: DEFAULT_MUSHI_FEATURES
+    }
+  };
+}
+function buildMcpServerName(opts) {
+  if (opts.legacy) return "mushi";
+  if (opts.projectName) {
+    const slug = opts.projectName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24);
+    return `mushi-${slug}`;
+  }
+  return `mushi-${(opts.projectId ?? "unknown").slice(0, 8)}`;
+}
+
+// src/connect.ts
+function envKeyPresent(content, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${escaped}=`, "m").test(content);
+}
+async function mergeEnvFile(path, lines) {
+  const block = `
+# Mushi \u2014 added by mushi connect
+${lines.join("\n")}
+`;
+  let existing = null;
+  try {
+    existing = await readFile2(path, "utf8");
+  } catch {
+  }
+  if (existing !== null) {
+    const needs = lines.filter((line) => {
+      const key = line.split("=")[0];
+      return !envKeyPresent(existing, key);
+    });
+    if (needs.length === 0) return false;
+    await appendFile(path, `
+# Mushi \u2014 added by mushi connect
+${needs.join("\n")}
+`, "utf8");
+    return true;
+  }
+  await writeFile2(path, block, "utf8");
+  return true;
+}
+async function ensureMcpJsonGitignored(cwd, messages) {
+  const gitignorePath = join3(cwd, ".gitignore");
+  const patterns = [".cursor/mcp.json", ".cursor/"];
+  let content = null;
+  try {
+    content = await readFile2(gitignorePath, "utf8");
+  } catch {
+  }
+  if (content === null) {
+    messages.push(
+      "\u26A0 No .gitignore found \u2014 .cursor/mcp.json contains your API key. Add `.cursor/mcp.json` before committing."
+    );
+    return;
+  }
+  const covered = patterns.some((p) => content.split("\n").some((line) => line.trim() === p || line.trim() === `${p}/`));
+  if (covered) return;
+  await appendFile(gitignorePath, "\n# Mushi \u2014 keep MCP credentials out of git\n.cursor/mcp.json\n", "utf8");
+  messages.push("\u2713 Added .cursor/mcp.json to .gitignore (contains API key)");
+}
+async function runConnect(opts, baseConfig = {}) {
+  const cwd = resolve(opts.cwd ?? process.cwd());
+  const endpoint = assertEndpoint(opts.endpoint);
+  const messages = [];
+  const config = {
+    ...baseConfig,
+    apiKey: opts.apiKey,
+    projectId: opts.projectId,
+    endpoint
+  };
+  saveConfig(config);
+  messages.push(`\u2713 Credentials saved to ${CONFIG_PATH}`);
+  let envPath = null;
+  if (opts.writeEnv !== false) {
+    const pkg = readPackageJson(cwd);
+    const framework = detectFramework(cwd, pkg);
+    const lines = envVarsToWrite(opts.apiKey, opts.projectId, framework).split("\n");
+    envPath = join3(cwd, ".env.local");
+    const wrote = await mergeEnvFile(envPath, lines);
+    messages.push(
+      wrote ? `\u2713 Env vars merged into ${envPath}` : `\u2713 Env vars already present in ${envPath} (existing values left untouched)`
+    );
+    const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+    if (deps["@capacitor/core"] && deps["react"]) {
+      messages.push(
+        "\u2139 Capacitor + React detected \u2014 install @mushi-mushi/web (or @mushi-mushi/react) and call initMushi() in main.tsx. Optional @mushi-mushi/capacitor for native shell parity."
+      );
+    }
+  }
+  let mcpPath = null;
+  if (opts.wireIde !== false) {
+    const mcpDir = join3(cwd, ".cursor");
+    mcpPath = join3(mcpDir, "mcp.json");
+    const serverName = buildMcpServerName({ projectId: opts.projectId });
+    const serverBlock = buildMcpServerBlock({
+      endpoint,
+      projectId: opts.projectId,
+      apiKey: opts.apiKey
+    });
+    await writeMcpServerEntry({ configPath: mcpPath, serverName, serverBlock });
+    await ensureMcpJsonGitignored(cwd, messages);
+    messages.push(`\u2713 Wired ${mcpPath} \u2014 restart Cursor and run "list mushi tools"`);
+  }
+  let heartbeat = null;
+  if (opts.wait) {
+    const timeoutSec = opts.waitTimeoutSec ?? 120;
+    const maxAttempts = Math.max(1, Math.ceil(timeoutSec * 1e3 / 3e3));
+    messages.push(`\u2026 Waiting for SDK heartbeat (up to ${timeoutSec}s) \u2014 start your dev server with the snippet installed`);
+    heartbeat = await waitForIngestReady({
+      endpoint,
+      apiKey: opts.apiKey,
+      projectId: opts.projectId,
+      maxAttempts,
+      onPoll: (payload, attempt) => {
+        if (!opts.json && attempt % 3 === 0) {
+          const sdk = payload.steps.find((s) => s.id === "sdk_installed");
+          const seen = payload.diagnostic?.last_sdk_seen_at ?? "never";
+          process.stdout.write(`  poll ${attempt}: sdk_installed=${sdk?.complete ? "yes" : "no"} last_seen=${seen}
+`);
+        }
+      }
+    });
+    if (heartbeat.ok) {
+      const label = heartbeat.reason === "heartbeat" ? "SDK heartbeat detected" : "Ingest setup complete";
+      messages.push(`\u2713 ${label} \u2014 ingest pipeline is live`);
+    } else if (heartbeat.reason === "unauthorized") {
+      messages.push(
+        `\u2717 The backend rejected these credentials (${heartbeat.error ?? "auth error"}). Double-check --api-key, --project-id, and --endpoint, then re-run \`mushi connect --wait\`.`
+      );
+    } else {
+      messages.push(
+        `\u2717 No heartbeat before timeout (${heartbeat.reason}). Confirm env vars are in your build, restart the dev server, then re-run \`mushi connect --wait\`.`
+      );
+    }
+  }
+  const ok = !opts.wait || Boolean(heartbeat?.ok);
+  return { ok, envPath, mcpPath, heartbeat, messages };
+}
+
+export {
+  loadConfig,
+  saveConfig,
+  FRAMEWORKS,
+  readPackageJson,
+  detectFramework,
+  detectPackageManager,
+  installCommand,
+  envVarsToWrite,
+  sanitizeApiKey,
+  sanitizeProjectId,
+  sanitizeEndpoint,
+  sanitizeCliCredentials,
+  apiKeyHeaders,
+  fetchIngestSetup,
+  writeMcpServerEntry,
+  buildMcpServerBlock,
+  buildMcpServerName,
+  runConnect
+};