@kaydash9999/banker-plugins 0.20.5 → 0.22.0

package/hooks/telemetry-count-codex.mjs

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+/*
+ * banker 텔레메트리 count 훅 (Codex Stop) - Codex 세션이 banker 스킬을 쓴 턴이 끝날 때 로컬 usage-log 에
+ * `banker:<name>\t<hour>` 한 줄을 남긴다. Claude Code 의 telemetry-count(.mjs, -skill.mjs)에 해당한다.
+ *
+ * Codex 0.144.5 실측으로 스킬이 쓰이는 길은 둘이다.
+ *  - 모델이 고른 스킬: 도구 호출로 SKILL.md 를 읽는다(Bash `cat <CODEX_HOME>/skills/banker-<name>/SKILL.md`).
+ *  - 사용자가 $banker-<name> 으로 부른 스킬: Codex 가 도구 호출 없이 `<skill>\n<name>..</name>\n<path>..</path>` 로
+ *    시작하는 사용자 역할 메시지로 본문을 넣는다. 이때는 머리의 <path> 줄만 보고 본문은 보지 않는다.
+ * Codex 플러그인으로 설치한 banker(codex plugin add, $banker:<name>)는 SKILL.md 가
+ * `<CODEX_HOME>/plugins/cache/<마켓플레이스>/banker/<판>/{skills,codex/skills,codex/command-skills}/<name>/` 에 있다.
+ * 두 길의 경로를 모두 센다.
+ * 도구 호출마다 도는 PreToolUse 대신 턴마다 한 번 도는 Stop 에서, 훅 입력의 transcript_path(rollout) 중
+ * 이번 턴(task_started 의 turn_id 뒤)의 두 기록에 `skills/banker-<name>/SKILL.md` 가 있으면 센다. 나눠 읽어도 한 번이고, Stop 이 한 턴에 두 번 와도
+ * 최근 턴 키(configDir 의 codex-count-turns)로 한 번만 센다. 기록은 끝에서부터 32 MB 까지만 읽는다.
+ *
+ * fail-closed 규약은 Claude 쪽과 같다(telemetry-count-codex.test.mjs 가 검증):
+ *  - countingActive() 가 아니면 로컬 쓰기조차 하지 않는다.
+ *  - 이름은 SKILL_NAME_RE 전체 일치이고 이 Codex 에 설치된 banker 스킬(<CODEX_HOME>/skills/banker-<name>/SKILL.md, 또는
+ *    기록의 경로 그대로 <CODEX_HOME>/plugins/cache/ 아래에 있는 플러그인의 SKILL.md)만.
+ *    모델이 `echo skills/banker-<아무 글>/SKILL.md` 를 돌려 체크인의 이름 칸으로 글을 내보내지 못하게 한다. 턴 키 파일은 일반 파일만 읽고, 링크 자리에 쓰지 않는다.
+ *  - 어떤 오류도 삼키고 항상 exit 0. 도구 호출을 절대 막지 않는다. 표준 출력은 비운다.
+ */
+import { closeSync, constants, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { codexHomeOf, pluginRoutes } from '../bin/lib/codex-routes.mjs';
+import { appendUsageLog, CODEX_SHAPE_MISS_PATH, configDir, countingActive, randomHex, readRegular, recordUsedSkill, SKILL_NAME_RE, writeByRename } from '../bin/lib/telemetry-config.mjs';
+
+export { codexHomeOf };
+
+const SKILL_PATH_RE = /skills[\\/]+banker-([a-z0-9_-]{1,64})[\\/]+SKILL\.md/g;
+// 플러그인 길: plugins/cache/<마켓플레이스>/banker/<판>/<스킬 폴더>/<name>/SKILL.md. 1 마켓플레이스, 2 판, 3 스킬 폴더, 4 이름.
+// 대소문자를 가리지 않는 파일 시스템에서 `FRONT-QA` 같은 변형이 다른 이름으로 세어지지 않게 i 를 두지 않는다.
+const PLUGIN_PATH_RE = /plugins[\\/]+cache[\\/]+([A-Za-z0-9._-]{1,80})[\\/]+banker[\\/]+([A-Za-z0-9._-]{1,80})[\\/]+(skills|codex[\\/]+skills|codex[\\/]+command-skills)[\\/]+([a-z0-9_-]{1,64})[\\/]+SKILL\.md/g;
+const KEEP_TURNS = 100;
+export const TURNS_FILE = () => join(configDir(), 'codex-count-turns');
+
+function readStdin() {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolvePromise(data));
+    process.stdin.on('error', rejectPromise);
+  });
+}
+
+const MAX_READ = 32 << 20;
+const FIRST_READ = 1 << 20;
+
+// 글에 나오는 banker 스킬, 중복 없이. npm 길은 'banker:<name>', 플러그인 길은 'banker:<name>\t<홈 기준 SKILL.md 상대 경로>'
+// (설치 확인에 쓰고, 셀 때는 이름만 남긴다).
+export function namesIn(text, names = new Set()) {
+  for (const m of text.matchAll(SKILL_PATH_RE)) {
+    const name = `banker:${m[1]}`;
+    if (SKILL_NAME_RE.test(name)) names.add(name);
+  }
+  for (const m of text.matchAll(PLUGIN_PATH_RE)) {
+    const name = `banker:${m[4]}`;
+    if (m[1] === '.' || m[1] === '..' || m[2] === '.' || m[2] === '..' || !SKILL_NAME_RE.test(name)) continue;
+    names.add(`${name}\t${['plugins', 'cache', m[1], 'banker', m[2], ...m[3].split(/[\\/]+/), m[4], 'SKILL.md'].join('/')}`);
+  }
+  return names;
+}
+
+// rollout 끝에서 max 바이트의 줄과, 파일 전체를 읽었는지. 일반 파일만: 기다리지 않게 O_NONBLOCK 으로 열고 연 것을 fstat 으로 본다. 앞에서 잘린 첫 줄은 버린다.
+function tailLines(file, max) {
+  const fd = openSync(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+  try {
+    if (!fstatSync(fd).isFile()) return { lines: [], whole: true };
+    const size = fstatSync(fd).size;
+    const start = Math.max(0, size - max);
+    const buf = Buffer.alloc(size - start);
+    readSync(fd, buf, 0, buf.length, start);
+    const lines = buf.toString('utf8').split('\n');
+    if (start > 0) lines.shift();
+    return { lines, whole: start === 0 };
+  } finally {
+    closeSync(fd);
+  }
+}
+
+const isCall = (rec) => rec?.type === 'response_item' && /_call$/.test(String(rec?.payload?.type ?? ''));
+const SKILL_HEAD_RE = /^<skill>\n<name>[^\n<]{1,80}<\/name>\n<path>([^\n<]{1,4096})<\/path>\n/;
+
+// $banker-<name> 으로 부른 스킬을 Codex 가 넣은 메시지의 <path>. 그 밖의 기록은 ''.
+function injectedPath(rec) {
+  const p = rec?.payload;
+  if (rec?.type !== 'response_item' || p?.type !== 'message' || p.role !== 'user' || !Array.isArray(p.content)) return '';
+  const text = p.content[0]?.text;
+  return typeof text === 'string' ? (SKILL_HEAD_RE.exec(text)?.[1] ?? '') : '';
+}
+
+// 이번 턴(turn_id 의 task_started 뒤)의 도구 호출과 넣은 스킬 머리에서 읽은 banker 스킬 이름. 사용자 글과 모델 답은 세지 않는다.
+// 턴 시작은 대개 기록 끝 가까이에 있으므로 끝 1 MB 부터 읽고, 못 찾으면 두 배씩 max 까지 넓힌다.
+// 기록 전체를 읽고도 task_started 가 하나도 없으면 null: Codex 는 턴마다 task_started 를 쓰므로 기록 형식이 바뀐 것이다.
+// 이 턴의 것만 없을 때(시작이 기록되지 않는 턴)는 형식 변경으로 보지 않는다.
+export function turnSkills(file, turnId, max = MAX_READ) {
+  for (let size = Math.min(FIRST_READ, max); ; size = Math.min(size * 2, max)) {
+    const { lines, whole } = tailLines(file, size);
+    const start = turnStart(lines, turnId);
+    if (start >= 0) return skillsAfter(lines, start);
+    if (whole) return lines.some((l) => l.trim()) && !lines.some((l) => l.includes('"task_started"')) ? null : [];
+    if (size >= max) return [];
+  }
+}
+
+// rollout 첫 기록(session_meta)의 Codex 판. Codex 기록이 아니면 ''.
+export function codexVersionOf(file) {
+  try {
+    const fd = openSync(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+    try {
+      if (!fstatSync(fd).isFile()) return '';
+      const buf = Buffer.alloc(Math.min(fstatSync(fd).size, 8 << 20)); // session_meta 는 지침을 품어 클 수 있다
+      readSync(fd, buf, 0, buf.length, 0);
+      const rec = JSON.parse(buf.toString('utf8').split('\n')[0]);
+      return rec?.type === 'session_meta' ? String(rec.payload?.cli_version ?? '?').slice(0, 40) : '';
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return '';
+  }
+}
+
+// 이 Codex 판의 기록을 읽지 못했음을 남긴다(같은 판은 한 번만). 다음 세션 시작 때 update-notify --codex 가 알린다.
+function noteShapeMiss(file) {
+  const version = codexVersionOf(file);
+  if (!version) return;
+  let prev = {};
+  try { prev = JSON.parse(readRegular(CODEX_SHAPE_MISS_PATH)); } catch { /* 없음 */ }
+  if (prev?.version !== version) writeByRename(CODEX_SHAPE_MISS_PATH, JSON.stringify({ version, notified: false }));
+}
+
+function turnStart(lines, turnId) {
+  let start = lines.length - 1;
+  while (start >= 0 && !(lines[start].includes('"task_started"') && lines[start].includes(turnId))) start--;
+  return start;
+}
+
+function skillsAfter(lines, start) {
+  const names = new Set();
+  for (const line of lines.slice(start + 1)) {
+    if (!line.includes('SKILL.md')) continue;
+    let rec;
+    try { rec = JSON.parse(line); } catch { continue; }
+    if (isCall(rec)) namesIn(JSON.stringify(rec.payload), names);
+    else namesIn(injectedPath(rec), names);
+  }
+  return [...names];
+}
+
+const ID_RE = /^[A-Za-z0-9._-]{1,80}$/;
+
+// 이 턴의 키. session_id 와 turn_id 가 모양이 맞을 때만(파일 한 줄 형식을 깨지 않게).
+export function turnKey(payload) {
+  const s = payload?.session_id;
+  const t = payload?.turn_id;
+  return typeof s === 'string' && typeof t === 'string' && ID_RE.test(s) && ID_RE.test(t) ? `${s}:${t}` : null;
+}
+
+function readTurns() {
+  try {
+    return readRegular(TURNS_FILE()).split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// 링크나 일반 파일이 아닌 자리에는 쓰지 않는다. 새 파일을 만들어 바꿔 넣는다.
+function writeTurns(lines) {
+  const file = TURNS_FILE();
+  try {
+    if (!lstatSync(file).isFile()) return;
+  } catch (e) {
+    if (e?.code !== 'ENOENT') return;
+  }
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(tmp, `${lines.slice(-KEEP_TURNS).join('\n')}\n`, { flag: 'wx', mode: 0o600 });
+    renameSync(tmp, file);
+  } catch {
+    rmSync(tmp, { force: true });
+  }
+}
+
+// 이 Codex 에 설치된 banker 스킬인지. 플러그인 길은 그 홈의 config.toml 에 켜져 있는 banker@<마켓플레이스> 의 것이고,
+// 기록의 경로 그대로 plugins/cache 아래에 있어야 한다(지운 플러그인이 남긴 폴더나 다른 마켓플레이스의 banker 는 세지 않음).
+export function installed(entry, home, routes = pluginRoutes(home)) {
+  const [name, rel] = entry.split('\t');
+  if (rel) return routes.includes(`banker@${rel.split('/')[2]}`) && existsSync(join(home, ...rel.split('/')));
+  return existsSync(join(home, 'skills', `banker-${name.slice('banker:'.length)}`, 'SKILL.md'));
+}
+
+// 이 턴에 아직 세지 않은 이름만 센다.
+export function countOnce(payload) {
+  const key = turnKey(payload);
+  const file = typeof payload?.transcript_path === 'string' ? payload.transcript_path : '';
+  const home = codexHomeOf(file);
+  const got = key && file ? turnSkills(file, payload.turn_id) : [];
+  if (got === null) {
+    noteShapeMiss(file);
+    return [];
+  }
+  const routes = got.some((n) => n.includes('\t')) ? pluginRoutes(home) : []; // config.toml 은 한 번만 읽는다
+  const names = [...new Set(got.filter((n) => installed(n, home, routes)).map((n) => n.split('\t')[0]))];
+  if (!names.length) return [];
+  return withTurnsLock(() => {
+    const seen = readTurns();
+    const fresh = names.filter((n) => !seen.includes(`${key}\t${n}`));
+    if (!fresh.length) return [];
+    for (const n of fresh) {
+      appendUsageLog(n);
+      recordUsedSkill(n);
+    }
+    writeTurns([...seen, ...fresh.map((n) => `${key}\t${n}`)]);
+    return fresh;
+  });
+}
+
+// npm 길과 플러그인 길의 Stop 훅이 같은 턴에 함께 돌면 둘 다 턴 키를 읽고 셀 수 있다. 턴 키를 읽고 쓰는 동안
+// codex-count-turns.lock 폴더를 잡는다(mkdir 은 이미 있으면 실패하고 링크를 따라가지 않아 둘 중 하나만 잡음).
+// 2초 안에 못 잡으면 잡은 쪽이 이 턴을 세므로 세지 않는다. 잠금은 몇 ms 만 잡으므로 훅 시간 제한(5초)보다 조금 긴
+// 6초가 지난 잠금은 죽은 훅의 것이다: 고유 이름으로 옮겨(rename 은 하나만 성공) 지운 뒤 다시 잡는다. 옮긴 것이
+// 새것이면(그사이 다른 훅이 넘겨받아 잡은 것) 그 훅에 이 턴을 맡기고 물러난다.
+// configDir 을 만들 수 없거나 잠금 폴더를 만들 수 없는 다른 오류면 잠금 없이 전처럼 센다.
+const LOCK_WAIT_MS = 2000;
+const LOCK_STALE_MS = 6000;
+export function withTurnsLock(fn, { wait = LOCK_WAIT_MS } = {}) {
+  const lock = `${TURNS_FILE()}.lock`;
+  try {
+    mkdirSync(configDir(), { recursive: true });
+  } catch {
+    return fn();
+  }
+  const end = Date.now() + wait;
+  const token = `${process.pid}-${randomHex()}`;
+  for (;;) {
+    try {
+      mkdirSync(lock);
+      try { writeFileSync(join(lock, 'owner'), token, { flag: 'wx' }); } catch { /* 표시 없이도 잠금은 잡았다 */ }
+      break;
+    } catch (e) {
+      if (e?.code !== 'EEXIST') return fn();
+    }
+    try {
+      if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) {
+        const old = `${lock}.stale-${process.pid}-${randomHex()}`;
+        renameSync(lock, old);
+        // 본 것과 옮긴 것 사이에 다른 훅이 낡은 잠금을 치우고 새로 잡았을 수 있다. 옮긴 것이 새것이면 그 훅이 이
+        // 턴을 세는 중이므로 세지 않고 물러난다. 돌려놓지 않는다(그사이 세 번째 훅이 잡은 잠금을 덮을 수 있다).
+        // 옮긴 폴더는 다음에 잠금을 잡은 훅이 치운다.
+        if (Date.now() - statSync(old).mtimeMs <= LOCK_STALE_MS) return [];
+        rmSync(old, { recursive: true, force: true });
+        continue;
+      }
+    } catch { /* 방금 풀렸거나 다른 훅이 먼저 치움: 다시 잡아 본다 */ }
+    if (Date.now() >= end) return [];
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+  }
+  try {
+    dropMovedLocks(lock);
+    return fn();
+  } finally {
+    releaseLock(lock, token);
+  }
+}
+
+// 잠금 폴더 안의 주인 표시(owner)가 이 훅의 것일 때만 놓는다. 넘겨받던 훅이 이 잠금을 옮기고 다른 훅이 그 이름을
+// 새로 잡았으면, 그 훅의 잠금은 지우지 않는다.
+function releaseLock(lock, token) {
+  try {
+    if (readFileSync(join(lock, 'owner'), 'utf8') !== token) return;
+    rmSync(join(lock, 'owner'), { force: true });
+    rmdirSync(lock);
+  } catch { /* 없거나 남의 것 */ }
+}
+
+// 넘겨받다 물러난 훅이 남긴 옮긴 잠금(<잠금>.stale-*) 가운데 오래된 것을 지운다.
+function dropMovedLocks(lock) {
+  const dir = configDir();
+  const prefix = `${lock.slice(dir.length + 1)}.stale-`;
+  try {
+    for (const name of readdirSync(dir)) {
+      if (!name.startsWith(prefix)) continue;
+      try {
+        if (Date.now() - statSync(join(dir, name)).mtimeMs > LOCK_STALE_MS) rmSync(join(dir, name), { recursive: true, force: true });
+      } catch { /* 다른 훅이 먼저 지움 */ }
+    }
+  } catch { /* 다음에 */ }
+}
+
+async function main() {
+  let payload;
+  try {
+    payload = JSON.parse(await readStdin());
+  } catch {
+    return;
+  }
+  if (!countingActive()) return;
+  countOnce(payload);
+}
+
+if (process.argv[1] && /telemetry-count-codex\.mjs$/.test(process.argv[1])) {
+  main()
+    .catch(() => {})
+    .finally(() => process.exit(0));
+}

package/hooks/update-notify.mjs

@@ -14,7 +14,7 @@
  *  - 어떤 오류도 삼키고 항상 exit 0. 세션을 절대 막지 않는다. 비TTY 안전.
  */
 import { spawn } from 'node:child_process';
-import { realpathSync } from 'node:fs';
+import { mkdirSync, readdirSync, realpathSync, renameSync, rmdirSync, rmSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -22,11 +22,19 @@ import {
   UPDATE_CHECK_PATH, updateCheckDue,
   noUpdateCheck, countingActive, endpoint,
   installedVersion, compareVersions, writeUpdateCache, readUsedSkills, readRegular,
+  CODEX_SHAPE_MISS_PATH, writeByRename, configDir, randomHex,
 } from '../bin/lib/telemetry-config.mjs';
+import { codexHomeOf, DEFAULT_MARKETPLACE, dualInstallNote, pluginRootInfo } from '../bin/lib/codex-routes.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 // 업데이트 안내에 쓰는 npm 패키지 이름(고지 문구·이모지/em-dash 없음).
 const NPM_PKG = '@kaydash9999/banker-plugins';
+// Codex 의 훅은 --codex 를 받는다. 그중 Codex 플러그인(codex/hooks.json)의 훅은 --plugin 도 받는다. npm 길의 훅은
+// banker setup --codex 가 <CODEX_HOME>/hooks.json 에 넣는다.
+const CODEX = process.argv.includes('--codex');
+const PLUGIN = CODEX && process.argv.includes('--plugin');
+// Codex 에서 banker 스킬을 부르는 이름: npm 길은 $banker-<이름>, 플러그인은 $banker:<이름>.
+const skillCall = (name) => (PLUGIN ? `$banker:${name}` : `$banker-${name}`);
 
 function readStdin() {
   return new Promise((resolvePromise, rejectPromise) => {
@@ -65,7 +73,14 @@ function personalizedSkills(cached) {
 // (기존 동작). banker: 접두는 떼서 짧게. 이모지/em-dash 없음(사용자 가시 채널).
 function buildMessage(latest, installed, cached) {
   const head = `banker ${latest} 사용 가능 (현재 ${installed}).`;
-  const tail = `업데이트: /banker:update-banker 또는 npm i -g ${NPM_PKG}`;
+  // Codex 에는 /banker: 명령이 없어 스킬 이름과 그 설치 길의 갱신 명령을 안내한다. 플러그인은 마켓플레이스를 올리면
+  // 설치된 플러그인도 새 판으로 바뀌고, Codex 는 세션을 시작할 때 git 마켓플레이스를 스스로 올린다(0.144.5 실측).
+  const mkt = pluginRootInfo(process.env.PLUGIN_ROOT)?.marketplace ?? DEFAULT_MARKETPLACE;
+  const tail = PLUGIN
+    ? `업데이트: Codex 가 세션을 시작할 때 마켓플레이스와 함께 올립니다. 바로 올리려면 codex plugin marketplace upgrade ${mkt} 뒤 Codex 를 다시 여십시오`
+    : CODEX
+      ? `업데이트: ${skillCall('update-banker')} 또는 npm i -g ${NPM_PKG} 뒤 banker setup --codex`
+      : `업데이트: /banker:update-banker 또는 npm i -g ${NPM_PKG}`;
   const hits = personalizedSkills(cached);
   if (hits.length) {
     const names = hits.slice(0, 5).map((s) => s.replace(/^banker:/, '')).join(', ');
@@ -79,14 +94,26 @@ function buildMessage(latest, installed, cached) {
 // compareVersions null(미확정·malformed)·구버전·동일 → 무고지. 고지 후 notified 를 기록해 재고지를 막는다.
 // 고지 문구는 buildMessage 가 만든다(로컬 changedSkills∩써본스킬이 있으면 개인화, 없으면 일반).
 function maybeNotify(cached) {
-  if (!cached) return;
+  if (!cached) return '';
   const installed = installedVersion();
   const cmp = compareVersions(cached.latest, installed);
-  if (cmp === null || cmp <= 0) return;          // 미확정/구/동일 → 무고지
-  if (cached.notified === cached.latest) return;  // 이미 고지한 버전 → dedupe
-  const msg = buildMessage(cached.latest, installed, cached);
-  process.stdout.write(JSON.stringify({ systemMessage: msg }));
+  if (cmp === null || cmp <= 0) return '';          // 미확정/구/동일 → 무고지
+  if (cached.notified === cached.latest) return '';  // 이미 고지한 버전 → dedupe
   writeUpdateCache({ notified: cached.latest }); // 형제 필드(latest/checkedAt/changedSkills) 보존하며 notified 만 병합.
+  return buildMessage(cached.latest, installed, cached);
+}
+
+// Codex: 사용량 카운팅 훅이 이 Codex 판의 기록 형식을 읽지 못했으면(codex-shape-miss.json) 한 번 알린다.
+// 카운트가 조용히 0 으로 남지 않게 하려는 것이다. 업데이트 확인을 끈 사용자에게도 알린다.
+export function shapeMissNotice() {
+  try {
+    const miss = JSON.parse(readRegular(CODEX_SHAPE_MISS_PATH));
+    if (!miss || typeof miss.version !== 'string' || miss.notified) return '';
+    writeByRename(CODEX_SHAPE_MISS_PATH, JSON.stringify({ version: miss.version, notified: true }));
+    return `banker 사용량 카운팅이 Codex ${miss.version.slice(0, 40)} 의 기록 형식을 읽지 못함. ${skillCall('update-banker')} 로 banker 를 업데이트하고, 그래도 같으면 알려 주십시오`;
+  } catch {
+    return '';
+  }
 }
 
 // 갱신 fetcher 절대경로 결정: count-default-on 활성(countingActive) + 엔드포인트 설정 시
@@ -106,15 +133,79 @@ function spawnFetcher() {
   }
 }
 
-async function main() {
-  // SessionStart payload 를 드레인(파이프 위생). 내용을 쓰지 않으므로 파싱 실패해도 무해.
-  try { await readStdin(); } catch { /* stdin 없음/오류 무해 */ }
+// Codex: npm 길과 플러그인 길이 함께 있으면 알린다. 세션마다 한 번만 알리는 일은 claimSession 이 맡는다.
+export function dualNotice(payload, env = process.env) {
+  try {
+    const cwd = typeof payload?.cwd === 'string' ? payload.cwd : '';
+    return dualInstallNote(codexHomeOf(payload?.transcript_path, env), cwd);
+  } catch {
+    return '';
+  }
+}
 
-  if (noUpdateCheck()) return; // opt-out - 무동작.
+// Codex: 두 길의 SessionStart 훅이 모두 신뢰돼 같은 세션에서 함께 돌면 같은 알림이 두 번 나간다. 세션 id 이름의
+// 폴더를 configDir 의 codex-sessions 에 만든 훅만 알린다. mkdir 은 이미 있으면 실패하고 링크를 따라가지 않아 둘이
+// 동시에 와도 하나만 만든다. 함께 도는 훅은 훅 시간 제한(5초) 안에 오므로, 30초 넘게 지난 폴더는 이어 연 세션(resume)
+// 의 것이다: 고유 이름으로 옮겨(rename 은 하나만 성공) 다시 만든 훅이 알린다. 옮긴 것이 새것이면(그사이 짝 훅이
+// 넘겨받아 만든 것) 알리지 않는다. 세션 id 가 없거나 폴더를 만들 수 없으면
+// 전처럼 알린다. 이틀 지난 폴더와 예전 판의 codex-dual-notified 는 지운다.
+const SESSION_RE = /^[A-Za-z0-9._-]{1,80}$/;
+const CLAIM_KEEP_MS = 2 * 24 * 60 * 60 * 1000;
+const CLAIM_TWIN_MS = 30 * 1000;
+export function claimSession(payload, now = Date.now()) {
+  const sid = typeof payload?.session_id === 'string' && SESSION_RE.test(payload.session_id) && !/^\.+$/.test(payload.session_id) ? payload.session_id : '';
+  if (!sid) return true;
+  const dir = join(configDir(), 'codex-sessions');
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch {
+    return true; // 폴더 자리에 다른 것이 있음: 중복을 막지 못해도 알림은 낸다
+  }
+  const mine = join(dir, sid);
+  try {
+    mkdirSync(mine);
+  } catch (e) {
+    if (e?.code !== 'EEXIST') return true;
+    try {
+      if (now - statSync(mine).mtimeMs < CLAIM_TWIN_MS) return false; // 같은 세션의 다른 길 훅이 방금 알렸다
+      const old = `${mine}.old-${process.pid}-${randomHex()}`;
+      renameSync(mine, old);
+      if (now - statSync(old).mtimeMs < CLAIM_TWIN_MS) {
+        // 본 것과 옮긴 것 사이에 짝 훅이 넘겨받아 새로 만든 폴더였다: 그 훅이 알리므로 알리지 않는다. 돌려놓지 않고
+        // (그사이 다른 훅이 만든 폴더를 덮을 수 있다) 옮긴 폴더는 이틀 뒤 정리에서 지운다.
+        return false;
+      }
+      rmdirSync(old);
+      mkdirSync(mine);
+    } catch {
+      return false; // 함께 온 다른 훅이 먼저 옮기거나 만들었다
+    }
+  }
+  try {
+    rmSync(join(configDir(), 'codex-dual-notified'), { force: true });
+    for (const d of readdirSync(dir)) {
+      try {
+        if (d !== sid && now - statSync(join(dir, d)).mtimeMs > CLAIM_KEEP_MS) rmdirSync(join(dir, d));
+      } catch { /* 다른 훅이 먼저 지움 */ }
+    }
+  } catch { /* 정리는 다음 세션에 */ }
+  return true;
+}
 
-  const cached = readCache(); // 포그라운드는 캐시 읽기만(네트워크 없음).
-  maybeNotify(cached);
-  if (updateCheckDue(cached)) spawnFetcher(); // 갱신은 백그라운드로 위임. 실패한 시도(triedAt)에서도 하루를 쉰다.
+async function main() {
+  // SessionStart payload. Codex 는 두 길 알림에 transcript_path, session_id 를 쓴다. 파싱 실패해도 무해.
+  let payload = null;
+  try { payload = JSON.parse(await readStdin()); } catch { /* stdin 없음/오류 무해 */ }
+
+  if (CODEX && !claimSession(payload)) return; // 같은 세션의 다른 길 훅이 이미 알렸다
+  const notes = CODEX ? [shapeMissNotice(), dualNotice(payload)] : [];
+  if (!noUpdateCheck()) { // opt-out 이면 업데이트 확인만 무동작.
+    const cached = readCache(); // 포그라운드는 캐시 읽기만(네트워크 없음).
+    notes.unshift(maybeNotify(cached));
+    if (updateCheckDue(cached)) spawnFetcher(); // 갱신은 백그라운드로 위임. 실패한 시도(triedAt)에서도 하루를 쉰다.
+  }
+  const msg = notes.filter(Boolean).join('\n');
+  if (msg) process.stdout.write(JSON.stringify({ systemMessage: msg }));
 }
 
 // 직접 실행(훅)일 때만 main() 을 돌린다. import(테스트)시엔 chooseFetcher 만 노출하고 main 은 미실행.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaydash9999/banker-plugins",
-  "version": "0.20.5",
+  "version": "0.22.0",
   "description": "banker — Claude Code + Codex CLI plugin (QA, audit, docs, architecture, wiki skills). Install via Claude Code marketplace, or `npm i -g @kaydash9999/banker-plugins` then `banker setup`.",
   "bin": {
     "banker": "bin/banker.js"

package/skills/3d-intro-build/references/verify-intro.mjs

@@ -304,11 +304,25 @@ async function pixels(context, png) {
   return { width: img.width, height: img.height, data: Uint8ClampedArray.from(img.data) };
 }
 
+// Chromium now and then answers a screenshot with "Unable to capture screenshot" while it is busy (seen once in three
+// full runs on a loaded Linux box). That error alone is tried again, up to three times with a short wait; any other
+// error is the page's and is thrown at once.
+export async function screenshot(page, opts, { tries = 3, waitMs = 150 } = {}) {
+  for (let n = 1; ; n++) {
+    try {
+      return await page.screenshot(opts);
+    } catch (e) {
+      if (n >= tries || !/Unable to capture screenshot/i.test(String(e?.message))) throw e;
+      await new Promise((r) => setTimeout(r, waitMs * n));
+    }
+  }
+}
+
 async function lineContrast(page, i, panel) {
   const clip = { x: Math.max(0, Math.floor(panel.x)), y: Math.max(0, Math.floor(panel.y)), width: Math.ceil(panel.width), height: Math.ceil(panel.height) };
   const lines = await page.evaluate(hideTextLines, { i, parts: TEXT_PARTS });
   await page.waitForTimeout(80);
-  const png = await page.screenshot({ type: 'png', clip });
+  const png = await screenshot(page, { type: 'png', clip });
   await page.evaluate(showText, { i, parts: TEXT_PARTS });
   const img = await pixels(page.context(), png);
   return lines.map((l) => {

package/skills/anti-drm/SKILL.md

@@ -30,7 +30,7 @@ argument-hint: "on | off | status | config"
    | 런타임 | `--runtime` | 스킬 디렉터리 |
    |---|---|---|
    | Claude Code | `claude` | 스킬 맨 위 "Base directory for this skill:" 경로 |
-   | Codex | `codex` | `~/.codex/skills/banker-anti-drm/` 의 절대경로. 프로젝트 범위 설치면 `./.codex/skills/banker-anti-drm/` |
+   | Codex | `codex` | Codex 스킬 목록이 보이는 이 SKILL.md 경로(file)의 폴더. npm 설치는 `~/.codex/skills/banker-anti-drm/`(프로젝트 범위 설치면 `./.codex/skills/banker-anti-drm/`), 플러그인 설치(`codex plugin add`)는 `~/.codex/plugins/cache/<마켓플레이스>/banker/<판>/skills/anti-drm/`. 절대경로로 씀 |
 
 3. 아래 인자별 절차를 따름
 

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

@@ -186,7 +186,7 @@ export function writeFresh(file, data, mode = 0o644) {
   const tmp = `${file}.${process.pid}.tmp`;
   rmSync(tmp, { force: true });
   try {
-    writeFileSync(tmp, data, { flag: "wx", mode });
+    writeNew(tmp, data, mode);
     renameOver(tmp, file);
   } catch (e) {
     rmSync(tmp, { force: true });
@@ -194,6 +194,48 @@ export function writeFresh(file, data, mode = 0o644) {
   }
 }
 
+// Opens a file that is not there yet, as "wx" does, and makes sure the name is the file made. macOS and Linux refuse
+// any name that is there, a link to nothing among them (EEXIST). Windows follows a link to nothing and makes the file
+// it leads to: then that file is removed again when it is still the empty one made, and the open is refused with
+// EEXIST as elsewhere. A look before the open catches such a link; this catches one planted between the look and the
+// open. A look that fails after the open leaves the file to the caller, as a plain "wx" would.
+export function openNew(path, mode) {
+  const fd = openSync(path, "wx", mode);
+  let made = null;
+  let st;
+  try {
+    made = fstatSync(fd, { bigint: true });
+    st = lstatSync(path, { bigint: true });
+  } catch {
+    return fd;
+  }
+  if (!st.isSymbolicLink() && (made.ino === 0n || sameInode(made, st))) return fd;
+  closeSync(fd);
+  if (st.isSymbolicLink()) dropFollowed(path, made);
+  throw Object.assign(new Error(`EEXIST: file already exists, open '${path}'`), { code: "EEXIST", syscall: "open", path });
+}
+
+// Removes the file a "wx" open made through the link at path, when it is still the empty file that open made.
+function dropFollowed(path, made) {
+  try {
+    const target = realpathSync(path);
+    const st = statSync(target, { bigint: true });
+    if (sameInode(made, st) && st.size === 0n) rmSync(target, { force: true });
+  } catch {
+    // gone already, or the link changed again: nothing of ours to take back
+  }
+}
+
+// Writes data to a file that is not there yet (openNew) and closes it.
+function writeNew(path, data, mode) {
+  const fd = openNew(path, mode);
+  try {
+    writeFileSync(fd, data);
+  } finally {
+    closeSync(fd);
+  }
+}
+
 // Windows does not rename a file over a link to a folder: there the link goes first, and the folder it
 // leads to stays.
 function renameOver(tmp, file) {
@@ -510,13 +552,14 @@ 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
+// A file that was not there when it was read is created only if it still is not (openNew): 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, flag: file.bytes === null ? "wx" : "w" });
+    else if (file.bytes === null) writeNew(file.path, after, 0o644);
+    else writeFileSync(file.path, after, { mode: 0o644, flag: "w" });
   }
 }
 
@@ -568,9 +611,19 @@ const SLEEP = new Int32Array(new SharedArrayBuffer(4));
 // when it may still be there (no stats or no inode number to prove it is that file, or the share could not say).
 // Any other error (permissions, EIO) throws, after the same taking away.
 function tryLock(path, token) {
+  // A name that is there in any form is held. Windows opens "wx" through a link to nothing and makes the file it leads
+  // to; macOS and Linux answer EEXIST for it below, and openNew takes back a file Windows made through a link planted
+  // after this look. A look that fails leaves the answer to the open, as before.
+  let there = false;
+  try {
+    there = lstatSync(path, { throwIfNoEntry: false }) !== undefined;
+  } catch {
+    // ESTALE and the like: the open below answers
+  }
+  if (there) return "held";
   let fd;
   try {
-    fd = openSync(path, "wx", 0o600);
+    fd = openNew(path, 0o600);
   } catch (e) {
     if (e.code === "EEXIST") return "held";
     if (e.code === "ESTALE") return "stale";