@mutmutco/cli 3.99.0 → 3.100.0

package/dist/main.cjs

@@ -20923,7 +20923,7 @@ function authorizeBodyHasMismatch(body) {
 }
 
 // src/project-set.ts
-var UNSET_KEYS = ["oauth", "requiredRuntimeSecrets", "requiredBuildSecrets", "secrets", "edgeDomains", "requiredGcpApis", "publishRequired", "publishDir", "dsManifestPath", "fofuEnabled", "consumesDesignSystem", "ci", "requiredChecks", "gate"];
+var UNSET_KEYS = ["oauth", "requiredRuntimeSecrets", "requiredBuildSecrets", "secrets", "edgeDomains", "requiredGcpApis", "publishRequired", "publishDir", "dsManifestPath", "fofuEnabled", "consumesDesignSystem", "ci", "requiredChecks", "gate", "seedCanary"];
 var UNSET_KEY_SET = new Set(UNSET_KEYS);
 var RUNTIME_SECRET_STAGES = ["dev", "rc", "main"];
 var SECRET_CONSUMERS = ["runtime", "build", "lambda", "actions", "agent", "box"];
@@ -21177,6 +21177,11 @@ function parseRuntimeVaultOnlyVar(raw) {
   if (raw === "false") return false;
   throw new Error("org project set: runtimeVaultOnly must be true or false");
 }
+function parseSeedCanaryVar(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  throw new Error("org project set: seedCanary must be true or false");
+}
 function parseConsumesDesignSystemVar(raw) {
   if (raw === "fofu") return raw;
   throw new Error('org project set: consumesDesignSystem must be "fofu"');
@@ -21266,7 +21271,8 @@ var SETTABLE_VAR_KEYS = [
   "ci",
   "requiredChecks",
   "gate",
-  "secrets"
+  "secrets",
+  "seedCanary"
 ];
 var SETTABLE_VAR_KEY_SET = new Set(SETTABLE_VAR_KEYS);
 var SETTABLE_VAR_HINTS = {
@@ -21277,6 +21283,7 @@ var SETTABLE_VAR_HINTS = {
   fofuEnabled: "true|false",
   consumesDesignSystem: '"fofu"',
   runtimeVaultOnly: "true|false",
+  seedCanary: "true|false",
   repos: 'JSON array, e.g. ["mutmutco/mm-foo"]',
   oauth: "JSON {subdomains,domains,callbackPath,fofuSubdomain}",
   requiredGcpApis: "comma-string",
@@ -21373,6 +21380,8 @@ function buildProjectSetPatch(input) {
       patch[key] = parseFofuEnabledVar(raw);
     } else if (key === "runtimeVaultOnly") {
       patch[key] = parseRuntimeVaultOnlyVar(raw);
+    } else if (key === "seedCanary") {
+      patch[key] = parseSeedCanaryVar(raw);
     } else if (key === "consumesDesignSystem") {
       patch[key] = parseConsumesDesignSystemVar(raw);
     } else if (key === "publishDir") {
@@ -24017,6 +24026,62 @@ function renderPropagationReport(plan) {
   return lines.join("\n");
 }
 
+// src/bootstrap-rollback.ts
+function resolveRollbackRecord(records, repo, target) {
+  const candidates = records.filter((r) => r.repo === repo && r.target === target && r.mergeSha);
+  if (candidates.length === 0) {
+    return { found: false, reason: `no propagation record resolves for ${repo} + ${target} \u2014 refusing to guess a commit to revert` };
+  }
+  const clean4 = candidates.filter((r) => r.files.length === 1 && r.files[0] === target);
+  if (clean4.length === 0) {
+    return {
+      found: false,
+      reason: `${candidates.length} merged seed-propagate PR(s) found for ${repo} + ${target}, but none is a clean single-file propagation of exactly this target \u2014 refusing to guess a commit to revert`
+    };
+  }
+  const latest = clean4.slice().sort((a, b) => a.mergedAt < b.mergedAt ? 1 : a.mergedAt > b.mergedAt ? -1 : 0)[0];
+  return { found: true, record: latest };
+}
+function planRollback(repo, target, slug, records) {
+  const resolution = resolveRollbackRecord(records, repo, target);
+  if (!resolution.found) return { repo, target, resolution };
+  const branch = `seed-rollback-${slug}`;
+  const title = `revert: rollback org-owned ${target} in ${repo} (seed PR #${resolution.record.number})`;
+  const body = renderRollbackPrBody(resolution.record);
+  return { repo, target, resolution, branch, title, body };
+}
+function renderRollbackPrBody(record) {
+  return [
+    `Per-repo emergency revert of \`${record.target}\`'s seed-propagate merge (\`mmi-cli bootstrap rollback\`, #4240).`,
+    "",
+    `Reverts ${record.url} (merge ${record.mergeSha}) \u2014 restores this repo's copy of \`${record.target}\` to its content immediately before that merge. Nothing else in this repo changes.`,
+    "",
+    "This is the emergency stop, not the fix: MMI-Hub is still the source of truth during a rollback. Closure is the Hub reverting (or fixing forward) the bad seed commit on `development` \u2014 once it does, this repo matches the Hub again and the drift alarm closes itself. A revert with no Hub-side follow-up re-alarms as drift within a week \u2014 deliberately, so an emergency divergence can never silently become permanent.",
+    "",
+    "Never re-run `bootstrap propagate` with the pre-revert bytes before the Hub itself is fixed \u2014 that reopens exactly what this PR closes."
+  ].join("\n");
+}
+function renderRollbackReport(plan) {
+  if (!plan.resolution.found) {
+    return `bootstrap rollback \u2014 ${plan.repo} / ${plan.target}: REFUSED \u2014 ${plan.resolution.reason}`;
+  }
+  const r = plan.resolution.record;
+  const opened = plan.prUrl ? ` \u2014 opened ${plan.prUrl}` : "";
+  return `bootstrap rollback \u2014 ${plan.repo} / ${plan.target}: reverting PR#${r.number} (merge ${r.mergeSha}${r.mergedAt ? `, merged ${r.mergedAt}` : ""}) on branch ${plan.branch}${opened}`;
+}
+function seedPrRecordFromPropagationRecord(record) {
+  if (!record.mergeSha || record.prNumber == null || !record.prUrl) return null;
+  return {
+    repo: record.repo,
+    target: record.target,
+    number: record.prNumber,
+    url: record.prUrl,
+    mergeSha: record.mergeSha,
+    mergedAt: "",
+    files: [record.target]
+  };
+}
+
 // src/bootstrap-verify.ts
 var TRAIN_BRANCHES2 = ["development", "rc", "main"];
 var requiredDocs = ["README.md", "architecture.md", "docs/decisions/README.md", "docs/index.md"];
@@ -25271,6 +25336,136 @@ Rollback: \`mmi-cli bootstrap rollback ${rec.repo} --target ${seed.target} --exe
     else console.log(renderPropagationReport(plan));
     if (plan.halted) process.exitCode = 1;
   });
+  bootstrap.command("rollback <repo>").description("#4240: open a per-repo revert PR of the recorded seed-propagate merge \u2014 never a fleet-wide overwrite; dry-run unless --execute").addOption(new Option("--class <class>", "deployable | content").default("deployable").choices(["deployable", "content"])).option("--target <path>", "the manifest target to roll back (an ownership:org + source:self seed, e.g. .github/workflows/agent-pr.yml)").option("--record <path>", "read propagation candidates from a persisted `bootstrap propagate --json` report instead of the live seed-propagate PR history").option("--execute", "LIVE revert via gh (master-gated) \u2014 opens/reuses the seed-rollback PR; dry-run prints the plan only").option("--json", "machine-readable output").action(async (repo) => {
+    const o = {
+      class: rawValue("--class", "deployable"),
+      target: rawValue("--target", ""),
+      record: rawValue("--record", ""),
+      execute: rawFlag("--execute"),
+      json: rawFlag("--json")
+    };
+    if (o.class !== "deployable" && o.class !== "content") return fail("bootstrap rollback: --class must be deployable or content");
+    let parsedRepo;
+    try {
+      parsedRepo = parseOwnerRepo(repo);
+    } catch (e) {
+      return fail(`bootstrap rollback: ${e.message}`);
+    }
+    const manifestPath = "skills/bootstrap/seeds/manifest.json";
+    if (!(0, import_node_fs31.existsSync)(manifestPath)) return fail(`bootstrap rollback: ${manifestPath} not found; run from the MMI-Hub repo root \u2014 the manifest names which targets are org-owned and therefore propagated (and rollback-able)`);
+    const manifest = loadBootstrapSeeds((0, import_node_fs31.readFileSync)(manifestPath, "utf8"));
+    const propagatable = manifest.seeds.filter((s) => s.ownership === "org" && s.source === "self");
+    if (!o.target) {
+      return fail(`bootstrap rollback: --target <path> is required \u2014 one of:
+  ${propagatable.map((s) => s.target).join("\n  ")}`);
+    }
+    const seed = propagatable.find((s) => s.target === o.target);
+    if (!seed) return fail(`bootstrap rollback: --target '${o.target}' names no ownership:org + source:self seed in ${manifestPath}. Propagatable (hence rollback-able) targets:
+  ${propagatable.map((s) => s.target).join("\n  ")}`);
+    const slug = parsedRepo.slug;
+    const baseBranch = o.class === "content" ? "main" : "development";
+    const branchPrefix = "seed-propagate";
+    const propagateBranch = `${branchPrefix}-${slug}`;
+    const gh = async (args) => execFileP2("gh", args, { timeout: 2e4 });
+    const enc = (p) => p.split("/").map(encodeURIComponent).join("/");
+    let candidates;
+    if (o.record) {
+      if (!(0, import_node_fs31.existsSync)(o.record)) return fail(`bootstrap rollback: --record '${o.record}' not found`);
+      let parsed;
+      try {
+        parsed = JSON.parse((0, import_node_fs31.readFileSync)(o.record, "utf8"));
+      } catch (e) {
+        return fail(`bootstrap rollback: --record '${o.record}' is not valid JSON: ${e.message}`);
+      }
+      const recs = Array.isArray(parsed?.records) ? parsed.records : Array.isArray(parsed) ? parsed : [];
+      candidates = recs.map((r) => {
+        try {
+          return seedPrRecordFromPropagationRecord(r);
+        } catch {
+          return null;
+        }
+      }).filter((r) => r !== null);
+    } else {
+      candidates = [];
+      try {
+        const listed = await gh(["pr", "list", "--repo", repo, "--head", propagateBranch, "--base", baseBranch, "--state", "merged", "--json", "number,url,mergedAt,mergeCommit,files", "--limit", "20"]);
+        const arr = JSON.parse(listed.stdout || "[]");
+        for (const p of arr) {
+          if (!p.mergeCommit?.oid) continue;
+          candidates.push({
+            repo,
+            target: seed.target,
+            number: p.number,
+            url: p.url,
+            mergeSha: p.mergeCommit.oid,
+            mergedAt: p.mergedAt ?? "",
+            files: (p.files ?? []).map((f) => f.path)
+          });
+        }
+      } catch (e) {
+        return fail(`bootstrap rollback: could not read ${repo}'s merged ${propagateBranch} PR history: ${e.message}`);
+      }
+    }
+    const plan = planRollback(repo, seed.target, slug, candidates);
+    if (!plan.resolution.found) {
+      if (o.json) console.log(JSON.stringify(plan, null, 2));
+      else console.log(renderRollbackReport(plan));
+      return fail(`bootstrap rollback: ${plan.resolution.reason}`);
+    }
+    if (o.execute) {
+      const record = plan.resolution.record;
+      const parentResp = await gh(["api", `repos/${repo}/commits/${record.mergeSha}`, "--jq", ".parents[0].sha"]);
+      const parentSha = parentResp.stdout.trim();
+      if (!parentSha) return fail(`bootstrap rollback: could not resolve ${repo}@${record.mergeSha}'s parent commit \u2014 refusing to guess what to restore`);
+      let preSeedContent = null;
+      try {
+        const resp = await gh(["api", `repos/${repo}/contents/${enc(seed.target)}?ref=${parentSha}`]);
+        const parsed = JSON.parse(resp.stdout);
+        preSeedContent = parsed.encoding === "base64" && typeof parsed.content === "string" ? Buffer.from(parsed.content, "base64").toString("utf8") : null;
+      } catch {
+        preSeedContent = null;
+      }
+      if (preSeedContent == null) return fail(`bootstrap rollback: '${seed.target}' did not exist in ${repo} at ${parentSha} (the commit before the seed merge) \u2014 nothing to restore; refusing to guess`);
+      const baseRef = await gh(["api", `repos/${repo}/git/ref/heads/${baseBranch}`, "--jq", ".object.sha"]);
+      const baseSha = baseRef.stdout.trim();
+      let branchExists = true;
+      try {
+        await gh(["api", `repos/${repo}/git/ref/heads/${plan.branch}`]);
+      } catch {
+        branchExists = false;
+      }
+      if (!branchExists) await gh(["api", `repos/${repo}/git/refs`, "-f", `ref=refs/heads/${plan.branch}`, "-f", `sha=${baseSha}`]);
+      let existingSha;
+      try {
+        const cur = await gh(["api", `repos/${repo}/contents/${enc(seed.target)}?ref=${plan.branch}`]);
+        existingSha = JSON.parse(cur.stdout).sha;
+      } catch {
+        existingSha = void 0;
+      }
+      const tmp = (0, import_node_path29.join)((0, import_node_os11.tmpdir)(), `mmi-rollback-${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}.json`);
+      (0, import_node_fs31.writeFileSync)(tmp, JSON.stringify(contentPutBody(seed.target, preSeedContent, plan.branch, existingSha)), "utf8");
+      try {
+        await gh(contentPutInputArgs(repo, seed.target, tmp));
+      } finally {
+        try {
+          (0, import_node_fs31.unlinkSync)(tmp);
+        } catch {
+        }
+      }
+      const openPrs = await gh(["pr", "list", "--repo", repo, "--head", plan.branch, "--base", baseBranch, "--state", "open", "--json", "number,url"]);
+      const prDecision = decideSeedPrAction(JSON.parse(openPrs.stdout || "[]"));
+      let prUrl;
+      if (prDecision.action === "reuse") {
+        prUrl = prDecision.url;
+      } else {
+        const created = await ghCreate(["pr", "create", "--repo", repo, "--base", baseBranch, "--head", plan.branch, "--title", plan.title, "--body", plan.body]);
+        prUrl = created.url;
+      }
+      plan.prUrl = prUrl;
+    }
+    if (o.json) console.log(JSON.stringify(plan, null, 2));
+    else console.log(renderRollbackReport(plan));
+  });
 }
 
 // src/stage-commands.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "3.99.0",
+  "version": "3.100.0",
   "description": "MMI Future CLI — the org dev toolbox and shared cross-IDE engine for every registry-declared MMI coding surface.",
   "type": "module",
   "license": "UNLICENSED",