ccx-native 0.0.1 → 0.2.0

package/ccx/system/pipes.py

@@ -0,0 +1,46 @@
+"""Quiet exit when the reader of stdout goes away (`ccx logs | head`).
+
+Standard CLI tools stop silently when the downstream reader closes the pipe.
+Python instead raises ``BrokenPipeError`` on the next write or on the final
+flush at shutdown, which prints a traceback. Entry points wrap their work in
+:func:`quiet_broken_stdout`; only a broken *stdout* is silenced, so an EPIPE
+from a worker socket still surfaces as an error.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import contextmanager
+from typing import Iterator
+
+from ccx.system import oslayer
+
+
+def stdout_reader_gone() -> bool:
+    """True when stdout is a pipe or socket whose reading end has closed."""
+    try:
+        return oslayer.stdout_reader_gone(sys.stdout.fileno())
+    except (AttributeError, OSError, ValueError):
+        return False
+
+
+@contextmanager
+def quiet_broken_stdout() -> Iterator[None]:
+    """Exit 0 without a traceback when stdout's reader has gone away."""
+    try:
+        try:
+            yield
+        finally:
+            sys.stdout.flush()
+    except BrokenPipeError:
+        if not stdout_reader_gone():
+            raise
+        # Point stdout at /dev/null so the interpreter's own shutdown flush of
+        # whatever is still buffered cannot fail again.
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+        os.close(devnull)
+        raise SystemExit(0)
+
+
+__all__ = ["quiet_broken_stdout", "stdout_reader_gone"]

package/ccx/system/private_json.py

@@ -0,0 +1,54 @@
+"""Private JSON files shared by account-level caches and settings."""
+
+from __future__ import annotations
+
+import errno
+import json
+import os
+from pathlib import Path
+import stat
+import tempfile
+
+
+def _open_private_file(path: Path) -> int:
+    """Do not trust a symlink, another owner's file, or a readable private record."""
+    fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+    st = os.fstat(fd)
+    if not stat.S_ISREG(st.st_mode) or st.st_uid != os.getuid() or st.st_mode & 0o077:
+        os.close(fd)
+        raise PermissionError(f"not a private regular file owned by this user: {path}")
+    return fd
+
+
+def _read_private_json(path: Path) -> dict | None:
+    with os.fdopen(_open_private_file(path), "rb") as handle:
+        value = json.load(handle)
+    return value if isinstance(value, dict) else None
+
+
+def _atomic_private_json(path: Path, value: dict) -> None:
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    tmp = None
+    try:
+        fd, tmp = tempfile.mkstemp(prefix=f".{path.name}.", dir=path.parent)
+        with os.fdopen(fd, "w", encoding="utf-8") as out:
+            json.dump(value, out, separators=(",", ":"), allow_nan=False)
+            out.flush()
+            os.fsync(out.fileno())
+        # Never overwrite a planted symlink/foreign file at the final path.
+        try:
+            existing = _open_private_file(path)
+        except FileNotFoundError:
+            pass
+        except OSError as exc:
+            # Replacing a planted symlink itself is safe: os.replace never
+            # follows the destination. Its target is neither read nor written.
+            if exc.errno != errno.ELOOP:
+                raise
+        else:
+            os.close(existing)
+        os.replace(tmp, path)
+        tmp = None
+    finally:
+        if tmp is not None:
+            os.unlink(tmp)

package/ccx/system/sanitize.py

@@ -0,0 +1,43 @@
+"""One sanitizer for every native payload CCX preserves or persists.
+
+Hidden reasoning is the thing CCX must never write down. Both places that keep
+native payloads — the normalized conversation document and the Codex evidence
+journal — have to strip it exactly the same way, so the rule lives here, in a
+module low enough that either can import it without importing the other.
+
+The rule is structural rather than a list of known types: any mapping whose
+``type`` mentions reasoning loses its raw ``content``, at every depth. A future
+item type that nests a reasoning-shaped payload inside itself is covered
+without being anticipated, while the engine's own surfaced ``summary`` — which
+is not hidden — survives.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def is_reasoning_shaped(value: Any) -> bool:
+    """Does this mapping look like it carries chain-of-thought?"""
+    return (
+        isinstance(value, dict)
+        and "reasoning" in str(value.get("type", "")).lower()
+    )
+
+
+def safe_native(value: Any) -> Any:
+    """A copy of one native payload that is safe to persist verbatim."""
+    if isinstance(value, list):
+        return [safe_native(entry) for entry in value]
+    if not isinstance(value, dict):
+        return value
+    hide = is_reasoning_shaped(value)
+    return {
+        key: safe_native(entry)
+        for key, entry in value.items()
+        if not key.startswith("_ccx_")
+        and not (hide and key == "content")
+    }
+
+
+__all__ = ["is_reasoning_shaped", "safe_native"]