subactor-shell 0.2.2__py3-none-any.whl

subactor_shell/control.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+from urllib.parse import urlsplit
+
+import httpx
+
+from .redaction import ExactRedactor
+from .secret_refs import SecretResolver
+
+
+class ControlError(RuntimeError):
+    pass
+
+
+class SubactorControlClient:
+    def __init__(
+        self,
+        config: dict[str, Any],
+        resolver: SecretResolver,
+        *,
+        transport: httpx.BaseTransport | None = None,
+    ):
+        self.config = config
+        self.resolver = resolver
+        self.transport = transport
+        self.base_url = str(config.get("base_url", "http://127.0.0.1:8088")).rstrip("/")
+        parsed = urlsplit(self.base_url)
+        if parsed.scheme not in {"http", "https"} or not parsed.hostname:
+            raise ValueError("control.base_url musi być adresem http:// lub https://")
+        if parsed.username or parsed.password or parsed.query or parsed.fragment:
+            raise ValueError("control.base_url nie może zawierać credentiali ani query")
+        self.account_id = self._identifier(str(config.get("account_id", "softreck")))
+        self.provider = self._identifier(str(config.get("provider", "chatgpt")))
+        self.tool_id = self._identifier(str(config.get("tool_id", "codex")))
+        self.bearer_ref = str(config.get("bearer_ref", ""))
+        self.allowed_tools = sorted(
+            str(item) for item in config.get("allowed_tools", ["cli.status", "cli.plan", "cli.execute"])
+        )
+        self.timeout = float(config.get("timeout_seconds", 10.0))
+
+    @staticmethod
+    def _identifier(value: str) -> str:
+        import re
+
+        normalized = value.strip().lower()
+        if re.fullmatch(r"[a-z0-9][a-z0-9-]{0,62}", normalized) is None:
+            raise ValueError(f"Nieprawidłowy identyfikator Subactor: {value}")
+        return normalized
+
+    @property
+    def endpoint(self) -> str:
+        return (
+            f"/mcp/accounts/{self.account_id}/providers/{self.provider}/tools/{self.tool_id}"
+        )
+
+    def _token(self) -> str:
+        if not self.bearer_ref:
+            raise ControlError("Brak control.bearer_ref")
+        token = self.resolver.resolve(self.bearer_ref)
+        if len(token) < 16:
+            raise ControlError("Bearer Subactor jest pusty albo zbyt krótki")
+        return token
+
+    def health(self) -> tuple[bool, str]:
+        try:
+            with httpx.Client(
+                base_url=self.base_url, timeout=self.timeout, transport=self.transport
+            ) as client:
+                response = client.get("/health")
+        except httpx.HTTPError as exc:
+            return False, f"błąd połączenia ({type(exc).__name__})"
+        if response.status_code != 200:
+            return False, f"HTTP {response.status_code}"
+        try:
+            payload = response.json()
+        except ValueError:
+            return False, "odpowiedź nie jest JSON"
+        if not isinstance(payload, dict):
+            return False, "odpowiedź JSON nie jest obiektem"
+        if payload.get("ok") is True:
+            return True, "ok=true"
+        status = payload.get("status")
+        return status == "ok", f"status={status!r}"
+
+    def _rpc(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        token = self._token()
+        headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+        payload: dict[str, Any] = {"jsonrpc": "2.0", "id": 1, "method": method}
+        if params is not None:
+            payload["params"] = params
+        try:
+            with httpx.Client(
+                base_url=self.base_url, timeout=self.timeout, transport=self.transport
+            ) as client:
+                response = client.post(self.endpoint, headers=headers, json=payload)
+        except httpx.HTTPError as exc:
+            raise ControlError(f"Błąd połączenia z Subactor Control ({type(exc).__name__})") from exc
+        if response.status_code >= 400:
+            raise ControlError(f"Subactor Control zwrócił HTTP {response.status_code}")
+        try:
+            result = response.json()
+        except ValueError as exc:
+            raise ControlError("Subactor Control zwrócił nieprawidłowy JSON") from exc
+        if not isinstance(result, dict):
+            raise ControlError("Subactor Control zwrócił nieprawidłową odpowiedź RPC")
+        if "error" in result:
+            # Redagujemy bearer na wypadek odbicia nagłówków przez serwer/proxy.
+            safe = ExactRedactor([token]).redact(json.dumps(result["error"], ensure_ascii=False))
+            raise ControlError(f"Błąd JSON-RPC Subactor: {safe}")
+        return result
+
+    def list_tools(self, *, strict: bool = True) -> list[dict[str, Any]]:
+        response = self._rpc("tools/list")
+        tools = response.get("result", {}).get("tools", [])
+        if not isinstance(tools, list):
+            raise ControlError("tools/list nie zwróciło listy")
+        names = sorted(
+            item.get("name") for item in tools if isinstance(item, dict) and isinstance(item.get("name"), str)
+        )
+        if strict and names != self.allowed_tools:
+            raise ControlError(
+                f"Naruszona granica MCP: otrzymano {names}, oczekiwano {self.allowed_tools}"
+            )
+        return [item for item in tools if isinstance(item, dict)]
+
+    def call_tool(
+        self,
+        name: str,
+        arguments: dict[str, Any],
+        *,
+        allow_execute: bool = False,
+    ) -> Any:
+        self.list_tools(strict=True)
+        if name not in self.allowed_tools:
+            raise ControlError(f"Narzędzie '{name}' nie jest dozwolone")
+        if name == "cli.execute" and not allow_execute:
+            raise ControlError("cli.execute wymaga jawnego potwierdzenia")
+        response = self._rpc("tools/call", {"name": name, "arguments": arguments})
+        return response.get("result")

subactor_shell/control_env.py

@@ -0,0 +1,93 @@
+"""Read the bounded local Control environment without sourcing a shell file."""
+
+from __future__ import annotations
+
+import os
+import stat
+import sys
+from collections.abc import MutableMapping
+from pathlib import Path
+
+
+_ALLOWED_KEYS = frozenset(
+    {
+        "SUBACTOR_ADMIN_TOKEN",
+        "SUBACTOR_CONTROL_URL",
+        "SUBACTOR_FOUNDER_URL",
+        "SUBACTOR_PLANFILE_URL",
+    }
+)
+_MAX_ENV_BYTES = 1_048_576
+
+
+class ControlEnvironmentError(ValueError):
+    """The optional Control environment file cannot be safely used."""
+
+
+def default_environment_file() -> Path:
+    """Locate ``platform/.env`` from a workspace, not from site-packages."""
+
+    roots: list[Path] = []
+    configured_root = os.environ.get("SUBACTOR_WORKSPACE_ROOT", "").strip()
+    if configured_root:
+        roots.append(Path(configured_root).expanduser())
+    for anchor in (Path.cwd(), Path(sys.argv[0]).resolve(), Path(__file__).resolve()):
+        roots.extend((anchor, *anchor.parents[:6]))
+    seen: set[Path] = set()
+    for root in roots:
+        candidate = root / "platform" / ".env"
+        if candidate in seen:
+            continue
+        seen.add(candidate)
+        if candidate.is_file():
+            return candidate
+    return Path.cwd() / "platform" / ".env"
+
+
+def _environment_file(values: MutableMapping[str, str]) -> tuple[Path, bool]:
+    configured = values.get("SUBACTOR_ENV_FILE", "").strip()
+    return (Path(configured).expanduser(), True) if configured else (default_environment_file(), False)
+
+
+def _read_selected_values(path: Path, *, explicit: bool) -> dict[str, str]:
+    if not path.exists():
+        if explicit:
+            raise ControlEnvironmentError("SUBACTOR_ENV_FILE nie istnieje")
+        return {}
+    if path.is_symlink() or not path.is_file():
+        raise ControlEnvironmentError("Plik Control environment musi być zwykłym plikiem")
+    try:
+        metadata = path.stat()
+    except OSError as exc:
+        raise ControlEnvironmentError("Nie można sprawdzić pliku Control environment") from exc
+    if metadata.st_size > _MAX_ENV_BYTES:
+        raise ControlEnvironmentError("Plik Control environment jest zbyt duży")
+    if stat.S_IMODE(metadata.st_mode) & 0o022:
+        raise ControlEnvironmentError("Plik Control environment nie może być zapisywalny dla grupy ani innych")
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise ControlEnvironmentError("Nie można odczytać pliku Control environment") from exc
+    selected: dict[str, str] = {}
+    for line in content.splitlines():
+        key, separator, value = line.partition("=")
+        if separator and key in _ALLOWED_KEYS and key not in selected:
+            selected[key] = value.strip().strip("\"'")
+    return selected
+
+
+def apply_control_environment(values: MutableMapping[str, str] | None = None) -> tuple[str, ...]:
+    """Populate missing Control keys from one validated file; values are never logged."""
+
+    target = os.environ if values is None else values
+    path, explicit = _environment_file(target)
+    loaded = _read_selected_values(path, explicit=explicit)
+    applied: list[str] = []
+    for key, value in loaded.items():
+        if value and not target.get(key):
+            target[key] = value
+            applied.append(key)
+    if not target.get("SUBACTOR_CONTROL_URL") and target.get("SUBACTOR_FOUNDER_URL"):
+        target["SUBACTOR_CONTROL_URL"] = target["SUBACTOR_FOUNDER_URL"]
+        applied.append("SUBACTOR_CONTROL_URL")
+    return tuple(applied)

subactor_shell/intent_ir.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+
+class IntentValidationError(ValueError):
+    pass
+
+
+_ALLOWED_MODES = {"ask", "plan", "execute"}
+_FORBIDDEN_ARGUMENT_NAMES = {
+    "cmd",
+    "command",
+    "shell",
+    "script",
+    "executable",
+    "endpoint",
+    "connector",
+    "connector_id",
+    "api_key",
+    "password",
+    "secret",
+    "token",
+}
+
+
+@dataclass(slots=True)
+class IntentIR:
+    v: int
+    intent_id: str
+    mode: str = "execute"
+    args: dict[str, Any] = field(default_factory=dict)
+    requirements: list[str] = field(default_factory=list)
+    constraints: list[str] = field(default_factory=list)
+    unresolved: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> "IntentIR":
+        if not isinstance(payload, dict):
+            raise IntentValidationError("IntentIR musi być obiektem JSON")
+        allowed_top = {
+            "v",
+            "intent_id",
+            "mode",
+            "args",
+            "requirements",
+            "constraints",
+            "unresolved",
+        }
+        unknown_top = set(payload) - allowed_top
+        if unknown_top:
+            raise IntentValidationError(
+                "IntentIR zawiera nieznane pola: " + ", ".join(sorted(unknown_top))
+            )
+        if payload.get("v", 1) != 1:
+            raise IntentValidationError("Obsługiwana jest wyłącznie wersja IntentIR v1")
+        intent_id = payload.get("intent_id")
+        if not isinstance(intent_id, str) or not intent_id.strip():
+            raise IntentValidationError("intent_id jest wymagany")
+        mode = payload.get("mode", "execute")
+        if mode not in _ALLOWED_MODES:
+            raise IntentValidationError("mode musi być ask, plan albo execute")
+        args = payload.get("args", {})
+        if not isinstance(args, dict):
+            raise IntentValidationError("args musi być obiektem")
+        clean_args: dict[str, Any] = {}
+        for raw_name, value in args.items():
+            name = str(raw_name)
+            if name.casefold() in _FORBIDDEN_ARGUMENT_NAMES:
+                raise IntentValidationError(
+                    f"Argument '{name}' jest zarezerwowany; model nie może wybierać wykonawcy ani sekretu"
+                )
+            _validate_json_value(name, value)
+            clean_args[name] = value
+
+        def string_list(name: str) -> list[str]:
+            value = payload.get(name, [])
+            if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
+                raise IntentValidationError(f"{name} musi być tablicą stringów")
+            return list(dict.fromkeys(item.strip() for item in value if item.strip()))
+
+        return cls(
+            v=1,
+            intent_id=intent_id.strip(),
+            mode=mode,
+            args=clean_args,
+            requirements=string_list("requirements"),
+            constraints=string_list("constraints"),
+            unresolved=string_list("unresolved"),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "v": 1,
+            "intent_id": self.intent_id,
+            "mode": self.mode,
+            "args": self.args,
+            "requirements": self.requirements,
+            "constraints": self.constraints,
+            "unresolved": self.unresolved,
+        }
+
+
+def _validate_json_value(name: str, value: Any) -> None:
+    if isinstance(value, str):
+        lowered = value.casefold()
+        if "{{secret:" in lowered or lowered.startswith(("vault://", "env://", "file://")):
+            raise IntentValidationError(
+                f"Argument '{name}' nie może zawierać sekretu ani referencji do sekretu"
+            )
+        if len(value) > 4096:
+            raise IntentValidationError(f"Argument '{name}' jest zbyt długi")
+        return
+    if value is None or isinstance(value, (bool, int, float)):
+        return
+    if isinstance(value, list):
+        if len(value) > 64:
+            raise IntentValidationError(f"Argument '{name}' ma zbyt wiele elementów")
+        for item in value:
+            if isinstance(item, (dict, list)):
+                raise IntentValidationError("Zagnieżdżone struktury nie są dozwolone w IntentIR")
+            _validate_json_value(name, item)
+        return
+    raise IntentValidationError(f"Nieobsługiwany typ argumentu '{name}'")
+
+
+def parse_json_object(text: str) -> dict[str, Any]:
+    candidate = text.strip()
+    if candidate.startswith("```"):
+        lines = candidate.splitlines()
+        if lines and lines[0].startswith("```"):
+            lines = lines[1:]
+        if lines and lines[-1].strip() == "```":
+            lines = lines[:-1]
+        candidate = "\n".join(lines).strip()
+    try:
+        parsed = json.loads(candidate)
+    except json.JSONDecodeError:
+        start = candidate.find("{")
+        end = candidate.rfind("}")
+        if start < 0 or end <= start:
+            raise IntentValidationError("Model nie zwrócił obiektu JSON")
+        try:
+            parsed = json.loads(candidate[start : end + 1])
+        except json.JSONDecodeError as exc:
+            raise IntentValidationError("Niepoprawny JSON zwrócony przez model") from exc
+    if not isinstance(parsed, dict):
+        raise IntentValidationError("Model musi zwrócić jeden obiekt JSON")
+    return parsed
+
+
+def intent_ir_schema(candidate_ids: list[str]) -> dict[str, Any]:
+    intent_property: dict[str, Any] = {"type": "string", "minLength": 1}
+    if candidate_ids:
+        intent_property["enum"] = candidate_ids
+    scalar: dict[str, Any] = {"type": ["string", "number", "integer", "boolean", "null"]}
+    return {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "title": "SubactorIntentIRV1",
+        "type": "object",
+        "additionalProperties": False,
+        "required": [
+            "v",
+            "intent_id",
+            "mode",
+            "args",
+            "requirements",
+            "constraints",
+            "unresolved",
+        ],
+        "properties": {
+            "v": {"const": 1},
+            "intent_id": intent_property,
+            "mode": {"type": "string", "enum": ["ask", "plan", "execute"]},
+            "args": {
+                "type": "object",
+                "additionalProperties": {
+                    "anyOf": [scalar, {"type": "array", "maxItems": 64, "items": scalar}]
+                },
+            },
+            "requirements": {"type": "array", "items": {"type": "string"}},
+            "constraints": {"type": "array", "items": {"type": "string"}},
+            "unresolved": {"type": "array", "items": {"type": "string"}},
+        },
+    }

subactor_shell/models.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Literal
+
+Role = Literal["system", "user", "assistant"]
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+@dataclass(slots=True)
+class Session:
+    id: str
+    name: str
+    provider: str
+    model: str
+    created_at: str
+    updated_at: str
+
+
+@dataclass(slots=True)
+class Message:
+    id: int
+    session_id: str
+    role: Role
+    display_content: str
+    context_content: str
+    metadata: dict[str, Any]
+    created_at: str
+
+
+@dataclass(slots=True)
+class Artifact:
+    id: str
+    original_path: str
+    stored_path: Path
+    mime_type: str
+    size: int
+    created_at: str
+
+
+@dataclass(slots=True)
+class ProviderProfile:
+    name: str
+    kind: str
+    model: str
+    base_url: str = ""
+    endpoint: str = ""
+    api_key_ref: str = ""
+    auth_required: bool = False
+    max_tokens: int = 4096
+    max_output_tokens: int = 256
+    structured_mode: str = "auto"
+    reasoning_effort: str = ""
+    anthropic_version: str = "2023-06-01"
+    timeout_seconds: float = 120.0
+    extra_headers: dict[str, str] = field(default_factory=dict)
+    input_cost_per_million: float = 0.0
+    cached_input_cost_per_million: float = 0.0
+    output_cost_per_million: float = 0.0
+
+
+@dataclass(slots=True)
+class ChatChunk:
+    text: str
+
+
+@dataclass(slots=True)
+class PreparedPrompt:
+    display_content: str
+    safe_context_content: str
+    provider_content: str
+    resolved_secret_values: list[str]
+    metadata: dict[str, Any]