@mushi-mushi/cli 0.22.1 → 0.23.0

package/dist/{chunk-R2HPR2FV.js → chunk-GSQO35YD.js}

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {
+  CLOUD_API_ENDPOINT,
   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";
+import { join as join4, resolve } from "path";
 
 // src/config.ts
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
@@ -101,9 +102,386 @@ function tightenDirPermissions(path) {
   }
 }
 
+// src/version.ts
+var MUSHI_CLI_VERSION = true ? "0.23.0" : "0.0.0-dev";
+
+// src/errors.ts
+var EXIT_CODE_MAP = {
+  E_AUTH_MISSING: 2,
+  E_AUTH_INVALID: 2,
+  E_PROJECT_MISSING: 2,
+  E_ENDPOINT_INVALID: 2,
+  E_INVALID_INPUT: 2,
+  E_NOT_INTERACTIVE: 2,
+  E_NETWORK: 3,
+  E_TIMEOUT: 3,
+  E_API_ERROR: 3,
+  E_RATE_LIMITED: 3,
+  E_FILE_NOT_FOUND: 1,
+  E_FILE_PERMISSION: 1,
+  E_FRESHNESS_STALE: 1,
+  E_INTERRUPTED: 130,
+  // 128 + SIGINT (2). POSIX convention.
+  E_INTERNAL: 1
+};
+var MushiCliError = class extends Error {
+  code;
+  hint;
+  cause;
+  constructor(code, message, hint, cause) {
+    super(message);
+    this.name = "MushiCliError";
+    this.code = code;
+    if (hint) this.hint = hint;
+    if (cause !== void 0) this.cause = cause;
+  }
+  /** Exit code POSIX-aware shell scripts should branch on. */
+  get exitCode() {
+    return EXIT_CODE_MAP[this.code];
+  }
+  /**
+   * Format for `--json` output. Used by the JSON writer when a CLI
+   * subcommand was invoked with `--json` and an error escapes.
+   */
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        ...this.hint ? { hint: this.hint } : {}
+      }
+    };
+  }
+};
+function printAndExit(err, asJson = false) {
+  const cliErr = err instanceof MushiCliError ? err : new MushiCliError(
+    "E_INTERNAL",
+    err instanceof Error ? err.message : String(err),
+    "this is unexpected \u2014 re-run with MUSHI_DEBUG=1 and report at https://github.com/kensaurus/mushi-mushi/issues",
+    err
+  );
+  if (asJson) {
+    process.stderr.write(JSON.stringify(cliErr.toJSON()) + "\n");
+  } else {
+    process.stderr.write(`error [${cliErr.code}]: ${cliErr.message}
+`);
+    if (cliErr.hint) process.stderr.write(`  \u2192 fix: ${cliErr.hint}
+`);
+  }
+  if (process.env.MUSHI_CLI_JSON_LOG === "1" || process.env.CI === "true") {
+    process.stderr.write(
+      JSON.stringify({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "error",
+        scope: "mushi:cli",
+        ...cliErr.toJSON(),
+        exitCode: cliErr.exitCode
+      }) + "\n"
+    );
+  }
+  process.exit(cliErr.exitCode);
+}
+
+// src/signals.ts
+var installed = false;
+var activeController = null;
+function installSignalHandlers() {
+  if (installed) return;
+  installed = true;
+  const abortAndExit = (signal) => {
+    activeController?.abort(
+      new MushiCliError(
+        "E_INTERRUPTED",
+        `aborted by ${signal}`,
+        "partial state on the server is safe to retry \u2014 re-run the same command"
+      )
+    );
+    const code = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 1;
+    process.nextTick(() => {
+      process.exit(code);
+    });
+  };
+  process.on("SIGINT", () => abortAndExit("SIGINT"));
+  process.on("SIGTERM", () => abortAndExit("SIGTERM"));
+}
+function getAbortSignal(external) {
+  if (external) return external.signal;
+  if (!activeController || activeController.signal.aborted) {
+    activeController = new AbortController();
+  }
+  return activeController.signal;
+}
+
+// src/console-url.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+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) {
+  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}`;
+  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 = join2(dir, "package.json");
+    if (existsSync2(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        if (pkg.name === "mushi-mushi") return true;
+      } catch {
+      }
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+async function probeLocalAdminConsole() {
+  try {
+    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;
+    }
+  } catch {
+  }
+  return null;
+}
+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;
+}
+async function resolveConsoleUrl(options) {
+  const fromEnv = resolveConsoleUrlFromEnv();
+  if (fromEnv) return fromEnv;
+  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) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return;
+  }
+  const safeUrl = parsed.toString();
+  const { spawn } = 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) => {
+    try {
+      const child = spawn(command, [...args], { stdio: "ignore", shell: false });
+      child.on("error", () => resolve2());
+      child.on("exit", () => resolve2());
+      child.unref();
+    } catch {
+      resolve2();
+    }
+  });
+}
+
+// src/cli-shared.ts
+var UUID_RX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function requireUuid(value, label = "id") {
+  if (UUID_RX.test(value)) return value;
+  throw new MushiCliError(
+    "E_INVALID_INPUT",
+    `${label} must be a valid UUID`,
+    "copy the full id from `mushi reports list` or the console URL"
+  );
+}
+var API_TIMEOUT_MS = 15e3;
+async function probeEndpointHealth(endpoint) {
+  const t0 = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+  try {
+    const res = await fetch(`${endpoint}/health`, { signal: controller.signal });
+    clearTimeout(timer);
+    const body = res.headers.get("content-type")?.includes("json") ? await res.json().catch(() => ({})) : {};
+    return { ok: res.ok, status: res.status, latencyMs: Date.now() - t0, body };
+  } catch (err) {
+    clearTimeout(timer);
+    throw err;
+  }
+}
+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 text = await res.text();
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = {
+          ok: false,
+          error: {
+            code: `HTTP_${res.status}`,
+            message: text.trim().slice(0, 300) || `HTTP ${res.status}`
+          }
+        };
+      }
+    }
+    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: errCode, message: errMsg }
+      };
+    }
+    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)
+      }
+    };
+  }
+}
+function die(result, exitCode = 1) {
+  const { code, message } = result.error;
+  const status = result.httpStatus ? ` [${result.httpStatus}]` : "";
+  process.stderr.write(`error${status}: ${code} \u2014 ${message}
+`);
+  if (code === "INSUFFICIENT_SCOPE") {
+    process.stderr.write(
+      "\n  Your current API key does not have the required scope for this command.\n  New keys minted by the wizard already include both scopes. Existing keys\n  can be upgraded with:\n\n    mushi login --upgrade-scope\n\n  Or visit your console \u2192 Projects \u2192 API Keys to mint a new key.\n"
+    );
+  }
+  process.exit(exitCode);
+}
+function requireConfig(opts = {}) {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    printAndExit(new MushiCliError(
+      "E_AUTH_MISSING",
+      "API key not configured.",
+      "Run: mushi login --api-key <key>  Or: export MUSHI_API_KEY=<key>"
+    ));
+  }
+  if (!config.endpoint) {
+    config.endpoint = process.env.MUSHI_API_ENDPOINT?.trim() || CLOUD_API_ENDPOINT;
+  }
+  if (opts.needsProject && !config.projectId) {
+    printAndExit(new MushiCliError(
+      "E_PROJECT_MISSING",
+      "Project ID not configured.",
+      `Run: mushi login --project-id <uuid>  Or find your project ID at ${consoleUrl(resolveConsoleUrlSync(), "/projects")}`
+    ));
+  }
+  return config;
+}
+function fmtDate(iso) {
+  if (!iso) return "\u2014";
+  return new Date(iso).toLocaleString(void 0, { dateStyle: "short", timeStyle: "short" });
+}
+function pad(s, width) {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+
 // src/detect.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
 var FRAMEWORKS = {
   next: {
     id: "next",
@@ -141,6 +519,90 @@ createRoot(document.getElementById('root')!).render(
     <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",
@@ -355,10 +817,10 @@ Mushi.init({
   }
 };
 function readPackageJson(cwd) {
-  const path = join2(cwd, "package.json");
-  if (!existsSync2(path)) return null;
+  const path = join3(cwd, "package.json");
+  if (!existsSync3(path)) return null;
   try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync3(path, "utf-8"));
   } catch {
     return null;
   }
@@ -371,29 +833,41 @@ function detectFramework(cwd, pkg) {
   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 (existsSync2(join2(cwd, "next.config.js")) || existsSync2(join2(cwd, "next.config.ts"))) {
+  if (existsSync3(join3(cwd, "next.config.js")) || existsSync3(join3(cwd, "next.config.ts"))) {
     return FRAMEWORKS.next;
   }
-  if (existsSync2(join2(cwd, "nuxt.config.ts")) || existsSync2(join2(cwd, "nuxt.config.js"))) {
+  if (existsSync3(join3(cwd, "nuxt.config.ts")) || existsSync3(join3(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;
+  if (existsSync3(join3(cwd, "svelte.config.js"))) return FRAMEWORKS.svelte;
+  if (existsSync3(join3(cwd, "angular.json"))) return FRAMEWORKS.angular;
+  if (existsSync3(join3(cwd, "remix.config.js")) || existsSync3(join3(cwd, "remix.config.ts"))) {
+    return FRAMEWORKS.remix;
+  }
+  if (existsSync3(join3(cwd, "astro.config.mjs")) || existsSync3(join3(cwd, "astro.config.ts")) || existsSync3(join3(cwd, "astro.config.js"))) {
+    return FRAMEWORKS.astro;
+  }
   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";
+  if (existsSync3(join3(cwd, "bun.lockb")) || existsSync3(join3(cwd, "bun.lock"))) return "bun";
+  if (existsSync3(join3(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join3(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync3(join3(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";
@@ -415,7 +889,7 @@ function envVarsToWrite(apiKey, projectId, framework, endpoint) {
       endpointLine
     ].filter(Boolean).join("\n");
   }
-  if (framework.id === "react-native") {
+  if (framework.id === "react-native" || framework.id === "remix") {
     return [
       `MUSHI_PROJECT_ID=${projectId}`,
       `MUSHI_API_KEY=${apiKey}`,
@@ -429,7 +903,7 @@ function envVarsToWrite(apiKey, projectId, framework, endpoint) {
       endpointLine ? `EXPO_PUBLIC_${endpointLine}` : null
     ].filter(Boolean).join("\n");
   }
-  const prefix = framework.id === "next" ? "NEXT_PUBLIC_" : framework.id === "nuxt" ? "NUXT_PUBLIC_" : "VITE_";
+  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}`,
@@ -558,7 +1032,7 @@ async function waitForIngestReady(options) {
 
 // src/mcp-config.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 var DEFAULT_MUSHI_FEATURES = "triage,fixes,inventory,setup,docs";
 async function writeMcpServerEntry(opts) {
   const { configPath, serverName, serverBlock, dryRun = false } = opts;
@@ -580,7 +1054,7 @@ async function writeMcpServerEntry(opts) {
   merged.mcpServers = servers;
   const output = JSON.stringify(merged, null, 2) + "\n";
   if (!dryRun) {
-    await mkdir(dirname2(configPath), { recursive: true });
+    await mkdir(dirname3(configPath), { recursive: true });
     await writeFile(configPath, output, "utf8");
   }
   return { created, path: configPath };
@@ -637,7 +1111,7 @@ ${needs.join("\n")}
   return true;
 }
 async function ensureMcpJsonGitignored(cwd, messages) {
-  const gitignorePath = join3(cwd, ".gitignore");
+  const gitignorePath = join4(cwd, ".gitignore");
   const patterns = [".cursor/mcp.json", ".cursor/"];
   let content = null;
   try {
@@ -658,11 +1132,12 @@ async function ensureMcpJsonGitignored(cwd, messages) {
 async function runConnect(opts, baseConfig = {}) {
   const cwd = resolve(opts.cwd ?? process.cwd());
   const endpoint = assertEndpoint(opts.endpoint);
+  const projectId = requireUuid(opts.projectId, "projectId");
   const messages = [];
   const config = {
     ...baseConfig,
     apiKey: opts.apiKey,
-    projectId: opts.projectId,
+    projectId,
     endpoint
   };
   saveConfig(config);
@@ -671,8 +1146,8 @@ async function runConnect(opts, baseConfig = {}) {
   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 lines = envVarsToWrite(opts.apiKey, projectId, framework).split("\n");
+    envPath = join4(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)`
@@ -686,12 +1161,12 @@ async function runConnect(opts, baseConfig = {}) {
   }
   let mcpPath = null;
   if (opts.wireIde !== false) {
-    const mcpDir = join3(cwd, ".cursor");
-    mcpPath = join3(mcpDir, "mcp.json");
-    const serverName = buildMcpServerName({ projectId: opts.projectId });
+    const mcpDir = join4(cwd, ".cursor");
+    mcpPath = join4(mcpDir, "mcp.json");
+    const serverName = buildMcpServerName({ projectId });
     const serverBlock = buildMcpServerBlock({
       endpoint,
-      projectId: opts.projectId,
+      projectId,
       apiKey: opts.apiKey
     });
     await writeMcpServerEntry({ configPath: mcpPath, serverName, serverBlock });
@@ -706,7 +1181,7 @@ async function runConnect(opts, baseConfig = {}) {
     heartbeat = await waitForIngestReady({
       endpoint,
       apiKey: opts.apiKey,
-      projectId: opts.projectId,
+      projectId,
       maxAttempts,
       onPoll: (payload, attempt) => {
         if (!opts.json && attempt % 3 === 0) {
@@ -735,6 +1210,9 @@ async function runConnect(opts, baseConfig = {}) {
 }
 
 export {
+  printAndExit,
+  installSignalHandlers,
+  MUSHI_CLI_VERSION,
   loadConfig,
   saveConfig,
   FRAMEWORKS,
@@ -743,6 +1221,21 @@ export {
   detectPackageManager,
   installCommand,
   envVarsToWrite,
+  consoleUrl,
+  resolveConsoleUrlSync,
+  resolveConsoleUrl,
+  projectIdHint,
+  apiKeyHint,
+  cliSetupDeepLink,
+  reportsUrl,
+  openInBrowser,
+  requireUuid,
+  probeEndpointHealth,
+  apiCall,
+  die,
+  requireConfig,
+  fmtDate,
+  pad,
   sanitizeApiKey,
   sanitizeProjectId,
   sanitizeEndpoint,