@mutmutco/cli 3.2.0 → 3.3.0

package/dist/main.cjs

@@ -9219,9 +9219,23 @@ function parseNpmVersion(stdout) {
 function staleTrainCliMessage(report, commandName) {
   return `running mmi-cli ${report.currentVersion} is stale against released ${report.releasedVersion}; this is recoverable \u2014 run \`mmi-cli doctor --apply --no-repo-writes\` to update to ${report.releasedVersion}, then rerun ${commandName} so it uses the current train path`;
 }
-function versionAutoUpdateAction(report, hasPluginRoot) {
+async function resolveReleasedVersion(runners) {
+  try {
+    const npmVersion = parseNpmVersion(await runners.npm());
+    if (npmVersion) return { version: npmVersion, source: "npm" };
+  } catch {
+  }
+  try {
+    const ghVersion = parseManifestVersion(await runners.gh());
+    if (ghVersion) return { version: ghVersion, source: "gh" };
+  } catch {
+  }
+  return { version: void 0, source: "unavailable" };
+}
+function versionAutoUpdateAction(report, hasPluginRoot, releasedSource) {
   if (report.ok || report.staleAgainst !== "released") return "none";
-  return hasPluginRoot ? "plugin-pull" : "npm";
+  if (hasPluginRoot) return "plugin-pull";
+  return releasedSource === "gh" ? "npm-unreachable" : "npm";
 }
 
 // src/issue-related.ts
@@ -12508,6 +12522,19 @@ async function fetchTrainAuthority(repo, deps) {
     return { ok: false, error: e.message };
   }
 }
+async function mintWikiToken(repo, deps) {
+  const res = await postJson("/wiki-mint", { repo }, deps, "POST", { noRetry: true });
+  if (res.error) return { ok: false, error: res.error };
+  const body = res.body ?? {};
+  if (res.status === 426) return { ok: false, error: upgradeRequiredError({ status: 426 }, res.body) };
+  if (res.status === 403) return { ok: false, error: `master-admin only (HTTP 403)${body.error ? ` \u2014 ${body.error}` : ""}` };
+  if (res.status === 404) {
+    return { ok: false, error: "the Hub API did not recognize /wiki-mint (HTTP 404) \u2014 the deployed Hub predates this command; it answers once a Hub release carrying it is deployed" };
+  }
+  if (!res.ok) return { ok: false, error: `wiki-mint HTTP ${res.status}${body.error ? ` \u2014 ${body.error}` : ""}` };
+  if (!body.token || !body.expiresAt) return { ok: false, error: "malformed wiki-mint response (no token)" };
+  return { ok: true, mint: { token: body.token, expiresAt: body.expiresAt, repository: body.repository ?? repo, permissions: body.permissions ?? {} } };
+}
 async function fetchProjectsList(deps) {
   if (!deps.baseUrl) return null;
   const token = await deps.token();
@@ -12645,6 +12672,32 @@ async function tenantDeploy(payload, deps) {
   return postJson("/tenant-deploy", payload, deps, "POST", { noRetry: true, timeoutMs: TENANT_DEPLOY_TIMEOUT_MS });
 }
 
+// src/wiki-publish-command.ts
+async function wikiPublish(deps, opts) {
+  if (!opts.pagesDir) {
+    deps.err("wiki publish: <pages-dir> is required");
+    return false;
+  }
+  const script = deps.scriptPath();
+  if (!deps.scriptExists(script)) {
+    deps.err(`wiki publish: publish script not found at ${script} \u2014 run from the repo checkout root`);
+    return false;
+  }
+  const minted = await deps.mint(opts.repo);
+  if (!minted.ok) {
+    deps.err(`wiki publish failed: could not mint a scoped wiki token for ${opts.repo}: ${minted.error}`);
+    return false;
+  }
+  const env = { ...process.env, WIKI_REPO: opts.repo, WIKI_TOKEN: minted.mint.token };
+  const code = deps.spawn("node", [script, opts.pagesDir], env);
+  if (code !== 0) {
+    deps.err(`wiki publish failed: publish script exited ${code} (token was scoped to ${opts.repo}, contents:write, expires ${minted.mint.expiresAt})`);
+    return false;
+  }
+  deps.log(`wiki published for ${opts.repo} (scoped token, expired/discarded)`);
+  return true;
+}
+
 // src/project-readiness.ts
 function stagesForTrack(meta) {
   return branchesForTrack(resolveReleaseTrack(meta)).map((b) => b === "development" ? "dev" : b);
@@ -13788,7 +13841,9 @@ function vaultPointer(slug) {
     slug,
     root,
     tiers: {
-      project: `${root}/{dev,rc,main}/*  (project-admin self-serve for this repo)`,
+      // #2482: a stageless catalog entry (stages: []) lives at the slug ROOT — one value per repo —
+      // alongside the staged tree for per-stage entries. Both are the same project-admin wall (#2032).
+      project: `${root}/<KEY>  (stageless, one value per repo)  +  ${root}/{dev,rc,main}/*  (staged entries)  (project-admin self-serve for this repo)`,
       org: [`/mmi-future/{shared,cloudflare,mmi-hub,...}/*  (org-infra, master-gated)`]
     },
     stages: ["dev", "rc", "main"],
@@ -15293,6 +15348,7 @@ function buildCodexActiveCacheCheck(input) {
     fix: CODEX_PLUGIN_RECOVERY
   };
   if (!input.isOrgRepo || !isSemverVersion2(input.releasedVersion)) return base;
+  if (input.codexPresent === false) return base;
   if (isSemverVersion2(input.codexActiveVersion)) {
     if (compareVersions(input.codexActiveVersion, input.releasedVersion) < 0) {
       return {
@@ -15571,12 +15627,13 @@ function buildPluginUpdateReport(input) {
       ...codexMarketplace ? { codexMarketplace } : {},
       ...codexActiveCache ? { codexActiveCache } : {},
       ...opencodePlugin ? { opencodePlugin } : {},
-      ...isSemverVersion2(input.releasedVersion) ? { released: input.releasedVersion } : {}
+      ...isSemverVersion2(input.releasedVersion) ? { released: input.releasedVersion } : {},
+      ...input.releasedVersionSource ? { releasedSource: input.releasedVersionSource } : {}
     },
     recipes: PLUGIN_UPDATE_RECIPES
   };
 }
-function renderPluginUpdateReport(report) {
+function renderPluginVersionBlock(report) {
   const v = report.versions;
   const show = (x) => x ?? "unknown";
   const versionRows = [
@@ -15587,16 +15644,10 @@ function renderPluginUpdateReport(report) {
     ["OpenCode plugin", show(v.opencodePlugin)]
   ];
   const pad = Math.max(...versionRows.map(([label]) => label.length));
-  const lines = [
+  return [
     `MMI versions  (target release: ${show(v.released)})`,
-    ...versionRows.map(([label, value]) => `  ${label.padEnd(pad)}  ${value}`),
-    "",
-    "Update commands by surface"
+    ...versionRows.map(([label, value]) => `  ${label.padEnd(pad)}  ${value}`)
   ];
-  for (const surface of PLUGIN_GUIDE_SURFACES) {
-    lines.push(...renderSurfaceGuide(surface.label, report.recipes[surface.key]));
-  }
-  return lines;
 }
 function buildDoctorJsonPayload(input) {
   return {
@@ -16230,7 +16281,7 @@ function doctorHumanLines(input) {
     lines.push("", DOCTOR_VERBOSE_HINT);
   }
   if (!input.verbose) return lines;
-  lines.push("", ...renderPluginUpdateReport(input.updateReport));
+  lines.push("", ...renderPluginVersionBlock(input.updateReport));
   lines.push(
     "",
     doctorSummaryLine({ checks: input.checks, updateReport: input.updateReport, shouldApply: input.shouldApply, healedCount: input.healedCount }),
@@ -16347,6 +16398,7 @@ function extractTomlServer(content, spec) {
 }
 function detectMcpState(target, spec) {
   if (!target.present) return { target, state: "skip", action: "skip", reasons: [] };
+  if (target.format === "claude-cli") return detectClaudeCliMcpState(target, spec);
   if (target.content == null) {
     if (target.createWhenFileAbsent) return { target, state: "absent", action: "install", reasons: [] };
     return { target, state: "skip", action: "skip", reasons: [] };
@@ -16370,6 +16422,56 @@ function detectMcpState(target, spec) {
 function planMcpReconcile(targets, spec) {
   return targets.map((t) => detectMcpState(t, spec));
 }
+function parseClaudeMcpGetOutput(stdout) {
+  const commandMatch = /^\s*Command:\s*(.+)$/m.exec(stdout);
+  if (commandMatch == null) return null;
+  const argsMatch = /^\s*Args:\s*(.*)$/m.exec(stdout);
+  const env = {};
+  const lines = stdout.replace(/\r\n/g, "\n").split("\n");
+  const headerIdx = lines.findIndex((l) => /^\s*Environment:\s*$/.test(l));
+  if (headerIdx !== -1) {
+    for (const line of lines.slice(headerIdx + 1)) {
+      if (line.trim() === "") continue;
+      if (!/^[ \t]/.test(line)) break;
+      const kv = /^\s*([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(line);
+      if (kv != null) env[kv[1]] = kv[2];
+    }
+  }
+  return { command: commandMatch[1].trim(), args: (argsMatch?.[1] ?? "").trim(), env };
+}
+function detectClaudeCliMcpState(target, spec) {
+  if (target.content == null) {
+    return { target, state: "absent", action: "install", reasons: [] };
+  }
+  const matchedName = target.claudeCliMatchedName ?? spec.name;
+  const isLegacy = matchedName !== spec.name;
+  const parsed = parseClaudeMcpGetOutput(target.content);
+  if (parsed == null) {
+    const reasons2 = isLegacy ? ["legacy-name", "unparseable"] : ["unparseable"];
+    return { target, state: "drifted", action: "reconcile", reasons: reasons2, matchedName };
+  }
+  const reasons = [];
+  if (isLegacy) reasons.push("legacy-name");
+  if (textHasPlaywrightVisionCap(parsed.args)) reasons.push("vision-cap");
+  if (!textHasCanonicalPlaywrightOutputDir(parsed.args)) reasons.push("output-dir");
+  if (reasons.length === 0) return { target, state: "healthy", action: "none", reasons: [], matchedName };
+  return { target, state: "drifted", action: "reconcile", reasons, matchedName };
+}
+var CLAUDE_MCP_USER_SCOPE = "user";
+function planClaudeCliMcpHeal(item, spec) {
+  if (item.action !== "install" && item.action !== "reconcile") return [];
+  const commands = [];
+  if (item.action === "reconcile" && item.matchedName != null) {
+    commands.push({ op: "remove", args: ["remove", item.matchedName, "-s", CLAUDE_MCP_USER_SCOPE] });
+  }
+  const parsed = item.target.content != null ? parseClaudeMcpGetOutput(item.target.content) : null;
+  const envFlags = Object.entries(parsed?.env ?? {}).flatMap(([k, v]) => ["-e", `${k}=${v}`]);
+  commands.push({
+    op: "add",
+    args: ["add", spec.name, "-s", CLAUDE_MCP_USER_SCOPE, ...envFlags, "--", spec.command, ...spec.args]
+  });
+  return commands;
+}
 function buildMcpReconcileCheck(plan) {
   const base = {
     ok: true,
@@ -16771,20 +16873,22 @@ function readRepoVersion() {
   }
 }
 async function fetchReleasedVersion() {
-  try {
-    const { stdout } = await execFileP2("gh", pluginManifestVersionArgs(), { timeout: 5e3 });
-    return parseManifestVersion(stdout);
-  } catch {
-    return void 0;
-  }
+  return resolveReleasedVersion({
+    npm: async () => (await runHostBin("npm", npmReleasedVersionArgs(), { timeout: NPM_VIEW_TIMEOUT_MS })).stdout,
+    gh: async () => (await execFileP2("gh", pluginManifestVersionArgs(), { timeout: 5e3 })).stdout
+  });
 }
 var NPM_UPDATE_TIMEOUT_MS = 12e4;
 var NPM_VIEW_TIMEOUT_MS = 15e3;
 var PLUGIN_PULL_TIMEOUT_MS = 3e4;
-async function applyVersionAutoUpdate(report, log) {
-  const action = versionAutoUpdateAction(report, Boolean(process.env.CLAUDE_PLUGIN_ROOT));
+async function applyVersionAutoUpdate(report, log, releasedSource) {
+  const action = versionAutoUpdateAction(report, Boolean(process.env.CLAUDE_PLUGIN_ROOT), releasedSource);
   if (action === "none") return { report, applied: "none" };
   const target = report.releasedVersion ?? "latest";
+  if (action === "npm-unreachable") {
+    log(`  \u2717 mmi-cli ${report.currentVersion} is stale (released ${target}, resolved via gh) \u2014 npm registry unreachable this pass; when npm is back: npm install -g @mutmutco/cli@latest`);
+    return { report, applied: "none" };
+  }
   if (action === "plugin-pull") {
     try {
       const root = (await execFileP2("git", ["-C", process.env.CLAUDE_PLUGIN_ROOT, "rev-parse", "--show-toplevel"], { timeout: PLUGIN_PULL_TIMEOUT_MS })).stdout.trim();
@@ -17495,17 +17599,51 @@ function writeMcpConfigFile(path2, content) {
     return false;
   }
 }
+var CLAUDE_CLI_MCP_LABEL = "Claude Code MCP store (user scope)";
+var CLAUDE_CLI_MCP_PATH = "claude mcp (user scope)";
+async function claudeCliMcpTarget(spec) {
+  const base = {
+    host: "claude-cli",
+    label: CLAUDE_CLI_MCP_LABEL,
+    path: CLAUDE_CLI_MCP_PATH,
+    format: "claude-cli",
+    isRepoFile: false,
+    createWhenFileAbsent: true
+  };
+  if (!await hostBinAvailable("claude")) return { ...base, present: false, content: null };
+  for (const name of [spec.name, ...spec.legacyNames]) {
+    try {
+      const { stdout } = await runHostBin("claude", ["mcp", "get", name], { timeout: CLAUDE_PLUGIN_TIMEOUT_MS });
+      return { ...base, present: true, content: stdout, claudeCliMatchedName: name };
+    } catch {
+    }
+  }
+  return { ...base, present: true, content: null };
+}
+async function runClaudeCliMcpCommands(commands) {
+  for (const cmd of commands) {
+    try {
+      await runHostBin("claude", ["mcp", ...cmd.args], { timeout: CLAUDE_PLUGIN_TIMEOUT_MS });
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
 async function reconcileMcpRegistrations(input) {
   if (!input.isOrgRepo) return buildMcpReconcileCheck([]);
-  const targets = mcpConfigTargets();
+  const snapshot = async () => [...mcpConfigTargets(), await claudeCliMcpTarget(PLAYWRIGHT_MCP_SPEC)];
+  const targets = await snapshot();
   if (!input.apply) return buildMcpReconcileCheck(planMcpReconcile(targets, PLAYWRIGHT_MCP_SPEC));
-  const results = applyMcpReconcile(targets, PLAYWRIGHT_MCP_SPEC, {
+  const fileTargets = targets.filter((t) => t.format !== "claude-cli");
+  const results = applyMcpReconcile(fileTargets, PLAYWRIGHT_MCP_SPEC, {
     repoWritesAllowed: input.repoWritesAllowed,
     write: writeMcpConfigFile
   });
   for (const r of results) {
     if (r.outcome === "wrote") {
       input.onHealed();
+      input.onReloadRequired();
       const verb = r.action === "install" ? "registered" : "reconciled";
       input.log(`  \u21BB ${verb} Playwright MCP in ${r.target.path} \u2014 restart the host to load it`);
     } else if (r.outcome === "unparseable") {
@@ -17514,7 +17652,22 @@ async function reconcileMcpRegistrations(input) {
       input.log(`  \u26A0 ${r.target.label}: failed to write ${r.target.path}`);
     }
   }
-  return buildMcpReconcileCheck(planMcpReconcile(mcpConfigTargets(), PLAYWRIGHT_MCP_SPEC));
+  const claudeTarget = targets.find((t) => t.format === "claude-cli");
+  if (claudeTarget != null) {
+    const item = detectMcpState(claudeTarget, PLAYWRIGHT_MCP_SPEC);
+    if (item.action === "install" || item.action === "reconcile") {
+      const commands = planClaudeCliMcpHeal(item, PLAYWRIGHT_MCP_SPEC);
+      if (await runClaudeCliMcpCommands(commands)) {
+        input.onHealed();
+        input.onReloadRequired();
+        const verb = item.action === "install" ? "registered" : "reconciled";
+        input.log(`  \u21BB ${verb} Playwright MCP via \`claude mcp add\` (${CLAUDE_CLI_MCP_PATH}) \u2014 restart Claude Code to load it`);
+      } else {
+        input.log(`  \u26A0 ${CLAUDE_CLI_MCP_LABEL}: \`claude mcp add\` failed for ${PLAYWRIGHT_MCP_SPEC.name} \u2014 run it by hand`);
+      }
+    }
+  }
+  return buildMcpReconcileCheck(planMcpReconcile(await snapshot(), PLAYWRIGHT_MCP_SPEC));
 }
 function strayBrowserArtifactPaths() {
   const cwd = process.cwd();
@@ -17553,7 +17706,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
   const checks = [];
   const REWRITE_KEY = "url.https://github.com/.insteadOf";
   const CLONE_FIX = 'run: git config --global url."https://github.com/".insteadOf "git@github.com:"';
-  const [login, pathProbe, releasedVersion, cfg, callerArn, cloneProbe, isOrgRepo] = await Promise.all([
+  const [login, pathProbe, releasedVersionResolution, cfg, callerArn, cloneProbe, isOrgRepo] = await Promise.all([
     githubLogin(),
     execFileP2(isWin ? "where" : "which", ["mmi-cli"]).then(() => true).catch(() => false),
     fetchReleasedVersion(),
@@ -17565,6 +17718,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
     // not the now-always-defaulted `cfg.sagaApiUrl`. Independent git read — resolved concurrently here.
     readOrigin ? isOrgRepoRoot(readOrigin) : isOrgRepoRoot()
   ]);
+  const releasedVersion = releasedVersionResolution.version;
   const surface = detectSurface(process.env);
   const versionReportProbe = buildVersionLagReport({
     currentVersion: resolveClientVersion(),
@@ -17630,7 +17784,7 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
   });
   let selfUpdatedCli = false;
   if (repairFull && !process.env[DOCTOR_POST_SELF_UPDATE_ENV]) {
-    const updated = await applyVersionAutoUpdate(versionReport, (m) => io.err(m));
+    const updated = await applyVersionAutoUpdate(versionReport, (m) => io.err(m), releasedVersionResolution.source);
     versionReport = updated.report;
     selfUpdatedCli = updated.applied === "npm";
   }
@@ -17978,15 +18132,16 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
     };
   }
   checks.push(cacheCleanupCheck);
+  const canDriveCodex = surfaceToken(surface) === "codex" || await hostBinAvailable("codex");
   let codexActiveCacheCheck = buildCodexActiveCacheCheck({
     isOrgRepo,
     releasedVersion,
     codexCacheVersions: codexCacheVersions(),
     codexRecordVersion: codexRecordVersion(),
-    codexActiveVersion: await codexActiveVersion()
+    codexActiveVersion: await codexActiveVersion(),
+    codexPresent: canDriveCodex
   });
   if (!codexActiveCacheCheck.ok && repairFull) {
-    const canDriveCodex = surfaceToken(surface) === "codex" || await hostBinAvailable("codex");
     if (canDriveCodex && await applyPluginHeal("codex", surface, (m) => io.err(m), { force: true })) {
       markPluginReloadRequired();
       markHealed();
@@ -17996,7 +18151,8 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         releasedVersion,
         codexCacheVersions: codexCacheVersions(),
         codexRecordVersion: codexRecordVersion(),
-        codexActiveVersion: await codexActiveVersion()
+        codexActiveVersion: await codexActiveVersion(),
+        codexPresent: canDriveCodex
       });
     }
   }
@@ -18130,7 +18286,8 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         apply: Boolean(opts.apply),
         repoWritesAllowed,
         log: (m) => io.err(m),
-        onHealed: markHealed
+        onHealed: markHealed,
+        onReloadRequired: markPluginReloadRequired
       })
     );
   }
@@ -18204,7 +18361,8 @@ async function runDoctor(opts, io = consoleIo, readOrigin) {
         codexPluginVersions: sourceVersions("codex"),
         codexCacheVersions: cacheVersionsFor("codex"),
         opencodePluginVersions: opencodePluginVersionsForReport(),
-        releasedVersion
+        releasedVersion,
+        releasedVersionSource: releasedVersionResolution.source
       });
     }
   });
@@ -20741,6 +20899,29 @@ ${r.repo}: applied=[${r.applied.join("; ")}] skipped=[${r.skipped.join("; ")}]${
   }
   if (!audit.ok) process.exitCode = 1;
 });
+var wiki = program2.command("wiki").description("release wiki lane \u2014 publish generated pages via a short-lived, repo-scoped minted token");
+wiki.command("publish <pages-dir>").description("mint a 1h repo-scoped contents:write token (master-gated) and publish the generated .md pages to <repo>.wiki.git via scripts/wiki-publish.mjs; the token stays in memory (never printed/committed). Fails loud on the credential gap \u2014 never a silent skip").option("--repo <owner/repo>", "target repo (defaults to the cwd repo)").action(async (pagesDir, o) => {
+  const repo = await resolveRepo(o.repo);
+  if (!repo) return fail("wiki publish: could not determine the target repo (pass --repo owner/name)");
+  const cfg = await loadConfig();
+  const ok = await wikiPublish(
+    {
+      mint: (r) => mintWikiToken(r, registryClientDeps(cfg)),
+      // scripts/wiki-publish.mjs lives at the repo root; Lane B runs there. Resolve against cwd.
+      scriptPath: () => (0, import_node_path18.resolve)(process.cwd(), "scripts", "wiki-publish.mjs"),
+      scriptExists: (p) => (0, import_node_fs18.existsSync)(p),
+      spawn: (command, args, env) => {
+        const r = (0, import_node_child_process11.spawnSync)(command, args, { stdio: "inherit", env });
+        if (r.error) throw r.error;
+        return r.status ?? 1;
+      },
+      log: (msg) => console.log(msg),
+      err: (msg) => console.error(msg)
+    },
+    { repo, pagesDir }
+  );
+  if (!ok) process.exitCode = 1;
+});
 var bootstrap = program2.command("bootstrap").description("plan repo bootstrap operations; mutations require master-admin approval").option("--repo <owner/repo>", "target repo").option("--class <class>", "deployable | content", "deployable").option("--json", "machine-readable output").option("--apply", "reserved for future bootstrap execution after explicit master-admin approval").action((o) => {
   if (!o.repo) return fail("bootstrap: required option --repo <owner/repo> not specified");
   if (o.apply) return fail("bootstrap: execution is not implemented yet; use the dry-run plan and the existing /bootstrap skill");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "MMI Future CLI — the org dev toolbox (board, registry, keyless secrets, release train, bootstrap, doctor) and the cross-IDE engine the plugin's session-start hook drives.",
   "type": "module",
   "license": "UNLICENSED",