code-puppy-core-plugins 0.0.53__tar.gz → 0.0.54__tar.gz

{code_puppy_core_plugins-0.0.53 → code_puppy_core_plugins-0.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.53
+Version: 0.0.54
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/README.md

@@ -0,0 +1,32 @@
+# mcp_binding_prompt
+
+Three MCP-install affordances layered over core at `startup`, no core edits:
+
+1. **Synchronous post-install binding prompt.** Core's installers call
+   `mcp_binding_menu.prompt_bind_after_install_sync(server_name)` inside a
+   `try/except ImportError` -- without this plugin the call silently no-ops.
+   `register_callbacks.py` provides that function: it runs the existing
+   `build_post_install_menu` inline in the installer's foreground (inside
+   `menu_session()`, with `set_awaiting_user_input` toggled) instead of
+   scheduling a competing UI task.
+2. **`/mcp install` is custom-JSON only** (`custom_install.py`). The bundled
+   marketplace is gone: `InstallCommand.execute` opens the custom server form
+   directly, `SearchCommand.execute` explains the removal, `HelpCommand.execute`
+   prints the trimmed help, and `MCPCompleter` stops advertising `search`.
+3. **HTTP form fields** (`http_form.py`). When the custom form's type is
+   `http`, `run_form_flow`'s `menu_factory` is swapped for `HTTPMenu`, which
+   exposes URL / auth (none, OAuth, headers) / headers as proper fields on
+   top of the raw JSON blob. Saving validates the URL (scheme, host, no
+   embedded credentials or whitespace), the headers (string keys/values, no
+   CRLF), and runs the config through core's `http_auth` transport policy.
+   Malformed advanced JSON falls back to the core menu so it stays editable.
+   Switching type to `http` with an untouched example seeds a minimal config.
+
+All strings go through `code_puppy.i18n` (`mcp.custom_install.*`,
+`mcp.http_form.*`); the keys live in core's `en-US` catalog.
+
+## Notes
+
+- Every patch is idempotent (`_custom_json_install` / `_http_fields` markers).
+- `HelpCommand.execute` is fully replaced, so new core `/mcp` subcommands must
+  also be added to the `mcp.custom_install.help` catalog string.

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/__init__.py

@@ -0,0 +1 @@
+"""Restore the synchronous post-install MCP binding prompt."""

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/custom_install.py

@@ -0,0 +1,58 @@
+"""Custom JSON replaces the bundled MCP marketplace at the command boundary."""
+
+import logging
+from functools import wraps
+
+from code_puppy.i18n import t
+from code_puppy.messaging import emit_error, emit_info
+
+logger = logging.getLogger(__name__)
+
+
+def install_custom(command, args, group_id=None):
+    """Keep the existing form's save, cancel, and binding semantics."""
+    from code_puppy.command_line.mcp.custom_server_form import run_custom_server_form
+
+    try:
+        run_custom_server_form(command.manager)
+    except (KeyboardInterrupt, EOFError):
+        return
+    except Exception as exc:
+        logger.exception("Custom MCP installation failed")
+        emit_error(
+            t("mcp.custom_install.failed", error=str(exc)), message_group=group_id
+        )
+
+
+def marketplace_removed(command, args, group_id=None):
+    emit_info(t("mcp.custom_install.no_marketplace"), message_group=group_id)
+
+
+def custom_help(command, args, group_id=None):
+    emit_info(t("mcp.custom_install.help"), message_group=group_id)
+
+
+def install_routes():
+    # Known slash commands do not reach custom_command. Install the override
+    # at startup, leaving core command_line files and existing instances intact.
+    from code_puppy.command_line.mcp.install_command import InstallCommand
+    from code_puppy.command_line.mcp.search_command import SearchCommand
+    from code_puppy.command_line.mcp.help_command import HelpCommand
+    from code_puppy.command_line.mcp_completion import MCPCompleter
+
+    original = MCPCompleter.__init__
+    if getattr(original, "_custom_json_install", False):
+        return  # already routed -- never double-wrap the completer
+    InstallCommand.execute = install_custom
+    SearchCommand.execute = marketplace_removed
+    HelpCommand.execute = custom_help
+
+    @wraps(original)
+    def initialize(completer, *args, **kwargs):
+        original(completer, *args, **kwargs)
+        for commands in (completer.general_subcommands, completer.all_subcommands):
+            commands.pop("search", None)
+            commands["install"] = t("mcp.custom_install.description")
+
+    initialize._custom_json_install = True
+    MCPCompleter.__init__ = initialize

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/http_form.py

@@ -0,0 +1,223 @@
+"""HTTP fields layered over the existing custom form and persistence loop."""
+
+import json
+from urllib.parse import urlsplit
+
+from code_puppy.i18n import t
+
+
+def read_config(form):
+    config = json.loads(form.json_config)
+    if not isinstance(config, dict):
+        raise ValueError(t("mcp.http_form.object_required"))
+    return config
+
+
+def validate_headers(headers):
+    """Non-empty string keys, string values, no CRLF (header injection)."""
+    if not isinstance(headers, dict) or any(
+        not isinstance(key, str)
+        or not isinstance(value, str)
+        or not key
+        or any(char in key + value for char in "\r\n")
+        for key, value in headers.items()
+    ):
+        raise ValueError(t("mcp.http_form.invalid_headers"))
+
+
+def validate_config(config):
+    url = config.get("url", "")
+    if not isinstance(url, str):
+        raise ValueError(t("mcp.http_form.invalid_url"))
+    parsed = urlsplit(url)
+    if (
+        parsed.scheme not in ("https", "http")
+        or not parsed.hostname
+        or parsed.username is not None
+        or parsed.password is not None
+        or any(char.isspace() for char in url)
+    ):
+        raise ValueError(t("mcp.http_form.invalid_url"))
+    headers = config.get("headers", {})
+    validate_headers(headers)
+    from code_puppy.mcp_.http_auth import http_auth
+
+    # Reuse transport security policy; constructing OAuth does not start login.
+    http_auth(config, url, headers)
+
+
+def save_config(form, config):
+    form.json_config = json.dumps(config, indent=2)
+
+
+def input_text(title, initial):
+    from termflow.tui import TextInputBuilder
+    from code_puppy.command_line.tui_style import menu_style
+
+    builder = TextInputBuilder(title).initial(initial).alt_screen(False)
+    style = menu_style()
+    if style is not None:
+        builder.style(style)
+    result = builder.build().run()
+    return None if result.cancelled else result.value
+
+
+def choose_auth(config):
+    from termflow.tui import MenuBuilder, MenuItem
+    from code_puppy.command_line.tui_style import themed
+
+    result = (
+        themed(
+            MenuBuilder(t("mcp.http_form.auth"))
+            .items(
+                [
+                    MenuItem(t("mcp.http_form.none"), value="none"),
+                    MenuItem(t("mcp.http_form.oauth"), value="oauth"),
+                    MenuItem(t("mcp.http_form.headers_auth"), value="headers"),
+                ]
+            )
+            .alt_screen(False)
+        )
+        .build()
+        .run()
+    )
+    if result.cancelled or result.item is None:
+        return False
+    if result.item.value == "oauth":
+        config["auth"] = "oauth"
+        # New OAuth selections need time for a human to finish browser login.
+        if config.get("timeout", 30) == 30:
+            config["timeout"] = 330
+    else:
+        config.pop("auth", None)
+    if result.item.value == "none":
+        headers = config.get("headers", {})
+        config["headers"] = {
+            key: val for key, val in headers.items() if key.lower() != "authorization"
+        }
+    if result.item.value == "headers":
+        return edit_headers(config)
+    return True
+
+
+def edit_headers(config):
+    value = input_text(
+        t("mcp.http_form.headers_prompt"), json.dumps(config.get("headers", {}))
+    )
+    if value is None:
+        return False
+    try:
+        headers = json.loads(value or "{}")
+    except ValueError:
+        # A JSONDecodeError message is noise in the footer; say what we mean.
+        raise ValueError(t("mcp.http_form.invalid_headers")) from None
+    validate_headers(headers)
+    if headers:
+        config["headers"] = headers
+    else:
+        config.pop("headers", None)
+    return True
+
+
+class HTTPMenu:
+    def __init__(self, form, original, overrides):
+        self.form = form
+        self.original = original
+        self.overrides = overrides
+
+    def run(self):
+        from termflow.tui import MenuBuilder, MenuItem
+        from code_puppy.command_line.tui_style import themed
+
+        form = self.form
+        while True:
+            try:
+                config = read_config(form)
+            except (ValueError, TypeError):
+                # Advanced malformed JSON remains editable, never discarded.
+                return self.original(form, **self.overrides).run()
+            auth = (
+                "oauth"
+                if config.get("auth") == "oauth"
+                else (
+                    "headers_auth"
+                    if any(
+                        key.lower() == "authorization"
+                        for key in config.get("headers", {})
+                    )
+                    else "none"
+                )
+            )
+            items = [
+                MenuItem(t("mcp.http_form.name", name=form.server_name), value="name"),
+                MenuItem(t("mcp.http_form.type"), value="type"),
+                MenuItem(t("mcp.http_form.url"), value="http_url"),
+                MenuItem(
+                    t("mcp.http_form.auth_value", auth=t("mcp.http_form." + auth)),
+                    value="http_auth",
+                ),
+                MenuItem(t("mcp.http_form.headers"), value="http_headers"),
+                MenuItem(t("mcp.http_form.advanced"), value="json"),
+                MenuItem(t("mcp.http_form.save"), value="save"),
+                MenuItem(t("mcp.http_form.cancel"), value="cancel"),
+            ]
+            # Do not echo credentials, header values, or URL query secrets.
+            builder = themed(
+                MenuBuilder(t("mcp.http_form.title")).items(items).alt_screen(False)
+            )
+            if form.validation_error:
+                builder.footer_hint(form.validation_error)
+            result = builder.build().run()
+            if result.cancelled or result.item is None:
+                return result
+            field = result.item.value
+            try:
+                if field == "http_url":
+                    value = input_text(t("mcp.http_form.url"), config.get("url", ""))
+                    if value is not None:
+                        config["url"] = value.strip()
+                        save_config(form, config)
+                elif field == "http_auth":
+                    if choose_auth(config):
+                        save_config(form, config)
+                elif field == "http_headers":
+                    if edit_headers(config):
+                        save_config(form, config)
+                elif field == "save":
+                    validate_config(config)
+                    return result
+                else:
+                    return result
+                form.validation_error = None
+            except (ValueError, TypeError) as exc:
+                form.validation_error = str(exc)
+
+
+def install_http_form():
+    from code_puppy.command_line.mcp import custom_server_form as core
+
+    original = core.run_form_flow
+    if getattr(original, "_http_fields", False):
+        return
+
+    def menu(form, **overrides):
+        if form._get_current_type() == "http":
+            return HTTPMenu(form, core.build_form_menu, overrides)
+        return core.build_form_menu(form, **overrides)
+
+    def type_menu(form):
+        old_type = form._get_current_type()
+        untouched = (
+            form.json_config.strip() == core.CUSTOM_SERVER_EXAMPLES[old_type].strip()
+        )
+        core.run_type_menu(form)
+        if old_type != "http" and form._get_current_type() == "http" and untouched:
+            save_config(form, {"type": "http", "url": "", "timeout": 30})
+
+    def run(form, **kwargs):
+        kwargs.setdefault("menu_factory", menu)
+        kwargs.setdefault("type_menu", type_menu)
+        return original(form, **kwargs)
+
+    run._http_fields = True
+    core.run_form_flow = run

code_puppy_core_plugins-0.0.54/code_puppy_core_plugins/mcp_binding_prompt/register_callbacks.py

@@ -0,0 +1,48 @@
+"""Bridge synchronous installers to the existing binding menu via startup."""
+
+import logging
+
+from code_puppy.callbacks import register_callback
+
+logger = logging.getLogger(__name__)
+
+
+def prompt_bind_after_install_sync(server_name: str) -> None:
+    """Run in the installer's foreground, never schedule a competing UI task."""
+    from code_puppy.agents import get_available_agents
+    from code_puppy.command_line.mcp_binding_menu import (
+        build_post_install_menu,
+        menu_session,
+        set_awaiting_user_input,
+    )
+
+    agents = sorted(get_available_agents(), key=str.lower)
+    if not agents:
+        return
+    set_awaiting_user_input(True)
+    try:
+        with menu_session():
+            build_post_install_menu(server_name, agents, alt_screen=False).run()
+    finally:
+        set_awaiting_user_input(False)
+
+
+def _install() -> None:
+    try:
+        from code_puppy.command_line import mcp_binding_menu
+
+        if not hasattr(mcp_binding_menu, "prompt_bind_after_install_sync"):
+            mcp_binding_menu.prompt_bind_after_install_sync = (
+                prompt_bind_after_install_sync
+            )
+        from .custom_install import install_routes
+
+        install_routes()
+        from .http_form import install_http_form
+
+        install_http_form()
+    except Exception:
+        logger.exception("Could not install MCP binding prompt compatibility bridge")
+
+
+register_callback("startup", _install)

{code_puppy_core_plugins-0.0.53 → code_puppy_core_plugins-0.0.54}/code_puppy_core_plugins/plugin_list/plugins_menu.py

@@ -82,8 +82,6 @@ class PluginsMenu:
         self.plugins: List[_PluginEntry] = []
         self.disabled: set[str] = set()
         self.project_dir: Optional[str] = None
-        self.lock_builtin: bool = False
-        self.hidden_builtin_count: int = 0
 
         # The trust modal disables list bindings while open, keeping accept-word
         # typing from triggering shortcuts; focus remains on its input.
@@ -131,27 +129,19 @@ class PluginsMenu:
             get_project_plugins_directory,
         )
         from code_puppy.plugins.config import get_disabled_plugins
-        from code_puppy.plugins.config import (
-            get_lock_builtin_plugins,
-        )
 
         loaded = get_loaded_plugins()
         self.disabled = get_disabled_plugins()
-        self.lock_builtin = get_lock_builtin_plugins()
 
         project_dir = get_project_plugins_directory()
         self.project_dir = project_dir.as_posix() if project_dir else None
 
-        entries: List[_PluginEntry] = []
-        self.hidden_builtin_count = 0
-        for tier in ("builtin", "user", "project"):
-            for name in sorted(loaded.get(tier, [])):
-                # When locked, builtins are managed/protected — hide them so
-                # they can't be toggled (the config layer refuses anyway).
-                if self.lock_builtin and tier == "builtin":
-                    self.hidden_builtin_count += 1
-                    continue
-                entries.append(_PluginEntry(name, tier))
+        # Every tier is listed and toggleable -- builtins included.
+        entries: List[_PluginEntry] = [
+            _PluginEntry(name, tier)
+            for tier in ("builtin", "user", "project")
+            for name in sorted(loaded.get(tier, []))
+        ]
 
         # Project plugins held back by the trust gate — shown so Enter can
         # open the ceremony popup on them.

{code_puppy_core_plugins-0.0.53 → code_puppy_core_plugins-0.0.54}/code_puppy_core_plugins/plugin_list/plugins_menu_render.py

@@ -72,21 +72,8 @@ def render_list(menu: "PluginsMenu") -> Fragments:
     lines.append(("bold", " Plugins"))
     lines.append(("", "\n\n"))
 
-    if menu.lock_builtin and menu.hidden_builtin_count:
-        lines.append(
-            (
-                "class:tui.muted",
-                f"  {menu.hidden_builtin_count} builtin plugins are "
-                f"managed and hidden.",
-            )
-        )
-        lines.append(("", "\n\n"))
-
     if not menu.plugins:
-        if menu.lock_builtin and menu.hidden_builtin_count:
-            lines.append(("class:tui.warning", "  No user or project plugins loaded."))
-        else:
-            lines.append(("class:tui.warning", "  No plugins loaded."))
+        lines.append(("class:tui.warning", "  No plugins loaded."))
         lines.append(("", "\n"))
         _render_hints(lines)
         return lines

{code_puppy_core_plugins-0.0.53 → code_puppy_core_plugins-0.0.54}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.53"
+version = "0.0.54"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
@@ -61,6 +61,7 @@ hook_creator = "code_puppy_core_plugins.hook_creator.register_callbacks"
 hook_manager = "code_puppy_core_plugins.hook_manager.register_callbacks"
 logfire_oauth = "code_puppy_core_plugins.logfire_oauth.register_callbacks"
 logfire_sessions = "code_puppy_core_plugins.logfire_sessions.register_callbacks"
+mcp_binding_prompt = "code_puppy_core_plugins.mcp_binding_prompt.register_callbacks"
 meta_oauth = "code_puppy_core_plugins.meta_oauth.register_callbacks"
 namespace_skill_search = "code_puppy_core_plugins.namespace_skill_search.register_callbacks"
 no_tools = "code_puppy_core_plugins.no_tools.register_callbacks"