plugin-scanner 2.0.1012__tar.gz → 2.0.1014__tar.gz

{plugin_scanner-2.0.1012 → plugin_scanner-2.0.1014}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.1012
+Version: 2.0.1014
 Summary: Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.1012 → plugin_scanner-2.0.1014}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.1012"
+version = "2.0.1014"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.1012 → plugin_scanner-2.0.1014}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.1012"
+version = "2.0.1014"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.1012 → plugin_scanner-2.0.1014}/scripts/codex-auto-resume-smoke.py

@@ -287,20 +287,21 @@ def _start_fake_codex_app_server(
                         _send_websocket_text(connection, {"id": 2, "result": {"threadId": thread_id}})
                     if message.get("id") == 3:
                         _send_websocket_text(connection, {"id": 3, "result": {"turnId": "turn-smoke"}})
-                        time.sleep(0.05)
-                        _send_websocket_text(
-                            connection,
-                            {
-                                "method": "turn/completed",
-                                "params": {
-                                    "threadId": thread_id,
-                                    "turn": {
-                                        "id": "turn-smoke",
-                                        "status": "completed",
+                        if message.get("method") == "turn/start":
+                            time.sleep(0.05)
+                            _send_websocket_text(
+                                connection,
+                                {
+                                    "method": "turn/completed",
+                                    "params": {
+                                        "threadId": thread_id,
+                                        "turn": {
+                                            "id": "turn-smoke",
+                                            "status": "completed",
+                                        },
                                     },
                                 },
-                            },
-                        )
+                            )
                         break
 
     thread = threading.Thread(target=server, name="codex-app-server-smoke", daemon=True)
@@ -535,6 +536,7 @@ def _queue_pending_request(
         resume_token=f"resume-{request_id}",
         metadata={
             "codex_thread_id": thread_id,
+            "codex_turn_id": "turn-smoke",
             "session_id": thread_id,
             "codex_home": codex_home,
             "codex_app_server_socket": str(socket_path),

{plugin_scanner-2.0.1012 → plugin_scanner-2.0.1014}/src/codex_plugin_scanner/guard/adapters/codex.py

@@ -24,6 +24,7 @@ from ..launcher import merge_guard_launcher_env
 from ..models import GuardArtifact, HarnessDetection
 from ..shims import install_guard_shim, remove_guard_shim
 from .base import HarnessAdapter, HarnessContext, _command_available, _warnings_include_setup_failure
+from .codex_remote_control import codex_remote_launch_environment, guarded_codex_launch_command
 from .mcp_servers import (
     ManagedMcpServer,
     is_guard_proxy_command,
@@ -246,12 +247,14 @@ def _managed_hook_entry(
     *,
     timeout_seconds: int = _MANAGED_HOOK_TIMEOUT_SECONDS,
 ) -> dict[str, object]:
+    environment = merge_guard_launcher_env(pin_package=True)
+    environment.update(codex_remote_launch_environment(context.home_dir))
     return {
         "type": "command",
         "command": _hook_command(context),
         "timeout": timeout_seconds,
         "statusMessage": status_message,
-        "env": merge_guard_launcher_env(pin_package=True),
+        "env": environment,
     }
 
 
@@ -629,6 +632,16 @@ class CodexHarnessAdapter(HarnessAdapter):
     approval_prompt_channel = "native"
     approval_auto_open_browser = False
 
+    def launch_command(self, context: HarnessContext, passthrough_args: list[str]) -> list[str]:
+        return guarded_codex_launch_command(
+            executable=self.resolved_executable(context) or self.executable,
+            home_dir=context.home_dir,
+            passthrough_args=passthrough_args,
+        )
+
+    def launch_environment(self, context: HarnessContext) -> dict[str, str]:
+        return codex_remote_launch_environment(context.home_dir)
+
     @staticmethod
     def _scope_for(context: HarnessContext, path: Path) -> str:
         if context.workspace_dir is not None and path.is_relative_to(context.workspace_dir):

plugin_scanner-2.0.1014/src/codex_plugin_scanner/guard/adapters/codex_remote_control.py

@@ -0,0 +1,237 @@
+"""Launch Codex through its local app-server for same-thread continuation."""
+
+from __future__ import annotations
+
+import os
+import signal
+import socket
+import subprocess
+import time
+from collections.abc import Mapping
+from pathlib import Path
+
+_REMOTE_CONTROL_START_TIMEOUT_SECONDS = 10
+_REMOTE_CONTROL_READY_TIMEOUT_SECONDS = 3.0
+_REMOTE_CONTROL_STOP_TIMEOUT_SECONDS = 1.0
+_REMOTE_INCOMPATIBLE_SUBCOMMANDS = frozenset(
+    {
+        "app-server",
+        "apply",
+        "cloud",
+        "completion",
+        "debug",
+        "doctor",
+        "exec",
+        "exec-server",
+        "features",
+        "help",
+        "login",
+        "logout",
+        "mcp",
+        "mcp-server",
+        "plugin",
+        "remote-control",
+        "review",
+        "sandbox",
+        "update",
+    }
+)
+
+
+def codex_home_for_user(home_dir: Path) -> Path:
+    return home_dir / ".codex"
+
+
+def default_codex_control_socket(home_dir: Path) -> Path:
+    return codex_home_for_user(home_dir) / "app-server-control" / "app-server-control.sock"
+
+
+def guarded_codex_launch_command(
+    *,
+    executable: str,
+    home_dir: Path,
+    passthrough_args: list[str],
+    environ: Mapping[str, str] | None = None,
+) -> list[str]:
+    """Return a remote TUI command when Codex app-server control is available."""
+
+    plain_command = [executable, *passthrough_args]
+    if not _supports_remote_tui(passthrough_args):
+        return plain_command
+    environment = dict(environ or os.environ)
+    codex_home = codex_home_for_user(home_dir)
+    try:
+        codex_home.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        return plain_command
+    environment["HOME"] = str(home_dir)
+    environment["CODEX_HOME"] = str(codex_home)
+    try:
+        result = subprocess.run(
+            [executable, "remote-control", "start", "--json"],
+            capture_output=True,
+            text=True,
+            timeout=_REMOTE_CONTROL_START_TIMEOUT_SECONDS,
+            check=False,
+            env=environment,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        result = None
+    socket_path = default_codex_control_socket(home_dir)
+    managed_daemon_ready = result is not None and result.returncode == 0 and _wait_for_socket(socket_path)
+    if not managed_daemon_ready and not _start_direct_app_server(
+        executable=executable,
+        socket_path=socket_path,
+        environment=environment,
+    ):
+        return plain_command
+    return [executable, "--remote", f"unix://{socket_path}", *passthrough_args]
+
+
+def codex_remote_launch_environment(home_dir: Path) -> dict[str, str]:
+    return {"CODEX_HOME": str(codex_home_for_user(home_dir))}
+
+
+def _supports_remote_tui(passthrough_args: list[str]) -> bool:
+    if any(argument == "--remote" or argument.startswith("--remote=") for argument in passthrough_args):
+        return False
+    if any(argument in {"--help", "-h", "--version", "-V"} for argument in passthrough_args):
+        return False
+    return not any(argument in _REMOTE_INCOMPATIBLE_SUBCOMMANDS for argument in passthrough_args)
+
+
+def _wait_for_socket(socket_path: Path) -> bool:
+    deadline = time.monotonic() + _REMOTE_CONTROL_READY_TIMEOUT_SECONDS
+    while time.monotonic() < deadline:
+        try:
+            if _socket_is_trusted(socket_path) and _socket_is_live(socket_path):
+                return True
+        except OSError:
+            pass
+        time.sleep(0.05)
+    return False
+
+
+def _socket_is_trusted(socket_path: Path) -> bool:
+    getuid = getattr(os, "getuid", None)
+    if not callable(getuid):
+        return False
+    try:
+        stat_result = socket_path.stat()
+        parent_stat = socket_path.parent.stat()
+    except OSError:
+        return False
+    return (
+        socket_path.is_socket()
+        and stat_result.st_uid == getuid()
+        and parent_stat.st_uid == getuid()
+        and parent_stat.st_mode & 0o022 == 0
+    )
+
+
+def _socket_is_live(socket_path: Path) -> bool:
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client:
+            client.settimeout(0.2)
+            client.connect(str(socket_path))
+    except OSError:
+        return False
+    return True
+
+
+def _start_direct_app_server(
+    *,
+    executable: str,
+    socket_path: Path,
+    environment: Mapping[str, str],
+) -> bool:
+    if os.name == "nt":
+        return False
+    if _wait_for_socket(socket_path):
+        return True
+    try:
+        socket_path.parent.mkdir(parents=True, exist_ok=True)
+        socket_path.parent.chmod(0o700)
+        pid_path = socket_path.parent / "hol-guard-app-server.pid"
+        tracked_pid = _tracked_process_pid(pid_path)
+        if tracked_pid is not None:
+            tracked_command = _tracked_process_command(tracked_pid)
+            if tracked_command is None:
+                return False
+            listener_uri = f"unix://{socket_path}"
+            if "app-server" in tracked_command and listener_uri in tracked_command:
+                if _wait_for_socket(socket_path):
+                    return True
+                if not _stop_tracked_process(tracked_pid):
+                    return False
+        process = subprocess.Popen(
+            [executable, "app-server", "--listen", f"unix://{socket_path}"],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            env=dict(environment),
+            start_new_session=True,
+        )
+        pid_path.write_text(str(process.pid), encoding="utf-8")
+        pid_path.chmod(0o600)
+    except OSError:
+        return False
+    return _wait_for_socket(socket_path)
+
+
+def _tracked_process_pid(pid_path: Path) -> int | None:
+    try:
+        pid_text = pid_path.read_text(encoding="utf-8").strip()
+        if not pid_text.isascii() or not pid_text.isdecimal():
+            return None
+        pid = int(pid_text)
+    except (OSError, ValueError):
+        return None
+    try:
+        os.kill(pid, 0)
+    except PermissionError:
+        return pid
+    except OSError:
+        return None
+    return pid
+
+
+def _tracked_process_command(pid: int) -> str | None:
+    proc_cmdline = Path("/proc") / str(pid) / "cmdline"
+    try:
+        command = proc_cmdline.read_bytes().replace(b"\0", b"\n").decode("utf-8", errors="replace").strip()
+        if command:
+            return command
+    except OSError:
+        pass
+    try:
+        result = subprocess.run(
+            ["ps", "-p", str(pid), "-o", "command="],
+            capture_output=True,
+            text=True,
+            timeout=1,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    command = result.stdout.strip()
+    return command if result.returncode == 0 and command else None
+
+
+def _stop_tracked_process(pid: int) -> bool:
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except ProcessLookupError:
+        return True
+    except OSError:
+        return False
+    deadline = time.monotonic() + _REMOTE_CONTROL_STOP_TIMEOUT_SECONDS
+    while time.monotonic() < deadline:
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            return True
+        except OSError:
+            return False
+        time.sleep(0.05)
+    return False

{plugin_scanner-2.0.1012 → plugin_scanner-2.0.1014}/src/codex_plugin_scanner/guard/aibom_cli.py

@@ -266,7 +266,8 @@ _AIBOM_EMPTY_SYNC_RETRY_SECONDS = 2 * 60
 _AIBOM_GUARD_EVENTS_BACKOFF_KEY = "aibom_guard_events_backoff"
 _AIBOM_GUARD_EVENTS_BACKOFF_MINUTES = 5  # matches _GUARD_EVENTS_ENDPOINT_UNAVAILABLE_RETRY_MINUTES
 _AIBOM_SYNC_BATCH_SIZE = 3  # keep each POST under Cloudflare's 100s origin timeout
-_AIBOM_MAX_ITEMS_PER_EVENT = 100  # chunk large snapshots to stay under Cloudflare timeout
+# Guard Cloud queues large projection work; preserve snapshot replacement semantics in transit.
+_AIBOM_MAX_REQUEST_BODY_BYTES = 7_500_000  # stay below the portal's 8 MB request limit
 
 
 def _aware_utc_timestamp(value: str) -> datetime:
@@ -438,31 +439,39 @@ def sync_aibom_snapshots(
         )
         for snapshot in snapshots
     ]
-    events = _chunk_inventory_events(events)
+    event_batches, oversized_events = _batch_inventory_events(events)
+    oversized_statuses: list[dict[str, object]] = [
+        {
+            "eventId": str(event.get("eventId") or ""),
+            "status": "rejected",
+            "reason": "snapshot_too_large",
+        }
+        for event in oversized_events
+    ]
+    if not event_batches:
+        failure_summary: dict[str, object] = {
+            "synced": False,
+            "synced_at": generated_at,
+            "snapshots": len(snapshots),
+            "accepted": 0,
+            "rejected": len(oversized_events),
+            "statuses": oversized_statuses,
+            "partial": False,
+            "reason": "snapshot_too_large",
+            "error": "Guard Cloud AIBOM sync failed because an inventory snapshot exceeds the request limit.",
+        }
+        store.set_sync_payload("aibom_sync_summary", failure_summary, generated_at)
+        return failure_summary
     total_accepted = 0
-    total_rejected = 0
-    all_statuses: list[dict[str, object]] = []
+    total_rejected = len(oversized_events)
+    all_statuses: list[dict[str, object]] = oversized_statuses
     synced_at = generated_at
     batches_sent = 0
+    events_sent = 0
+    syncable_event_count = sum(len(batch) for batch in event_batches)
 
-    # Adaptive batch size: when events were chunked (items >= threshold),
-    # send 1 per POST to stay within Cloudflare's 100s origin timeout.
-    def _event_item_count(e: dict[str, object]) -> int:
-        payload = e.get("payload")
-        if not isinstance(payload, dict):
-            return 0
-        snapshot = payload.get("snapshot")
-        if not isinstance(snapshot, dict):
-            return 0
-        items = snapshot.get("items")
-        return len(items) if isinstance(items, list) else 0
-
-    effective_batch_size = (
-        1 if any(_event_item_count(e) >= _AIBOM_MAX_ITEMS_PER_EVENT for e in events) else _AIBOM_SYNC_BATCH_SIZE
-    )
-    for batch_start in range(0, len(events), effective_batch_size):
-        batch = events[batch_start : batch_start + effective_batch_size]
-        body = json.dumps({"events": batch}).encode("utf-8")
+    for batch in event_batches:
+        body = _inventory_events_request_body(batch)
         request = runner._guard_sync_request(
             resolved_auth_context,
             request_url=sync_url,
@@ -495,35 +504,31 @@ def sync_aibom_snapshots(
                 )
             elif error.code == 404:
                 synced_at = generated_at
+                remaining_events = syncable_event_count - events_sent
                 store.set_sync_payload(
                     _AIBOM_GUARD_EVENTS_BACKOFF_KEY,
                     {
                         "synced_at": synced_at,
-                        "events": len(events) - batch_start,
+                        "events": remaining_events,
                         "accepted": total_accepted,
-                        "skipped": len(events) - batch_start,
+                        "skipped": remaining_events,
                         "sync_skipped": True,
                         "sync_reason": "guard_events_endpoint_unavailable",
                     },
                     synced_at,
                 )
-                if batches_sent > 0:
-                    summary: dict[str, object] = {
-                        "synced": False,
-                        "synced_at": synced_at,
-                        "snapshots": len(snapshots),
-                        "accepted": total_accepted,
-                        "rejected": total_rejected,
-                        "statuses": all_statuses,
-                        "partial": True,
-                        "reason": "guard_events_endpoint_unavailable",
-                    }
-                else:
-                    summary = {
-                        "synced": False,
-                        "skipped": True,
-                        "reason": "guard_events_endpoint_unavailable",
-                    }
+                summary: dict[str, object] = {
+                    "synced": False,
+                    "synced_at": synced_at,
+                    "snapshots": len(snapshots),
+                    "accepted": total_accepted,
+                    "rejected": total_rejected,
+                    "statuses": all_statuses,
+                    "partial": batches_sent > 0 or bool(oversized_events),
+                    "reason": "guard_events_endpoint_unavailable",
+                }
+                if batches_sent == 0:
+                    summary["skipped"] = True
                 store.set_sync_payload("aibom_sync_summary", summary, synced_at)
                 return summary
             failure_summary: dict[str, object] = {
@@ -533,7 +538,7 @@ def sync_aibom_snapshots(
                 "accepted": total_accepted,
                 "rejected": total_rejected,
                 "statuses": all_statuses,
-                "partial": batches_sent > 0,
+                "partial": batches_sent > 0 or bool(oversized_events),
                 "error": "Guard Cloud AIBOM sync failed due to an HTTP error.",
             }
             store.set_sync_payload("aibom_sync_summary", failure_summary, synced_at)
@@ -546,12 +551,13 @@ def sync_aibom_snapshots(
                 "accepted": total_accepted,
                 "rejected": total_rejected,
                 "statuses": all_statuses,
-                "partial": batches_sent > 0,
+                "partial": batches_sent > 0 or bool(oversized_events),
                 "error": "Guard Cloud AIBOM sync failed due to a network error.",
             }
             store.set_sync_payload("aibom_sync_summary", failure_summary, synced_at)
             raise RuntimeError("Guard Cloud AIBOM sync failed due to a network error.") from error
         batches_sent += 1  # noqa: SIM113
+        events_sent += len(batch)
         batch_accepted = payload.get("accepted")
         if isinstance(batch_accepted, int):
             total_accepted += batch_accepted
@@ -572,6 +578,9 @@ def sync_aibom_snapshots(
         "rejected": total_rejected,
         "statuses": all_statuses,
     }
+    if oversized_events:
+        summary["partial"] = True
+        summary["reason"] = "snapshot_too_large"
     store.set_sync_payload("aibom_sync_summary", summary, synced_at)
     return summary
 
@@ -839,60 +848,39 @@ def _inventory_snapshot_event(
     }
 
 
-def _chunk_inventory_events(
-    events: list[dict[str, object]],
-    max_items: int = _AIBOM_MAX_ITEMS_PER_EVENT,
-) -> list[dict[str, object]]:
-    """Split events whose snapshot has too many items into multiple events.
+def _inventory_events_request_body(events: list[dict[str, object]]) -> bytes:
+    return json.dumps({"events": events}).encode("utf-8")
 
-    Large inventories (e.g. Hermes with 486 skills) produce a single event
-    whose serialized payload exceeds 2MB, causing Cloudflare 504 timeouts
-    when the portal processes it synchronously.
 
-    Each chunk becomes a separate event with a unique snapshot_id suffix
-    so the portal treats them as independent snapshots.  The portal's AIBOM
-    projection accumulates items across snapshots for the same agent_id.
-    """
-    result: list[dict[str, object]] = []
+def _batch_inventory_events(
+    events: list[dict[str, object]],
+    *,
+    max_batch_size: int = _AIBOM_SYNC_BATCH_SIZE,
+    max_body_bytes: int = _AIBOM_MAX_REQUEST_BODY_BYTES,
+) -> tuple[list[list[dict[str, object]]], list[dict[str, object]]]:
+    """Batch whole inventory snapshots without changing replacement semantics."""
+    if max_batch_size < 1 or max_body_bytes < 1:
+        raise ValueError("AIBOM request batch limits must be positive.")
+
+    batches: list[list[dict[str, object]]] = []
+    oversized_events: list[dict[str, object]] = []
+    batch: list[dict[str, object]] = []
     for event in events:
-        payload = event.get("payload")
-        if not isinstance(payload, dict):
-            result.append(event)
-            continue
-        snapshot = payload.get("snapshot")
-        if not isinstance(snapshot, dict):
-            result.append(event)
-            continue
-        items = snapshot.get("items")
-        if not isinstance(items, list) or len(items) <= max_items:
-            result.append(event)
+        if len(_inventory_events_request_body([event])) > max_body_bytes:
+            oversized_events.append(event)
             continue
 
-        original_snapshot_id = str(event.get("idempotencyKey") or snapshot.get("snapshotId") or "").strip() or str(
-            uuid.uuid4()
-        )
-        total_chunks = (len(items) + max_items - 1) // max_items
-        for chunk_index in range(total_chunks):
-            chunk_start = chunk_index * max_items
-            chunk_items = items[chunk_start : chunk_start + max_items]
-            # Scope non-item fields (findings, drift, sources, etc.) to the
-            # first chunk only to avoid duplicating them across chunks on the
-            # portal side.  Items are accumulated; metadata is not.
-            chunk_snapshot = {**snapshot, "items": chunk_items}
-            if chunk_index > 0:
-                chunk_snapshot["findings"] = []
-                chunk_snapshot["drift"] = []
-                chunk_snapshot["sources"] = []
-                chunk_snapshot["dockerProofs"] = []
-            chunk_snapshot["snapshotId"] = f"{original_snapshot_id}-chunk-{chunk_index + 1}-of-{total_chunks}"
-            chunk_event = {
-                **event,
-                "eventId": str(uuid.uuid4()),
-                "idempotencyKey": chunk_snapshot["snapshotId"],
-                "payload": {"snapshot": chunk_snapshot},
-            }
-            result.append(chunk_event)
-    return result
+        candidate = [*batch, event]
+        candidate_too_large = len(_inventory_events_request_body(candidate)) > max_body_bytes
+        if batch and (len(candidate) > max_batch_size or candidate_too_large):
+            batches.append(batch)
+            batch = [event]
+        else:
+            batch = candidate
+
+    if batch:
+        batches.append(batch)
+    return batches, oversized_events
 
 
 def _sync_timestamp_from_payload(payload: dict[str, object]) -> str | None: