code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/acp/io_delegation.py

@@ -0,0 +1,231 @@
+"""Wire Code Puppy's I/O backends to the client (file reads/writes + terminal).
+
+This is the delegation layer that makes Code Puppy *truly native* inside the client:
+workspace file reads/writes go through the client's ``fs/*`` methods (so edits show in
+the client's diff UI and reads see unsaved buffers), and shell commands run through
+the client's ``terminal/*`` methods (so they execute in the client's terminal).
+
+It plugs into the two general core seams in ``code_puppy.tools.io_backends``:
+
+* ``FileSystemBackend`` is **synchronous** — file tools run in Code Puppy's
+  tool threadpool, so ``DelegatedFileSystemBackend`` bridges to the ACP event loop
+  with ``run_coroutine_threadsafe`` (same pattern as the approval backend).
+* ``CommandExecutor`` is **asynchronous** — the shell tool awaits it on the
+  loop, so ``DelegatedCommandExecutor`` calls the client directly.
+
+Both are installed only when the connected client advertises the matching
+capability in ``initialize``; otherwise Code Puppy keeps doing that I/O
+locally. Everything talks to the client through the SDK's ``AgentSideConnection``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import sys
+from typing import Any, List, Optional, Tuple
+
+from code_puppy_core_plugins.acp import capabilities, state
+from code_puppy.tools.io_backends import (
+    DirEntry,
+    ExecResult,
+    set_command_executor,
+    set_filesystem_backend,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def shell_invocation(command: str) -> Tuple[str, List[str]]:
+    """Split a shell string into ``(program, args)`` for ``terminal/create``.
+
+    ACP's ``terminal/create`` takes a program + argv, so we run the command
+    string through the platform shell (``sh -c`` / ``cmd /c``).
+    """
+    if sys.platform.startswith("win"):
+        return "cmd", ["/c", command]
+    return "/bin/sh", ["-c", command]
+
+
+class DelegatedFileSystemBackend:
+    """Workspace file I/O that delegates *content* to the client's ``fs/*``.
+
+    Called from Code Puppy's tool threadpool, so the content methods bridge to
+    the ACP loop via ``run_coroutine_threadsafe`` and block the worker for the
+    answer. The loop stays free to service the round-trip, so there's no
+    deadlock; a guard bails out if we ever end up on the loop thread itself.
+
+    Topology/metadata (exists / is_file / is_dir / list_dir / delete /
+    make_dirs) is served from the **local disk**: an ACP editor host runs on
+    the same machine and workspace as the agent, so the local filesystem is the
+    authoritative source for what exists and how the tree is shaped -- only
+    *content* carries the host's unsaved-buffer overlay. This "topology is
+    local" decision lives here, in the adapter that legitimately knows its host
+    shares the disk, and never leaks into the general ``FileSystemBackend``
+    seam (a remote/virtual backend would implement these against its own store).
+    """
+
+    def read_text_file(
+        self, path: str, line: Optional[int] = None, limit: Optional[int] = None
+    ) -> str:
+        async def _read(conn: Any, sid: str) -> str:
+            response = await conn.read_text_file(
+                path=path, session_id=sid, line=line, limit=limit
+            )
+            return getattr(response, "content", "") or ""
+
+        return self._bridge(_read)
+
+    def write_text_file(self, path: str, content: str) -> None:
+        async def _write(conn: Any, sid: str) -> None:
+            await conn.write_text_file(content=content, path=path, session_id=sid)
+
+        self._bridge(_write)
+
+    # --- topology / metadata: local disk (host shares it) ------------------
+    def exists(self, path: str) -> bool:
+        return os.path.exists(path)
+
+    def is_file(self, path: str) -> bool:
+        return os.path.isfile(path)
+
+    def is_dir(self, path: str) -> bool:
+        return os.path.isdir(path)
+
+    def list_dir(self, path: str) -> List[DirEntry]:
+        if not os.path.exists(path):
+            raise FileNotFoundError(path)
+        if not os.path.isdir(path):
+            raise NotADirectoryError(path)
+        entries: List[DirEntry] = []
+        for name in os.listdir(path):
+            full = os.path.join(path, name)
+            try:
+                if os.path.isdir(full):
+                    entries.append(DirEntry(name=name, is_dir=True, size=0))
+                elif os.path.isfile(full):
+                    size = os.path.getsize(full)
+                    entries.append(DirEntry(name=name, is_dir=False, size=size))
+            except OSError:
+                continue
+        return entries
+
+    def delete_file(self, path: str) -> None:
+        os.remove(path)
+
+    def make_dirs(self, path: str) -> None:
+        if path:
+            os.makedirs(path, exist_ok=True)
+
+    def _bridge(self, make_coro):
+        connection = state.get_connection()
+        loop = state.get_loop()
+        session_id = state.get_active_session_id()
+        if connection is None or loop is None:
+            raise RuntimeError("ACP filesystem backend used with no active connection")
+        if session_id is None:
+            raise RuntimeError("ACP filesystem backend used outside a session")
+        try:
+            running = asyncio.get_running_loop()
+        except RuntimeError:
+            running = None
+        if running is loop:
+            raise RuntimeError("ACP fs backend hit on the ACP loop (would deadlock)")
+        return asyncio.run_coroutine_threadsafe(
+            make_coro(connection, session_id), loop
+        ).result()
+
+
+class DelegatedCommandExecutor:
+    """Asynchronous shell execution that delegates to the client's ``terminal/*``.
+
+    Awaited on the ACP loop, so it talks to the client directly. Creates a terminal,
+    waits for exit (honoring ``timeout`` — kills on overrun), collects the
+    combined output, and always releases the terminal handle.
+    """
+
+    async def run(self, command: str, cwd: Optional[str], timeout: int) -> ExecResult:
+        connection = state.get_connection()
+        session_id = state.get_active_session_id()
+        if connection is None:
+            raise RuntimeError("ACP command executor used with no active connection")
+        if session_id is None:
+            raise RuntimeError("ACP command executor used outside a session")
+
+        program, args = shell_invocation(command)
+        created = await connection.create_terminal(
+            command=program, session_id=session_id, args=args, cwd=cwd
+        )
+        terminal_id = getattr(created, "terminal_id", None)
+        if not terminal_id:
+            raise RuntimeError("the client did not return a terminalId")
+
+        timed_out = False
+        exit_code: Optional[int] = None
+        try:
+            try:
+                exited = await asyncio.wait_for(
+                    connection.wait_for_terminal_exit(
+                        session_id=session_id, terminal_id=terminal_id
+                    ),
+                    timeout=timeout,
+                )
+                exit_code = getattr(exited, "exit_code", None)
+            except asyncio.TimeoutError:
+                timed_out = True
+                await self._kill(connection, session_id, terminal_id)
+
+            out = await connection.terminal_output(
+                session_id=session_id, terminal_id=terminal_id
+            )
+            output = getattr(out, "output", "") or ""
+            if exit_code is None:
+                status = getattr(out, "exit_status", None)
+                exit_code = getattr(status, "exit_code", None) if status else None
+        finally:
+            await self._release(connection, session_id, terminal_id)
+
+        if exit_code is None:
+            exit_code = -1 if timed_out else 0
+        return ExecResult(exit_code=int(exit_code), output=output, timed_out=timed_out)
+
+    @staticmethod
+    async def _kill(connection: Any, session_id: str, terminal_id: str) -> None:
+        try:
+            await connection.kill_terminal(
+                session_id=session_id, terminal_id=terminal_id
+            )
+        except Exception:  # noqa: BLE001
+            logger.debug("terminal/kill failed", exc_info=True)
+
+    @staticmethod
+    async def _release(connection: Any, session_id: str, terminal_id: str) -> None:
+        try:
+            await connection.release_terminal(
+                session_id=session_id, terminal_id=terminal_id
+            )
+        except Exception:  # noqa: BLE001
+            logger.debug("terminal/release failed", exc_info=True)
+
+
+def install(client_capabilities: Any) -> None:
+    """Install the client-backed I/O backends the client can actually service.
+
+    Capability-gated: only reroute reads/writes if the client advertises fs support,
+    and only reroute shell if the client advertises terminal support. Unsupported
+    edges keep running locally.
+    """
+    fs_read, fs_write, terminal = capabilities.client_io_caps(client_capabilities)
+    if fs_read and fs_write:
+        set_filesystem_backend(DelegatedFileSystemBackend())
+        logger.debug("ACP: delegating workspace file I/O to the client")
+    if terminal:
+        set_command_executor(DelegatedCommandExecutor())
+        logger.debug("ACP: delegating shell execution to the client's terminal")
+
+
+def uninstall() -> None:
+    """Clear both backends so Code Puppy resumes local I/O."""
+    set_filesystem_backend(None)
+    set_command_executor(None)

code_puppy_core_plugins/acp/mcp_config.py

@@ -0,0 +1,66 @@
+"""Attach client-injected MCP servers (from ``session/new``) to a session agent.
+
+ACP lets the client pass MCP server specs per session. We translate each into a
+pydantic-ai MCP server and append it to the agent's ``_mcp_servers`` list;
+``run_with_mcp`` starts them for that session's runs. Best-effort: a malformed
+spec is skipped, never fatal.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _kv(items: Any) -> Dict[str, str]:
+    """Turn a list of ``{name, value}`` models into a plain dict."""
+    out: Dict[str, str] = {}
+    for item in items or []:
+        name = getattr(item, "name", None)
+        if name is not None:
+            out[name] = getattr(item, "value", "") or ""
+    return out
+
+
+def _translate(spec: Any) -> Optional[Any]:
+    """Map one ACP MCP server spec to a pydantic-ai MCP server instance."""
+    from pydantic_ai.mcp import (
+        MCPServerSSE,
+        MCPServerStdio,
+        MCPServerStreamableHTTP,
+    )
+
+    name = getattr(spec, "name", None) or None
+    if getattr(spec, "command", None):
+        return MCPServerStdio(
+            command=spec.command,
+            args=list(getattr(spec, "args", None) or []),
+            env=_kv(getattr(spec, "env", None)) or None,
+            tool_prefix=name,
+        )
+    url = getattr(spec, "url", None)
+    if not url:
+        return None
+    headers = _kv(getattr(spec, "headers", None)) or None
+    if getattr(spec, "type", None) == "sse":
+        return MCPServerSSE(url=url, headers=headers, tool_prefix=name)
+    return MCPServerStreamableHTTP(url=url, headers=headers, tool_prefix=name)
+
+
+def attach(agent: Any, specs: List[Any]) -> None:
+    """Append the translated MCP servers from ``specs`` to ``agent``."""
+    servers: List[Any] = []
+    for spec in specs or []:
+        try:
+            translated = _translate(spec)
+        except Exception:  # noqa: BLE001
+            logger.debug("ACP: could not translate MCP server spec", exc_info=True)
+            continue
+        if translated is not None:
+            servers.append(translated)
+    if not servers:
+        return
+    existing = getattr(agent, "_mcp_servers", None) or []
+    agent._mcp_servers = list(existing) + servers

code_puppy_core_plugins/acp/permissions.py

@@ -0,0 +1,159 @@
+"""ACP permission integration — the client's dialog becomes the approval authority.
+
+Code Puppy has two approval edges, and this module wires both to the client via the
+SDK's ``AgentSideConnection.request_permission`` — without touching core tool
+logic or forcing yolo mode:
+
+* **File operations** go through the pluggable *approval backend* seam in
+  ``code_puppy.tools.common``. Sync file tools run in Code Puppy's tool
+  threadpool, so the backend bridges to the ACP event loop via
+  ``run_coroutine_threadsafe`` to ask the client, then blocks the worker thread for
+  the answer. The loop stays free to service the round-trip — no deadlock.
+* **Shell commands** go through the ``run_shell_command`` hook, which is async
+  and already runs on the ACP loop, so it can ``await`` the client directly.
+
+Both edges fail **closed** (deny) if the connection is gone or the client errors.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from typing import Any, Dict, Optional, Tuple
+
+from acp.schema import PermissionOption, ToolCallUpdate
+
+from code_puppy.callbacks import register_callback
+from code_puppy_core_plugins.acp import state
+
+logger = logging.getLogger(__name__)
+
+# How long to wait for a human in the client to answer a permission dialog. Dialogs
+# can sit for a while; deny (fail closed) if it's truly abandoned.
+_PERMISSION_TIMEOUT_S = 600
+
+# The allow/deny options we present. The client echoes back the chosen ``option_id``.
+_OPTIONS = [
+    PermissionOption(option_id="allow_once", name="Allow", kind="allow_once"),
+    PermissionOption(option_id="reject_once", name="Reject", kind="reject_once"),
+]
+_ALLOW_IDS = {"allow_once"}
+
+
+def _tool_call_ref(title: str) -> ToolCallUpdate:
+    """Build the ``toolCall`` ref a permission request attaches to.
+
+    Reuses the id/title of the tool call currently open (set by
+    ``pre_tool_call``) so the client pins the dialog to the right agent-panel entry;
+    falls back to a standalone id when no tool call is active.
+    """
+    current = state.current_tool_call()
+    if current is not None:
+        name, tool_call_id = current
+        return ToolCallUpdate(tool_call_id=tool_call_id, title=name)
+    return ToolCallUpdate(tool_call_id=f"perm_{uuid.uuid4().hex[:12]}", title=title)
+
+
+async def _ask_client(session_id: str, title: str) -> bool:
+    """Show an allow/deny dialog in the client; return ``True`` if allowed."""
+    connection = state.get_connection()
+    if connection is None:
+        return False
+    try:
+        response = await connection.request_permission(
+            options=list(_OPTIONS),
+            session_id=session_id,
+            tool_call=_tool_call_ref(title),
+        )
+    except Exception:  # noqa: BLE001
+        logger.exception("session/request_permission failed; denying")
+        return False
+    outcome = getattr(response, "outcome", None)
+    if getattr(outcome, "outcome", None) == "selected":
+        return getattr(outcome, "option_id", None) in _ALLOW_IDS
+    return False
+
+
+def _approval_backend(
+    title: str, message: str, preview: Optional[str]
+) -> Tuple[bool, Optional[str]]:
+    """Approval backend for file ops; asks the client from the tool threadpool.
+
+    Returns ``(approved, feedback)``. Feedback is always ``None`` — the client's
+    dialog is yes/no, not a free-text channel.
+    """
+    loop = state.get_loop()
+    session_id = state.get_active_session_id()
+    if loop is None or session_id is None:
+        return False, None
+
+    # Guard against being called on the loop thread itself: blocking on
+    # run_coroutine_threadsafe there would deadlock (file tools run off-loop).
+    try:
+        running = asyncio.get_running_loop()
+    except RuntimeError:
+        running = None
+    if running is loop:
+        logger.error("Approval backend hit on the ACP loop; denying to avoid deadlock")
+        return False, None
+
+    future = asyncio.run_coroutine_threadsafe(_ask_client(session_id, title), loop)
+    try:
+        allowed = future.result(_PERMISSION_TIMEOUT_S)
+    except Exception:  # noqa: BLE001 - includes TimeoutError
+        # Abandon the in-flight request so it doesn't linger on the loop.
+        future.cancel()
+        logger.exception("ACP approval bridge failed; denying")
+        return False, None
+    return bool(allowed), None
+
+
+async def _on_run_shell_command(
+    context: Any, command: str, cwd: Optional[str] = None, timeout: int = 60
+) -> Optional[Dict[str, Any]]:
+    """``run_shell_command`` hook: gate shell execution through the client.
+
+    Returns ``None`` to allow (the hook's "no objection"), or a
+    ``{"blocked": True, ...}`` dict to deny. Inert outside ACP mode.
+
+    Honors yolo mode: when the user has opted out of approvals we do *not*
+    surface a client dialog, matching Code Puppy's file-permission edge (which
+    skips its prompt in yolo mode). Otherwise ACP + yolo would silently
+    auto-approve file writes yet still prompt for every shell command.
+    """
+    session_id = state.get_active_session_id()
+    if state.get_connection() is None or session_id is None:
+        return None
+    from code_puppy.config import get_yolo_mode
+
+    if get_yolo_mode():
+        return None
+    allowed = await _ask_client(session_id, f"Run shell command: {command}")
+    if allowed:
+        return None
+    return {
+        "blocked": True,
+        "error_message": "Command rejected in the client",
+        "reasoning": "The user denied this shell command in the client's permission dialog.",
+    }
+
+
+def install() -> None:
+    """Install the file approval backend + the shell permission hook."""
+    from code_puppy.tools.common import set_approval_backend
+
+    set_approval_backend(_approval_backend)
+    register_callback("run_shell_command", _on_run_shell_command)
+
+
+def uninstall() -> None:
+    """Remove the approval backend + shell hook so normal stdin prompting resumes."""
+    from code_puppy.callbacks import unregister_callback
+    from code_puppy.tools.common import set_approval_backend
+
+    set_approval_backend(None)
+    try:
+        unregister_callback("run_shell_command", _on_run_shell_command)
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: run_shell_command unregister failed", exc_info=True)

code_puppy_core_plugins/acp/persistence.py

@@ -0,0 +1,197 @@
+"""Persist ACP session history so ``session/load`` and ``session/resume``
+rehydrate real turns across process restarts.
+
+Each session's pydantic-ai message history is pickled under a dedicated
+directory keyed by the ACP session id, reusing code-puppy's existing
+``session_storage`` layer. We keep it separate from the user's autosaves
+(``AUTOSAVE_DIR/acp``) so ACP threads never pollute the ``/resume`` picker.
+
+Alongside the pickle we write a small ACP metadata sidecar (``*_acp.json``)
+recording the session's own ``cwd`` + ``additional_directories``. This is what
+lets ``list_persisted`` surface revivable sessions after a
+restart *with the ``cwd`` that ACP's ``SessionInfo`` requires* -- the pickle
+alone can't answer "where did this thread live?", and ``session_storage``'s
+own ``_meta.json`` records the *process* cwd, which is wrong for per-session
+ACP threads.
+
+Every public entry point takes an optional ``base_dir``: production callers
+omit it (it defaults to ``AUTOSAVE_DIR/acp``), while tests pass an explicit
+directory so persistence is exercised end-to-end with zero shared global
+state -- no monkeypatching of a module-level location.
+
+All operations are best-effort: persistence must never break a live turn, so
+failures are logged and swallowed.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PersistedSession:
+    """On-disk record of an ACP session, enough to re-list + revive it."""
+
+    session_id: str
+    cwd: Optional[str] = None
+    additional_directories: Optional[List[str]] = None
+    updated_at: Optional[str] = None
+
+
+def _base_dir() -> Path:
+    from code_puppy.config import AUTOSAVE_DIR
+
+    return Path(AUTOSAVE_DIR) / "acp"
+
+
+def _resolve_base(base_dir: Optional[Path]) -> Path:
+    """Return the caller's ``base_dir`` or the default ``AUTOSAVE_DIR/acp``."""
+    return Path(base_dir) if base_dir is not None else _base_dir()
+
+
+def _safe_name(session_id: str) -> str:
+    """Sanitise a session id into a filesystem-safe pickle stem."""
+    return "".join(c if (c.isalnum() or c in "-_") else "_" for c in session_id)
+
+
+# Sidecar suffix for ACP-specific metadata. Distinct from ``session_storage``'s
+# own ``_meta.json`` so the two never collide.
+_ACP_META_SUFFIX = "_acp.json"
+
+
+def _acp_meta_path(base: Path, session_id: str) -> Path:
+    return base / f"{_safe_name(session_id)}{_ACP_META_SUFFIX}"
+
+
+def save(
+    session_id: str,
+    agent: Any,
+    cwd: Optional[str] = None,
+    additional_directories: Optional[List[str]] = None,
+    base_dir: Optional[Path] = None,
+) -> None:
+    """Persist ``agent``'s message history under ``session_id`` (best-effort).
+
+    Also writes an ACP metadata sidecar carrying the session's ``cwd`` +
+    ``additional_directories`` so ``list_persisted`` can surface it after a
+    restart.
+    """
+    try:
+        from code_puppy.session_storage import save_session
+
+        base = _resolve_base(base_dir)
+        history = list(agent.get_message_history())
+        if not history:
+            return
+        timestamp = datetime.datetime.now().isoformat()
+        save_session(
+            history=history,
+            session_name=_safe_name(session_id),
+            base_dir=base,
+            timestamp=timestamp,
+            token_estimator=getattr(agent, "estimate_tokens_for_message", lambda _m: 0),
+            auto_saved=True,
+        )
+        _write_acp_meta(
+            base,
+            PersistedSession(
+                session_id=session_id,
+                cwd=cwd,
+                additional_directories=list(additional_directories or []) or None,
+                updated_at=timestamp,
+            ),
+        )
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: session persist failed", exc_info=True)
+
+
+def _write_acp_meta(base: Path, record: PersistedSession) -> None:
+    """Write the ACP metadata sidecar for ``record`` (best-effort, atomic)."""
+    try:
+        base.mkdir(parents=True, exist_ok=True)
+        path = _acp_meta_path(base, record.session_id)
+        payload = {
+            "session_id": record.session_id,
+            "cwd": record.cwd,
+            "additional_directories": record.additional_directories,
+            "updated_at": record.updated_at,
+        }
+        tmp = path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+        tmp.replace(path)
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: session meta persist failed", exc_info=True)
+
+
+def load_history(
+    session_id: str, base_dir: Optional[Path] = None
+) -> Optional[List[Any]]:
+    """Return the persisted history for ``session_id``, or ``None`` if none."""
+    try:
+        from code_puppy.session_storage import load_session
+
+        return list(load_session(_safe_name(session_id), _resolve_base(base_dir)))
+    except FileNotFoundError:
+        return None
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: session load failed", exc_info=True)
+        return None
+
+
+def list_persisted(base_dir: Optional[Path] = None) -> List[PersistedSession]:
+    """Return every ACP session persisted on disk (newest first).
+
+    Reads the ACP metadata sidecars so revivable sessions survive process
+    restarts. A session whose pickle vanished (only the sidecar remains) is
+    skipped -- there is nothing left to rehydrate.
+    """
+    base = _resolve_base(base_dir)
+    if not base.exists():
+        return []
+    records: List[PersistedSession] = []
+    for meta_path in base.glob(f"*{_ACP_META_SUFFIX}"):
+        try:
+            data = json.loads(meta_path.read_text(encoding="utf-8"))
+            session_id = data.get("session_id")
+            if not session_id:
+                continue
+            if not (base / f"{_safe_name(session_id)}.pkl").exists():
+                continue
+            records.append(
+                PersistedSession(
+                    session_id=session_id,
+                    cwd=data.get("cwd"),
+                    additional_directories=data.get("additional_directories"),
+                    updated_at=data.get("updated_at"),
+                )
+            )
+        except Exception:  # noqa: BLE001
+            logger.debug("ACP: skipping unreadable session meta", exc_info=True)
+    records.sort(key=lambda r: r.updated_at or "", reverse=True)
+    return records
+
+
+def delete(session_id: str, base_dir: Optional[Path] = None) -> None:
+    """Remove a persisted session's pickle + sidecars (best-effort).
+
+    Called when a client explicitly closes a session so a deliberate close
+    doesn't leave a ghost that reappears in the next ``list_sessions``.
+    """
+    try:
+        base = _resolve_base(base_dir)
+        stem = _safe_name(session_id)
+        for path in (
+            base / f"{stem}.pkl",
+            base / f"{stem}_meta.json",
+            _acp_meta_path(base, session_id),
+        ):
+            path.unlink(missing_ok=True)
+    except Exception:  # noqa: BLE001
+        logger.debug("ACP: session delete failed", exc_info=True)