multiagentos 0.4.0__py3-none-any.whl

runtime/ide/bridge.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import hmac
+import json
+from dataclasses import dataclass, fields, is_dataclass
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from threading import Thread
+from typing import Callable
+from urllib.parse import urlparse
+
+from runtime.ide.runtime import IDERuntime
+from core.contracts.ide import (
+    IDECommand, IDECommandKind, IDEContext, IDEEvent, IDEEventKind, IDEKind, IDEWorkRequest,
+)
+
+
+class IDEBridgeAuthorizationError(PermissionError):
+    pass
+
+
+@dataclass(frozen=True)
+class IDEBridgePolicy:
+    token: str
+    max_body_bytes: int = 256 * 1024
+    allow_remote: bool = False
+
+    def authorize(self, supplied: str | None) -> None:
+        if not self.token or not supplied or not hmac.compare_digest(self.token, supplied):
+            raise IDEBridgeAuthorizationError("invalid VYRELON IDE bridge token")
+
+
+class IDEBridge:
+    def __init__(self, *, policy: IDEBridgePolicy,
+                 runtime: IDERuntime | None = None,
+                 event_handler: Callable[[IDEEvent], object] | None = None,
+                 command_handler: Callable[[IDECommand], object] | None = None,
+                 work_handler: Callable[[IDEWorkRequest], object] | None = None) -> None:
+        self.policy = policy
+        self.runtime = runtime
+        self.event_handler = event_handler or (lambda event: event)
+        self.command_handler = command_handler or (lambda command: command)
+        self.work_handler = work_handler
+
+    def handle_event(self, payload: dict[str, object]) -> object:
+        event = decode_event(payload)
+        if self.runtime is not None:
+            return self.runtime.ingest_event(event)
+        return self.event_handler(event)
+
+    def handle_work(self, payload: dict[str, object]) -> object:
+        request = decode_work_request(payload)
+        if self.work_handler is None:
+            raise ValueError("IDE work handler is not configured")
+        return self.work_handler(request)
+
+    def handle_command(self, payload: dict[str, object]) -> object:
+        command = decode_command(payload)
+        if self.runtime is not None:
+            if command.context is None:
+                raise ValueError("command context is required for IDE bridge dispatch")
+            return self.runtime.execute(command.context.kind, command)
+        return self.command_handler(command)
+
+
+class _Handler(BaseHTTPRequestHandler):
+    bridge: IDEBridge
+
+    def do_POST(self) -> None:  # noqa: N802
+        if not self.bridge.policy.allow_remote and self.client_address[0] not in {"127.0.0.1", "::1"}:
+            self._respond(403, {"error": "loopback only"})
+            return
+        token = self.headers.get("Authorization", "").removeprefix("Bearer ").strip()
+        try:
+            self.bridge.policy.authorize(token)
+            length = int(self.headers.get("Content-Length", "0"))
+            if length <= 0 or length > self.bridge.policy.max_body_bytes:
+                raise ValueError("invalid request body size")
+            payload = json.loads(self.rfile.read(length))
+            path = urlparse(self.path).path
+            if path == "/v1/ide/event":
+                result = self.bridge.handle_event(payload)
+            elif path == "/v1/ide/work":
+                result = self.bridge.handle_work(payload)
+            elif path == "/v1/ide/command":
+                result = self.bridge.handle_command(payload)
+            else:
+                self._respond(404, {"error": "not found"})
+                return
+            self._respond(200, {"ok": True, "result": _jsonable(result)})
+        except IDEBridgeAuthorizationError as exc:
+            self._respond(401, {"error": str(exc)})
+        except (ValueError, TypeError, json.JSONDecodeError) as exc:
+            self._respond(400, {"error": str(exc)})
+        except Exception as exc:  # pragma: no cover
+            self._respond(500, {"error": str(exc)})
+
+    def log_message(self, format: str, *args: object) -> None:
+        return
+
+    def _respond(self, status: int, payload: dict[str, object]) -> None:
+        encoded = json.dumps(payload).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(encoded)))
+        self.end_headers()
+        self.wfile.write(encoded)
+
+
+class IDEBridgeServer:
+    def __init__(self, bridge: IDEBridge, host: str = "127.0.0.1", port: int = 8787) -> None:
+        if host not in {"127.0.0.1", "::1"} and not bridge.policy.allow_remote:
+            raise ValueError("IDE bridge must bind to loopback unless remote access is explicitly allowed")
+        self.bridge = bridge
+        self.server = ThreadingHTTPServer((host, port), _Handler)
+        self.server.RequestHandlerClass.bridge = bridge
+        self.thread: Thread | None = None
+
+    def start(self) -> None:
+        if self.thread and self.thread.is_alive():
+            return
+        self.thread = Thread(target=self.server.serve_forever, daemon=True)
+        self.thread.start()
+
+    def stop(self) -> None:
+        self.server.shutdown()
+        self.server.server_close()
+        if self.thread:
+            self.thread.join(timeout=2)
+
+
+def _jsonable(value: object) -> object:
+    if is_dataclass(value):
+        return {item.name: _jsonable(getattr(value, item.name)) for item in fields(value)}
+    if isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+    if isinstance(value, dict):
+        return {str(key): _jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(item) for item in value]
+    return str(value)
+
+
+def _context(payload: dict[str, object]) -> IDEContext:
+    raw = payload.get("context")
+    if not isinstance(raw, dict):
+        raise ValueError("context must be an object")
+    return IDEContext(
+        kind=IDEKind(str(raw["kind"])),
+        project_root=str(raw.get("project_root", "")),
+        workspace_id=raw.get("workspace_id"),
+        file_path=raw.get("file_path"),
+        selection_start=raw.get("selection_start"),
+        selection_end=raw.get("selection_end"),
+        language_id=raw.get("language_id"),
+        metadata=raw.get("metadata", {}),
+    )
+
+
+def decode_event(payload: dict[str, object]) -> IDEEvent:
+    return IDEEvent(
+        kind=IDEEventKind(str(payload["kind"])),
+        context=_context(payload),
+        payload=payload.get("payload", {}),
+        metadata=payload.get("metadata", {}),
+    )
+
+
+def decode_command(payload: dict[str, object]) -> IDECommand:
+    arguments = payload.get("arguments", {})
+    if not isinstance(arguments, dict):
+        raise ValueError("arguments must be an object")
+    return IDECommand(
+        kind=IDECommandKind(str(payload["kind"])),
+        arguments=arguments,
+        context=_context(payload) if payload.get("context") is not None else None,
+        metadata=payload.get("metadata", {}),
+    )
+
+    
+def decode_work_request(payload: dict[str, object]) -> IDEWorkRequest:
+    objective = payload.get("objective")
+    agent_id = payload.get("agent_id")
+    model_ids = payload.get("model_ids", [])
+    if not isinstance(objective, str) or not objective.strip():
+        raise ValueError("objective must be a non-empty string")
+    if not isinstance(agent_id, str) or not agent_id.strip():
+        raise ValueError("agent_id must be a non-empty string")
+    if not isinstance(model_ids, list) or not all(isinstance(item, str) for item in model_ids):
+        raise ValueError("model_ids must be a list of strings")
+    return IDEWorkRequest(
+        context=_context(payload),
+        objective=objective,
+        agent_id=agent_id,
+        model_ids=tuple(model_ids),
+        apply_changes=bool(payload.get("apply_changes", False)),
+        validation_commands=tuple(payload.get("validation_commands", [])),
+        metadata=payload.get("metadata", {}),
+    )

runtime/ide/registry.py

@@ -0,0 +1,24 @@
+"""Registry for optional IDE adapters."""
+
+from __future__ import annotations
+
+from core.contracts.ide import IDEAdapter, IDEKind
+
+
+class IDEAdapterRegistry:
+    """Register and resolve IDE adapters without IDE SDK dependencies."""
+
+    def __init__(self) -> None:
+        self._adapters: dict[IDEKind, IDEAdapter] = {}
+
+    def register(self, adapter: IDEAdapter) -> None:
+        self._adapters[adapter.kind] = adapter
+
+    def get(self, kind: IDEKind) -> IDEAdapter:
+        try:
+            return self._adapters[kind]
+        except KeyError as exc:
+            raise LookupError(f"IDE adapter not registered: {kind.value}") from exc
+
+    def list(self) -> tuple[IDEKind, ...]:
+        return tuple(self._adapters)

runtime/ide/runtime.py

@@ -0,0 +1,35 @@
+"""High-level facade for optional IDE adapters."""
+
+from __future__ import annotations
+
+from core.contracts.ide import IDEAdapter, IDECommand, IDECommandResult, IDEContext, IDEEvent, IDEKind
+from runtime.ide.registry import IDEAdapterRegistry
+
+
+class IDERuntime:
+    """Expose IDE adapters without importing any native IDE SDK."""
+
+    def __init__(self, registry: IDEAdapterRegistry | None = None) -> None:
+        self.registry = registry or IDEAdapterRegistry()
+        self._contexts: dict[IDEKind, IDEContext] = {}
+
+    def register(self, adapter: IDEAdapter) -> None:
+        self.registry.register(adapter)
+
+    def context(self, kind: IDEKind) -> IDEContext:
+        if kind in self._contexts:
+            return self._contexts[kind]
+        context = self.registry.get(kind).context()
+        self._contexts[kind] = context
+        return context
+
+    def execute(self, kind: IDEKind, command: IDECommand) -> IDECommandResult:
+        return self.registry.get(kind).execute(command)
+
+    def ingest_event(self, event: IDEEvent) -> object:
+        """Record normalized IDE state while keeping event ingestion separate from commands."""
+        self._contexts[event.context.kind] = event.context
+        return event
+
+    def capabilities(self, kind: IDEKind) -> frozenset[str]:
+        return self.registry.get(kind).capabilities()

runtime/local/__init__.py

@@ -0,0 +1,18 @@
+"""VYRELON local tool runtime."""
+
+from runtime.local.filesystem import FilesystemRuntime
+from runtime.local.path_security import PathPolicy, PathSecurityError
+from runtime.local.patch import PatchRuntime
+from runtime.local.permissions import LocalPermissionGuard
+from runtime.local.shell import PersistentShellRuntime, ShellResult, ShellState
+
+__all__ = [
+    "FilesystemRuntime",
+    "LocalPermissionGuard",
+    "PatchRuntime",
+    "PathPolicy",
+    "PathSecurityError",
+    "PersistentShellRuntime",
+    "ShellResult",
+    "ShellState",
+]

runtime/local/filesystem.py

@@ -0,0 +1,58 @@
+"""Policy- and path-controlled filesystem runtime."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from runtime.local.path_security import PathPolicy
+from runtime.local.permissions import LocalPermissionGuard
+from runtime.policy import ExecutionPolicy
+
+
+class FilesystemRuntime:
+    """First-class VYRELON filesystem operations."""
+
+    def __init__(
+        self,
+        policy: ExecutionPolicy | None = None,
+        paths: PathPolicy | None = None,
+    ) -> None:
+        self.policy = policy or ExecutionPolicy()
+        self.paths = paths or PathPolicy()
+        self.permissions = LocalPermissionGuard(self.policy)
+
+    def read_text(self, path: str, *, encoding: str = "utf-8") -> str:
+        target = self.paths.resolve(path, must_exist=True)
+        if not target.is_file():
+            raise IsADirectoryError(str(target))
+        return target.read_text(encoding=encoding)
+
+    def write_text(
+        self, path: str, content: str, *, encoding: str = "utf-8", approved: bool = False
+    ) -> Path:
+        self.permissions.require("filesystem.write", approved=approved)
+        target = self.paths.resolve(path)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(content, encoding=encoding)
+        return target
+
+    def list_directory(self, path: str = ".") -> tuple[str, ...]:
+        target = self.paths.resolve(path, must_exist=True)
+        if not target.is_dir():
+            raise NotADirectoryError(str(target))
+        return tuple(sorted(item.name for item in target.iterdir()))
+
+    def create_directory(self, path: str, *, approved: bool = False) -> Path:
+        self.permissions.require("filesystem.write", approved=approved)
+        target = self.paths.resolve(path)
+        target.mkdir(parents=True, exist_ok=True)
+        return target
+
+    def delete(self, path: str, *, approved: bool = False) -> Path:
+        self.permissions.require("filesystem.write", approved=approved)
+        target = self.paths.resolve(path, must_exist=True)
+        if target.is_dir():
+            target.rmdir()
+        else:
+            target.unlink()
+        return target

runtime/local/patch.py

@@ -0,0 +1,79 @@
+"""Patch application runtime for VYRELON."""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from runtime.local.path_security import PathPolicy
+from runtime.local.permissions import LocalPermissionGuard
+from runtime.policy import ExecutionPolicy
+from runtime.process import ProcessResult, ProcessRuntime
+
+
+class PatchRuntime:
+    """Apply/check unified patches through the local Git patch engine.
+
+    Patch application is a filesystem-write capability. The Git subprocess used
+    internally is an implementation detail and must not grant or require the
+    separately exposed shell/process capability.
+    """
+
+    def __init__(
+        self,
+        policy: ExecutionPolicy | None = None,
+        paths: PathPolicy | None = None,
+        process: ProcessRuntime | None = None,
+    ) -> None:
+        self.policy = policy or ExecutionPolicy()
+        self.paths = paths or PathPolicy()
+        self.permissions = LocalPermissionGuard(self.policy)
+        self.process = process or ProcessRuntime(
+            ExecutionPolicy(
+                allow_process=True,
+                allow_filesystem_write=self.policy.allow_filesystem_write,
+                allow_git_write=self.policy.allow_git_write,
+                allow_network=self.policy.allow_network,
+                allow_github_write=self.policy.allow_github_write,
+                require_approval_for=self.policy.require_approval_for,
+            )
+        )
+
+    def _with_patch_file(self, patch_text: str, callback):
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            suffix=".patch",
+            delete=True,
+        ) as patch_file:
+            patch_file.write(patch_text)
+            patch_file.flush()
+            return callback(patch_file.name)
+
+    def check(self, project_root: str, patch_text: str) -> ProcessResult:
+        root = self.paths.resolve(project_root, must_exist=True)
+        if not root.is_dir():
+            raise NotADirectoryError(str(root))
+        return self._with_patch_file(
+            patch_text,
+            lambda patch_path: self.process.run(
+                ["git", "apply", "--check", patch_path],
+                cwd=str(root),
+            ),
+        )
+
+    def apply(
+        self, project_root: str, patch_text: str, *, approved: bool = False
+    ) -> ProcessResult:
+        self.permissions.require("filesystem.write", approved=approved)
+        checked = self.check(project_root, patch_text)
+        if checked.returncode != 0:
+            return checked
+        root = self.paths.resolve(project_root, must_exist=True)
+        return self._with_patch_file(
+            patch_text,
+            lambda patch_path: self.process.run(
+                ["git", "apply", patch_path],
+                cwd=str(root),
+            ),
+        )

runtime/local/path_security.py

@@ -0,0 +1,31 @@
+"""Workspace/path security for VYRELON local tools."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+class PathSecurityError(PermissionError):
+    """Raised when a path escapes the configured local workspace."""
+
+
+class PathPolicy:
+    """Resolve paths and optionally confine them to explicit workspace roots."""
+
+    def __init__(self, roots: tuple[str, ...] = ()) -> None:
+        self.roots = tuple(Path(root).expanduser().resolve() for root in roots)
+
+    def resolve(self, path: str | Path, *, must_exist: bool = False) -> Path:
+        candidate = Path(path).expanduser()
+        if not candidate.is_absolute() and self.roots:
+            candidate = self.roots[0] / candidate
+        resolved = candidate.resolve(strict=must_exist)
+        self._check_allowed(resolved)
+        return resolved
+
+    def _check_allowed(self, path: Path) -> None:
+        if not self.roots:
+            return
+        if not any(path == root or root in path.parents for root in self.roots):
+            allowed = ", ".join(str(root) for root in self.roots)
+            raise PathSecurityError(f"path is outside allowed roots: {path}; allowed={allowed}")

runtime/local/permissions.py

@@ -0,0 +1,20 @@
+"""Local tool permission enforcement."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from runtime.policy import ExecutionPolicy
+
+
+@dataclass(frozen=True)
+class LocalPermissionGuard:
+    """Apply VYRELON execution policy to local tool operations."""
+
+    policy: ExecutionPolicy
+
+    def require(self, capability: str, *, approved: bool = False) -> None:
+        if not self.policy.permits(capability):
+            raise PermissionError(f"local capability is disabled: {capability}")
+        if self.policy.requires_approval(capability) and not approved:
+            raise PermissionError(f"explicit approval required for: {capability}")

runtime/local/process.py

@@ -0,0 +1,56 @@
+"""Subprocess executor with explicit execution policy."""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from core.contracts.runtime import ExecutionRequest
+from runtime.policy import ExecutionPolicy
+
+
+@dataclass(frozen=True)
+class ProcessResult:
+    returncode: int
+    stdout: str
+    stderr: str
+    command: tuple[str, ...]
+
+
+class LocalProcessExecutor:
+    """Execute an explicit argv command on the local machine."""
+
+    def __init__(self, policy: ExecutionPolicy | None = None) -> None:
+        self.policy = policy or ExecutionPolicy()
+
+    def execute(self, request: ExecutionRequest) -> ProcessResult:
+        if not self.policy.permits("process"):
+            raise PermissionError("Local process execution is disabled by policy")
+
+        command = request.work_unit.inputs.get("command")
+        if not isinstance(command, (list, tuple)) or not command:
+            raise ValueError("WorkUnit.inputs['command'] must be a non-empty argv list")
+        if not all(isinstance(part, str) and part for part in command):
+            raise ValueError("Every command argument must be a non-empty string")
+
+        cwd_value = request.work_unit.inputs.get("cwd")
+        cwd = Path(cwd_value).expanduser() if isinstance(cwd_value, str) else None
+        timeout = request.work_unit.inputs.get("timeout", 300)
+        if not isinstance(timeout, (int, float)) or timeout <= 0:
+            raise ValueError("WorkUnit.inputs['timeout'] must be a positive number")
+
+        completed = subprocess.run(
+            list(command),
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        return ProcessResult(
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+            command=tuple(command),
+        )

runtime/local/shell.py

@@ -0,0 +1,97 @@
+"""Persistent working-directory shell runtime."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+from dataclasses import dataclass, field
+
+from runtime.local.path_security import PathPolicy
+from runtime.local.permissions import LocalPermissionGuard
+from runtime.policy import ExecutionPolicy
+
+
+@dataclass
+class ShellState:
+    cwd: str
+    environment: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ShellResult:
+    command: str
+    cwd: str
+    returncode: int
+    stdout: str
+    stderr: str
+
+
+class PersistentShellRuntime:
+    """Shell execution with persistent cwd/environment state between calls."""
+
+    def __init__(
+        self,
+        cwd: str,
+        policy: ExecutionPolicy | None = None,
+        paths: PathPolicy | None = None,
+    ) -> None:
+        self.policy = policy or ExecutionPolicy()
+        self.paths = paths or PathPolicy()
+        self.permissions = LocalPermissionGuard(self.policy)
+        initial = self.paths.resolve(cwd, must_exist=True)
+        if not initial.is_dir():
+            raise NotADirectoryError(str(initial))
+        self.state = ShellState(str(initial))
+
+    def status(self) -> ShellState:
+        return ShellState(self.state.cwd, dict(self.state.environment))
+
+    def reset(self, cwd: str) -> ShellState:
+        self.permissions.require("process")
+        target = self.paths.resolve(cwd, must_exist=True)
+        if not target.is_dir():
+            raise NotADirectoryError(str(target))
+        self.state.cwd = str(target)
+        return self.status()
+
+    def set_environment(self, name: str, value: str) -> ShellState:
+        self.permissions.require("process")
+        if not name or "=" in name or "\x00" in name:
+            raise ValueError("invalid environment variable name")
+        self.state.environment[name] = value
+        return self.status()
+
+    def run(self, command: str, *, timeout: float = 120.0) -> ShellResult:
+        self.permissions.require("process")
+        if not command.strip():
+            raise ValueError("command must not be empty")
+        env = os.environ.copy()
+        env.update(self.state.environment)
+        completed = subprocess.run(
+            command,
+            cwd=self.state.cwd,
+            env=env,
+            shell=True,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=timeout,
+        )
+        return ShellResult(
+            command=command,
+            cwd=self.state.cwd,
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+        )
+
+    def cd(self, path: str) -> ShellState:
+        target = self.paths.resolve(path, must_exist=True)
+        if not target.is_dir():
+            raise NotADirectoryError(str(target))
+        self.state.cwd = str(target)
+        return self.status()
+
+    def command_words(self, command: str) -> tuple[str, ...]:
+        return tuple(shlex.split(command))

runtime/mcp/__init__.py

@@ -0,0 +1,7 @@
+"""MCP runtime for VYRELON."""
+from .client import MCPClient, MCPError, MCPProtocolError
+from .config import MCPConfigLoader
+from .proxy import MCPToolProxy
+from .server import VYRELONMCPServer
+from .session import MCPSessionRegistry
+__all__=["MCPClient","MCPConfigLoader","MCPError","MCPProtocolError","MCPToolProxy","VYRELONMCPServer","MCPSessionRegistry"]