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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.1014
+Version: 2.0.1016
 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.1014 → plugin_scanner-2.0.1016}/docs/guard/harness-support.md

@@ -161,5 +161,5 @@ Generated from `src/codex_plugin_scanner/guard/adapters/contracts.py`.
 | `antigravity` | `antigravity` | ❌ | ✅ | ❌ | mcp_tool, prompt |
 | `kimi` | `kimi`, `kimi-code`, `kimi-cli` | ❌ | ✅ | ❌ | shell, prompt |
 | `grok` | `grok`, `grok-build`, `grok-build-cli`, `xai-grok` | ❌ | ✅ | ❌ | shell, prompt, mcp_tool, file_read |
-| `pi` | `pi`, `pi-agent`, `pi-coding-agent`, `omp`, `oh-my-pi` | ✅ | ✅ | ❌ | shell, prompt, mcp_tool, file_read, tool_result |
+| `pi` | `pi`, `pi-agent`, `pi-coding-agent`, `omp`, `oh-my-pi` | ✅ | ✅ | ✅ | shell, prompt, mcp_tool, file_read, tool_result |
 | `zcode` | `zcode`, `zai`, `z-code`, `zai-zcode` | ❌ | ✅ | ❌ | shell, prompt, mcp_tool, file_read |

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.1014"
+version = "2.0.1016"
 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.1014 → plugin_scanner-2.0.1016}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.1014"
+version = "2.0.1016"
 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.1014 → plugin_scanner-2.0.1016}/src/codex_plugin_scanner/guard/adapters/contracts.py

@@ -332,7 +332,7 @@ HARNESS_CONTRACTS: tuple[HarnessProtectionContract, ...] = (
         event_surfaces=("shell", "prompt", "mcp_tool", "file_read", "tool_result"),
         native_approval=True,
         browser_fallback=True,
-        resume_support=False,
+        resume_support=True,
         known_blind_spots=(
             "Pi package install and update flows happen outside the runtime extension bridge, so Guard observes the "
             "configured package surfaces plus the prompt and tool events forwarded by the managed extension."

{plugin_scanner-2.0.1014 → plugin_scanner-2.0.1016}/src/codex_plugin_scanner/guard/approvals.py

@@ -253,6 +253,12 @@ _GENERIC_TOOL_LABELS = frozenset(
         "Grep",
         "WebFetch",
         "TodoWrite",
+        "tool",
+        "mcp",
+        "skill",
+        "bash",
+        "rg",
+        "cat",
         "mcp_tool",
         "package_request",
         "file_read_request",
@@ -1174,7 +1180,7 @@ def wait_for_approval_requests(
     store: GuardStore,
     request_ids: list[str],
     timeout_seconds: int,
-    poll_interval: float = 0.25,
+    poll_interval: float = 0.01,
 ) -> dict[str, object]:
     deadline = time.monotonic() + max(timeout_seconds, 0)
     while True:
@@ -1266,9 +1272,16 @@ def _item_risk_signals(item: dict[str, object], artifact) -> tuple[str, ...]:
 
 def _item_action_envelope_json(item: Mapping[str, object]) -> dict[str, object] | None:
     value = item.get("action_envelope_json")
-    if not isinstance(value, Mapping):
-        return None
-    return {str(key): item_value for key, item_value in value.items() if isinstance(key, str)}
+    if isinstance(value, str) and value.strip():
+        try:
+            import json as _json
+
+            value = _json.loads(value)
+        except (TypeError, ValueError):
+            return None
+    if isinstance(value, Mapping):
+        return {str(key): item_value for key, item_value in value.items() if isinstance(key, str)}
+    return None
 
 
 def _item_decision_v2_json(item: dict[str, object]) -> dict[str, object] | None:

{plugin_scanner-2.0.1014 → plugin_scanner-2.0.1016}/src/codex_plugin_scanner/guard/codex_resume.py

@@ -8,6 +8,14 @@ from datetime import datetime, timezone
 from .codex_app_server import default_codex_app_server_socket_available, resume_codex_thread_for_request
 from .store import GuardStore
 
+
+class ResumeNotSupportedError(ValueError):
+    """Raised when an approval request cannot be resumed automatically."""
+
+    def __init__(self) -> None:
+        super().__init__("resume_not_supported")
+
+
 _THREAD_ID_KEYS = (
     "codex_thread_id",
     "thread_id",
@@ -72,13 +80,13 @@ def retry_request_resume(
     if request is None:
         raise ValueError("not_found")
     if str(request.get("harness")) != "codex":
-        raise ValueError("resume_not_supported")
+        raise ResumeNotSupportedError()
     action = request.get("resolution_action")
     if not isinstance(action, str) or not action:
         raise ValueError("not_resolved")
     resume = get_request_resume_status(store, request_id=request_id, now=now)
     if resume is None:
-        raise ValueError("resume_not_supported")
+        raise ResumeNotSupportedError()
     if action == "block":
         attempt_count = _int_value(resume.get("attempt_count")) + 1
         return _skip_blocked_resume(
@@ -113,7 +121,7 @@ def retry_request_resume(
     )
     refreshed = store.get_request_resume(request_id)
     if refreshed is None:
-        raise ValueError("resume_not_supported")
+        raise ResumeNotSupportedError()
     final = _finalize_resume_attempt(
         store=store,
         request_id=request_id,
@@ -247,7 +255,7 @@ def _finalize_resume_attempt(
         )
         result = store.get_request_resume(request_id)
         if result is None:
-            raise ValueError("resume_not_supported")
+            raise ResumeNotSupportedError()
         return result
 
     raw_result = _dispatch_resume_attempt(
@@ -280,7 +288,7 @@ def _finalize_resume_attempt(
     )
     result = store.get_request_resume(request_id)
     if result is None:
-        raise ValueError("resume_not_supported")
+        raise ResumeNotSupportedError()
     return result
 
 
@@ -308,7 +316,7 @@ def _skip_blocked_resume(
     )
     result = store.get_request_resume(request_id)
     if result is None:
-        raise ValueError("resume_not_supported")
+        raise ResumeNotSupportedError()
     return result
 
 

{plugin_scanner-2.0.1014 → plugin_scanner-2.0.1016}/src/codex_plugin_scanner/guard/daemon/server.py

@@ -83,6 +83,7 @@ from ..cloud_exception_requests import (
     submit_cloud_exception_request,
 )
 from ..codex_resume import (
+    ResumeNotSupportedError,
     defer_request_resume_to_live_hook,
     get_request_resume_status,
     retry_request_resume,
@@ -99,6 +100,7 @@ from ..desktop_notifications import (
     ensure_desktop_notification_setup,
     macos_notification_guidance,
 )
+from ..harness_resume import resume_harness_operation, safe_resume_metadata
 from ..insights_share import publish_insights_share
 from ..local_dashboard_session import LOCAL_DASHBOARD_SESSION_AUDIENCE, build_local_dashboard_session_token
 from ..local_supply_chain import (
@@ -1994,6 +1996,18 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
                 title = self._optional_string(updated_copy.get("title")) or copy["title"]
                 body = self._optional_string(updated_copy.get("body")) or copy["body"]
                 copy = {"title": title, "body": body}
+        elif action in {"allow", "block"}:
+            harness_resume = resume_harness_operation(
+                self.server.store,  # type: ignore[attr-defined]
+                request_id=request_id,
+                action=action,
+                now=_now(),
+            )
+            if harness_resume is not None:
+                updated = self._apply_harness_resume_result(
+                    updated=updated,
+                    harness_resume=harness_resume,
+                )
         updated["copy"] = copy
         updated["retry_hint"] = copy["body"]
         self._write_json(updated)
@@ -2493,16 +2507,37 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
                 "request_id": request_id,
             },
         )
-        self._write_json(
-            {
-                "harness": adapter.harness,
-                "operation": "remote_once",
-                "receipt": receipt,
-                "request_id": request_id,
-                "resolved_request": resolved_request,
-                "status": "completed",
-            }
-        )
+        response_payload: dict[str, object] = {
+            "harness": adapter.harness,
+            "operation": "remote_once",
+            "receipt": receipt,
+            "request_id": request_id,
+            "resolved_request": resolved_request,
+            "status": "completed",
+        }
+        if adapter.harness == "codex":
+            codex_resume = self._codex_resume_after_remote_once(
+                request_id=request_id,
+                action=resolution_action,
+            )
+            if codex_resume is not None:
+                response_payload["codex_resume"] = codex_resume
+                self.server.store.add_event(  # type: ignore[attr-defined]
+                    "codex/thread_resume",
+                    {"request_id": request_id, "action": resolution_action, **codex_resume},
+                    _now(),
+                )
+        else:
+            harness_resume = resume_harness_operation(
+                self.server.store,  # type: ignore[attr-defined]
+                request_id=request_id,
+                action=resolution_action,
+                now=_now(),
+            )
+            if harness_resume is not None:
+                response_payload["harness_resume"] = harness_resume
+                response_payload["harnessResume"] = harness_resume
+        self._write_json(response_payload)
 
     def _handle_audit_remediation(self, action: str, payload: dict[str, object]) -> None:
         if action != "package_shim_path":
@@ -4090,6 +4125,49 @@ class _GuardDaemonHandler(BaseHTTPRequestHandler):
         updated["retry_hint"] = copy["body"]
         return updated
 
+    def _apply_harness_resume_result(
+        self,
+        *,
+        updated: dict[str, object],
+        harness_resume: dict[str, object],
+    ) -> dict[str, object]:
+        updated["harness_resume"] = harness_resume
+        updated["harnessResume"] = harness_resume
+        return updated
+
+    def _codex_resume_after_remote_once(
+        self,
+        *,
+        request_id: str,
+        action: str,
+    ) -> dict[str, object] | None:
+        try:
+            codex_resume = defer_request_resume_to_live_hook(
+                self.server.store,  # type: ignore[attr-defined]
+                request_id=request_id,
+                action=action,
+                now=_now(),
+            )
+            if codex_resume is None:
+                codex_resume = retry_request_resume(
+                    self.server.store,  # type: ignore[attr-defined]
+                    request_id=request_id,
+                    now=_now(),
+                )
+            return safe_resume_metadata(codex_resume)
+        except ResumeNotSupportedError:
+            return {
+                "status": "skipped",
+                "reason": "resume_not_supported",
+                "message": "This Codex request does not expose a supported resume target.",
+            }
+        except ValueError as error:
+            return {
+                "status": "failed",
+                "reason": str(error) or "resume_failed",
+                "message": "HOL Guard could not resume the Codex request after applying the remote decision.",
+            }
+
     def _write_legacy_pairing_disabled(self) -> None:
         self._write_json(
             {

plugin_scanner-2.0.1016/src/codex_plugin_scanner/guard/harness_resume.py

@@ -0,0 +1,123 @@
+"""Non-Codex harness resume helpers for approval resolution."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from contextlib import suppress
+
+from .adapters.contracts import contract_for
+from .store import GuardStore
+
+
+def safe_resume_metadata(resume: Mapping[str, object]) -> dict[str, object]:
+    """Return the public, normalized subset of harness resume metadata."""
+
+    safe: dict[str, object] = {}
+    for source_key, target_key in (
+        ("operationId", "operationId"),
+        ("operation_id", "operationId"),
+        ("harness", "harness"),
+        ("requestId", "requestId"),
+        ("request_id", "requestId"),
+        ("status", "status"),
+        ("reason", "reason"),
+        ("message", "message"),
+        ("attempt_count", "attemptCount"),
+        ("attemptCount", "attemptCount"),
+        ("last_attempt_at", "lastAttemptAt"),
+        ("lastAttemptAt", "lastAttemptAt"),
+        ("sent_at", "sentAt"),
+        ("sentAt", "sentAt"),
+        ("completedAt", "completedAt"),
+        ("completed_at", "completedAt"),
+        ("resolution_action", "resolutionAction"),
+        ("resolutionAction", "resolutionAction"),
+        ("strategy", "strategy"),
+        ("supported", "supported"),
+    ):
+        value = resume.get(source_key)
+        if isinstance(value, str) and value.strip():
+            safe[target_key] = value.strip()
+        elif isinstance(value, (int, float, bool)):
+            safe[target_key] = value
+    return safe
+
+
+def resume_harness_operation(
+    store: GuardStore,
+    *,
+    request_id: str,
+    action: str,
+    now: str,
+) -> dict[str, object] | None:
+    """Mark a waiting non-Codex operation as resumed or blocked."""
+
+    operation = store.get_guard_operation_for_approval_request(request_id)
+    if operation is None:
+        return None
+    canonical_harness = _canonical_harness(operation.get("harness"))
+    if canonical_harness != "pi":
+        return None
+    normalized_action = _normalize_action(action)
+    if normalized_action is None:
+        return None
+    status = "resumed" if normalized_action == "allow" else "blocked"
+    metadata = operation.get("metadata")
+    safe_metadata = dict(metadata) if isinstance(metadata, Mapping) else {}
+    safe_metadata["resume_action"] = normalized_action
+    safe_metadata["resume_completed_at"] = now
+    approval_request_ids = operation.get("approval_request_ids")
+    safe_approval_request_ids = (
+        [str(item) for item in approval_request_ids if isinstance(item, str)]
+        if isinstance(approval_request_ids, list)
+        else [request_id]
+    )
+    updated = store.upsert_guard_operation(
+        operation_id=str(operation["operation_id"]),
+        session_id=str(operation["session_id"]),
+        harness=canonical_harness,
+        operation_type=str(operation["operation_type"]),
+        status=status,
+        approval_request_ids=safe_approval_request_ids,
+        resume_token=str(operation["resume_token"]) if isinstance(operation.get("resume_token"), str) else None,
+        metadata=safe_metadata,
+        now=now,
+    )
+    payload: dict[str, object] = {
+        "operationId": str(updated["operation_id"]),
+        "harness": canonical_harness,
+        "status": status,
+        "action": normalized_action,
+        "completedAt": now,
+    }
+    with suppress(Exception):
+        store.add_event(
+            "harness/operation_resume",
+            {
+                "action": normalized_action,
+                "harness": canonical_harness,
+                "operation_id": str(updated["operation_id"]),
+                "request_id": request_id,
+                "status": status,
+            },
+            now,
+        )
+    return payload
+
+
+def _canonical_harness(value: object) -> str | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    contract = contract_for(value.strip())
+    return contract.harness if contract is not None else value.strip()
+
+
+def _normalize_action(value: object) -> str | None:
+    if not isinstance(value, str):
+        return None
+    normalized = value.strip().replace("_", "-")
+    if normalized in {"allow", "allow-once"} or value.strip() == "allowOnce":
+        return "allow"
+    if normalized in {"block", "deny", "denied", "blocked"}:
+        return "block"
+    return None

{plugin_scanner-2.0.1014 → plugin_scanner-2.0.1016}/src/codex_plugin_scanner/guard/memory_decision_event.py

@@ -13,6 +13,7 @@ event transport — no new outbox table or auth path.
 
 from __future__ import annotations
 
+import json
 from collections.abc import Mapping
 from dataclasses import asdict, dataclass, field
 from typing import Literal
@@ -91,13 +92,26 @@ def resolve_command_display(
     review_command: str | None,
     raw_command: str | None,
     redaction_state: MemoryRedactionState,
+    action_envelope: Mapping[str, object] | None = None,
+    artifact_name: str | None = None,
+    artifact_id: str | None = None,
+    launch_target: str | None = None,
 ) -> str:
     """Return the human-facing command text honoring the redaction policy."""
-    if redaction_state == "withheld":
-        return review_command or "Command withheld"
+    if raw_command and redaction_state in {"disabled", "enabled"}:
+        return raw_command
+    envelope_display = _display_from_action_envelope(action_envelope)
+    if envelope_display is not None:
+        return envelope_display
+    for candidate in (launch_target, artifact_name, artifact_id, review_command):
+        value = _string_or_none(candidate)
+        if value is not None and not _is_approval_wrapper(value) and not _is_generic_fragment(value):
+            return value
     if redaction_state == "enabled":
-        return review_command or "Command redacted"
-    return raw_command or review_command or "Command unavailable"
+        return "Command redacted"
+    if redaction_state == "withheld":
+        return "Command withheld"
+    return "Command unavailable"
 
 
 def build_memory_decision_event(
@@ -133,6 +147,7 @@ def build_memory_decision_event(
     artifact_name = _string_or_none(request.get("artifact_name"))
     artifact_type = _string_or_none(request.get("artifact_type"))
     harness = _string_or_none(request.get("harness"))
+    action_envelope = _mapping_or_none(request.get("action_envelope_json"))
 
     redaction_state = resolve_redaction_state(
         raw_command=raw_command,
@@ -142,6 +157,10 @@ def build_memory_decision_event(
         review_command=review_command,
         raw_command=raw_command,
         redaction_state=redaction_state,
+        action_envelope=action_envelope,
+        artifact_name=artifact_name,
+        artifact_id=artifact_id,
+        launch_target=_string_or_none(request.get("launch_target")),
     )
 
     # Build the fingerprint from the real command when redaction permits it.
@@ -171,7 +190,7 @@ def build_memory_decision_event(
         machine_id=machine_id,
         machine_installation_id=machine_installation_id,
         harness_id=harness,
-        project_id=_string_or_none(request.get("project_id")),
+        project_id=_request_project_identity(request),
         request_id=request_id,
         queue_group_id=_string_or_none(request.get("queue_group_id")),
         action_identity=_string_or_none(request.get("action_identity")),
@@ -220,6 +239,81 @@ def _string_or_none(value: object) -> str | None:
     return None
 
 
+def _mapping_or_none(value: object) -> Mapping[str, object] | None:
+    if isinstance(value, Mapping):
+        return value
+    if not isinstance(value, str) or not value.strip():
+        return None
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError:
+        return None
+    return parsed if isinstance(parsed, Mapping) else None
+
+
+def _request_project_identity(request: Mapping[str, object]) -> str | None:
+    for key in ("project_id", "projectId", "workspace_path", "workspacePath"):
+        value = _string_or_none(request.get(key))
+        if value is not None:
+            return value
+    return None
+
+
+def _display_from_action_envelope(envelope: Mapping[str, object] | None) -> str | None:
+    if envelope is None:
+        return None
+    action_type = _string_or_none(envelope.get("action_type") or envelope.get("actionType"))
+    if action_type in {"file_read", "file_read_request", "file_write", "file_write_request"}:
+        path = _first_string_from_sequence(envelope.get("target_paths") or envelope.get("targetPaths"))
+        if path is None:
+            path = _string_or_none(envelope.get("path") or envelope.get("file_path") or envelope.get("filePath"))
+        if path is not None:
+            verb = "Read" if "read" in action_type else "Write"
+            return f"{verb} {path}"
+    if action_type == "mcp_tool":
+        server = _string_or_none(envelope.get("mcp_server") or envelope.get("mcpServer"))
+        tool = _string_or_none(envelope.get("mcp_tool") or envelope.get("mcpTool") or envelope.get("tool_name"))
+        if server and tool:
+            return f"mcp {server}.{tool}"
+        if tool and not _is_generic_fragment(tool):
+            return f"mcp {tool}"
+    package_manager = _string_or_none(envelope.get("package_manager") or envelope.get("packageManager"))
+    package_name = _string_or_none(envelope.get("package_name") or envelope.get("packageName"))
+    if package_manager and package_name:
+        return f"{package_manager} install {package_name}"
+    url = _string_or_none(
+        envelope.get("url") or envelope.get("uri") or envelope.get("endpoint") or envelope.get("host")
+    )
+    method = _string_or_none(envelope.get("method"))
+    if url and method:
+        return f"{method.upper()} {url}"
+    if url:
+        return url
+    tool_name = _string_or_none(envelope.get("tool_name") or envelope.get("toolName"))
+    if tool_name and not _is_generic_fragment(tool_name):
+        return tool_name
+    return None
+
+
+def _first_string_from_sequence(value: object) -> str | None:
+    if isinstance(value, str):
+        return _string_or_none(value)
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            candidate = _string_or_none(item)
+            if candidate is not None:
+                return candidate
+    return None
+
+
+def _is_approval_wrapper(value: str) -> bool:
+    return value.strip().startswith("hol-guard approvals approve ")
+
+
+def _is_generic_fragment(value: str) -> bool:
+    return value.strip().lower() in {"bash", "rg", "cat", "tool", "mcp", "skill"}
+
+
 def _risk_signals(request: Mapping[str, object]) -> tuple[str, ...]:
     raw = request.get("risk_signals")
     if isinstance(raw, (list, tuple)):

{plugin_scanner-2.0.1014 → plugin_scanner-2.0.1016}/src/codex_plugin_scanner/guard/memory_decision_outbox.py

@@ -50,8 +50,9 @@ def enqueue_memory_decision_event(
         machine_id = _resolve_oauth_machine_id(store) or machine_installation_id
         redaction_enabled = _resolve_redaction_enabled(store)
 
+        enriched_request = _request_with_project_identity(store, request)
         event = build_memory_decision_event(
-            request=request,
+            request=enriched_request,
             action=action,
             scope=scope,
             resolved_at=resolved_at,
@@ -155,6 +156,35 @@ def _resolve_redaction_enabled(store: Any) -> bool:
     return False
 
 
+def _request_with_project_identity(
+    store: Any,
+    request: Mapping[str, object],
+) -> Mapping[str, object]:
+    request_id = request.get("request_id")
+    if not isinstance(request_id, str) or not request_id.strip():
+        return request
+    getter = getattr(store, "get_guard_operation_for_approval_request", None)
+    if not callable(getter):
+        return request
+    try:
+        operation = getter(request_id.strip())
+    except Exception:
+        return request
+    if not isinstance(operation, Mapping):
+        return request
+    metadata = operation.get("metadata")
+    if not isinstance(metadata, Mapping):
+        return request
+    additions: dict[str, object] = {}
+    for key in ("project_id", "projectId", "workspace_path", "workspacePath"):
+        value = metadata.get(key)
+        if isinstance(value, str) and value.strip() and key not in request:
+            additions[key] = value.strip()
+    if not additions:
+        return request
+    return {**dict(request), **additions}
+
+
 def _oauth_credentials(store: Any) -> Mapping[str, object] | None:
     getter = getattr(store, "get_oauth_local_credentials", None)
     if not callable(getter):

{plugin_scanner-2.0.1014 → plugin_scanner-2.0.1016}/src/codex_plugin_scanner/guard/memory_pattern_fingerprint.py

@@ -49,6 +49,11 @@ _GENERIC_FINGERPRINT_LABELS: frozenset[str] = frozenset(
         "irc",
         "github",
         "glob",
+        "tool",
+        "mcp",
+        "skill",
+        "rg",
+        "cat",
         "pi:project:read",
         "pi:project:write",
         "pi:project",
@@ -59,7 +64,7 @@ _GENERIC_FINGERPRINT_LABELS: frozenset[str] = frozenset(
 
 # Commands whose only value is a single generic verb (no concrete target).
 _BARE_COMMAND_VERBS: frozenset[str] = frozenset(
-    {"read", "write", "bash", "grep", "shell", "edit", "eval", "ls", "cat", "echo"}
+    {"read", "write", "bash", "grep", "shell", "edit", "eval", "ls", "echo"}
 )
 
 _PACKAGE_MANAGERS: frozenset[str] = frozenset(