ccx-native 0.0.1 → 0.1.0

package/ccx/cli/skills.py

@@ -0,0 +1,215 @@
+"""Install the bundled agent skills into agent skill folders.
+
+A wheel carries the skills as package data in ``ccx/_skills``; a source
+checkout or editable install uses the repository's ``skills/`` directory.
+Installs are copies with a marker file, so CCX only ever replaces or removes
+folders it created, and refreshes them after an upgrade.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import sys
+import tempfile
+import uuid
+
+MARKER = ".ccx-skill.json"
+_IGNORE = shutil.ignore_patterns("__pycache__", "*.pyc", MARKER)
+
+
+def skills_dir() -> Path:
+    package = Path(__file__).resolve().parents[1]
+    bundled = package / "_skills"
+    if bundled.is_dir():
+        return bundled
+    return package.parent / "skills"
+
+
+def bundled_skills() -> dict[str, Path]:
+    root = skills_dir()
+    if not root.is_dir():
+        return {}
+    return {p.name: p for p in sorted(root.iterdir()) if (p / "SKILL.md").is_file()}
+
+
+def _digest(folder: Path) -> str:
+    h = hashlib.sha256()
+    for path in sorted(folder.rglob("*")):
+        rel = path.relative_to(folder)
+        if not path.is_file() or rel.name == MARKER or "__pycache__" in rel.parts \
+                or rel.suffix == ".pyc":
+            continue
+        h.update(str(rel).encode() + b"\0" + path.read_bytes() + b"\0")
+    return h.hexdigest()
+
+
+def _claude_skills_dir() -> Path:
+    config = os.environ.get("CLAUDE_CONFIG_DIR")
+    return (Path(config).expanduser() if config else Path.home() / ".claude") / "skills"
+
+
+def _agents_skills_dir() -> Path:
+    return Path.home() / ".agents" / "skills"
+
+
+def _installed(engine: str) -> bool:
+    from ccx.errors import CcxError
+    from ccx.system.engine_binary import resolve_engine_binary
+    try:
+        resolve_engine_binary(engine)
+    except CcxError:
+        return False
+    return True
+
+
+def default_targets() -> list[Path]:
+    """Claude Code's folder, and the shared ~/.agents/skills (Codex and others)."""
+    targets = []
+    if _installed("claude"):
+        targets.append(_claude_skills_dir())
+    agents = _agents_skills_dir()
+    if _installed("codex") or agents.is_dir():
+        targets.append(agents)
+    return targets
+
+
+def _marker(folder: Path) -> dict | None:
+    if folder.is_symlink() or not folder.is_dir():
+        return None
+    try:
+        data = json.loads((folder / MARKER).read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return data if isinstance(data, dict) and data.get("installedBy") == "ccx" else None
+
+
+def _remove(folder: Path) -> None:
+    if folder.is_symlink() or folder.is_file():
+        folder.unlink()
+    elif folder.exists():
+        shutil.rmtree(folder)
+
+
+def _copy(source: Path, dest: Path, digest: str) -> None:
+    """Copy next to dest, then swap it in, so readers never see half a skill."""
+    from ccx.version import ccx_version
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    staging = dest.parent / f".{dest.name}.ccx-{uuid.uuid4().hex[:8]}"
+    shutil.copytree(source, staging, ignore=_IGNORE)
+    (staging / MARKER).write_text(json.dumps(
+        {"installedBy": "ccx", "version": ccx_version(), "digest": digest},
+        indent=2) + "\n", encoding="utf-8")
+    old = None
+    if dest.exists() or dest.is_symlink():
+        old = dest.parent / f".{dest.name}.ccx-old-{uuid.uuid4().hex[:8]}"
+        os.rename(dest, old)
+    os.rename(staging, dest)
+    if old is not None:
+        _remove(old)
+
+
+def install(targets: list[Path], *, force: bool = False) -> list[tuple[str, Path, str]]:
+    rows = []
+    for target in targets:
+        for name, source in bundled_skills().items():
+            dest = target / name
+            digest = _digest(source)
+            marker = _marker(dest)
+            if marker is None and (dest.exists() or dest.is_symlink()) and not force:
+                rows.append(("skipped", dest, "not created by ccx; use --force to replace"))
+                continue
+            if marker is not None and marker.get("digest") == digest:
+                rows.append(("unchanged", dest, ""))
+                continue
+            action = ("updated" if marker is not None
+                      else "replaced" if dest.exists() or dest.is_symlink() else "installed")
+            _copy(source, dest, digest)
+            rows.append((action, dest, ""))
+    return rows
+
+
+def uninstall(targets: list[Path]) -> list[tuple[str, Path, str]]:
+    rows = []
+    for target in targets:
+        for name in bundled_skills():
+            dest = target / name
+            if _marker(dest) is not None:
+                _remove(dest)
+                rows.append(("removed", dest, ""))
+            elif dest.exists() or dest.is_symlink():
+                rows.append(("skipped", dest, "not created by ccx"))
+    return rows
+
+
+def refresh_installed() -> None:
+    """Bring CCX-installed copies in the default folders up to date.
+
+    Runs on ordinary commands after an upgrade. Only marked folders are
+    touched, nothing is created, and any failure leaves things as they were.
+    """
+    try:
+        skills = bundled_skills()
+        stale = []
+        for target in (_claude_skills_dir(), _agents_skills_dir()):
+            for name, source in skills.items():
+                marker = _marker(target / name)
+                if marker is not None and marker.get("digest") != _digest(source):
+                    stale.append((source, target / name))
+        if not stale:
+            return
+        import fcntl
+        lock_path = Path(tempfile.gettempdir()) / f"ccx-skills-{os.getuid()}.lock"
+        with open(lock_path, "a") as lock:
+            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            for source, dest in stale:
+                digest = _digest(source)
+                marker = _marker(dest)
+                if marker is not None and marker.get("digest") != digest:
+                    _copy(source, dest, digest)
+                    sys.stderr.write(f"[ccx] refreshed the {dest.name} skill in {dest.parent}\n")
+    except Exception:
+        return
+
+
+def _print(rows) -> None:
+    home = str(Path.home())
+    for action, path, note in rows:
+        shown = str(path)
+        if shown == home or shown.startswith(home + os.sep):
+            shown = "~" + shown[len(home):]
+        print(f"{action:<10} {shown}" + (f"   ({note})" if note else ""))
+
+
+def _targets(args) -> list[Path]:
+    if getattr(args, "dir", None):
+        return [Path(args.dir).expanduser().resolve()]
+    targets = default_targets()
+    if not targets:
+        sys.stderr.write(
+            "[ccx] skills: neither Claude Code nor Codex was found and ~/.agents/skills "
+            "doesn't exist; pass --dir with your agent's skills folder\n")
+        raise SystemExit(1)
+    return targets
+
+
+def cmd_skills(args) -> None:
+    if not bundled_skills():
+        sys.stderr.write(f"[ccx] skills: no bundled skills found in {skills_dir()}\n")
+        raise SystemExit(1)
+    command = getattr(args, "skills_cmd", None)
+    if command == "install":
+        _print(install(_targets(args), force=args.force))
+    elif command == "uninstall":
+        targets = ([Path(args.dir).expanduser().resolve()] if args.dir
+                   else [_claude_skills_dir(), _agents_skills_dir()])
+        rows = uninstall(targets)
+        if rows:
+            _print(rows)
+        else:
+            print("no ccx-installed skills found")
+    else:
+        args.skills_parser.print_help()

package/ccx/cli/statusline.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import socket
+from pathlib import Path
+import signal
+import subprocess
+import sys
+import time
+
+from ccx.constants import SELF_ENGINE_ENV, SELF_WORKER_ID_ENV
+
+SCHEMA_VERSION = 1
+_MAX_STDIN = 32768
+_USER_COMMAND_TIMEOUT_S = 2.0
+
+
+def _normalize_payload(short: str, payload: dict) -> dict:
+    model = payload.get("model")
+    if not isinstance(model, dict):
+        model = {}
+    cw = payload.get("context_window")
+    if not isinstance(cw, dict):
+        cw = None
+    return {
+        "schemaVersion": SCHEMA_VERSION,
+        "writtenAtMs": int(time.time() * 1000),
+        "short": short,
+        "sessionId": payload.get("session_id"),
+        "model": {
+            "id": model.get("id"),
+            "display_name": model.get("display_name"),
+        },
+        "statuslineVersion": payload.get("version"),
+        "contextWindow": cw,
+        "exceeds200k": payload.get("exceeds_200k_tokens"),
+    }
+
+
+def write_statusline_sidecar(short: str, payload: dict) -> str | None:
+    """Capture only the original owned Claude session's advisory statusline."""
+    from ccx import constants
+    from ccx.store.root import StorageIntegrityError, _write_json, require_ccx_active
+
+    store = require_ccx_active(constants.CCX_ROOT)
+    owner = store.resolve(short)  # Exact global full UUID; never display/short/native.
+    if (owner.engine != "claude"
+            or os.environ.get(SELF_WORKER_ID_ENV) != owner.worker_id
+            or os.environ.get(SELF_ENGINE_ENV) != "claude"):
+        raise StorageIntegrityError("statusline worker binding mismatch")
+    rec = store.record(owner.worker)
+    native = rec.get("native")
+    native_sid = native.get("sessionId") if isinstance(native, dict) else None
+    fingerprint = rec.get("createSha256")
+    if (not isinstance(native_sid, str) or not isinstance(fingerprint, str)
+            or payload.get("session_id") != native_sid):
+        raise StorageIntegrityError("statusline original native session mismatch")
+    original = store.creation_binding(
+        owner.worker, engine="claude", fingerprint=fingerprint,
+    )
+    if not isinstance(original, dict) or original.get("sessionId") != native_sid:
+        raise StorageIntegrityError("statusline original native binding unproven")
+    doc = _normalize_payload(owner.worker_id, payload)
+    with store.lease():
+        current_owner, current = store._owned(owner.worker)
+        if (current_owner != owner or not isinstance(current.get("native"), dict)
+                or current["native"].get("sessionId") != native_sid
+                or current.get("createSha256") != fingerprint):
+            raise StorageIntegrityError("statusline owner changed during capture")
+        with store._gen("workers", "claude", owner.worker_id) as fd:
+            _write_json(fd, "statusline.json", doc)
+    return rec.get("cwd") if isinstance(rec.get("cwd"), str) else None
+
+
+def nudge_statusline_host(short: str, session_id: str) -> None:
+    """One best-effort local wake. The host, not this relay, reads and journals."""
+    from ccx.store.paths import sock_path
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
+            sock.setblocking(False)
+            # Never select/wait for a busy host and never read an ACK.
+            if sock.connect_ex(str(sock_path(short))) != 0:
+                return
+            sock.send((json.dumps({
+                "op": "statusline-updated", "worker_id": short,
+                "session_id": session_id,
+            }) + "\n").encode())
+    except (OSError, ValueError):
+        pass
+
+
+def _configured_statusline(cwd: Path) -> str | None:
+    """Resolve Claude's user -> project -> local command, omitting our sidecar.
+
+    This is a separate projection of the caller's settings. Do not read CCX's
+    generated per-worker ``--settings`` file, which points back at this relay.
+    Later layers override earlier ones, including explicit null/disabled values.
+    """
+    from ccx import constants
+
+    selected = None
+    for path in (constants.CLAUDE_HOME / "settings.json",
+                 cwd / ".claude" / "settings.json",
+                 cwd / ".claude" / "settings.local.json"):
+        try:
+            cfg = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError, UnicodeError):
+            continue
+        if isinstance(cfg, dict) and "statusLine" in cfg:
+            selected = cfg["statusLine"]
+    if not isinstance(selected, dict) or selected.get("type") != "command":
+        return None
+    command = selected.get("command")
+    return command if isinstance(command, str) and command.strip() else None
+
+
+def cmd_statusline_relay(args) -> None:
+    """Capture exact original statusline, then pass stdin to user configuration.
+
+    The user-configured command is unmodified and runs from the owned worker's
+    cwd with the original statusline JSON bytes. Its stderr is not displayed or
+    logged. Any missing configuration, failed command or timeout is fail-open.
+    """
+    try:
+        raw = sys.stdin.read(_MAX_STDIN + 1)
+        if len(raw) > _MAX_STDIN:
+            return
+        payload = json.loads(raw or "{}")
+        if not isinstance(payload, dict):
+            return
+        cwd_string = write_statusline_sidecar(args.short, payload)
+        if not cwd_string:
+            return
+        nudge_statusline_host(args.short, payload.get("session_id"))
+        cwd = Path(cwd_string)
+        command = _configured_statusline(cwd)
+        if command is None:
+            return
+        # Shell commands can launch children/pipelines. Own a fresh process
+        # group and kill the whole group on timeout, not just the shell, so
+        # statusline refreshes never strand a slow background child.
+        child = subprocess.Popen(
+            command, shell=True, cwd=cwd, text=True,
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE, start_new_session=True,
+        )
+        try:
+            stdout, _stderr = child.communicate(input=raw, timeout=_USER_COMMAND_TIMEOUT_S)
+        except subprocess.TimeoutExpired:
+            with contextlib.suppress(OSError):
+                os.killpg(child.pid, signal.SIGKILL)
+            with contextlib.suppress(OSError, subprocess.TimeoutExpired):
+                child.communicate(timeout=1.0)
+            return
+        if child.returncode == 0:
+            sys.stdout.write(stdout)
+    except Exception:
+        pass