@mushi-mushi/cli 0.18.2 → 0.19.0

package/dist/chunk-T4XX5FMH.js

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

package/dist/chunk-XEXYGDQV.js

@@ -0,0 +1,137 @@
+// 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/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 {
+  CONFIG_PATH,
+  loadConfig,
+  saveConfig,
+  TEST_REPORT_FETCH_TIMEOUT_MS,
+  resolveCloudEndpoint,
+  assertEndpoint,
+  normalizeEndpoint
+};

package/dist/connect-IC7I76Z2.js

@@ -0,0 +1,297 @@
+import {
+  CONFIG_PATH,
+  assertEndpoint,
+  normalizeEndpoint,
+  saveConfig
+} from "./chunk-XEXYGDQV.js";
+import {
+  detectFramework,
+  envVarsToWrite,
+  readPackageJson
+} from "./chunk-7Q44KWGN.js";
+
+// src/connect.ts
+import { appendFile, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join, resolve } from "path";
+
+// 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 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 } 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(dirname(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 = join(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 = join(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 = join(cwd, ".cursor");
+    mcpPath = join(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 {
+  runConnect
+};

package/dist/connect-W2Q6N7K3.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  runConnect
+} from "./chunk-D5IDNBJO.js";
+import "./chunk-LDPFTQLE.js";
+export {
+  runConnect
+};