Scaffold: fork of Chambers architecture, renamed to Boardroom Map
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Jonathan Kirkwood
@@ -0,0 +1,162 @@
|
||||
"""Launch the reviewer panel on the head Spark over SSH.
|
||||
|
||||
Each reviewer is a ONE-SHOT, hardened, read-only container: it reads the document
|
||||
text mounted at /docs, runs its model (through the on-Spark proxy) under its
|
||||
persona + the shared rubric, writes a single report to /out/<id>.md, and exits.
|
||||
There is no shared writable workspace and no git — reviewers cannot alter the
|
||||
documents or each other's reports.
|
||||
|
||||
Sandbox (per the operator's confidentiality requirement):
|
||||
* non-root, --cap-drop ALL, --security-opt no-new-privileges
|
||||
* read-only rootfs + small writable tmpfs; only /docs (ro), /persona (ro), and
|
||||
/out (rw, this reviewer's report dir) are mounted
|
||||
* NO docker socket, cpu/mem/pid caps
|
||||
* attached to the per-job network — in airgapped mode that network is
|
||||
--internal, so the reviewer can reach ONLY the model proxy, never the internet
|
||||
|
||||
Reviewers hold no credentials beyond a dummy proxy key.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import re
|
||||
import shlex
|
||||
|
||||
import spark_client as sc
|
||||
import serving
|
||||
|
||||
SANDBOX_SRC = os.path.join(os.path.dirname(os.path.abspath(__file__)), "sandbox")
|
||||
|
||||
|
||||
def ensure_reviewer_image(cfg: dict, log) -> None:
|
||||
"""Build the reviewer image on the head Spark if missing (aarch64, native)."""
|
||||
head = sc.head(cfg)
|
||||
image = cfg["graderImage"]
|
||||
q = shlex.quote
|
||||
r = sc.run(head, f"docker image inspect {q(image)} >/dev/null 2>&1 && echo PRESENT || echo MISSING",
|
||||
timeout=30)
|
||||
if "PRESENT" in (r.stdout or ""):
|
||||
log(f"[reviewers] image {image} already present on {head.host}")
|
||||
return
|
||||
if not os.path.isdir(SANDBOX_SRC):
|
||||
raise RuntimeError(f"reviewer build context missing at {SANDBOX_SRC} (image not baked in?)")
|
||||
remote_dir = f"{cfg['remoteWorkDir']}/sandbox-build"
|
||||
log(f"[reviewers] building reviewer image {image} on {head.host} (first run; a few minutes)…")
|
||||
push = sc.push_dir(head, SANDBOX_SRC, remote_dir)
|
||||
if push.returncode != 0:
|
||||
raise RuntimeError(f"rsync reviewer build context to {head.host} failed: {push.stderr}")
|
||||
b = sc.run(head, f"cd {q(remote_dir)} && IMAGE={q(image)} bash build.sh", timeout=1800)
|
||||
if b.returncode != 0:
|
||||
raise RuntimeError(f"reviewer image build failed on {head.host}: {b.stderr or b.stdout}")
|
||||
log(f"[reviewers] reviewer image built: {image}")
|
||||
|
||||
|
||||
def slug(name: str) -> str:
|
||||
s = re.sub(r"[^A-Za-z0-9]+", "-", (name or "").strip().lower()).strip("-")
|
||||
return s or "reviewer"
|
||||
|
||||
|
||||
def roster(cfg: dict) -> list[dict]:
|
||||
"""Reviewer roster from config. Each: {rid, name, model alias, persona, temperature}."""
|
||||
out: list[dict] = []
|
||||
seen: dict[str, int] = {}
|
||||
for w in (cfg.get("reviewers") or []):
|
||||
name = (w.get("name") or "reviewer").strip()
|
||||
rid = slug(name)
|
||||
if rid in seen:
|
||||
seen[rid] += 1
|
||||
rid = f"{rid}-{seen[rid]}"
|
||||
else:
|
||||
seen[rid] = 1
|
||||
out.append({
|
||||
"rid": rid, "name": name, "model": (w.get("model") or "").strip(),
|
||||
"persona": (w.get("persona") or "").strip(),
|
||||
"temperature": w.get("temperature"),
|
||||
})
|
||||
return out
|
||||
|
||||
|
||||
def _container(cfg: dict, jobdir: str, rid: str, name: str, model: str, persona: str,
|
||||
temperature, role: str, extra_mounts: str = "") -> str:
|
||||
"""docker run command for one reviewer/synthesizer container (detached, one-shot)."""
|
||||
q = shlex.quote
|
||||
net = serving.net_name(cfg)
|
||||
base = serving.reviewer_proxy_base(cfg)
|
||||
searxng = (cfg.get("searxngUrl") or "").strip()
|
||||
persona_path = f"{jobdir}/personas/{rid}.md"
|
||||
|
||||
env = (
|
||||
f"-e BM_REVIEWER_ID={q(rid)} -e BM_REVIEWER_NAME={q(name)} -e BM_ROLE={q(role)} "
|
||||
f"-e BM_MODEL={q(model)} -e BM_LLM_BASE={q(base)} -e BM_LLM_KEY=sk-local "
|
||||
f"-e BM_MAX_MODEL_LEN={q(str(int(cfg.get('maxModelLen', 32768))))} "
|
||||
f"-e HOME=/home/rev "
|
||||
)
|
||||
if temperature is not None:
|
||||
env += f"-e BM_TEMPERATURE={q(str(temperature))} "
|
||||
# web_search is offered ONLY in local_services mode with a SearXNG URL.
|
||||
if cfg.get("networkMode") == "local_services" and searxng:
|
||||
env += f"-e BM_SEARXNG_URL={q(searxng)} "
|
||||
|
||||
harden = (
|
||||
"--user 1000:1000 --security-opt no-new-privileges --cap-drop ALL "
|
||||
"--read-only --tmpfs /tmp:size=256m --tmpfs /home/rev:size=128m "
|
||||
"--pids-limit 256 --memory 6g --cpus 4"
|
||||
)
|
||||
mounts = (
|
||||
f"-v {q(jobdir)}/docs:/docs:ro "
|
||||
f"-v {q(jobdir)}/out:/out "
|
||||
f"-v {q(persona_path)}:/persona/PERSONA.md:ro "
|
||||
+ extra_mounts
|
||||
)
|
||||
cname = f"bm-grader-{rid}"
|
||||
return (
|
||||
f"docker rm -f {cname} >/dev/null 2>&1; "
|
||||
f"docker run -d --name {cname} --network {q(net)} {harden} {env} {mounts} {q(cfg['graderImage'])}"
|
||||
)
|
||||
|
||||
|
||||
def _write_persona(cfg: dict, jobdir: str, rid: str, persona: str) -> None:
|
||||
q = shlex.quote
|
||||
sc.run(sc.head(cfg),
|
||||
f"mkdir -p {q(jobdir)}/personas && printf '%s' {q(persona)} > {q(jobdir)}/personas/{rid}.md",
|
||||
timeout=30)
|
||||
|
||||
|
||||
def run_wave_reviewers(cfg: dict, jobdir: str, panel: list[dict], rubric: str, log,
|
||||
wait_timeout: int = 1800) -> list[dict]:
|
||||
"""Launch every reviewer in `panel` (already filtered to this wave's models),
|
||||
wait for them to finish, and report status. Reports land in <jobdir>/out."""
|
||||
head = sc.head(cfg)
|
||||
q = shlex.quote
|
||||
# Rubric is shared; write it once into the job dir, mounted into every container.
|
||||
sc.run(head, f"mkdir -p {q(jobdir)}/out && printf '%s' {q(rubric)} > {q(jobdir)}/RUBRIC.md", timeout=30)
|
||||
launched = []
|
||||
for r in panel:
|
||||
_write_persona(cfg, jobdir, r["rid"], r["persona"])
|
||||
cmd = _container(cfg, jobdir, r["rid"], r["name"], r["model"], r["persona"],
|
||||
r.get("temperature"), role="reviewer",
|
||||
extra_mounts=f"-v {q(jobdir)}/RUBRIC.md:/RUBRIC.md:ro ")
|
||||
res = sc.run(head, cmd, timeout=120)
|
||||
if res.returncode != 0:
|
||||
log(f"[reviewers] launch {r['rid']} FAILED: {res.stderr or res.stdout}")
|
||||
launched.append({**r, "ok": False, "error": (res.stderr or res.stdout)[:300]})
|
||||
continue
|
||||
log(f"[reviewers] up: {r['rid']} -> {r['model']}")
|
||||
launched.append({**r, "ok": True, "error": ""})
|
||||
|
||||
# Wait for each launched container to exit (they run in parallel; waiting
|
||||
# sequentially still finishes when the slowest does).
|
||||
results = []
|
||||
for r in launched:
|
||||
if not r["ok"]:
|
||||
results.append(r)
|
||||
continue
|
||||
cname = f"bm-grader-{r['rid']}"
|
||||
w = sc.run(head, f"docker wait {cname}", timeout=wait_timeout)
|
||||
code = (w.stdout or "").strip()
|
||||
out_check = sc.run(head, f"test -s {q(jobdir)}/out/{q(r['rid'])}.md && echo OK || echo MISSING", timeout=30)
|
||||
wrote = "OK" in (out_check.stdout or "")
|
||||
log(f"[reviewers] {r['rid']} exited (code={code or '?'}), report={'written' if wrote else 'MISSING'}")
|
||||
sc.run(head, f"docker rm -f {cname} 2>/dev/null; true", timeout=30)
|
||||
results.append({**r, "exit": code, "report": wrote})
|
||||
return results
|
||||
Reference in New Issue
Block a user