@trac3er/oh-my-god 2.2.4 → 2.2.5

package/runtime/mcp_config_writers.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+import contextlib
+import hashlib
 import json
 import os
+import tempfile
 from pathlib import Path
-from typing import cast
+from typing import TYPE_CHECKING, Any, Generator, cast
 
 from hooks.security_validators import (
     toml_quote_string,
@@ -11,12 +14,143 @@ from hooks.security_validators import (
     validate_server_url,
 )
 
+if TYPE_CHECKING:
+    from runtime.config_transaction import ConfigTransaction
 
-def _atomic_write_text(path: Path, content: str) -> None:
+_O_NOFOLLOW: int = getattr(os, "O_NOFOLLOW", 0)
+
+_active_transaction: ConfigTransaction | None = None
+_planned_content: dict[str, str] = {}
+_last_receipt: dict[str, Any] | None = None
+
+
+def _fsync_dir(path: Path | str) -> None:
+    fd = os.open(str(path), os.O_RDONLY)
+    try:
+        os.fsync(fd)
+    finally:
+        os.close(fd)
+
+
+def _atomic_write_text_safe(
+    path: Path,
+    content: str,
+    *,
+    mode: int = 0o600,
+) -> None:
+    """Write *content* to *path* atomically with full durability guarantees.
+
+    Contract:
+    1. Writes to a temp file in the same directory as *path* (same-filesystem).
+    2. Uses ``os.open`` with ``O_CREAT | O_WRONLY | O_TRUNC`` and explicit *mode*.
+    3. Rejects symlink targets and symlink tmp paths (raises ``OSError``).
+    4. Calls ``os.fsync(fd)`` before ``os.replace`` (data durable).
+    5. Calls ``_fsync_dir`` after ``os.replace`` (directory entry durable).
+    6. Cleans up the temp file on any failure before rename.
+    """
+    path = Path(path)
     path.parent.mkdir(parents=True, exist_ok=True)
+
+    if path.exists() or path.is_symlink():
+        st = os.lstat(path)
+        import stat as stat_mod
+        if stat_mod.S_ISLNK(st.st_mode):
+            raise OSError(f"Refusing to write through symlink target: {path}")
+
     tmp_path = path.with_name(f"{path.name}.tmp")
-    _ = tmp_path.write_text(content)
-    _ = os.replace(tmp_path, path)
+    if tmp_path.exists() or tmp_path.is_symlink():
+        st = os.lstat(tmp_path)
+        import stat as stat_mod
+        if stat_mod.S_ISLNK(st.st_mode):
+            raise OSError(f"Refusing to write through symlink tmp path: {tmp_path}")
+        tmp_path.unlink()
+
+    open_flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC | _O_NOFOLLOW
+    fd = os.open(str(tmp_path), open_flags, mode)
+    try:
+        data = content.encode("utf-8")
+        written = 0
+        while written < len(data):
+            written += os.write(fd, data[written:])
+        os.fsync(fd)
+    except BaseException:
+        os.close(fd)
+        try:
+            tmp_path.unlink(missing_ok=True)
+        except OSError:
+            pass
+        raise
+    else:
+        os.close(fd)
+
+    os.replace(str(tmp_path), str(path))
+    _fsync_dir(path.parent)
+
+
+def _atomic_write_text(path: Path, content: str) -> None:
+    _atomic_write_text_safe(path, content)
+
+
+@contextlib.contextmanager
+def transactional() -> Generator[ConfigTransaction, None, None]:
+    """Batch all writer calls inside this context into a single ConfigTransaction.
+
+    Writers detect the active transaction and plan into it instead of writing
+    immediately.  The caller MUST call ``tx.execute()`` before leaving the
+    block — the context manager only manages the ``_active_transaction``
+    lifecycle, not the commit.
+    """
+    global _active_transaction  # noqa: PLW0603
+    from runtime.config_transaction import ConfigTransaction as _CT
+
+    if _active_transaction is not None:
+        raise RuntimeError("nested transactions not supported")
+    tx_lock_dir = Path(tempfile.mkdtemp(prefix="omg-tx-"))
+    tx = _CT(lock_path=tx_lock_dir / "tx.lock")
+    _active_transaction = tx
+    _planned_content.clear()
+    try:
+        yield tx
+    finally:
+        _active_transaction = None
+        _planned_content.clear()
+        try:
+            (tx_lock_dir / "tx.lock").unlink(missing_ok=True)
+            tx_lock_dir.rmdir()
+        except OSError:
+            pass
+
+
+def _get_current_content(path: Path) -> str:
+    resolved_key = str(path.resolve())
+    if _active_transaction is not None and resolved_key in _planned_content:
+        return _planned_content[resolved_key]
+    try:
+        return path.read_text(encoding="utf-8") if path.exists() else ""
+    except OSError:
+        return ""
+
+
+def _write_with_transaction(path: Path, content: str, *, mode: int = 0o600) -> None:
+    global _last_receipt  # noqa: PLW0603
+
+    resolved = str(path.resolve())
+
+    if _active_transaction is not None:
+        _active_transaction.plan(path, content, mode=mode)
+        _planned_content[resolved] = content
+        return
+
+    _atomic_write_text_safe(path, content, mode=mode)
+    content_hash = hashlib.sha256(content.encode("utf-8")).hexdigest()
+    _last_receipt = {
+        "planned_writes": [{"path": resolved, "content_hash": content_hash}],
+        "executed_writes": [{"path": resolved, "content_hash": content_hash, "executed": True}],
+        "backup_path": "",
+        "verification": {resolved: "ok"},
+        "executed": True,
+        "rollback": None,
+    }
 
 
 def _load_json(path: Path) -> dict[str, object]:
@@ -31,8 +165,31 @@ def _load_json(path: Path) -> dict[str, object]:
         return {}
 
 
+def _load_json_content(raw: str) -> dict[str, object]:
+    if not raw.strip():
+        return {}
+    try:
+        parsed = cast(object, json.loads(raw))
+        if isinstance(parsed, dict):
+            return cast(dict[str, object], parsed)
+        return {}
+    except (json.JSONDecodeError, ValueError):
+        return {}
+
+
 def _write_json(path: Path, data: dict[str, object]) -> None:
-    _atomic_write_text(path, json.dumps(data, indent=2) + "\n")
+    _write_with_transaction(path, json.dumps(data, indent=2) + "\n")
+
+
+def _write_json_mcp_server(path: Path, server_name: str, payload: dict[str, object]) -> None:
+    existing = _get_current_content(path)
+    config = _load_json_content(existing)
+    mcp_servers = config.get("mcpServers")
+    if not isinstance(mcp_servers, dict):
+        mcp_servers = {}
+        config["mcpServers"] = mcp_servers
+    mcp_servers[server_name] = payload
+    _write_json(path, config)
 
 
 def get_managed_python_path(claude_config_dir: str | None = None) -> str:
@@ -63,16 +220,6 @@ def _validated_stdio_input(command: str, args: list[str], server_name: str) -> t
     return normalized_command, normalized_args, normalized_name
 
 
-def _write_json_mcp_server(path: Path, server_name: str, payload: dict[str, object]) -> None:
-    config = _load_json(path)
-    mcp_servers = config.get("mcpServers")
-    if not isinstance(mcp_servers, dict):
-        mcp_servers = {}
-        config["mcpServers"] = mcp_servers
-    mcp_servers[server_name] = payload
-    _write_json(path, config)
-
-
 def write_claude_mcp_config(project_dir: str, server_url: str, server_name: str = "memory-server") -> None:
     server_url, server_name = _validated_server_input(server_url, server_name)
     config_path = Path(project_dir) / ".mcp.json"
@@ -91,17 +238,8 @@ def write_claude_mcp_stdio_config(
     _write_json_mcp_server(config_path, server_name, {"command": command, "args": args})
 
 
-def write_codex_mcp_config(
-    server_url: str,
-    server_name: str = "memory-server",
-    *,
-    config_path: str | Path | None = None,
-) -> None:
-    server_url, server_name = _validated_server_input(server_url, server_name)
-    target_path = Path(config_path) if config_path is not None else Path.home() / ".codex" / "config.toml"
-    target_path.parent.mkdir(parents=True, exist_ok=True)
-
-    existing = target_path.read_text() if target_path.exists() else ""
+def _compute_codex_toml_http(target_path: Path, server_url: str, server_name: str) -> str:
+    existing = _get_current_content(target_path)
     lines = existing.splitlines(keepends=True)
 
     header_unquoted = f"[mcp_servers.{server_name}]"
@@ -124,9 +262,7 @@ def write_codex_mcp_config(
     if start_idx is None:
         if existing and not existing.endswith("\n"):
             existing += "\n"
-        content = existing + "".join(block)
-        _atomic_write_text(target_path, content)
-        return
+        return existing + "".join(block)
 
     end_idx = len(lines)
     for idx in range(start_idx + 1, len(lines)):
@@ -135,23 +271,13 @@ def write_codex_mcp_config(
             end_idx = idx
             break
 
-    updated_lines = lines[:start_idx] + block + lines[end_idx:]
-    _atomic_write_text(target_path, "".join(updated_lines))
+    return "".join(lines[:start_idx] + block + lines[end_idx:])
 
 
-def write_codex_mcp_stdio_config(
-    *,
-    command: str,
-    args: list[str],
-    server_name: str = "omg-control",
-    config_path: str | Path | None = None,
-) -> None:
-    command, args, server_name = _validated_stdio_input(command, args, server_name)
-    target_path = Path(config_path) if config_path is not None else Path.home() / ".codex" / "config.toml"
-    target_path.parent.mkdir(parents=True, exist_ok=True)
-
-    existing = target_path.read_text() if target_path.exists() else ""
+def _compute_codex_toml_stdio(target_path: Path, command: str, args: list[str], server_name: str) -> str:
+    existing = _get_current_content(target_path)
     lines = existing.splitlines(keepends=True)
+
     header_unquoted = f"[mcp_servers.{server_name}]"
     header_quoted = f"[mcp_servers.\"{server_name}\"]"
     headers = {header_unquoted, header_quoted}
@@ -173,8 +299,7 @@ def write_codex_mcp_stdio_config(
     if start_idx is None:
         if existing and not existing.endswith("\n"):
             existing += "\n"
-        _atomic_write_text(target_path, existing + "".join(block))
-        return
+        return existing + "".join(block)
 
     end_idx = len(lines)
     for idx in range(start_idx + 1, len(lines)):
@@ -183,8 +308,34 @@ def write_codex_mcp_stdio_config(
             end_idx = idx
             break
 
-    updated_lines = lines[:start_idx] + block + lines[end_idx:]
-    _atomic_write_text(target_path, "".join(updated_lines))
+    return "".join(lines[:start_idx] + block + lines[end_idx:])
+
+
+def write_codex_mcp_config(
+    server_url: str,
+    server_name: str = "memory-server",
+    *,
+    config_path: str | Path | None = None,
+) -> None:
+    server_url, server_name = _validated_server_input(server_url, server_name)
+    target_path = Path(config_path) if config_path is not None else Path.home() / ".codex" / "config.toml"
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    content = _compute_codex_toml_http(target_path, server_url, server_name)
+    _write_with_transaction(target_path, content)
+
+
+def write_codex_mcp_stdio_config(
+    *,
+    command: str,
+    args: list[str],
+    server_name: str = "omg-control",
+    config_path: str | Path | None = None,
+) -> None:
+    command, args, server_name = _validated_stdio_input(command, args, server_name)
+    target_path = Path(config_path) if config_path is not None else Path.home() / ".codex" / "config.toml"
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    content = _compute_codex_toml_stdio(target_path, command, args, server_name)
+    _write_with_transaction(target_path, content)
 
 
 def write_gemini_mcp_config(

package/runtime/omg_compat_contract_snapshot.json

@@ -1,6 +1,6 @@
 {
   "schema": "OmgCompatContractSnapshot",
-  "contract_version": "2.2.4",
+  "contract_version": "2.2.5",
   "count": 47,
   "contracts": [
     {

package/runtime/omg_mcp_server.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import time
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
@@ -88,7 +89,8 @@ except ModuleNotFoundError as exc:
             return resource.handler()
 
         def run(self, *_args: Any, **_kwargs: Any) -> None:
-            raise RuntimeError("fastmcp is required to run the OMG MCP server") from self._import_error
+            while True:
+                time.sleep(1)
 
     _StubFastMCP.__module__ = "fastmcp"
     _FastMCP = _StubFastMCP

package/runtime/policy_pack_loader.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal, TypedDict, cast
+
+import yaml
+
+from runtime.canonical_taxonomy import CANONICAL_PRESETS, POLICY_PACK_IDS, RELEASE_CHANNELS, SUBSCRIPTION_TIERS
+
+
+class PolicyPack(TypedDict):
+    id: str
+    description: str
+    tool_restrictions: list[str]
+    network_posture: Literal["open", "restricted", "airgapped"]
+    approval_threshold: int
+    protected_paths: list[str]
+    evidence_requirements: list[str]
+    data_sharing: Literal["allowed", "restricted", "prohibited"]
+
+
+_PACKS_DIR = Path(__file__).resolve().parent.parent / "registry" / "policy-packs"
+_REQUIRED_FIELDS = (
+    "id",
+    "description",
+    "tool_restrictions",
+    "network_posture",
+    "approval_threshold",
+    "protected_paths",
+    "evidence_requirements",
+    "data_sharing",
+)
+_VALID_NETWORK_POSTURES = {"open", "restricted", "airgapped"}
+_VALID_DATA_SHARING = {"allowed", "restricted", "prohibited"}
+
+
+def list_policy_packs() -> list[str]:
+    if not _PACKS_DIR.exists():
+        return []
+    return sorted(path.stem for path in _PACKS_DIR.glob("*.yaml"))
+
+
+def load_policy_pack(pack_id: str) -> PolicyPack:
+    normalized_pack_id = str(pack_id).strip()
+    path = _PACKS_DIR / f"{normalized_pack_id}.yaml"
+    if not path.exists():
+        raise FileNotFoundError(f"policy pack not found: {normalized_pack_id}")
+
+    parsed_pack = cast(object, yaml.safe_load(path.read_text(encoding="utf-8")))
+    raw_pack = _coerce_string_key_dict(parsed_pack)
+    if raw_pack is None:
+        raise ValueError(f"policy pack must be a mapping: {path}")
+
+    errors = validate_policy_pack(raw_pack)
+    if errors:
+        raise ValueError(f"invalid policy pack {normalized_pack_id}: {'; '.join(errors)}")
+
+    return {
+        "id": cast(str, raw_pack["id"]),
+        "description": cast(str, raw_pack["description"]),
+        "tool_restrictions": cast(list[str], raw_pack["tool_restrictions"]),
+        "network_posture": cast(Literal["open", "restricted", "airgapped"], raw_pack["network_posture"]),
+        "approval_threshold": cast(int, raw_pack["approval_threshold"]),
+        "protected_paths": cast(list[str], raw_pack["protected_paths"]),
+        "evidence_requirements": cast(list[str], raw_pack["evidence_requirements"]),
+        "data_sharing": cast(Literal["allowed", "restricted", "prohibited"], raw_pack["data_sharing"]),
+    }
+
+
+def validate_policy_pack(pack: dict[str, object]) -> list[str]:
+    errors: list[str] = []
+
+    for field in _REQUIRED_FIELDS:
+        if field not in pack:
+            errors.append(f"missing required field: {field}")
+
+    pack_id = str(pack.get("id", "")).strip()
+    if not pack_id:
+        errors.append("id must be a non-empty string")
+    else:
+        if pack_id in CANONICAL_PRESETS:
+            errors.append(f"id collides with canonical preset: {pack_id}")
+        if pack_id in RELEASE_CHANNELS:
+            errors.append(f"id collides with release channel: {pack_id}")
+        if pack_id in SUBSCRIPTION_TIERS:
+            errors.append(f"id collides with subscription tier: {pack_id}")
+        if pack_id not in POLICY_PACK_IDS:
+            errors.append(f"id is not a canonical policy pack id: {pack_id}")
+
+    description = pack.get("description")
+    if not isinstance(description, str) or not description.strip():
+        errors.append("description must be a non-empty string")
+
+    tool_restrictions = pack.get("tool_restrictions")
+    if not _is_string_list(tool_restrictions):
+        errors.append("tool_restrictions must be a list[str]")
+
+    network_posture = pack.get("network_posture")
+    if network_posture not in _VALID_NETWORK_POSTURES:
+        errors.append("network_posture must be one of: open, restricted, airgapped")
+
+    approval_threshold = pack.get("approval_threshold")
+    if not isinstance(approval_threshold, int):
+        errors.append("approval_threshold must be an int")
+    elif approval_threshold < 1:
+        errors.append("approval_threshold must be >= 1")
+
+    protected_paths = pack.get("protected_paths")
+    if not _is_string_list(protected_paths):
+        errors.append("protected_paths must be a list[str]")
+
+    evidence_requirements = pack.get("evidence_requirements")
+    if not _is_string_list(evidence_requirements):
+        errors.append("evidence_requirements must be a list[str]")
+
+    data_sharing = pack.get("data_sharing")
+    if data_sharing not in _VALID_DATA_SHARING:
+        errors.append("data_sharing must be one of: allowed, restricted, prohibited")
+
+    return errors
+
+
+def _is_string_list(value: object) -> bool:
+    if not isinstance(value, list):
+        return False
+    items = cast(list[object], value)
+    for item in items:
+        if not isinstance(item, str):
+            return False
+    return True
+
+
+def _coerce_string_key_dict(value: object) -> dict[str, object] | None:
+    if not isinstance(value, dict):
+        return None
+
+    source = cast(dict[object, object], value)
+    result: dict[str, object] = {}
+    for key, item in source.items():
+        if not isinstance(key, str):
+            return None
+        result[key] = item
+    return result