opencodekit 0.21.10 → 0.23.0

package/dist/template/.opencode/skill/screenshot/scripts/take_screenshot.py

@@ -1,585 +0,0 @@
-#!/usr/bin/env python3
-"""Cross-platform screenshot helper for Codex skills."""
-
-from __future__ import annotations
-
-import argparse
-import datetime as dt
-import json
-import os
-import platform
-import shutil
-import subprocess
-import tempfile
-from pathlib import Path
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-MAC_PERM_SCRIPT = SCRIPT_DIR / "macos_permissions.swift"
-MAC_PERM_HELPER = SCRIPT_DIR / "ensure_macos_permissions.sh"
-MAC_WINDOW_SCRIPT = SCRIPT_DIR / "macos_window_info.swift"
-MAC_DISPLAY_SCRIPT = SCRIPT_DIR / "macos_display_info.swift"
-TEST_MODE_ENV = "CODEX_SCREENSHOT_TEST_MODE"
-TEST_PLATFORM_ENV = "CODEX_SCREENSHOT_TEST_PLATFORM"
-TEST_WINDOWS_ENV = "CODEX_SCREENSHOT_TEST_WINDOWS"
-TEST_DISPLAYS_ENV = "CODEX_SCREENSHOT_TEST_DISPLAYS"
-TEST_PNG = (
-    b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01"
-    b"\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\x0cIDAT\x08\xd7c"
-    b"\xf8\xff\xff?\x00\x05\xfe\x02\xfeA\xad\x1c\x1c\x00\x00\x00\x00IEND"
-    b"\xaeB`\x82"
-)
-
-
-def parse_region(value: str) -> tuple[int, int, int, int]:
-    parts = [p.strip() for p in value.split(",")]
-    if len(parts) != 4:
-        raise argparse.ArgumentTypeError("region must be x,y,w,h")
-    try:
-        x, y, w, h = (int(p) for p in parts)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError("region values must be integers") from exc
-    if w <= 0 or h <= 0:
-        raise argparse.ArgumentTypeError("region width and height must be positive")
-    return x, y, w, h
-
-
-def test_mode_enabled() -> bool:
-    value = os.environ.get(TEST_MODE_ENV, "")
-    return value.lower() in {"1", "true", "yes", "on"}
-
-
-def normalize_platform(value: str) -> str:
-    lowered = value.strip().lower()
-    if lowered in {"darwin", "mac", "macos", "osx"}:
-        return "Darwin"
-    if lowered in {"linux", "ubuntu"}:
-        return "Linux"
-    if lowered in {"windows", "win"}:
-        return "Windows"
-    return value
-
-
-def test_platform_override() -> str | None:
-    value = os.environ.get(TEST_PLATFORM_ENV)
-    if value:
-        return normalize_platform(value)
-    return None
-
-
-def parse_int_list(value: str) -> list[int]:
-    results: list[int] = []
-    for part in value.split(","):
-        part = part.strip()
-        if not part:
-            continue
-        try:
-            results.append(int(part))
-        except ValueError:
-            continue
-    return results
-
-
-def test_window_ids() -> list[int]:
-    value = os.environ.get(TEST_WINDOWS_ENV, "101,102")
-    ids = parse_int_list(value)
-    return ids or [101]
-
-
-def test_display_ids() -> list[int]:
-    value = os.environ.get(TEST_DISPLAYS_ENV, "1,2")
-    ids = parse_int_list(value)
-    return ids or [1]
-
-
-def write_test_png(path: Path) -> None:
-    ensure_parent(path)
-    path.write_bytes(TEST_PNG)
-
-
-def timestamp() -> str:
-    return dt.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-
-
-def default_filename(fmt: str, prefix: str = "screenshot") -> str:
-    return f"{prefix}-{timestamp()}.{fmt}"
-
-
-def mac_default_dir() -> Path:
-    desktop = Path.home() / "Desktop"
-    try:
-        proc = subprocess.run(
-            ["defaults", "read", "com.apple.screencapture", "location"],
-            check=False,
-            capture_output=True,
-            text=True,
-        )
-        location = proc.stdout.strip()
-        if location:
-            return Path(location).expanduser()
-    except OSError:
-        pass
-    return desktop
-
-
-def default_dir(system: str) -> Path:
-    home = Path.home()
-    if system == "Darwin":
-        return mac_default_dir()
-    if system == "Windows":
-        pictures = home / "Pictures"
-        screenshots = pictures / "Screenshots"
-        if screenshots.exists():
-            return screenshots
-        if pictures.exists():
-            return pictures
-        return home
-    pictures = home / "Pictures"
-    screenshots = pictures / "Screenshots"
-    if screenshots.exists():
-        return screenshots
-    if pictures.exists():
-        return pictures
-    return home
-
-
-def ensure_parent(path: Path) -> None:
-    try:
-        path.parent.mkdir(parents=True, exist_ok=True)
-    except OSError:
-        # Fall back to letting the capture command report a clearer error.
-        pass
-
-
-def resolve_output_path(
-    requested_path: str | None, mode: str, fmt: str, system: str
-) -> Path:
-    if requested_path:
-        path = Path(requested_path).expanduser()
-        if path.exists() and path.is_dir():
-            path = path / default_filename(fmt)
-        elif requested_path.endswith(("/", "\\")) and not path.exists():
-            path.mkdir(parents=True, exist_ok=True)
-            path = path / default_filename(fmt)
-        elif path.suffix == "":
-            path = path.with_suffix(f".{fmt}")
-        ensure_parent(path)
-        return path
-
-    if mode == "temp":
-        tmp_dir = Path(tempfile.gettempdir())
-        tmp_path = tmp_dir / default_filename(fmt, prefix="codex-shot")
-        ensure_parent(tmp_path)
-        return tmp_path
-
-    dest_dir = default_dir(system)
-    dest_path = dest_dir / default_filename(fmt)
-    ensure_parent(dest_path)
-    return dest_path
-
-
-def multi_output_paths(base: Path, suffixes: list[str]) -> list[Path]:
-    if len(suffixes) <= 1:
-        return [base]
-    paths: list[Path] = []
-    for suffix in suffixes:
-        candidate = base.with_name(f"{base.stem}-{suffix}{base.suffix}")
-        ensure_parent(candidate)
-        paths.append(candidate)
-    return paths
-
-
-def run(cmd: list[str]) -> None:
-    try:
-        subprocess.run(cmd, check=True)
-    except FileNotFoundError as exc:
-        raise SystemExit(f"required command not found: {cmd[0]}") from exc
-    except subprocess.CalledProcessError as exc:
-        raise SystemExit(f"command failed ({exc.returncode}): {' '.join(cmd)}") from exc
-
-
-def swift_json(script: Path, extra_args: list[str] | None = None) -> dict:
-    module_cache = Path(tempfile.gettempdir()) / "codex-swift-module-cache"
-    module_cache.mkdir(parents=True, exist_ok=True)
-    cmd = ["swift", "-module-cache-path", str(module_cache), str(script)]
-    if extra_args:
-        cmd.extend(extra_args)
-    try:
-        proc = subprocess.run(cmd, check=True, capture_output=True, text=True)
-    except FileNotFoundError as exc:
-        raise SystemExit("swift not found; install Xcode command line tools") from exc
-    except subprocess.CalledProcessError as exc:
-        stderr = (exc.stderr or "").strip()
-        if "ModuleCache" in stderr and "Operation not permitted" in stderr:
-            raise SystemExit(
-                "swift needs module-cache access; rerun with escalated permissions"
-            ) from exc
-        msg = stderr or (exc.stdout or "").strip() or "swift helper failed"
-        raise SystemExit(msg) from exc
-    try:
-        return json.loads(proc.stdout)
-    except json.JSONDecodeError as exc:
-        raise SystemExit(f"swift helper returned invalid JSON: {proc.stdout.strip()}") from exc
-
-
-def macos_screen_capture_granted(request: bool = False) -> bool:
-    args = ["--request"] if request else []
-    payload = swift_json(MAC_PERM_SCRIPT, args)
-    return bool(payload.get("screenCapture"))
-
-
-def ensure_macos_permissions() -> None:
-    if os.environ.get("CODEX_SANDBOX"):
-        raise SystemExit(
-            "screen capture checks are blocked in the sandbox; rerun with escalated permissions"
-        )
-    if macos_screen_capture_granted():
-        return
-    subprocess.run(["bash", str(MAC_PERM_HELPER)], check=False)
-    if not macos_screen_capture_granted():
-        raise SystemExit(
-            "Screen Recording permission is required; enable it in System Settings and retry"
-        )
-
-
-def activate_app(app: str) -> None:
-    safe_app = app.replace('"', '\\"')
-    script = f'tell application "{safe_app}" to activate'
-    subprocess.run(["osascript", "-e", script], check=False, capture_output=True, text=True)
-
-
-def macos_window_payload(args: argparse.Namespace, frontmost: bool, include_list: bool) -> dict:
-    flags: list[str] = []
-    if frontmost:
-        flags.append("--frontmost")
-    if args.app:
-        flags.extend(["--app", args.app])
-    if args.window_name:
-        flags.extend(["--window-name", args.window_name])
-    if include_list:
-        flags.append("--list")
-    return swift_json(MAC_WINDOW_SCRIPT, flags)
-
-
-def macos_display_indexes() -> list[int]:
-    payload = swift_json(MAC_DISPLAY_SCRIPT)
-    displays = payload.get("displays") or []
-    indexes: list[int] = []
-    for item in displays:
-        try:
-            value = int(item)
-        except (TypeError, ValueError):
-            continue
-        if value > 0:
-            indexes.append(value)
-    return indexes or [1]
-
-
-def macos_window_ids(args: argparse.Namespace, capture_all: bool) -> list[int]:
-    payload = macos_window_payload(
-        args,
-        frontmost=args.active_window,
-        include_list=capture_all,
-    )
-    if capture_all:
-        windows = payload.get("windows") or []
-        ids: list[int] = []
-        for item in windows:
-            win_id = item.get("id")
-            if win_id is None:
-                continue
-            try:
-                ids.append(int(win_id))
-            except (TypeError, ValueError):
-                continue
-        if ids:
-            return ids
-    selected = payload.get("selected") or {}
-    win_id = selected.get("id")
-    if win_id is not None:
-        try:
-            return [int(win_id)]
-        except (TypeError, ValueError):
-            pass
-    raise SystemExit("no matching macOS window found; try --list-windows to inspect ids")
-
-
-def list_macos_windows(args: argparse.Namespace) -> None:
-    payload = macos_window_payload(args, frontmost=args.active_window, include_list=True)
-    windows = payload.get("windows") or []
-    if not windows:
-        print("no matching windows found")
-        return
-    for item in windows:
-        bounds = item.get("bounds") or {}
-        name = item.get("name") or ""
-        width = bounds.get("width", 0)
-        height = bounds.get("height", 0)
-        x = bounds.get("x", 0)
-        y = bounds.get("y", 0)
-        print(f"{item.get('id')}\t{item.get('owner')}\t{name}\t{width}x{height}+{x}+{y}")
-
-
-def list_test_macos_windows(args: argparse.Namespace) -> None:
-    owner = args.app or "TestApp"
-    name = args.window_name or ""
-    ids = test_window_ids()
-    if args.active_window and ids:
-        ids = [ids[0]]
-    for idx, win_id in enumerate(ids, start=1):
-        window_name = name or f"Window {idx}"
-        print(f"{win_id}\t{owner}\t{window_name}\t800x600+0+0")
-
-
-def resolve_macos_windows(args: argparse.Namespace) -> list[int]:
-    if args.app:
-        activate_app(args.app)
-    capture_all = not args.active_window
-    return macos_window_ids(args, capture_all=capture_all)
-
-
-def resolve_test_macos_windows(args: argparse.Namespace) -> list[int]:
-    ids = test_window_ids()
-    if args.active_window and ids:
-        return [ids[0]]
-    return ids
-
-
-def capture_macos(
-    args: argparse.Namespace,
-    output: Path,
-    *,
-    window_id: int | None = None,
-    display: int | None = None,
-) -> None:
-    cmd = ["screencapture", "-x", f"-t{args.format}"]
-    if args.interactive:
-        cmd.append("-i")
-    if display is not None:
-        cmd.append(f"-D{display}")
-    effective_window_id = window_id if window_id is not None else args.window_id
-    if effective_window_id is not None:
-        cmd.append(f"-l{effective_window_id}")
-    elif args.region is not None:
-        x, y, w, h = args.region
-        cmd.append(f"-R{x},{y},{w},{h}")
-    cmd.append(str(output))
-    run(cmd)
-
-
-def capture_linux(args: argparse.Namespace, output: Path) -> None:
-    scrot = shutil.which("scrot")
-    gnome = shutil.which("gnome-screenshot")
-    imagemagick = shutil.which("import")
-    xdotool = shutil.which("xdotool")
-
-    if args.region is not None:
-        x, y, w, h = args.region
-        if scrot:
-            run(["scrot", "-a", f"{x},{y},{w},{h}", str(output)])
-            return
-        if imagemagick:
-            geometry = f"{w}x{h}+{x}+{y}"
-            run(["import", "-window", "root", "-crop", geometry, str(output)])
-            return
-        raise SystemExit("region capture requires scrot or ImageMagick (import)")
-
-    if args.window_id is not None:
-        if imagemagick:
-            run(["import", "-window", str(args.window_id), str(output)])
-            return
-        raise SystemExit("window-id capture requires ImageMagick (import)")
-
-    if args.active_window:
-        if scrot:
-            run(["scrot", "-u", str(output)])
-            return
-        if gnome:
-            run(["gnome-screenshot", "-w", "-f", str(output)])
-            return
-        if imagemagick and xdotool:
-            win_id = (
-                subprocess.check_output(["xdotool", "getactivewindow"], text=True)
-                .strip()
-            )
-            run(["import", "-window", win_id, str(output)])
-            return
-        raise SystemExit("active-window capture requires scrot, gnome-screenshot, or import+xdotool")
-
-    if scrot:
-        run(["scrot", str(output)])
-        return
-    if gnome:
-        run(["gnome-screenshot", "-f", str(output)])
-        return
-    if imagemagick:
-        run(["import", "-window", "root", str(output)])
-        return
-    raise SystemExit("no supported screenshot tool found (scrot, gnome-screenshot, or import)")
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument(
-        "--path",
-        help="output file path or directory; overrides --mode",
-    )
-    parser.add_argument(
-        "--mode",
-        choices=("default", "temp"),
-        default="default",
-        help="default saves to the OS screenshot location; temp saves to the temp dir",
-    )
-    parser.add_argument(
-        "--format",
-        default="png",
-        help="image format/extension (default: png)",
-    )
-    parser.add_argument(
-        "--app",
-        help="macOS only: capture all matching on-screen windows for this app name",
-    )
-    parser.add_argument(
-        "--window-name",
-        help="macOS only: substring match for a window title (optionally scoped by --app)",
-    )
-    parser.add_argument(
-        "--list-windows",
-        action="store_true",
-        help="macOS only: list matching window ids instead of capturing",
-    )
-    parser.add_argument(
-        "--region",
-        type=parse_region,
-        help="capture region as x,y,w,h (pixel coordinates)",
-    )
-    parser.add_argument(
-        "--window-id",
-        type=int,
-        help="capture a specific window id when supported",
-    )
-    parser.add_argument(
-        "--active-window",
-        action="store_true",
-        help="capture the focused/active window only when supported",
-    )
-    parser.add_argument(
-        "--interactive",
-        action="store_true",
-        help="use interactive selection where the OS tool supports it",
-    )
-    args = parser.parse_args()
-
-    if args.region and args.window_id is not None:
-        raise SystemExit("choose either --region or --window-id, not both")
-    if args.region and args.active_window:
-        raise SystemExit("choose either --region or --active-window, not both")
-    if args.window_id is not None and args.active_window:
-        raise SystemExit("choose either --window-id or --active-window, not both")
-    if args.app and args.window_id is not None:
-        raise SystemExit("choose either --app or --window-id, not both")
-    if args.region and args.app:
-        raise SystemExit("choose either --region or --app, not both")
-    if args.region and args.window_name:
-        raise SystemExit("choose either --region or --window-name, not both")
-    if args.interactive and args.app:
-        raise SystemExit("choose either --interactive or --app, not both")
-    if args.interactive and args.window_name:
-        raise SystemExit("choose either --interactive or --window-name, not both")
-    if args.interactive and args.window_id is not None:
-        raise SystemExit("choose either --interactive or --window-id, not both")
-    if args.interactive and args.active_window:
-        raise SystemExit("choose either --interactive or --active-window, not both")
-    if args.list_windows and (args.region or args.window_id is not None or args.interactive):
-        raise SystemExit("--list-windows only supports --app, --window-name, and --active-window")
-
-    test_mode = test_mode_enabled()
-    system = platform.system()
-    if test_mode:
-        override = test_platform_override()
-        if override:
-            system = override
-    window_ids: list[int] = []
-    display_ids: list[int] = []
-
-    if system != "Darwin" and (args.app or args.window_name or args.list_windows):
-        raise SystemExit("--app/--window-name/--list-windows are supported on macOS only")
-
-    if system == "Darwin":
-        if test_mode:
-            if args.list_windows:
-                list_test_macos_windows(args)
-                return
-            if args.window_id is not None:
-                window_ids = [args.window_id]
-            elif args.app or args.window_name or args.active_window:
-                window_ids = resolve_test_macos_windows(args)
-            elif args.region is None and not args.interactive:
-                display_ids = test_display_ids()
-        else:
-            ensure_macos_permissions()
-            if args.list_windows:
-                list_macos_windows(args)
-                return
-            if args.window_id is not None:
-                window_ids = [args.window_id]
-            elif args.app or args.window_name or args.active_window:
-                window_ids = resolve_macos_windows(args)
-            elif args.region is None and not args.interactive:
-                display_ids = macos_display_indexes()
-
-    output = resolve_output_path(args.path, args.mode, args.format, system)
-
-    if test_mode:
-        if system == "Darwin":
-            if window_ids:
-                suffixes = [f"w{wid}" for wid in window_ids]
-                paths = multi_output_paths(output, suffixes)
-                for path in paths:
-                    write_test_png(path)
-                for path in paths:
-                    print(path)
-                return
-            if len(display_ids) > 1:
-                suffixes = [f"d{did}" for did in display_ids]
-                paths = multi_output_paths(output, suffixes)
-                for path in paths:
-                    write_test_png(path)
-                for path in paths:
-                    print(path)
-                return
-        write_test_png(output)
-        print(output)
-        return
-
-    if system == "Darwin":
-        if window_ids:
-            suffixes = [f"w{wid}" for wid in window_ids]
-            paths = multi_output_paths(output, suffixes)
-            for wid, path in zip(window_ids, paths):
-                capture_macos(args, path, window_id=wid)
-            for path in paths:
-                print(path)
-            return
-        if len(display_ids) > 1:
-            suffixes = [f"d{did}" for did in display_ids]
-            paths = multi_output_paths(output, suffixes)
-            for did, path in zip(display_ids, paths):
-                capture_macos(args, path, display=did)
-            for path in paths:
-                print(path)
-            return
-        capture_macos(args, output)
-    elif system == "Linux":
-        capture_linux(args, output)
-    elif system == "Windows":
-        raise SystemExit(
-            "Windows support lives in scripts/take_screenshot.ps1; run it with PowerShell"
-        )
-    else:
-        raise SystemExit(f"unsupported platform: {system}")
-
-    print(output)
-
-
-if __name__ == "__main__":
-    main()

package/dist/template/.opencode/skill/security-threat-model/SKILL.md

@@ -1,36 +0,0 @@
----
-name: security-threat-model
-description: Use when the user explicitly requests threat modeling for a repo or path, with concrete abuse paths, trust boundaries, and mitigations.
-version: 1.0.0
-tags: [planning, code-quality, research]
-dependencies: []
----
-
-# security-threat-model
-
-Repository-grounded threat modeling for real attack paths and mitigations.
-
-## When to Use
-
-- User explicitly asks for threat modeling
-- User asks for abuse-path analysis, attacker goals, or trust-boundary review
-
-## When NOT to Use
-
-- General code review without threat-model request
-- Pure style/refactor requests
-
-## Workflow
-
-1. Scope system/runtime components from repository evidence
-2. Enumerate trust boundaries, assets, and entry points
-3. Define realistic attacker capabilities
-4. Model concrete abuse paths and rank by impact/likelihood
-5. Validate assumptions with user (1–3 targeted questions)
-6. Recommend mitigations tied to concrete files/components
-7. Write final report to `<repo-name>-threat-model.md`
-
-## References
-
-- `references/prompt-template.md`
-- `references/security-controls-and-assets.md`