@mushi-mushi/cli 0.18.2 → 0.19.0

package/dist/init.js

@@ -1,3 +1,13 @@
+import {
+  MUSHI_CLI_VERSION
+} from "./chunk-T4XX5FMH.js";
+import {
+  TEST_REPORT_FETCH_TIMEOUT_MS,
+  loadConfig,
+  normalizeEndpoint,
+  resolveCloudEndpoint,
+  saveConfig
+} from "./chunk-XEXYGDQV.js";
 import {
   FRAMEWORKS,
   detectFramework,
@@ -6,9 +16,6 @@ import {
   installCommand,
   readPackageJson
 } from "./chunk-7Q44KWGN.js";
-import {
-  MUSHI_CLI_VERSION
-} from "./chunk-E4IZPV6D.js";
 
 // src/init.ts
 import * as p from "@clack/prompts";
@@ -17,117 +24,191 @@ import { randomUUID } from "crypto";
 import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
 
-// src/config.ts
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
-import { homedir } from "os";
+// src/console-url.ts
+import { existsSync, readFileSync } from "fs";
 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 {
+var HOSTED_CONSOLE_BASE = "https://kensaur.us/mushi-mushi/admin";
+var LOCAL_ADMIN_URL = "http://localhost:6464";
+var LOCAL_PROBE_MS = 800;
+function normalizeConsoleBase(url) {
+  return url.trim().replace(/\/+$/, "");
+}
+function consoleUrl(base, route) {
+  const normalizedRoute = route.startsWith("/") ? route : `/${route}`;
+  return `${normalizeConsoleBase(base)}${normalizedRoute}`;
+}
+function resolveConsoleUrlFromEnv() {
+  const raw = process.env["MUSHI_CONSOLE_URL"]?.trim();
+  return raw ? normalizeConsoleBase(raw) : void 0;
+}
+function isInsideMushiMonorepo(cwd) {
+  let dir = cwd;
+  for (let depth = 0; depth < 14; depth += 1) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "mushi-mushi") return true;
+      } 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 } : {}
-  };
-  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);
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
-  writeFileSync(path, JSON.stringify(config, null, 2), { mode: SECURE_FILE_MODE });
-  tightenPermissions(path);
+  return false;
 }
-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 });
-  }
+async function probeLocalAdminConsole() {
   try {
-    renameSync(legacyPath, destPath);
-  } catch {
-    writeFileSync(destPath, JSON.stringify(parsed, null, 2), { mode: SECURE_FILE_MODE });
-    try {
-      unlinkSync(legacyPath);
-    } catch {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), LOCAL_PROBE_MS);
+    const res = await fetch(LOCAL_ADMIN_URL, {
+      signal: controller.signal,
+      method: "HEAD"
+    });
+    clearTimeout(timer);
+    if (res.ok || res.status === 404 || res.status === 401) {
+      return LOCAL_ADMIN_URL;
     }
-  }
-  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 {
   }
+  return null;
 }
-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 {
-  }
+function resolveConsoleUrlSync(cwd = process.cwd()) {
+  const fromEnv = resolveConsoleUrlFromEnv();
+  if (fromEnv) return fromEnv;
+  const config = loadConfig();
+  if (config.consoleUrl) return normalizeConsoleBase(config.consoleUrl);
+  if (isInsideMushiMonorepo(cwd)) return LOCAL_ADMIN_URL;
+  return HOSTED_CONSOLE_BASE;
 }
-
-// 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();
+async function resolveConsoleUrl(options) {
+  const fromEnv = resolveConsoleUrlFromEnv();
   if (fromEnv) return fromEnv;
-  return CLOUD_API_ENDPOINT;
+  const config = loadConfig();
+  if (config.consoleUrl) return normalizeConsoleBase(config.consoleUrl);
+  const local = await probeLocalAdminConsole();
+  if (local) return local;
+  const cwd = options?.cwd ?? process.cwd();
+  if (isInsideMushiMonorepo(cwd)) return LOCAL_ADMIN_URL;
+  return HOSTED_CONSOLE_BASE;
+}
+function projectIdHint(base) {
+  return `Where to find it: ${consoleUrl(base, "/projects")} \u2192 select your project \u2192 click the UUID chip to copy (or copy it from the panel right after you create the project).`;
+}
+function apiKeyHint(base) {
+  return `Where to find it: ${consoleUrl(base, "/onboarding?tab=verify")} \u2192 Generate API key (SDK ingest needs report:write \u2014 not Settings \u2192 BYOK keys). Treat it like a password \u2014 env file only, never commit.`;
+}
+function cliSetupDeepLink(base) {
+  return consoleUrl(base, "/onboarding?tab=steps&setup=cli");
+}
+function reportsUrl(base, reportId) {
+  return reportId ? consoleUrl(base, `/reports/${reportId}`) : consoleUrl(base, "/reports");
+}
+async function openInBrowser(url) {
+  const { exec } = await import("child_process");
+  const openCmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+  await new Promise((resolve2) => {
+    exec(openCmd, () => resolve2());
+  });
 }
-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"
-    );
+
+// src/signals.ts
+var activeController = null;
+function getAbortSignal(external) {
+  if (external) return external.signal;
+  if (!activeController || activeController.signal.aborted) {
+    activeController = new AbortController();
+  }
+  return activeController.signal;
+}
+
+// src/cli-shared.ts
+var API_TIMEOUT_MS = 15e3;
+async function apiCall(path, config, options = {}) {
+  const endpoint = config.endpoint;
+  if (!endpoint) {
+    return {
+      ok: false,
+      error: {
+        code: "NO_ENDPOINT",
+        message: "No API endpoint configured.\n  Run: mushi login --api-key <key> --endpoint <url> --project-id <id>\n  Or:  export MUSHI_API_ENDPOINT=https://<project-ref>.supabase.co/functions/v1/api"
+      }
+    };
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+  const signals = [controller.signal, getAbortSignal()];
+  const compositeSignal = AbortSignal.any ? AbortSignal.any(signals) : controller.signal;
+  try {
+    const res = await fetch(`${endpoint}${path}`, {
+      ...options,
+      signal: compositeSignal,
+      headers: {
+        "Content-Type": "application/json",
+        // `apiKeyAuth` reads X-Mushi-Api-Key; the Authorization header is a
+        // fallback accepted by some older middleware. Both are sent.
+        "Authorization": `Bearer ${config.apiKey ?? ""}`,
+        "X-Mushi-Api-Key": config.apiKey ?? "",
+        "X-Mushi-Project": config.projectId ?? "",
+        "X-Mushi-Cli-Version": MUSHI_CLI_VERSION,
+        ...options.headers
+      }
+    });
+    clearTimeout(timer);
+    let body;
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      try {
+        body = await res.json();
+      } catch {
+        body = null;
+      }
+    } else {
+      const text2 = await res.text();
+      try {
+        body = JSON.parse(text2);
+      } catch {
+        body = {
+          ok: false,
+          error: {
+            code: `HTTP_${res.status}`,
+            message: text2.trim().slice(0, 300) || `HTTP ${res.status}`
+          }
+        };
+      }
+    }
+    if (!res.ok && typeof body === "object" && body !== null && !("ok" in body)) {
+      const b = body;
+      return {
+        ok: false,
+        httpStatus: res.status,
+        error: {
+          code: b["code"] ?? `HTTP_${res.status}`,
+          message: b["message"] ?? `Request failed (${res.status})`
+        }
+      };
+    }
+    return body;
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      return {
+        ok: false,
+        error: {
+          code: "TIMEOUT",
+          message: `Request timed out after ${API_TIMEOUT_MS / 1e3}s. Check your network or endpoint.`
+        }
+      };
+    }
+    return {
+      ok: false,
+      error: {
+        code: "NETWORK_ERROR",
+        message: err instanceof Error ? err.message : String(err)
+      }
+    };
   }
-  let end = url.length;
-  while (end > 0 && url.charCodeAt(end - 1) === 47) end--;
-  return url.slice(0, end);
 }
 
 // src/freshness.ts
@@ -190,7 +271,7 @@ function parse(version) {
 }
 
 // src/monorepo.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
 import { dirname as dirname2, join as join2, resolve } from "path";
 var WORKSPACE_GLOB_CANDIDATES = ["apps/*", "packages/*", "examples/*"];
 var FRAMEWORK_DEPS = {
@@ -269,7 +350,7 @@ function readPackageJsonSafely(path) {
 }
 function isFileSafe(path) {
   try {
-    return existsSync2(path) && statSync2(path).isFile();
+    return existsSync2(path) && statSync(path).isFile();
   } catch {
     return false;
   }
@@ -310,7 +391,10 @@ async function runInit(options = {}) {
   }
   const detected = detectFramework(cwd, pkg);
   const framework = await chooseFramework(detected, options);
-  const credentials = await collectCredentials(options);
+  const consoleBase = await resolveConsoleUrl({ cwd });
+  await maybeGuideConsoleSetup(options, consoleBase);
+  const credentials = await collectCredentials(options, consoleBase);
+  await verifyCredentials(credentials, options, consoleBase);
   const pm = detectPackageManager(cwd);
   const packagesToInstall = framework.needsWebPackage ? [framework.packageName, "@mushi-mushi/web"] : [framework.packageName];
   if (!options.skipInstall) {
@@ -322,8 +406,9 @@ async function runInit(options = {}) {
   writeEnvFile(cwd, credentials.apiKey, credentials.projectId, framework);
   persistCliConfig(credentials.apiKey, credentials.projectId, endpoint);
   const enableRewards = await maybeEnableRewards(options);
-  printNextSteps(framework, credentials.apiKey, credentials.projectId, enableRewards);
-  await maybeSendTestReport(credentials, { ...options, endpoint });
+  printNextSteps(framework, consoleBase, enableRewards);
+  await maybeSendTestReport(credentials, { ...options, endpoint, consoleBase });
+  await maybeOfferConnect(credentials, options, consoleBase);
   p.outro("Setup complete. Happy bug squashing \u{1F41B}");
 }
 function ensureInteractiveOrBailOut(options) {
@@ -364,25 +449,93 @@ async function chooseFramework(detected, options) {
   }
   return FRAMEWORKS[confirmed];
 }
-async function collectCredentials(options) {
+async function maybeGuideConsoleSetup(options, consoleBase) {
+  if (options.yes) return;
+  if (options.projectId && options.apiKey) return;
+  const existing = loadConfig();
+  if (existing.projectId && existing.apiKey) return;
+  const choice = await p.select({
+    message: "Do you already have a Mushi project?",
+    options: [
+      {
+        value: "create",
+        label: "No \u2014 open the console to create one",
+        hint: "Recommended for first-time setup"
+      },
+      {
+        value: "have",
+        label: "Yes \u2014 I have Project ID + API key",
+        hint: "Paste values from the admin console"
+      },
+      {
+        value: "login",
+        label: "Use mushi login first",
+        hint: "Run `mushi login` in another terminal, then re-run this wizard"
+      }
+    ]
+  });
+  if (p.isCancel(choice)) {
+    p.cancel("Aborted.");
+    process.exit(0);
+  }
+  if (choice === "login") {
+    p.log.info("Run `mushi login` to save credentials, then re-run `mushi init`.");
+    p.cancel("Aborted.");
+    process.exit(0);
+  }
+  if (choice !== "create") return;
+  const setupUrl = cliSetupDeepLink(consoleBase);
+  p.log.info(`Opening the Mushi console:
+  ${setupUrl}`);
+  await openInBrowser(setupUrl);
+  p.log.message("In the console:");
+  p.log.message("  1. Enter a project name and click Create");
+  p.log.message("  2. Copy the Project ID from the success panel");
+  p.log.message("  3. Generate an API key (Verify tab \u2014 report:write scope)");
+  p.log.message("  4. Return here and paste both values");
+  const ready = await p.confirm({
+    message: "Created your project and ready to paste credentials?",
+    initialValue: false
+  });
+  if (p.isCancel(ready) || !ready) {
+    p.log.warn(`Finish in the console first: ${setupUrl}`);
+  }
+}
+async function collectCredentials(options, consoleBase) {
   const existing = loadConfig();
+  if (!options.projectId && !options.apiKey && existing.projectId && existing.apiKey) {
+    const reuse = options.yes ? true : await p.confirm({
+      message: "Use Project ID + API key from ~/.config/mushi/config.json?",
+      initialValue: true
+    });
+    if (p.isCancel(reuse)) {
+      p.cancel("Aborted.");
+      process.exit(0);
+    }
+    if (reuse) {
+      return {
+        projectId: sanitizeSecret(existing.projectId),
+        apiKey: sanitizeSecret(existing.apiKey)
+      };
+    }
+  }
   const rawProjectId = options.projectId ?? existing.projectId ?? await promptText({
     message: "Project ID",
     placeholder: "e.g. bdafa28d-b153-482f-bd4f-42981f3fd3a4",
-    hint: "Where to find it: https://kensaur.us/mushi-mushi/projects \u2192 click your project \u2192 copy the UUID below the project name.",
-    validate: (v) => PROJECT_ID_PATTERN.test(v.trim()) ? void 0 : "Expected a UUID (e.g. bdafa28d-b153-482f-bd4f-42981f3fd3a4) \u2014 copy it from the Mushi admin console Projects page."
+    hint: projectIdHint(consoleBase),
+    validate: (v) => PROJECT_ID_PATTERN.test(v.trim()) ? void 0 : "Expected a UUID \u2014 copy it from the Projects page or the panel right after you create a project."
   });
   const rawApiKey = options.apiKey ?? existing.apiKey ?? await promptText({
     message: "API key",
     placeholder: "mushi_xxxxxxxxxxxx",
-    hint: "Where to find it: https://kensaur.us/mushi-mushi/settings \u2192 API Keys tab. Treat it like a password \u2014 env file only, never commit it.",
+    hint: apiKeyHint(consoleBase),
     validate: (v) => API_KEY_PATTERN.test(v) ? void 0 : "Expected format: mushi_ followed by 10+ alphanumeric characters"
   });
   const projectId = sanitizeSecret(rawProjectId);
   const apiKey = sanitizeSecret(rawApiKey);
   if (!PROJECT_ID_PATTERN.test(projectId)) {
     throw new Error(
-      `Invalid project ID. Expected a UUID (e.g. bdafa28d-b153-482f-bd4f-42981f3fd3a4) or the proj_* prefixed form. Got: ${redact(projectId)} \u2014 copy it from the Projects page in the Mushi console at https://kensaur.us/mushi-mushi/projects`
+      `Invalid project ID. Expected a UUID (e.g. bdafa28d-b153-482f-bd4f-42981f3fd3a4) or the proj_* prefixed form. Got: ${redact(projectId)} \u2014 copy it from ${projectIdHint(consoleBase)}`
     );
   }
   if (!API_KEY_PATTERN.test(apiKey)) {
@@ -392,6 +545,23 @@ async function collectCredentials(options) {
   }
   return { projectId, apiKey };
 }
+async function verifyCredentials(credentials, options, consoleBase) {
+  const endpoint = resolveCloudEndpoint(options.endpoint);
+  const spinner2 = p.spinner();
+  spinner2.start("Verifying credentials\u2026");
+  const result = await apiCall(
+    "/v1/sync/whoami",
+    { apiKey: credentials.apiKey, projectId: credentials.projectId, endpoint }
+  );
+  if (!result.ok) {
+    spinner2.stop("Credentials could not be verified.");
+    p.log.error(result.error?.message ?? "Authentication failed.");
+    p.log.info(`Double-check values in the console:
+  ${cliSetupDeepLink(consoleBase)}`);
+    throw new Error("Credential verification failed \u2014 fix Project ID / API key and re-run.");
+  }
+  spinner2.stop(`Connected to ${result.data.project_name}`);
+}
 function sanitizeSecret(raw) {
   return raw.trim().replace(/^['"]|['"]$/g, "").replace(/[\r\n\0]/g, "");
 }
@@ -501,7 +671,7 @@ function persistCliConfig(apiKey, projectId, endpoint) {
   const existing = loadConfig();
   saveConfig({ ...existing, apiKey, projectId, endpoint });
 }
-function printNextSteps(framework, _apiKey, _projectId, enableRewards = false) {
+function printNextSteps(framework, consoleBase, enableRewards = false) {
   p.note(framework.snippet(), "Add this to your app:");
   if (enableRewards) {
     const badgeSnippet = framework.id === "react" ? `// Add to your user menu or profile UI:
@@ -512,13 +682,44 @@ import { MushiRewardsBadge } from '@mushi-mushi/react';
 // import { MushiRewardsBadge } from '@mushi-mushi/react';
 // <MushiRewardsBadge showPoints />`;
     p.note(badgeSnippet, "Rewards badge snippet:");
-    p.log.info("Enable rewards in your project settings at https://kensaur.us/mushi-mushi/rewards");
+    p.log.info(`Enable rewards in your project settings at ${consoleUrl(consoleBase, "/rewards")}`);
     p.log.info("Users will earn points for bug reports, screen navigation, and app activity.");
   }
   p.log.message("Verify the install:");
   p.log.message("  \u2022 Start your dev server");
   p.log.message("  \u2022 Look for the \u{1F41B} button in the bottom-right corner (or shake on mobile)");
-  p.log.message("  \u2022 Submit a test report \u2014 it should appear at https://kensaur.us/mushi-mushi/reports");
+  p.log.message(`  \u2022 Submit a test report \u2014 it should appear at ${reportsUrl(consoleBase)}`);
+  p.log.info(
+    "Tip: `mushi connect --write-env --wire-ide --wait` also wires Cursor MCP and waits for SDK heartbeat."
+  );
+}
+async function maybeOfferConnect(credentials, options, _consoleBase) {
+  if (options.yes) return;
+  const answer = await p.confirm({
+    message: "Run `mushi connect --write-env --wire-ide --wait` now? (SDK env + Cursor MCP + heartbeat check)",
+    initialValue: false
+  });
+  if (p.isCancel(answer) || !answer) return;
+  const endpoint = resolveCloudEndpoint(options.endpoint);
+  try {
+    const { runConnect } = await import("./connect-IC7I76Z2.js");
+    await runConnect({
+      apiKey: credentials.apiKey,
+      projectId: credentials.projectId,
+      endpoint,
+      cwd: options.cwd,
+      writeEnv: true,
+      wireIde: true,
+      wait: true
+    });
+  } catch (err) {
+    p.log.warn(
+      err instanceof Error ? err.message : String(err)
+    );
+    p.log.info(
+      "You can run manually: mushi connect --write-env --wire-ide --wait"
+    );
+  }
 }
 async function maybeEnableRewards(options) {
   if (options.yes) return false;
@@ -589,8 +790,8 @@ async function maybeSendTestReport(credentials, options) {
       reportId = body.data?.reportId;
     } catch {
     }
-    const reportPath = reportId ? `/reports/${reportId}` : "/reports";
-    p.log.success(`View it at https://kensaur.us/mushi-mushi/admin${reportPath}`);
+    const consoleBase = options.consoleBase ?? resolveConsoleUrlSync(options.cwd);
+    p.log.success(`View it at ${reportsUrl(consoleBase, reportId)}`);
   } catch (err) {
     const aborted = err instanceof Error && err.name === "AbortError";
     spinner2.stop(aborted ? "Timed out reaching the Mushi API." : "Could not reach the Mushi API.");

package/dist/version.js

@@ -1,6 +1,6 @@
 import {
   MUSHI_CLI_VERSION
-} from "./chunk-E4IZPV6D.js";
+} from "./chunk-T4XX5FMH.js";
 export {
   MUSHI_CLI_VERSION
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mushi-mushi/cli",
-  "version": "0.18.2",
+  "version": "0.19.0",
   "license": "MIT",
   "description": "CLI for Mushi Mushi — `mushi init` wizard installs the right SDK for your framework, plus report triage and pipeline health commands",
   "bin": {