seedcode-cli 6.1.5__py3-none-any.whl

seedcode/computer/permissions.py

@@ -0,0 +1,203 @@
+"""Desktop Control permission group: Y[once] / A[always] / N[deny] grants.
+
+Filesystem permissions (see :mod:`seedcode.tools.permissions`) bound WHERE the
+agent may act; this module bounds WHETHER it may touch the desktop at all.
+Grants are per-category and session-only — nothing here is persisted, so a
+fresh session always starts with a fresh ask. Sensitive categories (registry
+writes, secrets, purchases, system power, deletions) can never be granted
+"Always": they re-prompt on every single action by design.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Callable
+
+from ..tools.permissions import PermissionError_
+
+
+class DesktopGrant(str, Enum):
+    ONCE = "once"
+    ALWAYS = "always"
+    DENY = "deny"
+
+
+# Categories an action may fall into. `control` covers plain input and
+# observation; the rest gate riskier ground.
+CATEGORY_CONTROL = "control"          # mouse, keyboard, screenshots, window reads
+CATEGORY_APPS = "apps"                # opening / closing applications
+CATEGORY_REGISTRY_READ = "registry_read"
+CATEGORY_NETWORK = "network"          # downloads / non-navigation web transfers
+
+# Sensitive categories: confirmation can never be remembered ("Always" is
+# treated as "Once"), so each individual action is user-approved.
+CATEGORY_REGISTRY_WRITE = "registry_write"
+CATEGORY_SECRET = "type_secret"       # typing passwords / credentials
+CATEGORY_SYSTEM = "system"            # shutdown, restart, system settings
+CATEGORY_DELETE = "delete"            # deleting files via the desktop
+CATEGORY_PURCHASE = "purchase"        # browser purchases / payments
+CATEGORY_INSTALL = "install"          # installing software (never remembered)
+
+SENSITIVE_CATEGORIES = frozenset(
+    {
+        CATEGORY_REGISTRY_WRITE,
+        CATEGORY_SECRET,
+        CATEGORY_SYSTEM,
+        CATEGORY_DELETE,
+        CATEGORY_PURCHASE,
+        CATEGORY_INSTALL,
+    }
+)
+
+# The non-sensitive categories Assist Mode grants up-front in ONE prompt when it
+# starts, so the session never re-asks for routine control during a task. These
+# are exactly the categories a normal automation session touches; sensitive
+# categories are deliberately excluded — they always confirm per action.
+SESSION_GRANT_CATEGORIES: tuple[str, ...] = (
+    CATEGORY_CONTROL,
+    CATEGORY_APPS,
+    CATEGORY_REGISTRY_READ,
+)
+
+CATEGORY_LABELS = {
+    CATEGORY_CONTROL: "Desktop control (mouse, keyboard, screen)",
+    CATEGORY_APPS: "Open / close applications",
+    CATEGORY_REGISTRY_READ: "Read the Windows registry",
+    CATEGORY_NETWORK: "Download files from the web",
+    CATEGORY_REGISTRY_WRITE: "WRITE to the Windows registry",
+    CATEGORY_SECRET: "Type a password or secret",
+    CATEGORY_SYSTEM: "System action (shutdown / restart / settings)",
+    CATEGORY_DELETE: "Delete files via the desktop",
+    CATEGORY_PURCHASE: "Browser purchase / payment",
+    CATEGORY_INSTALL: "Install software",
+}
+
+# confirm(category, description) -> the user's choice for this ask.
+ConfirmCallback = Callable[[str, str], DesktopGrant]
+
+
+def _deny_all(category: str, description: str) -> DesktopGrant:
+    """Default callback when no UI is wired: refuse everything."""
+    return DesktopGrant.DENY
+
+
+@dataclass
+class SessionPermissionManager:
+    """Session-wide desktop grants, requested ONCE when Assist Mode starts.
+
+    This is the fix for "asks for permission on every action": instead of
+    prompting lazily the first time each category is touched, Assist Mode calls
+    :meth:`request` at start-up to grant the whole routine-control set in a
+    single dialog. Every :class:`DesktopSession` created for the session
+    (the app rebuilds them whenever the permission level changes) consults the
+    *same* manager, so a grant made once holds for the entire session and
+    survives those rebuilds.
+
+    Only re-prompt when an action *exceeds* what was granted — i.e. sensitive
+    categories, which are never blanket-granted here and always confirm per
+    action. Nothing is persisted to disk; a new process starts fresh.
+    """
+
+    granted: set[str] = field(default_factory=set)
+    denied: set[str] = field(default_factory=set)
+    requested: bool = False
+
+    def request(self, categories: "list[str] | tuple[str, ...]", allow: bool) -> None:
+        """Record the user's one-time answer for a batch of categories."""
+        self.requested = True
+        for category in categories:
+            if category in SENSITIVE_CATEGORIES:
+                continue  # sensitive is never granted for the whole session
+            if allow:
+                self.granted.add(category)
+                self.denied.discard(category)
+            else:
+                self.denied.add(category)
+                self.granted.discard(category)
+
+    def is_granted(self, category: str) -> bool:
+        return category in self.granted
+
+    def is_denied(self, category: str) -> bool:
+        return category in self.denied
+
+    def reset(self) -> None:
+        """Forget the session decision (Assist Mode turned off)."""
+        self.granted.clear()
+        self.denied.clear()
+        self.requested = False
+
+
+# One manager per process, shared by every DesktopSession the app builds.
+_SESSION = SessionPermissionManager()
+
+
+def session_permissions() -> SessionPermissionManager:
+    """The process-wide :class:`SessionPermissionManager`."""
+    return _SESSION
+
+
+@dataclass
+class DesktopSession:
+    """Session-scoped Desktop Control gate consulted by every desktop tool.
+
+    ``enabled`` mirrors ``config.desktop_mode``; ``confirm`` is wired to the
+    UI prompt by the app layer. :meth:`check` either returns silently or
+    raises :class:`PermissionError_` with text the model can act on.
+    """
+
+    enabled: bool = False
+    confirm: ConfirmCallback = _deny_all
+    grants: dict[str, DesktopGrant] = field(default_factory=dict)
+    # Base64 PNG screenshots queued by observation tools; the agent loop
+    # drains this and attaches images when the provider supports vision.
+    pending_images: list[str] = field(default_factory=list)
+    # Session-wide grants requested once at Assist start-up. When wired by the
+    # app layer, a category the user already approved for the session is never
+    # re-prompted here. None (the default, and in unit tests) preserves the
+    # original lazy per-category behaviour exactly.
+    session: "SessionPermissionManager | None" = None
+
+    def check(self, category: str, description: str) -> None:
+        """Gate one desktop action; raises PermissionError_ when refused."""
+        if not self.enabled:
+            raise PermissionError_(
+                "Blocked: desktop mode is off. The user can enable it with /desktop on."
+            )
+
+        sensitive = category in SENSITIVE_CATEGORIES
+        if not sensitive:
+            # Session-wide decision (asked once at /assist on) takes priority.
+            if self.session is not None:
+                if self.session.is_granted(category):
+                    return
+                if self.session.is_denied(category):
+                    raise PermissionError_(
+                        f"Blocked: the user denied "
+                        f"'{CATEGORY_LABELS.get(category, category)}' for this session."
+                    )
+            granted = self.grants.get(category)
+            if granted is DesktopGrant.ALWAYS:
+                return
+            if granted is DesktopGrant.DENY:
+                raise PermissionError_(
+                    f"Blocked: the user denied '{CATEGORY_LABELS.get(category, category)}' "
+                    "for this session."
+                )
+
+        choice = self.confirm(category, description)
+        if sensitive and choice is DesktopGrant.ALWAYS:
+            # Sensitive actions are approved one at a time, never blanket.
+            choice = DesktopGrant.ONCE
+        if not sensitive and choice in (DesktopGrant.ALWAYS, DesktopGrant.DENY):
+            self.grants[category] = choice
+        if choice is DesktopGrant.DENY:
+            raise PermissionError_(
+                f"Blocked: the user denied this action ({description})."
+            )
+
+    def reset(self) -> None:
+        """Forget all session grants (used when desktop mode toggles)."""
+        self.grants.clear()
+        self.pending_images.clear()

seedcode/computer/recovery.py

@@ -0,0 +1,115 @@
+"""Recovery engine: deterministic reflexes before the AI is asked to replan.
+
+When an action fails verification, the dispatcher hands the situation to the
+recovery engine, which walks a fixed ladder of local strategies — retry,
+refocus the target window, dismiss a stray dialog, re-snapshot the UI, restart
+the app — re-running the action after each. Only when every strategy is
+exhausted does control return to the dispatcher, which then (and only then)
+asks the AI planner to replan.
+
+The engine is deterministic and offline: it composes existing controller
+primitives and never calls an AI provider. Strategies are ordered from
+cheapest/least disruptive to most disruptive so a transient hiccup is fixed
+without, say, killing and relaunching an application.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+# The result of trying to recover: whether the action ultimately succeeded and
+# the trail of strategies attempted (surfaced in logs and to the AI on replan).
+@dataclass(slots=True)
+class RecoveryOutcome:
+    recovered: bool
+    detail: str
+    strategies_tried: list[str] = field(default_factory=list)
+
+
+# An action is a zero-arg callable that performs the operation and returns a
+# short result string; it raises on hard failure. A verify is a zero-arg
+# callable returning a truthy VerifyResult-like object.
+Action = Callable[[], str]
+Verify = Callable[[], Any]
+
+
+class RecoveryEngine:
+    """Applies local recovery strategies to a failed, verified action."""
+
+    def __init__(self, controller: Any = None, state: Any = None) -> None:
+        self._controller = controller
+        self._state = state
+
+    def recover(
+        self,
+        action: Action,
+        verify: Verify,
+        *,
+        window_title: str | None = None,
+        app_target: str | None = None,
+    ) -> RecoveryOutcome:
+        """Try to make ``action`` verify, walking the strategy ladder.
+
+        Each strategy nudges the environment, re-runs the action, then
+        re-verifies. Returns as soon as verification passes.
+        """
+        tried: list[str] = []
+        last = "no recovery strategies applied"
+        for name, strategy in self._ladder(window_title, app_target):
+            tried.append(name)
+            try:
+                strategy()
+            except Exception:
+                # A strategy that itself fails is not fatal — move to the next.
+                continue
+            try:
+                action()
+            except Exception as exc:
+                last = f"retry after {name} raised: {exc}"
+                continue
+            result = verify()
+            if result:
+                return RecoveryOutcome(
+                    True, f"recovered via {name}: {getattr(result, 'detail', 'ok')}", tried
+                )
+            last = f"still failing after {name}: {getattr(result, 'detail', result)}"
+        return RecoveryOutcome(False, last, tried)
+
+    def _ladder(
+        self, window_title: str | None, app_target: str | None
+    ) -> list[tuple[str, Callable[[], None]]]:
+        """Ordered (name, strategy) pairs, cheapest and least disruptive first."""
+        c = self._controller
+        ladder: list[tuple[str, Callable[[], None]]] = []
+
+        # 1) Plain retry: let transient timing settle.
+        ladder.append(("retry", lambda: c.wait(0.5) if c else None))
+
+        # 2) Dismiss a stray modal/tooltip that may be intercepting input.
+        ladder.append(("dismiss_dialog", lambda: c.hotkey(["esc"]) if c else None))
+
+        # 3) Refocus the intended window — the most common real cause.
+        if window_title and c:
+            ladder.append(("refocus_window", lambda: c.focus_window(window_title)))
+
+        # 4) Re-snapshot the UI so the next resolve sees the current tree.
+        if c:
+            ladder.append(("resnapshot", lambda: c.see(window_title)))
+
+        # 5) Restart the app: close then reopen, the most disruptive step.
+        if app_target and c:
+            def _restart() -> None:
+                try:
+                    c.close_app(app_target, force=False)
+                except Exception:
+                    pass
+                c.wait(0.5)
+                c.open_app(app_target)
+                if window_title:
+                    c.wait(0.5)
+                    c.focus_window(window_title)
+
+            ladder.append(("restart_app", _restart))
+
+        return ladder

seedcode/computer/registry.py

@@ -0,0 +1,107 @@
+"""Registry driver: read anywhere, write only through explicit confirmation.
+
+The permission layer (:mod:`seedcode.computer.permissions`) forces a per-write
+user confirmation — this module only performs the operations. Uses the
+standard-library ``winreg``; hive names accept the common long and short
+forms (HKEY_CURRENT_USER / HKCU, ...).
+"""
+
+from __future__ import annotations
+
+import sys
+
+_HIVE_ALIASES = {
+    "hkcu": "HKEY_CURRENT_USER",
+    "hkey_current_user": "HKEY_CURRENT_USER",
+    "hklm": "HKEY_LOCAL_MACHINE",
+    "hkey_local_machine": "HKEY_LOCAL_MACHINE",
+    "hkcr": "HKEY_CLASSES_ROOT",
+    "hkey_classes_root": "HKEY_CLASSES_ROOT",
+    "hku": "HKEY_USERS",
+    "hkey_users": "HKEY_USERS",
+    "hkcc": "HKEY_CURRENT_CONFIG",
+    "hkey_current_config": "HKEY_CURRENT_CONFIG",
+}
+
+_MAX_LIST = 200
+
+
+def _winreg():
+    if sys.platform != "win32":
+        raise RuntimeError("The registry only exists on Windows.")
+    import winreg
+
+    return winreg
+
+
+def parse_key(path: str):
+    """Split 'HKCU\\Software\\...' into (hive handle, subkey, display name)."""
+    winreg = _winreg()
+    raw = (path or "").strip().strip("\\")
+    if not raw:
+        raise ValueError("Registry path is required, e.g. HKCU\\Software\\MyApp.")
+    hive_part, _, subkey = raw.partition("\\")
+    hive_name = _HIVE_ALIASES.get(hive_part.lower())
+    if hive_name is None:
+        raise ValueError(
+            f"Unknown registry hive '{hive_part}'. "
+            "Use HKCU, HKLM, HKCR, HKU, or HKCC."
+        )
+    return getattr(winreg, hive_name), subkey, f"{hive_name}\\{subkey}".rstrip("\\")
+
+
+def read_value(path: str, name: str) -> str:
+    """Read one value ('' name means the key's default value)."""
+    winreg = _winreg()
+    hive, subkey, display = parse_key(path)
+    with winreg.OpenKey(hive, subkey) as key:
+        value, kind = winreg.QueryValueEx(key, name or "")
+    return f"{display} : {name or '(default)'} = {value!r} (type {kind})"
+
+
+def list_key(path: str) -> str:
+    """List a key's subkeys and values."""
+    winreg = _winreg()
+    hive, subkey, display = parse_key(path)
+    subkeys: list[str] = []
+    values: list[str] = []
+    with winreg.OpenKey(hive, subkey) as key:
+        info = winreg.QueryInfoKey(key)
+        for i in range(min(info[0], _MAX_LIST)):
+            subkeys.append(winreg.EnumKey(key, i))
+        for i in range(min(info[1], _MAX_LIST)):
+            name, value, kind = winreg.EnumValue(key, i)
+            values.append(f"{name or '(default)'} = {value!r} (type {kind})")
+    lines = [f"{display}:"]
+    if subkeys:
+        lines.append("  subkeys: " + ", ".join(subkeys))
+    if values:
+        lines += [f"  {v}" for v in values]
+    if not subkeys and not values:
+        lines.append("  (empty)")
+    return "\n".join(lines)
+
+
+def write_value(path: str, name: str, value: str, value_type: str = "REG_SZ") -> str:
+    """Create/overwrite a string or dword value (key is created if missing)."""
+    winreg = _winreg()
+    hive, subkey, display = parse_key(path)
+    kind_name = value_type.strip().upper()
+    if kind_name == "REG_SZ":
+        kind, data = winreg.REG_SZ, str(value)
+    elif kind_name == "REG_DWORD":
+        kind, data = winreg.REG_DWORD, int(value)
+    else:
+        raise ValueError("Only REG_SZ and REG_DWORD writes are supported.")
+    with winreg.CreateKey(hive, subkey) as key:
+        winreg.SetValueEx(key, name or "", 0, kind, data)
+    return f"Wrote {display} : {name or '(default)'} = {data!r} ({kind_name})"
+
+
+def delete_value(path: str, name: str) -> str:
+    """Delete one value from a key."""
+    winreg = _winreg()
+    hive, subkey, display = parse_key(path)
+    with winreg.OpenKey(hive, subkey, 0, winreg.KEY_SET_VALUE) as key:
+        winreg.DeleteValue(key, name or "")
+    return f"Deleted {display} : {name or '(default)'}"