@trac3er/oh-my-god 2.1.8 → 2.2.2

package/build/lib/runtime/cli_provider.py

@@ -2,19 +2,32 @@
 
 from __future__ import annotations
 
+import os
 import subprocess
 from abc import ABC, abstractmethod
 from typing import Any
+from typing import Mapping
 
 
-def _run_tool(cmd: list[str], *, timeout: int = 30) -> subprocess.CompletedProcess[str]:
+def _run_tool(
+    cmd: list[str],
+    *,
+    timeout: int = 30,
+    cwd: str | None = None,
+    env: Mapping[str, str] | None = None,
+) -> subprocess.CompletedProcess[str]:
     """Run an external tool with a mandatory timeout."""
+    proc_env = os.environ.copy()
+    if env:
+        proc_env.update({key: str(value) for key, value in env.items()})
     return subprocess.run(
         cmd,
         capture_output=True,
         text=True,
         check=False,
         timeout=timeout,
+        cwd=cwd,
+        env=proc_env,
     )
 
 
@@ -53,9 +66,16 @@ class CLIProvider(ABC):
     def write_mcp_config(self, server_url: str, server_name: str = "memory-server") -> None:
         """Write or update MCP server configuration for this provider."""
 
-    def run_tool(self, cmd: list[str], *, timeout: int = 30) -> subprocess.CompletedProcess[str]:
+    def run_tool(
+        self,
+        cmd: list[str],
+        *,
+        timeout: int = 30,
+        cwd: str | None = None,
+        env: Mapping[str, str] | None = None,
+    ) -> subprocess.CompletedProcess[str]:
         """Execute subprocess commands via mandatory timeout helper."""
-        return _run_tool(cmd, timeout=timeout)
+        return _run_tool(cmd, timeout=timeout, cwd=cwd, env=env)
 
 
 _PROVIDER_REGISTRY: dict[str, CLIProvider] = {}

package/build/lib/runtime/compat.py

@@ -16,6 +16,7 @@ from typing import Any
 from hooks.policy_engine import evaluate_bash_command
 from lab.pipeline import run_pipeline
 from runtime.adoption import CANONICAL_VERSION
+from runtime.canonical_surface import get_canonical_hosts, get_compat_hosts
 from runtime.dispatcher import dispatch_runtime
 from runtime.plugin_diagnostics import run_plugin_diagnostics
 from runtime.security_check import run_security_check
@@ -330,11 +331,19 @@ def get_compat_skill_contract(skill: str) -> dict[str, Any] | None:
 
 
 def build_contract_snapshot_payload(*, include_generated_at: bool = True) -> dict[str, Any]:
+    canonical_hosts = get_canonical_hosts()
+    compat_hosts = get_compat_hosts()
     payload: dict[str, Any] = {
         "schema": CONTRACT_SNAPSHOT_SCHEMA,
         "contract_version": CONTRACT_SNAPSHOT_VERSION,
         "count": len(LEGACY_SKILL_CONTRACTS),
         "contracts": list_compat_skill_contracts(),
+        "host_surfaces": {
+            "canonical_parity_hosts": canonical_hosts,
+            "release_blocking_hosts": canonical_hosts,
+            "compatibility_only_hosts": compat_hosts,
+            "release_non_blocking_hosts": compat_hosts,
+        },
     }
     if include_generated_at:
         payload["generated_at"] = _now()

package/build/lib/runtime/compliance_governor.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+import re
 from collections.abc import Mapping
 from typing import Any
 
 from registry.approval_artifact import load_approval_artifact_from_path, verify_approval_artifact
-from registry.verify_artifact import verify_artifact
+from registry.verify_artifact import verify_artifact, verify_tool_attestation
 from runtime.claim_judge import evaluate_claims_for_release
 from runtime.runtime_contracts import read_run_state
 
@@ -17,10 +18,35 @@ _READ_ONLY_TOOL_HINTS = (
     "glob",
     "list",
     "ls",
+)
+_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
+_EXTERNAL_EXECUTION_TOOL_HINTS = (
     "context7",
     "websearch",
+    "web_search",
+    "browser",
+    "playwright",
+    "chrome-devtools",
+)
+_EXTERNAL_BASH_PATTERNS = (
+    re.compile(r"(?:^|[\s;&|()])(curl|wget)\b"),
+    re.compile(r"(?:^|[\s;&|()])(ssh|scp|rsync)\b"),
+    re.compile(r"\bgit\s+(clone|fetch|pull)\b"),
+)
+_MUTATION_BASH_PATTERNS = (
+    r"\b(git\s+(add|commit|push|rebase|cherry-pick|merge|tag))\b",
+    r"\b(rm|mv|cp|tee|touch|mkdir|rmdir|ln)\b",
+    r"\b(sed\s+-i|perl\s+-pi)\b",
+    r"\b(chmod|chown)\b",
+)
+_HARMLESS_REDIRECTION_PATTERNS = (
+    re.compile(r"(?:^|[\s;&|()])\d*>>?\s*/dev/(?:null|stdout|stderr)(?=\s|$)"),
+    re.compile(r"(?:^|[\s;&|()])\d*>&\d+(?=\s|$)"),
+    re.compile(r"(?:^|[\s;&|()])\d*>&-(?=\s|$)"),
+)
+_FILE_WRITE_REDIRECTION_PATTERN = re.compile(
+    r"(?:^|[\s;&|()])\d*>>?(?!\s*(?:/dev/(?:null|stdout|stderr)\b|&\d+\b|&-\b))\s*\S+"
 )
-_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
 
 
 def evaluate_tool_compliance(
@@ -30,18 +56,26 @@ def evaluate_tool_compliance(
     tool: str,
     has_tool_plan: bool,
     clarification_status: dict[str, object] | None = None,
+    tool_input: dict[str, object] | None = None,
 ) -> dict[str, object]:
     clarification = _normalized_clarification_status(clarification_status)
     if clarification["requires_clarification"]:
         reason = _clarification_reason(str(clarification["clarification_prompt"]))
-        if _is_mutation_capable_tool(tool):
+        if _is_mutation_capable_tool(tool, tool_input=tool_input):
             return {
                 "status": "blocked",
                 "authority": "clarification",
                 "reason": reason,
                 "clarification_status": clarification,
             }
-        if _is_read_search_review_tool(tool):
+        if _is_external_execution_tool(tool, tool_input=tool_input):
+            return {
+                "status": "blocked",
+                "authority": "clarification",
+                "reason": _clarification_external_reason(str(clarification["clarification_prompt"])),
+                "clarification_status": clarification,
+            }
+        if _is_read_search_review_tool(tool, tool_input=tool_input):
             return {
                 "status": "allowed",
                 "authority": "clarification",
@@ -101,7 +135,12 @@ def evaluate_release_compliance(
         }
 
     if not isinstance(release_evidence, dict):
-        return {"status": "blocked", "authority": "artifact", "reason": "no release evidence supplied"}
+        return {
+            "status": "blocked",
+            "authority": "release",
+            "reason": "no release evidence supplied",
+            **artifact_audit,
+        }
 
     raw_claims = release_evidence.get("claims")
     claims = raw_claims if isinstance(raw_claims, list) else []
@@ -123,6 +162,53 @@ def evaluate_release_compliance(
     }
 
 
+def evaluate_governed_tool_request(
+    *,
+    project_dir: str,
+    run_id: str,
+    lane_name: str,
+    tool: str,
+    has_tool_plan: bool,
+    attestation_artifact: dict[str, object] | None,
+    require_attestation: bool,
+    clarification_status: dict[str, object] | None = None,
+) -> dict[str, object]:
+    plan_decision = evaluate_tool_compliance(
+        project_dir=project_dir,
+        run_id=run_id,
+        tool=tool,
+        has_tool_plan=has_tool_plan,
+        clarification_status=clarification_status,
+    )
+    if plan_decision.get("status") == "blocked":
+        return plan_decision
+
+    if not require_attestation:
+        return {
+            "status": "allowed",
+            "authority": "governed_tool",
+            "reason": "compliance checks passed without attestation requirement",
+        }
+
+    attestation_decision = verify_tool_attestation(
+        lane_name=lane_name,
+        tool_name=tool,
+        artifact=attestation_artifact,
+        mode="warn_and_run",
+    )
+    if attestation_decision.get("status") == "blocked":
+        return {
+            "status": "blocked",
+            "authority": "artifact",
+            "reason": str(attestation_decision.get("reason", "attestation required")),
+        }
+    return {
+        "status": "allowed",
+        "authority": "governed_tool",
+        "reason": "compliance checks passed",
+    }
+
+
 _UNVERIFIED_ARTIFACT_STATUSES = frozenset({"pending_verification", "insufficient_evidence", "placeholder"})
 
 
@@ -261,17 +347,73 @@ def _clarification_reason(clarification_prompt: str) -> str:
     return "Clarification required before mutation: provide the missing intent details."
 
 
-def _is_mutation_capable_tool(tool: str) -> bool:
+def _clarification_external_reason(clarification_prompt: str) -> str:
+    prompt = " ".join(str(clarification_prompt or "").split())
+    if prompt:
+        return f"Clarification required before external execution: {prompt}"
+    return "Clarification required before external execution: provide the missing intent details."
+
+
+def classify_bash_command_mode(command: str) -> str:
+    normalized_command = str(command or "").strip()
+    if not normalized_command:
+        return "read"
+    if _is_mutation_capable_bash(normalized_command):
+        return "mutation"
+    lowered = normalized_command.lower()
+    for pattern in _EXTERNAL_BASH_PATTERNS:
+        if pattern.search(lowered):
+            return "external"
+    return "read"
+
+
+def _is_mutation_capable_bash(command: str) -> bool:
+    normalized_command = str(command or "").strip()
+    if not normalized_command:
+        return False
+    lowered = _strip_harmless_redirections(normalized_command.lower())
+    for pattern in _MUTATION_BASH_PATTERNS:
+        if re.search(pattern, lowered):
+            return True
+    if _FILE_WRITE_REDIRECTION_PATTERN.search(lowered):
+        return True
+    return False
+
+
+def _strip_harmless_redirections(command: str) -> str:
+    sanitized = command
+    for pattern in _HARMLESS_REDIRECTION_PATTERNS:
+        sanitized = pattern.sub(" ", sanitized)
+    return re.sub(r"\s+", " ", sanitized).strip()
+
+
+def _is_mutation_capable_tool(tool: str, *, tool_input: dict[str, object] | None = None) -> bool:
     token = str(tool or "").strip().lower()
+    if token == "bash":
+        mode = classify_bash_command_mode(str((tool_input or {}).get("command", "")))
+        return mode == "mutation"
     if token in _MUTATION_TOOLS:
         return True
-    return token.startswith("bash:")
+    return token == "bash:mutation"
+
+
+def _is_external_execution_tool(tool: str, *, tool_input: dict[str, object] | None = None) -> bool:
+    token = str(tool or "").strip().lower()
+    if token == "bash":
+        mode = classify_bash_command_mode(str((tool_input or {}).get("command", "")))
+        return mode == "external"
+    if token == "bash:external":
+        return True
+    return any(hint in token for hint in _EXTERNAL_EXECUTION_TOOL_HINTS)
 
 
-def _is_read_search_review_tool(tool: str) -> bool:
+def _is_read_search_review_tool(tool: str, *, tool_input: dict[str, object] | None = None) -> bool:
     token = str(tool or "").strip().lower()
     if not token:
         return False
+    if token == "bash":
+        mode = classify_bash_command_mode(str((tool_input or {}).get("command", "")))
+        return mode == "read"
     return any(hint in token for hint in _READ_ONLY_TOOL_HINTS)