ruvnet-brain 4.7.22 → 4.7.24

package/scripts/issue-autofix-report.mjs

@@ -0,0 +1,121 @@
+// scripts/issue-autofix-report.mjs — S13 / S13b of the autofix job (ADR-107): tell the people who filed issues.
+// ONE note per person per night, covering all of their issues, written fresh from their own words in the full thread
+// and checked by issue-autofix-notes.mjs (specific, not boilerplate, not like any earlier note to anyone, apologetic
+// after a 7-day wait, truthful about what was and was not verified). A note that never passes is not posted: the
+// factual report goes out without it and the owner is paged to write one. The text rules of every comment live in
+// issue-autofix-comment.mjs; this module decides WHETHER to post, reading the live thread so a wiped state file can
+// never cause a second comment, and closes an issue only after a `fixed` comment naming an install-verified version.
+import fs from 'node:fs';
+import path from 'node:path';
+import { alreadyPosted, renderComment, postOutcome } from './issue-autofix-comment.mjs';
+import { groupByPerson, reporterWords, waitedDays, generatePersonNote, noteText } from './issue-autofix-notes.mjs';
+import { verifyTerminal } from './issue-autofix-release.mjs';
+import { patchIssue, readNs, patchNs, clearAwaiting } from './issue-autofix-state.mjs';
+
+const VIEW_FIELDS = 'number,title,author,body,labels,comments,updatedAt,state,createdAt';
+const NOTES_KEPT = 400;
+const NEEDS_OWNER_LABEL = { findings: ['autofix:needs-owner'], 'not-fixed': ['autofix:needs-owner'], reply: ['autofix:needs-owner'] };
+
+export function viewIssue(rt, n) {
+  const r = rt.exec(rt.ghBin, ['issue', 'view', String(n), '--repo', rt.repo, '--json', VIEW_FIELDS]);
+  if (r.status !== 0) return null;
+  try { return JSON.parse(r.stdout); } catch { return null; }
+}
+
+const words = (t) => String(t).split(/\s+/).filter(Boolean);
+export const priorNotes = (rt) => (readNs(rt.paths.state)._notesLog || []);
+const openings = (notes) => notes.map((n) => `${words(n.text).slice(0, 8).join(' ')} … ${words(n.text).slice(-8).join(' ')}`);
+
+async function writeNote(rt, login, group, now) {
+  const items = group.items.map((it) => ({ number: it.issue.number, title: it.issue.title, theirWords: reporterWords(it.issue, login),
+    waitedDays: waitedDays(it.issue, now), kind: it.kind, facts: it.facts }));
+  const prior = [...priorNotes(rt), ...rt.tonightNotes];
+  fs.mkdirSync(rt.tmpRoot, { recursive: true });
+  const tmp = fs.mkdtempSync(path.join(rt.tmpRoot, 'autofix-note-'));
+  return generatePersonNote({ login, items: group.items, priorNotes: prior, now, generate: async ({ feedback }) => {
+    const r = await rt.agent('note', 'S5b', tmp, { login, items, priorOpenings: openings(prior), feedback });
+    return r.result;
+  } });
+}
+
+/**
+ * items: [{ issue (full view), kind: fixed|shipping|findings|not-fixed|reply, facts, version?, sha?, testPath?,
+ *   platformCaveat?, fallback: {whatWasWrong, whatChanged?, whatItNeeds?} }]. `checkpoint` is re-run before every post.
+ * Returns per-issue results. Never throws for a GitHub failure: the state keeps what still needs saying.
+ */
+export async function notifyPeople(rt, items, { checkpoint }) {
+  const results = [];
+  const now = rt.now();
+  for (const group of groupByPerson(items)) {
+    const login = group.login;
+    let gen;
+    try { gen = await writeNote(rt, login, group, now); } catch (e) { gen = { ok: false, note: null, rejections: [[`error:${e.code || e.message}`]] }; }
+    if (!gen.ok) rt.page(`AUTOFIX NEEDS OWNER: write a personal thank-you to @${login}`, `No note passed the guards in ${gen.attempts ?? 0} attempts (${JSON.stringify(gen.rejections).slice(0, 400)}). Issues ${group.items.map((i) => i.issue.number).join(', ')} got the factual report only.`);
+    let thanksOn = null;
+    for (const it of group.items) {
+      const n = it.issue.number;
+      await checkpoint(n);
+      const view = viewIssue(rt, n);
+      if (!view) { results.push({ number: n, kind: it.kind, commented: false, error: 'cannot read the issue thread' }); continue; }
+      const close = it.kind === 'fixed' && String(view.state || 'OPEN').toUpperCase() === 'OPEN';
+      if (alreadyPosted(view.comments || [], { outcome: it.kind, version: it.version, issueUpdatedAt: view.updatedAt })) {
+        let closed = false;
+        if (close) closed = rt.exec(rt.ghBin, ['issue', 'close', String(n), '--repo', rt.repo, '--reason', 'completed']).status === 0;
+        results.push({ number: n, kind: it.kind, commented: false, deduped: true, closed });
+        continue;
+      }
+      const entry = { ...it.fallback, ...((gen.note?.perIssue || []).find((p) => p.number === n) || {}) };
+      const thanks = gen.ok && thanksOn === null ? gen.note.thanks : null;
+      const body = renderComment({ kind: it.kind, issueNumber: n, login: view.author?.login || login, thanks, thanksOn, entry,
+        facts: it.facts, version: it.version, sha: it.sha, commitUrl: it.sha ? `https://github.com/${rt.repo}/commit/${it.sha}` : undefined,
+        testPath: it.testPath, platformCaveat: it.platformCaveat || [], at: new Date(rt.now()).toISOString() });
+      const r = postOutcome({ repo: rt.repo, exec: rt.exec, ghBin: rt.ghBin }, { issueNumber: n, body, close, addLabels: NEEDS_OWNER_LABEL[it.kind] || [] });
+      if (r.commented && thanks) {
+        thanksOn = n;
+        const rec = { login: login.toLowerCase(), text: noteText(gen.note), at: new Date(rt.now()).toISOString(), issues: group.items.map((x) => x.issue.number) };
+        rt.tonightNotes.push(rec);
+        patchNs(rt.paths.state, { _notesLog: [...priorNotes(rt), rec].slice(-NOTES_KEPT) });
+      }
+      if (r.commented) {
+        patchIssue(rt.paths.state, n, { outcomes: [...(readNs(rt.paths.state)[n]?.outcomes || []), { kind: it.kind, version: it.version ?? null, postedAt: new Date(rt.now()).toISOString() }],
+          ...(it.kind === 'findings' ? { findingsPostedAt: new Date(rt.now()).toISOString() } : {}) });
+      }
+      results.push({ number: n, kind: it.kind, commented: r.commented, closed: r.closed, thanksIncluded: !!(r.commented && thanks), error: r.error, body });
+    }
+  }
+  return results;
+}
+
+/**
+ * S13b: issues whose release was published but not yet install-verified. Runs EVEN WHILE HALTED (it only reads and
+ * comments): when the terminal check now passes, say `fixed` and close; after 72 h unresolved, page.
+ */
+export async function recheckAwaiting(rt, ctx, { checkpoint }) {
+  const done = [];
+  const due = [];
+  for (const [key, rec] of Object.entries(readNs(rt.paths.state))) {
+    const a = rec?.awaitingVerification;
+    if (!/^\d+$/.test(key) || !a) continue;
+    const n = Number(key);
+    const t = await verifyTerminal(ctx, { version: a.version, sha: a.sha });
+    if (!t.installVerified) {
+      if (rt.now() - Date.parse(a.publishedAt) > 72 * 3_600_000) rt.page(`AUTOFIX NEEDS OWNER #${n}: v${a.version} still unverified after 72 h`, 'The release was published but its install verification never passed.', 'high');
+      done.push({ number: n, outcome: 'still-awaiting' });
+      continue;
+    }
+    const view = viewIssue(rt, n);
+    if (!view) { done.push({ number: n, outcome: 'unreadable' }); continue; }
+    due.push({ issue: view, kind: 'fixed', facts: { verified: [...(a.facts?.verified || []), 'install-verified on Linux, macOS and Windows'], notVerified: a.facts?.notVerified || [] },
+      version: a.version, sha: a.fixSha || a.sha, testPath: a.testPath, platformCaveat: a.platformCaveat || [], fallback: a.fallback || { whatWasWrong: 'see the linked commit', whatChanged: 'see the linked commit' } });
+  }
+  if (!due.length) return done;
+  for (const r of await notifyPeople(rt, due, { checkpoint })) {
+    if (r.commented || r.deduped) {
+      clearAwaiting(rt.paths.state, r.number);
+      patchIssue(rt.paths.state, r.number, { lastOutcome: 'shipped' });
+      rt.page(`AUTOFIX SHIPPED #${r.number}`, 'Install-verified; the reporter was told and the issue closed.', 'low');
+    }
+    done.push({ number: r.number, outcome: r.commented || r.deduped ? 'fixed' : 'comment-failed', error: r.error });
+  }
+  return done;
+}

package/scripts/issue-autofix-runner.mjs

@@ -0,0 +1,75 @@
+// scripts/issue-autofix-runner.mjs — where the nightly autofix job's OWN code lives (ADR-107).
+// launchd runs the job from ~/.cache/ruvnet-brain/autofix-runner: a detached worktree of the job's clone, pinned to
+// the newest install-verified release tag. Never the owner's checkout: that would make the job depend on, and run, the
+// owner's uncommitted work. After each run the runner moves to the newest tag that is published on npm, is GitHub's
+// latest release, and resolves as install-verified — for the NEXT run; the running process is never changed under
+// itself. Every file the runner executes is outside the editable allowlist (tests/unit/issue-autofix-deploy.test.mjs
+// proves it over the whole import closure), so the job cannot change its own code; only a person's release can.
+//
+//   node scripts/issue-autofix-runner.mjs --install --tag vX.Y.Z   (arming: create the runner at a released tag)
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
+import { makeExec } from './issue-autofix-exec.mjs';
+import { PATHS } from './issue-autofix-state.mjs';
+
+export const runnerPath = (home) => path.join(home, '.cache', 'ruvnet-brain', 'autofix-runner');
+const TAG = /^v\d+\.\d+\.\d+$/;
+const ver = (t) => String(t).replace(/^v/, '').split('.').map(Number);
+const newer = (a, b) => { const x = ver(a); const y = ver(b); for (let i = 0; i < 3; i += 1) if (x[i] !== y[i]) return x[i] > y[i]; return false; };
+
+function runnerVersion(dir) {
+  try { return `v${JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')).version}`; } catch { return null; }
+}
+
+/** Point the runner at `tag` (fetching it into the clone) and install its node_modules. Throws on any failure. */
+export function checkoutRunner(exec, { clone, runner, tag }) {
+  if (!TAG.test(tag)) throw new Error(`not a release tag: ${tag}`);
+  const must = (args, opts) => { const r = exec('git', args, opts); if (r.status !== 0) throw new Error(`git ${args.join(' ')}: ${r.stderr.slice(-300)}`); return r; };
+  must(['-C', clone, 'fetch', '-q', 'origin', `refs/tags/${tag}:refs/tags/${tag}`]);
+  if (!fs.existsSync(path.join(runner, '.git'))) {
+    fs.mkdirSync(path.dirname(runner), { recursive: true });
+    must(['-C', clone, 'worktree', 'add', '--detach', runner, tag]);
+  } else {
+    if (exec('git', ['-C', runner, 'status', '--porcelain', '--untracked-files=no']).stdout.trim()) throw new Error('the runner worktree has local changes; it is never overwritten');
+    must(['-C', runner, 'checkout', '-q', '--detach', tag]);
+  }
+  fs.mkdirSync(path.join(runner, 'logs'), { recursive: true }); // launchd's StandardOutPath/StandardErrorPath live here
+  const ci = exec('npm', ['ci', '--no-audit', '--no-fund'], { cwd: runner, timeoutMs: 30 * 60_000 });
+  if (ci.status !== 0) throw new Error(`npm ci in the runner failed: ${ci.stderr.slice(-300)}`);
+  return runnerVersion(runner);
+}
+
+/**
+ * After a live run: move the runner to `latestTag` when it is newer AND install-verified. Best effort; never throws.
+ * Returns { moved, from, to, reason }.
+ */
+export async function advanceRunner(rt, { latestTag, installVerified }) {
+  const runner = rt.paths.runner;
+  if (!runner) return { moved: false, from: null, to: null, reason: 'no runner path' };
+  const from = runnerVersion(runner);
+  if (!fs.existsSync(path.join(runner, '.git'))) return { moved: false, from, to: null, reason: 'no runner worktree (not armed from one)' };
+  if (!latestTag || !TAG.test(latestTag) || !from || !newer(latestTag, from)) return { moved: false, from, to: latestTag, reason: 'up to date' };
+  if (!installVerified) return { moved: false, from, to: latestTag, reason: `${latestTag} is not install-verified yet` };
+  try { return { moved: true, from, to: checkoutRunner(rt.exec, { clone: rt.paths.clone, runner, tag: latestTag }), reason: 'advanced' }; }
+  catch (e) { return { moved: false, from, to: latestTag, reason: e.message.slice(0, 300) }; }
+}
+
+if (isDirectInvocation(import.meta.url)) {
+  const argv = process.argv.slice(2);
+  const tag = argv[argv.indexOf('--tag') + 1];
+  if (!argv.includes('--install') || !TAG.test(String(tag))) {
+    console.error('usage: node scripts/issue-autofix-runner.mjs --install --tag vX.Y.Z');
+    process.exit(2);
+  }
+  const home = process.env.HOME || os.homedir();
+  const paths = PATHS(home);
+  const exec = makeExec({ primary: paths.primary });
+  if (!fs.existsSync(path.join(paths.clone, '.git'))) {
+    const r = exec('git', ['clone', '-q', '--no-checkout', 'https://github.com/stuinfla/ruvnet-brain.git', paths.clone]);
+    if (r.status !== 0) { console.error(r.stderr); process.exit(1); }
+  }
+  try { console.log(`runner ${runnerPath(home)} at ${checkoutRunner(exec, { clone: paths.clone, runner: runnerPath(home), tag })}`); }
+  catch (e) { console.error(`issue-autofix-runner: ${e.message}`); process.exit(1); }
+}

package/scripts/issue-autofix-sandbox.mjs

@@ -0,0 +1,108 @@
+// scripts/issue-autofix-sandbox.mjs — the ONLY way the autofix job (ADR-107) runs code a model wrote.
+//
+// The build stage edits files from a stranger's issue. Running its tests (test validity, the verifier's evidence
+// re-runs) executes that code on the owner's Mac, where the gh token sits in ~/.config/gh/hosts.yml and Claude's
+// OAuth credential sits in the login keychain. So every such run goes through macOS `sandbox-exec` with a profile
+// that denies ALL outbound network, keychain lookups, reads of credential stores and private folders, and every write
+// outside the worktree and a per-run temp dir; the child also gets a minimal environment (no tokens, HOME = temp).
+// Measured on this Mac (Darwin 27, 2026-10-30): inside the profile vitest runs normally while ~/.npmrc,
+// ~/.config/gh, ~/.ssh, the Claude keychain item, curl and fetch are all refused (scratchpad probe, see ADR-107).
+// Off macOS, or with sandbox-exec missing, nothing runs: AutofixAbort('sandbox-unavailable') — fail closed.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { AutofixAbort } from './issue-autofix-policy.mjs';
+
+export const SANDBOX_BIN = '/usr/bin/sandbox-exec';
+const q = (p) => JSON.stringify(String(p)); // SBPL string literal (paths never contain quotes; JSON escaping is exact)
+
+const real = (p) => { try { return fs.realpathSync(p); } catch { return path.resolve(p); } };
+/** Every hop of a symlink chain: the kernel checks each link it walks, so each must be readable. */
+function linkChain(p, out = new Set()) {
+  let cur = path.resolve(p);
+  for (let i = 0; i < 16 && !out.has(cur); i += 1) {
+    out.add(cur);
+    let next;
+    try { next = path.resolve(path.dirname(cur), fs.readlinkSync(cur)); } catch { break; }
+    cur = next;
+  }
+  out.add(real(p));
+  return out;
+}
+
+/** Home-relative stores the child may never read (credentials, browser data, other projects' .env files). */
+export const READ_DENY_HOME = ['.ssh', '.npmrc', '.netrc', '.aws', '.config', '.claude', '.gnupg', '.docker', '.kube',
+  '.git-credentials', '.gitconfig', '.local/share', '.npm/_cacache', 'Library', 'Documents', 'Desktop', 'Downloads', 'Code', '.cache/ruvnet-brain'];
+const SECRET_MACH = ['com.apple.SecurityServer', 'com.apple.securityd.xpc', 'com.apple.security.agent', 'com.apple.secd',
+  'com.apple.security.keychain-circle-notification', 'com.apple.trustd.agent'];
+
+/**
+ * The SBPL profile. `writable` and `readable` are absolute paths; `readable` re-opens subpaths of a denied tree (for
+ * example a node_modules the worktree links to). Later rules win in SBPL, so the allows come after the denies.
+ */
+export function sandboxProfile({ home, writable = [], readable = [] }) {
+  if (!home || !path.isAbsolute(home)) throw new Error('sandboxProfile: home must be absolute');
+  if (!writable.length || !writable.every((p) => path.isAbsolute(p))) throw new Error('sandboxProfile: writable paths must be absolute');
+  const h = real(home);
+  const deny = READ_DENY_HOME.map((d) => `(subpath ${q(path.join(h, d))})`);
+  return [
+    '(version 1)',
+    '(allow default)',
+    '(deny network-outbound (remote ip))',
+    '(deny network-outbound (remote unix-socket))',
+    '(deny network-bind)',
+    `(deny mach-lookup ${SECRET_MACH.map((n) => `(global-name ${q(n)})`).join(' ')})`,
+    `(deny file-read-data ${deny.join(' ')} (subpath "/Library/Keychains") (regex #"/\\.env(\\.[^/]*)?$"))`,
+    readable.length ? `(allow file-read-data ${[...new Set(readable.flatMap((p) => [...linkChain(p)]))].map((p) => `(subpath ${q(p)})`).join(' ')})` : '',
+    `(deny file-write* (require-not (require-any ${writable.map((p) => `(subpath ${q(real(p))})`).join(' ')} (subpath "/dev"))))`,
+    '',
+  ].filter((l, i, a) => l !== '' || i === a.length - 1).join('\n');
+}
+
+/** The child environment: nothing inherited but what node/npx need to find themselves. */
+export function sandboxEnv({ tmpHome, pathDirs }) {
+  return { PATH: pathDirs.join(':'), HOME: tmpHome, TMPDIR: tmpHome, CI: '1', NO_COLOR: '1', LANG: 'en_US.UTF-8',
+    npm_config_update_notifier: 'false', npm_config_audit: 'false', npm_config_fund: 'false', npm_config_offline: 'true' };
+}
+
+/**
+ * Returns run(cmd, args, { cwd, timeoutMs, readable }) that executes through `exec` (so assertCommandAllowed and the
+ * primary-checkout guard still apply) inside the sandbox, writable only in `cwd` and a fresh temp dir.
+ */
+export function makeSandboxRunner({ exec, tmpRoot = os.tmpdir(), platform = process.platform, sandboxBin = SANDBOX_BIN,
+  home = os.homedir(), nodeDir = path.dirname(process.execPath), exists = fs.existsSync } = {}) {
+  return function runSandboxed(cmd, args = [], { cwd, timeoutMs, readable = [], stage = 'S4' } = {}) {
+    if (platform !== 'darwin' || !exists(sandboxBin)) {
+      throw new AutofixAbort(stage, 'sandbox-unavailable', `untrusted code runs only under ${sandboxBin} on macOS`);
+    }
+    if (!cwd || !path.isAbsolute(cwd)) throw new AutofixAbort(stage, 'sandbox-unavailable', 'sandboxed runs need an absolute cwd');
+    fs.mkdirSync(tmpRoot, { recursive: true });
+    const tmp = fs.mkdtempSync(path.join(tmpRoot, 'autofix-sbx-'));
+    const profile = path.join(tmp, 'profile.sb');
+    // node_modules is usually a link out of the worktree; its target must stay readable even under a denied tree.
+    // node_modules is a directory of links into the shared install (issue-autofix-diff.mjs linkModules) or, in older
+    // layouts, a single link: either way the install it points into must stay READABLE even inside a denied tree such as
+    // ~/.cache/ruvnet-brain (measured 2026-10-30: without this, vitest itself could not be read and no test started).
+    const nm = path.join(cwd, 'node_modules');
+    const targets = new Set();
+    if (exists(nm)) {
+      targets.add(real(nm));
+      try {
+        for (const e of fs.readdirSync(nm)) {
+          const p = path.join(nm, e);
+          if (fs.lstatSync(p).isSymbolicLink()) targets.add(path.dirname(real(p)));
+        }
+      } catch { /* an unreadable node_modules just gets no extra grants */ }
+    }
+    const extra = [cwd, ...readable, ...targets];
+    fs.writeFileSync(profile, sandboxProfile({ home, writable: [cwd, tmp], readable: extra }));
+    const tmpHome = path.join(tmp, 'home');
+    fs.mkdirSync(tmpHome);
+    const env = sandboxEnv({ tmpHome, pathDirs: [nodeDir, '/usr/bin', '/bin'] });
+    try {
+      return exec(sandboxBin, ['-f', profile, cmd, ...args], { cwd, env, timeoutMs });
+    } finally {
+      try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { /* temp only */ }
+    }
+  };
+}