@kaydash9999/banker-plugins 0.24.1 → 0.25.1

package/skills/3d-intro-setup/references/azure-adapter.mjs

@@ -642,12 +642,26 @@ export async function generateImage({
 const classicWorthTrying = (r) => !(r.ok && dataB64(r)) && r.status !== 429 && r.status !== 0;
 const dataB64 = (r) => r.body?.data?.[0]?.b64_json;
 
-// The PNG an image call answered with, or an error that starts with `failed`.
+// The PNG an image call answered with, or an error that starts with `failed`. Bytes that are not an image (a URL or an
+// error text in the image field, base64 that decodes to nothing) are a failure, not a picture.
 function pngFrom(r, b64, failed) {
   if (!(r.ok && b64)) throw new Error(`${failed}: HTTP ${r.status}${why(r)} ${truncate(r.body)}`);
-  return Buffer.from(b64, 'base64');
+  const buf = Buffer.from(String(b64), 'base64');
+  if (!isImage(buf)) throw new Error(`${failed}: the answer is not a PNG, JPEG or WebP image (${buf.length} bytes)`);
+  return buf;
 }
 
+/** Whether bytes start as a PNG, JPEG or WebP image. */
+export const isImage = (b) => Buffer.isBuffer(b) && b.length >= 12 && (b.readUInt32BE(0) === 0x89504e47
+  || (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) || (b.toString('latin1', 0, 4) === 'RIFF' && b.toString('latin1', 8, 12) === 'WEBP'));
+
+/**
+ * Whether bytes start as an ISO media file (mp4, mov): the first box is one such a file starts with (ftyp, or styp,
+ * free, skip, wide, moov, mdat in fragmented and QuickTime files). An HTML or JSON error page is not.
+ */
+const MEDIA_BOXES = new Set(['ftyp', 'styp', 'free', 'skip', 'wide', 'moov', 'mdat']);
+export const isMp4 = (b) => Buffer.isBuffer(b) && b.length >= 12 && MEDIA_BOXES.has(b.toString('latin1', 4, 8));
+
 /** Edit an image (optional mask) via the v1 images/edits multipart path. Returns a PNG Buffer. */
 export async function editImage({
   endpoint, key, deployment, apiVersion = 'preview', prompt, imageBuf, maskBuf, size,
@@ -781,6 +795,7 @@ export async function downloadVideo({ endpoint, key, id, apiVersion = 'preview'
     key, method: 'GET', binary: true,
   });
   if (!(r.status === 200 && r.body?.length)) throw Object.assign(new Error(`downloadVideo failed: HTTP ${r.status}${why(r)}`), { status: r.status });
+  if (!isMp4(r.body)) throw Object.assign(new Error(`downloadVideo failed: HTTP 200 but the body is not an mp4 (${r.ct || 'no content type'}, ${r.body.length} bytes)`), { status: r.status });
   return r.body;
 }
 
@@ -919,7 +934,7 @@ function twoImageForm({ model, prompt, firstPng, lastPng, size, seconds }) {
  *   3) the optional ffmpeg-static package (dynamic import — may be absent)
  * A project's .env.3d-intro.local never names the program, and "." or another relative PATH entry is
  * skipped: either would let the files of a project, a cloned repository say, choose what runs.
- * Throws an actionable error if none is found.
+ * Throws an actionable error if none is found, or if $FFMPEG_PATH is set but not usable.
  */
 export async function resolveFfmpeg() {
   const found = namedFfmpeg() || ffmpegOnPath() || await staticFfmpeg();
@@ -928,10 +943,17 @@ export async function resolveFfmpeg() {
 }
 
 // The ffmpeg this machine names. Absolute only: a relative value would be looked up in the current
-// folder, the project. The files are read only when the shell names nothing usable.
+// folder, the project. A $FFMPEG_PATH from the shell is the user's choice for this run: when it is
+// relative or names no file, this stops with why instead of quietly taking another ffmpeg. The files
+// are read only when the shell names nothing.
 function namedFfmpeg() {
   const usable = (p) => !!p && path.isAbsolute(p) && fs.existsSync(p);
-  if (usable(process.env.FFMPEG_PATH)) return process.env.FFMPEG_PATH;
+  const shell = process.env.FFMPEG_PATH;
+  if (shell) {
+    if (usable(shell)) return shell;
+    const why = path.isAbsolute(shell) ? 'no such file' : 'not an absolute path';
+    throw new Error(`FFMPEG_PATH from the shell is not usable (${why}): ${shell}; fix it or unset it`);
+  }
   return [readSettings(), readEnvQuietly(homeCredsPath)].map((s) => s.FFMPEG_PATH).find(usable) || null;
 }
 
@@ -953,17 +975,30 @@ async function staticFfmpeg() {
 }
 
 // Run ffmpeg with an ARGUMENT ARRAY (never a shell string). Returns {code, stdout, stderr, args}.
+// ffmpeg has a time limit: a stuck one (a FIFO input, a blocked disk) would hold the whole run. SIGKILL, as a stuck
+// ffmpeg may not end on SIGTERM.
+export const FF_TIMEOUT_MS = 10 * 60 * 1000;
 function runFf(bin, args, cwd) {
-  const r = cp.spawnSync(bin, args, { cwd, encoding: 'utf8', maxBuffer: 1 << 28 });
-  return { code: r.status, stdout: r.stdout || '', stderr: r.stderr || '', args };
+  const r = cp.spawnSync(bin, args, { cwd, encoding: 'utf8', maxBuffer: 1 << 28, timeout: FF_TIMEOUT_MS, killSignal: 'SIGKILL' });
+  return { code: r.status, signal: r.signal || null, error: r.error || null, stdout: r.stdout || '', stderr: r.stderr || '', args };
+}
+
+// One ffmpeg run that must make `out`: an earlier file there is removed first, and the run counts only when ffmpeg
+// ended by itself with 0 and `out` is a file with something in it. A killed or failed ffmpeg's partial file is not a result.
+function ffOut(name, bin, args, out) {
+  fs.rmSync(out, { force: true });
+  const r = runFf(bin, args);
+  const size = (() => { try { return fs.statSync(out).size; } catch { return 0; } })();
+  if (r.code === 0 && size > 0) return out;
+  const how = r.error ? (r.error.code === 'ETIMEDOUT' ? `timed out after ${FF_TIMEOUT_MS / 1000} s` : r.error.code || r.error.message)
+    : r.signal ? `killed by ${r.signal}` : r.code !== 0 ? `exit ${r.code}: ${tail(r.stderr)}` : 'ffmpeg wrote no output';
+  throw new Error(`${name} failed: ${how}`);
 }
 
 /** Extract the exact LAST frame of an mp4 to a PNG (reverse + first-frame trick). Returns out. */
 export async function extractLastFrame(mp4, out, { ffmpeg } = {}) {
   const bin = ffmpeg || await resolveFfmpeg();
-  const r = runFf(bin, ['-y', '-i', mp4, '-vf', 'reverse', '-frames:v', '1', out]);
-  if (r.code !== 0 && !fs.existsSync(out)) throw new Error(`extractLastFrame failed: ${tail(r.stderr)}`);
-  return out;
+  return ffOut('extractLastFrame', bin, ['-y', '-i', mp4, '-vf', 'reverse', '-frames:v', '1', out], out);
 }
 
 /**
@@ -974,20 +1009,15 @@ export async function extractLastFrame(mp4, out, { ffmpeg } = {}) {
  */
 export async function stillToClip(png, out, { ffmpeg, seconds = 1, fps = 24, size } = {}) {
   const bin = ffmpeg || await resolveFfmpeg();
-  fs.rmSync(out, { force: true }); // a file from an earlier run must not pass for this one
   const vf = `${size ? `scale=${String(size).replace('x', ':')},` : ''}format=yuv420p`;
-  const r = runFf(bin, ['-y', '-loop', '1', '-i', png, '-t', String(seconds), '-r', String(fps), '-vf', vf,
-    '-c:v', 'libx264', '-crf', '20', '-g', '8', '-movflags', '+faststart', '-an', out]);
-  if (r.code !== 0 && !fs.existsSync(out)) throw new Error(`stillToClip failed: ${tail(r.stderr)}`);
-  return out;
+  return ffOut('stillToClip', bin, ['-y', '-loop', '1', '-i', png, '-t', String(seconds), '-r', String(fps), '-vf', vf,
+    '-c:v', 'libx264', '-crf', '20', '-g', '8', '-movflags', '+faststart', '-an', out], out);
 }
 
 /** Extract the FIRST frame of an mp4 to a PNG. Returns out. */
 export async function extractFirstFrame(mp4, out, { ffmpeg } = {}) {
   const bin = ffmpeg || await resolveFfmpeg();
-  const r = runFf(bin, ['-y', '-i', mp4, '-frames:v', '1', out]);
-  if (r.code !== 0 && !fs.existsSync(out)) throw new Error(`extractFirstFrame failed: ${tail(r.stderr)}`);
-  return out;
+  return ffOut('extractFirstFrame', bin, ['-y', '-i', mp4, '-frames:v', '1', out], out);
 }
 
 /**
@@ -1000,13 +1030,12 @@ export async function crossfade(aMp4, bMp4, out, sec = 0.5, { ffmpeg, offset } =
   let off = offset;
   if (off == null) {
     const dur = probeDurationSec(bin, aMp4);
-    off = dur != null ? Math.max(0, dur - sec) : 0;
+    // with A's length unknown, an offset of 0 would cut A to the fade: a wrong clip, not a result
+    if (dur == null) throw new Error(`crossfade failed: could not read the duration of ${path.basename(aMp4)}; pass { offset }`);
+    off = Math.max(0, dur - sec);
   }
   const filter = `[0:v][1:v]xfade=transition=fade:duration=${sec}:offset=${off}`;
-  const args = ['-y', '-i', aMp4, '-i', bMp4, '-filter_complex', filter, '-c:v', 'libx264', '-pix_fmt', 'yuv420p', out];
-  const r = runFf(bin, args);
-  if (r.code !== 0 && !fs.existsSync(out)) throw new Error(`crossfade failed: ${tail(r.stderr)}`);
-  return out;
+  return ffOut('crossfade', bin, ['-y', '-i', aMp4, '-i', bMp4, '-filter_complex', filter, '-c:v', 'libx264', '-pix_fmt', 'yuv420p', out], out);
 }
 
 /**
@@ -1015,9 +1044,7 @@ export async function crossfade(aMp4, bMp4, out, sec = 0.5, { ffmpeg, offset } =
  */
 export async function concatClips(mp4List, out, { ffmpeg, fps = 30, width = 720, height = 1280 } = {}) {
   const bin = ffmpeg || await resolveFfmpeg();
-  const r = runFf(bin, concatArgs(clipList(mp4List), out, { fps, width, height }));
-  if (r.code !== 0 && !fs.existsSync(out)) throw new Error(`concatClips failed: ${tail(r.stderr)}`);
-  return out;
+  return ffOut('concatClips', bin, concatArgs(clipList(mp4List), out, { fps, width, height }), out);
 }
 
 function clipList(mp4List) {
@@ -1038,7 +1065,7 @@ function concatArgs(list, out, { fps, width, height }) {
 
 // Probe an mp4's duration (seconds) by parsing ffmpeg's stderr banner. Returns null if absent.
 function probeDurationSec(bin, mp4) {
-  const r = cp.spawnSync(bin, ['-i', mp4], { encoding: 'utf8' });
+  const r = cp.spawnSync(bin, ['-i', mp4], { encoding: 'utf8', timeout: FF_TIMEOUT_MS, killSignal: 'SIGKILL' });
   const text = `${r.stderr || ''}${r.stdout || ''}`;
   const m = text.match(/Duration:\s*(\d+):(\d+):(\d+(?:\.\d+)?)/);
   if (!m) return null;

package/skills/3d-intro-setup/references/video-pool.mjs

@@ -43,7 +43,7 @@ import crypto from 'node:crypto';
 import cp from 'node:child_process';
 import {
   createVideo, pollVideo, downloadVideo, resolveFfmpeg, redact, fetchGuarded, safeForKey, keyHeldBack, probeSoraDeployment,
-  API_TIMEOUT_MS, DOWNLOAD_TIMEOUT_MS, HELD_KEY, errnoOf, timeLeft,
+  API_TIMEOUT_MS, DOWNLOAD_TIMEOUT_MS, HELD_KEY, errnoOf, timeLeft, isMp4, isImage, FF_TIMEOUT_MS,
 } from './azure-adapter.mjs';
 
 export const WAN_DEFAULT_MODEL = 'wan3.0-video-prime';
@@ -399,9 +399,11 @@ async function stripAlpha(buf) {
     const src = path.join(dir, 'in.png');
     const out = path.join(dir, 'out.png');
     fs.writeFileSync(src, buf);
-    const r = cp.spawnSync(bin, ['-y', '-i', src, '-vf', 'format=rgb24', '-frames:v', '1', out], { encoding: 'utf8' });
-    if (!fs.existsSync(out)) throw new Error(`stripAlpha failed: ${String(r.stderr || '').slice(-400)}`);
-    return fs.readFileSync(out);
+    const r = cp.spawnSync(bin, ['-y', '-i', src, '-vf', 'format=rgb24', '-frames:v', '1', out], { encoding: 'utf8', timeout: FF_TIMEOUT_MS, killSignal: 'SIGKILL' });
+    // only a run that ended by itself with 0: a killed ffmpeg's partial PNG would go to WAN as the frame
+    const png = r.status === 0 && fs.existsSync(out) ? fs.readFileSync(out) : null;
+    if (!png || !isImage(png)) throw new Error(`stripAlpha failed: ${r.error ? r.error.code : r.signal ? `killed by ${r.signal}` : String(r.stderr || '').slice(-400)}`);
+    return png;
   } finally {
     fs.rmSync(dir, { recursive: true, force: true });
   }
@@ -410,6 +412,8 @@ async function stripAlpha(buf) {
 /** Encode a PNG/JPEG frame as the data URI WAN accepts, dropping any PNG alpha channel first. */
 export async function frameDataUri(buf) {
   const b = Buffer.isBuffer(buf) ? buf : fs.readFileSync(buf);
+  // an empty or non-image seed would be sent with a paid task and answered with a clip that does not start from it
+  if (!isImage(b)) throw new Error(`frameDataUri: the frame is not a PNG, JPEG or WebP image (${b.length} bytes)`);
   if (b[0] === 0xff && b[1] === 0xd8) return `data:image/jpeg;base64,${b.toString('base64')}`;
   const png = pngHasAlpha(b) ? await stripAlpha(b) : b;
   return `data:image/png;base64,${png.toString('base64')}`;
@@ -514,10 +518,11 @@ export async function downloadWanVideo(url, { sleep = realSleep, tries = 3 } = {
   let last;
   for (let i = 0; i < tries; i++) {
     last = await wanFetch(url, { binary: true, timeoutMs: DOWNLOAD_TIMEOUT_MS });
-    if (last.status === 200 && last.body?.length) return last.body;
+    // a 200 that is an HTML or JSON page (an expired or refused signed URL) is not the video: try again, then fail
+    if (last.status === 200 && isMp4(last.body)) return last.body;
     if (i < tries - 1) await sleep(2000 * (i + 1));
   }
-  throw new Error(`WAN video download failed: HTTP ${last?.status}`);
+  throw new Error(`WAN video download failed: HTTP ${last?.status}${last?.status === 200 ? ` but the body is not an mp4 (${last.body?.length ?? 0} bytes)` : ''}`);
 }
 
 /**

package/skills/anti-drm/SKILL.md

@@ -217,7 +217,7 @@ argument-hint: "on | off | status | config"
   - 설정 자리가 링크면 `status` 는 설정 줄에 링크가 가리키는 곳을 함께 보이고, 그 파일의 틀린 값은 글 대신 형식과 길이만 보임(`(string, 12자)`)
   - 폴더, FIFO, 64KiB 를 넘는 파일, 읽을 수 없는 파일은 덮어쓰지 않음(링크와 하드 링크는 다음 줄)
   - 저장할 때 링크와 하드 링크(이름이 둘 이상인 일반 파일)는 그 이름만 새 파일로 바꿈. 가리키던 파일은 읽지 않고 그대로 둠
-  - anti-drm 이 쓰지 않은 파일이 그 자리에 있으면 `anti-drm.json.bak` 에 한 번 남김 (이 계정만 읽기 가능). 링크와 하드 링크는 남기지 않음
+  - anti-drm 이 쓰지 않은 파일이 그 자리에 있으면 `anti-drm.json.bak` 에 한 번 남김 (이 계정만 읽기 가능). 링크와 하드 링크는 남기지 않음. `.bak` 자리에 일반 파일이 아닌 것(폴더, 링크)이 있으면 설정을 저장하지 않고 거부
 - 설정 폴더
   - Claude Code: `$CLAUDE_CONFIG_DIR`, 없으면 `~/.claude`
   - Codex: `$CODEX_HOME`, 없으면 `~/.codex`
@@ -243,7 +243,7 @@ argument-hint: "on | off | status | config"
 | 설정이 없습니다 | "질문" 으로 설정을 정해 `on` 에 넘김 |
 | 표준 입력에 설정 줄이 없습니다 | heredoc 이 비었음. "설정 넘기기" 대로 줄을 넣어 다시 실행 |
 | 표준 입력이 64KiB 보다 큽니다 | "답 처리" 대로 정규화한 값만 넘김 |
-| 설정 파일이 올바르지 않습니다 (뒤에 `--stdin 이나 --deny, --alt 로 함께 주세요` 가 붙음) | 이유를 전하고 설정을 다시 정할지 물은 뒤 진행. 정하면 "질문" 뒤 켜는 중이면 `on --runtime <런타임> --stdin`, 설정만 바꿀 때는 `config --stdin` 실행. 그 파일은 새 파일로 바뀌고(그 자리가 폴더나 특수 파일이거나, 64KiB 보다 크거나, 읽을 수 없는 파일이면 바꾸지 않고 거부함. 링크와 하드 링크(이름이 둘 이상인 일반 파일)는 거부하지 않고 그 이름만 일반 파일로 바꾸며, 가리키던 파일은 그대로 두고 `.bak` 에 남기지 않음), anti-drm 형식이 아니면 `anti-drm.json.bak` 에 한 번 남음(먼저 남긴 파일이나 일반 파일이 아닌 것이 그 자리에 있으면 남기지 않고 결과에 알림). 에이전트가 그 파일을 직접 지우거나 옮기지 않음 |
+| 설정 파일이 올바르지 않습니다 (뒤에 `--stdin 이나 --deny, --alt 로 함께 주세요` 가 붙음) | 이유를 전하고 설정을 다시 정할지 물은 뒤 진행. 정하면 "질문" 뒤 켜는 중이면 `on --runtime <런타임> --stdin`, 설정만 바꿀 때는 `config --stdin` 실행. 그 파일은 새 파일로 바뀌고(그 자리가 폴더나 특수 파일이거나, 64KiB 보다 크거나, 읽을 수 없는 파일이면 바꾸지 않고 거부함. 링크와 하드 링크(이름이 둘 이상인 일반 파일)는 거부하지 않고 그 이름만 일반 파일로 바꾸며, 가리키던 파일은 그대로 두고 `.bak` 에 남기지 않음), anti-drm 형식이 아니면 `anti-drm.json.bak` 에 한 번 남음(먼저 남긴 파일이 있으면 남기지 않고 결과에 알림. 그 자리에 일반 파일이 아닌 것이 있으면 원래 파일을 잃지 않게 설정을 저장하지 않고 거부). 에이전트가 그 파일을 직접 지우거나 옮기지 않음 |
 | 설정 파일이 올바르지 않습니다 (뒤에 `anti-drm 은 이 자리를 덮어쓰지 않습니다` 가 붙음) | 설정 자리가 폴더, 특수 파일, 64KiB 보다 큰 파일, 읽을 수 없는 파일임(링크면 이 말이 붙지 않고, 설정을 다시 주면 그 이름이 새 파일로 바뀜). 지우지 않음. 무엇인지 보이고, 옮길지 권한을 고칠지(다른 경로는 `BANKER_ANTI_DRM_CONFIG`) 물은 뒤 다시 실행 |
 | 일반 파일이 아니라 설정을 저장하지 않았습니다 | 설정 경로의 폴더나 특수 파일은 지우지 않음. 무엇인지 보이고, 옮길지 다른 경로(`BANKER_ANTI_DRM_CONFIG`)를 쓸지 물은 뒤 다시 실행 |
 | 64KiB 보다 큰 파일이라, 읽을 수 없는 파일이라 설정을 저장하지 않았습니다 | 그 파일이 무엇인지 보이고, 권한을 고칠지 옮길지 물은 뒤 다시 실행 |

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

@@ -358,11 +358,13 @@ function priorSettings(file) {
  * 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. Gives back what became of keep: null when none was
- * given, else "kept", "earlier" or "other" (see keepOnce).
+ * given, else "kept", "earlier" or "other" (see keepOnce). With "other" the settings are not written: the
+ * original would be lost.
  */
 export function writeConfig(file, config, keep = null) {
   mkdirSync(dirname(file), { recursive: true, mode: 0o755 });
   const kept = keep === null ? null : keepOnce(`${file}.bak`, keep);
+  if (kept === "other") return kept; // the original has nowhere to go: the settings are not written over it
   writeFresh(file, `${JSON.stringify(config, null, 2)}\n`, 0o644);
   return kept;
 }
@@ -472,12 +474,11 @@ export function status(opts = {}) {
 
 // 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.
+// .bak, or is not kept when an earlier one is there already (something that is not a regular file there refuses the
+// save before this). 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,
@@ -496,7 +497,9 @@ function save(o, config) {
     const prior = priorSettings(o.configFile);
     if (prior.refusal) return refuse(`${prior.refusal}: ${where(o.configFile)}`);
     const replaced = pathKind(o.configFile);
-    notes = saveNotes(o.configFile, replaced, writeConfig(o.configFile, config, prior.keep));
+    const kept = writeConfig(o.configFile, config, prior.keep);
+    if (kept === "other") return refuse(`원래 파일을 남길 자리에 일반 파일이 아닌 것이 있어 설정을 저장하지 않았습니다: ${where(`${o.configFile}.bak`)}`);
+    notes = saveNotes(o.configFile, replaced, kept);
   } catch (e) {
     if (denied(e)) return refuse(`쓸 권한이 없어 설정을 저장하지 못했습니다 (${e.code}): ${where(o.configFile)}`);
     throw e;

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

@@ -198,7 +198,8 @@ export function writeFresh(file, data, mode = 0o644) {
 // 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.
+// open. A name gone after the open is EEXIST too. A look that cannot be made (ESTALE, EPERM) 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;
@@ -206,8 +207,10 @@ export function openNew(path, mode) {
   try {
     made = fstatSync(fd, { bigint: true });
     st = lstatSync(path, { bigint: true });
-  } catch {
-    return fd;
+  } catch (e) {
+    if (e?.code !== "ENOENT") return fd; // cannot look (ESTALE, EPERM): the file is the caller's, as a plain "wx" leaves it
+    closeSync(fd); // the name is gone: nothing is written through a name not proved
+    throw Object.assign(new Error(`EEXIST: file already exists, open '${path}'`), { code: "EEXIST", syscall: "open", path });
   }
   if (!st.isSymbolicLink() && (made.ino === 0n || sameInode(made, st))) return fd;
   closeSync(fd);

package/skills/build-testbox/scripts/browser-cell.mjs

@@ -7,7 +7,7 @@
 //
 // spec: { url, jobs, timeoutMs, settleMs, outDir, cells: [{ id, device, browser, png }] }
 // Prints one line "BANKER_TESTBOX_RESULT <json>": { cells: [...] } or { fatal, detail }.
-import { mkdirSync, readFileSync } from "node:fs";
+import { mkdirSync, readFileSync, realpathSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
@@ -173,7 +173,15 @@ async function main(argv) {
   return { cells: await runGroup(pw, spec) };
 }
 
-const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+// Run directly, also through a linked path or another spelling: both sides as real paths.
+const realOr = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve(p);
+  }
+};
+const isMain = process.argv[1] && realOr(process.argv[1]) === realOr(fileURLToPath(import.meta.url));
 if (isMain) {
   main(process.argv.slice(2))
     .then((r) => { process.stdout.write(`${RESULT_TAG}${JSON.stringify(r)}\n`); process.exit(0); })

package/skills/build-testbox/scripts/containers.mjs

@@ -3,14 +3,18 @@
 // No bind mount (SELinux relabel, Windows paths). Containers are named banker-testbox-<random>-<os> and removed on
 // success, failure, time-out and signal.
 import { spawnSync } from "node:child_process";
-import { copyFileSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, sep } from "node:path";
 import { imageFor } from "./args.mjs";
 import { pool } from "./browser-cell.mjs";
 import { firstLine, runProc, which } from "./proc.mjs";
 import { cellOf } from "./report.mjs";
 
+// The folder programs start in: the home folder (Windows looks for a program in the working folder first, so a
+// program planted in the folder worked on never runs), or the temp folder when there is no home folder.
+const runDir = () => (existsSync(homedir()) ? homedir() : tmpdir());
+
 export const NAME_PREFIX = "banker-testbox";
 const iso = () => new Date().toISOString();
 export const randomTag = () => Math.random().toString(16).slice(2, 10).padEnd(8, "0");
@@ -66,7 +70,8 @@ export function removeAllSync(engine, names) {
 
 function gitFiles(src) {
   const env = Object.fromEntries(Object.entries(process.env).filter(([k]) => !/^GIT_/i.test(k)));
-  const r = spawnSync("git", ["-C", src, "ls-files", "-z", "-co", "--exclude-standard"], { encoding: "utf8", env, maxBuffer: 256 * 1024 * 1024 });
+  // from the home folder: Windows looks for git.exe in the working folder first
+  const r = spawnSync("git", ["-C", src, "ls-files", "-z", "-co", "--exclude-standard"], { cwd: runDir(), encoding: "utf8", env, maxBuffer: 256 * 1024 * 1024 });
   return r.status === 0 ? r.stdout.split("\0").filter(Boolean) : null;
 }
 

package/skills/build-testbox/scripts/proc.mjs

@@ -1,9 +1,9 @@
 // Child processes for build-testbox: PATH lookup (PATHEXT on Windows), a promise-returning runner with a time limit
 // and a set of live children, so a signal handler can stop them all. No shell: arguments go to the program as given.
 // On Windows a .cmd or .bat goes through cmd.exe with each argument quoted (Node refuses to spawn them directly).
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { accessSync, constants, statSync } from "node:fs";
-import { delimiter, extname, isAbsolute, join } from "node:path";
+import { delimiter, extname, isAbsolute, join, win32 } from "node:path";
 
 const LIVE = new Set();
 const MAX_OUT = 8 * 1024 * 1024;
@@ -51,6 +51,21 @@ function collector() {
   return { parts, add };
 }
 
+// Ends a child and everything it started: on POSIX its process group (the child leads one, spawned detached), on
+// Windows the tree through System32's taskkill /T /F (not a taskkill found in the working folder).
+function killTree(child) {
+  if (process.platform === "win32") {
+    const taskkill = win32.join(process.env.SystemRoot || "C:\\Windows", "System32", "taskkill.exe");
+    spawnSync(taskkill, ["/T", "/F", "/PID", String(child.pid)], { stdio: "ignore", windowsHide: true });
+    return;
+  }
+  try {
+    process.kill(-child.pid, "SIGKILL");
+  } catch {
+    try { child.kill("SIGKILL"); } catch { /* already gone */ }
+  }
+}
+
 // Runs a program and resolves { code, signal, stdout, stderr, out, timedOut, error }. Never rejects: a missing
 // program is { code: null, error: "ENOENT" }. out holds stdout and stderr in arrival order.
 export function runProc(cmd, args = [], opts = {}) {
@@ -61,13 +76,19 @@ export function runProc(cmd, args = [], opts = {}) {
     let timedOut = false;
     let child;
     try {
-      child = spawn(bin, argv, { cwd: opts.cwd, env: opts.env || process.env, stdio: ["ignore", "pipe", "pipe"], ...extra });
+      const detached = process.platform !== "win32"; // its own process group, so a time-out ends what it started too
+      child = spawn(bin, argv, { cwd: opts.cwd, env: opts.env || process.env, stdio: ["ignore", "pipe", "pipe"], detached, ...extra });
     } catch (e) {
       resolveRun({ code: null, signal: null, ...parts, timedOut, error: e.code || String(e.message) });
       return;
     }
     LIVE.add(child);
-    const timer = opts.timeoutMs ? setTimeout(() => { timedOut = true; child.kill("SIGKILL"); }, opts.timeoutMs) : null;
+    const timer = opts.timeoutMs ? setTimeout(() => { timedOut = true; killTree(child); }, opts.timeoutMs) : null;
+    // After a time-out, a process that left the tree may still hold the pipes: they are closed a second after the exit,
+    // so the run ends instead of waiting for it.
+    child.on("exit", () => {
+      if (timedOut) setTimeout(() => { child.stdout.destroy(); child.stderr.destroy(); }, 1000).unref();
+    });
     child.stdout.on("data", add("stdout"));
     child.stderr.on("data", add("stderr"));
     let error = null;
@@ -80,12 +101,15 @@ export function runProc(cmd, args = [], opts = {}) {
   });
 }
 
-// Stops every child still running (used by the SIGINT and SIGTERM handlers).
+// Stops every child still running (used by the SIGINT and SIGTERM handlers, and when this process exits). On POSIX a
+// child leads its own process group, so it no longer gets the terminal's signals: an entry point that uses runProc
+// keeps signal handlers that call killAll (testbox.mjs does).
 export function killAll() {
-  for (const child of LIVE) {
-    try { child.kill("SIGKILL"); } catch { /* already gone */ }
-  }
+  for (const child of LIVE) killTree(child);
   LIVE.clear();
 }
 
 export const firstLine = (s) => String(s || "").split(/\r?\n/).map((l) => l.trim()).find(Boolean) || "";
+
+// A child group left when this process ends some other way (an uncaught error) is ended too.
+process.on("exit", killAll);

package/skills/build-testbox/scripts/testbox.mjs

@@ -2,7 +2,7 @@
 // build-testbox: a test bed each PC builds for itself. Browser matrix (Playwright Chromium and WebKit, desktop and
 // mobile emulation) and container OS (Rocky Linux; macOS only as a Tart VM on Apple Silicon) run in parallel.
 // run downloads nothing; setup downloads only after --yes. Pure Node 18+, no dependency.
-import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, realpathSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { UsageError, parseArgs } from "./args.mjs";
@@ -144,5 +144,13 @@ export async function main(argv) {
   }
 }
 
-const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+// Run directly, also through a linked path or another spelling: both sides as real paths.
+const realOr = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return resolve(p);
+  }
+};
+const isMain = process.argv[1] && realOr(process.argv[1]) === realOr(fileURLToPath(import.meta.url));
 if (isMain) main(process.argv.slice(2)).then((code) => { process.exitCode = code; });

package/skills/git-init/scripts/git-init.mjs

@@ -24,13 +24,17 @@
  * repository, a .git below the root, no commit identity). No network is used.
  */
 import { spawnSync } from "node:child_process";
-import { lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join, parse, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { HASH, commitBlock, findBlock, markers, planBlock } from "./marker-block.mjs";
 import { scan } from "./payload-scan.mjs";
 
+// The folder programs start in: the home folder (Windows looks for a program in the working folder first, so a
+// program planted in the folder worked on never runs), or the temp folder when there is no home folder.
+const runDir = () => (existsSync(homedir()) ? homedir() : tmpdir());
+
 const USAGE = [
   "git-init: 민감 정보를 빼는 .gitignore 를 쓰고 비밀값을 스캔한 뒤 git init, git add ., git commit -m \"init\" 으로 첫 커밋을 만듦(check 는 계획만)",
   "사용법: node git-init.mjs [check|run] [--root <dir>] [--branch <이름>] [--local-identity \"<이름> <<메일>>\"] [--nested]",
@@ -120,9 +124,29 @@ function gitEnv(extra) {
   return env;
 }
 
-// Runs git; never throws. ok is false when git could not start or exited non-zero.
+// On Windows git is a wrapper (cmd\git.exe) that starts the real git: a time limit on the wrapper alone leaves the real
+// git running, which can still make the commit after the failure was reported. With a time limit, git runs under this
+// small Node supervisor instead, which ends the whole tree with System32's taskkill /T /F and exits 124.
+const TREE_SUPERVISOR = [
+  "const {spawn,spawnSync}=require('child_process');const p=require('path');",
+  "const [ms,...a]=process.argv.slice(1);",
+  "const c=spawn('git',a,{stdio:'inherit',windowsHide:true});",
+  "const t=setTimeout(()=>{spawnSync(p.win32.join(process.env.SystemRoot||'C:\\\\Windows','System32','taskkill.exe'),['/T','/F','/PID',String(c.pid)],{stdio:'ignore',windowsHide:true});process.exit(124)},Number(ms));",
+  "c.on('error',()=>process.exit(127));c.on('exit',(code)=>{clearTimeout(t);process.exit(code==null?1:code)});",
+].join("");
+
+// Runs git on the folder cwd (git -C), started from the home folder: Windows looks for a program in the working folder
+// first, so a git.exe inside the folder being initialized never runs. Never throws. ok is false when git could not
+// start or exited non-zero; a time-out is error.code ETIMEDOUT.
 function git(args, cwd, { env, timeout } = {}) {
-  const r = spawnSync("git", args, { cwd, encoding: "utf8", env: gitEnv(env), timeout, killSignal: "SIGKILL", maxBuffer: 256 * 1024 * 1024, windowsHide: true });
+  const opts = { cwd: runDir(), encoding: "utf8", env: gitEnv(env), killSignal: "SIGKILL", maxBuffer: 256 * 1024 * 1024, windowsHide: true };
+  const argv = ["-C", cwd, ...args];
+  if (timeout && process.platform === "win32") {
+    const r = spawnSync(process.execPath, ["-e", TREE_SUPERVISOR, String(timeout), ...argv], { ...opts, timeout: timeout + 30000 });
+    const error = r.status === 124 ? Object.assign(new Error("git timed out"), { code: "ETIMEDOUT" }) : r.error;
+    return { ok: !error && r.status === 0, out: r.stdout ?? "", err: (r.stderr ?? "").trim(), error };
+  }
+  const r = spawnSync("git", argv, { ...opts, timeout });
   return { ok: !r.error && r.status === 0, out: r.stdout ?? "", err: (r.stderr ?? "").trim(), error: r.error };
 }
 
@@ -136,12 +160,35 @@ const real = (p) => {
   }
 };
 
+// Whether a and b are one folder: device and inode (bigint, as NTFS file ids pass 2^53), or where the file system has
+// no inode numbers, the path as the file system spells it (realpathSync.native gives one spelling for names that differ
+// only in case, an 8.3 short name or a linked parent), case folded on Windows and macOS. A string compare of the JS
+// realpath let `--root c:\users\me` (or /users/me on macOS) pass the HOME refusal.
+function sameDir(a, b) {
+  try {
+    const x = statSync(a, { bigint: true });
+    const y = statSync(b, { bigint: true });
+    if (x.ino !== 0n && y.ino !== 0n) return x.dev === y.dev && x.ino === y.ino;
+  } catch {
+    // one is gone: the spellings below decide
+  }
+  const spell = (p) => {
+    try {
+      return realpathSync.native(p);
+    } catch {
+      return real(p);
+    }
+  };
+  const fold = (p) => (process.platform === "win32" || process.platform === "darwin" ? p.toLowerCase() : p);
+  return fold(spell(a)) === fold(spell(b));
+}
+
 // The root folder, or a failure: missing (2), HOME or a file system root (3).
 function checkRoot(rootArg) {
   const root = resolve(rootArg);
   if (!statSync(root, { throwIfNoEntry: false })?.isDirectory()) return fail(2, `루트 폴더가 없음: ${root}`);
   const r = real(root);
-  if (r === real(homedir())) return fail(3, `루트가 HOME 이라 거부: ${root}. 프로젝트 폴더에서 실행하거나 --root 로 지정`);
+  if (sameDir(root, homedir())) return fail(3, `루트가 HOME 이라 거부: ${root}. 프로젝트 폴더에서 실행하거나 --root 로 지정`);
   if (parse(r).root === r) return fail(3, `루트가 파일 시스템 루트라 거부: ${root}`);
   return { root };
 }
@@ -212,7 +259,7 @@ export function missingPatterns(text) {
 function gitignorePlan(root, follow) {
   const path = join(root, ".gitignore");
   const opts = { comment: HASH, id: ID, skill: SKILL, followSymlink: follow };
-  const probe = planBlock(path, { ...opts, body: null });
+  const probe = planBlock(path, { ...opts, body: null, readOnly: true }); // read only: never written
   if (!probe.ok) return { refuse: probe };
   const missing = missingPatterns(probe.before === null ? "" : probe.before.toString("utf8"));
   const plan = planBlock(path, { ...opts, body: missing.length > 0 ? [BLOCK_HEAD, ...missing].join("\n") : null });
@@ -325,6 +372,7 @@ function commitInit(root) {
 
 function runSteps(o, ctx) {
   const done = commitBlock(ctx.gi.plan, SKILL);
+  if (!done.ok) return fail(1, `.gitignore 거부: ${done.message}. git init 하지 않음`, { ...ctx.report, ok: false });
   const report = { ...ctx.report, gitignore: { ...ctx.report.gitignore, status: done.changed ? (done.created ? "created" : "updated") : "unchanged", backup: done.backup ?? null } };
   const list = listCandidates(ctx.tmp, ctx.root, []);
   const nested = list.filter((p) => p.endsWith("/"));