@mushi-mushi/cli 0.27.0 → 0.28.0

package/dist/chunk-KOBEOGNF.js

@@ -0,0 +1,475 @@
+#!/usr/bin/env node
+
+// src/detect.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+var FRAMEWORK_IDS = [
+  "next",
+  "react",
+  "cra",
+  "remix",
+  "astro",
+  "solid",
+  "vue",
+  "nuxt",
+  "svelte",
+  "sveltekit",
+  "angular",
+  "expo",
+  "react-native",
+  "capacitor",
+  "express",
+  "fastify",
+  "hono",
+  "vanilla"
+];
+function isFrameworkId(value) {
+  return typeof value === "string" && FRAMEWORK_IDS.includes(value);
+}
+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>
+)`
+  },
+  cra: {
+    id: "cra",
+    label: "Create React App",
+    packageName: "@mushi-mushi/react",
+    needsWebPackage: false,
+    // CRA inlines only REACT_APP_*-prefixed vars into process.env at build time.
+    snippet: () => `// src/index.tsx
+import { MushiProvider } from '@mushi-mushi/react'
+
+root.render(
+  <MushiProvider config={{
+    projectId: process.env.REACT_APP_MUSHI_PROJECT_ID,
+    apiKey: process.env.REACT_APP_MUSHI_API_KEY,
+  }}>
+    <App />
+  </MushiProvider>
+)`
+  },
+  remix: {
+    id: "remix",
+    label: "Remix",
+    packageName: "@mushi-mushi/react",
+    needsWebPackage: false,
+    // Remix doesn't inline client env. Expose public values at runtime via the
+    // root loader + window.ENV (works on both the classic compiler and Vite).
+    snippet: () => `// app/root.tsx
+import { MushiProvider } from '@mushi-mushi/react'
+import { useLoaderData } from '@remix-run/react'
+
+export async function loader() {
+  return { ENV: {
+    MUSHI_PROJECT_ID: process.env.MUSHI_PROJECT_ID,
+    MUSHI_API_KEY: process.env.MUSHI_API_KEY,
+  } }
+}
+
+export default function App() {
+  const { ENV } = useLoaderData<typeof loader>()
+  return (
+    <html>
+      <body>
+        <MushiProvider config={{ projectId: ENV.MUSHI_PROJECT_ID, apiKey: ENV.MUSHI_API_KEY }}>
+          <Outlet />
+        </MushiProvider>
+        <Scripts />
+      </body>
+    </html>
+  )
+}`
+  },
+  astro: {
+    id: "astro",
+    label: "Astro",
+    packageName: "@mushi-mushi/web",
+    needsWebPackage: false,
+    // Astro exposes only PUBLIC_*-prefixed vars to client code (Vite-based).
+    snippet: () => `---
+// src/layouts/Layout.astro (add this <script> once, e.g. in your base layout)
+---
+<script>
+  import { Mushi } from '@mushi-mushi/web'
+  Mushi.init({
+    projectId: import.meta.env.PUBLIC_MUSHI_PROJECT_ID,
+    apiKey: import.meta.env.PUBLIC_MUSHI_API_KEY,
+  })
+</script>`
+  },
+  solid: {
+    id: "solid",
+    label: "Solid",
+    packageName: "@mushi-mushi/web",
+    needsWebPackage: false,
+    // Solid / SolidStart are Vite-based → VITE_*-prefixed client env.
+    snippet: () => `// src/index.tsx (or src/app.tsx for SolidStart)
+import { onMount } from 'solid-js'
+import { Mushi } from '@mushi-mushi/web'
+
+onMount(() => {
+  Mushi.init({
+    projectId: import.meta.env.VITE_MUSHI_PROJECT_ID,
+    apiKey: import.meta.env.VITE_MUSHI_API_KEY,
+  })
+})`
+  },
+  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 = join(cwd, "package.json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(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("@remix-run/react") || deps.has("@remix-run/node") || deps.has("@remix-run/serve")) {
+    return FRAMEWORKS.remix;
+  }
+  if (deps.has("astro")) return FRAMEWORKS.astro;
+  if (deps.has("@solidjs/start") || deps.has("solid-js")) return FRAMEWORKS.solid;
+  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-scripts")) return FRAMEWORKS.cra;
+  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 (existsSync(join(cwd, "next.config.js")) || existsSync(join(cwd, "next.config.ts"))) {
+    return FRAMEWORKS.next;
+  }
+  if (existsSync(join(cwd, "nuxt.config.ts")) || existsSync(join(cwd, "nuxt.config.js"))) {
+    return FRAMEWORKS.nuxt;
+  }
+  if (existsSync(join(cwd, "svelte.config.js"))) return FRAMEWORKS.svelte;
+  if (existsSync(join(cwd, "angular.json"))) return FRAMEWORKS.angular;
+  if (existsSync(join(cwd, "remix.config.js")) || existsSync(join(cwd, "remix.config.ts"))) {
+    return FRAMEWORKS.remix;
+  }
+  if (existsSync(join(cwd, "astro.config.mjs")) || existsSync(join(cwd, "astro.config.ts")) || existsSync(join(cwd, "astro.config.js"))) {
+    return FRAMEWORKS.astro;
+  }
+  return FRAMEWORKS.vanilla;
+}
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) return "bun";
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync(join(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, endpoint) {
+  const CLOUD_ENDPOINT = "https://dxptnwrhwsqckaftyymj.supabase.co/functions/v1/api";
+  const endpointLine = endpoint && endpoint !== CLOUD_ENDPOINT ? `MUSHI_API_ENDPOINT=${endpoint}` : null;
+  if (SERVER_FRAMEWORK_IDS.has(framework.id)) {
+    return [
+      `MUSHI_PROJECT_ID=${projectId}`,
+      `MUSHI_API_KEY=${apiKey}`,
+      endpointLine
+    ].filter(Boolean).join("\n");
+  }
+  if (framework.id === "react-native" || framework.id === "remix") {
+    return [
+      `MUSHI_PROJECT_ID=${projectId}`,
+      `MUSHI_API_KEY=${apiKey}`,
+      endpointLine
+    ].filter(Boolean).join("\n");
+  }
+  if (framework.id === "expo") {
+    return [
+      `EXPO_PUBLIC_MUSHI_PROJECT_ID=${projectId}`,
+      `EXPO_PUBLIC_MUSHI_API_KEY=${apiKey}`,
+      endpointLine ? `EXPO_PUBLIC_${endpointLine}` : null
+    ].filter(Boolean).join("\n");
+  }
+  const prefix = framework.id === "next" ? "NEXT_PUBLIC_" : framework.id === "nuxt" ? "NUXT_PUBLIC_" : framework.id === "cra" ? "REACT_APP_" : framework.id === "astro" ? "PUBLIC_" : "VITE_";
+  return [
+    `${prefix}MUSHI_PROJECT_ID=${projectId}`,
+    `${prefix}MUSHI_API_KEY=${apiKey}`,
+    endpointLine ? `${prefix}${endpointLine}` : null
+  ].filter(Boolean).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 ?? {})
+  ]);
+}
+
+export {
+  FRAMEWORK_IDS,
+  isFrameworkId,
+  FRAMEWORKS,
+  readPackageJson,
+  detectFramework,
+  detectPackageManager,
+  installCommand,
+  envVarsToWrite
+};

package/dist/chunk-SXSI2W6Z.js

@@ -0,0 +1,42 @@
+// src/endpoint.ts
+var TEST_REPORT_TIMEOUT_MS = 1e4;
+var TEST_REPORT_FETCH_TIMEOUT_MS = TEST_REPORT_TIMEOUT_MS;
+var CLOUD_API_ENDPOINT = "https://dxptnwrhwsqckaftyymj.supabase.co/functions/v1/api";
+function resolveCloudEndpoint(explicit) {
+  if (explicit?.trim()) return explicit.trim();
+  const fromEnv = process.env.MUSHI_API_ENDPOINT?.trim();
+  if (fromEnv) return fromEnv;
+  return CLOUD_API_ENDPOINT;
+}
+function assertEndpoint(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid endpoint URL: ${url}`);
+  }
+  const host = parsed.hostname;
+  const isLocal = host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".local");
+  if (parsed.protocol !== "https:" && !isLocal) {
+    throw new Error(`Endpoint must use https:// (got ${parsed.protocol}//${host}).`);
+  }
+  return normalizeEndpoint(parsed.origin + parsed.pathname);
+}
+function normalizeEndpoint(url) {
+  if (!url) {
+    throw new Error(
+      "No API endpoint configured. Run `mushi init` or set MUSHI_API_ENDPOINT. Set endpoint to your Supabase edge function URL, e.g. https://xyz.supabase.co/functions/v1/api"
+    );
+  }
+  let end = url.length;
+  while (end > 0 && url.charCodeAt(end - 1) === 47) end--;
+  return url.slice(0, end);
+}
+
+export {
+  TEST_REPORT_FETCH_TIMEOUT_MS,
+  CLOUD_API_ENDPOINT,
+  resolveCloudEndpoint,
+  assertEndpoint,
+  normalizeEndpoint
+};

package/dist/chunk-U2VGB63C.js

@@ -0,0 +1,8 @@
+// src/version.ts
+var MUSHI_CLI_VERSION = true ? "0.28.0" : "0.0.0-dev";
+var MUSHI_MCP_PIN_SPEC = "@mushi-mushi/mcp@0.22.0";
+
+export {
+  MUSHI_CLI_VERSION,
+  MUSHI_MCP_PIN_SPEC
+};

package/dist/chunk-UVO4A2G6.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// src/version.ts
+var MUSHI_CLI_VERSION = true ? "0.28.0" : "0.0.0-dev";
+var MUSHI_MCP_PIN_SPEC = "@mushi-mushi/mcp@0.22.0";
+
+export {
+  MUSHI_CLI_VERSION,
+  MUSHI_MCP_PIN_SPEC
+};

package/dist/connect-63GYZLFM.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  resolveSdkEnvKey,
+  runConnect
+} from "./chunk-FJETUM25.js";
+import "./chunk-UVO4A2G6.js";
+import "./chunk-KOBEOGNF.js";
+import "./chunk-LDPFTQLE.js";
+import "./chunk-PDX44BCA.js";
+export {
+  resolveSdkEnvKey,
+  runConnect
+};