@kaydash9999/banker-plugins 0.25.0 → 0.26.0

package/skills/ralph-qa/references/verifier-probe.mjs

@@ -188,6 +188,8 @@ export const DECISION_REASONS = [
 
 export const CLI_DEFAULT = "@cli-default";
 
+// How a CLI call ended, for a note.
+const callWhy = (res) => (res?.why ? res.why : res?.status === 0 ? "exit 0 with output the probe could not use" : `exit ${res?.status ?? "?"}`);
 const firstLine = (res) => (res?.status === 0 ? String(res.stdout).trim().split("\n")[0] || null : null);
 const absent = (cli) => ({ cli, present: false, decision: "unseated", reason: "cli-absent" });
 const adopt = (seat, model, reason) => ({ ...seat, decision: "adopt", model, reason });
@@ -382,6 +384,8 @@ const rawMcpNames = (lines) => lines.filter((l) => !/^\s*#/.test(l))
 // or the line that opened what is still open), and the strings of each top-level array
 // (`arrays`). Enough for those keys; not a TOML parser.
 export function readToml(text) {
+  // a file there that could not be read (permissions, a folder): nothing it says is known, so it reads as broken
+  if (text?.unreadable) return { values: {}, roots: [], arrays: {}, mcpServers: [], mcpUnread: true, modelKeys: false, broken: true, brokenAt: 0, unreadable: text.unreadable };
   const state = tomlState();
   const lines = String(text ?? "").split(/\r?\n/);
   const isOpen = () => state.open !== null || state.depth > 0;
@@ -457,6 +461,7 @@ export function stripJsonc(text) {
 // { value } for a readable JSONC text, { unreadable: true } for a broken one, {} when absent.
 function readJsonc(text) {
   if (text == null) return {};
+  if (text.unreadable) return { unreadable: true };
   try {
     const value = JSON.parse(stripJsonc(String(text)));
     return value && typeof value === "object" && !Array.isArray(value) ? { value } : { unreadable: true };
@@ -530,7 +535,7 @@ function codexConfig(world) {
     mcpUnread: layers.some((l) => l.mcpUnread),
     modelKeys: layers.some((l) => l.modelKeys),
     broken: layers.some((l) => l.broken),
-    brokenAt: layers.map((l, k) => (l.broken ? `${files[k]} line ${l.brokenAt}` : null)).filter(Boolean),
+    brokenAt: layers.map((l, k) => (!l.broken ? null : l.unreadable ? `${files[k]} (not readable: ${l.unreadable})` : `${files[k]} line ${l.brokenAt}`)).filter(Boolean),
   };
 }
 
@@ -555,6 +560,8 @@ function mcpBlockedSeat(seat, conf, notes) {
 const SEAT_KEYS = ["notify", "otel", "mcp_servers", "web_search", "tools", "analytics", "features", "hooks",
   "sandbox_mode", "sandbox_workspace_write", "approval_policy"];
 
+const unreadAt = (read) => (read.unreadable ? `could not be read (${read.unreadable})` : `could not be read to its end (line ${read.brokenAt})`);
+
 // The unseated seat when the managed file sets one of those keys, or could not be read to its
 // end (a line read short may set one); null otherwise.
 function managedBlockedSeat(seat, world, notes) {
@@ -562,7 +569,7 @@ function managedBlockedSeat(seat, world, notes) {
   const read = readToml(world.readFile(CODEX_MANAGED));
   const keys = read.roots.filter((k) => SEAT_KEYS.includes(k));
   if (!keys.length && !read.broken) return null;
-  notes.push(`${CODEX_MANAGED} ${keys.length ? `sets ${keys.join(", ")}` : `could not be read to its end (line ${read.brokenAt})`}, which codex applies over the seat's -c flags: the seat cannot hold its guards`);
+  notes.push(`${CODEX_MANAGED} ${keys.length ? `sets ${keys.join(", ")}` : unreadAt(read)}, which codex applies over the seat's -c flags: the seat cannot hold its guards`);
   return { ...seat, decision: "unseated", reason: "cli-call-failed" };
 }
 
@@ -583,7 +590,7 @@ function requirementsBlockedSeat(seat, world, notes) {
   const allows = (k) => SEAT_ALLOWS[k] !== undefined && (read.arrays[k] ?? []).includes(SEAT_ALLOWS[k]);
   const keys = read.roots.filter((k) => !GUARD_FREE.includes(k) && !allows(k));
   if (!keys.length && !read.broken) return null;
-  notes.push(`${CODEX_REQUIREMENTS} ${keys.length ? `sets ${keys.join(", ")}` : `could not be read to its end (line ${read.brokenAt})`}, which codex holds over the seat's -c, --disable and -s flags: the seat cannot hold its guards`);
+  notes.push(`${CODEX_REQUIREMENTS} ${keys.length ? `sets ${keys.join(", ")}` : unreadAt(read)}, which codex holds over the seat's -c, --disable and -s flags: the seat cannot hold its guards`);
   return { ...seat, decision: "unseated", reason: "cli-call-failed" };
 }
 
@@ -653,10 +660,18 @@ function codexSeat(flag, { world, runtime, authorFamilies }) {
   const notes = [];
   const conf = codexConfig(world);
   const configured = vetConfigured(safeOnly([conf.cfg.model], "config.toml", notes)[0], authorFamilies, notes);
-  const catalog = readCatalog(world.run("codex", ["debug", "models", "--bundled"]), notes) ?? [];
+  const listed = world.run("codex", ["debug", "models", "--bundled"]);
+  const read = readCatalog(listed, notes);
+  const catalog = read ?? [];
   const sorted = sortModels([...catalog, configured], authorFamilies);
-  const version = firstLine(world.run("codex", ["--version"]));
+  const ran = world.run("codex", ["--version"]);
+  // a version line has a version number in it; an error text on stdout with exit 0 is not one
+  const version = /\d+\.\d+/.test(firstLine(ran) ?? "") ? firstLine(ran) : null;
+  if (!read) notes.push(`codex debug models --bundled gave no catalog (${callWhy(listed)})`);
+  if (!version) notes.push(`codex --version gave no version (${callWhy(ran)})`);
   const seat = { cli: "codex", present: true, version, configured, candidates: sorted.independent, unclassified: sorted.unclassified, mcpServers: conf.mcpServers };
+  // both calls failed: this codex does not run here (not logged in, broken install, killed), so it is not a seat
+  if (!read && !version) return withNotes({ ...seat, decision: "unseated", reason: "cli-call-failed" }, notes);
   const refused = legacyProfileSeat(seat, conf.cfg, notes) ?? managedBlockedSeat(seat, world, notes)
     ?? requirementsBlockedSeat(seat, world, notes) ?? mcpBlockedSeat(seat, conf, notes);
   if (refused) return withNotes(refused, notes);
@@ -710,8 +725,10 @@ function geminiPoliciesDir(world) {
 // seat's read-only tools rest on that flag: such a seat is not seated.
 function geminiPolicySeat(seat, world, notes) {
   const dir = geminiPoliciesDir(world);
-  if (!world.listDir(dir).some((f) => f.endsWith(".toml"))) return null;
-  notes.push(`gemini ignores --admin-policy while ${dir} holds policies: the seat cannot be held to its read-only tools`);
+  const list = world.listDir(dir);
+  if (list && !list.some((f) => f.endsWith(".toml"))) return null;
+  notes.push(list ? `gemini ignores --admin-policy while ${dir} holds policies: the seat cannot be held to its read-only tools`
+    : `the probe could not list ${dir}: gemini ignores --admin-policy while it holds policies, so the seat cannot be shown to keep to its read-only tools`);
   return { ...seat, decision: "unseated", reason: "cli-call-failed" };
 }
 
@@ -835,7 +852,8 @@ const opencodeCache = (world) => join(world.env.XDG_CACHE_HOME || join(world.hom
 function catalogProviders(world) {
   const file = join(opencodeCache(world), "models.json");
   const read = readJsonc(world.readFile(file));
-  return read.value ? new Set(Object.keys(read.value)) : null;
+  // an emptied copy ({}) lists no provider: it says nothing about which ones models.dev knows
+  return read.value && Object.keys(read.value).length ? new Set(Object.keys(read.value)) : null;
 }
 
 // The models the config lists are all opencode can run only when enabled_providers names
@@ -953,18 +971,20 @@ function realWorld() {
     platform: process.platform,
     env: process.env,
     which: onPath,
+    // null when the file is not there; { unreadable } when it is but cannot be read, which is not the same as absent
     readFile: (path) => {
       try {
         return readFileSync(path, "utf8");
-      } catch {
-        return null;
+      } catch (e) {
+        return e.code === "ENOENT" || e.code === "ENOTDIR" ? null : { unreadable: e.code || "error" };
       }
     },
+    // [] when the folder is not there; null when it is but cannot be listed
     listDir: (path) => {
       try {
         return readdirSync(path);
-      } catch {
-        return [];
+      } catch (e) {
+        return e.code === "ENOENT" || e.code === "ENOTDIR" ? [] : null;
       }
     },
     run: (cmd, args, env = {}) => {
@@ -978,11 +998,13 @@ function realWorld() {
       const r = spawnSync(viaCmd ? `"${exe}"` : exe, args, {
         encoding: "utf8",
         timeout: 15000,
+        // a CLI that ignores SIGTERM would hold spawnSync past its time limit
+        killSignal: "SIGKILL",
         maxBuffer: 64 * 1024 * 1024,
         shell,
         env: { ...process.env, ...(viaCmd ? { NoDefaultCurrentDirectoryInExePath: "1" } : {}), ...env },
       });
-      return { status: r.status, stdout: r.stdout ?? "" };
+      return { status: r.status, stdout: r.stdout ?? "", why: r.error ? (r.error.code === "ETIMEDOUT" ? "timed out" : r.error.code) : r.signal ? `killed by ${r.signal}` : null };
     },
   };
 }

package/skills/remains/SKILL.md

@@ -92,7 +92,7 @@ argument-hint: "[기준 커밋] [--no-boxes]"
    - `noTests` 는 시험이 하나도 돌지 않았다는 뜻이라 통과가 아니라 미검증이다.
    - 한 OS 에서만 실패하면, 제품의 결함은 버그로, 시험이 실행 환경을 잘못 가정한 것은 하자로 적는다.
 
-박스에 둔 것은 `run` 이 끝날 때 지운다. 시간 초과, 연결 끊김, 중단(SIGINT, SIGTERM) 때는 박스에서 시작한 프로세스를 먼저 끝낸다. Linux, macOS 는 `mktemp -d` 로 만든 개인 폴더를 쓴다. 지우지 못하면 결과의 `cleaned` 가 `false` 이고, 그 박스를 하자로 적는다.
+박스에 둔 것은 `run` 이 끝날 때 지운다. 시간 초과, 연결 끊김, 중단(SIGINT, SIGTERM) 때는 박스에서 시작한 프로세스를 먼저 끝낸다. Linux, macOS 는 `mktemp -d` 로 만든 개인 폴더를 쓴다. 보통은 `/tmp` 아래이고, `runAs` 박스는 `/var/lib` 아래다. `runAs` 계정의 HOME 도 그 안에 있어서, 임시 폴더를 거부하는 도구(teamwork 등)의 시험도 그대로 돈다. 지우지 못하면 결과의 `cleaned` 가 `false` 이고, 그 박스를 하자로 적는다.
 알려진 한계: 이중 fork 로 프로세스 트리를 벗어난 프로세스는 끝나지 않는다. `pgrep` 이 없는 박스에서는 기록된 프로세스 하나만 끝난다.
 
 ### 등록 파일

package/skills/remains/scripts/boxes.mjs

@@ -27,7 +27,11 @@ const FIELDS = new Set(["name", "os", "ssh", "port", "identity", "path", "runAs"
 const SECRETISH = /pass|secret|token|credential/i;
 const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const TARGET = /^[A-Za-z0-9][A-Za-z0-9._-]*@[A-Za-z0-9][A-Za-z0-9.-]*$/;
-const REMOTE_DIR = /^\/tmp\/banker-remains\.[A-Za-z0-9]+$/;
+// Where a box's private folder goes. A runAs box gets one outside the temporary folders, so that the copy and the
+// run account's HOME inside it are not under /tmp: tools that refuse temporary folders (teamwork's Codex home check)
+// would refuse the tests' fixtures there. /var/lib is root's, so only a root login (runAs) makes one there.
+const dirBase = (b) => (b.runAs ? "/var/lib" : "/tmp");
+const remoteDir = (b) => new RegExp(`^${dirBase(b).replace(/\//g, "\\/")}\\/banker-remains\\.[A-Za-z0-9]+$`);
 // What ssh and scp print about the connection itself, as opposed to what the remote command prints.
 const SSH_ERR = /^(ssh|scp): |Connection (closed|refused|reset|timed out)|Host key verification failed|Permission denied \(|Could not resolve hostname|No route to host|Broken pipe/m;
 const UPLOAD_MS = 10 * 60 * 1000;
@@ -153,8 +157,8 @@ function winSteps(b, name) {
   };
 }
 
-// Linux and macOS work in the private folder `mktemp -d` made. A root login hands the run to runAs, with a
-// HOME of its own. Ending a run takes the process tree under the recorded id first, then the folder.
+// Linux and macOS work in the private folder `mktemp -d` made (under /tmp, or /var/lib for runAs). A root login
+// hands the run to runAs, with a HOME of its own inside that folder. Ending a run takes the process tree under the recorded id first, then the folder.
 function posixSteps(b, name, dir) {
   const go = b.runAs
     ? `mkdir -p "$D/home" && chown -R ${b.runAs} "$D" && runuser -u ${b.runAs} -- env HOME="$D/home" sh "$D/run.sh"`
@@ -227,10 +231,10 @@ const sshFailed = (r) => (r.status === null && !r.timedOut) || (r.status === 255
 
 async function makeDir(b, exec) {
   if (b.os === "win32") return { dir: null };
-  const r = await exec("ssh", [...sshBase(b), b.ssh, "mktemp -d /tmp/banker-remains.XXXXXXXX"], { timeoutMs: PROBE_MS });
+  const r = await exec("ssh", [...sshBase(b), b.ssh, `mktemp -d ${dirBase(b)}/banker-remains.XXXXXXXX`], { timeoutMs: PROBE_MS });
   const dir = String(r.stdout || "").trim();
   if (r.status !== 0) return { error: lastLine(r.stderr) || "ssh 실패" };
-  return REMOTE_DIR.test(dir) ? { dir } : { error: `mktemp -d 가 예상과 다른 경로를 냈습니다: ${dir.slice(0, 80)}` };
+  return remoteDir(b).test(dir) ? { dir } : { error: `mktemp -d 가 예상과 다른 경로를 냈습니다: ${dir.slice(0, 80)}` };
 }
 
 async function attempt(b, plan, exec, files, steps) {
@@ -265,22 +269,37 @@ export async function runOnBox(b, plan, exec) {
 
 // Started from the home folder with git -C: Windows looks for a program in the working folder first, so a git.exe
 // inside the folder worked on never runs.
-function git(cwd, args) {
-  const r = spawnSync("git", ["-C", resolve(cwd), ...args], { cwd: runDir(), encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
-  if (r.status !== 0) throw new Error(`git ${args.filter((a) => !a.includes("=")).join(" ")} 실패: ${lastLine(r.stderr) || r.error?.message || ""}`);
+function git(cwd, args, env = process.env) {
+  const r = spawnSync("git", ["-C", resolve(cwd), ...args], { cwd: runDir(), env, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  if (r.status !== 0) throw new Error(`git ${gitWords(args)} 실패: ${lastLine(r.stderr) || r.error?.message || ""}`);
   return r.stdout;
 }
 
+// The command words for a message: global options (-c key=value, --no-optional-locks) are left out.
+export const gitWords = (args) => args.filter((a, i) => a !== "-c" && args[i - 1] !== "-c" && !a.startsWith("--no-optional-locks")).join(" ");
+
 // The commit to send. `worktree` is a commit object made from the tracked files as they are now
 // (git stash create: no stash entry, no change to the work tree). Untracked files are never sent.
-function resolveTree(repo, ref) {
-  const status = git(repo, ["status", "--porcelain", "--untracked-files=all"]).split("\n").filter(Boolean);
+// Neither step writes the repository's index: status takes no optional lock, and stash create works on a copy of
+// the index (GIT_INDEX_FILE), so two runs at once, or a git command of the user's, do not meet on index.lock.
+export function resolveTree(repo, ref) {
+  const status = git(repo, ["--no-optional-locks", "status", "--porcelain", "--untracked-files=all"]).split("\n").filter(Boolean);
   const untracked = status.filter((l) => l.startsWith("??")).length;
   if (ref !== "worktree") {
     return { sha: git(repo, ["rev-parse", "--verify", `${ref}^{commit}`]).trim(), untracked, modified: status.length - untracked };
   }
-  const made = git(repo, ["-c", "user.name=banker-remains", "-c", "user.email=banker-remains@localhost", "stash", "create"]).trim();
-  return { sha: made || git(repo, ["rev-parse", "HEAD"]).trim(), untracked, modified: 0 };
+  const tmp = join(tmpdir(), `banker-remains-index-${randomBytes(8).toString("hex")}`);
+  mkdirSync(tmp, { mode: 0o700 });
+  try {
+    const index = resolve(repo, git(repo, ["rev-parse", "--git-path", "index"]).trim());
+    const copy = join(tmp, "index");
+    if (existsSync(index)) copyFileSync(index, copy);
+    const env = { ...process.env, GIT_INDEX_FILE: copy };
+    const made = git(repo, ["-c", "user.name=banker-remains", "-c", "user.email=banker-remains@localhost", "stash", "create"], env).trim();
+    return { sha: made || git(repo, ["rev-parse", "HEAD"]).trim(), untracked, modified: 0 };
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
 }
 
 function testFiles(repo, sha) {