code-puppy 0.0.783__tar.gz → 0.0.785__tar.gz

{code_puppy-0.0.783 → code_puppy-0.0.785}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy
-Version: 0.0.783
+Version: 0.0.785
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -20,7 +20,7 @@ Requires-Dist: anthropic<1,>=0.108.0
 Requires-Dist: anyio>=4.7.0
 Requires-Dist: azure-identity>=1.15.0
 Requires-Dist: boto3>=1.43.9
-Requires-Dist: code-puppy-core-plugins>=0.0.26
+Requires-Dist: code-puppy-core-plugins>=0.0.27
 Requires-Dist: httpx[http2]>=0.24.1
 Requires-Dist: json-repair>=0.46.2
 Requires-Dist: keyring>=24.0.0

{code_puppy-0.0.783 → code_puppy-0.0.785}/code_puppy/callbacks.py

@@ -49,6 +49,7 @@ PhaseType = Literal[
     "agent_run_end",
     "agent_run_result",
     "model_select",
+    "provider_credential_flow",
     "register_mcp_catalog_servers",
     "register_browser_types",
     "register_model_providers",
@@ -138,6 +139,7 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "agent_run_end": [],
     "agent_run_result": [],
     "model_select": [],
+    "provider_credential_flow": [],
     "register_mcp_catalog_servers": [],
     "register_browser_types": [],
     "register_model_providers": [],
@@ -1225,6 +1227,44 @@ def on_model_select(
     return None
 
 
+def on_provider_credential_flow(*, provider_id: str, env_var: str) -> bool:
+    """Ask plugins to acquire a missing provider credential.
+
+    Fired by the ``/add_model`` flow for each required env var that is not
+    set, before falling back to manual key entry. A plugin that can mint the
+    credential itself (e.g. an OAuth flow that exchanges an authorization
+    code for an API key) should persist it so it takes effect immediately
+    (config + ``os.environ``) and return ``True``. Return ``None``/``False``
+    to defer to manual entry.
+
+    Unlike most hooks this one deliberately short-circuits: callbacks run
+    interactive, side-effectful flows, so the first one to return ``True``
+    wins and the rest are never invoked. Callbacks must gate on
+    ``provider_id``/``env_var`` and return ``None`` immediately for
+    providers they do not own.
+
+    Args:
+        provider_id: models.dev provider id (e.g. ``"openrouter"``).
+        env_var: The credential env var being requested.
+
+    Returns:
+        True when a callback reports the credential as acquired.
+    """
+    for callback in get_callbacks("provider_credential_flow"):
+        try:
+            result = callback(provider_id=provider_id, env_var=env_var)
+        except Exception as e:
+            logger.error(
+                f"Callback {getattr(callback, '__name__', callback)!r} failed "
+                f"in phase 'provider_credential_flow': {e}\n"
+                f"{traceback.format_exc()}"
+            )
+            continue
+        if result is True:
+            return True
+    return False
+
+
 async def on_agent_run_end(
     agent_name: str,
     model_name: str,

{code_puppy-0.0.783 → code_puppy-0.0.785}/code_puppy/command_line/add_model_menu.py

@@ -346,16 +346,34 @@ def _text_input(title: str, **kwargs):
     return builder
 
 
+def _plugin_credential_flow(provider: ProviderInfo, env_var: str) -> bool:
+    """Give plugins first crack at acquiring a missing credential.
+
+    A plugin (e.g. an OAuth flow that exchanges a code for an API key) saves
+    the credential itself and returns True via the ``provider_credential_flow``
+    hook. Trust but verify: the env var must actually be set afterwards,
+    otherwise we fall back to manual entry anyway.
+    """
+    from code_puppy.callbacks import on_provider_credential_flow
+
+    handled = on_provider_credential_flow(provider_id=provider.id, env_var=env_var)
+    return bool(handled and os.environ.get(env_var))
+
+
 def prompt_for_credentials(provider: ProviderInfo, **overrides) -> bool:
     """Prompt for each missing credential. Empty skips; Esc cancels all.
 
-    Saves via config + os.environ so the key is immediately usable.
+    Plugins get first crack via the ``provider_credential_flow`` hook (e.g.
+    browser OAuth); anything unhandled falls back to manual entry, which
+    saves via config + os.environ so the key is immediately usable.
     """
     missing = missing_env_vars(provider)
     if not missing:
         emit_info(t("model_menu.credentials.all_set", provider=provider.name))
         return True
     for env_var in missing:
+        if _plugin_credential_flow(provider, env_var):
+            continue
         result = (
             _text_input(
                 f"{provider.name}: {env_var}",

{code_puppy-0.0.783 → code_puppy-0.0.785}/code_puppy/command_line/mcp/trust_command.py

@@ -150,11 +150,14 @@ class TrustCommand(MCPCommandBase):
 
     def _revoke(self, group_id: str) -> None:
         if revoke_project_mcp():
+            try:
+                self.manager.sync_from_config()
+            except Exception as exc:  # pragma: no cover - defensive
+                logger.warning("Post-revoke registry sync failed: %s", exc)
             emit_info(
                 Text.from_markup(
                     "[green]\u2713 Revoked[/green] trust for this project's MCP "
-                    "config. Its servers will no longer load. Restart or re-sync "
-                    "to drop already-registered ones."
+                    "config. Its servers will no longer load."
                 ),
                 message_group=group_id,
             )

{code_puppy-0.0.783 → code_puppy-0.0.785}/code_puppy/config.py

@@ -595,7 +595,7 @@ def _parse_mcp_servers_mapping(raw_text: str) -> dict:
     return servers
 
 
-def load_mcp_server_configs():
+def load_mcp_server_configs(*, raise_on_error: bool = False):
     """Load MCP server configs, merging user-level and trusted project-level.
 
     Sources, in ascending order of precedence:
@@ -610,6 +610,11 @@ def load_mcp_server_configs():
     Project entries win on name collision, matching how project agents, skills,
     and plugins override their user-level counterparts. Returns an empty dict
     when nothing is configured.
+
+    When *raise_on_error* is true, a parse/IO failure of an existing user-level
+    file (or a failure of the project loader) is re-raised after the error is
+    emitted, so callers that unregister missing names can skip that drop
+    instead of treating ``{}`` as "configure nothing".
     """
     from code_puppy.messaging.message_queue import emit_error
 
@@ -622,6 +627,8 @@ def load_mcp_server_configs():
                 configs.update(_parse_mcp_servers_mapping(f.read()))
     except Exception as e:
         emit_error(f"Failed to load MCP servers - {str(e)}")
+        if raise_on_error:
+            raise
 
     # 2. Project-level config (opt-in, trust-gated). A broken or untrusted
     #    project file must never break user-level loading.
@@ -633,6 +640,8 @@ def load_mcp_server_configs():
             configs.update(project_configs)
     except Exception as e:
         emit_error(f"Failed to load project MCP servers - {str(e)}")
+        if raise_on_error:
+            raise
 
     return configs
 

{code_puppy-0.0.783 → code_puppy-0.0.785}/code_puppy/mcp_/manager.py

@@ -161,10 +161,7 @@ class MCPManager:
         try:
             from code_puppy.config import load_mcp_server_configs
 
-            configs = load_mcp_server_configs()
-            if not configs:
-                logger.debug("No servers found in mcp_servers.json")
-                return
+            configs = load_mcp_server_configs(raise_on_error=True) or {}
 
             synced_count = 0
             updated_count = 0
@@ -209,9 +206,23 @@ class MCPManager:
                     logger.warning(f"Failed to sync server '{name}' from config: {e}")
                     continue
 
-            if synced_count > 0 or updated_count > 0:
+            configured_names = {
+                name for name, conf in configs.items() if isinstance(conf, dict)
+            }
+            dropped_count = 0
+            for existing in list(self.registry.list_all()):
+                if existing.name not in configured_names:
+                    if self.remove_server(existing.id):
+                        dropped_count += 1
+                        logger.debug(
+                            "Dropped server no longer in mcp_servers.json: %s",
+                            existing.name,
+                        )
+
+            if synced_count > 0 or updated_count > 0 or dropped_count > 0:
                 logger.info(
-                    f"Synced {synced_count} new and updated {updated_count} servers from mcp_servers.json"
+                    f"Synced {synced_count} new, updated {updated_count}, "
+                    f"dropped {dropped_count} servers from mcp_servers.json"
                 )
 
         except Exception as e:

{code_puppy-0.0.783 → code_puppy-0.0.785}/code_puppy/plugins/__init__.py

@@ -117,6 +117,18 @@ def _install_project_plugin_finder() -> None:
 
 PLUGIN_ENTRY_POINT_GROUP = "code_puppy.plugins"
 
+# shell_safety implements the safety_permission_level threshold. Skip it only
+# when the user opted into high/critical autonomy; the default (medium) must
+# load it or the setting is a no-op.
+_SHELL_SAFETY_SKIP_LEVELS = frozenset({"high", "critical"})
+
+
+def _skip_shell_safety_plugin() -> bool:
+    from code_puppy.config import get_safety_permission_level
+
+    return get_safety_permission_level() in _SHELL_SAFETY_SKIP_LEVELS
+
+
 # Track if plugins have already been loaded to prevent duplicate registration
 _PLUGINS_LOADED = False
 
@@ -135,18 +147,13 @@ def _load_installed_plugins() -> list[str]:
     project plugins, but remain physically independent from the core package.
     Entry points are sorted for deterministic startup and test behavior.
     """
-    from code_puppy.config import get_safety_permission_level
-
     loaded: list[str] = []
     discovered = sorted(
         entry_points(group=PLUGIN_ENTRY_POINT_GROUP), key=lambda item: item.name
     )
     for entry_point in discovered:
         plugin_name = entry_point.name
-        if plugin_name == "shell_safety" and get_safety_permission_level() not in (
-            "none",
-            "low",
-        ):
+        if plugin_name == "shell_safety" and _skip_shell_safety_plugin():
             logger.debug("Skipping shell_safety plugin due to safety permission level")
             continue
         try:
@@ -191,14 +198,12 @@ def _load_builtin_plugins(
                 continue
 
             if callbacks_file.exists():
-                # Skip shell_safety plugin unless safety_permission_level is "low" or "none"
-                if plugin_name == "shell_safety":
-                    safety_level = get_safety_permission_level()
-                    if safety_level not in ("none", "low"):
-                        logger.debug(
-                            f"Skipping shell_safety plugin - safety_permission_level is '{safety_level}' (needs 'low' or 'none')"
-                        )
-                        continue
+                if plugin_name == "shell_safety" and _skip_shell_safety_plugin():
+                    logger.debug(
+                        "Skipping shell_safety plugin - safety_permission_level is %s",
+                        get_safety_permission_level(),
+                    )
+                    continue
 
                 try:
                     module_name = f"code_puppy.plugins.{plugin_name}.register_callbacks"

{code_puppy-0.0.783 → code_puppy-0.0.785}/code_puppy/session_surrogate_unpickler.py

@@ -72,9 +72,9 @@ _TZINFO_EQUIVALENTS: Dict[Tuple[str, str], Callable[..., Any]] = {
     ("pydantic_core", "TzInfo"): _tz_from_utc_offset,
 }
 
-# Genuine timezone libraries: unpickle their classes for real when the
-# library is installed; otherwise fall back to surrogates as usual.
-_TZ_LIBRARY_PREFIXES = ("pytz", "dateutil.tz")
+# pytz / dateutil.tz must NOT go through super().find_class: those packages
+# re-export os/sys the same way uuid and collections did. Known tzinfo
+# shapes are rebuilt via _TZINFO_EQUIVALENTS; everything else is a surrogate.
 
 
 class SurrogateBase:
@@ -145,14 +145,6 @@ class SurrogateUnpickler(pickle.Unpickler):
         equivalent = _TZINFO_EQUIVALENTS.get((module, name))
         if equivalent is not None:
             return equivalent
-        if any(
-            module == prefix or module.startswith(prefix + ".")
-            for prefix in _TZ_LIBRARY_PREFIXES
-        ):
-            try:
-                return super().find_class(module, name)
-            except Exception:  # noqa: BLE001 - library absent/renamed
-                pass
         return self._surrogate_for(module, name)
 
     def _tz_tolerant(self, obj: Any) -> Any:

{code_puppy-0.0.783 → code_puppy-0.0.785}/code_puppy/tools/file_modifications.py

@@ -14,6 +14,7 @@ import difflib
 import json
 import os
 import traceback
+from pathlib import Path
 from code_puppy.undo_manager import UndoManager
 import warnings
 from typing import Annotated, Any, Dict, List, Union
@@ -45,6 +46,75 @@ from code_puppy.tools.file_permission_state import (
 )
 
 
+def _split_existing(path: Path) -> tuple[Path, tuple[str, ...]]:
+    """Deepest existing ancestor of *path*, plus the missing trailing names."""
+    missing: list[str] = []
+    current = path
+    while True:
+        if current.exists():
+            return current.resolve(), tuple(reversed(missing))
+        parent = current.parent
+        if parent == current:
+            return current, tuple(reversed(missing))
+        missing.append(current.name)
+        current = parent
+
+
+def _casefold_has_prefix(parts: tuple[str, ...], prefix: tuple[str, ...]) -> bool:
+    if len(parts) < len(prefix):
+        return False
+    return all(a.casefold() == b.casefold() for a, b in zip(prefix, parts))
+
+
+def _is_inside_user_plugin_root(target: Path, root: Path) -> bool:
+    """Containment that survives APFS case-folding. ``Path.resolve`` does not."""
+    target_existing, target_rest = _split_existing(target)
+    root_existing, root_rest = _split_existing(root)
+
+    if os.path.samefile(target_existing, root_existing):
+        return _casefold_has_prefix(target_rest, root_rest)
+
+    current = target_existing
+    while True:
+        if os.path.samefile(current, root_existing):
+            return not root_rest
+        parent = current.parent
+        if parent == current:
+            return False
+        current = parent
+
+
+def _is_user_plugin_tree_path(file_path: str) -> bool:
+    """True if *file_path* is inside ``~/.code_puppy/plugins``.
+
+    That tree is imported at the next process start with no trust ceremony.
+    File tools must not plant ``register_callbacks.py`` there.
+    Canonicalization errors fail closed (treated as inside).
+    """
+    from code_puppy.plugins import USER_PLUGINS_DIR
+
+    try:
+        resolved = Path(resolve_path(file_path)).resolve()
+        root = Path(USER_PLUGINS_DIR).expanduser().resolve()
+        return _is_inside_user_plugin_root(resolved, root)
+    except (OSError, RuntimeError, ValueError):
+        return True
+
+
+def _refuse_user_plugin_tree(file_path: str) -> Dict[str, Any] | None:
+    if not _is_user_plugin_tree_path(file_path):
+        return None
+    return {
+        "success": False,
+        "path": file_path,
+        "message": (
+            "Refused: file tools cannot modify ~/.code_puppy/plugins. "
+            "That directory is imported at startup."
+        ),
+        "changed": False,
+    }
+
+
 def _permission_denied(permission_results: List[Any]) -> bool:
     """Return True when any permission callback explicitly denies.
 
@@ -424,6 +494,9 @@ def _write_to_file(
 def delete_snippet_from_file(
     context: RunContext, file_path: str, snippet: str, message_group: str | None = None
 ) -> Dict[str, Any]:
+    refused = _refuse_user_plugin_tree(file_path)
+    if refused is not None:
+        return refused
     # Use the plugin system for permission handling with operation data
     from code_puppy.callbacks import on_file_permission
 
@@ -452,6 +525,9 @@ def write_to_file(
     overwrite: bool,
     message_group: str | None = None,
 ) -> Dict[str, Any]:
+    refused = _refuse_user_plugin_tree(path)
+    if refused is not None:
+        return refused
     # Use the plugin system for permission handling with operation data
     from code_puppy.callbacks import on_file_permission
 
@@ -481,6 +557,9 @@ def replace_in_file(
     replacements: List[Dict[str, str]],
     message_group: str | None = None,
 ) -> Dict[str, Any]:
+    refused = _refuse_user_plugin_tree(path)
+    if refused is not None:
+        return refused
     # Use the plugin system for permission handling with operation data
     from code_puppy.callbacks import on_file_permission
 
@@ -504,6 +583,9 @@ async def delete_snippet_from_file_async(
     context: RunContext, file_path: str, snippet: str, message_group: str | None = None
 ) -> Dict[str, Any]:
     """Async permission-aware variant of ``delete_snippet_from_file``."""
+    refused = _refuse_user_plugin_tree(file_path)
+    if refused is not None:
+        return refused
     from code_puppy.callbacks import on_file_permission_async
 
     operation_data = {"snippet": snippet}
@@ -530,6 +612,9 @@ async def write_to_file_async(
     message_group: str | None = None,
 ) -> Dict[str, Any]:
     """Async permission-aware variant of ``write_to_file``."""
+    refused = _refuse_user_plugin_tree(path)
+    if refused is not None:
+        return refused
     from code_puppy.callbacks import on_file_permission_async
 
     operation_data = {"content": content, "overwrite": overwrite}
@@ -556,6 +641,9 @@ async def replace_in_file_async(
     message_group: str | None = None,
 ) -> Dict[str, Any]:
     """Async permission-aware variant of ``replace_in_file``."""
+    refused = _refuse_user_plugin_tree(path)
+    if refused is not None:
+        return refused
     from code_puppy.callbacks import on_file_permission_async
 
     operation_data = {"replacements": replacements}
@@ -726,6 +814,9 @@ async def _edit_file_async(
 def _delete_file(
     context: RunContext, file_path: str, message_group: str | None = None
 ) -> Dict[str, Any]:
+    refused = _refuse_user_plugin_tree(file_path)
+    if refused is not None:
+        return refused
     UndoManager().record_change(file_path, "delete_file")
     file_path = resolve_path(file_path)
 
@@ -786,6 +877,9 @@ async def _delete_file_async(
     context: RunContext, file_path: str, message_group: str | None = None
 ) -> Dict[str, Any]:
     """Async permission-aware variant of ``_delete_file``."""
+    refused = _refuse_user_plugin_tree(file_path)
+    if refused is not None:
+        return refused
     file_path = resolve_path(file_path)
 
     from code_puppy.callbacks import on_file_permission_async

{code_puppy-0.0.783 → code_puppy-0.0.785}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.783"
+version = "0.0.785"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
 dependencies = [
-    "code-puppy-core-plugins>=0.0.26",
+    "code-puppy-core-plugins>=0.0.27",
     "logfire>=4.0",
     "pydantic-ai-slim[openai,anthropic,mcp]==2.31.0",
     "pydantic-ai-harness==0.23.0",