@mushi-mushi/cli 0.19.0 → 0.21.0

package/dist/init.js

@@ -1,6 +1,6 @@
 import {
   MUSHI_CLI_VERSION
-} from "./chunk-T4XX5FMH.js";
+} from "./chunk-L7KBJ2XY.js";
 import {
   TEST_REPORT_FETCH_TIMEOUT_MS,
   loadConfig,
@@ -15,13 +15,13 @@ import {
   envVarsToWrite,
   installCommand,
   readPackageJson
-} from "./chunk-7Q44KWGN.js";
+} from "./chunk-JAUKBLPK.js";
 
 // src/init.ts
 import * as p from "@clack/prompts";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { join as join3 } from "path";
 
 // src/console-url.ts
@@ -31,7 +31,10 @@ 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(/\/+$/, "");
+  const trimmed = url.trim();
+  let end = trimmed.length;
+  while (end > 0 && trimmed.charCodeAt(end - 1) === 47) end--;
+  return trimmed.slice(0, end);
 }
 function consoleUrl(base, route) {
   const normalizedRoute = route.startsWith("/") ? route : `/${route}`;
@@ -106,10 +109,34 @@ 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}"`;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return;
+  }
+  const safeUrl = parsed.toString();
+  const { spawn: spawn2 } = await import("child_process");
+  const [command, args] = process.platform === "win32" ? (
+    // Open via rundll32's FileProtocolHandler rather than `cmd /c start`.
+    // `start` is a cmd builtin, so the URL would be re-parsed by cmd.exe and
+    // characters like `&` / `|` / `^` could still break out — exactly the
+    // injection surface CodeQL flags. rundll32 never invokes a shell: the URL
+    // is handed to the default browser as one opaque argument.
+    ["rundll32", ["url.dll,FileProtocolHandler", safeUrl]]
+  ) : process.platform === "darwin" ? ["open", [safeUrl]] : ["xdg-open", [safeUrl]];
   await new Promise((resolve2) => {
-    exec(openCmd, () => resolve2());
+    try {
+      const child = spawn2(command, [...args], { stdio: "ignore", shell: false });
+      child.on("error", () => resolve2());
+      child.on("exit", () => resolve2());
+      child.unref();
+    } catch {
+      resolve2();
+    }
   });
 }
 
@@ -180,13 +207,13 @@ async function apiCall(path, config, options = {}) {
     }
     if (!res.ok && typeof body === "object" && body !== null && !("ok" in body)) {
       const b = body;
+      const nested = b["error"];
+      const errCode = nested?.["code"] ?? b["code"] ?? `HTTP_${res.status}`;
+      const errMsg = nested?.["message"] ?? b["message"] ?? `Request failed (${res.status})`;
       return {
         ok: false,
         httpStatus: res.status,
-        error: {
-          code: b["code"] ?? `HTTP_${res.status}`,
-          message: b["message"] ?? `Request failed (${res.status})`
-        }
+        error: { code: errCode, message: errMsg }
       };
     }
     return body;
@@ -211,6 +238,151 @@ async function apiCall(path, config, options = {}) {
   }
 }
 
+// src/device-auth.ts
+var DEVICE_FETCH_TIMEOUT_MS = 15e3;
+function trimTrailingSlash(endpoint) {
+  let end = endpoint.length;
+  while (end > 0 && endpoint.charCodeAt(end - 1) === 47) end--;
+  return endpoint.slice(0, end);
+}
+async function deviceFetch(url, init = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DEVICE_FETCH_TIMEOUT_MS);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function startDeviceAuth(endpoint) {
+  const base = trimTrailingSlash(endpoint);
+  const res = await deviceFetch(`${base}/v1/cli/auth/device/start`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" }
+  });
+  const json = await res.json().catch(() => null);
+  if (!res.ok || !json?.ok || !json.data) {
+    throw new Error(json?.error?.message ?? `Could not start browser sign-in (HTTP ${res.status}).`);
+  }
+  return json.data;
+}
+async function pollDeviceToken(endpoint, deviceCode) {
+  const base = trimTrailingSlash(endpoint);
+  try {
+    const res = await deviceFetch(`${base}/v1/cli/auth/device/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ device_code: deviceCode })
+    });
+    const json = await res.json().catch(() => ({}));
+    if (res.ok && json.ok && json.data?.cli_token) {
+      return { status: "approved", cliToken: json.data.cli_token, userId: json.data.user_id };
+    }
+    switch (json.error) {
+      case "authorization_pending":
+        return { status: "pending" };
+      case "access_denied":
+        return { status: "denied" };
+      case "expired_token":
+        return { status: "expired" };
+      default:
+        return {
+          status: "error",
+          message: json.error_description ?? json.error ?? `HTTP ${res.status}`,
+          // 5xx is a server hiccup the next poll may clear; a 4xx is a definitive
+          // rejection (already claimed / invalid_grant) that won't fix itself.
+          retryable: res.status >= 500
+        };
+    }
+  } catch (err) {
+    return { status: "error", message: err instanceof Error ? err.message : String(err), retryable: true };
+  }
+}
+var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitForCliToken(endpoint, session, opts = {}) {
+  const sleep = opts.sleep ?? defaultSleep;
+  const now = opts.now ?? Date.now;
+  const intervalMs = (session.interval || 5) * 1e3;
+  const deadline = now() + (session.expires_in || 600) * 1e3;
+  const maxConsecutiveErrors = opts.maxConsecutiveErrors ?? 5;
+  let consecutiveErrors = 0;
+  let firstPoll = true;
+  while (now() < deadline) {
+    if (!firstPoll) {
+      await sleep(intervalMs);
+    }
+    firstPoll = false;
+    const outcome = await pollDeviceToken(endpoint, session.device_code);
+    switch (outcome.status) {
+      case "approved":
+        return outcome.cliToken;
+      case "pending":
+        consecutiveErrors = 0;
+        opts.onPending?.();
+        continue;
+      case "denied":
+        throw new Error("Login was denied in the browser.");
+      case "expired":
+        throw new Error("The login code expired. Run sign-in again.");
+      case "error":
+        if (!outcome.retryable) {
+          throw new Error(outcome.message);
+        }
+        consecutiveErrors += 1;
+        if (consecutiveErrors >= maxConsecutiveErrors) {
+          throw new Error(outcome.message);
+        }
+        opts.onTransientError?.(outcome.message, consecutiveErrors);
+        continue;
+    }
+  }
+  throw new Error("Login timed out before approval. Run sign-in again.");
+}
+function cliAuthHeaders(cliToken) {
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${cliToken}`
+  };
+}
+async function listProjects(endpoint, cliToken) {
+  const base = trimTrailingSlash(endpoint);
+  try {
+    const res = await deviceFetch(`${base}/v1/cli/projects`, { headers: cliAuthHeaders(cliToken) });
+    const json = await res.json().catch(() => null);
+    if (res.ok && json?.ok) return json.data?.projects ?? [];
+  } catch {
+  }
+  return [];
+}
+async function createProject(endpoint, cliToken, name) {
+  const base = trimTrailingSlash(endpoint);
+  const res = await deviceFetch(`${base}/v1/cli/projects`, {
+    method: "POST",
+    headers: cliAuthHeaders(cliToken),
+    body: JSON.stringify({ name })
+  });
+  const json = await res.json().catch(() => null);
+  if (!res.ok || !json?.ok || !json.data) {
+    throw new Error(json?.error?.message ?? `Could not create project (HTTP ${res.status}).`);
+  }
+  const { id, name: created, slug, apiKey } = json.data;
+  return { id, name: created, slug, apiKey: apiKey ?? null };
+}
+async function mintProjectKey(endpoint, cliToken, projectId) {
+  const base = trimTrailingSlash(endpoint);
+  try {
+    const res = await deviceFetch(`${base}/v1/cli/projects/${projectId}/keys`, {
+      method: "POST",
+      headers: cliAuthHeaders(cliToken),
+      body: JSON.stringify({})
+    });
+    const json = await res.json().catch(() => null);
+    if (res.ok && json?.ok) return json.data?.key ?? null;
+  } catch {
+  }
+  return null;
+}
+
 // src/freshness.ts
 var REGISTRY = "https://registry.npmjs.org";
 var DEFAULT_TIMEOUT_MS = 2e3;
@@ -367,6 +539,33 @@ function getFrameworkFromPkg(pkg) {
   return void 0;
 }
 
+// src/auth-ui.ts
+var LINE = "\u2500".repeat(58);
+function printAuthBanner(userCode, verificationUri) {
+  console.log("");
+  console.log(`  \u250C${LINE}\u2510`);
+  console.log(`  \u2502  Browser sign-in \u2014 follow these 3 steps              \u2502`);
+  console.log(`  \u251C${LINE}\u2524`);
+  console.log(`  \u2502                                                        \u2502`);
+  console.log(`  \u2502  1. A browser tab will open (or visit the URL below)  \u2502`);
+  console.log(`  \u2502  2. Sign in if prompted, then click "Approve"         \u2502`);
+  console.log(`  \u2502  3. Come back here \u2014 setup continues automatically    \u2502`);
+  console.log(`  \u2502                                                        \u2502`);
+  console.log(`  \u251C${LINE}\u2524`);
+  console.log(`  \u2502  Verification code (show in browser \u2014 NOT terminal):  \u2502`);
+  console.log(`  \u2502                                                        \u2502`);
+  console.log(`  \u2502    ${userCode.padEnd(52)}\u2502`);
+  console.log(`  \u2502                                                        \u2502`);
+  console.log(`  \u2502  \u26A0  Do NOT paste or type this code in your terminal   \u2502`);
+  console.log(`  \u2514${LINE}\u2518`);
+  console.log("");
+  console.log(`  If the browser didn't open, visit this URL and approve:`);
+  console.log(`    ${verificationUri}`);
+  console.log("");
+  console.log("  \u23F3 Waiting for browser approval\u2026 (Ctrl+C to cancel)");
+  console.log("");
+}
+
 // src/init.ts
 var ENV_FILES = [".env.local", ".env"];
 var PROJECT_ID_PATTERN = /^(?: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;
@@ -392,8 +591,8 @@ async function runInit(options = {}) {
   const detected = detectFramework(cwd, pkg);
   const framework = await chooseFramework(detected, options);
   const consoleBase = await resolveConsoleUrl({ cwd });
-  await maybeGuideConsoleSetup(options, consoleBase);
-  const credentials = await collectCredentials(options, consoleBase);
+  const endpoint = resolveCloudEndpoint(options.endpoint);
+  const credentials = await acquireCredentials(options, consoleBase, endpoint);
   await verifyCredentials(credentials, options, consoleBase);
   const pm = detectPackageManager(cwd);
   const packagesToInstall = framework.needsWebPackage ? [framework.packageName, "@mushi-mushi/web"] : [framework.packageName];
@@ -402,8 +601,7 @@ async function runInit(options = {}) {
   } else {
     p.log.info(`Skipped install. Run \`${installCommand(pm, packagesToInstall)}\` yourself.`);
   }
-  const endpoint = resolveCloudEndpoint(options.endpoint);
-  writeEnvFile(cwd, credentials.apiKey, credentials.projectId, framework);
+  await writeEnvFile(cwd, credentials.apiKey, credentials.projectId, framework, endpoint, Boolean(options.yes));
   persistCliConfig(credentials.apiKey, credentials.projectId, endpoint);
   const enableRewards = await maybeEnableRewards(options);
   printNextSteps(framework, consoleBase, enableRewards);
@@ -449,63 +647,17 @@ async function chooseFramework(detected, options) {
   }
   return FRAMEWORKS[confirmed];
 }
-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 acquireCredentials(options, consoleBase, endpoint) {
+  if (options.projectId && options.apiKey) {
+    return {
+      projectId: sanitizeSecret(options.projectId),
+      apiKey: sanitizeSecret(options.apiKey)
+    };
   }
-}
-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?",
+      message: "Use the Mushi credentials saved from your last sign-in?",
       initialValue: true
     });
     if (p.isCancel(reuse)) {
@@ -519,6 +671,144 @@ async function collectCredentials(options, consoleBase) {
       };
     }
   }
+  if (options.yes) {
+    const creds = await runBrowserSignIn(options, endpoint, consoleBase);
+    if (creds) return creds;
+    p.log.warn("Browser sign-in didn't complete \u2014 switching to manual entry.");
+  } else {
+    const method = await p.select({
+      message: "Connect this app to Mushi",
+      initialValue: "browser",
+      options: [
+        {
+          value: "browser",
+          label: "Sign in with your browser",
+          hint: "Recommended \u2014 no copy-paste, creates the project + key for you"
+        },
+        {
+          value: "manual",
+          label: "Paste a Project ID + API key",
+          hint: "Self-hosted or expert setup \u2014 run npx mushi-mushi (not mushi setup)"
+        }
+      ]
+    });
+    if (p.isCancel(method)) {
+      p.cancel("Aborted.");
+      process.exit(0);
+    }
+    if (method === "browser") {
+      const creds = await runBrowserSignIn(options, endpoint, consoleBase);
+      if (creds) return creds;
+      p.log.warn("Browser sign-in didn't complete \u2014 switching to manual entry.");
+    }
+  }
+  return collectCredentialsManually(options, consoleBase);
+}
+async function runBrowserSignIn(options, endpoint, consoleBase) {
+  const startSpin = p.spinner();
+  startSpin.start("Starting secure browser sign-in\u2026");
+  let session;
+  try {
+    session = await startDeviceAuth(endpoint);
+  } catch (err) {
+    startSpin.stop("Could not start browser sign-in.");
+    p.log.warn(err instanceof Error ? err.message : String(err));
+    return null;
+  }
+  startSpin.stop("Browser sign-in ready.");
+  try {
+    await openInBrowser(session.verification_uri);
+  } catch {
+  }
+  printAuthBanner(session.user_code, session.verification_uri);
+  const waitSpin = p.spinner();
+  waitSpin.start("Waiting for you to approve in the browser\u2026");
+  let cliToken;
+  try {
+    cliToken = await waitForCliToken(endpoint, session);
+  } catch (err) {
+    waitSpin.stop("Browser sign-in didn't complete.");
+    p.log.warn(err instanceof Error ? err.message : String(err));
+    return null;
+  }
+  waitSpin.stop("Approved.");
+  let projectId = options.projectId ? sanitizeSecret(options.projectId) : void 0;
+  let apiKey;
+  if (!projectId) {
+    let projects = [];
+    const fetchSpin = p.spinner();
+    fetchSpin.start("Loading your projects\u2026");
+    try {
+      projects = await listProjects(endpoint, cliToken);
+      fetchSpin.stop(projects.length > 0 ? `Found ${projects.length} project(s).` : "No projects yet.");
+    } catch (err) {
+      fetchSpin.stop("Could not load projects \u2014 you can still create a new one.");
+      p.log.warn(err instanceof Error ? err.message : String(err));
+    }
+    const NEW = "__new__";
+    const choice = await p.select({
+      message: "Choose a project",
+      initialValue: projects[0]?.id ?? NEW,
+      options: [
+        ...projects.map((pr) => ({ value: pr.id, label: pr.name, hint: pr.id.slice(0, 8) })),
+        { value: NEW, label: "Create a new project", hint: "mints an SDK key automatically" }
+      ]
+    });
+    if (p.isCancel(choice)) {
+      p.cancel("Aborted.");
+      process.exit(0);
+    }
+    if (choice === NEW) {
+      const name = await p.text({
+        message: "Project name",
+        placeholder: "My app",
+        validate: (v) => v && v.trim().length > 0 ? void 0 : "Required"
+      });
+      if (p.isCancel(name)) {
+        p.cancel("Aborted.");
+        process.exit(0);
+      }
+      const createSpin = p.spinner();
+      createSpin.start(`Creating "${name.trim()}"\u2026`);
+      try {
+        const created = await createProject(endpoint, cliToken, name.trim());
+        projectId = created.id;
+        apiKey = created.apiKey ?? void 0;
+        createSpin.stop(`Created project "${created.name}".`);
+      } catch (err) {
+        createSpin.stop("Could not create the project.");
+        p.log.warn(err instanceof Error ? err.message : String(err));
+        return null;
+      }
+    } else {
+      projectId = choice;
+    }
+  }
+  if (projectId && !apiKey) {
+    const keySpin = p.spinner();
+    keySpin.start("Minting SDK key\u2026");
+    try {
+      const minted = await mintProjectKey(endpoint, cliToken, projectId);
+      apiKey = minted ?? void 0;
+      if (!apiKey) {
+        keySpin.stop("Could not mint an API key.");
+        p.log.warn(
+          `Open the console Verify tab to generate a key manually: ${consoleUrl(consoleBase, "/onboarding?tab=verify")}`
+        );
+        return null;
+      }
+      keySpin.stop("SDK key ready.");
+    } catch (err) {
+      keySpin.stop("Could not mint an API key.");
+      p.log.warn(err instanceof Error ? err.message : String(err));
+      return null;
+    }
+  }
+  if (!projectId || !apiKey) return null;
+  return { apiKey, projectId };
+}
+async function collectCredentialsManually(options, consoleBase) {
+  const existing = loadConfig();
   const rawProjectId = options.projectId ?? existing.projectId ?? await promptText({
     message: "Project ID",
     placeholder: "e.g. bdafa28d-b153-482f-bd4f-42981f3fd3a4",
@@ -618,13 +908,37 @@ function runCommand(pm, packages, cwd) {
     });
   });
 }
-function writeEnvFile(cwd, apiKey, projectId, framework) {
+async function writeEnvFile(cwd, apiKey, projectId, framework, endpoint, overwrite) {
   const target = ENV_FILES.find((f) => existsSync3(join3(cwd, f))) ?? ENV_FILES[0];
   const targetPath = join3(cwd, target);
-  const newVars = envVarsToWrite(apiKey, projectId, framework);
+  const newVars = envVarsToWrite(apiKey, projectId, framework, endpoint);
   const existing = existsSync3(targetPath) ? readFileSync3(targetPath, "utf-8") : "";
   if (existing.includes("MUSHI_PROJECT_ID")) {
-    p.log.warn(`Existing MUSHI_* vars found in ${target} \u2014 leaving them untouched.`);
+    let shouldOverwrite = overwrite;
+    if (!shouldOverwrite) {
+      const answer = await p.confirm({
+        message: `Existing MUSHI_* vars found in ${target}. Update with new credentials?`,
+        initialValue: true
+      });
+      if (p.isCancel(answer)) {
+        p.log.info(`Kept existing env vars in ${target}.`);
+        return;
+      }
+      shouldOverwrite = Boolean(answer);
+    }
+    if (!shouldOverwrite) {
+      p.log.info(`Kept existing env vars in ${target}. Re-run and confirm to overwrite.`);
+      return;
+    }
+    const MUSHI_LINE_RE = /^(NEXT_PUBLIC_|NUXT_PUBLIC_|VITE_|EXPO_PUBLIC_)?MUSHI_[A-Z_]+=.*/gm;
+    const stripped = existing.replace(MUSHI_LINE_RE, "").replace(/\n{3,}/g, "\n\n").trimEnd();
+    const prefix2 = stripped.length > 0 ? "\n" : "";
+    writeFileSync(targetPath, `${stripped}${prefix2}
+# Mushi Mushi
+${newVars}
+`);
+    p.log.success(`Updated MUSHI_* env vars in ${target}`);
+    warnIfMissingFromGitignore(cwd, target);
     return;
   }
   const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
@@ -685,12 +999,14 @@ import { MushiRewardsBadge } from '@mushi-mushi/react';
     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 ${reportsUrl(consoleBase)}`);
-  p.log.info(
-    "Tip: `mushi connect --write-env --wire-ide --wait` also wires Cursor MCP and waits for SDK heartbeat."
+  p.note(
+    [
+      "  [ ] 1. Paste the init snippet above into your app entry file",
+      "  [ ] 2. Start your dev server",
+      "  [ ] 3. Run: mushi connect --write-env --wire-ide --wait",
+      `  [ ] 4. Open the Verify tab to send a test report: ${consoleUrl(consoleBase, "/onboarding?tab=verify")}`
+    ].join("\n"),
+    "Next steps:"
   );
 }
 async function maybeOfferConnect(credentials, options, _consoleBase) {
@@ -702,7 +1018,7 @@ async function maybeOfferConnect(credentials, options, _consoleBase) {
   if (p.isCancel(answer) || !answer) return;
   const endpoint = resolveCloudEndpoint(options.endpoint);
   try {
-    const { runConnect } = await import("./connect-IC7I76Z2.js");
+    const { runConnect } = await import("./connect-2RM43XHO.js");
     await runConnect({
       apiKey: credentials.apiKey,
       projectId: credentials.projectId,

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mushi-mushi/cli",
-  "version": "0.19.0",
+  "version": "0.21.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": {
@@ -18,13 +18,13 @@
     "vitest": "^4.1.8",
     "@mushi-mushi/eslint-config": "0.0.0"
   },
-  "author": "Kenji Sakuramoto",
+  "author": "Kenji Sakuramoto (https://bsky.app/profile/mushimushi.dev)",
   "repository": {
     "type": "git",
     "url": "https://github.com/kensaurus/mushi-mushi.git",
     "directory": "packages/cli"
   },
-  "homepage": "https://github.com/kensaurus/mushi-mushi/tree/main/packages/cli#readme",
+  "homepage": "https://kensaur.us/mushi-mushi",
   "bugs": {
     "url": "https://github.com/kensaurus/mushi-mushi/issues"
   },

package/dist/chunk-T4XX5FMH.js

@@ -1,6 +0,0 @@
-// src/version.ts
-var MUSHI_CLI_VERSION = true ? "0.19.0" : "0.0.0-dev";
-
-export {
-  MUSHI_CLI_VERSION
-};