@kaydash9999/banker-plugins 0.19.0 → 0.19.2

package/skills/anti-drm/scripts/anti-drm.mjs

@@ -47,7 +47,6 @@ import {
   readFileSync,
   readSync,
   realpathSync,
-  statSync,
 } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -61,6 +60,7 @@ import {
   done,
   hasMarker,
   lf,
+  LINK_REPLACED,
   noBom,
   present,
   refuse,
@@ -204,9 +204,9 @@ export function readConfig(file) {
   return checkConfig({ deny: raw.deny, alt: raw.alt, tsvDelimiter: raw.tsvDelimiter ?? "tab" });
 }
 
-// What sits at the settings path: "none", "file" (a regular file, or a link to
-// one), or "other" (a folder, a FIFO). A link that points nowhere or loops is
-// "none": the save replaces the link.
+// What sits at the settings path: "none", "file" (a regular file with this one name), "link" (a link, wherever it
+// leads), "hardlink" (a regular file with another name too) or "other" (a folder, a FIFO). The save replaces a link
+// or a hard link by this name only: what it led to stays, so nothing of it is read or kept.
 function pathKind(file) {
   let st;
   try {
@@ -215,31 +215,64 @@ function pathKind(file) {
     if (e.code === "ENOENT" || e.code === "ENOTDIR") return "none";
     throw e;
   }
-  if (st.isFile()) return "file";
-  if (!st.isSymbolicLink()) return "other";
+  if (st.isSymbolicLink()) return "link";
+  if (!st.isFile()) return "other";
+  return st.nlink > 1 ? "hardlink" : "file";
+}
+
+// Opened without blocking. O_NOFOLLOW, where the system has it, keeps the open from following a link put at the name
+// after the first look; Windows has none, so there the name is looked at again after the open.
+const PRIOR_OPEN = constants.O_RDONLY | (constants.O_NONBLOCK ?? 0);
+const NO_FOLLOW = constants.O_NOFOLLOW ?? 0;
+
+/**
+ * What the settings name holds after the open, against the opened file, from their bigint stats: "same", "link" (a
+ * link now: the open followed it), "hardlink" (the opened file has another name now) or "changed" (gone, not a regular
+ * file, or another file: the file IDs differ; an ID of 0, which some file systems give, proves nothing).
+ */
+export function nameNow(opened, now) {
+  if (now?.isSymbolicLink()) return "link";
+  if (!now?.isFile()) return "changed";
+  if (opened.ino !== 0n && (now.ino !== opened.ino || now.dev !== opened.dev)) return "changed";
+  return now.nlink > 1n ? "hardlink" : "same";
+}
+
+// The name's own stats in bigint, or null when it cannot be looked at.
+function lstatOrNull(file) {
   try {
-    return statSync(file).isFile() ? "file" : "none";
+    return lstatSync(file, { bigint: true });
   } catch {
-    return "none";
+    return null;
   }
 }
 
-// The bytes of the file at the settings path, opened without blocking: { bytes }
-// (null when it turned out not to be a regular file) or { refusal }.
-export function priorBytes(file) {
+// What the file opened at the settings path gives, as priorBytes says. Without O_NOFOLLOW the name must still hold it.
+function openedBytes(file, fd, noFollow) {
+  const st = fstatSync(fd);
+  if (!st.isFile() || st.nlink > 1) return { bytes: null };
+  const now = noFollow ? "same" : nameNow(fstatSync(fd, { bigint: true }), lstatOrNull(file));
+  if (now === "changed") return { refusal: "확인하는 사이에 바뀐 자리라 설정을 저장하지 않았습니다" };
+  if (now !== "same") return { bytes: null };
+  if (st.size > MAX_BYTES) return { refusal: "64KiB 보다 큰 파일이라 설정을 저장하지 않았습니다" };
+  return { bytes: readFileSync(fd) };
+}
+
+/**
+ * The bytes of the regular file with this one name at the settings path: { bytes } (null when it turned out to be
+ * something else: gone, a link, not a regular file, or a file with another name too, which the save loses nothing
+ * of) or { refusal }. noFollow is O_NOFOLLOW where the system has it; 0 takes the Windows way.
+ */
+export function priorBytes(file, noFollow = NO_FOLLOW) {
   let fd;
   try {
-    fd = openSync(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+    fd = openSync(file, PRIOR_OPEN | noFollow);
   } catch (e) {
-    if (e.code === "ENOENT" || e.code === "ENOTDIR") return { bytes: null };
+    if (e.code === "ENOENT" || e.code === "ENOTDIR" || e.code === "ELOOP") return { bytes: null };
     if (denied(e)) return { refusal: "읽을 수 없는 파일이라 설정을 저장하지 않았습니다" };
     throw e;
   }
   try {
-    const st = fstatSync(fd);
-    if (!st.isFile()) return { bytes: null };
-    if (st.size > MAX_BYTES) return { refusal: "64KiB 보다 큰 파일이라 설정을 저장하지 않았습니다" };
-    return { bytes: readFileSync(fd) };
+    return openedBytes(file, fd, noFollow);
   } finally {
     closeSync(fd);
   }
@@ -260,22 +293,27 @@ function ownSettings(bytes) {
   }
 }
 
-// Whether anything, a dangling link included, already sits at path.
-function taken(path) {
+// Keeps a file anti-drm did not write at bak, once, and says what it did: "kept", "earlier" (a regular file is there
+// already and stays) or "other" (something else is there: a link, a dangling one too, or a folder; nothing is written).
+// The note comes from the same look as the write.
+function keepOnce(bak, bytes) {
+  let st;
   try {
-    lstatSync(path);
-    return true;
-  } catch {
-    return false;
+    st = lstatSync(bak);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+    writeFresh(bak, bytes, 0o600);
+    return "kept";
   }
+  return st.isFile() ? "earlier" : "other";
 }
 
-// What a save finds at the settings path: { keep } (the bytes to put in .bak,
-// null for none: nothing there, or anti-drm's own settings) or { refusal }.
+// What a save finds at the settings path: { keep } (the bytes to put in .bak, null for none: nothing there, a link
+// or a hard link, whose file stays, or anti-drm's own settings) or { refusal }.
 function priorSettings(file) {
   const kind = pathKind(file);
-  if (kind === "none") return { keep: null };
   if (kind === "other") return { refusal: "일반 파일이 아니라 설정을 저장하지 않았습니다" };
+  if (kind !== "file") return { keep: null };
   const got = priorBytes(file);
   if (got.refusal) return got;
   return { keep: got.bytes === null || ownSettings(got.bytes) ? null : got.bytes };
@@ -285,12 +323,14 @@ function priorSettings(file) {
  * Saves the settings: the folder 0755, the file 0644 through a temp file and a
  * rename. keep, when given, is a file anti-drm did not write; its bytes go to
  * <file>.bak, readable by this account only, once: a .bak already there is the
- * first such file and stays.
+ * first such file and stays. Gives back what became of keep: null when none was
+ * given, else "kept", "earlier" or "other" (see keepOnce).
  */
 export function writeConfig(file, config, keep = null) {
   mkdirSync(dirname(file), { recursive: true, mode: 0o755 });
-  if (keep !== null && !taken(`${file}.bak`)) writeFresh(`${file}.bak`, keep, 0o600);
+  const kept = keep === null ? null : keepOnce(`${file}.bak`, keep);
   writeFresh(file, `${JSON.stringify(config, null, 2)}\n`, 0o644);
+  return kept;
 }
 
 // ---- rules ----
@@ -396,17 +436,38 @@ export function status(opts = {}) {
   return done(lines.join("\n"));
 }
 
-// Saves the settings, as a result to report.
+// What a save does beyond writing the settings, as lines to report: a link or a hard link at the settings path becomes
+// a regular file (what it led to stays, and nothing of it goes to .bak), and a file anti-drm did not write goes to
+// .bak, or is not kept when an earlier one, or something that is not a regular file, is there already. kept is what
+// writeConfig gave back.
+const KEPT_NOTES = {
+  kept: (bak) => `참고: anti-drm 이 쓰지 않은 원래 파일은 ${bak} 에 남겼습니다.`,
+  earlier: (bak) => `참고: anti-drm 이 쓰지 않은 원래 파일은 남기지 않았습니다. 먼저 남긴 파일이 있습니다: ${bak}`,
+  other: (bak) => `참고: anti-drm 이 쓰지 않은 원래 파일은 남기지 않았습니다. 그 자리에 일반 파일이 아닌 것이 있습니다: ${bak}`,
+};
+const REPLACED_NOTES = {
+  link: LINK_REPLACED,
+  hardlink: "참고: 하드 링크였던 자리를 일반 파일로 바꿨습니다. 같은 파일의 다른 이름은 건드리지 않았습니다.",
+};
+function saveNotes(file, replaced, kept) {
+  const notes = REPLACED_NOTES[replaced] ? [REPLACED_NOTES[replaced]] : [];
+  if (kept) notes.push(KEPT_NOTES[kept](where(`${file}.bak`)));
+  return notes;
+}
+
+// Saves the settings, as a result to report. The look just before the write names what the rename replaces.
 function save(o, config) {
+  let notes;
   try {
     const prior = priorSettings(o.configFile);
     if (prior.refusal) return refuse(`${prior.refusal}: ${where(o.configFile)}`);
-    writeConfig(o.configFile, config, prior.keep);
+    const replaced = pathKind(o.configFile);
+    notes = saveNotes(o.configFile, replaced, writeConfig(o.configFile, config, prior.keep));
   } catch (e) {
     if (denied(e)) return refuse(`쓸 권한이 없어 설정을 저장하지 못했습니다 (${e.code}): ${where(o.configFile)}`);
     throw e;
   }
-  return done(`설정을 저장했습니다: ${where(o.configFile)}`);
+  return done([`설정을 저장했습니다: ${where(o.configFile)}`, ...notes].join("\n"));
 }
 
 // New rules in each runtime that holds the rules, but `skip`. A runtime that

package/skills/anti-drm/scripts/instruction-toggle.mjs

@@ -42,7 +42,9 @@
  * the Codex folder), so both skills turned on at once keep both blocks; a lock
  * older than a minute is taken over.
  *
- * Results are { ok, message }; ok false means refused with nothing changed.
+ * Results are { ok, message }; ok false means refused with nothing changed, or,
+ * when a change of two files was refused at the second, with the first changed
+ * and named in the message ("앞서 바꾼 파일").
  * Anything else that goes wrong throws.
  */
 import {
@@ -95,7 +97,7 @@ const isLink = (path) => {
 
 const UTF8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 
-// What sits at a name that is not a regular file: a folder, a FIFO or a device.
+// What sits at a name that is not a regular file: a folder, a FIFO, a socket, a device or a link loop.
 // It is never read; reading a FIFO waits for a writer.
 const SPECIAL = Object.freeze({ bytes: null, text: null, special: true });
 // What sits at a name that is a link to nothing: Codex finds no file there, and writing would follow the link.
@@ -148,7 +150,7 @@ function readFile(path) {
 
 /** A result that did, or found already done, what was asked. */
 export const done = (message) => ({ ok: true, message });
-/** A result that refused and changed nothing. */
+/** A result that refused and changed nothing, unless its message names a file changed before (applied). */
 export const refuse = (message) => ({ ok: false, message });
 
 /** A skill's marks: the first line of its rules file, and the lines around its Codex block. */
@@ -226,6 +228,7 @@ function claudeOn(t, o, getRules) {
   const state = claudeState(t, readFile(file), rules);
   if (state === "foreign") return refuse(`같은 이름의 다른 파일이 있어 그대로 두었습니다: ${shown}`);
   if (state === "on") return done(`Claude Code: 이미 켜져 있습니다 (변경 없음). ${shown}`);
+  const wasLink = isLink(file);
   try {
     mkdirSync(dirname(file), { recursive: true, mode: 0o755 });
     writeFresh(file, claudeText(t, rules));
@@ -233,13 +236,13 @@ function claudeOn(t, o, getRules) {
     if (denied(e)) return refuse(`쓸 권한이 없어 켜지 못했습니다 (${e.code}): ${shown}`);
     throw e;
   }
-  return done(
-    state === "stale"
-      ? `Claude Code: ${t.updatedText}. ${shown}`
-      : `Claude Code: 켰습니다. 다음 세션부터 자동 적용됩니다. ${shown}`,
-  );
+  const words = state === "stale" ? `Claude Code: ${t.updatedText}. ${shown}` : `Claude Code: 켰습니다. 다음 세션부터 자동 적용됩니다. ${shown}`;
+  return done(wasLink ? `${words}\n${LINK_REPLACED}` : words);
 }
 
+/** The note for a name that was a link (to nothing, or to an older copy) and is now a regular file. */
+export const LINK_REPLACED = "참고: 링크였던 자리를 일반 파일로 바꿨습니다. 링크가 가리키던 곳은 건드리지 않았습니다.";
+
 function claudeOff(t, o) {
   const file = claudeFile(t, o);
   const state = claudeState(t, readFile(file));
@@ -435,10 +438,14 @@ function withBlock(t, text, rules) {
 }
 
 // The state when the block is not in its place: "hidden" (only in an override with no text of its own),
-// "misplaced" (only in AGENTS.md while Codex reads the override), "dangling" (nowhere, and AGENTS.md is a link to
-// nothing that on must not write through) or "off".
+// "hiddenbroken" (the same, with AGENTS.md a link to nothing, so on cannot move it), "misplaced" (only in AGENTS.md
+// while Codex reads the override), "dangling" (nowhere, and AGENTS.md is a link to nothing that on must not write
+// through) or "off".
 function placeState(files) {
-  if (hasBlock(files.other)) return files.other === files.all[0] ? "hidden" : "misplaced";
+  if (hasBlock(files.other)) {
+    if (files.other !== files.all[0]) return "misplaced";
+    return files.target.dangling ? "hiddenbroken" : "hidden";
+  }
   return files.target.dangling ? "dangling" : "off";
 }
 
@@ -477,12 +484,32 @@ function writeBlocked(changes) {
 // whatever the umask allows more. A file left empty is removed, unless it is a
 // link or has other names (a hard link), whose other names would keep the old
 // text: it is emptied instead. Codex skips an empty file anyway.
+// A file that was not there when it was read is created only if it still is not ("wx"): a name that appeared in
+// between, a link planted there among them, is not written through.
 function apply(t, changes) {
   for (const { file, after } of changes) {
     if (file.bytes !== null) writeFresh(`${file.path}.${t.slug}.bak`, file.bytes, 0o600);
     if (after === "" && !isLink(file.path) && !hasOtherNames(file.path)) rmSync(file.path, { force: true });
-    else writeFileSync(file.path, after, { mode: 0o644 });
+    else writeFileSync(file.path, after, { mode: 0o644, flag: file.bytes === null ? "wx" : "w" });
+  }
+}
+
+// Applies the changes, or the refusal for a write that failed with nothing of the file changed: a name that
+// appeared in between (EEXIST), or a write a sandbox refused after access() allowed it. The refusal names the place
+// the system refused (a rename's target, as the backup, or the file it was about), and a file changed before the
+// failing one. Other errors propagate.
+function applied(t, changes) {
+  let i = 0;
+  try {
+    for (; i < changes.length; i++) apply(t, [changes[i]]);
+  } catch (e) {
+    if (e.code !== "EEXIST" && !denied(e)) throw e;
+    const why = e.code === "EEXIST" ? "쓰는 사이에 같은 이름이 생겨 그대로 두었습니다" : `쓸 권한이 없어 그대로 두었습니다 (${where(e.code)})`;
+    const at = [e.dest, e.path].find((p) => typeof p === "string") ?? changes[i].file.path;
+    const before = i === 0 ? "" : `\n앞서 바꾼 파일: ${changes.slice(0, i).map((c) => where(c.file.path)).join(", ")}`;
+    return refuse(`${why}: ${where(at)}${before}`);
   }
+  return null;
 }
 
 // Whether the file at path is also reachable under another name: a hard link.
@@ -523,6 +550,7 @@ function dropStale(path) {
     st = lstatSync(path);
   } catch (e) {
     if (e.code === "ENOENT") return true; /* gone in between */
+    if (e.code === "ESTALE") return false; /* a network share's stale handle: rest and look again, not spin */
     throw e;
   }
   if (st.isDirectory() || Math.abs(Date.now() - st.mtimeMs) <= LOCK_STALE_MS) return false;
@@ -628,7 +656,8 @@ function codexOnHeld(t, o, getRules) {
   if (hasBlock(files.other)) changes.push({ file: files.other, after: stripped(files.other) });
   const why = writeBlocked(changes);
   if (why) return refuse(why);
-  apply(t, changes);
+  const failed = applied(t, changes);
+  if (failed) return failed;
   const note = files.target === files.all[1] ? `\n${OMX_NOTE}` : "";
   return done(`Codex: ${words}. ${tail}${note}`);
 }
@@ -646,7 +675,8 @@ function codexOffHeld(t, o) {
   if (changes.length === 0) return done("Codex: 이미 꺼져 있습니다 (변경 없음).");
   const why = writeBlocked(changes);
   if (why) return refuse(why);
-  apply(t, changes);
+  const failed = applied(t, changes);
+  if (failed) return failed;
   const paths = changes.map((c) => where(c.file.path)).join(", ");
   const baks = changes.map((c) => where(`${c.file.path}.${t.slug}.bak`)).join(", ");
   return done(`Codex: 껐습니다. 다음 세션부터 적용되지 않습니다. ${paths}\n지우기 전 파일: ${baks}`);
@@ -661,6 +691,7 @@ const STATE_TEXT = {
   foreign: "꺼짐, 같은 이름의 다른 파일이 있음 (손대지 않음)",
   misplaced: "꺼짐, 단 블록이 Codex 가 읽지 않는 AGENTS.md 에 있음 (on 으로 옮김)",
   hidden: "켜짐, 단 AGENTS.override.md 에 블록만 있어 AGENTS.md 가 가려짐 (on 으로 옮김)",
+  hiddenbroken: "켜짐, 단 AGENTS.override.md 에 블록만 있고 AGENTS.md 가 끊어진 링크라 on 이 블록을 옮기지 못함 (링크 확인 필요)",
   notutf8: "UTF-8 이 아닌 지침 파일이 있어 손대지 않음 (on, off 모두 거부)",
   notregular: "일반 파일이 아닌 지침 파일이 있어 손대지 않음 (on, off 모두 거부)",
   unpaired: "표시의 짝이 맞지 않음 (on, off 모두 거부. 남은 표시 줄 정리 필요)",

package/skills/lineage/SKILL.md

@@ -2,7 +2,7 @@
 name: lineage
 description: "현재 세션 대화를 카카오톡 스타일의 단일 HTML 로 내보냄. Claude 답변은 한 줄 요약 아래에 원문을 접어 두고, 펼치면 마크다운으로 렌더해 보여 줌. 기본은 세션 모델이 요약을 쓰고 노이즈 턴을 걸러 내며, `--rulebase` 는 모델 없이 규칙만 씀. 여러 세션을 합칠 수 있음. 'lineage'/'대화 export'/'카톡 스타일 html' 시 사용."
 invocation: /lineage
-version: 3.0.5
+version: 3.0.7
 schema_version: 1
 ---
 
@@ -17,6 +17,8 @@ Claude 본문은 **마크다운으로 렌더**(헤딩·리스트·표·코드·
 노이즈(스킬 본문·compaction 요약·조작 명령·에코 교환)는 **기본으로 걸러진다**.
 Secret 자동 redaction. 규칙 단계는 결정론(turn uuid·요약기버전 캐시)이고, 세션 모델의 검토 결정은 캐시해 다음 실행에 다시 쓴다.
 
+> **3.0.6** — 글자 방향을 바꾸는 제어 문자 9자(U+202A~202E, U+2066~2069)는 `--no-markdown` 이어도 `[U+202E]` 처럼 보이는 표지로 넣는다. 화면의 글자 순서가 실제와 달라 보이는 속임수를 막기 위해서다. 방향 표시(LRM, RLM, ALM)는 그대로 둔다.
+
 > **3.0.0 — 기본 흐름이 세션 모델 검토로 바뀌었습니다.**
 > - 규칙이 1차로 정리한 턴을 세션 모델이 다시 검토한다. 요약 줄을 직접 쓰고, 남길 턴과 뺄 턴을 고른다.
 > - 2.x 의 한 번 실행(규칙만, 모델 호출 없음)은 `--rulebase` 다.
@@ -214,6 +216,7 @@ Schema-tolerant 파서: 미지 record type → stderr WARN + 다음 line. `v1`/`
 
 - 캐시 hit(`~/.cache/lineage/<schema>/<sid>/<uuid>-<digest>.md`, 3.0.2 까지 쓴 `.txt` 도 읽음) → 그대로. digest 는 본문+요약기버전
   해시라 **요약기를 고치면 자동 무효화**된다.
+- 캐시는 64KiB 이하의 일반 파일만 읽고 링크는 따르지 않는다. 그 자리의 FIFO, 링크, 큰 파일, 깊게 중첩된 결정 캐시는 읽지 못한 것으로 보고 다시 요약한다(3.0.6).
 - miss → head+tail 추출(도입이 순수 의도문이면 결론절을 끝에서 읽어 승격) + 0600 캐시 쓰기.
 - 요약 저장은 항상 **redact 적용 후**(평문 secret 이 디스크에 남지 않음).