@kaydash9999/banker-plugins 0.18.0 → 0.19.1

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

@@ -9,8 +9,13 @@
  *   node anti-drm.mjs off    --runtime claude|codex
  *   node anti-drm.mjs status
  *   node anti-drm.mjs config --deny <list> --alt <list> [--tsv tab|comma]
+ *   node anti-drm.mjs on --runtime claude|codex --stdin
+ *   node anti-drm.mjs config --stdin
  *
  * <list> is extensions split by commas or spaces, such as ".txt,.pdf".
+ * --stdin reads the settings from standard input instead, one line each:
+ * deny=<list>, alt=<list> and tsv=tab|comma. The skill passes them in a
+ * quoted heredoc, so no value the user chose is ever read by a shell.
  *
  * The settings are one JSON file both runtimes share, ~/.config/banker/anti-drm.json
  * ($BANKER_ANTI_DRM_CONFIG names another): the denied extensions, the
@@ -40,8 +45,8 @@ import {
   mkdirSync,
   openSync,
   readFileSync,
+  readSync,
   realpathSync,
-  statSync,
 } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -50,9 +55,15 @@ import {
   KEEP_CLOSE,
   KEEP_OPEN,
   RUNTIMES,
+  count,
   denied,
+  done,
   hasMarker,
+  lf,
+  LINK_REPLACED,
+  noBom,
   present,
+  refuse,
   stateLines,
   toggleSpec,
   turnOff as toggleOff,
@@ -80,12 +91,7 @@ const DEFAULTS = {
   skillFile: fileURLToPath(new URL("../SKILL.md", import.meta.url)),
 };
 
-const BOM = String.fromCharCode(0xfeff);
 const RUNTIME_NAME = { claude: "Claude Code", codex: "Codex" };
-const done = (message) => ({ ok: true, message });
-const refuse = (message) => ({ ok: false, message });
-const count = (text, needle) => text.split(needle).length - 1;
-const lf = (text) => text.replace(/\r\n/g, "\n");
 // A value from outside, as a message shows it. An extension is printable
 // ASCII, so anything else becomes "?" (a line break or a direction mark cannot
 // forge a line or reorder the text), at most 40 characters stay, and a value
@@ -136,10 +142,12 @@ export function checkConfig({ deny, alt, tsvDelimiter = "tab" }) {
   if (reserved.length > 0) return { error: `anti-drm 이 쓰는 형식이라 금지할 수 없습니다: ${reserved.join(" ")}` };
   const both = d.list.filter((x) => a.list.includes(x));
   if (both.length > 0) return { error: `금지 확장자와 대체 확장자에 함께 있습니다: ${both.join(" ")}` };
-  if (tsvDelimiter !== "tab" && tsvDelimiter !== "comma") {
+  // In any letter case, as the --tsv flag takes it; kept lower-cased.
+  const tsv = typeof tsvDelimiter === "string" ? tsvDelimiter.toLowerCase() : tsvDelimiter;
+  if (tsv !== "tab" && tsv !== "comma") {
     return { error: `TSV 구분자는 tab 이나 comma 여야 합니다: ${shown(tsvDelimiter)}` };
   }
-  return { config: { version: 1, deny: d.list, alt: a.list, tsvDelimiter } };
+  return { config: { version: 1, deny: d.list, alt: a.list, tsvDelimiter: tsv } };
 }
 
 /**
@@ -188,7 +196,7 @@ export function readConfig(file) {
   const { text } = got;
   let raw;
   try {
-    raw = JSON.parse(text.startsWith(BOM) ? text.slice(BOM.length) : text);
+    raw = JSON.parse(noBom(text));
   } catch {
     return { error: "JSON 이 아닙니다" };
   }
@@ -196,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 {
@@ -207,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);
   }
@@ -244,7 +285,7 @@ const OWN_KEYS = ["version", "deny", "alt", "tsvDelimiter"];
 function ownSettings(bytes) {
   try {
     const text = bytes.toString("utf8");
-    const raw = JSON.parse(text.startsWith(BOM) ? text.slice(BOM.length) : text);
+    const raw = JSON.parse(noBom(text));
     const plain = Boolean(raw) && typeof raw === "object" && !Array.isArray(raw);
     return plain && Object.keys(raw).every((k) => OWN_KEYS.includes(k)) && Boolean(checkConfig(raw).config);
   } catch {
@@ -252,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 };
@@ -277,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 ----
@@ -337,13 +385,16 @@ const code = (ext) => `\`${ext}\``;
 export function renderRules(template, config) {
   const map = table(["금지 확장자", "대신 쓸 확장자"], config.deny.map((d) => [code(d), code(replacementFor(d, config.alt))]));
   const alts = table(["확장자", "쓰는 곳"], config.alt.map((a) => [code(a), useOf(a, config)]));
-  return template.replace("{{map}}", () => map).replace("{{alts}}", () => alts);
+  const rules = template.replace("{{map}}", () => map).replace("{{alts}}", () => alts);
+  if (rules.includes("{{")) throw new Error("규칙을 채운 뒤에도 자리 표시({{)가 남았습니다");
+  return rules;
 }
 
 // ---- commands ----
 
 const USAGE =
-  "사용법: anti-drm on | off | status | config [--runtime claude|codex] [--deny <확장자 목록> --alt <확장자 목록> [--tsv tab|comma]]";
+  "사용법: anti-drm on | off | status | config [--runtime claude|codex] [--stdin | --deny <확장자 목록> --alt <확장자 목록> [--tsv tab|comma]]\n" +
+  "--stdin 은 표준 입력이 끝날 때까지 기다립니다.";
 
 // The settings as `status` shows them.
 function configLines(o, found) {
@@ -385,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
@@ -416,8 +488,7 @@ function refresh(o, rules, skip) {
 // The settings from --deny, --alt and --tsv: { config }, { error }, or { usage } when a list is missing.
 function configFromFlags(flags) {
   if (flags.deny === undefined || flags.alt === undefined) return { usage: true };
-  const tsvDelimiter = (flags.tsv ?? "tab").toLowerCase();
-  return checkConfig({ deny: splitList(flags.deny), alt: splitList(flags.alt), tsvDelimiter });
+  return checkConfig({ deny: splitList(flags.deny), alt: splitList(flags.alt), tsvDelimiter: flags.tsv ?? "tab" });
 }
 
 const settingsGiven = (flags) => ["deny", "alt", "tsv"].some((k) => flags[k] !== undefined);
@@ -438,7 +509,7 @@ function applySettings(o, flags, skip) {
 // The rules from the saved settings: { rules, lines, ok } or { refusal }.
 function savedRules(o) {
   const found = readConfig(o.configFile);
-  if (found === null) return { refusal: refuse("설정이 없습니다. 금지 확장자와 대체 확장자를 --deny, --alt 로 함께 주세요.") };
+  if (found === null) return { refusal: refuse("설정이 없습니다. 금지 확장자와 대체 확장자를 --stdin 이나 --deny, --alt 로 함께 주세요.") };
   if (found.error) {
     return { refusal: refuse(`설정 파일이 올바르지 않습니다 (${found.error}): ${where(o.configFile)}. config 로 다시 만드세요.`) };
   }
@@ -481,17 +552,89 @@ export const configure = (opts = {}, flags = {}) => cmdConfig({ ...DEFAULTS, ...
 const FLAG_NAMES = ["runtime", "deny", "alt", "tsv"];
 const COMMANDS = ["on", "off", "status", "config"];
 
-/** { command, runtime, flags, extra } from the command line; each flag takes "x" or "=x". */
+/**
+ * { command, runtime, flags, extra, stdin } from the command line; each value
+ * flag takes "x" or "=x", and --stdin takes nothing.
+ */
 export function parseArgs(argv) {
   const rest = [];
   const flags = {};
+  let stdin = false;
   for (let i = 0; i < argv.length; i++) {
     const m = /^--([a-z]+)(?:=(.*))?$/.exec(argv[i]);
     if (m && FLAG_NAMES.includes(m[1])) flags[m[1]] = m[2] ?? argv[++i] ?? "";
+    else if (argv[i] === "--stdin") stdin = true;
     else rest.push(argv[i]);
   }
   const { runtime, ...settings } = flags;
-  return { command: (rest[0] ?? "status").toLowerCase(), runtime: runtime?.toLowerCase() ?? null, flags: settings, extra: rest.slice(1) };
+  const command = (rest[0] ?? "status").toLowerCase();
+  return { command, runtime: runtime?.toLowerCase() ?? null, flags: settings, extra: rest.slice(1), stdin };
+}
+
+// Lines on standard input that hold the settings: the key, "=", the value.
+const STDIN_LINE = /^(deny|alt|tsv)=(.*)$/;
+const UTF8_STRICT = new TextDecoder("utf-8", { fatal: true });
+
+/**
+ * The settings on standard input as flags: { flags } or { error }. At most
+ * 64 KiB of UTF-8; a leading byte order mark and CRLF line ends are fine;
+ * each of deny=, alt= and tsv= once; blank lines are skipped.
+ */
+export function stdinSettings(bytes) {
+  if (bytes.length > MAX_BYTES) return { error: "표준 입력이 64KiB 보다 큽니다" };
+  let text;
+  try {
+    text = UTF8_STRICT.decode(bytes);
+  } catch {
+    return { error: "표준 입력이 UTF-8 이 아닙니다" };
+  }
+  const flags = {};
+  for (const line of noBom(text).split(/\r?\n/)) {
+    if (line.trim() === "") continue;
+    const m = STDIN_LINE.exec(line);
+    if (!m || flags[m[1]] !== undefined) return { error: `표준 입력의 설정 줄을 읽을 수 없습니다: ${shown(line)}` };
+    flags[m[1]] = m[2].trim();
+  }
+  return { flags };
+}
+
+const PAUSE = new Int32Array(new SharedArrayBuffer(4));
+
+// Standard input, read up to cap bytes and one more: { bytes } at the end of input, or { tooBig: true } as soon as
+// more than cap came. A pipe left non-blocking answers EAGAIN until data comes: wait a little and read again.
+function readCapped(fd, cap) {
+  const chunks = [];
+  const buf = Buffer.alloc(64 * 1024);
+  let total = 0;
+  for (;;) {
+    const n = readSome(fd, buf);
+    if (n === 0) return { bytes: Buffer.concat(chunks) };
+    total += n;
+    if (total > cap) return { tooBig: true };
+    chunks.push(Buffer.from(buf.subarray(0, n)));
+  }
+}
+
+// One read into buf: how many bytes came, 0 at the end of input (Windows may say EOF instead).
+function readSome(fd, buf) {
+  for (;;) {
+    try {
+      return readSync(fd, buf, 0, buf.length, null);
+    } catch (e) {
+      if (e.code === "EOF") return 0;
+      if (e.code !== "EAGAIN") throw e;
+      Atomics.wait(PAUSE, 0, 0, 10);
+    }
+  }
+}
+
+// The settings standard input held: an error when it was too big or unreadable, or held no settings line, which
+// on and config both refuse rather than reach for the saved settings.
+function stdinFrom(got) {
+  if (got.tooBig) return { error: "표준 입력이 64KiB 보다 큽니다" };
+  const read = stdinSettings(got.bytes);
+  if (read.error || Object.keys(read.flags).length > 0) return read;
+  return { error: "표준 입력에 설정 줄이 없습니다" };
 }
 
 // Settings flags go only with on and config, and config needs both lists.
@@ -501,9 +644,11 @@ function settingsUsage(command, flags) {
 }
 
 // Why the command line cannot run as given, or "" when it can.
-function usageError({ command, runtime, flags, extra }) {
+function usageError({ command, runtime, flags, extra, stdin }) {
   if (extra.length > 0 || !COMMANDS.includes(command)) return USAGE;
   if (runtime !== null && !RUNTIMES.includes(runtime)) return USAGE;
+  // --stdin brings all the settings, so it goes with on and config only and never with a settings flag.
+  if (stdin) return (command === "on" || command === "config") && Object.keys(flags).length === 0 ? "" : USAGE;
   return settingsUsage(command, flags);
 }
 
@@ -517,25 +662,32 @@ function run(command, runtime, flags) {
   return command === "on" ? cmdOn(o, runtime, flags) : cmdOff(o, runtime);
 }
 
-function main(argv, env = process.env) {
+// Writes a message line and gives back the exit status.
+const say = (text, code) => {
+  process.stdout.write(`${text}\n`);
+  return code;
+};
+
+// Whether a command acts on one runtime and so needs to know which.
+const needsRuntime = (command) => command === "on" || command === "off";
+// The settings flags: from standard input with --stdin, else from the command line.
+const settingsOf = (args, input) => (args.stdin ? stdinFrom(input()) : { flags: args.flags });
+
+function main(argv, env = process.env, input = () => readCapped(0, MAX_BYTES)) {
   const args = parseArgs(argv);
   const why = usageError(args);
-  if (why) {
-    process.stdout.write(`${why}\n`);
-    return 1;
-  }
+  if (why) return say(why, 1);
   const runtime = runtimeOf(args.runtime, env);
-  if ((args.command === "on" || args.command === "off") && !RUNTIMES.includes(runtime)) {
-    process.stdout.write(`런타임을 정할 수 없습니다. --runtime claude 또는 --runtime codex 를 붙이세요.\n${USAGE}\n`);
-    return 1;
+  if (needsRuntime(args.command) && !RUNTIMES.includes(runtime)) {
+    return say(`런타임을 정할 수 없습니다. --runtime claude 또는 --runtime codex 를 붙이세요.\n${USAGE}`, 1);
   }
   try {
-    const { ok, message } = run(args.command, runtime, args.flags);
-    process.stdout.write(`${message}\n`);
-    return ok ? 0 : 1;
+    const got = settingsOf(args, input);
+    if (got.error) return say(`${got.error}\n${USAGE}`, 1);
+    const { ok, message } = run(args.command, runtime, got.flags);
+    return say(message, ok ? 0 : 1);
   } catch (e) {
-    process.stdout.write(`예기치 못한 오류로 중단했습니다: ${where(e.message)}\nstatus 로 상태를 확인하세요.\n`);
-    return 2;
+    return say(`예기치 못한 오류로 중단했습니다: ${where(e.message)}\nstatus 로 상태를 확인하세요.`, 2);
   }
 }