@kaydash9999/banker-plugins 0.20.2 → 0.21.0

package/skills/payload-mon/SKILL.md

@@ -35,15 +35,17 @@ node "<이 스킬 디렉터리 절대경로>/scripts/payload-mon.mjs" <on|off|st
 - **Codex**: Codex 자신의 요청 크기는 재지 않는다. 32MB 한도와 세션 파일 형식은 Claude Code 의 것이기 때문이다.
   Codex 에서 실행해도 같은 머신의 Claude Code HUD 래퍼를 켜고 끄는 것만 하고, `status` 의 "현재 세션" 줄은 Claude Code 세션에서만 나온다.
   사용자가 Codex 쪽 표시를 기대하면 이 점을 먼저 알린다.
+  Codex 의 `workspace-write` 샌드박스는 `~/.claude` 쓰기를 막는다. `status` 는 읽기만 해 그대로 된다. `on`, `off` 는 샌드박스 밖 실행으로 승인을 요청해 돌린다.
+  승인 없이 돌리면 종료 1 과 `EROFS` 로 끝나고 아무것도 바뀌지 않는다(승인한 실행은 Codex 0.144.5 에서 확인). 승인을 요청할 수 없거나(승인 정책 `never`) 거부되면, 같은 명령을 Codex 입력창에서 `!` 를 붙여 사용자가 직접 실행하게 안내한다(예: `!node "<경로>" on`). 사용자가 친 `!` 명령은 샌드박스 밖에서 돈다(Codex 0.144.5, `-a never` 에서 실측). `codex exec` 처럼 사람이 없는 실행이면 그 명령을 보고하고 멈춘다. `--add-dir ~/.claude` 처럼 설정 폴더를 통째로 여는 방법은 쓰지 않는다. 그 세션이 훅과 설정을 고칠 수 있게 되어 샌드박스가 무력해진다.
 
 ## 동작
 
 - `on`: Claude Code 설정 폴더(`$CLAUDE_CONFIG_DIR`, 없으면 `~/.claude`)의 `hud/omc-hud-custom.mjs` 에서, ctx 를 넣는 줄 바로 뒤에 `// >>> payload-mon >>>` 블록 하나를 넣는다.
   블록이 불러오는 추정 모듈은 래퍼 옆 `hud/payload-mon/payload-size.mjs` 에 사본으로 둔다. 플러그인 설치 경로는 버전마다 바뀌어 업데이트 뒤에 사라지기 때문이다.
-  래퍼 파일이 다른 곳을 가리키는 링크면 사본은 그 파일 옆에 둔다. 래퍼 v4 가 링크를 푼 자리에서 사본을 찾기 때문이다.
+  래퍼 파일이 다른 곳을 가리키는 링크면 사본은 그 파일 옆에 둔다. 래퍼 v4 가 그 자리에서 사본을 먼저 찾기 때문이다.
   이미 켜져 있으면 래퍼를 바꾸지 않고, 모듈 사본이 이 버전과 다를 때만 사본을 맞춘다. 예전 방식(블록 2개)으로 켜져 있었다면 새 방식으로 바꾼다.
   바꾸기 전 내용은 `omc-hud-custom.mjs.payload-mon.bak` 에 남는다.
-- `off`: 그 블록만 빼서 래퍼를 켜기 전 상태로 되돌리고, 모듈 사본과 추정치 캐시를 지운다. 래퍼 v4 에서는 모듈 사본이 없어져 `PL:` 칸도 사라진다.
+- `off`: 그 블록만 빼서 래퍼를 켜기 전 상태로 되돌리고, 모듈 사본과 추정치 캐시를 지운다. 래퍼 v4 에서는 모듈 사본이 없어져 `PL:` 칸도 사라진다. 사본 폴더가 링크면 사본을 지우지 않고 그렇다고 알린다(`PL:` 칸이 남는다).
 - `status`: 켜짐·꺼짐, 모듈 사본이 이 버전과 같은지, statusLine 이 이 래퍼를 쓰는지, 현재 세션의 추정치를 보여 준다.
 - 같은 래퍼에 자기 표시 블록을 넣는 다른 도구가 있어도 서로의 블록을 건드리지 않는다.
 
@@ -61,6 +63,8 @@ node "<이 스킬 디렉터리 절대경로>/scripts/payload-mon.mjs" <on|off|st
 - "node --check 실패": 블록을 넣은 결과가 문법 검사를 통과하지 못했다(예: 래퍼가 ctx 를 넣는 줄을 비동기가 아닌 함수 안으로 옮김). 파일은 그대로다.
 - "래퍼에 쓸 권한이 없습니다", 또는 `status` 의 "HUD 래퍼를 읽을 수 없음": 래퍼 파일의 권한을 확인한다. 파일은 그대로다.
 - "모듈 사본을 쓰지 못했습니다": 래퍼 옆(래퍼 파일이 링크면 링크가 가리키는 파일 옆) `payload-mon/` 에 쓸 수 없다(권한, 같은 이름의 파일, 디스크 공간). 래퍼는 그대로다.
+  `사본 폴더가 링크입니다` 면 그 폴더가 다른 곳을 가리키는 링크다. 이 도구는 링크 너머에 쓰거나 지우지 않는다. 링크를 일반 폴더로 바꾼 뒤 다시 켠다.
+  `사본 폴더가 쓰는 동안 바뀌었습니다` 면 쓰는 사이 그 폴더가 다른 것(링크, 다른 폴더)으로 바뀌었거나, 바뀌었다 돌아와 사본이 폴더에 없다. 바뀐 자리의 사본은 이 도구가 쓴 그 파일이고 바이트도 같을 때만 거뒀다(원래 거기 있던 다른 래퍼의 사본은 둔다). 바뀌었다 돌아온 사이 다른 곳에 간 사본은 거두지 못한다. 폴더를 확인한 뒤 다시 켠다.
 - "표시(>>> / <<<)의 짝이 맞지 않습니다": 래퍼에 payload-mon 표시 줄이 한쪽만 남았다. `on`·`off` 모두 거부하므로, 손으로 고치지 말라는 원칙의 유일한 예외다.
   `setup-omc-hud` 로 HUD 를 재설치하거나, 래퍼에서 짝 없이 남은 `// >>> payload-mon >>>` 또는 `// <<< payload-mon <<<` 줄을 지운 뒤 다시 실행한다.
 - HUD 를 재설치한 뒤 payload 가 안 보이면 `on` 을 다시 실행한다. `setup-omc-hud` 는 설치할 때마다 이 스킬을 늘 켠다(래퍼 v4 의 `PL:` 칸이 모듈 사본을 씀).

package/skills/payload-mon/scripts/payload-mon.mjs

@@ -26,7 +26,9 @@
  * import pointing there would go dark without a word. `on` writes the copy and
  * refreshes it when this version's module differs; `status` says when it does.
  * When the wrapper file itself is a symlink, the copy goes beside the file it
- * points at, where wrapper v4 looks.
+ * points at, where wrapper v4 looks first. A copy folder (payload-mon/) that is
+ * itself a link is neither written nor emptied through: `on` refuses it, and
+ * also refuses (taking its copy back) when the folder changes while it writes.
  *
  * The block takes the ctx line's line ending, so a CRLF wrapper stays CRLF, and
  * a block whose line endings an editor rewrote still counts as on. A wrapper
@@ -63,7 +65,10 @@ import { CACHE_DIR, clearCache, estimatePayloadBytes, REQUEST_LIMIT_BYTES, SHOW_
 
 const OPEN = "// >>> payload-mon >>>";
 const CLOSE = "// <<< payload-mon <<<";
-const BLOCKS = /^[ \t]*\/\/ >>> payload-mon >>>[\s\S]*?\/\/ <<< payload-mon <<<[ \t]*\r?\n/gm;
+export const BLOCKS = /^[ \t]*\/\/ >>> payload-mon >>>[\s\S]*?\/\/ <<< payload-mon <<<[ \t]*\r?\n/gm;
+// The closing line. No block reaches past the last one, so the 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).
+export const CLOSE_LINE = /\/\/ <<< payload-mon <<<[ \t]*\r?\n/g;
 // The block goes right after the line that adds ctx.
 const CTX_LINE = /^ {2}if \(f\.ctx\) colored\.push\(colorCtx\(f\.ctx\)\);\r?\n/m;
 // The statusline JSON the block reads, in either layout.
@@ -139,6 +144,13 @@ const insertBlock = (base, url) => base.replace(CTX_LINE, (line) => line + place
 
 const count = (text, needle) => text.split(needle).length - 1;
 
+// The text without its blocks, the pattern run only up to the last closing line (see CLOSE_LINE).
+function withoutBlocks(src) {
+  let end = -1;
+  for (const m of src.matchAll(CLOSE_LINE)) end = m.index + m[0].length;
+  return end < 0 ? src : src.slice(0, end).replace(BLOCKS, "") + src.slice(end);
+}
+
 // The wrapper's text, null when there is no such file. Any other read failure
 // (permissions, say) is not "missing" and propagates.
 const readText = (file) => {
@@ -174,7 +186,7 @@ function blockEol(src, url) {
 // not pair up would let the block pattern swallow the code between them.
 function misfit(src) {
   if (count(src, OPEN) !== count(src, CLOSE)) return "payload-mon 표시(>>> / <<<)의 짝이 맞지 않습니다";
-  const base = src.replace(BLOCKS, "");
+  const base = withoutBlocks(src);
   if (!base.includes("omc-hud.mjs") || !base.includes("const colorRate")) return "OMC 커스텀 HUD 래퍼가 아닙니다";
   if (!INPUT_DECL.test(base)) return "삽입 위치를 찾지 못했습니다(statusline 입력을 담는 input 변수가 없음)";
   if (!CTX_LINE.test(base)) return "삽입 위치를 찾지 못했습니다(ctx를 넣는 줄이 없음)";
@@ -189,6 +201,16 @@ function copyState(o) {
   return source !== null && copy.equals(source) ? "current" : "stale";
 }
 
+// Whether the folder holding `file` is a link. The copy folder is this tool's, and a link there
+// would take the copy, or its removal, to wherever it points.
+function linkedFolder(file) {
+  try {
+    return lstatSync(dirname(file)).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
 // Replaces file through a fresh temp file ("wx") and a rename: a link planted at
 // either name is replaced rather than written through, and a write that fails
 // leaves the old file as it was.
@@ -197,24 +219,62 @@ function writeFresh(file, data, mode) {
   rmSync(tmp, { force: true });
   try {
     writeFileSync(tmp, data, { flag: "wx", mode });
+    const id = fileId(tmp);
     renameSync(tmp, file);
+    return id;
   } catch (e) {
     rmSync(tmp, { force: true });
     throw e;
   }
 }
 
+// A file's identity, exact: NTFS file IDs pass 2^53, where a Number loses the low bits.
+const fileId = (p) => {
+  const s = lstatSync(p, { bigint: true });
+  return `${s.dev}:${s.ino}`;
+};
+// The copy folder's identity, to tell afterwards whether it is still the folder that was written into.
+const folderStamp = (dir) => {
+  const s = lstatSync(dir, { bigint: true });
+  return `${s.dev}:${s.ino}:${s.isSymbolicLink()}`;
+};
+// After the write: the copy folder must still be the one stamped before, holding these bytes. Another program
+// may have swapped it (for a link, say), so the copy went wherever it led, or put it back after the write, so
+// the copy is not in it. Then the write is refused, and the copy is taken back from where the folder now leads
+// when the file there is the one written (`written`, from writeFresh) and still ours byte for byte: a copy that
+// was there before, or one another program wrote over, stays.
+// Node has no openat, so a copy that went elsewhere through a swap that was put back stays where it went, and
+// a swap after this check goes unseen.
+function checkFolder(copy, stamp, data, written) {
+  const dir = dirname(copy);
+  if (folderStamp(dir) === stamp && readBytes(copy)?.equals(data)) return;
+  try {
+    const landed = join(realpathSync(dir), basename(copy));
+    if (fileId(landed) === written && readFileSync(landed).equals(data)) rmSync(landed, { force: true });
+  } catch {
+    /* nothing there to take back */
+  }
+  throw new Error(`사본 폴더가 쓰는 동안 바뀌었습니다: ${dir}`);
+}
+
 // Brings the copy up to this version's module; true when it had to write. The
 // statusline imports it on every refresh, so no other account may change it
 // (reading it is harmless). When the write fails, a folder made here is taken
 // away again: mkdirSync names a folder only when it created it, and rmdir
 // leaves one that something else has meanwhile put a file in.
 function syncModule(o) {
-  if (copyState(o) === "current") return false;
   const copy = moduleCopy(o.hudFile);
+  if (linkedFolder(copy)) throw new Error(`사본 폴더가 링크입니다: ${dirname(copy)}`);
+  if (copyState(o) === "current") return false;
+  // Read first: a module that cannot be read leaves no folder behind.
+  const data = readFileSync(o.moduleSource);
   const made = mkdirSync(dirname(copy), { recursive: true, mode: 0o755 }) !== undefined;
   try {
-    writeFresh(copy, readFileSync(o.moduleSource), 0o644);
+    const stamp = folderStamp(dirname(copy));
+    // From the same lstat: a folder that became a link since the check above is refused before the write.
+    if (stamp.endsWith(":true")) throw new Error(`사본 폴더가 링크입니다: ${dirname(copy)}`);
+    const written = writeFresh(copy, data, 0o644);
+    checkFolder(copy, stamp, data, written);
   } catch (e) {
     if (made) {
       try {
@@ -307,23 +367,26 @@ export function turnOn(opts = {}) {
   const done = showsPL(src)
     ? "켰습니다. 다음 statusline 갱신부터 PL 칸에 요청 크기가 늘 표시됩니다."
     : "켰습니다. 다음 statusline 갱신부터 8MB 이상이면 ctx 옆에 payload가 표시됩니다.";
-  const after = insertBlock(src.replace(BLOCKS, ""), moduleUrl(o.hudFile));
+  const after = insertBlock(withoutBlocks(src), moduleUrl(o.hudFile));
   return commit(o.hudFile, src, after, done + notShownNote(o), () => syncModule(o));
 }
 
 function removeBlocks(o, src) {
   if (src === null) return { ok: true, message: `HUD 래퍼가 없어 끌 것이 없습니다: ${o.hudFile}` };
   if (count(src, OPEN) !== count(src, CLOSE)) return refusal("payload-mon 표시(>>> / <<<)의 짝이 맞지 않습니다", o.hudFile);
-  const out = src.replace(BLOCKS, "");
+  const out = withoutBlocks(src);
   if (out === src) return { ok: true, message: "이미 꺼져 있습니다 (래퍼 변경 없음)." };
   return commit(o.hudFile, src, out, "껐습니다. 다음 statusline 갱신부터 payload가 표시되지 않습니다.");
 }
 
 // What off leaves behind otherwise: the cache (when this account controls its
 // folder), and the module copy with its folder (only when nothing else is in
-// it), also the one 0.20.1 left beside a linked wrapper. None failing undoes off.
+// it), also the one 0.20.1 left beside a linked wrapper, but nothing through a copy folder that is a link.
+// None failing undoes off.
+// Returns the copy folders it left alone because they are links.
 function removeLeftovers(o) {
-  const copies = [...new Set([moduleCopy(o.hudFile), besideLink(o.hudFile)])];
+  const all = [...new Set([moduleCopy(o.hudFile), besideLink(o.hudFile)])];
+  const copies = all.filter((copy) => !linkedFolder(copy));
   for (const remove of [() => clearCache(o.cacheDir), ...copies.map((copy) => () => rmSync(copy, { force: true }))]) {
     try {
       remove();
@@ -338,14 +401,18 @@ function removeLeftovers(o) {
       /* absent, or holds something that is not ours */
     }
   }
+  return all.filter((copy) => !copies.includes(copy)).map((copy) => dirname(copy));
 }
 
 export function turnOff(opts = {}) {
   const o = { ...DEFAULTS, ...opts };
   const res = removeBlocks(o, readText(o.hudFile));
-  if (res.ok) removeLeftovers(o);
-  return res;
+  if (!res.ok) return res;
+  // A copy kept in a linked folder still feeds wrapper v4's PL segment, so off says so.
+  const kept = removeLeftovers(o);
+  return kept.length ? { ...res, message: `${res.message} ${KEPT_NOTE}: ${kept.join(", ")}` } : res;
 }
+const KEPT_NOTE = "사본 폴더가 링크라 모듈 사본은 지우지 않았습니다(래퍼 v4 의 PL 칸이 계속 보일 수 있음)";
 
 // The estimate for the session that runs this, "" if unknown, ending with where
 // it shows when `where` names it:
@@ -378,7 +445,16 @@ function stateOf(src, o) {
   // on and off both refuse this, so pointing at on would be a dead end.
   if (count(src, OPEN) !== count(src, CLOSE)) return "표시(>>> / <<<)의 짝이 맞지 않습니다 (on·off 모두 거부: HUD 재설치 또는 남은 표시 줄 정리)";
   if (blockEol(src, moduleUrl(o.hudFile)) === "") return "켜짐이 불완전하거나 오래됨 (on 으로 복구)";
-  return "켜짐" + COPY_NOTE[copyState(o)];
+  return "켜짐" + copyNote(o);
+}
+
+// What status adds about the module copy. In a copy folder that is a link, on refuses to write it, so
+// pointing at on would be a dead end.
+function copyNote(o) {
+  const state = copyState(o);
+  const copy = moduleCopy(o.hudFile);
+  if (state !== "current" && linkedFolder(copy)) return `, 단 사본 폴더가 링크라 모듈 사본을 쓰지 않음 (링크를 일반 폴더로 바꾼 뒤 on): ${dirname(copy)}`;
+  return COPY_NOTE[state];
 }
 
 // What status says about the wrapper. A wrapper it cannot read is reported, not

package/skills/payload-mon/scripts/payload-size.mjs

@@ -211,7 +211,10 @@ export function clearCache(dir = CACHE_DIR) {
 export function estimatePayloadBytes(transcriptPath, cacheDir = CACHE_DIR) {
   const fd = openSync(transcriptPath, "r");
   try {
-    const { size, ino } = fstatSync(fd);
+    // The file number as a string: NTFS file IDs pass 2^53, where a Number loses the low bits, and JSON has no BigInt.
+    const st = fstatSync(fd, { bigint: true });
+    const size = Number(st.size);
+    const ino = String(st.ino);
     const file = cacheFile(cacheDir, transcriptPath);
     const c = loadCache(file);
     // Resume only a cache of these rules, for this file, which has not shrunk since.

package/skills/pdf-vision-extract/SKILL.md

@@ -35,7 +35,7 @@ Target: **long edge = 2400 px** (just under cap, leaves headroom).
 
 ```bash
 ls -lh <pdf-path>
-python3 -c "import fitz; d=fitz.open('<pdf-path>'); print('pages=', d.page_count)"
+(cd ~ && python3 -c "import fitz; d=fitz.open('<absolute-pdf-path>'); print('pages=', d.page_count)")   # from home: -c, -m and a stdin script import from the current folder first
 ```
 
 ### 2. Choose output directory
@@ -49,7 +49,7 @@ Convention: place PNGs **next to** existing design assets, in a subfolder named
 PyMuPDF is the most reliable single-dependency path (no Poppler, no ImageMagick).
 
 ```bash
-python3 - <<'PY'
+(cd ~ && python3 - <<'PY'
 import fitz, os
 SRC = "<absolute-pdf-path>"
 OUT = "<absolute-output-dir>"
@@ -63,9 +63,12 @@ for i, page in enumerate(doc, start=1):
     pix.save(f"{OUT}/page-{i:03d}.png")
     print(f"[{i}/{doc.page_count}] page-{i:03d}.png {pix.width}x{pix.height}")
 PY
+)
 ```
 
-Install if missing: `python3 -m pip install --user pymupdf`
+Install if missing: `(cd ~ && python3 -m pip install --user pymupdf)`
+
+Offline (no network): do not install; look for the fallback tools of section 4 (`pdftoppm`, ImageMagick) instead and say "오프라인이라 설치하지 않음(필요한 것: pymupdf)". pip retries 5 times with a 15 s timeout by default before it fails.
 
 ### 4. Fallback toolchain
 
@@ -83,7 +86,7 @@ If Python/PyMuPDF unavailable:
 
 ```bash
 ls <OUT> | wc -l                # page count matches PDF
-python3 -c "from PIL import Image; im=Image.open('<OUT>/page-001.png'); print(im.size)"
+(cd ~ && python3 -c "from PIL import Image; im=Image.open('<absolute-output-dir>/page-001.png'); print(im.size)")
 ```
 
 Expect long edge ≈ 2400 px.
@@ -110,10 +113,12 @@ For multiple pages in one turn, batch multiple `Read` calls in parallel.
 For a hybrid pipeline (visual + searchable text), also extract markdown:
 
 ```bash
-python3 -m pip install --user pymupdf4llm
-python3 -c "import pymupdf4llm; print(pymupdf4llm.to_markdown('<pdf>'))" > <OUT>/text.md
+(cd ~ && python3 -m pip install --user pymupdf4llm)
+(cd ~ && python3 -c "import pymupdf4llm; print(pymupdf4llm.to_markdown('<absolute-pdf-path>'))") > <OUT>/text.md
 ```
 
+The install needs the network too; offline, leave the markdown companion out and say so.
+
 Then `grep` the `.md` for labels and cross-reference with the PNGs.
 
 ## Example invocation history