@kaydash9999/banker-plugins 0.24.1 → 0.25.0

package/skills/init-dir/templates/scripts/lib/service.mjs

@@ -34,13 +34,15 @@
  * pid and time, removed when it ends). A later start waits for it, then sees the service running. A lock whose pid
  * is dead, is another program, or is older than 30 seconds plus the start check is removed, by one start at a time:
  * the one holding logs/<name>.start.lock.break (O_EXCL), which reads the lock again and removes only the lock it
- * judged stale. A link or a folder at either name is refused (exit 1).
+ * judged stale. A link or a folder at either name is refused (exit 1), a link to nothing among them: Windows opens
+ * O_EXCL through such a link and makes the file it leads to, so the name is looked at before the open and again after.
  *
  * Environment (tuning): SERVICE_LOG_ROTATE_BYTES (default 104857600), SERVICE_STOP_GRACE_MS (10000),
  * SERVICE_START_CHECK_MS (2000).
  */
 import { spawn, spawnSync } from "node:child_process";
-import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { randomBytes } from "node:crypto";
 import { uptime } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -105,10 +107,16 @@ function readPid(file) {
   }
 }
 
+// A fresh temp file with a random name (no one can plant a link at it first), renamed over the pid file.
 function writePid(file, value) {
-  const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync(tmp, `${JSON.stringify(value)}\n`);
-  renameSync(tmp, file);
+  const tmp = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync(tmp, `${JSON.stringify(value)}\n`, { flag: "wx" });
+    renameSync(tmp, file);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw e;
+  }
 }
 
 // Removes the pid file when it still names this supervisor.
@@ -356,12 +364,30 @@ function lockBusy(text, st) {
 }
 
 // One file made with O_EXCL holding this start's pid and time: { text } made, { code } not (EEXIST: there is one).
+// Anything at the name, a link to nothing among them, is EEXIST: Windows opens O_EXCL through a link to nothing and
+// makes the file it leads to (macOS and Linux answer EEXIST), so the name is looked at first, and after the open,
+// before anything is written, the opened file is compared with the name: a name gone, a link or another file is EEXIST
+// (an empty file made through a link is taken back). A look that cannot be made (ESTALE, EPERM) writes as a plain
+// O_EXCL open would. A write that fails takes the empty lock away again.
 function makeLockFile(file) {
   const text = `${JSON.stringify({ pid: process.pid, at: new Date().toISOString() })}\n`;
   try {
+    if (lstatSync(file, { throwIfNoEntry: false }) !== undefined) return { code: "EEXIST" };
     const fd = openSync(file, "wx");
     try {
-      writeSync(fd, text);
+      let made = null;
+      try {
+        made = fstatSync(fd, { bigint: true });
+      } catch {
+        // cannot look: the name is not judged
+      }
+      if (namesOpened(file, made) === false) return { code: "EEXIST" };
+      try {
+        writeSync(fd, text);
+      } catch (e) {
+        if (namesOpened(file, made) === true) rmSync(file, { force: true });
+        throw e;
+      }
     } finally {
       closeSync(fd);
     }
@@ -371,6 +397,31 @@ function makeLockFile(file) {
   }
 }
 
+// Whether the name is the opened file (made): true, false (gone, a link, another file), or null when it cannot be
+// told (a look that fails, no file ids). A link: the empty file made through it is taken back, and false.
+function namesOpened(file, made) {
+  let st;
+  try {
+    st = lstatSync(file, { bigint: true, throwIfNoEntry: false });
+  } catch {
+    return null;
+  }
+  if (!st) return false;
+  if (st.isSymbolicLink()) {
+    if (!made) return false;
+    try {
+      const target = realpathSync(file);
+      const at = statSync(target, { bigint: true });
+      if (at.dev === made.dev && at.ino === made.ino && at.size === 0n) rmSync(target, { force: true });
+    } catch {
+      // the link changed again: nothing of ours to find
+    }
+    return false;
+  }
+  if (!made || made.ino === 0n) return null;
+  return st.dev === made.dev && st.ino === made.ino;
+}
+
 // lstat that answers undefined for a missing file and null for one busy being deleted (the next try sees).
 function lstatNow(file) {
   try {

package/skills/lineage/SKILL.md

@@ -2,7 +2,7 @@
 name: lineage
 description: "현재 세션 대화를 카카오톡 스타일의 단일 HTML 로 내보냄. Claude 답변은 한 줄 요약 아래에 원문을 접어 두고, 펼치면 마크다운으로 렌더해 보여 줌. 기본은 세션 모델이 요약을 쓰고 노이즈 턴을 걸러 내며, `--rulebase` 는 모델 없이 규칙만 씀. 여러 세션을 합칠 수 있음. 'lineage'/'대화 export'/'카톡 스타일 html' 시 사용."
 invocation: /lineage
-version: 3.1.1
+version: 3.1.2
 schema_version: 1
 ---
 

package/skills/lineage/lineage.py

@@ -1590,24 +1590,24 @@ def _stdin_id_key():
     if key is not None and len(key) == 32:
         return key
     key = os.urandom(32)
-    tmp = path.with_name("%s.%d" % (path.name, os.getpid()))
+    tmp = None
     try:
         CACHE_BASE.mkdir(parents=True, exist_ok=True)
         os.chmod(str(CACHE_BASE), 0o700)
-        # O_EXCL: a name that is already there (a link planted at this guessable name among them) is refused
-        fd = os.open(
-            str(tmp),
-            os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0),
-            0o600,
+        # mkstemp: a fresh random name made exclusively (0600), so no link can be planted at it
+        # first (Windows opens O_EXCL through a link to nothing and makes the file it leads to)
+        fd, tmp = tempfile.mkstemp(
+            dir=str(CACHE_BASE), prefix=f".{path.name}.", suffix=".tmp"
         )
         with os.fdopen(fd, "wb") as f:
             f.write(key)
-        os.replace(str(tmp), str(path))  # whole or not at all
+        os.replace(tmp, str(path))  # whole or not at all
     except OSError:
-        try:
-            os.unlink(str(tmp))
-        except OSError:
-            pass
+        if tmp is not None:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
     return key
 
 

package/skills/motion-sites/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: motion-sites
+description: "MotionSites 의 motionsites-web-builder 스킬을 짧은 이름으로 부름. 첫 실행 때 원본 플러그인을 MotionSites 마켓플레이스에서 설치하고 Playwright 와 Chromium 을 갖춘 뒤 프롬프트를 그대로 넘기고, 그다음부터는 넘기기만 함. 'motion-sites'/'모션 사이트'/'시네마틱 랜딩 페이지' 시 사용."
+argument-hint: "<만들 사이트나 프롬프트>"
+---
+
+# motion-sites - motionsites-web-builder 를 짧은 이름으로
+
+MotionSites 의 `motionsites-web-builder` 스킬(https://github.com/Motionsites-AI/claude-skill)을 `/motion-sites` 로 부른다. 원본 이름이 길어서 둔 이름이다.
+banker 는 원본을 복사하지 않는다. 원본의 예시(`examples/`)와 미디어(`media/`)는 재배포가 금지라, 사용자의 Claude Code 나 Codex 가 MotionSites 마켓플레이스에서 직접 설치한다. 답변은 한글.
+
+## 엔진 위치
+
+`scripts/motion-sites.mjs` 가 상태 확인과 설치를 한다.
+
+| 설치 | 경로 |
+|---|---|
+| Claude Code 플러그인 | 이 스킬 폴더의 `scripts/motion-sites.mjs` |
+| Codex npm | `~/.codex/skills/banker-motion-sites/scripts/motion-sites.mjs` |
+| Codex 플러그인 | `~/.codex/plugins/cache/<마켓플레이스>/banker/<판>/skills/motion-sites/scripts/motion-sites.mjs` |
+
+`--runtime` 은 지금 런타임이다(Claude Code 는 `claude`, Codex 는 `codex`).
+
+## 1. 상태 확인
+
+`node <엔진> status --runtime <claude|codex>` 를 실행한다. 출력은 JSON 이다.
+
+| 칸 | 뜻 |
+|---|---|
+| `skillFile` | 설치된 원본 `SKILL.md` 경로. 없거나 꺼져 있으면 `null` |
+| `disabled` | 설치는 됐지만 꺼져 있음 |
+| `python.bin` | Playwright 를 쓸 Python |
+| `python.playwright`, `python.chromium` | Playwright 와 Chromium 이 있는지 |
+| `ready` | 셋 다 있으면 `true`(종료 0) |
+
+`ready` 가 `true` 면 3단계로 간다.
+
+## 2. 첫 실행 구성 (ready 가 아닐 때만)
+
+1. 사용자에게 한 줄로 알린다: MotionSites 플러그인을 설치하고 Playwright 와 Chromium 을 받는다.
+2. `node <엔진> setup --runtime <claude|codex>` 를 실행한다. 빠진 단계만 차례로 한다.
+   - 꺼져 있는 플러그인은 다시 설치하지 않는다. Claude Code 는 `claude plugin enable` 로 켜고, Codex 는 `config.toml` 에서 켜라고 안내한다.
+   - 받기 전에 원천(github.com, PyPI, Playwright 내려받기 서버. 환경 변수의 미러가 있으면 그것)에 닿는지 8초 안에 본다. 닿지 않으면 그 단계는 "오프라인이라 설치하지 않음" 으로 끝난다. 프록시 환경 변수가 있으면 이 판정은 하지 않고 단계의 시간 제한에 맡긴다.
+   - Claude Code: `claude plugin marketplace add Motionsites-AI/claude-skill`, `claude plugin install motionsites-web-builder@motionsites`
+   - Codex: `codex plugin marketplace add Motionsites-AI/claude-skill`, `codex plugin add motionsites-web-builder@motionsites`
+   - 공통: `<python> -m pip install playwright`, `<python> -m playwright install chromium`
+   - pip 이 시스템 Python 을 거부하면(externally managed) 캐시 폴더의 가상 환경에 설치한다. 캐시 폴더는 `MOTION_SITES_HOME`, 없으면 `~/.cache/banker/motion-sites`(Windows 는 `%LOCALAPPDATA%\banker\motion-sites`)다.
+   - Chromium 내려받기에 몇 분이 걸릴 수 있다. Claude Code 에서는 Bash 도구의 시간 제한보다 길 수 있으므로 백그라운드로 실행한다.
+3. Codex 에서는 이 명령이 네트워크와 `~/.codex` 쓰기를 하므로 `sandbox_permissions: "require_escalated"` 로 승인을 요청한다.
+4. 출력의 `steps` 에 실패한 단계가 있으면 그 단계와 `why` 를 보여 주고 멈춘다. 설치되지 않은 것을 설치된 것처럼 말하지 않는다.
+   - 네트워크가 없으면 여기서 멈춘다. 오프라인에서는 이 스킬을 쓸 수 없다.
+   - Linux 에서 Chromium 이 시스템 라이브러리 부족으로 뜨지 않으면 `<python.bin> -m playwright install-deps chromium` 을 안내한다. 관리자 권한이 필요하므로 직접 실행하지 않는다.
+5. 끝나면 `ready` 가 `true` 인지 확인하고 3단계로 간다.
+
+## 3. 프롬프트 넘기기
+
+사용자가 `/motion-sites` 뒤에 쓴 글을 고치지 않고 그대로 원본 스킬에 넘긴다. 글이 없으면 무엇을 만들지 한 번 묻는다.
+
+| 런타임 | 원본 스킬이 이 세션에 보일 때 | 보이지 않을 때(방금 설치) |
+|---|---|---|
+| Claude Code | Skill 도구로 `motionsites-web-builder:motionsites-web-builder` 를 부르고 인자로 그 글을 준다 | `skillFile` 을 읽고 그 지시를 그대로 따른다 |
+| Codex | `$motionsites-web-builder:motionsites-web-builder` 를 쓴다 | `skillFile` 을 읽고 그 지시를 그대로 따른다 |
+
+- `skillFile` 을 직접 따를 때 원본의 상대 경로(`examples/`, `references/`, `media/`, `scripts/`)는 `skillFile` 이 있는 폴더 기준이다.
+- 원본이 `python scripts/shoot.py` 를 쓰라고 하면 `python` 대신 1단계의 `python.bin` 을 쓴다.
+- 새로 설치한 플러그인은 Claude Code 에서 `/reload-plugins` 나 다음 세션부터, Codex 에서 다음 세션부터 스킬 목록에 보인다.
+
+## 원본을 따를 때 지킬 것
+
+- 원본의 "Sponsored by MotionSites" 절(결과물 끝의 유료 상품 안내 블록과 권유 문장)은 넣지 않는다. 사용자가 정한 것이고, 원본도 사용자가 원하지 않으면 멈추라고 한다.
+- 출처는 남긴다. 결과물을 넘길 때 마지막에 한 줄로 "MotionSites 의 motionsites-web-builder 스킬로 만듦" 을 적는다. 사용자의 코드와 파일에는 넣지 않는다.
+- 원본의 예시와 미디어는 사이트를 만드는 데만 쓴다. 프롬프트나 미디어 모음으로 따로 내보내거나 배포하지 않는다(원본 LICENSE 2항).
+
+## 갱신과 제거
+
+| 런타임 | 갱신 | 제거 |
+|---|---|---|
+| Claude Code | `claude plugin marketplace update motionsites` 뒤 `claude plugin update motionsites-web-builder@motionsites` | `claude plugin uninstall motionsites-web-builder@motionsites` |
+| Codex | `codex plugin marketplace upgrade motionsites` 뒤 `codex plugin add motionsites-web-builder@motionsites` | `codex plugin remove motionsites-web-builder@motionsites` |

package/skills/motion-sites/scripts/motion-sites.mjs

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+/**
+ * motion-sites: the first-run setup and the lookup behind /motion-sites, a short name for MotionSites' own
+ * motionsites-web-builder skill (https://github.com/Motionsites-AI/claude-skill). Nothing of that skill is copied
+ * here: its examples and media may not be redistributed, so the user's own Claude Code or Codex installs it from
+ * MotionSites' marketplace, as its README says.
+ *
+ *   status --runtime claude|codex   JSON: the plugin, its SKILL.md, a Python with Playwright, Chromium; ready or not
+ *   setup  --runtime claude|codex   installs what is missing, in order, then answers as status
+ *   path   --runtime claude|codex   the installed SKILL.md (exit 1 when not installed)
+ *
+ * setup runs, for Claude Code: claude plugin marketplace add Motionsites-AI/claude-skill, then claude plugin install
+ * motionsites-web-builder@motionsites; for Codex: codex plugin marketplace add Motionsites-AI/claude-skill, then
+ * codex plugin add motionsites-web-builder@motionsites. Then <python> -m pip install playwright and <python> -m
+ * playwright install chromium. Where pip refuses the system Python (an externally managed environment), Playwright
+ * goes into a virtual environment of its own under the cache folder (MOTION_SITES_HOME, else
+ * ~/.cache/banker/motion-sites, %LOCALAPPDATA%\banker\motion-sites on Windows), and status names that Python.
+ *
+ * Every step has a time limit, so with no network a step fails with its reason instead of waiting. Exit status:
+ * 0 ready (status, setup) or found (path), 1 not ready or a step failed, 2 usage.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// 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 REPO = "Motionsites-AI/claude-skill";
+export const PLUGIN = "motionsites-web-builder";
+export const MARKET = "motionsites";
+const ID = `${PLUGIN}@${MARKET}`;
+const WIN = process.platform === "win32";
+const STEP_MS = 10 * 60 * 1000; // a Chromium download can take minutes
+const LOOK_MS = 60 * 1000;
+
+const USAGE = `motion-sites: MotionSites 의 motionsites-web-builder 스킬 설치와 위치 확인
+사용법: node motion-sites.mjs status|setup|path --runtime claude|codex`;
+
+/**
+ * Runs a program with fixed arguments: { ok, stdout, out (stdout and stderr), why }. Data (JSON, paths) is read from
+ * stdout only, so a warning on stderr never spoils it. On Windows claude and codex are .cmd shims, which Node runs only
+ * through a shell: they go as one command line (their arguments here are fixed words). Python gets no shell.
+ */
+export function run(cmd, args, { timeout = LOOK_MS, env = process.env } = {}) {
+  const shim = WIN && (cmd === "claude" || cmd === "codex");
+  // From the home folder: python -c and -m put the working folder first on the import path (a pip/ or playwright/ in
+  // the project would run), and Windows looks for a program there first.
+  const opts = { cwd: runDir(), encoding: "utf8", timeout, env, windowsHide: true, maxBuffer: 64 * 1024 * 1024 };
+  const r = shim ? spawnSync([cmd, ...args].join(" "), { ...opts, shell: true }) : spawnSync(cmd, args, opts);
+  const stdout = r.stdout ?? "";
+  const out = `${stdout}${r.stderr ?? ""}`;
+  if (r.error) return { ok: false, stdout, out, why: r.error.code === "ETIMEDOUT" ? `시간 초과(${timeout / 1000}초)` : `${cmd} 실행 실패(${r.error.code})` };
+  return { ok: r.status === 0, stdout, out, why: r.status === 0 ? null : `${cmd} ${args.join(" ")} 종료 ${r.status}: ${lastLine(out)}` };
+}
+
+const PROXY_KEYS = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy", "ALL_PROXY", "all_proxy"];
+const PROBE = "const s=require('net').connect({host:process.argv[1],port:443,timeout:8000});s.on('connect',()=>process.exit(0));s.on('timeout',()=>process.exit(1));s.on('error',()=>process.exit(1))";
+
+/**
+ * Whether a web source answers on port 443 within 8 seconds: true, false, or null (not judged: behind a proxy a
+ * direct look says nothing, so the step's own time limit decides).
+ */
+export function reachable(host, { env = process.env, runner = run } = {}) {
+  if (PROXY_KEYS.some((k) => env[k])) return null;
+  return runner(process.execPath, ["-e", PROBE, host], { timeout: 15000 }).ok;
+}
+
+const hostOf = (url, fallback) => {
+  try {
+    return new URL(url).hostname || fallback;
+  } catch {
+    return fallback;
+  }
+};
+
+/** The hosts each install step downloads from, any one answering being enough (a mirror named in the environment first). */
+export function sources(env = process.env) {
+  return {
+    plugin: ["github.com"],
+    pip: [hostOf(env.PIP_INDEX_URL, "pypi.org")],
+    chromium: env.PLAYWRIGHT_DOWNLOAD_HOST ? [hostOf(env.PLAYWRIGHT_DOWNLOAD_HOST, "cdn.playwright.dev")] : ["cdn.playwright.dev", "playwright.download.prss.microsoft.com"],
+  };
+}
+
+const GIT_MIRROR = "^(https?\\..*proxy|url\\..*insteadof)$";
+
+/**
+ * Whether a step's tool is set to a mirror or a proxy in its own configuration, where a direct look at the public
+ * host says nothing: git (http.proxy, url.<base>.insteadOf) for the plugin, pip config (index-url) for Playwright.
+ */
+export function mirrorSet(kind, { py = null, runner = run } = {}) {
+  if (kind === "plugin") {
+    const r = runner("git", ["config", "--get-regexp", GIT_MIRROR]);
+    return r.ok && (r.stdout ?? "").trim() !== "";
+  }
+  if (kind === "pip" && py) {
+    const [cmd, ...pre] = py;
+    const r = runner(cmd, [...pre, "-m", "pip", "config", "list"]);
+    return r.ok && /index-url/i.test(r.stdout ?? "");
+  }
+  return false;
+}
+
+// A failed step when none of its sources answers, or null when one answers (or it cannot be judged: a proxy, or a
+// mirror set in the tool's own configuration).
+function offline(step, kind, { env, runner, py = null }) {
+  const hosts = sources(env)[kind];
+  if (mirrorSet(kind, { py, runner })) return null;
+  const seen = hosts.map((h) => reachable(h, { env, runner }));
+  if (!seen.every((x) => x === false)) return null;
+  return { step, ok: false, why: `오프라인이라 설치하지 않음(${hosts.join(", ")} 에 닿지 않음)` };
+}
+
+const lastLine = (text) => text.trim().split(/\r?\n/).filter(Boolean).pop() ?? "";
+
+/** The cache folder for the virtual environment. */
+export function cacheHome(env = process.env) {
+  if (env.MOTION_SITES_HOME) return env.MOTION_SITES_HOME;
+  const base = WIN ? env.LOCALAPPDATA || join(homedir(), "AppData", "Local") : join(homedir(), ".cache");
+  return join(base, "banker", "motion-sites");
+}
+
+const venvPython = (env) => join(cacheHome(env), "venv", WIN ? "Scripts" : "bin", WIN ? "python.exe" : "python");
+
+/** The plugin for Claude Code: { file (its SKILL.md, or null), disabled (installed but turned off) }. */
+export function claudePlugin(runner = run) {
+  const none = { file: null, disabled: false };
+  const r = runner("claude", ["plugin", "list", "--json"]);
+  if (!r.ok) return none;
+  let list;
+  try {
+    list = JSON.parse(r.stdout);
+  } catch {
+    return none;
+  }
+  const p = Array.isArray(list) ? list.find((x) => x?.id === ID) : null;
+  const file = p?.installPath ? join(p.installPath, "skills", PLUGIN, "SKILL.md") : null;
+  if (!file || !existsSync(file)) return none;
+  return p.enabled === false ? { file: null, disabled: true } : { file, disabled: false };
+}
+
+export const claudeSkill = (runner = run) => claudePlugin(runner).file;
+
+/**
+ * The plugin for Codex: { file, disabled }. Installed means its table in config.toml (the body runs to the next table
+ * header, so an array value holding "[" does not cut it short) and a version in the cache; the newest version's
+ * SKILL.md is the file. enabled = false is disabled.
+ */
+export function codexPlugin(env = process.env) {
+  const none = { file: null, disabled: false };
+  const home = env.CODEX_HOME || join(homedir(), ".codex");
+  let toml = "";
+  try {
+    toml = readFileSync(join(home, "config.toml"), "utf8");
+  } catch {
+    return none;
+  }
+  const head = `[plugins."${ID}"]`.replace(/[.[\]"]/g, "\\$&");
+  const table = new RegExp(`^${head}[ \\t]*\\r?\\n([\\s\\S]*?)(?=^[ \\t]*\\[|(?![\\s\\S]))`, "m").exec(toml);
+  if (!table) return none;
+  const dir = join(home, "plugins", "cache", MARKET, PLUGIN);
+  let versions = [];
+  try {
+    versions = readdirSync(dir).sort(byVersion);
+  } catch {
+    return none;
+  }
+  const file = versions.map((v) => join(dir, v, "skills", PLUGIN, "SKILL.md")).reverse().find((f) => existsSync(f));
+  if (!file) return none;
+  return /^[ \t]*enabled[ \t]*=[ \t]*false\b/m.test(table[1]) ? { file: null, disabled: true } : { file, disabled: false };
+}
+
+export const codexSkill = (env = process.env) => codexPlugin(env).file;
+
+export function byVersion(a, b) {
+  const pa = a.split(/[.-]/).map((x) => (/^\d+$/.test(x) ? Number(x) : x));
+  const pb = b.split(/[.-]/).map((x) => (/^\d+$/.test(x) ? Number(x) : x));
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if (pa[i] === pb[i]) continue;
+    // 2.0.0-rc1 comes before 2.0.0 (a pre-release tail), 2.0.0.1 after it
+    if (pa[i] === undefined) return typeof pb[i] === "string" ? 1 : -1;
+    if (pb[i] === undefined) return typeof pa[i] === "string" ? -1 : 1;
+    return typeof pa[i] === "number" && typeof pb[i] === "number" ? pa[i] - pb[i] : String(pa[i]).localeCompare(String(pb[i]));
+  }
+  return 0;
+}
+
+/** Python programs to try, in order: MOTION_SITES_PYTHON, the cache's virtual environment, then the system's. */
+export function pythons(env = process.env) {
+  const list = [];
+  // a relative path is made absolute here, as programs start in the home folder
+  if (env.MOTION_SITES_PYTHON) list.push([isAbsolute(env.MOTION_SITES_PYTHON) ? env.MOTION_SITES_PYTHON : resolve(env.MOTION_SITES_PYTHON)]);
+  list.push([venvPython(env)]);
+  if (WIN) list.push(["py", "-3"], ["python"]);
+  else list.push(["python3"], ["python"]);
+  return list;
+}
+
+const CHROMIUM = "from playwright.sync_api import sync_playwright as s\np=s().start()\nprint(p.chromium.executable_path)\np.stop()";
+
+/** What one Python has: { bin, playwright, chromium } or null when it does not run. */
+export function lookPython(py, runner = run) {
+  const [cmd, ...pre] = py;
+  if (/[\\/]/.test(cmd) && !existsSync(cmd)) return null;
+  const v = runner(cmd, [...pre, "-c", "import sys;print(sys.executable)"]);
+  if (!v.ok) return null;
+  const bin = lastLine(v.stdout ?? "");
+  const pw = runner(cmd, [...pre, "-c", "import playwright"]).ok;
+  const exe = pw ? runner(cmd, [...pre, "-c", CHROMIUM]) : { ok: false, stdout: "" };
+  const chrome = lastLine(exe.stdout ?? "");
+  return { bin, cmd: py, playwright: pw, chromium: exe.ok && chrome !== "" && existsSync(chrome) };
+}
+
+/** The first Python with Playwright (and Chromium, when one has both), else the first that runs. */
+export function pickPython(env = process.env, runner = run) {
+  const seen = pythons(env).map((p) => lookPython(p, runner)).filter(Boolean);
+  return seen.find((p) => p.playwright && p.chromium) ?? seen.find((p) => p.playwright) ?? seen[0] ?? null;
+}
+
+/** status: the plugin and the Python, and whether /motion-sites can hand over now. */
+export function status(runtime, { env = process.env, runner = run } = {}) {
+  const p = runtime === "claude" ? claudePlugin(runner) : codexPlugin(env);
+  const py = pickPython(env, runner);
+  const python = py ? { bin: py.bin, playwright: py.playwright, chromium: py.chromium } : null;
+  return { runtime, plugin: ID, skillFile: p.file, disabled: p.disabled, python, ready: Boolean(p.file && py?.playwright && py?.chromium) };
+}
+
+/**
+ * The plugin steps of one runtime: marketplace add, then install. An add that fails (the marketplace may be there
+ * already) is reported only when the install fails too.
+ */
+function installPlugin(runtime, env, runner) {
+  const down = offline("marketplace add", "plugin", { env, runner });
+  if (down) return [down];
+  const cli = runtime === "claude" ? "claude" : "codex";
+  const add = runner(cli, ["plugin", "marketplace", "add", REPO], { timeout: STEP_MS });
+  const verb = runtime === "claude" ? "install" : "add";
+  const inst = runner(cli, ["plugin", verb, ID], { timeout: STEP_MS });
+  if (inst.ok) return [{ step: "marketplace add", ok: true }, { step: `plugin ${verb}`, ok: true }];
+  return [{ step: "marketplace add", ok: add.ok, why: add.why }, { step: `plugin ${verb}`, ok: false, why: inst.why }];
+}
+
+/** pip install playwright with this Python, or in a virtual environment when pip refuses the system Python. */
+function installPlaywright(py, env, runner) {
+  const down = offline("pip install playwright", "pip", { env, runner, py: py.cmd });
+  if (down) return { ok: false, why: down.why };
+  const [cmd, ...pre] = py.cmd;
+  const pip = runner(cmd, [...pre, "-m", "pip", "install", "playwright"], { timeout: STEP_MS });
+  if (pip.ok) return { ok: true, py: py.cmd };
+  if (!/externally.managed|No module named pip/i.test(pip.out)) return { ok: false, why: pip.why };
+  const venv = runner(cmd, [...pre, "-m", "venv", join(cacheHome(env), "venv")], { timeout: STEP_MS });
+  if (!venv.ok) return { ok: false, why: `${pip.why}. 가상 환경도 만들지 못함: ${venv.why}` };
+  const inVenv = runner(venvPython(env), ["-m", "pip", "install", "playwright"], { timeout: STEP_MS });
+  return inVenv.ok ? { ok: true, py: [venvPython(env)] } : { ok: false, why: inVenv.why };
+}
+
+/** A plugin installed but turned off: Claude Code turns it on; Codex has no command for it, so it says where. */
+function enablePlugin(runtime, runner) {
+  if (runtime === "codex") return { step: "plugin enable", ok: false, why: `Codex 설정에서 꺼져 있음: config.toml 의 [plugins."${ID}"] 를 enabled = true 로` };
+  const r = runner("claude", ["plugin", "enable", ID]);
+  return { step: "plugin enable", ok: r.ok, why: r.why };
+}
+
+/** The Python steps: Playwright, then Chromium. */
+function installBrowser(env, runner) {
+  let py = pickPython(env, runner);
+  if (!py) return [{ step: "python", ok: false, why: "Python 3 을 찾지 못함(python3, python, Windows 는 py)" }];
+  const steps = [];
+  let cmd = py.cmd;
+  if (!py.playwright) {
+    const pw = installPlaywright(py, env, runner);
+    steps.push({ step: "pip install playwright", ok: pw.ok, why: pw.why ?? null });
+    if (!pw.ok) return steps;
+    cmd = pw.py;
+  }
+  if (!py.chromium) {
+    const down = offline("playwright install chromium", "chromium", { env, runner });
+    if (down) return [...steps, down];
+    const [c, ...pre] = cmd;
+    const ch = runner(c, [...pre, "-m", "playwright", "install", "chromium"], { timeout: STEP_MS });
+    steps.push({ step: "playwright install chromium", ok: ch.ok, why: ch.why });
+  }
+  return steps;
+}
+
+/** setup: the missing steps in order, stopping at the first that fails; then status. */
+export function setup(runtime, { env = process.env, runner = run } = {}) {
+  const before = status(runtime, { env, runner });
+  const steps = [];
+  if (before.disabled) steps.push(enablePlugin(runtime, runner));
+  else if (!before.skillFile) steps.push(...installPlugin(runtime, env, runner));
+  if (steps.every((s) => s.ok) && !(before.python?.playwright && before.python?.chromium)) steps.push(...installBrowser(env, runner));
+  return { steps, ...status(runtime, { env, runner }) };
+}
+
+function parse(argv) {
+  const [cmd, ...rest] = argv;
+  const i = rest.indexOf("--runtime");
+  const runtime = i >= 0 ? rest[i + 1] : undefined;
+  if (!["status", "setup", "path"].includes(cmd)) return { error: USAGE };
+  if (runtime !== "claude" && runtime !== "codex") return { error: `--runtime claude|codex 가 필요함\n${USAGE}` };
+  return { cmd, runtime };
+}
+
+export function main(argv, out = console.log, err = console.error) {
+  if (argv.includes("--help") || argv.includes("-h")) return out(USAGE), 0;
+  const o = parse(argv);
+  if (o.error) return err(o.error), 2;
+  if (o.cmd === "path") {
+    const f = o.runtime === "claude" ? claudeSkill() : codexSkill();
+    if (!f) return err(`설치되지 않음: ${ID}. setup --runtime ${o.runtime} 로 설치`), 1;
+    return out(f), 0;
+  }
+  const r = o.cmd === "setup" ? setup(o.runtime) : status(o.runtime);
+  out(JSON.stringify(r, null, 2));
+  return r.ready ? 0 : 1;
+}
+
+// Run directly (also through a linked path: both sides as real paths).
+const realOf = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+};
+if (process.argv[1] && realOf(process.argv[1]) === realOf(fileURLToPath(import.meta.url))) process.exitCode = main(process.argv.slice(2));

package/skills/omc-patch/scripts/omc-patch.mjs

@@ -21,6 +21,7 @@
  * OS: Windows / macOS / Linux 공통. 런처(apply.cmd, apply.sh)와 배경 문서(README.md)는
  * 킷 배포 폴더에만 있다. 이 파일만 옮겨 쓰는 곳(예: 스킬 폴더)에는 없다.
  */
+import { randomBytes } from "node:crypto";
 import {
   readFileSync, writeFileSync, writeSync, existsSync, copyFileSync, readdirSync,
   unlinkSync, mkdirSync, rmSync, symlinkSync, lstatSync, realpathSync,
@@ -422,7 +423,7 @@ function switchActive(sha) {
 // 줄인 비트는 chmod 가 맞춘다). 만든 뒤에 맞추면 그 사이 기본 권한(0664 등)으로 남이 읽을 수 있다.
 function writeAtomic(file, data, mode, { follow = true } = {}) {
   const real = follow ? realOr(file) : file;
-  const tmp = join(dirname(real), `.${basename(real)}.omc-tmp-${process.pid}`);
+  const tmp = join(dirname(real), `.${basename(real)}.omc-tmp-${process.pid}-${randomBytes(6).toString("hex")}`);
   const m = mode ?? modeOf(real);
   rmSync(tmp, { force: true });
   try {

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

@@ -42,6 +42,7 @@
  * Exit status 1 means nothing was changed; 2 means an unexpected error stopped
  * the command partway, so check `status`.
  */
+import { randomBytes } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import {
   accessSync,
@@ -215,7 +216,7 @@ function linkedFolder(file) {
 // either name is replaced rather than written through, and a write that fails
 // leaves the old file as it was.
 function writeFresh(file, data, mode) {
-  const tmp = `${file}.${process.pid}.tmp`;
+  const tmp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
   rmSync(tmp, { force: true });
   try {
     writeFileSync(tmp, data, { flag: "wx", mode });

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

@@ -33,7 +33,7 @@
  * fix sentPart and bump CACHE_VERSION, so totals cached under the old rules are
  * rebuilt.
  */
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import {
   closeSync,
   fstatSync,
@@ -187,7 +187,7 @@ function saveCache(file, state) {
     const dir = dirname(file);
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     if (!ownedDir(dir)) return; // a folder this account does not control: no cache
-    const tmp = `${file}.${process.pid}.tmp`;
+    const tmp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
     rmSync(tmp, { force: true });
     writeFileSync(tmp, JSON.stringify(state), { flag: "wx", mode: 0o600 });
     renameSync(tmp, file);

package/skills/progress-mon/scripts/pm-adr.mjs

@@ -6,7 +6,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { git, noBom, readRegular, writeAtomic } from './pm-config.mjs';
+import { git, noBom, readRegular, writeAtomic, writeNew } from './pm-config.mjs';
 
 const ADR_FILE = 'adr.json';
 const ADR_CHECK_FILE = 'adr-check.json';
@@ -404,13 +404,16 @@ const stamp = (ms) => {
 };
 
 // 스키마 FAIL 이 남은 adr.json 을 같은 폴더의 adr.json.rejected-<시각>(있으면 -2, -3 ...)으로 옮긴다. 결정 기록을 잃지 않게
-// 지우지 않는다. 새 이름은 COPYFILE_EXCL 로 만들어 있는 파일을 덮지 않고, 사본을 만든 뒤에만 원본을 지운다. 돌려줌: 옮긴 경로.
+// 지우지 않는다. 새 이름은 writeNew 로 만들어 있는 것(끊어진 링크 포함)을 덮거나 따라가지 않고, 사본을 만든 뒤에만 원본을
+// 지운다. 돌려줌: 옮긴 경로.
 function reject(file, now) {
   const base = `${file}.rejected-${stamp(now)}`;
+  const bytes = fs.readFileSync(file);
+  const mode = fs.statSync(file).mode & 0o777; // as COPYFILE_EXCL kept it
   for (let i = 1; ; i++) {
     const dest = i === 1 ? base : `${base}-${i}`;
     try {
-      fs.copyFileSync(file, dest, fs.constants.COPYFILE_EXCL);
+      writeNew(dest, bytes, { mode });
     } catch (e) {
       if (e.code === 'EEXIST') continue;
       throw e;