@deeeed/metamask-harness 0.51.5 → 0.51.7

package/adapters/extension/lib/macos-focus.cjs

@@ -1,32 +1,236 @@
 'use strict';
 
-const { execFileSync } = require('node:child_process');
+const { execFileSync, spawn } = require('node:child_process');
+const fs = require('node:fs');
 
-function captureMacFrontmostProcess() {
+// Window activation is not sub-20ms; 80ms keeps the hold responsive while
+// spawning far fewer lsappinfo/open subprocesses per second.
+const HOLD_INTERVAL_MS = 80;
+// Upper bound for one Launch Services query or `open -a`. A short bound made a
+// loaded Mac time out the first query, which silently disabled the whole hold.
+const LS_TIMEOUT_MS = 2000;
+// Hard cap on a hold whose parent is alive but never released it.
+const HOLD_MAX_MS = 120_000;
+const toolEnv = () => ({ ...process.env });
+
+function captureMacFrontmost() {
   if (process.platform !== 'darwin') return null;
   try {
-    const value = execFileSync('osascript', [
-      '-e',
-      'tell application "System Events" to get unix id of first application process whose frontmost is true',
-    ], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 1_000 }).trim();
-    const pid = Number.parseInt(value, 10);
+    const asn = execFileSync('lsappinfo', ['front'], {
+      encoding: 'utf8',
+      env: toolEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: LS_TIMEOUT_MS,
+    }).trim();
+    if (!asn) return null;
+    return parseLsappinfo(execFileSync('lsappinfo', ['info', asn], {
+      encoding: 'utf8',
+      env: toolEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: LS_TIMEOUT_MS,
+    }));
+  } catch {
+    // Best effort: lsappinfo missing, timed out, or the app exited; no focus to preserve.
+    return null;
+  }
+}
+
+function captureMacFrontmostProcess() {
+  return captureMacFrontmost()?.pid ?? null;
+}
+
+function parseLsappinfo(info) {
+  const pid = Number.parseInt((info.match(/\bpid\s*=\s*(\d+)/u) || info.match(/"pid"=(\d+)/u) || [])[1], 10);
+  const bundlePath = (info.match(/bundle path="([^"]+)"/u) || info.match(/"LSBundlePath"="([^"]+)"/u) || [])[1];
+  const name = (info.match(/^"([^"]+)"/mu) || info.match(/"LSDisplayName"="([^"]+)"/u) || [])[1];
+  if (!Number.isInteger(pid) || pid <= 0 || !bundlePath) return null;
+  return { pid, bundlePath, name: name || bundlePath };
+}
+
+function currentFrontmostPid() {
+  try {
+    const asn = execFileSync('lsappinfo', ['front'], {
+      encoding: 'utf8',
+      env: toolEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: LS_TIMEOUT_MS,
+    }).trim();
+    if (!asn) return null;
+    const value = execFileSync('lsappinfo', ['info', '-only', 'pid', asn], {
+      encoding: 'utf8',
+      env: toolEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: LS_TIMEOUT_MS,
+    }).trim();
+    const pid = Number.parseInt((value.match(/"pid"=(\d+)/u) || [])[1], 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
+    // Best effort: lsappinfo unavailable or timed out; callers treat null as unknown.
     return null;
   }
 }
 
+function restoreMacFrontmost(target) {
+  if (process.platform !== 'darwin' || !target?.bundlePath) return false;
+  try {
+    execFileSync('open', ['-a', target.bundlePath], {
+      env: toolEnv(),
+      stdio: 'ignore',
+      timeout: LS_TIMEOUT_MS,
+    });
+    return true;
+  } catch {
+    // Best effort: `open -a` failed or timed out; the operator keeps whatever is in front.
+    return false;
+  }
+}
+
 function restoreMacFrontmostProcess(pid) {
   if (process.platform !== 'darwin' || !Number.isInteger(pid) || pid <= 0) return false;
   try {
-    execFileSync('osascript', [
-      '-e',
-      `tell application "System Events" to set frontmost of first application process whose unix id is ${pid} to true`,
-    ], { stdio: 'ignore', timeout: 1_000 });
+    const asn = execFileSync('lsappinfo', ['find', `pid=${pid}`], {
+      encoding: 'utf8',
+      env: toolEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: LS_TIMEOUT_MS,
+    }).trim();
+    if (!asn) return false;
+    return restoreMacFrontmost(parseLsappinfo(execFileSync('lsappinfo', ['info', asn], {
+      encoding: 'utf8',
+      env: toolEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: LS_TIMEOUT_MS,
+    })));
+  } catch {
+    // Best effort: lsappinfo unavailable, timed out, or the pid has no Launch Services entry; nothing to restore.
+    return false;
+  }
+}
+
+// Bring `target` back in front of the launched browser. With `launchedBundlePath`
+// given, any other frontmost app is an intentional operator switch and is kept.
+function preserveMacFrontmost(target, launchedBundlePath) {
+  if (process.env.MM_HARNESS_FOCUS_BROWSER === '1') return false;
+  if (process.platform !== 'darwin' || !target?.bundlePath || !Number.isInteger(target.pid) || target.pid <= 0) {
+    return false;
+  }
+  const front = captureMacFrontmost();
+  if (front && front.pid === target.pid) return true;
+  if (front && launchedBundlePath && !sameBundle(front.bundlePath, launchedBundlePath)) return false;
+  return restoreMacFrontmost(target);
+}
+
+function preserveMacFrontmostProcess(pid) {
+  if (process.env.MM_HARNESS_FOCUS_BROWSER === '1') return false;
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  const current = currentFrontmostPid();
+  if (current === pid) return true;
+  return restoreMacFrontmostProcess(pid);
+}
+
+function macBackgroundOpenArgs(application, chromeArgs) {
+  return ['-g', '-n', '-a', application, '--args', ...chromeArgs];
+}
+
+// Keep the previously focused app in front while `launchedBundlePath` starts.
+// The hold only counters the launched browser: the moment any other app is
+// brought to the front, the operator switched on purpose and the hold ends.
+function startMacFocusHold(targetOrPid, launchedBundlePath) {
+  if (process.env.MM_HARNESS_FOCUS_BROWSER === '1') return null;
+  if (process.platform !== 'darwin') return null;
+  const target = typeof targetOrPid === 'number'
+    ? { pid: targetOrPid, bundlePath: bundlePathForPid(targetOrPid) }
+    : targetOrPid;
+  if (!target?.bundlePath || !Number.isInteger(target.pid) || target.pid <= 0) return null;
+  return spawn(process.execPath, [
+    __filename,
+    '--hold',
+    String(target.pid),
+    target.bundlePath,
+    String(process.pid),
+    launchedBundlePath || '',
+  ], { stdio: 'ignore', env: toolEnv() });
+}
+
+function sameBundle(left, right) {
+  if (!left || !right) return false;
+  const real = (value) => {
+    try {
+      return fs.realpathSync(value);
+    } catch {
+      // A path that cannot be resolved is compared as given.
+      return value;
+    }
+  };
+  return real(left) === real(right);
+}
+
+function bundlePathForPid(pid) {
+  try {
+    const asn = execFileSync('lsappinfo', ['find', `pid=${pid}`], {
+      encoding: 'utf8',
+      env: toolEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: LS_TIMEOUT_MS,
+    }).trim();
+    return parseLsappinfo(execFileSync('lsappinfo', ['info', asn], {
+      encoding: 'utf8',
+      env: toolEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: LS_TIMEOUT_MS,
+    }))?.bundlePath ?? null;
+  } catch {
+    // Best effort: lsappinfo unavailable, timed out, or the pid has no Launch Services entry; the hold is skipped.
+    return null;
+  }
+}
+
+function stopMacFocusHold(child) {
+  if (!child || !Number.isInteger(child.pid) || child.pid <= 0) return;
+  try {
+    process.kill(child.pid, 'SIGTERM');
+  } catch (error) {
+    if (error.code !== 'ESRCH') throw error;
+  }
+}
+
+function parentAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
     return true;
   } catch {
+    // ESRCH or EPERM: the parent is gone or not ours; either way the hold must end.
     return false;
   }
 }
 
-module.exports = { captureMacFrontmostProcess, restoreMacFrontmostProcess };
+if (require.main === module && process.argv[2] === '--hold') {
+  const pid = Number.parseInt(process.argv[3], 10);
+  const bundlePath = process.argv[4];
+  const parentPid = Number.parseInt(process.argv[5], 10);
+  const launchedBundlePath = process.argv[6] || '';
+  const target = { pid, bundlePath };
+  const hold = () => {
+    if (!parentAlive(parentPid)) process.exit(0);
+    const front = captureMacFrontmost();
+    if (front && front.pid === target.pid) return;
+    if (front && launchedBundlePath && !sameBundle(front.bundlePath, launchedBundlePath)) process.exit(0);
+    preserveMacFrontmost(target, launchedBundlePath);
+  };
+  hold();
+  setInterval(hold, HOLD_INTERVAL_MS);
+  setTimeout(() => process.exit(0), HOLD_MAX_MS);
+}
+
+module.exports = {
+  captureMacFrontmost,
+  captureMacFrontmostProcess,
+  macBackgroundOpenArgs,
+  preserveMacFrontmost,
+  preserveMacFrontmostProcess,
+  restoreMacFrontmost,
+  restoreMacFrontmostProcess,
+  startMacFocusHold,
+  stopMacFocusHold,
+};

package/adapters/extension/lib/validation-process-ownership.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const { execFileSync } = require('node:child_process');
+const { execFileSync, spawnSync } = require('node:child_process');
 
 function commandHasExactProfile(command, profile) {
   const expected = `--user-data-dir=${profile}`;
@@ -43,6 +43,62 @@ function delay(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
+// A process that already exited but has not been reaped yet (zombie) still
+// answers `kill(pid, 0)`. The synchronous stop loop below never yields to the
+// event loop, so a spawned child that dies immediately stays a zombie until the
+// launcher returns; it must not count as a surviving browser.
+function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if (error.code === 'ESRCH') return false;
+    throw error;
+  }
+  // Requires macOS or procps ps; a ps that rejects these flags prints nothing, which is treated as dead.
+  const state = spawnSync('ps', ['-o', 'stat=', '-p', String(pid)], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  }).stdout.trim();
+  return state !== '' && !state.startsWith('Z');
+}
+
+function uniquePids(pids) {
+  return [...new Set(pids)].filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid);
+}
+
+// Reap every live process that still owns this profile, then refuse to continue
+// if any survive. `open -n` otherwise starts a second headed Chrome on the same
+// user-data-dir while the previous instance is still dying.
+function stopProfileProcessesSync(profile, { extraPids = [], timeoutMs = 5_000, waitForAppearanceMs = 0 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  const appearUntil = Date.now() + Math.max(0, waitForAppearanceMs);
+  let ownersSince = 0;
+  while (Date.now() < deadline) {
+    const pids = uniquePids([
+      ...profileProcessPids(profile),
+      ...extraPids.filter(pidAlive),
+    ]);
+    if (pids.length === 0) {
+      if (Date.now() >= appearUntil) return;
+    } else {
+      if (ownersSince === 0) ownersSince = Date.now();
+      signalPids(pids, Date.now() - ownersSince >= 500 ? 'SIGKILL' : 'SIGTERM');
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+  }
+  const remaining = uniquePids([
+    ...profileProcessPids(profile),
+    ...extraPids.filter(pidAlive),
+  ]);
+  if (remaining.length > 0) {
+    throw new Error(
+      `Owned Chrome processes survived stop (pid ${remaining.join(', ')}). ` +
+        'Next: mm-harness stop --adapter extension --target <checkout>',
+    );
+  }
+}
+
 async function stopProfileProcesses(profile, { quietMs = 0, timeoutMs = 5_000 } = {}) {
   const deadline = Date.now() + timeoutMs;
   let quietSince = Date.now();
@@ -66,4 +122,4 @@ async function stopProfileProcesses(profile, { quietMs = 0, timeoutMs = 5_000 }
   throw new Error(`Extension validation profile did not remain quiescent for ${quietMs}ms.`);
 }
 
-module.exports = { profileProcessPids, stopProfileProcesses };
+module.exports = { profileProcessPids, stopProfileProcesses, stopProfileProcessesSync };

package/adapters/extension/live.sh

@@ -228,7 +228,6 @@ NODE
   quoted_check_infura="$(printf '%q' "$SCRIPT_DIR/check-infura-readiness.cjs")"
   quoted_stamp_title="$(printf '%q' "$SCRIPT_DIR/stamp-runtime-title.cjs")"
   quoted_chrome_launcher="$(printf '%q' "$SCRIPT_DIR/launch-browser.cjs")"
-  quoted_build_handoff="$(printf '%q' "$SCRIPT_DIR/build-handoff.cjs")"
   quoted_artifact_state="$(printf '%q' "$SCRIPT_DIR/artifact-runtime-state.cjs")"
   quoted_fixture_state="$(printf '%q' "$FIXTURE_STATE_ABS")"
   quoted_fixture_validation="$(printf '%q' "$FIXTURE_VALIDATION_ABS")"
@@ -353,7 +352,6 @@ NODE
   fi
   prepare_parts+=("$chrome_launch_cmd")
   prepare_parts+=("for i in {1..60}; do curl -fsS --max-time 1 http://127.0.0.1:${CDP_PORT}/json/version >/dev/null 2>&1 && break; sleep 1; done; curl -fsS --max-time 1 http://127.0.0.1:${CDP_PORT}/json/version >/dev/null")
-  prepare_parts+=("node ${quoted_build_handoff} --target ${quoted_target} --runtime-dist ${quoted_runtime_dist} --cdp-port ${CDP_PORT}")
   if [ -n "$WALLET_FIXTURE_ABS" ]; then
     prepare_parts+=("bash ${quoted_seed_fixture} seed-cdp --target ${quoted_target} --fixture ${quoted_wallet_fixture} --state ${quoted_fixture_state} --cdp-port ${CDP_PORT} --extension-dir ${quoted_runtime_dist} --extension-id-file ${quoted_extension_id_file} --out ${quoted_fixture_validation}")
   fi

package/adapters/extension/stop-viewers.sh

@@ -29,7 +29,6 @@ done
 unset _tv_src
 
 runtime_dir="$TARGET/$(recipe_runtime_dir)"
-console_log="$runtime_dir/extension-console.log"
 set +e
 
 if command -v tmux_viewer_close_marker >/dev/null 2>&1; then
@@ -48,7 +47,7 @@ ps -axo pid=,command= 2>/dev/null | while read -r pid command; do
     *) continue ;;
   esac
   case "$command" in
-    *"--log $console_log"*|*"$console_log"*) kill "$pid" 2>/dev/null || true ;;
+    *"$runtime_dir/"*) kill "$pid" 2>/dev/null || true ;;
   esac
 done
 

package/dist/adapters/extension/validation-process-ownership.js

@@ -3,8 +3,9 @@ const require2 = createRequire(import.meta.url);
 const processOwnership = require2(
   "../../../adapters/extension/lib/validation-process-ownership.cjs"
 );
-const { profileProcessPids, stopProfileProcesses } = processOwnership;
+const { profileProcessPids, stopProfileProcesses, stopProfileProcessesSync } = processOwnership;
 export {
   profileProcessPids,
-  stopProfileProcesses
+  stopProfileProcesses,
+  stopProfileProcessesSync
 };

package/dist/adapters/slot-ports.js

@@ -1,5 +1,6 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { recipeRuntimeDir } from "../paths.js";
 import {
@@ -131,11 +132,60 @@ function stopExtensionWatcher(target) {
   }
   return ownedPids.length;
 }
+function commandFlagMatches(command, flag, value, mode) {
+  if (!path.isAbsolute(value)) return false;
+  const escapedFlag = escapeRegex(flag);
+  const escapedValue = escapeRegex(value);
+  const unquotedEnd = mode === "exact" ? "(?=\\s|$)" : "([^\\s]*)";
+  const quotedEnd = (quote) => mode === "exact" ? quote : `([^${quote}]*)`;
+  const patterns = [
+    new RegExp(`(?:^|\\s)${escapedFlag}=${escapedValue}${unquotedEnd}`, "u"),
+    new RegExp(`(?:^|\\s)${escapedFlag}="${escapedValue}${quotedEnd('"')}`, "u"),
+    new RegExp(`(?:^|\\s)${escapedFlag}='${escapedValue}${quotedEnd("'")}`, "u"),
+    new RegExp(`(?:^|\\s)${escapedFlag}\\s+${escapedValue}${unquotedEnd}`, "u")
+  ];
+  for (const pattern of patterns) {
+    const match = pattern.exec(command);
+    if (!match) continue;
+    if (mode === "exact") return true;
+    const tail = match[1] ?? "";
+    if (!tail.split(/[\\/]/u).some((segment) => segment === "." || segment === "..")) return true;
+  }
+  return false;
+}
+function pathIsInsideDir(candidate, root) {
+  const resolved = path.resolve(candidate);
+  const base = path.resolve(root);
+  return resolved === base || resolved.startsWith(`${base}${path.sep}`);
+}
+function chromeUserDataDirOwnedByCheckout(command, runtimeAbs) {
+  return commandFlagMatches(command, "--user-data-dir", `${path.resolve(runtimeAbs)}${path.sep}`, "prefix");
+}
+function chromeUserDataDirIs(command, profileAbs) {
+  return commandFlagMatches(command, "--user-data-dir", path.resolve(profileAbs), "exact");
+}
+function commandLoadsCheckoutExtension(command, targetAbs) {
+  const prefix = `${path.resolve(targetAbs)}${path.sep}`;
+  return commandFlagMatches(command, "--load-extension", prefix, "prefix") || commandFlagMatches(command, "--disable-extensions-except", prefix, "prefix");
+}
+function isSharedOrDefaultBrowserProfile(profile) {
+  const resolved = path.resolve(profile);
+  const home = os.homedir();
+  const osDefaults = [
+    path.join(home, "Library/Application Support/Google/Chrome"),
+    path.join(home, "Library/Application Support/Chromium"),
+    path.join(home, "Library/Application Support/Microsoft Edge"),
+    path.join(home, ".config/google-chrome"),
+    path.join(home, ".config/chromium"),
+    path.join(home, ".config/microsoft-edge")
+  ];
+  const underDefault = (dir) => resolved === dir || resolved.startsWith(`${dir}${path.sep}`);
+  return resolved === home || resolved.includes(`${path.sep}.chrome-farmslot`) || osDefaults.some(underDefault);
+}
 function stopExtensionRuntime(target) {
   const resolved = path.resolve(target);
   const runtimeAbs = path.join(resolved, recipeRuntimeDir());
-  const configuredProfile = process.env.CHROME_USER_DATA_DIR || path.join(runtimeAbs, process.env.RECIPE_CHROME_PROFILE_NAME || "chrome-profile");
-  const profiles = process.env.CHROME_USER_DATA_DIR ? [path.resolve(configuredProfile)] : [configuredProfile, path.join(runtimeAbs, "chrome-profile-recipe"), path.join(runtimeAbs, "chrome-profile-pw")].map((value) => path.resolve(value));
+  const extraProfile = process.env.CHROME_USER_DATA_DIR ? path.resolve(process.env.CHROME_USER_DATA_DIR) : null;
   let signalled = stopExtensionWatcher(resolved);
   const ownedBrowserPids = /* @__PURE__ */ new Set();
   try {
@@ -144,7 +194,15 @@ function stopExtensionRuntime(target) {
       const match = /^\s*(\d+)\s+(.*)$/u.exec(line);
       if (!match) continue;
       const pid = Number(match[1]);
-      if (pid !== process.pid && profiles.some((profile) => commandHasExactArg(match[2], "--user-data-dir", profile))) ownedBrowserPids.add(pid);
+      if (pid === process.pid) continue;
+      if (chromeUserDataDirOwnedByCheckout(match[2], runtimeAbs)) {
+        ownedBrowserPids.add(pid);
+        continue;
+      }
+      if (!extraProfile || pathIsInsideDir(extraProfile, runtimeAbs) || isSharedOrDefaultBrowserProfile(extraProfile)) continue;
+      if (chromeUserDataDirIs(match[2], extraProfile) && commandLoadsCheckoutExtension(match[2], resolved)) {
+        ownedBrowserPids.add(pid);
+      }
     }
   } catch {
   }
@@ -203,22 +261,16 @@ function processAlive(pid) {
     return error.code === "EPERM";
   }
 }
-function commandHasExactArg(command, flag, value) {
-  const escapedFlag = escapeRegex(flag);
-  const escapedValue = escapeRegex(value);
-  return [
-    new RegExp(`(?:^|\\s)${escapedFlag}=${escapedValue}(?=\\s|$)`, "u"),
-    new RegExp(`(?:^|\\s)${escapedFlag}="${escapedValue}"(?=\\s|$)`, "u"),
-    new RegExp(`(?:^|\\s)${escapedFlag}='${escapedValue}'(?=\\s|$)`, "u"),
-    new RegExp(`(?:^|\\s)${escapedFlag}\\s+${escapedValue}(?=\\s|$)`, "u")
-  ].some((pattern) => pattern.test(command));
-}
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 export {
   applyKVLines,
+  chromeUserDataDirIs,
+  chromeUserDataDirOwnedByCheckout,
   isExtensionWatcherLive,
+  isSharedOrDefaultBrowserProfile,
+  pathIsInsideDir,
   resolveExtensionSlotPorts,
   resolveMobileSlotPorts,
   stopExtensionRuntime,

package/dist/cli-commands.js

@@ -8,7 +8,11 @@ const SPEC = {
     { name: "help", aliases: ["-h", "--help"], desc: "Show usage" }
   ],
   shared: [
-    { name: "help", desc: "Load version-matched recipe guidance", flags: ["--json", "--adapter", "--target"] },
+    { name: "help", desc: "Load version-matched recipe guidance (help review composes the review guide)", args: ["review"], flags: ["--json", "--adapter", "--target", "--domain"] },
+    { name: "review", desc: "Materialize a review checklist composed from the base review and a team library", args: ["checklist"], flags: ["--domain", "--since", "--base", "--out", "--adapter", "--target", "--json"] },
+    { name: "domain", desc: "Which team library owns the change (declared value, else owned-paths.json)", flags: ["--domain", "--base", "--adapter", "--target", "--json"] },
+    { name: "pr-body", desc: "Render the publishable PR body: pr-description.md plus the recipe and run sections built from artifacts", args: ["render", "<task-dir>"], flags: ["--command", "--out", "--json"] },
+    { name: "config", desc: "Per-engineer locations: libraries.<name>, references.<adapter>", args: ["list", "path", "get", "set", "unset"], flags: ["--json"] },
     { name: "tutorial", desc: "Open the visual recipe tutorial", flags: ["--json", "--no-open"] },
     { name: "setup-base", desc: "Bootstrap numbered product checkouts", flags: ["--dir", "--counts", "--only", "--dry-run", "--force", "--json", "--show-config", "--reset-config", "--skip-harness-update"] },
     { name: "status", aliases: ["health", "home"], desc: "Home status + next commands", flags: ["--json", "--fast"] },

package/dist/cli.js

@@ -25,6 +25,10 @@ import { handleExecutionTemplate } from "./commands/execution-template.js";
 import { handlePrepare } from "./commands/prepare.js";
 import { handleTaskInit } from "./commands/task-init.js";
 import { handleLast } from "./commands/last.js";
+import { handleReview } from "./commands/review.js";
+import { handleDomain } from "./commands/domain.js";
+import { handleConfig } from "./commands/config.js";
+import { handlePrBody } from "./commands/pr-body.js";
 import { parseArgs, targetPath } from "./commands/parse-args.js";
 const COMMANDS = {
   actions: handleActions,
@@ -132,6 +136,10 @@ async function main(argv) {
   if (command === "task") return handleTaskInit(argv.slice(1));
   if (command === "prepare") return handlePrepare(argv.slice(1));
   if (command === "last") return handleLast(parseArgs(argv.slice(1), command));
+  if (command === "review") return handleReview(argv.slice(1));
+  if (command === "domain") return handleDomain(argv.slice(1));
+  if (command === "config") return handleConfig(argv.slice(1));
+  if (command === "pr-body") return handlePrBody(argv.slice(1));
   const handler = COMMANDS[command];
   if (!handler) throw new Error(`Unknown command: ${command}`);
   return handler(parseArgs(argv.slice(1), command));

package/dist/command-contract.js

@@ -58,7 +58,40 @@ const REMOVED_OPTION_REPLACEMENTS = {
 };
 const PUBLIC_COMMAND_CONTRACTS = {
   help: {
-    options: options(HELP, JSON, TARGET, ADAPTER)
+    options: options(HELP, JSON, TARGET, ADAPTER, { "--domain": value() }),
+    positionals: [{ label: "topic", choices: ["review"] }]
+  },
+  review: {
+    options: options(HELP, JSON, TARGET, ADAPTER, {
+      "--domain": value(),
+      "--since": value(),
+      "--base": value(),
+      "--out": value()
+    }),
+    positionals: [{ label: "action", choices: ["checklist"] }],
+    minimumPositionals: 1
+  },
+  domain: {
+    options: options(HELP, JSON, TARGET, ADAPTER, {
+      "--domain": value(),
+      "--base": value()
+    })
+  },
+  "pr-body": {
+    options: options(HELP, JSON, {
+      "--command": value(),
+      "--out": value()
+    }),
+    positionals: [{ label: "action", choices: ["render"] }, { label: "task-dir" }],
+    minimumPositionals: 2
+  },
+  config: {
+    options: options(HELP, JSON),
+    positionals: [
+      { label: "action", choices: ["list", "path", "get", "set", "unset"] },
+      { label: "key" },
+      { label: "value" }
+    ]
   },
   tutorial: {
     options: options(HELP, JSON, NO_OPEN)

package/dist/commands/config.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import {
+  configPath,
+  readConfig,
+  REVIEW_ADAPTERS,
+  writeConfig
+} from "../review/knowledge.js";
+import { optionFlag, parseArgs, usageError } from "./parse-args.js";
+const USAGE = "Usage: mm-harness config <list|path|get <key>|set <key> <path>|unset <key>> [--json]\n  keys: libraries.<name>, references.<mobile|extension|core>";
+function parseKey(raw) {
+  if (!raw) throw usageError(USAGE);
+  const dot = raw.indexOf(".");
+  const section = dot === -1 ? raw : raw.slice(0, dot);
+  const name = dot === -1 ? "" : raw.slice(dot + 1);
+  if (!name) throw usageError(`Config key must be libraries.<name> or references.<adapter> (got ${raw}).`);
+  if (section === "libraries") return { section, name };
+  if (section === "references") {
+    if (!REVIEW_ADAPTERS.includes(name)) {
+      throw usageError(`references.<adapter> must be one of ${REVIEW_ADAPTERS.join(", ")} (got ${name}).`);
+    }
+    return { section, name };
+  }
+  throw usageError(`Config key must start with libraries. or references. (got ${raw}).`);
+}
+function getValue(config, key) {
+  return key.section === "libraries" ? config.libraries?.[key.name] : config.references?.[key.name];
+}
+function setValue(config, key, value) {
+  const section = config[key.section] ?? {};
+  if (value === void 0) delete section[key.name];
+  else section[key.name] = value;
+  if (Object.keys(section).length === 0) delete config[key.section];
+  else config[key.section] = section;
+}
+async function handleConfig(argv) {
+  const parsed = parseArgs(argv, "config");
+  const json = optionFlag(parsed.options, "json");
+  const [action, rawKey, rawValue] = parsed.positional;
+  const expectedPositionals = { path: 1, list: 1, get: 2, set: 3, unset: 2 }[action ?? "list"];
+  if (expectedPositionals !== void 0 && parsed.positional.length > expectedPositionals) {
+    throw usageError(`Unexpected argument "${parsed.positional[expectedPositionals]}". ${USAGE}`);
+  }
+  const file = configPath();
+  const config = readConfig(file);
+  if (action === "path") {
+    process.stdout.write(json ? `${JSON.stringify({ command: "config", path: file })}
+` : `${file}
+`);
+    return 0;
+  }
+  if (action === "list" || action === void 0) {
+    if (json) {
+      process.stdout.write(`${JSON.stringify({ command: "config", path: file, ...config }, null, 2)}
+`);
+      return 0;
+    }
+    const lines = [
+      ...Object.entries(config.libraries ?? {}).map(([name, root]) => `libraries.${name}=${root}`),
+      ...Object.entries(config.references ?? {}).map(([name, root]) => `references.${name}=${root}`)
+    ];
+    process.stdout.write(lines.length > 0 ? `${lines.join("\n")}
+` : `(empty) ${file}
+`);
+    return 0;
+  }
+  if (action === "get") {
+    const value = getValue(config, parseKey(rawKey));
+    if (json) {
+      process.stdout.write(`${JSON.stringify({ command: "config", key: rawKey, value: value ?? null })}
+`);
+      return 0;
+    }
+    if (value === void 0) return 1;
+    process.stdout.write(`${value}
+`);
+    return 0;
+  }
+  if (action === "set") {
+    const key = parseKey(rawKey);
+    if (!rawValue) throw usageError(`mm-harness config set ${rawKey} <path>`);
+    setValue(config, key, path.resolve(rawValue));
+    writeConfig(file, config);
+    process.stdout.write(json ? `${JSON.stringify({ command: "config", key: rawKey, value: path.resolve(rawValue), path: file })}
+` : `${rawKey}=${path.resolve(rawValue)}
+`);
+    return 0;
+  }
+  if (action === "unset") {
+    setValue(config, parseKey(rawKey), void 0);
+    writeConfig(file, config);
+    process.stdout.write(json ? `${JSON.stringify({ command: "config", key: rawKey, value: null, path: file })}
+` : `${rawKey} removed
+`);
+    return 0;
+  }
+  throw usageError(USAGE);
+}
+export {
+  handleConfig
+};