opencode-skills-collection 3.1.1 → 3.1.3

package/bundled-skills/remote-gpu-trainer/scripts/run_queue.sh.template

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# Queue iterator for multi-ablation deployment — platform-agnostic.
+#
+# Network-accel hook so every child (incl. the tracker client) inherits it; ":" no-op on a clean box.
+# See references/gotchas_universal.md and references/china-network.md.
+PROXY_HOOK="${PROXY_HOOK:-source /etc/network_turbo}"
+# PROXY_HOOK is an OPERATOR-supplied profile snippet (source a file / module load / export ...), eval'd
+# on purpose to run an arbitrary setup hook. Set it ONLY from your own trusted profile, never from
+# untrusted or remote-derived input.
+eval "${PROXY_HOOK}" 2>/dev/null || true
+#
+# Each queue line: <config_yaml_path> <task> [epochs]   (epochs defaults to 20)
+# Calls $RUN_ONE per line — defaults to $DURABLE_DIR/run_one.sh (the durable/shared mount from
+# profiles/<platform>.md §8). Export DURABLE_DIR, or set RUN_ONE directly if run_one.sh lives elsewhere.
+#
+# Usage: ./run_queue.sh <queue_file> [start_index]
+#   start_index defaults to 1 (run all). Pass N to RESUME from ablation N (principle #8 — see
+#   references/parallel_ablation.md §5).
+#
+# IMPORTANT: tmux/bash loads THIS script into memory at launch. Editing it mid-flight does NOT affect
+# the running queue; only a NEW launch sees changes. Never overwrite it while a queue reads it
+# (references/gotchas_universal.md, never-mutate-inputs-under-a-live-run; principle #6).
+set -u
+
+RUN_ONE="${RUN_ONE:-${DURABLE_DIR:-/root/autodl-fs}/run_one.sh}"   # = <durable mount>/run_one.sh; export DURABLE_DIR (profile §8) or set RUN_ONE directly
+
+# Arg-count guard FIRST — under `set -u`, QUEUE="$1" below would abort with an unbound-variable
+# error before the Usage check could run. Guard so the Usage message is reachable.
+if [ "$#" -lt 1 ]; then
+    echo "Usage: $0 <queue_file> [start_index]"
+    exit 1
+fi
+
+QUEUE="$1"
+START="${2:-1}"
+
+if [ -z "$QUEUE" ] || [ ! -f "$QUEUE" ]; then
+    echo "Usage: $0 <queue_file> [start_index]"
+    exit 1
+fi
+
+HOSTNAME_SHORT=$(hostname -s)
+# Count ablation CELLS only (skip #-comments + blank lines) so $TOTAL and the resume index are
+# CELL numbers, not raw line numbers — `start_index=N` then resumes from ablation N regardless of how
+# many comment/blank lines precede it (the loop below increments i only after the same skip guards).
+TOTAL=$(grep -cvE '^[[:space:]]*(#|$)' "$QUEUE")
+i=0
+fail=0
+failed_names=()
+
+echo "=== Queue $(basename "$QUEUE"): $TOTAL ablations, starting from $START on $HOSTNAME_SHORT ==="
+
+while IFS=$' \t' read -r cfg task epochs; do
+    # Skip comment/blank lines BEFORE counting so i (and the START resume index) count CELLS, not lines.
+    if [ -z "$cfg" ]; then continue; fi
+    case "$cfg" in \#*) continue ;; esac   # skip #-prefixed comment lines
+    i=$((i+1))
+    if [ "$i" -lt "$START" ]; then continue; fi
+
+    EPOCHS="${epochs:-20}"
+    NAME=$(basename "$cfg" .yaml)
+
+    echo "================================================================"
+    echo "[$(date +'%Y-%m-%d %H:%M:%S')] [$i/$TOTAL] STARTING $NAME ($task, ${EPOCHS}ep)"
+    echo "================================================================"
+
+    bash "$RUN_ONE" "$cfg" "$task" "$EPOCHS"
+    RC=$?
+    if [ "$RC" -ne 0 ]; then fail=$((fail+1)); failed_names+=("$NAME"); fi
+
+    echo "[$(date +'%Y-%m-%d %H:%M:%S')] [$i/$TOTAL] FINISHED $NAME (exit=$RC)"
+done < "$QUEUE"
+
+echo "================================================================"
+if [ "$fail" -eq 0 ]; then
+    echo "[$(date +'%Y-%m-%d %H:%M:%S')] === QUEUE DONE on $HOSTNAME_SHORT -- all $TOTAL cell(s) exited 0 ==="
+else
+    echo "[$(date +'%Y-%m-%d %H:%M:%S')] === QUEUE DONE on $HOSTNAME_SHORT -- $fail cell(s) FAILED: ${failed_names[*]} ==="
+fi
+echo "================================================================"
+# Propagate failure: a queue with any failed cell must NOT exit 0, or tmux/patrol
+# automation reads "QUEUE DONE" as success and a broken ablation hides for hours.
+[ "$fail" -eq 0 ] || exit 1

package/bundled-skills/remote-gpu-trainer/scripts/setup-china-mirrors.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+# One-shot China-network setup for a rented GPU box behind the GFW.
+# scp this to the instance, then `source` it (it exports env vars into the CURRENT shell):
+#   scp scripts/setup-china-mirrors.sh <alias>:/root/ && ssh <alias> 'source /root/setup-china-mirrors.sh'
+# Full rationale + the no_proxy trap + the resumable-download ladder: references/china-network.md
+set -u
+
+# 1. HuggingFace -> hf-mirror (drop-in; identical repo IDs). MUST be set BEFORE importing
+#    huggingface_hub / transformers / datasets — they read HF_ENDPOINT at import time.
+export HF_ENDPOINT="${HF_ENDPOINT:-https://hf-mirror.com}"
+# Keep hf_transfer OFF on flaky CN links — documented hang-with-no-error in exactly these conditions.
+export HF_HUB_ENABLE_HF_TRANSFER=0
+
+# 2. Redirect model caches off the small system disk onto the data disk (override DATA_DIR per profile).
+DATA_DIR="${DATA_DIR:-/root/autodl-tmp}"
+export HF_HOME="${HF_HOME:-$DATA_DIR/huggingface}"
+export HF_HUB_CACHE="${HF_HUB_CACHE:-$HF_HOME/hub}"
+export MODELSCOPE_CACHE="${MODELSCOPE_CACHE:-$DATA_DIR/modelscope}"
+mkdir -p "$HF_HOME" "$MODELSCOPE_CACHE"
+
+# 3. pip index -> Tsinghua TUNA (Aliyun / USTC are alternates).
+pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple 2>/dev/null \
+  || export PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple
+
+# 4. no_proxy hygiene — ONLY when an overseas proxy is exported in THIS shell. A proxy that fixes
+#    huggingface.co will route every domestic mirror overseas and break it unless exempted here.
+#    Use leading-dot domains, set BOTH spellings, include loopback.
+if [ -n "${http_proxy:-}${https_proxy:-}" ]; then
+  export no_proxy="127.0.0.1,localhost,.tuna.tsinghua.edu.cn,.aliyuncs.com,.modelscope.cn,.hf-mirror.com"
+  export NO_PROXY="$no_proxy"
+  echo "[setup-china-mirrors] proxy detected -> exempted domestic mirrors via no_proxy"
+fi
+
+echo "[setup-china-mirrors] HF_ENDPOINT=$HF_ENDPOINT  HF_HOME=$HF_HOME"
+echo "[setup-china-mirrors] done. conda: edit ~/.condarc per references/china-network.md (NEVER mirror pytorch-nightly)."

package/bundled-skills/remote-gpu-trainer/scripts/verify_local.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+"""Verify integrity of downloaded ckpt directories.
+
+For each <name>/ in the target dir, check:
+  - best.pth exists
+  - best.pth loads cleanly via torch.load
+  - best.pth contains a weights key ('model_state_dict' / 'model' / 'state_dict')
+  - best_metrics.json exists and is valid JSON
+  - reports best epoch + main metric per ablation
+
+Usage:
+    python verify_local.py <path_to_final_ckpts_dir> [--expect N] [--list-metrics]
+
+Exit code:
+    0 = all OK
+    1 = at least one error, an empty input dir, or a dir count != --expect
+"""
+from __future__ import annotations
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("ckpt_dir", help="Directory containing ablation subdirs (each with best.pth + best_metrics.json)")
+    ap.add_argument("--list-metrics", action="store_true", help="Print per-ablation epoch + main metric")
+    ap.add_argument("--expect", type=int, default=None,
+                    help="Assert exactly N ablation subdirs are present -- guards a teardown gate against a partial/empty pull")
+    ap.add_argument("--allow-pickle", action="store_true",
+                    help="Permit the weights_only=False fallback (executes pickle) for checkpoints you trust -- "
+                         "needed only when a checkpoint pickles non-tensor objects (e.g. an args Namespace); OFF by default")
+    args = ap.parse_args()
+
+    root = Path(args.ckpt_dir)
+    if not root.exists():
+        print(f"ERROR: {root} does not exist")
+        return 1
+    if not root.is_dir():
+        print(f"ERROR: {root} is not a directory")
+        return 1
+
+    # Structural checks BEFORE importing torch: an empty (or short) input must fail
+    # LOUDLY here -- never silently print "OK: 0/0" and return success, which would let
+    # a Phase-5 teardown gate destroy the rented disk having verified nothing
+    # (principle #3: trust the artifact, not a success line; the teardown Iron Law).
+    dirs = sorted([d for d in root.iterdir() if d.is_dir()])
+    if not dirs:
+        print(f"ERROR: no ablation subdirectories found in {root} -- refusing to report success on an empty input")
+        return 1
+    if args.expect is not None and len(dirs) != args.expect:
+        print(f"ERROR: expected {args.expect} ablation dirs but found {len(dirs)} in {root} -- partial/incomplete pull")
+        return 1
+
+    try:
+        import torch
+    except ImportError:
+        print("ERROR: torch not installed in this environment")
+        return 1
+
+    print(f"Found {len(dirs)} ablation dirs in {root}")
+    print()
+
+    ok = 0
+    errors: list[tuple[str, str]] = []
+    metrics_rows: list[tuple[str, int, str]] = []
+    total_size_bytes = 0
+
+    for d in dirs:
+        name = d.name
+        pth = d / "best.pth"
+        metrics_path = d / "best_metrics.json"
+
+        if not pth.exists():
+            errors.append((name, "missing best.pth"))
+            continue
+        if not metrics_path.exists():
+            errors.append((name, "missing best_metrics.json"))
+            continue
+
+        # Load safe-by-default: weights_only=True refuses to execute pickle, so a poisoned or
+        # compromised remote checkpoint cannot run code on the operator's machine. The unsafe
+        # weights_only=False path (which DOES execute pickle) is OPT-IN via --allow-pickle: an attacker
+        # who controls the remote file could otherwise craft one that fails the safe load to FORCE the
+        # fallback, so auto-falling-back would defeat the gate. Pass --allow-pickle ONLY for your own ckpts.
+        try:
+            ckpt = torch.load(pth, map_location="cpu", weights_only=True)
+        except Exception as e_safe:
+            if not args.allow_pickle:
+                errors.append((name, f"safe load (weights_only=True) failed: {str(e_safe)[:70]} "
+                                     "-- re-run with --allow-pickle if this is your own checkpoint"))
+                continue
+            try:
+                print(
+                    f"  [warn] {name}: weights_only=True failed; --allow-pickle set, retrying "
+                    "weights_only=False (executes pickle -- trust this file)"
+                )
+                ckpt = torch.load(pth, map_location="cpu", weights_only=False)
+            except Exception as e:
+                errors.append((name, f"torch.load failed: {str(e)[:100]}"))
+                continue
+
+        if not isinstance(ckpt, dict) or not any(k in ckpt for k in ("model_state_dict", "model", "state_dict")):
+            errors.append((name, "no model/model_state_dict/state_dict key in checkpoint"))
+            continue
+
+        try:
+            with open(metrics_path) as f:
+                m = json.load(f)
+        except Exception as e:
+            errors.append((name, f"best_metrics.json invalid: {str(e)[:80]}"))
+            continue
+
+        epoch = m.get("epoch", "?")
+        if epoch is None:  # {"epoch": null} → .get returns None (not the default); guard the :3 format. `or` would wrongly eat epoch 0.
+            epoch = "?"
+        # Pick main metric (PSNR for recon, mAP50 for det, dice for seg, fall back to loss)
+        main_metric_key = next(
+            (k for k in ["psnr", "mAP50", "dice"] if k in m),
+            "loss",
+        )
+        main_metric_val = m.get(main_metric_key, "?")
+        metrics_rows.append((name, epoch, f"{main_metric_key}={main_metric_val}"))
+
+        total_size_bytes += pth.stat().st_size
+        ok += 1
+
+    print(f"OK: {ok}/{len(dirs)}")
+    print(f"Errors: {len(errors)}")
+    for name, err in errors[:20]:
+        print(f"  - {name}: {err}")
+    print(f"Total best.pth size: {total_size_bytes / 1e9:.1f} GB")
+
+    if args.list_metrics:
+        print()
+        print("=== Per-ablation metrics ===")
+        for name, epoch, metric in metrics_rows:
+            print(f"  {name:40s} epoch={epoch:3} {metric}")
+
+    return 0 if not errors else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/bundled-skills/screenstudio-alt/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: screenstudio-alt
 description: "Open-source headless Screen Studio alternative: auto speed-up of idle, auto-zoom on click clusters, keystroke overlay chips, smoothed synthetic cursor, and 9:16 vertical export that follows the action — post-production for screen recordings from the CLI."
-risk: safe
+risk: critical
 source: community
 source_type: community
 source_repo: connerkward/screenstudio-alternative-skill
@@ -21,6 +21,14 @@ tools:
   - cursor
   - gemini-cli
   - codex-cli
+plugin:
+  targets:
+    codex: blocked
+    claude: blocked
+  setup:
+    type: manual
+    summary: "Screen/input capture requires sensitive local permissions; keep out of plugin-safe bundles."
+    docs: SKILL.md
 ---
 ## When to Use
 

package/bundled-skills/vibecode-production-qa-validator/SKILL.md

@@ -58,7 +58,7 @@ qa:code() { npx tsc --noEmit && npx eslint . --ext .js,.jsx,.ts,.tsx --max-warni
 - [ ] Build log has no errors
 
 ```bash
-qa:build() { npm run build 2>&1 | tee /tmp/qa-build.log && ! grep -qi "error\|failed" /tmp/qa-build.log; }
+qa:build() { local log; log="$(mktemp "${TMPDIR:-/tmp}/qa-build.XXXXXX.log")" || return 1; set -o pipefail; npm run build 2>&1 | tee "$log"; local rc=$?; set +o pipefail; [ "$rc" -eq 0 ] && ! grep -qi "error\|failed" "$log"; local ok=$?; rm -f "$log"; return "$ok"; }
 ```
 
 | Symbol | Meaning |

package/bundled-skills/youtube-notetaker/scripts/serve.py

@@ -21,6 +21,8 @@ arbitrary and kept only so the same artifact HTML works unmodified):
 """
 import argparse, json, os, sys, re, mimetypes, posixpath
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from tempfile import TemporaryDirectory
 
 try:
     import yaml
@@ -29,6 +31,9 @@ except ImportError:
 
 API = "/api/video-deepdives"
 FM_RE = re.compile(r"^---\n(.*?)\n---\n?(.*)$", re.DOTALL)
+SAFE_SLUG_RE = re.compile(r"^[A-Za-z0-9_-]+$")
+SAFE_MEDIA_RE = re.compile(r"^[A-Za-z0-9_.-]+$")
+SAFE_CTYPE_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*/[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*(?:; charset=[A-Za-z0-9._-]+)?$")
 
 
 def split_frontmatter(text):
@@ -45,20 +50,37 @@ def dump_file(meta, body):
     return out + body
 
 
+def library_path(lib, *parts):
+    root = Path(lib).resolve()
+    candidate = root.joinpath(*parts).resolve()
+    try:
+        candidate.relative_to(root)
+    except ValueError:
+        return None
+    return candidate
+
+
+def safe_content_type(ctype):
+    return ctype if isinstance(ctype, str) and SAFE_CTYPE_RE.match(ctype) else "application/octet-stream"
+
+
 def load_item(lib, slug):
-    path = os.path.join(lib, slug + ".md")
-    if not os.path.isfile(path):
+    if not SAFE_SLUG_RE.match(slug):
+        return None
+    path = library_path(lib, slug + ".md")
+    if not path or not path.is_file():
         return None
-    meta, body = split_frontmatter(open(path, encoding="utf-8").read())
+    meta, body = split_frontmatter(path.read_text(encoding="utf-8"))
     return path, meta, body
 
 
 def list_items(lib):
     items = []
-    for fn in sorted(os.listdir(lib)):
-        if not fn.endswith(".md") or fn.startswith("_"):
+    for path in sorted(Path(lib).iterdir()):
+        fn = path.name
+        if not path.is_file() or not fn.endswith(".md") or fn.startswith("_"):
             continue
-        slug = fn[:-3]
+        slug = path.stem
         loaded = load_item(lib, slug)
         if not loaded:
             continue
@@ -74,11 +96,13 @@ def list_items(lib):
 class Handler(BaseHTTPRequestHandler):
     lib = None
     artifact = None
+    write_token = None
 
     def log_message(self, *a):
         pass  # quiet
 
     def _send(self, code, body, ctype="application/json"):
+        ctype = safe_content_type(ctype)
         if isinstance(body, (dict, list)):
             body = json.dumps(body).encode()
         elif isinstance(body, str):
@@ -87,8 +111,8 @@ class Handler(BaseHTTPRequestHandler):
         self.send_header("Content-Type", ctype)
         self.send_header("Content-Length", str(len(body)))
         self.send_header("Access-Control-Allow-Origin", "*")
-        self.send_header("Access-Control-Allow-Methods", "GET, PATCH, OPTIONS")
-        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type, X-Video-Library-Token")
         self.end_headers()
         if self.command != "HEAD":
             self.wfile.write(body)
@@ -110,12 +134,13 @@ class Handler(BaseHTTPRequestHandler):
 
         if path.startswith(API + "/_media/"):
             fn = posixpath.basename(path)  # strip any traversal
-            fp = os.path.join(self.lib, "_media", fn)
-            if not os.path.isfile(fp):
+            if not SAFE_MEDIA_RE.match(fn):
+                return self._send(400, {"error": "bad media name"})
+            fp = library_path(self.lib, "_media", fn)
+            if not fp or not fp.is_file():
                 return self._send(404, {"error": "no such media"})
-            ctype = mimetypes.guess_type(fp)[0] or "application/octet-stream"
-            with open(fp, "rb") as f:
-                return self._send(200, f.read(), ctype)
+            ctype = mimetypes.guess_type(str(fp))[0] or "application/octet-stream"
+            return self._send(200, fp.read_bytes(), ctype)
 
         if path.startswith(API + "/"):
             slug = posixpath.basename(path)
@@ -128,6 +153,10 @@ class Handler(BaseHTTPRequestHandler):
         return self._send(404, {"error": "not found"})
 
     def do_PATCH(self):
+        if not self.write_token:
+            return self._send(403, {"error": "writes disabled"})
+        if self.headers.get("X-Video-Library-Token") != self.write_token:
+            return self._send(403, {"error": "bad write token"})
         path = self.path.split("?", 1)[0].rstrip("/")
         if not path.startswith(API + "/"):
             return self._send(404, {"error": "not found"})
@@ -145,26 +174,46 @@ class Handler(BaseHTTPRequestHandler):
         if not isinstance(fields, dict):
             return self._send(400, {"error": "fields must be an object"})
         meta.update(fields)
-        open(fp, "w", encoding="utf-8").write(dump_file(meta, body))
+        fp.write_text(dump_file(meta, body), encoding="utf-8")
         return self._send(200, {"ok": True, "slug": slug, "updated": list(fields.keys())})
 
 
+def self_test():
+    with TemporaryDirectory() as tmp:
+        root = Path(tmp)
+        (root / "video_1.md").write_text("---\ntitle: Demo\n---\nBody", encoding="utf-8")
+        (root / "_media").mkdir()
+        (root / "_media" / "video_1-slide-01.jpg").write_bytes(b"x")
+        assert load_item(str(root), "video_1")
+        assert load_item(str(root), "../secret") is None
+        assert library_path(str(root), "_media", "../video_1.md") == root.resolve() / "video_1.md"
+        assert safe_content_type("text/html; charset=utf-8") == "text/html; charset=utf-8"
+        assert safe_content_type("text/html\r\nX-Bad: 1") == "application/octet-stream"
+
+
 def main():
     ap = argparse.ArgumentParser()
+    ap.add_argument("--self-test", action="store_true")
     ap.add_argument("--dir", default=os.path.expanduser(os.environ.get("VIDEO_LIBRARY_DIR", "~/video-deepdives")))
     ap.add_argument("--port", type=int, default=int(os.environ.get("VIDEO_LIBRARY_PORT", "8000")))
     ap.add_argument("--host", default="127.0.0.1")
+    ap.add_argument("--write-token", default=os.environ.get("VIDEO_LIBRARY_WRITE_TOKEN"))
     here = os.path.dirname(os.path.abspath(__file__))
     ap.add_argument("--artifact", default=os.path.join(here, "..", "reference", "artifact.html"))
     a = ap.parse_args()
+    if a.self_test:
+        self_test()
+        return
 
     lib = os.path.abspath(os.path.expanduser(a.dir))
     os.makedirs(lib, exist_ok=True)
     Handler.lib = lib
     Handler.artifact = os.path.abspath(a.artifact)
+    Handler.write_token = a.write_token
     n = len([f for f in os.listdir(lib) if f.endswith(".md") and not f.startswith("_")])
     print(f"Library: {lib}  ({n} videos)")
     print(f"Artifact: {Handler.artifact}")
+    print("Writes: " + ("enabled with X-Video-Library-Token" if Handler.write_token else "disabled (set VIDEO_LIBRARY_WRITE_TOKEN to enable PATCH)"))
     print(f"Serving on http://{a.host}:{a.port}/   (Ctrl-C to stop)")
     ThreadingHTTPServer((a.host, a.port), Handler).serve_forever()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",