@claude-flow/cli 3.11.0 → 3.12.1

package/plugins/ruflo-metaharness/scripts/mcp-scan.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// mcp-scan.mjs — wrapper around `harness mcp-scan <path>`.
+//
+// Static security scan of the harness's declared MCP surface. Reads
+// .mcp/servers.json + .harness/claims.json. Pure-read, no dispatch.
+//
+// USAGE
+//   node scripts/mcp-scan.mjs                           # current dir
+//   node scripts/mcp-scan.mjs --path <dir>
+//   node scripts/mcp-scan.mjs --fail-on high            # exit 1 if any HIGH finding (default)
+//   node scripts/mcp-scan.mjs --fail-on medium          # also fail on MEDIUM
+//   node scripts/mcp-scan.mjs --format json
+//
+// EXIT CODES
+//   0  no findings at or above --fail-on (or degraded)
+//   1  at least one finding ≥ --fail-on severity
+//   2  config error or scan failure
+
+// iter 50 — parseMcpScanText extracted to _harness.mjs so oia-audit
+// can use the same parser without duplicating logic.
+// iter 63 — SEVERITY_RANK also moves to _harness.mjs (single source of
+// truth; previously this file had a literal that diverged from oia-audit's).
+import { runHarness, emitDegradedJsonAndExit, parseMcpScanText, SEVERITY_RANK, rankSeverity } from './_harness.mjs';
+
+const ARGS = (() => {
+  const a = { path: '.', format: 'json', failOn: 'high' };
+  for (let i = 2; i < process.argv.length; i++) {
+    const v = process.argv[i];
+    if (v === '--path') a.path = process.argv[++i];
+    else if (v === '--fail-on') a.failOn = String(process.argv[++i] || 'high').toLowerCase();
+    else if (v === '--format') a.format = process.argv[++i];
+  }
+  return a;
+})();
+
+function main() {
+  if (!SEVERITY_RANK[ARGS.failOn]) {
+    console.error(`mcp-scan: --fail-on must be one of low|medium|high; got ${ARGS.failOn}`);
+    process.exit(2);
+  }
+  const r = runHarness(['mcp-scan', ARGS.path]);
+  if (r.degraded) { emitDegradedJsonAndExit(r.reason); return; }
+  if (r.exitCode !== 0 && r.exitCode !== 1) {
+    // exit 1 from harness can be "findings present"; only treat other
+    // non-zero as a real failure.
+    console.error(`mcp-scan: harness exited ${r.exitCode}`);
+    if (r.stderr) console.error(r.stderr.slice(0, 400));
+    process.exit(2);
+  }
+  // The JSON output shape from `harness mcp-scan` historically didn't
+  // include structured findings — it emits text even with --json. Parse
+  // the text into findings (iter 50) so audit-trend's introduced/cleared
+  // diff actually works. If a future upstream version DOES emit
+  // findings[], the parsed-text findings are overridden.
+  const parsed = parseMcpScanText(r.stdout);
+  // iter 124 — normalize finding shape so consumers see a stable contract.
+  // Upstream metaharness@0.1.x JSON path emits {id, severity, title, detail};
+  // our parseMcpScanText emits {severity, message}. Project both into a
+  // unified {severity, message, title?, detail?} so audit-trend's fingerprint
+  // diff and test-mcp-tools' assertions don't care which path produced them.
+  const rawFindings = Array.isArray(r.json?.findings) ? r.json.findings : parsed.findings;
+  const findings = rawFindings.map((f) => ({
+    ...f,
+    message: typeof f.message === 'string' && f.message
+      ? f.message
+      : (f.title || f.detail || ''),
+  }));
+  const payload = {
+    ...(r.json ?? {}),
+    findings,
+    summary: r.json?.summary ?? parsed.summary,
+    rawStdout: r.stdout.slice(0, 400),
+  };
+  const threshold = SEVERITY_RANK[ARGS.failOn];
+  // iter 63 — rankSeverity() safe lookup. Pre-iter-63 `undefined >= 3`
+  // was false → unknown-severity findings (e.g., warn / error) were
+  // silently excluded from the offending set, weakening --fail-on alerts.
+  const offending = findings.filter((f) => rankSeverity(f.severity) >= threshold);
+
+  const alert = {
+    threshold: ARGS.failOn,
+    triggered: offending.length > 0,
+    offendingCount: offending.length,
+    reason: offending.length > 0
+      ? `${offending.length} finding(s) at or above ${ARGS.failOn} severity`
+      : `no findings at or above ${ARGS.failOn} severity — OK`,
+  };
+
+  if (ARGS.format === 'json') {
+    // iter 112 — generatedAt for consistency with other --format json outputs
+    console.log(JSON.stringify({
+      ...payload, durationMs: r.durationMs, alert,
+      generatedAt: new Date().toISOString(),
+    }, null, 2));
+  } else {
+    console.log(`# harness mcp-scan — ${ARGS.path}`);
+    console.log('');
+    console.log(`Total findings: ${findings.length}`);
+    console.log(`| Severity | ID | Server | Tool | Message |`);
+    console.log(`|---|---|---|---|---|`);
+    for (const f of findings.slice(0, 50)) {
+      console.log(`| ${f.severity} | ${f.id ?? '—'} | ${f.server ?? '—'} | ${f.tool ?? '—'} | ${f.message ?? ''} |`);
+    }
+    console.log('');
+    console.log(alert.triggered ? `⚠ **ALERT**: ${alert.reason}` : `✓ ${alert.reason}`);
+  }
+
+  if (alert.triggered) process.exit(1);
+}
+
+main();

package/plugins/ruflo-metaharness/scripts/mint.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+// mint.mjs — wrapper around `metaharness new <name> --template <id> --host <id>`.
+//
+// SAFETY (ADR-150 architectural constraint + "executing actions with care"):
+//   - Target directory MUST be explicitly specified via --target. Defaults to
+//     a temp dir under /tmp/ruflo-mint-<timestamp>/ if not given — never the
+//     project root (ruflo behavioral rule "never save to root folder").
+//   - --confirm flag required. Without it the script prints a dry-run plan
+//     and exits 0 without writing files. This honors the "destructive-action
+//     confirmation" pattern in ruflo's CLAUDE.md.
+//
+// USAGE
+//   node scripts/mint.mjs --name my-harness --template vertical:coding --host claude-code
+//     # → prints dry-run plan, exits 0
+//   node scripts/mint.mjs --name my-harness --template vertical:coding --host claude-code --target /tmp/foo --confirm
+//     # → actually scaffolds
+
+import { runMetaharness, emitDegradedJsonAndExit } from './_harness.mjs';
+import { existsSync, mkdirSync } from 'node:fs';
+import { resolve, dirname, basename } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const ARGS = (() => {
+  const a = { name: null, template: null, host: 'claude-code', target: null, confirm: false, format: 'json' };
+  for (let i = 2; i < process.argv.length; i++) {
+    const v = process.argv[i];
+    if (v === '--name') a.name = process.argv[++i];
+    else if (v === '--template') a.template = process.argv[++i];
+    else if (v === '--host') a.host = process.argv[++i];
+    else if (v === '--target') a.target = process.argv[++i];
+    else if (v === '--confirm') a.confirm = true;
+    else if (v === '--format') a.format = process.argv[++i];
+  }
+  return a;
+})();
+
+function safetyChecks() {
+  if (!ARGS.name) {
+    console.error('mint: --name is required');
+    process.exit(2);
+  }
+  if (!ARGS.template) {
+    console.error('mint: --template is required (e.g. vertical:coding, minimal)');
+    process.exit(2);
+  }
+  if (!ARGS.target) {
+    ARGS.target = resolve(tmpdir(), `ruflo-mint-${Date.now()}-${ARGS.name}`);
+  }
+  const targetAbs = resolve(ARGS.target);
+  const repoRoot = resolve(process.cwd());
+  if (targetAbs === repoRoot) {
+    console.error(`mint: refusing to write to project root (${repoRoot}). Specify a different --target.`);
+    process.exit(2);
+  }
+  if (targetAbs.startsWith(repoRoot + '/')) {
+    console.error(`mint: refusing to write inside the calling repo root. Use a --target outside ${repoRoot}.`);
+    process.exit(2);
+  }
+}
+
+function main() {
+  safetyChecks();
+  const plan = {
+    action: 'metaharness new',
+    name: ARGS.name,
+    template: ARGS.template,
+    host: ARGS.host,
+    target: ARGS.target,
+    confirm: ARGS.confirm,
+    willWrite: ARGS.confirm,
+  };
+  if (!ARGS.confirm) {
+    if (ARGS.format === 'json') console.log(JSON.stringify({ ...plan, dryRun: true }, null, 2));
+    else {
+      console.log(`# harness-mint (dry-run)`);
+      console.log('');
+      for (const [k, v] of Object.entries(plan)) console.log(`- ${k}: ${v}`);
+      console.log('');
+      console.log('Re-run with `--confirm` to actually scaffold.');
+    }
+    process.exit(0);
+  }
+  if (existsSync(ARGS.target)) {
+    console.error(`mint: target ${ARGS.target} already exists`);
+    process.exit(2);
+  }
+  // ITER 27 FIX (forward-compatible) — at the time of writing,
+  // metaharness@0.1.12 silently ignored the --target flag and wrote
+  // to $CWD/<name> instead. Upstream issue #9
+  // (ruvnet/agent-harness-generator) was filed + fixed in 0.1.13
+  // within ~20 min — but this workaround is intentionally
+  // forward-compatible: setting `cwd: dirname(target)` + passing
+  // `basename(target)` as <name> produces the same correct landing
+  // path on BOTH broken (0.1.12) and fixed (0.1.13+) upstream
+  // versions. Keeping it as belt-and-braces against any future
+  // regression. See `iter 29` for the verification log.
+  const parentDir = dirname(ARGS.target);
+  const cliName = basename(ARGS.target);
+  mkdirSync(parentDir, { recursive: true });
+  const r = runMetaharness(
+    ['new', cliName, '--template', ARGS.template, '--host', ARGS.host],
+    { json: false, cwd: parentDir, timeoutMs: 180_000 },
+  );
+  if (r.degraded) { emitDegradedJsonAndExit(r.reason); return; }
+  if (r.exitCode !== 0) {
+    console.error(`mint: metaharness exited ${r.exitCode}`);
+    if (r.stderr) console.error(r.stderr.slice(0, 400));
+    process.exit(2);
+  }
+  const result = { ...plan, exitCode: r.exitCode, durationMs: r.durationMs, ok: true };
+  if (ARGS.format === 'json') console.log(JSON.stringify(result, null, 2));
+  else {
+    console.log(`# harness-mint — done`);
+    console.log('');
+    for (const [k, v] of Object.entries(result)) console.log(`- ${k}: ${v}`);
+  }
+}
+
+main();

package/plugins/ruflo-metaharness/scripts/oia-audit.mjs

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+// oia-audit.mjs — composite Phase-2 worker (ADR-150).
+//
+// Bundles three MetaHarness static-analysis surfaces into one timestamped
+// audit record:
+//   - harness oia-manifest   (Open Infrastructure Architecture L1-L9 alignment)
+//   - harness threat-model   (categorized MCP-surface threat report)
+//   - harness mcp-scan       (per-server/tool policy + permissions + deps)
+//
+// The combined record is stored in the `metaharness-audit` memory
+// namespace, keyed by ISO timestamp. Designed to be invoked on a cron
+// schedule (e.g. weekly) so audit drift is visible over time.
+//
+// USAGE
+//   node scripts/oia-audit.mjs                      # run + store
+//   node scripts/oia-audit.mjs --path <dir>         # audit specific dir
+//   node scripts/oia-audit.mjs --dry-run            # don't write to memory
+//   node scripts/oia-audit.mjs --alert-on-worst high
+//                                                  # exit 1 if threat-model worst >= high
+//   node scripts/oia-audit.mjs --format json
+//
+// EXIT CODES
+//   0  audit OK (or degraded)
+//   1  --alert-on-worst threshold exceeded
+//   2  config error or audit failure
+
+import { spawnSync } from 'node:child_process';
+// iter 63 — SEVERITY_RANK + rankSeverity consolidated to _harness.mjs
+// (was local in iter 62; now shared with audit-trend + mcp-scan).
+import { runHarness, runMetaharness, runHarnessAsync, runMetaharnessAsync, emitDegradedJsonAndExit, parseMcpScanText, SEVERITY_RANK, rankSeverity } from './_harness.mjs';
+
+// iter 63 — SEVERITY_RANK + rankSeverity moved to _harness.mjs (single
+// source of truth). The local copy from iter 62 is gone; the imports
+// at the top of this file provide the same names.
+const NS = process.env.OIA_AUDIT_NAMESPACE || 'metaharness-audit';
+const CLI_PKG = process.env.CLI_CORE === '1'
+  ? '@claude-flow/cli-core@alpha'
+  : '@claude-flow/cli@latest';
+
+const ARGS = (() => {
+  const a = { path: '.', format: 'json', dryRun: false, alertWorst: null };
+  for (let i = 2; i < process.argv.length; i++) {
+    const v = process.argv[i];
+    if (v === '--path') a.path = process.argv[++i];
+    else if (v === '--dry-run') a.dryRun = true;
+    else if (v === '--alert-on-worst') a.alertWorst = String(process.argv[++i] || '').toLowerCase();
+    else if (v === '--format') a.format = process.argv[++i];
+  }
+  return a;
+})();
+
+// iter 47 — the `harness` and `metaharness` CLIs both have `score` /
+// `genome` subcommands but with DIFFERENT output schemas. For the
+// fingerprint to be consumable by _similarity.mjs (which expects the
+// metaharness CLI shape: harnessFit/compileConfidence/agent_topology),
+// we need to dispatch to runMetaharness for score+genome, not runHarness.
+// iter 56 — annotated runOne result is identical for sync/async paths.
+function annotateOne(r, label) {
+  let json = r.json;
+  if (label === 'mcp-scan' && !json && !r.degraded && r.stdout) {
+    const parsed = parseMcpScanText(r.stdout);
+    json = { findings: parsed.findings, summary: parsed.summary, rawStdout: r.stdout.slice(0, 400) };
+  }
+  return {
+    label,
+    exitCode: r.exitCode,
+    degraded: r.degraded,
+    reason: r.degraded ? r.reason : null,
+    json,
+    durationMs: r.durationMs,
+    stderrTail: r.degraded ? (r.stderr || '').slice(-200) : null,
+  };
+}
+
+function runOne(args, label, engine = 'harness') {
+  const r = engine === 'metaharness' ? runMetaharness(args) : runHarness(args);
+  return annotateOne(r, label);
+}
+
+// iter 56 — parallel variant. The composite audit's 5 subprocess calls
+// are mutually independent (each scans the same path read-only), so
+// they can run concurrently. Worst-case wall-clock drops from
+// 5×DEFAULT_TIMEOUT_MS (sequential) to 1×DEFAULT_TIMEOUT_MS (parallel)
+// — the iter-55-flagged gap (oia-audit timeout under unreachable
+// registry) is closed by this.
+async function runAllParallel(path) {
+  const tasks = [
+    runHarnessAsync(['oia-manifest', path]).then((r) => ['oiaManifest', annotateOne(r, 'oia-manifest')]),
+    runHarnessAsync(['threat-model', path]).then((r) => ['threatModel', annotateOne(r, 'threat-model')]),
+    runHarnessAsync(['mcp-scan', path]).then((r) => ['mcpScan', annotateOne(r, 'mcp-scan')]),
+    runMetaharnessAsync(['score', path]).then((r) => ['score', annotateOne(r, 'score')]),
+    runMetaharnessAsync(['genome', path]).then((r) => ['genome', annotateOne(r, 'genome')]),
+  ];
+  const results = await Promise.all(tasks);
+  return Object.fromEntries(results);
+}
+
+function persist(payload) {
+  const key = `audit-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+  const r = spawnSync('npx', [
+    CLI_PKG, 'memory', 'store',
+    '--namespace', NS,
+    '--key', key,
+    '--value', JSON.stringify(payload),
+  ], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', shell: process.platform === 'win32' });
+  return {
+    ok: r.status === 0,
+    namespace: NS,
+    key,
+    error: r.status === 0 ? null : (r.stderr || '').slice(0, 200),
+  };
+}
+
+async function main() {
+  if (ARGS.alertWorst !== null && !SEVERITY_RANK.hasOwnProperty(ARGS.alertWorst)) {
+    console.error(`oia-audit: --alert-on-worst must be one of clean|low|medium|high; got ${ARGS.alertWorst}`);
+    process.exit(2);
+  }
+
+  const startedAt = new Date().toISOString();
+  const wallStart = Date.now();
+  // iter 56 — run the 5 sub-audits in parallel (was sequential pre-iter-56).
+  // Worst-case wall-clock improves from 5×TIMEOUT to 1×TIMEOUT in the
+  // unreachable-registry case; the happy path improves from sum-of-durations
+  // to max-of-durations (typically ~2-4× faster).
+  const all = await runAllParallel(ARGS.path);
+  const wallMs = Date.now() - wallStart;
+  const { oiaManifest: oia, threatModel: tm, mcpScan: mcp, score, genome } = all;
+
+  // If all FIVE say "metaharness not available", surface the degraded
+  // payload exactly once and exit 0 (architectural constraint #3).
+  if (oia.degraded && tm.degraded && mcp.degraded && score.degraded && genome.degraded) {
+    emitDegradedJsonAndExit('metaharness-not-available');
+    return;
+  }
+
+  // Aggregate the worst-severity signal across mcp-scan + threat-model.
+  // iter 62 — safe lookup using `?? 0` so unknown severities don't
+  // silently bump composite via NaN-comparison (was: `acc | undefined`
+  // → reduce never updated). Now any [WARN]/[CRITICAL]/[ERROR] finding
+  // correctly elevates composite worst.
+  const tmWorst = String(tm.json?.worst || 'clean').toLowerCase();
+  const mcpFindings = Array.isArray(mcp.json?.findings) ? mcp.json.findings : [];
+  // iter 63 — rankSeverity() from _harness.mjs handles unknown-severity
+  // safely (returns 0 instead of undefined) so the reduce never sees NaN.
+  const mcpWorst = mcpFindings.reduce((acc, f) => {
+    const s = String(f.severity || 'low').toLowerCase();
+    return rankSeverity(s) > rankSeverity(acc) ? s : acc;
+  }, 'clean');
+  const compositeWorst = rankSeverity(tmWorst) > rankSeverity(mcpWorst) ? tmWorst : mcpWorst;
+
+  let alertTriggered = false;
+  let alertReason = null;
+  if (ARGS.alertWorst !== null) {
+    const threshold = rankSeverity(ARGS.alertWorst);
+    const compositeRank = rankSeverity(compositeWorst);
+    if (compositeRank >= threshold && threshold > 0) {
+      alertTriggered = true;
+      alertReason = `composite worst=${compositeWorst} ≥ ${ARGS.alertWorst}`;
+    }
+  }
+
+  // iter 59 — surface parallelization metrics. wallMs is the actual
+  // time the 5 subprocess race took (max of components); the sum of
+  // component.durationMs is what a SERIAL implementation would have
+  // taken. A future smoke gate compares them to catch silent
+  // serialization regression.
+  const sumComponentMs = Object.values(all).reduce(
+    (a, c) => a + (c?.durationMs ?? 0), 0);
+  const payload = {
+    path: ARGS.path,
+    startedAt,
+    finishedAt: new Date().toISOString(),
+    timing: {
+      wallMs,
+      sumComponentMs,
+      parallelSpeedup: sumComponentMs > 0
+        ? Math.round((sumComponentMs / Math.max(wallMs, 1)) * 100) / 100 : 0,
+    },
+    composite: { worst: compositeWorst, threatModelWorst: tmWorst, mcpScanWorst: mcpWorst },
+    components: { oiaManifest: oia, threatModel: tm, mcpScan: mcp, score, genome },
+    // iter 38 — denormalized harness fingerprint for cheap similarity().
+    // Mirrors the shape `_similarity.mjs::similarity()` expects so
+    // audit-trend can call it without reshuffling components.
+    fingerprint: {
+      score: score?.json && !score.degraded ? score.json : null,
+      genome: genome?.json && !genome.degraded ? genome.json : null,
+    },
+    alert: ARGS.alertWorst !== null ? {
+      threshold: ARGS.alertWorst,
+      triggered: alertTriggered,
+      reason: alertReason || `composite worst=${compositeWorst} < ${ARGS.alertWorst} — OK`,
+    } : null,
+    persisted: null,
+  };
+
+  if (!ARGS.dryRun) {
+    payload.persisted = persist(payload);
+  }
+
+  if (ARGS.format === 'json') {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(`# oia-audit — ${ARGS.path}`);
+    console.log('');
+    console.log(`| Component | Exit | Degraded | Duration |`);
+    console.log(`|---|---:|:---:|---:|`);
+    console.log(`| oia-manifest | ${oia.exitCode} | ${oia.degraded ? '⚠' : '✓'} | ${oia.durationMs}ms |`);
+    console.log(`| threat-model | ${tm.exitCode} | ${tm.degraded ? '⚠' : '✓'} | ${tm.durationMs}ms |`);
+    console.log(`| mcp-scan | ${mcp.exitCode} | ${mcp.degraded ? '⚠' : '✓'} | ${mcp.durationMs}ms |`);
+    console.log('');
+    console.log(`Composite worst severity: **${compositeWorst}** (tm=${tmWorst}, mcp=${mcpWorst})`);
+    if (payload.persisted) {
+      console.log(`Persisted: ${payload.persisted.ok ? `${payload.persisted.namespace}:${payload.persisted.key}` : `FAILED: ${payload.persisted.error}`}`);
+    }
+    if (payload.alert) {
+      console.log('');
+      console.log(payload.alert.triggered ? `⚠ **ALERT**: ${payload.alert.reason}` : `✓ ${payload.alert.reason}`);
+    }
+  }
+
+  if (alertTriggered) process.exit(1);
+}
+
+main().catch((e) => {
+  console.error('oia-audit crashed:', e?.message ?? e);
+  process.exit(2);
+});