code-puppy-core-plugins 0.0.95__tar.gz → 0.0.96__tar.gz

{code_puppy_core_plugins-0.0.95 → code_puppy_core_plugins-0.0.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.95
+Version: 0.0.96
 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.96/code_puppy_core_plugins/setup_cli/README.md

@@ -0,0 +1,37 @@
+# setup_cli
+
+Scriptable configuration for Code Puppy: `code-puppy --setup <command>`.
+
+The interactive UI is great for humans at a terminal and useless for
+scripts, SSH sessions, CI, and sandbox provisioning. This plugin adds
+a flag-driven front door over the exact same machinery the TUI uses —
+no parallel config logic.
+
+```console
+code-puppy --setup wizard                     # guided first-run setup
+code-puppy --setup doctor [--network]         # what's broken / missing?
+code-puppy --setup auth login meta            # delegate to the plugin's own flow
+code-puppy --setup auth list --json
+code-puppy --setup model add anthropic/claude-haiku-5-5 --set-default
+code-puppy --setup model list
+code-puppy --setup mcp add fetch --command uvx --arg mcp-server-fetch --bind code-puppy
+code-puppy --setup plugin add ./my-plugin     # shows code, asks first
+code-puppy --setup skill add ./my-skill
+code-puppy --setup agent new reviewer
+code-puppy --setup config set yolo_mode true
+code-puppy --setup export ./my-bundle --sbx   # secret-free, sandbox-ready
+code-puppy --setup sbx plan                  # credentials/egress your models need
+```
+
+Design notes:
+
+- `--setup` is registered via `register_cli_args` with
+  `argparse.REMAINDER`; the plugin parses its own subcommands, prints
+  to real stdout (messaging renderers do not exist yet at
+  `handle_cli_args` time), and exits with its own code.
+- OAuth logins delegate to each plugin's existing interactive command
+  in a subprocess (`code-puppy -p "/x-auth"`), so browser/callback/
+  device flows keep working untouched. Status reads use the plugins'
+  own loaders and never surface credential values.
+- `providers.py` carries the provider registry, including how each
+  credential can be fed to a Docker sandbox (`sandbox_transport`).

code_puppy_core_plugins-0.0.96/code_puppy_core_plugins/setup_cli/__init__.py

@@ -0,0 +1 @@
+"""Setup CLI plugin: scriptable Code Puppy configuration via ``--setup``."""

code_puppy_core_plugins-0.0.96/code_puppy_core_plugins/setup_cli/agent_cmds.py

@@ -0,0 +1,110 @@
+"""``setup agent`` — manage user-tier JSON agent definitions."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+from .output import Out, SetupError, confirm
+
+
+def _agents_dir() -> Path:
+    from code_puppy.config import AGENTS_DIR
+
+    return Path(AGENTS_DIR)
+
+
+def _read_agent(path: Path) -> dict:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        raise SetupError(f"{path}: invalid JSON ({exc})") from exc
+    if not isinstance(data, dict):
+        raise SetupError(f"{path}: agent definition must be a JSON object")
+    return data
+
+
+def cmd_agent_list(out: Out) -> int:
+    base = _agents_dir()
+    rows = []
+    if base.is_dir():
+        for path in sorted(base.glob("*.json")):
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+            except Exception:
+                data = {}
+            rows.append(
+                {
+                    "file": path.name,
+                    "name": data.get("name", path.stem),
+                    "description": data.get("description", ""),
+                }
+            )
+    out.result(
+        {"agents": rows, "agents_dir": str(base)},
+        human=[f"{row['name']}  ({row['file']})" for row in rows]
+        or ["(no user JSON agents installed)"],
+    )
+    return 0
+
+
+def cmd_agent_add(out: Out, source: str, force: bool) -> int:
+    src = Path(source).expanduser()
+    if not src.is_file():
+        raise SetupError(f"agent source '{source}' is not a file")
+    # Validate with the real loader so a broken agent never lands on disk.
+    from code_puppy.agents.json_agent import JSONAgent
+
+    try:
+        agent = JSONAgent(str(src))
+    except Exception as exc:
+        raise SetupError(f"invalid agent definition: {exc}") from exc
+    dest = _agents_dir() / src.name
+    if dest.exists() and not force:
+        raise SetupError(f"agent file '{src.name}' already exists (use --force)")
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(src, dest)
+    out.result(
+        {"name": agent.name, "installed_to": str(dest)},
+        human=f"installed agent '{agent.name}'",
+    )
+    return 0
+
+
+def cmd_agent_new(out: Out, name: str, description: str) -> int:
+    dest = _agents_dir() / f"{name}.json"
+    if dest.exists():
+        raise SetupError(f"agent file '{dest.name}' already exists")
+    payload = {
+        "name": name,
+        "display_name": name.replace("-", " ").title(),
+        "description": description or f"Custom agent '{name}' (edit me).",
+        "system_prompt": "You are a helpful coding agent. Replace this prompt.",
+        "tools": ["list_files", "read_file", "grep", "create_file"],
+    }
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    out.result(
+        {"name": name, "path": str(dest)},
+        human=f"created agent scaffold at {dest} (edit its system_prompt/tools)",
+    )
+    return 0
+
+
+def cmd_agent_remove(out: Out, name: str, assume_yes: bool) -> int:
+    base = _agents_dir()
+    dest = base / (name if name.endswith(".json") else f"{name}.json")
+    if not dest.is_file():
+        # Fall back to matching the declared agent name.
+        for path in sorted(base.glob("*.json")) if base.is_dir() else []:
+            if _read_agent(path).get("name") == name:
+                dest = path
+                break
+    if not dest.is_file():
+        raise SetupError(f"no user agent '{name}'")
+    if not confirm(f"Remove agent file '{dest.name}'?", assume_yes=assume_yes):
+        raise SetupError("aborted", exit_code=2)
+    dest.unlink()
+    out.result({"file": dest.name, "removed": True}, human=f"removed {dest.name}")
+    return 0

code_puppy_core_plugins-0.0.96/code_puppy_core_plugins/setup_cli/auth_cmds.py

@@ -0,0 +1,124 @@
+"""``setup auth`` — one front door for every provider login Code Puppy has.
+
+OAuth logins are *delegated* to the owning plugin's existing interactive
+command in a full Code Puppy subprocess (``code-puppy -p "/x-auth"``):
+those flows print through the messaging system and may open browsers or
+localhost callbacks, none of which exist yet in the ``handle_cli_args``
+context this CLI runs in. Status/logout reads go through the plugins'
+own loaders with structured results. API keys are collected directly
+(hidden prompt, stdin, or environment) into the shared credential
+store and never echoed.
+"""
+
+from __future__ import annotations
+
+import getpass
+import os
+import shutil
+import subprocess
+import sys
+from typing import Optional
+
+from . import providers
+from .output import Out, SetupError
+
+
+def _delegate_slash_command(command: str) -> int:
+    exe = shutil.which("code-puppy") or sys.argv[0]
+    print(f'launching: code-puppy -p "/{command}" (interactive provider flow)')
+    return subprocess.call([exe, "-p", f"/{command}"])
+
+
+def cmd_auth_list(out: Out) -> int:
+    status = providers.all_provider_status()
+    human = []
+    for entry in status.oauth:
+        mark = "authenticated" if entry["authenticated"] else "not authenticated"
+        human.append(f"{entry['id']}: {mark} [{entry['sandbox_transport']}]")
+    for entry in status.api_keys:
+        if entry["authenticated"]:
+            human.append(f"{entry['env_var']}: set")
+    out.result(
+        {"oauth": status.oauth, "api_keys": status.api_keys},
+        human=human or ["(nothing authenticated)"],
+    )
+    return 0
+
+
+def cmd_auth_status(out: Out, provider_id: str) -> int:
+    provider = providers.get_oauth_provider(provider_id)
+    if provider:
+        entry = providers.oauth_status(provider)
+        out.result(
+            entry,
+            human=f"{provider.id}: "
+            + ("authenticated" if entry["authenticated"] else "not authenticated")
+            + f" (source: {entry['source']})",
+        )
+        return 0 if entry["authenticated"] else 1
+    env_var = provider_id.strip().upper()
+    if providers.is_known_api_key_env(env_var):
+        present = providers.credential_present(env_var)
+        out.result(
+            {"env_var": env_var, "authenticated": present, "kind": "api-key"},
+            human=f"{env_var}: {'set' if present else 'not set'}",
+        )
+        return 0 if present else 1
+    raise SetupError(
+        f"unknown provider '{provider_id}' (see `setup auth list`)", exit_code=2
+    )
+
+
+def _collect_api_key(env_var: str, from_env: Optional[str], stdin: bool) -> str:
+    if stdin:
+        value = sys.stdin.read().strip()
+    elif from_env:
+        value = os.environ.get(from_env, "").strip()
+    else:
+        value = getpass.getpass(f"Enter {env_var}: ").strip()
+    if not value:
+        raise SetupError(f"no value provided for {env_var}")
+    return value
+
+
+def cmd_auth_login(
+    out: Out, provider_id: str, from_env: Optional[str], stdin: bool
+) -> int:
+    provider = providers.get_oauth_provider(provider_id)
+    if provider and provider.login_kind == "slash" and provider.auth_command:
+        return _delegate_slash_command(provider.auth_command)
+    env_var = (
+        provider.env_var
+        if provider and provider.env_var
+        else provider_id.strip().upper()
+    )
+    if not env_var:
+        raise SetupError(f"provider '{provider_id}' has no API-key login", exit_code=2)
+    value = _collect_api_key(env_var, from_env, stdin)
+    from code_puppy.provider_credentials import save_credential
+
+    save_credential(env_var, value)
+    out.result(
+        {"env_var": env_var, "saved": True}, human=f"saved credential for {env_var}"
+    )
+    return 0
+
+
+def cmd_auth_logout(out: Out, provider_id: str) -> int:
+    provider = providers.get_oauth_provider(provider_id)
+    if provider and provider.logout_command:
+        return _delegate_slash_command(provider.logout_command)
+    env_var = (
+        provider.env_var
+        if provider and provider.env_var
+        else provider_id.strip().upper()
+    )
+    from code_puppy.provider_credentials import save_credential
+
+    save_credential(env_var, "")
+    out.result(
+        {"env_var": env_var, "cleared": True},
+        human=f"cleared stored credential for {env_var} "
+        "(a shell environment variable of the same name still wins if set)",
+    )
+    return 0

code_puppy_core_plugins-0.0.96/code_puppy_core_plugins/setup_cli/cli.py

@@ -0,0 +1,271 @@
+"""Argument parsing and dispatch for ``code-puppy --setup ...``.
+
+The host CLI hands us the raw token tail after ``--setup``
+(``argparse.REMAINDER``); this module owns a private subparser tree so
+setup flags never collide with the agent's own flags.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from . import (
+    agent_cmds,
+    auth_cmds,
+    config_cmds,
+    doctor,
+    export_cmds,
+    mcp_cmds,
+    model_cmds,
+    plugin_cmds,
+    sbx_plan,
+    skill_cmds,
+    wizard,
+)
+from .output import Out, SetupError
+
+
+def build_parser() -> argparse.ArgumentParser:
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--json", action="store_true", help="machine-readable output")
+
+    parser = argparse.ArgumentParser(
+        prog="code-puppy --setup",
+        description="Configure Code Puppy non-interactively "
+        "(auth, models, plugins, MCP servers, skills, agents, settings).",
+        parents=[common],
+    )
+    sub = parser.add_subparsers(dest="group")
+
+    p = sub.add_parser("doctor", parents=[common], help="diagnose the current setup")
+    p.add_argument("--network", action="store_true", help="also probe provider domains")
+    p.set_defaults(func=_doctor)
+
+    p = sub.add_parser("wizard", parents=[common], help="guided first-run setup")
+    p.add_argument("--provider", help="provider id (see `auth list`)")
+    p.add_argument("--model", help="model key to make the default")
+    p.set_defaults(func=_wizard)
+
+    p = sub.add_parser("config", parents=[common], help="puppy.cfg access")
+    pc = p.add_subparsers(dest="action", required=True)
+    g = pc.add_parser("get", parents=[common])
+    g.add_argument("key", nargs="?")
+    g.set_defaults(func=lambda o, a: config_cmds.cmd_config_get(o, a.key))
+    s = pc.add_parser("set", parents=[common])
+    s.add_argument("key")
+    s.add_argument("value")
+    s.set_defaults(func=lambda o, a: config_cmds.cmd_config_set(o, a.key, a.value))
+    pc.add_parser("path", parents=[common]).set_defaults(
+        func=lambda o, a: config_cmds.cmd_config_path(o)
+    )
+
+    p = sub.add_parser("model", parents=[common], help="model catalog")
+    pm = p.add_subparsers(dest="action", required=True)
+    pm.add_parser("list", parents=[common]).set_defaults(
+        func=lambda o, a: model_cmds.cmd_model_list(o)
+    )
+    c = pm.add_parser("catalog", parents=[common])
+    c.add_argument("provider", nargs="?")
+    c.add_argument("--search")
+    c.set_defaults(
+        func=lambda o, a: model_cmds.cmd_model_catalog(o, a.provider, a.search)
+    )
+    a_ = pm.add_parser("add", parents=[common])
+    a_.add_argument("ref", help="<provider>/<model-id>")
+    a_.add_argument("--set-default", action="store_true")
+    a_.set_defaults(func=lambda o, a: model_cmds.cmd_model_add(o, a.ref, a.set_default))
+    r = pm.add_parser("remove", parents=[common])
+    r.add_argument("key")
+    r.set_defaults(func=lambda o, a: model_cmds.cmd_model_remove(o, a.key))
+    d = pm.add_parser("default", parents=[common])
+    d.add_argument("key", nargs="?")
+    d.set_defaults(func=lambda o, a: model_cmds.cmd_model_default(o, a.key))
+    pm.add_parser("refresh", parents=[common]).set_defaults(
+        func=lambda o, a: model_cmds.cmd_model_refresh(o)
+    )
+
+    p = sub.add_parser("auth", parents=[common], help="provider authentication")
+    pa = p.add_subparsers(dest="action", required=True)
+    pa.add_parser("list", parents=[common]).set_defaults(
+        func=lambda o, a: auth_cmds.cmd_auth_list(o)
+    )
+    s = pa.add_parser("status", parents=[common])
+    s.add_argument("provider")
+    s.set_defaults(func=lambda o, a: auth_cmds.cmd_auth_status(o, a.provider))
+    li = pa.add_parser("login", parents=[common])
+    li.add_argument("provider")
+    li.add_argument(
+        "--from-env", metavar="VAR", help="read an API key from this env var"
+    )
+    li.add_argument("--stdin", action="store_true", help="read an API key from stdin")
+    li.set_defaults(
+        func=lambda o, a: auth_cmds.cmd_auth_login(o, a.provider, a.from_env, a.stdin)
+    )
+    lo = pa.add_parser("logout", parents=[common])
+    lo.add_argument("provider")
+    lo.set_defaults(func=lambda o, a: auth_cmds.cmd_auth_logout(o, a.provider))
+
+    p = sub.add_parser("mcp", parents=[common], help="MCP servers")
+    pmcp = p.add_subparsers(dest="action", required=True)
+    pmcp.add_parser("list", parents=[common]).set_defaults(
+        func=lambda o, a: mcp_cmds.cmd_mcp_list(o)
+    )
+    a_ = pmcp.add_parser("add", parents=[common])
+    a_.add_argument("name")
+    a_.add_argument("--command")
+    a_.add_argument("--url")
+    a_.add_argument("--arg", action="append", default=[])
+    a_.add_argument("--env", action="append", default=[], metavar="KEY=VALUE")
+    a_.add_argument("--bind", metavar="AGENT")
+    a_.set_defaults(
+        func=lambda o, a: mcp_cmds.cmd_mcp_add(
+            o, a.name, a.command, a.arg, a.url, a.env, a.bind
+        )
+    )
+    r = pmcp.add_parser("remove", parents=[common])
+    r.add_argument("name")
+    r.set_defaults(func=lambda o, a: mcp_cmds.cmd_mcp_remove(o, a.name))
+    b = pmcp.add_parser("bind", parents=[common])
+    b.add_argument("agent")
+    b.add_argument("server")
+    b.add_argument("--no-auto-start", action="store_true")
+    b.set_defaults(
+        func=lambda o, a: mcp_cmds.cmd_mcp_bind(o, a.agent, a.server, a.no_auto_start)
+    )
+    u = pmcp.add_parser("unbind", parents=[common])
+    u.add_argument("agent")
+    u.add_argument("server")
+    u.set_defaults(func=lambda o, a: mcp_cmds.cmd_mcp_unbind(o, a.agent, a.server))
+
+    p = sub.add_parser("plugin", parents=[common], help="user plugins")
+    pp = p.add_subparsers(dest="action", required=True)
+    pp.add_parser("list", parents=[common]).set_defaults(
+        func=lambda o, a: plugin_cmds.cmd_plugin_list(o)
+    )
+    a_ = pp.add_parser("add", parents=[common])
+    a_.add_argument("source", help="directory or git URL")
+    a_.add_argument("--name")
+    a_.add_argument("--yes", action="store_true")
+    a_.add_argument("--force", action="store_true")
+    a_.set_defaults(
+        func=lambda o, a: plugin_cmds.cmd_plugin_add(
+            o, a.source, a.name, a.yes, a.force
+        )
+    )
+    r = pp.add_parser("remove", parents=[common])
+    r.add_argument("name")
+    r.add_argument("--yes", action="store_true")
+    r.set_defaults(func=lambda o, a: plugin_cmds.cmd_plugin_remove(o, a.name, a.yes))
+    for verb, disabled in (("enable", False), ("disable", True)):
+        v = pp.add_parser(verb, parents=[common])
+        v.add_argument("name")
+        v.set_defaults(
+            func=lambda o, a, d=disabled: plugin_cmds.cmd_plugin_set_disabled(
+                o, a.name, d
+            )
+        )
+
+    p = sub.add_parser("skill", parents=[common], help="user skills")
+    ps = p.add_subparsers(dest="action", required=True)
+    ps.add_parser("list", parents=[common]).set_defaults(
+        func=lambda o, a: skill_cmds.cmd_skill_list(o)
+    )
+    a_ = ps.add_parser("add", parents=[common])
+    a_.add_argument("source")
+    a_.add_argument("--name")
+    a_.add_argument("--yes", action="store_true")
+    a_.add_argument("--force", action="store_true")
+    a_.set_defaults(
+        func=lambda o, a: skill_cmds.cmd_skill_add(o, a.source, a.name, a.yes, a.force)
+    )
+    r = ps.add_parser("remove", parents=[common])
+    r.add_argument("name")
+    r.add_argument("--yes", action="store_true")
+    r.set_defaults(func=lambda o, a: skill_cmds.cmd_skill_remove(o, a.name, a.yes))
+
+    p = sub.add_parser("agent", parents=[common], help="JSON agent definitions")
+    pag = p.add_subparsers(dest="action", required=True)
+    pag.add_parser("list", parents=[common]).set_defaults(
+        func=lambda o, a: agent_cmds.cmd_agent_list(o)
+    )
+    a_ = pag.add_parser("add", parents=[common])
+    a_.add_argument("file")
+    a_.add_argument("--force", action="store_true")
+    a_.set_defaults(func=lambda o, a: agent_cmds.cmd_agent_add(o, a.file, a.force))
+    n = pag.add_parser("new", parents=[common])
+    n.add_argument("name")
+    n.add_argument("--description", default="")
+    n.set_defaults(func=lambda o, a: agent_cmds.cmd_agent_new(o, a.name, a.description))
+    r = pag.add_parser("remove", parents=[common])
+    r.add_argument("name")
+    r.add_argument("--yes", action="store_true")
+    r.set_defaults(func=lambda o, a: agent_cmds.cmd_agent_remove(o, a.name, a.yes))
+
+    p = sub.add_parser("export", parents=[common], help="write a secret-free bundle")
+    p.add_argument("directory")
+    p.add_argument("--sbx", action="store_true", help="Docker sbx mixin overlay layout")
+    p.set_defaults(func=lambda o, a: export_cmds.cmd_export(o, a.directory, a.sbx))
+
+    p = sub.add_parser("import", parents=[common], help="apply an exported bundle")
+    p.add_argument("directory")
+    p.add_argument("--yes", action="store_true")
+    p.add_argument("--dry-run", action="store_true")
+    p.set_defaults(
+        func=lambda o, a: export_cmds.cmd_import(o, a.directory, a.yes, a.dry_run)
+    )
+
+    p = sub.add_parser(
+        "sbx", parents=[common], help="Docker sandbox derivation helpers"
+    )
+    psbx = p.add_subparsers(dest="action", required=True)
+    plan_p = psbx.add_parser(
+        "plan",
+        parents=[common],
+        help="derive sandbox credentials/egress from configured models",
+    )
+    plan_p.add_argument("--provider", help="restrict to one service/provider id")
+    plan_p.set_defaults(func=lambda o, a: sbx_plan.cmd_sbx_plan(o, a.provider))
+    creds_p = psbx.add_parser(
+        "creds-mixin",
+        parents=[common],
+        help="write the generated credentials mixin for sbx composition",
+    )
+    creds_p.add_argument("directory")
+    creds_p.add_argument("--provider", help="restrict to one service/provider id")
+    creds_p.set_defaults(
+        func=lambda o, a: sbx_plan.cmd_sbx_creds_mixin(o, a.directory, a.provider)
+    )
+    return parser
+
+
+def _doctor(out: Out, args: argparse.Namespace) -> int:
+    report, code = doctor.run_doctor(check_network=args.network)
+    out.result(report, human=doctor.render_human(report))
+    return code
+
+
+def _wizard(out: Out, args: argparse.Namespace) -> int:
+    return wizard.run_wizard(out, args.provider, args.model)
+
+
+def main(tokens: list[str]) -> int:
+    """Entry point called from ``handle_cli_args`` with the raw tail."""
+    parser = build_parser()
+    args = parser.parse_args(tokens)
+    out = Out(json_mode=bool(getattr(args, "json", False)))
+    func = getattr(args, "func", None)
+    if func is None:
+        parser.print_help()
+        return 2
+    try:
+        return int(func(out, args) or 0)
+    except SetupError as exc:
+        if out.json_mode:
+            print(json.dumps({"error": str(exc)}), file=sys.stderr)
+        else:
+            print(f"error: {exc}", file=sys.stderr)
+        return exc.exit_code
+    except BrokenPipeError:
+        return 0

code_puppy_core_plugins-0.0.96/code_puppy_core_plugins/setup_cli/config_cmds.py

@@ -0,0 +1,52 @@
+"""``setup config`` — puppy.cfg access without the interactive ``/set`` UI."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .output import Out, SetupError, mask_value
+
+
+def cmd_config_get(out: Out, key: str | None) -> int:
+    from code_puppy.config import get_config_keys, get_value
+
+    if key:
+        value = get_value(key)
+        out.result(
+            {"key": key, "value": mask_value(key, value), "set": value is not None},
+            human=f"{key} = {mask_value(key, value)}",
+        )
+        return 0
+    data = {name: mask_value(name, get_value(name)) for name in get_config_keys()}
+    out.result(data)
+    return 0
+
+
+def cmd_config_set(out: Out, key: str, value: str) -> int:
+    from code_puppy.command_line.config_apply import apply_setting
+
+    result = apply_setting(key, value, reload_agent=False)
+    if not result.ok:
+        raise SetupError(result.error or f"could not set '{key}'")
+    out.result(
+        {"key": key, "value": mask_value(key, value), "warning": result.warning},
+        human=f"{key} = {mask_value(key, value)}"
+        + (f"\n{result.warning}" if result.warning else ""),
+    )
+    return 0
+
+
+def cmd_config_path(out: Out) -> int:
+    from code_puppy import config as cp_config
+
+    data: dict[str, Any] = {
+        "config_file": cp_config.CONFIG_FILE,
+        "config_dir": cp_config.CONFIG_DIR,
+        "data_dir": cp_config.DATA_DIR,
+        "mcp_servers_file": cp_config.MCP_SERVERS_FILE,
+        "extra_models_file": cp_config.EXTRA_MODELS_FILE,
+        "agents_dir": cp_config.AGENTS_DIR,
+        "skills_dir": cp_config.SKILLS_DIR,
+    }
+    out.result(data)
+    return 0