qwen-sci 0.2.2__py3-none-any.whl

src/harness/src/openharness/hooks/executor.py

@@ -0,0 +1,242 @@
+"""Hook execution engine."""
+
+from __future__ import annotations
+
+import asyncio
+import fnmatch
+import json
+import os
+import shlex
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from openharness.api.client import ApiMessageCompleteEvent, ApiMessageRequest, SupportsStreamingMessages
+from openharness.engine.messages import ConversationMessage
+from openharness.hooks.events import HookEvent
+from openharness.hooks.loader import HookRegistry
+from openharness.hooks.schemas import (
+    AgentHookDefinition,
+    CommandHookDefinition,
+    HookDefinition,
+    HttpHookDefinition,
+    PromptHookDefinition,
+)
+from openharness.hooks.types import AggregatedHookResult, HookResult
+from openharness.sandbox import SandboxUnavailableError
+from openharness.utils.shell import create_shell_subprocess
+
+
+@dataclass
+class HookExecutionContext:
+    """Context passed into hook execution."""
+
+    cwd: Path
+    api_client: SupportsStreamingMessages
+    default_model: str
+
+
+class HookExecutor:
+    """Execute hooks for lifecycle events."""
+
+    def __init__(self, registry: HookRegistry, context: HookExecutionContext) -> None:
+        self._registry = registry
+        self._context = context
+
+    def update_registry(self, registry: HookRegistry) -> None:
+        """Replace the active hook registry."""
+        self._registry = registry
+
+    def update_context(
+        self,
+        *,
+        api_client: SupportsStreamingMessages | None = None,
+        default_model: str | None = None,
+    ) -> None:
+        """Update the active hook execution context."""
+        if api_client is not None:
+            self._context.api_client = api_client
+        if default_model is not None:
+            self._context.default_model = default_model
+
+    async def execute(self, event: HookEvent, payload: dict[str, Any]) -> AggregatedHookResult:
+        """Execute all matching hooks for an event."""
+        results: list[HookResult] = []
+        for hook in self._registry.get(event):
+            if not _matches_hook(hook, payload):
+                continue
+            if isinstance(hook, CommandHookDefinition):
+                results.append(await self._run_command_hook(hook, event, payload))
+            elif isinstance(hook, HttpHookDefinition):
+                results.append(await self._run_http_hook(hook, event, payload))
+            elif isinstance(hook, PromptHookDefinition):
+                results.append(await self._run_prompt_like_hook(hook, event, payload, agent_mode=False))
+            elif isinstance(hook, AgentHookDefinition):
+                results.append(await self._run_prompt_like_hook(hook, event, payload, agent_mode=True))
+        return AggregatedHookResult(results=results)
+
+    async def _run_command_hook(
+        self,
+        hook: CommandHookDefinition,
+        event: HookEvent,
+        payload: dict[str, Any],
+    ) -> HookResult:
+        command = _inject_arguments(hook.command, payload, shell_escape=True)
+        try:
+            process = await create_shell_subprocess(
+                command,
+                cwd=self._context.cwd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env={
+                    **os.environ,
+                    "OPENHARNESS_HOOK_EVENT": event.value,
+                    "OPENHARNESS_HOOK_PAYLOAD": json.dumps(payload),
+                },
+            )
+        except SandboxUnavailableError as exc:
+            return HookResult(
+                hook_type=hook.type,
+                success=False,
+                blocked=hook.block_on_failure,
+                reason=str(exc),
+            )
+
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(),
+                timeout=hook.timeout_seconds,
+            )
+        except asyncio.TimeoutError:
+            process.kill()
+            await process.wait()
+            return HookResult(
+                hook_type=hook.type,
+                success=False,
+                blocked=hook.block_on_failure,
+                reason=f"command hook timed out after {hook.timeout_seconds}s",
+            )
+
+        output = "\n".join(
+            part for part in (
+                stdout.decode("utf-8", errors="replace").strip(),
+                stderr.decode("utf-8", errors="replace").strip(),
+            ) if part
+        )
+        success = process.returncode == 0
+        return HookResult(
+            hook_type=hook.type,
+            success=success,
+            output=output,
+            blocked=hook.block_on_failure and not success,
+            reason=output or f"command hook failed with exit code {process.returncode}",
+            metadata={"returncode": process.returncode},
+        )
+
+    async def _run_http_hook(
+        self,
+        hook: HttpHookDefinition,
+        event: HookEvent,
+        payload: dict[str, Any],
+    ) -> HookResult:
+        try:
+            async with httpx.AsyncClient(timeout=hook.timeout_seconds) as client:
+                response = await client.post(
+                    hook.url,
+                    json={"event": event.value, "payload": payload},
+                    headers=hook.headers,
+                )
+            success = response.is_success
+            output = response.text
+            return HookResult(
+                hook_type=hook.type,
+                success=success,
+                output=output,
+                blocked=hook.block_on_failure and not success,
+                reason=output or f"http hook returned {response.status_code}",
+                metadata={"status_code": response.status_code},
+            )
+        except Exception as exc:
+            return HookResult(
+                hook_type=hook.type,
+                success=False,
+                blocked=hook.block_on_failure,
+                reason=str(exc),
+            )
+
+    async def _run_prompt_like_hook(
+        self,
+        hook: PromptHookDefinition | AgentHookDefinition,
+        event: HookEvent,
+        payload: dict[str, Any],
+        *,
+        agent_mode: bool,
+    ) -> HookResult:
+        prompt = _inject_arguments(hook.prompt, payload)
+        prefix = (
+            "You are validating whether a hook condition passes in OpenHarness. "
+            "Return strict JSON: {\"ok\": true} or {\"ok\": false, \"reason\": \"...\"}."
+        )
+        if agent_mode:
+            prefix += " Be more thorough and reason over the payload before deciding."
+        request = ApiMessageRequest(
+            model=hook.model or self._context.default_model,
+            messages=[ConversationMessage.from_user_text(prompt)],
+            system_prompt=prefix,
+            max_tokens=512,
+        )
+
+        text_chunks: list[str] = []
+        final_event: ApiMessageCompleteEvent | None = None
+        async for event_item in self._context.api_client.stream_message(request):
+            if isinstance(event_item, ApiMessageCompleteEvent):
+                final_event = event_item
+            else:
+                text_chunks.append(event_item.text)
+
+        text = "".join(text_chunks)
+        if final_event is not None and final_event.message.text:
+            text = final_event.message.text
+
+        parsed = _parse_hook_json(text)
+        if parsed["ok"]:
+            return HookResult(hook_type=hook.type, success=True, output=text)
+        return HookResult(
+            hook_type=hook.type,
+            success=False,
+            output=text,
+            blocked=hook.block_on_failure,
+            reason=parsed.get("reason", "hook rejected the event"),
+        )
+
+
+def _matches_hook(hook: HookDefinition, payload: dict[str, Any]) -> bool:
+    matcher = getattr(hook, "matcher", None)
+    if not matcher:
+        return True
+    subject = str(payload.get("tool_name") or payload.get("prompt") or payload.get("event") or "")
+    return fnmatch.fnmatch(subject, matcher)
+
+
+def _inject_arguments(
+    template: str, payload: dict[str, Any], *, shell_escape: bool = False
+) -> str:
+    serialized = json.dumps(payload, ensure_ascii=True)
+    if shell_escape:
+        serialized = shlex.quote(serialized)
+    return template.replace("$ARGUMENTS", serialized)
+
+
+def _parse_hook_json(text: str) -> dict[str, Any]:
+    try:
+        parsed = json.loads(text)
+        if isinstance(parsed, dict) and isinstance(parsed.get("ok"), bool):
+            return parsed
+    except json.JSONDecodeError:
+        pass
+    lowered = text.strip().lower()
+    if lowered in {"ok", "true", "yes"}:
+        return {"ok": True}
+    return {"ok": False, "reason": text.strip() or "hook returned invalid JSON"}

src/harness/src/openharness/hooks/hot_reload.py

@@ -0,0 +1,31 @@
+"""Best-effort hot reloading for settings-backed hooks."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from openharness.config import load_settings
+from openharness.hooks.loader import HookRegistry, load_hook_registry
+
+
+class HookReloader:
+    """Reload hook definitions when the settings file changes."""
+
+    def __init__(self, settings_path: Path) -> None:
+        self._settings_path = settings_path
+        self._last_mtime_ns = -1
+        self._registry = HookRegistry()
+
+    def current_registry(self) -> HookRegistry:
+        """Return the latest registry, reloading if needed."""
+        try:
+            stat = self._settings_path.stat()
+        except FileNotFoundError:
+            self._registry = HookRegistry()
+            self._last_mtime_ns = -1
+            return self._registry
+
+        if stat.st_mtime_ns != self._last_mtime_ns:
+            self._last_mtime_ns = stat.st_mtime_ns
+            self._registry = load_hook_registry(load_settings(self._settings_path))
+        return self._registry

src/harness/src/openharness/hooks/loader.py

@@ -0,0 +1,68 @@
+"""Load hooks from settings."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from openharness.hooks.events import HookEvent
+from openharness.hooks.schemas import HookDefinition
+
+
+class HookRegistry:
+    """Store hooks grouped by event."""
+
+    def __init__(self) -> None:
+        self._hooks: dict[HookEvent, list[HookDefinition]] = defaultdict(list)
+
+    def register(self, event: HookEvent, hook: HookDefinition) -> None:
+        """Register one hook."""
+        self._hooks[event].append(hook)
+
+    def get(self, event: HookEvent) -> list[HookDefinition]:
+        """Return hooks registered for an event, ordered by priority.
+
+        Hooks with a higher ``priority`` run first. ``sorted`` is stable, so
+        hooks sharing the same priority keep their registration order.
+        """
+        hooks = self._hooks.get(event, [])
+        return sorted(hooks, key=lambda hook: -getattr(hook, "priority", 0))
+
+    def summary(self) -> str:
+        """Return a human-readable hook summary."""
+        lines: list[str] = []
+        for event in HookEvent:
+            hooks = self.get(event)
+            if not hooks:
+                continue
+            lines.append(f"{event.value}:")
+            for hook in hooks:
+                matcher = getattr(hook, "matcher", None)
+                detail = getattr(hook, "command", None) or getattr(hook, "prompt", None) or getattr(hook, "url", None) or ""
+                suffix = f" matcher={matcher}" if matcher else ""
+                priority = getattr(hook, "priority", 0)
+                if priority:
+                    suffix += f" priority={priority}"
+                lines.append(f"  - {hook.type}{suffix}: {detail}")
+        return "\n".join(lines)
+
+
+def load_hook_registry(settings, plugins=None) -> HookRegistry:
+    """Load hooks from the current settings object."""
+    registry = HookRegistry()
+    for raw_event, hooks in settings.hooks.items():
+        try:
+            event = HookEvent(raw_event)
+        except ValueError:
+            continue
+        for hook in hooks:
+            registry.register(event, hook)
+    for plugin in plugins or []:
+        if not plugin.enabled:
+            continue
+        for raw_event, hooks in plugin.hooks.items():
+            try:
+                event = HookEvent(raw_event)
+            except ValueError:
+                continue
+            for hook in hooks:
+                registry.register(event, hook)
+    return registry

src/harness/src/openharness/hooks/schemas.py

@@ -0,0 +1,66 @@
+"""Hook configuration schemas."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class CommandHookDefinition(BaseModel):
+    """A hook that executes a shell command."""
+
+    type: Literal["command"] = "command"
+    command: str
+    timeout_seconds: int = Field(default=30, ge=1, le=600)
+    matcher: str | None = None
+    block_on_failure: bool = False
+    priority: int = Field(default=0)
+    """Higher priority runs first within an event; ties keep registration order."""
+
+
+class PromptHookDefinition(BaseModel):
+    """A hook that asks the model to validate a condition."""
+
+    type: Literal["prompt"] = "prompt"
+    prompt: str
+    model: str | None = None
+    timeout_seconds: int = Field(default=30, ge=1, le=600)
+    matcher: str | None = None
+    block_on_failure: bool = True
+    priority: int = Field(default=0)
+    """Higher priority runs first within an event; ties keep registration order."""
+
+
+class HttpHookDefinition(BaseModel):
+    """A hook that POSTs the event payload to an HTTP endpoint."""
+
+    type: Literal["http"] = "http"
+    url: str
+    headers: dict[str, str] = Field(default_factory=dict)
+    timeout_seconds: int = Field(default=30, ge=1, le=600)
+    matcher: str | None = None
+    block_on_failure: bool = False
+    priority: int = Field(default=0)
+    """Higher priority runs first within an event; ties keep registration order."""
+
+
+class AgentHookDefinition(BaseModel):
+    """A hook that performs a deeper model-based validation."""
+
+    type: Literal["agent"] = "agent"
+    prompt: str
+    model: str | None = None
+    timeout_seconds: int = Field(default=60, ge=1, le=1200)
+    matcher: str | None = None
+    block_on_failure: bool = True
+    priority: int = Field(default=0)
+    """Higher priority runs first within an event; ties keep registration order."""
+
+
+HookDefinition = (
+    CommandHookDefinition
+    | PromptHookDefinition
+    | HttpHookDefinition
+    | AgentHookDefinition
+)

src/harness/src/openharness/hooks/types.py

@@ -0,0 +1,38 @@
+"""Runtime hook result types."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class HookResult:
+    """Result from a single hook execution."""
+
+    hook_type: str
+    success: bool
+    output: str = ""
+    blocked: bool = False
+    reason: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class AggregatedHookResult:
+    """Aggregated result for a hook event."""
+
+    results: list[HookResult] = field(default_factory=list)
+
+    @property
+    def blocked(self) -> bool:
+        """Return whether any hook blocked continuation."""
+        return any(result.blocked for result in self.results)
+
+    @property
+    def reason(self) -> str:
+        """Return the first blocking reason, if any."""
+        for result in self.results:
+            if result.blocked:
+                return result.reason or result.output
+        return ""

src/harness/src/openharness/keybindings/__init__.py

@@ -0,0 +1,14 @@
+"""Keybindings exports."""
+
+from openharness.keybindings.default_bindings import DEFAULT_KEYBINDINGS
+from openharness.keybindings.loader import get_keybindings_path, load_keybindings
+from openharness.keybindings.parser import parse_keybindings
+from openharness.keybindings.resolver import resolve_keybindings
+
+__all__ = [
+    "DEFAULT_KEYBINDINGS",
+    "get_keybindings_path",
+    "load_keybindings",
+    "parse_keybindings",
+    "resolve_keybindings",
+]

src/harness/src/openharness/keybindings/default_bindings.py

@@ -0,0 +1,11 @@
+"""Default keybinding map."""
+
+from __future__ import annotations
+
+
+DEFAULT_KEYBINDINGS: dict[str, str] = {
+    "ctrl+l": "clear",
+    "ctrl+k": "toggle_vim",
+    "ctrl+v": "toggle_voice",
+    "ctrl+t": "tasks",
+}

src/harness/src/openharness/keybindings/loader.py

@@ -0,0 +1,22 @@
+"""Load keybindings from config."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from openharness.config.paths import get_config_dir
+from openharness.keybindings.parser import parse_keybindings
+from openharness.keybindings.resolver import resolve_keybindings
+
+
+def get_keybindings_path() -> Path:
+    """Return the user keybindings path."""
+    return get_config_dir() / "keybindings.json"
+
+
+def load_keybindings() -> dict[str, str]:
+    """Load and merge keybindings."""
+    path = get_keybindings_path()
+    if not path.exists():
+        return resolve_keybindings()
+    return resolve_keybindings(parse_keybindings(path.read_text(encoding="utf-8")))

src/harness/src/openharness/keybindings/parser.py

@@ -0,0 +1,18 @@
+"""Keybinding file parsing."""
+
+from __future__ import annotations
+
+import json
+
+
+def parse_keybindings(text: str) -> dict[str, str]:
+    """Parse a JSON keybinding mapping."""
+    data = json.loads(text)
+    if not isinstance(data, dict):
+        raise ValueError("keybindings file must be a JSON object")
+    parsed: dict[str, str] = {}
+    for key, value in data.items():
+        if not isinstance(key, str) or not isinstance(value, str):
+            raise ValueError("keybindings keys and values must be strings")
+        parsed[key] = value
+    return parsed

src/harness/src/openharness/keybindings/resolver.py

@@ -0,0 +1,13 @@
+"""Keybinding resolution."""
+
+from __future__ import annotations
+
+from openharness.keybindings.default_bindings import DEFAULT_KEYBINDINGS
+
+
+def resolve_keybindings(overrides: dict[str, str] | None = None) -> dict[str, str]:
+    """Merge user overrides over the default keybindings."""
+    resolved = dict(DEFAULT_KEYBINDINGS)
+    if overrides:
+        resolved.update(overrides)
+    return resolved

src/harness/src/openharness/mcp/__init__.py

@@ -0,0 +1,79 @@
+"""MCP exports."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:  # pragma: no cover
+    from openharness.mcp.client import McpClientManager, McpServerNotConnectedError
+    from openharness.mcp.types import (
+        McpConnectionStatus,
+        McpHttpServerConfig,
+        McpJsonConfig,
+        McpResourceInfo,
+        McpServerConfig,
+        McpStdioServerConfig,
+        McpToolInfo,
+        McpWebSocketServerConfig,
+    )
+
+__all__ = [
+    "McpClientManager",
+    "McpConnectionStatus",
+    "McpServerNotConnectedError",
+    "McpHttpServerConfig",
+    "McpJsonConfig",
+    "McpResourceInfo",
+    "McpServerConfig",
+    "McpStdioServerConfig",
+    "McpToolInfo",
+    "McpWebSocketServerConfig",
+    "load_mcp_server_configs",
+]
+
+
+def __getattr__(name: str):
+    if name == "McpClientManager":
+        from openharness.mcp.client import McpClientManager
+
+        return McpClientManager
+    if name == "McpServerNotConnectedError":
+        from openharness.mcp.client import McpServerNotConnectedError
+
+        return McpServerNotConnectedError
+    if name == "load_mcp_server_configs":
+        from openharness.mcp.config import load_mcp_server_configs
+
+        return load_mcp_server_configs
+    if name in {
+        "McpConnectionStatus",
+        "McpHttpServerConfig",
+        "McpJsonConfig",
+        "McpResourceInfo",
+        "McpServerConfig",
+        "McpStdioServerConfig",
+        "McpToolInfo",
+        "McpWebSocketServerConfig",
+    }:
+        from openharness.mcp.types import (
+            McpConnectionStatus,
+            McpHttpServerConfig,
+            McpJsonConfig,
+            McpResourceInfo,
+            McpServerConfig,
+            McpStdioServerConfig,
+            McpToolInfo,
+            McpWebSocketServerConfig,
+        )
+
+        return {
+            "McpConnectionStatus": McpConnectionStatus,
+            "McpHttpServerConfig": McpHttpServerConfig,
+            "McpJsonConfig": McpJsonConfig,
+            "McpResourceInfo": McpResourceInfo,
+            "McpServerConfig": McpServerConfig,
+            "McpStdioServerConfig": McpStdioServerConfig,
+            "McpToolInfo": McpToolInfo,
+            "McpWebSocketServerConfig": McpWebSocketServerConfig,
+        }[name]
+    raise AttributeError(name)