@kaydash9999/banker-plugins 0.20.2 → 0.21.0

package/skills/setup-omc-hud/assets/apply-hud.mjs

@@ -19,13 +19,16 @@
  * column when Node reports one but never quoting it; one holding only white
  * space is read as {}, as Claude Code does; UTF-8 BOM accepted; CLAUDE_CONFIG_DIR trimmed, "~" expanded
  * and made absolute; formatter and HUD config backed up when they differ (the
- * blocks payload-mon and claude-update-last add do not count), settings.json only
+ * blocks payload-mon and claude-update-last add do not count unless edited by hand), settings.json only
  * when it changes; pre-releases sort below their release; no
  * folder is made when OMC is missing. Also refused before any change: a config
  * folder path the statusLine shell would act on, a file or folder it cannot
  * write, an OMC folder without both loader files, a relative OMC_PLUGIN_ROOT.
  * Backups keep the original bytes and mode; the files it writes are 0644 and new
- * folders 0755; the other statusLine fields (padding, ...) stay.
+ * folders 0755; the other statusLine fields (padding, ...) stay. settings.json goes
+ * in as a new file through a rename (a link keeps pointing at it), in place where
+ * that cannot be done or would part a hard link or change its owner or group, and
+ * is left as it was when the disk is too full for the new file.
  * At the end it runs the installed formatter once with no input and reports
  * whether OMC's HUD loads and which version draws (the render check); that never
  * changes the exit code. APPLY_HUD_CHECK_TIMEOUT_MS (tests) shortens its 25s limit.
@@ -38,9 +41,13 @@ import {
   constants,
   copyFileSync,
   existsSync,
+  lstatSync,
   mkdirSync,
   readdirSync,
   readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
   statSync,
   writeFileSync,
 } from "node:fs";
@@ -70,6 +77,27 @@ const configDst = join(OMC_DIR, "hud-config.json");
 // PowerShell on Windows) that treats backslashes as escapes.
 const cmdPath = wrapperDst.split(sep).join("/");
 const log = (m) => process.stdout.write(m + "\n");
+// Characters that could act on a terminal or pass for a line of their own are shown as "?", as
+// omc-patch.mjs (UNSAFE_CH) shows file values in output an agent reads.
+const UNSAFE = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Co}\p{Cn}\p{Variation_Selector}\p{Default_Ignorable_Code_Point}\u{2800}\u{a0}\u{1680}\u{2000}-\u{200a}\u{202f}\u{205f}\u{3000}]/gu;
+const shown = (s) => String(s).replace(UNSAFE, "?");
+// The old statusLine command as the report shows it: its first word (the program; a NAME=value it sets is skipped) and
+// its length. settings.json can hold tokens (see step 0) and the line goes into a report; masking the parts that look
+// like secrets missed every form no rule named (curl -u, sshpass -p, mysql -pPW), so the rest stays in the backup.
+const ASSIGN = /^[A-Za-z_][A-Za-z0-9_]*=/;
+// Shell words: runs of plain characters, quoted pieces and backslash escapes (a quote or a space after a backslash
+// stays in its word, inside double quotes too), a quote left open running to the end, so a value in quotes stays one
+// word with its name.
+const WORDS = /(?:"(?:[^"\\]|\\.)*"?|'[^']*'?|\\[\s\S]?|[^\s"'\\])+/g;
+function priorShown(command) {
+  const text = String(command).trim();
+  const words = text.match(WORDS) || [];
+  const first = words.findIndex((w) => !ASSIGN.test(w));
+  // a first word that looks like a setting or an address may hold a secret itself
+  const name = first === -1 ? "(no program)" : /[=@]|:\/\//.test(words[first]) ? "(program hidden)" : words[first];
+  const head = `${name}${first !== -1 && first < words.length - 1 ? " …" : ""}`;
+  return `${JSON.stringify(shown(head))} (${text.length} characters)`;
+}
 const stamp = new Date().toISOString().replace(/[:.]/g, "-");
 const refuse = (lines) => {
   for (const l of lines) log(l);
@@ -108,6 +136,30 @@ function readSettings(raw) {
   if (value && typeof value === "object" && !Array.isArray(value)) return { settings: value, empty: false };
   return { refusal: `[x] settings.json holds ${kindOf(value)}, not a JSON object; nothing changed. Fix it and re-run.` };
 }
+// A target that is there but no regular file (a folder, a FIFO, a device), or a folder the install writes into that
+// is there but no folder, is refused before anything is read or written: reading or writing a FIFO waits for good,
+// and the others stopped the install half-way. Links are followed, as the reads and writes follow them; a target
+// that is not there (a broken link too) is written new.
+function oddTarget() {
+  for (const p of [settingsPath, loaderDst, libDst, wrapperDst, configDst]) {
+    try {
+      if (!statSync(p).isFile()) return `${shown(p)} is not a regular file (a folder, a FIFO or a device)`;
+    } catch {
+      /* not there: written new */
+    }
+  }
+  for (const d of [CONFIG_DIR, HUD_DIR, join(HUD_DIR, "lib"), OMC_DIR]) {
+    try {
+      if (!statSync(d).isDirectory()) return `${shown(d)} is not a folder`;
+    } catch {
+      /* not there: made */
+    }
+  }
+  return "";
+}
+const odd = oddTarget();
+if (odd) refuse([`[x] ${odd}; nothing changed. Move it aside and re-run.`]);
+
 let settings = {};
 let settingsRaw = null;
 if (existsSync(settingsPath)) {
@@ -199,17 +251,82 @@ function writeOwned(file, data) {
 }
 
 // The marker blocks payload-mon and claude-update-last add to the installed formatter, matched as those
-// tools match them (payload-mon.mjs BLOCKS, claude-update-last.mjs's block pattern). Read as latin1,
-// which maps every byte to one character, so text outside the blocks compares byte for byte.
+// tools match them (payload-mon.mjs BLOCKS, claude-update-last.mjs BLOCKS). Read as latin1, which maps
+// every byte to one character, so text outside the blocks compares byte for byte.
 const TOOL_BLOCKS = [
   /^[ \t]*\/\/ >>> payload-mon >>>[\s\S]*?\/\/ <<< payload-mon <<<[ \t]*\r?\n/gm,
   /^[ \t]*\/\/ >>> claude-update-last >>>(?:(?!\/\/ >>> claude-update-last >>>)[\s\S])*?\/\/ <<< claude-update-last <<<[ \t]*(?:\r?\n|(?![\s\S]))/gm,
 ];
-const withoutToolBlocks = (text) => TOOL_BLOCKS.reduce((t, blocks) => t.replace(blocks, ""), text);
+// payload-mon's closing line (payload-mon.mjs CLOSE_LINE). No block reaches past the last one, so its
+// pattern runs only on the text before it: otherwise every stray opening line scans to the end again
+// (a 2MB file of them took 28s).
+const PM_CLOSE = /\/\/ <<< payload-mon <<<[ \t]*\r?\n/g;
+// The text without the tools' blocks, and the blocks it held.
+function splitToolBlocks(text) {
+  const blocks = [];
+  const take = (t, pattern) =>
+    t.replace(pattern, (block) => {
+      blocks.push(block);
+      return "";
+    });
+  let end = -1;
+  for (const m of text.matchAll(PM_CLOSE)) end = m.index + m[0].length;
+  const rest = end < 0 ? text : take(text.slice(0, end), TOOL_BLOCKS[0]) + text.slice(end);
+  return { body: take(rest, TOOL_BLOCKS[1]), blocks };
+}
+// The blocks as the tools write them (payload-mon.mjs placeBlock, claude-update-last.mjs blockText), with
+// LF line endings and payload-mon's import of its module copy as "<module copy>" (where the copy sits is the
+// tool's to choose; a URL to any other file is an edit). A block that differs from both was edited by hand. When a tool's block changes, the test "payload-mon 블록만 다른 래퍼와 바뀌지 않은 settings.json 은
+// 다시 설치해도 백업하지 않음" fails until this copy follows.
+const TOOL_BLOCK_TEXTS = [
+  [
+    "  // >>> payload-mon >>>",
+    "  // payload-mon: estimated API request payload against the 32MB request limit, shown",
+    "  // like ctx from 8MB (25%) on. `payload-mon off` removes this block; a missing or",
+    "  // broken module costs only this segment, never the statusline.",
+    "  try {",
+    "    const transcript = JSON.parse(input)?.transcript_path;",
+    "    if (transcript) {",
+    "      const { estimatePayloadBytes, payloadSegment } = await <module copy>;",
+    "      const segment = payloadSegment(estimatePayloadBytes(transcript));",
+    "      if (segment) colored.push(colorRate(segment));",
+    "    }",
+    "  } catch {",
+    "    /* no stdin JSON, unreadable transcript or module error */",
+    "  }",
+    "  // <<< payload-mon <<<",
+    "",
+  ].join("\n"),
+  [
+    "  // >>> claude-update-last >>>",
+    "  // claude-update-last (setup-omc-hud): OMC's Claude Code update notice",
+    "  // (\"[Claude#X] -> Y claude update\") goes after every other segment.",
+    "  // `claude-update-last off` removes this block; on any error the order stays as it was.",
+    "  try {",
+    "    const notice = /^\\[Claude(?:#[^\\]]*)?\\]\\s*->\\s*\\S+\\s+claude\\s+update\\b/;",
+    "    const plain = (s) => stripAnsi(String(s)).trim();",
+    "    const found = segs.find((s) => notice.test(plain(s)));",
+    "    if (found) {",
+    "      const moved = A(\"2\", plain(found));",
+    "      for (let i = colored.length - 1; i >= 0; i--) if (notice.test(plain(colored[i]))) colored.splice(i, 1);",
+    "      colored.push(moved);",
+    "    }",
+    "  } catch {",
+    "    /* keep the order the wrapper chose */",
+    "  }",
+    "  // <<< claude-update-last <<<",
+    "",
+  ].join("\n"),
+];
+const toolMade = (block) =>
+  TOOL_BLOCK_TEXTS.includes(block.replace(/\r\n/g, "\n").replace(/await import\("file:\/\/[^"\\]*\/payload-mon\/payload-size\.mjs"\)/, "await <module copy>"));
 const sameBytes = (a, b) => a.equals(b);
-// Those blocks alone are no reason for a backup: `payload-mon on` puts its block back, and wrapper v4
-// needs no claude-update-last block.
-const sameFormatter = (a, b) => withoutToolBlocks(a.toString("latin1")) === withoutToolBlocks(b.toString("latin1"));
+// Blocks as the tools write them are no reason for a backup: `payload-mon on` puts its block back, and
+// wrapper v4 needs no claude-update-last block. A block edited by hand is one.
+function sameFormatter(a, b) {
+  const old = splitToolBlocks(a.toString("latin1"));
+  return old.body === splitToolBlocks(b.toString("latin1")).body && old.blocks.every(toolMade);
+}
 
 // Keep a timestamped copy, with its bytes and mode, of a file that differs from what replaces it.
 function backupIfDifferent(dst, next, label, same = sameBytes) {
@@ -234,7 +351,7 @@ function installLoader() {
 
 // 3. Install the custom formatter and HUD config from the bundled templates.
 //    Files that differ from the templates (local edits) are kept as timestamped
-//    backups first; the blocks payload-mon / claude-update-last add do not count.
+//    backups first; the blocks payload-mon / claude-update-last add, as they write them, do not count.
 function installTemplates() {
   const wrapperSrc = readFileSync(join(SELF, "omc-hud-custom.mjs"));
   const configSrc = readFileSync(join(SELF, "hud-config.json"));
@@ -246,6 +363,72 @@ function installTemplates() {
   log("[ok] HUD config       -> " + configDst);
 }
 
+// settings.json goes in as a new file through a rename, so a stop midway never leaves it half written.
+// One that is a link (dotfiles) keeps its link, and the file it points at is the one replaced. A file
+// left at the temporary name (an earlier run with this pid, or a link put there) is removed first and
+// never written through. It is written in place as before where the new file cannot go in (a folder
+// this account may not write, a file another program holds open, a file system that refuses the
+// rename) or the link leads nowhere yet, and where a rename would part a hard link (its other name
+// would keep the old text) or the new file has another owner or group. Only a full disk stops it, as
+// writing in place could then cut settings.json short; the new file is written before that choice, so
+// a hard link or another owner finds a full disk first too.
+const FULL_DISK = new Set(["ENOSPC", "EDQUOT"]);
+const isLink = (p) => {
+  try {
+    return lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+};
+const removeTmp = (tmp) => {
+  try {
+    rmSync(tmp, { force: true });
+  } catch {
+    /* a folder at that name: left alone */
+  }
+};
+// Whether the file, as `old` was, must keep its inode: it has a second name (a hard link), or the new file
+// `tmp` got another owner or group than it had.
+function keepsInode(old, tmp) {
+  if (!old) return false;
+  const now = statSync(tmp);
+  return old.nlink > 1 || now.uid !== old.uid || now.gid !== old.gid;
+}
+function writeSettings(file, text) {
+  let target = file;
+  let old;
+  let mode;
+  try {
+    target = realpathSync(file);
+    old = statSync(target);
+    mode = old.mode & 0o777;
+  } catch {
+    if (isLink(file)) return writeFileSync(file, text);
+  }
+  const tmp = `${target}.${process.pid}.tmp`;
+  try {
+    rmSync(tmp, { force: true });
+    writeFileSync(tmp, text, { flag: "wx", mode });
+    if (mode !== undefined && process.platform !== "win32") chmodSync(tmp, mode);
+    if (!keepsInode(old, tmp)) return renameSync(tmp, target);
+  } catch (e) {
+    if (FULL_DISK.has(e.code)) throw e;
+  } finally {
+    removeTmp(tmp);
+  }
+  writeFileSync(file, text);
+}
+
+// How many other names settings.json has (a hard link, a `cp -al` snapshot, say), 0 when it cannot be read.
+// writeSettings writes such a file in place, so those names show the new text too.
+function otherNames(file) {
+  try {
+    return statSync(file).nlink - 1;
+  } catch {
+    return 0;
+  }
+}
+
 // 4. Point settings.json statusLine at the custom formatter; its other fields (padding, ...) stay.
 //    A settings.json that already says exactly this is neither backed up nor written.
 const objectOr = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {});
@@ -254,7 +437,7 @@ function pointStatusLine() {
   const command = `node "${cmdPath}"`;
   const prior = objectOr(settings.statusLine);
   if (typeof prior.command === "string" && prior.command && prior.command !== command) {
-    log(`[..] statusLine ran ${JSON.stringify(prior.command)}; it now runs the custom HUD (the old value is in the backup)`);
+    log(`[..] statusLine ran ${priorShown(prior.command)}; it now runs the custom HUD (the old value is in the backup)`);
   }
   settings.statusLine = { ...prior, type: "command", command };
   const next = JSON.stringify(settings, null, 2) + "\n";
@@ -267,8 +450,12 @@ function pointStatusLine() {
     copyFileSync(settingsPath, backup); // the original bytes and mode
     log("[ok] Backed up settings.json -> " + backup);
   }
-  writeFileSync(settingsPath, next);
+  const others = otherNames(settingsPath);
+  writeSettings(settingsPath, next);
   log("[ok] statusLine -> " + command);
+  if (others > 0) {
+    log(`[..] settings.json has ${others} other name${others > 1 ? "s" : ""} (a hard link); it was written in place, so they show the new text too (the old text is in the backup)`);
+  }
 }
 
 // 5. Render check: run the installed formatter once with no input, as the statusLine command does,
@@ -280,7 +467,7 @@ function pointStatusLine() {
 const CHECK_MS = Number(process.env.APPLY_HUD_CHECK_TIMEOUT_MS) || 25000;
 const BLAME =
   "    OMC's install is at fault. /oh-my-claudecode:omc-setup repairs it but points statusLine back at OMC, so run setup-omc-hud again after it.";
-const clip = (s, n = 200) => String(s).slice(0, n);
+const clip = (s, n = 200) => shown(s).slice(0, n);
 // No input, and the config folder as working folder: OMC's loader looks in the working folder's
 // node_modules and runs git from it, and Windows looks there first for a bare program name, so the
 // folder the installer was started in (a project, say) must not be it.
@@ -288,20 +475,31 @@ const RUN_OPTS = { input: "", encoding: "utf8", timeout: CHECK_MS, windowsHide:
 
 // node as the statusLine shell finds it, but only in PATH folders given as absolute paths: spawning the
 // bare name would on Windows try the working folder first, where a project's own node.exe could run.
-function findNode(pathEnv) {
-  const name = process.platform === "win32" ? "node.exe" : "node";
+// Like the shell, it passes over a file it may not run.
+function findNode(pathEnv, name = process.platform === "win32" ? "node.exe" : "node") {
   for (const entry of (pathEnv || "").split(delimiter)) {
     const dir = entry.replace(/^"(.*)"$/, "$1");
     if (!dir || !isAbsolute(dir)) continue;
+    const file = join(dir, name);
     try {
-      if (statSync(join(dir, name)).isFile()) return join(dir, name);
+      if (statSync(file).isFile()) {
+        accessSync(file, constants.X_OK);
+        return file;
+      }
     } catch {
-      /* not in this folder */
+      /* not in this folder, or not runnable */
     }
   }
   return null;
 }
 
+const NO_NODE = '[!!] Render check: no "node" on PATH; the statusLine command runs "node", so the statusline will not show.';
+// Claude Code runs statusLine with Git Bash when it finds it, else with PowerShell. Of the two only
+// PowerShell runs node.cmd for "node", and this check cannot tell which it will be, so it does not run.
+const NODE_CMD_ONLY =
+  '[..] Render check: skipped; PATH has node.cmd but no node.exe, and Git Bash, which Claude Code runs statusLine with when it finds it, does not run node.cmd as "node".';
+const noNodeLine = (pathEnv) => (process.platform === "win32" && findNode(pathEnv, "node.cmd") ? NODE_CMD_ONLY : NO_NODE);
+
 function omcVersion(root) {
   if (!root) return null;
   try {
@@ -312,41 +510,58 @@ function omcVersion(root) {
   }
 }
 
+// The first line of a Node error ("Error: ...", "TypeError [ERR_X]: ..."), "" when there is none.
+const errorLine = (text) => /^\w*Error\b.*$/m.exec(text || "")?.[0] ?? "";
+
 // Why an OMC version does not load: its HUD's own error when run directly.
 function loadReason(node, root) {
   const hud = join(root, "dist", "hud", "index.js");
   if (!existsSync(hud)) return "no dist/hud/index.js";
   const r = spawnSync(node, [hud], RUN_OPTS);
-  const line = /^\w*Error\b.*$/m.exec(r.stderr || "");
-  return line ? clip(line[0]) : "";
+  const line = errorLine(r.stderr);
+  return line ? clip(line) : "";
 }
 
+const NO_OUTPUT = "[..] Render check: OMC printed nothing with no input, so this check cannot tell whether the statusline draws.";
+
 // What the formatter printed, as report lines.
 function judgeRender(out, node) {
   const banner = /^\[OMC\] HUD v(\S+) \| preset: /m.exec(out);
   if (banner) {
     const installed = omcVersion(pluginRoot);
-    if (!installed || installed === banner[1]) return [`[ok] Render check: the statusline loads OMC ${banner[1]}.`];
+    // Both version strings come from OMC (its output, its package.json): shown through clip like its lines.
+    const [drew, want] = [clip(banner[1], 40), clip(installed, 40)];
+    if (!installed || installed === banner[1]) return [`[ok] Render check: the statusline loads OMC ${drew}.`];
     const why = loadReason(node, pluginRoot);
-    const line = `[!!] Render check: the statusline loads OMC ${banner[1]}, not the installed ${installed}; ${installed} does not load`;
-    return [`${line}${why ? ` (${why})` : ""}.`, BLAME];
+    // Without an error from the installed version, all this check saw is which version drew.
+    if (!why) return [`[..] Render check: the statusline loads OMC ${drew}, not the installed ${want}.`];
+    return [`[!!] Render check: the statusline loads OMC ${drew}, not the installed ${want}; ${want} does not load (${why}).`, BLAME];
   }
+  // The formatter says this when OMC printed nothing; with no input that alone does not say it cannot draw.
+  if (/^\[OMC HUD\] no output$/m.test(out)) return [NO_OUTPUT];
   // OMC's line ends with the reason, after a path that can be long: keep it whole within reason.
   const failed = /^\[OMC HUD\] .*$/m.exec(out);
   if (failed) return [`[!!] Render check: OMC's HUD does not load: ${clip(failed[0], 1000)}`, BLAME];
+  // A loader that cannot load prints Node's error, header lines first; its module path can be long.
+  const error = errorLine(out);
+  if (error) return [`[!!] Render check: the statusline prints an error instead of a line: ${clip(error, 1000)}`];
   return [`[..] Render check: unrecognized output: ${clip(out.split("\n")[0])}`];
 }
 
+// A statusline command that exited non-zero: its Node error line when stderr has one, else the first line.
+function failedLine(r) {
+  const stderr = (r.stderr || "").trim();
+  const err = errorLine(stderr) || stderr.split("\n")[0];
+  return `[!!] Render check: the statusline command failed (exit ${r.status ?? r.signal})${err ? `: ${clip(err)}` : ""}`;
+}
+
 function renderReport() {
   const node = findNode(process.env.PATH);
-  if (!node) return ['[!!] Render check: no "node" on PATH; the statusLine command runs "node", so the statusline will not show.'];
+  if (!node) return [noNodeLine(process.env.PATH)];
   const r = spawnSync(node, [wrapperDst], RUN_OPTS);
   if (r.error && r.error.code === "ETIMEDOUT") return [`[!!] Render check: the statusline gave no answer in ${CHECK_MS / 1000}s.`];
   if (r.error) throw r.error;
-  if (r.status !== 0) {
-    const err = (r.stderr || "").trim().split("\n")[0];
-    return [`[!!] Render check: the statusline command failed (exit ${r.status ?? r.signal})${err ? `: ${clip(err)}` : ""}`];
-  }
+  if (r.status !== 0) return [failedLine(r)];
   return judgeRender((r.stdout || "").replace(/\x1b\[[0-9;]*m/g, ""), node);
 }
 
@@ -364,7 +579,7 @@ try {
   pointStatusLine();
 } catch (e) {
   log(`[x] Stopped partway (${e.code || e.message}); some files may have changed.`);
-  log(`    Earlier versions it replaced, apart from the loader and the tool blocks, are in <file>.backup.${stamp}.`);
+  log(`    Earlier versions it replaced, apart from the loader and blocks as the tools wrote them, are in <file>.backup.${stamp}.`);
   process.exit(2);
 }
 

package/skills/setup-omc-hud/assets/codex-config.mjs

@@ -0,0 +1,210 @@
+/*
+ * Codex 의 config.toml 을 줄 단위로 읽고 고치는 공통 모듈. setup-bypass-permissions 가 정본이고 setup-omc-hud 의
+ * assets/ 에 같은 사본을 둔다(scripts/sync-adapter.js 가 지킴).
+ *
+ * TOML 전체를 다시 쓰지 않는다. 바꾸는 키의 줄만 고쳐 주석, 순서, 다른 표는 그대로 둔다.
+ * - 줄을 훑으며 문자열(한 줄, 여러 줄)과 괄호 깊이를 따라가, 여러 줄 문자열이나 배열 안의 줄을 표 머리나 키로 보지 않는다.
+ * - 키 이름은 따옴표를 벗겨 비교한다(`"approval_policy"` 도 approval_policy). 값 끝의 주석은 값으로 보지 않는다.
+ * - 최상위가 표를 점 키나 인라인 표로 정했는지(definedInline) 알려, 그런 파일에 같은 표를 더하지 않게 한다.
+ * - 파일이 링크이거나 일반 파일이 아니면 고치지 않는다. 쓰기 전 원본을 백업(이 계정만 읽음)하고, 새 파일에 쓴 뒤
+ *   바꿔 넣으며 파일 모드를 지킨다.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// Codex 처럼 상대 경로 CODEX_HOME 은 지금 폴더 기준으로 푼다.
+export function codexConfigFile(env = process.env) {
+  const home = env.CODEX_HOME ? path.resolve(env.CODEX_HOME) : path.join(os.homedir(), '.codex');
+  return path.join(home, 'config.toml');
+}
+
+export class Refused extends Error {}
+
+// { text, mode, exists }. 없으면 빈 글. 링크나 일반 파일이 아니면 Refused.
+export function readToml(file) {
+  let st;
+  try {
+    st = fs.lstatSync(file);
+  } catch (e) {
+    if (e.code === 'ENOENT') return { text: '', mode: null, exists: false };
+    throw e;
+  }
+  if (!st.isFile()) throw new Refused(`${file} 이 일반 파일이 아님(링크이거나 다른 종류)`);
+  return { text: fs.readFileSync(file, 'utf8'), mode: st.mode & 0o7777, exists: true };
+}
+
+// 원본을 backup 에 복사한 뒤(원본이 있을 때) 새 파일에 써서 바꿔 넣는다.
+export function writeToml(file, text, { mode = null, backup = null } = {}) {
+  if (backup && fs.existsSync(file)) {
+    fs.copyFileSync(file, backup);
+    fs.chmodSync(backup, 0o600); // 원본에 비밀 값이 있을 수 있다
+  }
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, text, { flag: 'wx', mode: mode ?? 0o600 });
+    if (mode !== null) fs.chmodSync(tmp, mode);
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    fs.rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+
+const lines = (text) => text.split(/\r?\n/);
+const eol = (text) => (text.includes('\r\n') ? '\r\n' : '\n');
+// 파일이 쓰는 줄바꿈(CRLF 가 하나라도 있으면 CRLF).
+export const eolOf = eol;
+const TRIPLE = ['"""', "'''"];
+
+// 키나 표 이름을 낱말 배열로. 따옴표 안의 점은 나누지 않는다(`profiles."a.b"` 는 ['profiles', 'a.b']).
+export const nameParts = (s) => (s.match(/"[^"]*"|'[^']*'|[^.\s]+/g) ?? []).map((p) => p.replace(/^"(.*)"$|^'(.*)'$/, '$1$2'));
+// 비교용 이름. 낱말 사이를 \u0000 으로 이어, 점이 든 낱말과 점으로 나뉜 낱말을 구분한다.
+const plainName = (s) => nameParts(s).join('\u0000');
+
+// 한 줄을 문자열 밖에서 훑는다. { d: 괄호 깊이 변화, multi: 줄 끝에 열려 있는 여러 줄 문자열 구분자, cut: 주석 시작 위치 }.
+function scanLine(s, multi = '') {
+  let d = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (multi) {
+      if (s.startsWith(multi, i)) { i += 2; multi = ''; } else if (multi === TRIPLE[0] && s[i] === '\\') i++;
+      continue;
+    }
+    const c = s[i];
+    if (TRIPLE.some((t) => s.startsWith(t, i))) { multi = s.slice(i, i + 3); i += 2; }
+    else if (c === '"') { for (i++; i < s.length && s[i] !== '"'; i++) if (s[i] === '\\') i++; }
+    else if (c === "'") { const k = s.indexOf("'", i + 1); i = k < 0 ? s.length : k; }
+    else if (c === '#') return { d, multi, cut: i };
+    else if (c === '[' || c === '{') d++;
+    else if (c === ']' || c === '}') d--;
+  }
+  return { d, multi, cut: s.length };
+}
+
+// 표 머리. 이름 안의 따옴표 친 낱말에는 ] 가 들어갈 수 있다(`[projects."/a]b"]`).
+// 이름 부분은 탐욕 한 번으로 읽는다(겹치는 공백 패턴은 긴 줄에서 역추적이 폭증한다). 앞뒤 공백은 nameParts 가 지운다.
+const HEADER_RE = /^\s*\[\[?((?:"[^"]*"|'[^']*'|[^\]"'])+)\]\]?\s*(#.*)?$/;
+const KEY_RE = /^\s*((?:"[^"]*"|'[^']*'|[A-Za-z0-9_-]+)(?:\s*\.\s*(?:"[^"]*"|'[^']*'|[A-Za-z0-9_-]+))*)\s*=(.*)$/;
+
+// 줄마다 { kind: 'header'|'key'|'inside'|'other', name, end }. header 의 name 은 표 이름, key 의 name 은 키 이름이고
+// end 는 값이 끝나는 줄 다음. 여러 줄 문자열이나 배열 안의 줄은 inside.
+export function scan(text) {
+  const ls = lines(text);
+  const out = ls.map(() => ({ kind: 'other' }));
+  for (let i = 0; i < ls.length; i++) {
+    const header = HEADER_RE.exec(ls[i]);
+    if (header) { out[i] = { kind: 'header', name: plainName(header[1]) }; continue; }
+    const key = KEY_RE.exec(ls[i]);
+    if (!key) continue;
+    let { d, multi } = scanLine(key[2]);
+    let j = i + 1;
+    for (; (d > 0 || multi) && j < ls.length; j++) {
+      out[j] = { kind: 'inside' };
+      const r = scanLine(ls[j], multi);
+      d += r.d;
+      multi = r.multi;
+    }
+    out[i] = { kind: 'key', name: plainName(key[1]), end: j };
+    i = j - 1;
+  }
+  return out;
+}
+
+// 표의 줄 범위 [from, to). table '' 은 최상위. 표가 없으면 null.
+function tableRange(info, table) {
+  table = table.includes('\u0000') || !table ? table : plainName(table);
+  let from = table ? -1 : 0;
+  for (let i = 0; i < info.length; i++) {
+    if (info[i].kind !== 'header') continue;
+    if (from >= 0) return [from, i];
+    if (info[i].name === table) from = i + 1;
+  }
+  return from >= 0 ? [from, info.length] : null;
+}
+
+function keysOf(text, table) {
+  const info = scan(text);
+  const range = tableRange(info, table);
+  if (!range) return [];
+  const keys = [];
+  for (let i = range[0]; i < range[1]; i++) if (info[i].kind === 'key') keys.push({ at: i, end: info[i].end, name: info[i].name });
+  return keys;
+}
+
+// 키의 { at, end, raw }. raw 는 값 끝의 주석을 뺀 글. 없으면 null.
+export function findKey(text, table, key) {
+  const want = nameParts(key).join('\u0000');
+  const hit = keysOf(text, plainName(table)).find((k) => k.name === want);
+  if (!hit) return null;
+  const ls = lines(text).slice(hit.at, hit.end);
+  const parts = [ls[0].slice(ls[0].indexOf('=') + 1), ...ls.slice(1)];
+  let multi = '';
+  for (const part of parts.slice(0, -1)) multi = scanLine(part, multi).multi;
+  const last = parts.length - 1;
+  parts[last] = parts[last].slice(0, scanLine(parts[last], multi).cut); // 마지막 줄의 주석을 뗀다
+  const raw = parts.join('\n');
+  return { at: hit.at, end: hit.end, raw: raw.trim() };
+}
+
+// 최상위가 이 표를 점 키나 인라인 표로 정했는지(`tui.x = 1`, `tui = { ... }`). 그런 파일에 [표] 를 더하면 키가 겹쳐
+// Codex 가 설정을 읽지 못한다.
+export function definedInline(text, table) {
+  const t = plainName(table);
+  return keysOf(text, '').some((k) => k.name === t || k.name.startsWith(`${t}\u0000`));
+}
+
+// 키를 rawValue 로 둔다. 있으면 그 줄을 바꾸고, 없으면 표 끝(최상위는 첫 표 머리 앞)에 넣는다. 표가 없으면 끝에 만든다.
+// comment 가 있으면 키 바로 위에 그 주석 줄을 둔다.
+export function setKey(text, table, key, rawValue, comment = '') {
+  const ls = lines(text);
+  const nl = eol(text);
+  const line = [...(comment ? [comment] : []), `${key} = ${rawValue}`];
+  const hit = findKey(text, table, key);
+  if (hit) {
+    const above = comment && ls[hit.at - 1] === comment ? 1 : 0;
+    ls.splice(hit.at - above, hit.end - hit.at + above, ...line);
+    return ls.join(nl);
+  }
+  const range = tableRange(scan(text), table);
+  if (!range) {
+    while (ls.length && ls[ls.length - 1] === '') ls.pop();
+    return [...ls, ...(ls.length ? [''] : []), `[${table}]`, ...line, ''].join(nl);
+  }
+  // 다음 표 머리에 붙은 주석(`# MCP servers` 처럼 머리 바로 위의 주석 줄)과 그 앞 빈 줄은 건너뛰고 넣는다.
+  let at = range[1];
+  if (range[1] < ls.length) while (at > range[0] && ls[at - 1].trim().startsWith('#')) at--;
+  while (at > range[0] && ls[at - 1].trim() === '') at--;
+  ls.splice(at, 0, ...line);
+  return ls.join(nl);
+}
+
+// 키를 뺀다. comment 와 같은 주석 줄이 바로 위에 있으면 그것도 뺀다.
+export function removeKey(text, table, key, comment = '') {
+  const hit = findKey(text, table, key);
+  if (!hit) return text;
+  const ls = lines(text);
+  const above = comment && ls[hit.at - 1] === comment ? 1 : 0;
+  ls.splice(hit.at - above, hit.end - hit.at + above);
+  return ls.join(eol(text));
+}
+
+// 표에 키도 주석도 없으면 그 머리와 뒤의 빈 줄을 뺀다.
+export function dropEmptyTable(text, table) {
+  const info = scan(text);
+  const range = tableRange(info, table);
+  if (!range) return text;
+  const ls = lines(text);
+  if (ls.slice(range[0], range[1]).some((l) => l.trim())) return text;
+  ls.splice(range[0] - 1, range[1] - range[0] + 1);
+  return ls.join(eol(text));
+}
+
+// 이름이 prefix 로 시작하는 표들 중 key 를 정한 표 이름(예: profiles.* 의 approval_policy).
+export function tablesSetting(text, prefix, key) {
+  const p = plainName(prefix);
+  const names = scan(text).filter((x) => x.kind === 'header' && x.name.startsWith(`${p}\u0000`)).map((x) => x.name);
+  return [...new Set(names)].filter((n) => findKey(text, n, key)).map((n) => n.split('\u0000').join('.'));
+}
+
+// 쓰기 실패가 이 계정의 권한(샌드박스, 읽기 전용, 다른 소유자) 때문인지.
+export const denied = (e) => ['EACCES', 'EPERM', 'EROFS'].includes(e?.code);