crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_core/computer_use_mode.py

@@ -0,0 +1,38 @@
+"""Resolve the implicit target against the connected executor, not the Gateway OS."""
+
+from typing import Any
+
+
+def effective_computer_use_mode(session: Any) -> str:
+    """Adapt only the omitted default; explicit targets and permissions never change."""
+    mode = getattr(session, "computer_use_mode", "background_app")
+    if mode not in ("background_app", "foreground_desktop"):
+        mode = "background_app"
+    configured = getattr(getattr(session, "settings", None), "computer_use", None)
+    if (
+        mode != "background_app"
+        or configured is None
+        or getattr(session, "_computer_use_mode_override", None) is not None
+        or "target_scope" in getattr(configured, "model_fields_set", {"target_scope"})
+        or getattr(
+            session, "effective_computer_use_delivery_policy",
+            getattr(session, "computer_use_delivery_policy", "allow_foreground"),
+        ) != "allow_foreground"
+    ):
+        return mode
+    backend = getattr(session, "computer_use_backend", None)
+    capabilities = getattr(backend, "capabilities", None)
+    caps = (
+        capabilities(getattr(session, "computer_use_host_id", None))
+        if callable(capabilities) else {}
+    )
+    modes = caps.get("supported_modes") if isinstance(caps, dict) else None
+    if (
+        isinstance(caps, dict)
+        and caps.get("platform") in ("windows", "win32")
+        and isinstance(modes, list)
+        and "foreground_desktop" in modes
+        and "background_app" not in modes
+    ):
+        return "foreground_desktop"
+    return mode

crabcode_core/computer_use_observation.py

@@ -0,0 +1,144 @@
+"""Compact, indexed AX text for model requests; native receipts stay structured."""
+
+from __future__ import annotations
+
+import json
+import re
+from difflib import unified_diff
+from typing import Any
+
+
+TREE_FORMAT = "indexed_text_v1"
+_ELEMENT_ID = re.compile(r"e[0-9]+\Z")
+_ROLES = {
+    "AXWindow": "window", "AXGroup": "container", "AXWebArea": "web content",
+    "AXStaticText": "text", "AXTextField": "text field", "AXTextArea": "text area",
+    "AXButton": "button", "AXImage": "image", "AXLink": "link",
+    "AXScrollArea": "scroll area", "AXCheckBox": "checkbox", "AXRadioButton": "radio button",
+    "AXPopUpButton": "pop up button", "AXComboBox": "combo box", "AXMenuItem": "menu item",
+    "AXCloseButton": "close button", "AXMinimizeButton": "minimize button",
+    "AXZoomButton": "zoom button", "AXFullScreenButton": "full screen button",
+    "AXStandardWindow": "window", "AXSecureTextField": "secure text field",
+}
+
+
+def _label(value: Any) -> str:
+    # Keep UI content on one quoted line, including text that resembles tree syntax.
+    return json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+
+
+def _node_text(node: dict[str, Any]) -> str:
+    role = str(node.get("role") or "element")
+    label_role = str(node.get("subrole") or role)
+    parts = [_ROLES.get(label_role, label_role.removeprefix("AX"))]
+    flags = []
+    allowed = node.get("allowed_actions") or []
+    if node.get("enabled") is False:
+        flags.append("disabled")
+        allowed = []
+    elif not node.get("protected"):
+        if "AXPress" in allowed or "AXPick" in allowed:
+            flags.append("press")
+        if node.get("allow_set_value"):
+            flags.append("settable")
+    if node.get("selected"):
+        flags.append("selected")
+    if node.get("focused"):
+        flags.append("focused")
+    if node.get("protected"):
+        flags.append("protected")
+        allowed = []
+    if flags:
+        parts.append(f"({', '.join(flags)})")
+    seen = []
+    for field in ("title", "description", "value"):
+        value = node.get(field)
+        if node.get("protected") and field != "title":
+            continue
+        if value is None or value == "" or value in seen:
+            continue
+        seen.append(value)
+        parts.append(("Value: " if field == "value" and len(seen) > 1 else "") + _label(value))
+    secondary = [a for a in allowed if a not in ("AXPress", "AXPick") and not (
+        role in ("AXStaticText", "AXImage", "AXGroup") and a in ("AXShowMenu", "AXScrollToVisible")
+    )]
+    if secondary:
+        parts.append("Secondary Actions: " + ", ".join(secondary))
+    return " ".join(parts)
+
+
+def compact_ax_result(result: dict[str, Any]) -> dict[str, Any]:
+    """Return a model-only projection, without mutating the host data or images."""
+    accessibility = result.get("accessibility")
+    if not isinstance(accessibility, dict) or not isinstance(accessibility.get("elements"), list):
+        return result
+    nodes = {
+        node["element_id"]: node for node in accessibility["elements"]
+        if isinstance(node, dict) and isinstance(node.get("element_id"), str)
+        and _ELEMENT_ID.fullmatch(node["element_id"])
+    }
+    children: dict[str | None, list[str]] = {}
+    for element_id, node in nodes.items():
+        parent = node.get("parent_id")
+        if parent not in nodes or parent == element_id:
+            parent = None
+        children.setdefault(parent, []).append(element_id)
+    merged_values: dict[str, str] = {}
+    merged_away: set[str] = set()
+    # Rich text often exposes one AXStaticText per styled span. Join adjacent
+    # passive leaves under the same parent, never controls or protected values.
+    # The representative ID is still a real native node; it advertises no input.
+    for siblings in children.values():
+        run: list[str] = []
+        for element_id in [*siblings, None]:
+            node = nodes.get(element_id, {})
+            plain_text = (node.get("role") == "AXStaticText" and isinstance(node.get("value"), str)
+                          and not node.get("title") and not node.get("description")
+                          and not children.get(element_id) and node.get("enabled") is not False
+                          and not any(node.get(flag) for flag in ("protected", "focused", "selected", "allow_set_value"))
+                          and set(node.get("allowed_actions") or []) <= {"AXShowMenu", "AXScrollToVisible"})
+            if plain_text:
+                run.append(element_id)
+                continue
+            if len(run) > 1:
+                merged_values[run[0]] = " ".join(nodes[key]["value"] for key in run)
+                merged_away.update(run[1:])
+            run = []
+    lines = []
+    visited = set()
+    # DFS makes document text readable even when an older host returns BFS JSON.
+    pending = [(root, 0) for root in reversed(children.get(None, []))]
+    # Appending disconnected nodes also tolerates malformed cyclic parents.
+    pending = [(element_id, 0) for element_id in reversed(nodes)] + pending
+    while pending:
+        element_id, depth = pending.pop()
+        if element_id in visited:
+            continue
+        visited.add(element_id)
+        if element_id in merged_away:
+            continue
+        node = nodes[element_id]
+        if element_id in merged_values:
+            node = {**node, "value": merged_values[element_id]}
+        lines.append("\t" * min(depth, 64) + element_id + " " + _node_text(node))
+        pending.extend((child, depth + 1) for child in reversed(children.get(element_id, [])))
+    tree = {k: v for k, v in accessibility.items() if k not in ("elements", "coordinate_space")}
+    tree.update(tree_format=TREE_FORMAT, element_count=len(lines), source_element_count=len(nodes), tree="\n".join(lines))
+    return {**result, "accessibility": tree}
+
+
+def diff_ax_tree(previous: dict[str, Any], current: dict[str, Any]) -> dict[str, Any]:
+    """Use a delta only when it is smaller and its full base remains in context."""
+    if (previous.get("tree_format") != TREE_FORMAT or current.get("tree_format") != TREE_FORMAT
+            or not previous.get("snapshot_id") or not current.get("snapshot_id")
+            or not isinstance(previous.get("tree"), str) or not isinstance(current.get("tree"), str)):
+        return current
+    # Standard hunks preserve parent indentation AND sibling reading order,
+    # including inserted/removed/reordered elements whose IDs may be renumbered.
+    changes = list(unified_diff(previous["tree"].splitlines(), current["tree"].splitlines(), n=1, lineterm=""))[2:]
+    delta = {
+        **{k: v for k, v in current.items() if k != "tree"},
+        "base_snapshot_id": previous["snapshot_id"],
+        "tree_delta": "\n".join(changes) if changes else "No change in the accessibility tree.",
+    }
+    return delta if len(json.dumps(delta, ensure_ascii=False)) < len(json.dumps(current, ensure_ascii=False)) else current

crabcode_core/config/__init__.py

@@ -0,0 +1,3 @@
+from crabcode_core.config.manager import ConfigManager
+
+__all__ = ["ConfigManager"]

crabcode_core/config/claudemd.py

@@ -0,0 +1,61 @@
+"""CLAUDE.md discovery — finds and loads CLAUDE.md files from the project hierarchy."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.paths import get_config_home
+
+logger = get_logger(__name__)
+
+
+def discover_claude_md(cwd: str) -> list[dict[str, str]]:
+    """Discover all CLAUDE.md files in the project hierarchy.
+
+    Returns list of dicts with 'path' and 'content' keys,
+    ordered from most general (home) to most specific (project root).
+    """
+    results: list[dict[str, str]] = []
+    home = Path.home()
+
+    global_files = [home / ".claude" / "CLAUDE.md", get_config_home() / "CLAUDE.md"]
+    for home_md in global_files:
+        if home_md.exists():
+            try:
+                content = home_md.read_text(encoding="utf-8", errors="replace")
+                results.append({"path": str(home_md), "content": content})
+            except Exception:
+                logger.warning("Failed to read %s", home_md, exc_info=True)
+
+    search_dir = Path(cwd).resolve()
+    project_files: list[dict[str, str]] = []
+
+    current = search_dir
+    while current != current.parent:
+        for name in ["CLAUDE.md", ".claude/CLAUDE.md", ".crabcode/CLAUDE.md"]:
+            candidate = current / name
+            # User-global files are handled above, including a relocated home.
+            if candidate in global_files or (current == home and name != "CLAUDE.md"):
+                continue
+            if candidate.exists():
+                try:
+                    content = candidate.read_text(encoding="utf-8", errors="replace")
+                    project_files.append({"path": str(candidate), "content": content})
+                except Exception:
+                    logger.warning("Failed to read %s", candidate, exc_info=True)
+        if (current / ".git").exists():
+            break
+        current = current.parent
+
+    results.extend(reversed(project_files))
+    return results
+
+
+def load_claude_md_as_string(cwd: str) -> str | None:
+    """Load all CLAUDE.md files and join them into a single string."""
+    files = discover_claude_md(cwd)
+    if not files:
+        return None
+    return "\n\n---\n\n".join(f["content"] for f in files)

crabcode_core/config/manager.py

@@ -0,0 +1,237 @@
+"""Configuration manager — 5-layer settings merge with Pydantic validation."""
+
+from __future__ import annotations
+
+import json
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.paths import get_config_home
+from crabcode_core.text_io import read_utf8_text, write_utf8_text
+from crabcode_core.types.config import (
+    ComputerUseSettings,
+    CrabCodeSettings,
+    GatewaySecuritySettings,
+    GatewayWorkspaceSettings,
+)
+
+logger = get_logger(__name__)
+
+
+SETTING_SOURCES = [
+    "userSettings",
+    "projectSettings",
+    "localSettings",
+    "flagSettings",
+    "policySettings",
+]
+
+
+def _merge_settings(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    """Deep merge two settings dicts. Arrays are concatenated and deduped."""
+    result = deepcopy(base)
+    for key, value in override.items():
+        # Normalize each layer before merging: a higher-priority legacy mode
+        # must override a lower-priority target_scope without granting input.
+        if (
+            key == "computer_use"
+            and isinstance(value, dict)
+            and value.get("mode") in ("background_app", "foreground_desktop")
+        ):
+            value = ComputerUseSettings.migrate_mode(value)
+        if key in result:
+            if isinstance(result[key], list) and isinstance(value, list):
+                seen: set[str] = set()
+                merged: list[Any] = []
+                for item in result[key] + value:
+                    item_key = json.dumps(item, sort_keys=True) if isinstance(item, dict) else str(item)
+                    if item_key not in seen:
+                        seen.add(item_key)
+                        merged.append(item)
+                result[key] = merged
+            elif isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = _merge_settings(result[key], value)
+            else:
+                result[key] = deepcopy(value)
+        else:
+            result[key] = deepcopy(value)
+    return result
+
+
+class ConfigManager:
+    """Manages CrabCode settings from multiple sources.
+
+    Merge order (later overrides earlier):
+        userSettings -> projectSettings -> localSettings -> flagSettings -> policySettings
+    """
+
+    def __init__(
+        self,
+        cwd: str = ".",
+        flag_settings_path: str | None = None,
+    ):
+        self._cwd = cwd
+        self._flag_settings_path = flag_settings_path
+        self._cache: CrabCodeSettings | None = None
+
+    @property
+    def settings_file_paths(self) -> dict[str, str | None]:
+        home = get_config_home()
+        project = Path(self._cwd).resolve()
+        return {
+            "userSettings": str(home / "settings.json"),
+            "projectSettings": str(project / ".crabcode" / "settings.json"),
+            "localSettings": str(project / ".crabcode" / "settings.local.json"),
+            "flagSettings": self._flag_settings_path,
+            "policySettings": str(home / "managed-settings.json"),
+        }
+
+    def load(self) -> CrabCodeSettings:
+        """Load and merge all settings layers."""
+        merged: dict[str, Any] = {}
+
+        for source in SETTING_SOURCES:
+            path_str = self.settings_file_paths.get(source)
+            if not path_str:
+                continue
+
+            path = Path(path_str)
+            if not path.exists():
+                continue
+
+            try:
+                raw = json.loads(read_utf8_text(path).text)
+                if isinstance(raw, dict):
+                    merged = _merge_settings(merged, raw)
+            except (json.JSONDecodeError, OSError, UnicodeError):
+                logger.warning("Failed to load settings source: %s", path, exc_info=True)
+                continue
+
+        try:
+            self._cache = CrabCodeSettings.model_validate(merged)
+        except Exception:
+            logger.exception("Failed to validate merged settings; using defaults")
+            self._cache = CrabCodeSettings()
+
+        return self._cache
+
+    def get(self) -> CrabCodeSettings:
+        """Get cached settings or load from disk."""
+        if self._cache is None:
+            return self.load()
+        return self._cache
+
+    def reset_cache(self) -> None:
+        """Clear the cached settings."""
+        self._cache = None
+
+    def load_gateway_security(
+        self,
+        overrides: dict[str, Any] | None = None,
+    ) -> GatewaySecuritySettings:
+        """Load process-level gateway security without project overrides.
+
+        A repository must not be able to weaken authentication for a gateway
+        launched from that repository. CLI overrides sit between user and
+        managed policy settings, matching the normal precedence model.
+        """
+        merged: dict[str, Any] = {}
+        for source in ("userSettings",):
+            raw = self.get_settings_for_source(source) or {}
+            gateway = raw.get("gateway", {})
+            security = gateway.get("security", {}) if isinstance(gateway, dict) else {}
+            if isinstance(security, dict):
+                merged = _merge_settings(merged, security)
+        if overrides:
+            merged = _merge_settings(merged, overrides)
+        raw_policy = self.get_settings_for_source("policySettings") or {}
+        policy_gateway = raw_policy.get("gateway", {})
+        policy_security = (
+            policy_gateway.get("security", {})
+            if isinstance(policy_gateway, dict)
+            else {}
+        )
+        if isinstance(policy_security, dict):
+            merged = _merge_settings(merged, policy_security)
+        return GatewaySecuritySettings.model_validate(merged)
+
+    def load_gateway_workspace(self) -> GatewayWorkspaceSettings:
+        """Load filesystem discovery policy without project overrides."""
+        merged: dict[str, Any] = {}
+        raw_user = self.get_settings_for_source("userSettings") or {}
+        user_gateway = raw_user.get("gateway", {})
+        user_workspace = (
+            user_gateway.get("workspace", {})
+            if isinstance(user_gateway, dict)
+            else {}
+        )
+        if isinstance(user_workspace, dict):
+            merged = _merge_settings(merged, user_workspace)
+
+        raw_policy = self.get_settings_for_source("policySettings") or {}
+        policy_gateway = raw_policy.get("gateway", {})
+        policy_workspace = (
+            policy_gateway.get("workspace", {})
+            if isinstance(policy_gateway, dict)
+            else {}
+        )
+        if isinstance(policy_workspace, dict):
+            merged = _merge_settings(merged, policy_workspace)
+        return GatewayWorkspaceSettings.model_validate(merged)
+
+    def get_settings_for_source(self, source: str) -> dict[str, Any] | None:
+        """Get raw settings from a single source."""
+        path_str = self.settings_file_paths.get(source)
+        if not path_str:
+            return None
+
+        path = Path(path_str)
+        if not path.exists():
+            return None
+
+        try:
+            raw = json.loads(read_utf8_text(path).text)
+            return raw if isinstance(raw, dict) else None
+        except (json.JSONDecodeError, OSError, UnicodeError):
+            logger.warning("Failed to read settings source: %s", path, exc_info=True)
+            return None
+
+    def update_settings(
+        self,
+        source: str,
+        settings: dict[str, Any],
+    ) -> None:
+        """Update settings for a given source."""
+        if source in ("policySettings", "flagSettings"):
+            return
+
+        path_str = self.settings_file_paths.get(source)
+        if not path_str:
+            return
+
+        path = Path(path_str)
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        existing: dict[str, Any] = {}
+        newline = "\n"
+        has_bom = False
+        if path.exists():
+            try:
+                source = read_utf8_text(path)
+                existing = json.loads(source.text)
+                newline = source.newline or newline
+                has_bom = source.has_bom
+            except (json.JSONDecodeError, OSError, UnicodeError):
+                logger.warning("Failed to read existing settings before update: %s", path, exc_info=True)
+
+        merged = _merge_settings(existing, settings)
+        write_utf8_text(
+            path,
+            json.dumps(merged, indent=2, ensure_ascii=False) + "\n",
+            newline=newline,
+            has_bom=has_bom,
+        )
+
+        self.reset_cache()