cade-cli 0.16.2__tar.gz → 0.16.4__tar.gz

{cade_cli-0.16.2 → cade_cli-0.16.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.16.2
+Version: 0.16.4
 Summary: Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://arcadeagent.dev/docs
@@ -129,7 +129,7 @@ The script detects your OS/arch, downloads the matching prebuilt binary
 `~/.local/bin`. Pin a version or install location:
 
 ```bash
-CADE_VERSION=0.16.2 CADE_INSTALL_DIR=/usr/local/bin \
+CADE_VERSION=0.16.4 CADE_INSTALL_DIR=/usr/local/bin \
   sh -c "$(curl -fsSL https://arcadeagent.dev/install)"
 ```
 

{cade_cli-0.16.2 → cade_cli-0.16.4}/README.md

@@ -38,7 +38,7 @@ The script detects your OS/arch, downloads the matching prebuilt binary
 `~/.local/bin`. Pin a version or install location:
 
 ```bash
-CADE_VERSION=0.16.2 CADE_INSTALL_DIR=/usr/local/bin \
+CADE_VERSION=0.16.4 CADE_INSTALL_DIR=/usr/local/bin \
   sh -c "$(curl -fsSL https://arcadeagent.dev/install)"
 ```
 

{cade_cli-0.16.2 → cade_cli-0.16.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.16.2"
+version = "0.16.4"
 description = "Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)"
 readme = "README.md"
 requires-python = ">=3.11"

{cade_cli-0.16.2 → cade_cli-0.16.4}/src/cadecoder/cli/commands/mcp.py

@@ -617,6 +617,70 @@ def authorize_server(
         raise typer.Exit(1)
 
 
+@mcp_app.command("install-hosts")
+def install_hosts_cmd(
+    agent: Annotated[
+        str,
+        typer.Option("--agent", "-a", help="Agent the stdio shim targets."),
+    ] = "default",
+    force: Annotated[
+        bool,
+        typer.Option("--force", "-f", help="Overwrite an existing cade MCP entry."),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Show what would change without writing."),
+    ] = False,
+) -> None:
+    """Register Cade as an MCP server in Claude Desktop, Cursor, Claude Code, etc.
+
+    Only touches hosts that already look installed (their config dir/file exists
+    under your home directory). Safe to re-run — updates the command path after
+    upgrades. The curl installer runs this automatically unless
+    ``CADE_SKIP_MCP_HOSTS=1``.
+    """
+    from cadecoder.cli.mcp_hosts import install_into_hosts, resolve_cade_command
+
+    command = resolve_cade_command()
+    updates = install_into_hosts(command=command, agent=agent, force=force, dry_run=dry_run)
+    if not updates:
+        console.print(
+            "[dim]No MCP hosts detected (looked for Cursor, Claude Desktop, "
+            "Claude Code, OpenCode, Windsurf).[/dim]"
+        )
+        console.print(
+            "[dim]After installing a host, re-run [bold]cade mcp install-hosts[/bold].[/dim]"
+        )
+        return
+
+    console.print(f"[dim]Using binary:[/dim] {command}")
+    changed = 0
+    for u in updates:
+        style = {
+            "added": "green",
+            "updated": "cyan",
+            "unchanged": "dim",
+            "would-added": "yellow",
+            "would-updated": "yellow",
+            "error": "red",
+            "skipped": "dim",
+        }.get(u.status, "white")
+        msg = f"[{style}]{u.status}[/{style}]  {u.name}  [dim]{u.path}[/dim]"
+        if u.detail:
+            msg += f"  ({u.detail})"
+        console.print(msg)
+        if u.status in ("added", "updated", "would-added", "would-updated"):
+            changed += 1
+
+    if changed and not dry_run:
+        console.print(
+            "\n[green]Done.[/green] Restart those apps, then run "
+            "[bold]cade daemon start[/bold] (or just [bold]cade[/bold] — it autostarts)."
+        )
+    elif dry_run:
+        console.print(f"\n[dim]Dry run — {changed} host(s) would change.[/dim]")
+
+
 @mcp_app.command("token-info")
 def token_info(
     name: Annotated[str, typer.Argument(help="Name of the server")],

cade_cli-0.16.4/src/cadecoder/cli/mcp_hosts.py

@@ -0,0 +1,351 @@
+"""Register Cade as an MCP server in detected AI host apps.
+
+Scans typical home-directory config locations for Claude Desktop, Cursor,
+Claude Code, OpenCode, and Windsurf. When a host's config dir (or file)
+already exists, merges a ``cade`` stdio entry that points at
+``cade __mcp-adapter`` — using an absolute path so GUI apps find the binary
+even when ``PATH`` is incomplete.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import re
+import shutil
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+
+SERVER_KEY = "cade"
+DEFAULT_AGENT = "default"
+
+
+class HostKind(str, Enum):
+    """How a host stores MCP server entries."""
+
+    MCP_SERVERS = "mcpServers"  # Claude Desktop / Cursor / Claude Code
+    OPENCODE = "opencode"  # OpenCode ``mcp`` map with type/command
+    WINDSURF = "windsurf"  # Windsurf mcp_config.json
+
+
+@dataclass(frozen=True)
+class HostTarget:
+    """One MCP host config file we may update."""
+
+    name: str
+    path: Path
+    kind: HostKind
+    # Parent path that must exist (app installed / used before).
+    marker: Path
+
+
+@dataclass(frozen=True)
+class HostUpdate:
+    """Result of attempting to register Cade with one host."""
+
+    name: str
+    path: Path
+    status: str  # added | updated | unchanged | skipped | error
+    detail: str = ""
+
+
+def resolve_cade_command() -> str:
+    """Absolute path to the ``cade`` binary when possible."""
+    if getattr(sys, "frozen", False):
+        return str(Path(sys.executable).resolve())
+    which = shutil.which("cade")
+    if which:
+        return str(Path(which).resolve())
+    # Dev / module invocation fallback — hosts need a real executable.
+    return sys.executable
+
+
+def stdio_entry(*, command: str | None = None, agent: str = DEFAULT_AGENT) -> dict[str, Any]:
+    """Claude/Cursor/Claude Code mcpServers entry."""
+    cmd = command or resolve_cade_command()
+    return {
+        "command": cmd,
+        "args": ["__mcp-adapter", "--agent", agent],
+    }
+
+
+def opencode_entry(*, command: str | None = None, agent: str = DEFAULT_AGENT) -> dict[str, Any]:
+    """OpenCode ``mcp.<name>`` local server entry."""
+    cmd = command or resolve_cade_command()
+    return {
+        "type": "local",
+        "command": [cmd, "__mcp-adapter", "--agent", agent],
+        "enabled": True,
+    }
+
+
+def discover_hosts(home: Path | None = None) -> list[HostTarget]:
+    """Return host configs that look installed (marker path exists)."""
+    home = home or Path.home()
+    system = platform.system()
+    targets: list[HostTarget] = []
+
+    # Cursor (all platforms)
+    cursor_dir = home / ".cursor"
+    targets.append(
+        HostTarget(
+            name="Cursor",
+            path=cursor_dir / "mcp.json",
+            kind=HostKind.MCP_SERVERS,
+            marker=cursor_dir,
+        )
+    )
+
+    # Claude Code
+    claude_json = home / ".claude.json"
+    claude_dir = home / ".claude"
+    targets.append(
+        HostTarget(
+            name="Claude Code",
+            path=claude_json,
+            kind=HostKind.MCP_SERVERS,
+            marker=claude_json if claude_json.exists() else claude_dir,
+        )
+    )
+
+    # Claude Desktop
+    if system == "Darwin":
+        desktop_dir = home / "Library" / "Application Support" / "Claude"
+    elif system == "Windows":
+        appdata = os.environ.get("APPDATA", str(home / "AppData" / "Roaming"))
+        desktop_dir = Path(appdata) / "Claude"
+    else:
+        desktop_dir = home / ".config" / "Claude"
+    targets.append(
+        HostTarget(
+            name="Claude Desktop",
+            path=desktop_dir / "claude_desktop_config.json",
+            kind=HostKind.MCP_SERVERS,
+            marker=desktop_dir,
+        )
+    )
+
+    # OpenCode — prefer XDG config; fall back to ~/.opencode
+    opencode_xdg = home / ".config" / "opencode"
+    opencode_legacy = home / ".opencode"
+    if opencode_xdg.exists():
+        # Prefer .json over .jsonc (we write strict JSON).
+        oc_path = opencode_xdg / "opencode.json"
+        if not oc_path.exists() and (opencode_xdg / "opencode.jsonc").exists():
+            oc_path = opencode_xdg / "opencode.jsonc"
+        targets.append(
+            HostTarget(
+                name="OpenCode",
+                path=oc_path,
+                kind=HostKind.OPENCODE,
+                marker=opencode_xdg,
+            )
+        )
+    elif opencode_legacy.exists():
+        oc_path = opencode_legacy / "opencode.json"
+        targets.append(
+            HostTarget(
+                name="OpenCode",
+                path=oc_path,
+                kind=HostKind.OPENCODE,
+                marker=opencode_legacy,
+            )
+        )
+
+    # Windsurf
+    windsurf = home / ".codeium" / "windsurf" / "mcp_config.json"
+    targets.append(
+        HostTarget(
+            name="Windsurf",
+            path=windsurf,
+            kind=HostKind.WINDSURF,
+            marker=home / ".codeium" / "windsurf",
+        )
+    )
+
+    return [t for t in targets if t.marker.exists()]
+
+
+def _strip_jsonc(text: str) -> str:
+    """Best-effort strip of // and /* */ comments for JSONC files."""
+    # Remove /* ... */ blocks
+    text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
+    # Remove // line comments (not inside strings — good enough for config)
+    out_lines: list[str] = []
+    for line in text.splitlines():
+        in_str = False
+        escaped = False
+        cut = len(line)
+        for i, ch in enumerate(line):
+            if escaped:
+                escaped = False
+                continue
+            if ch == "\\":
+                escaped = True
+                continue
+            if ch == '"':
+                in_str = not in_str
+                continue
+            if not in_str and ch == "/" and i + 1 < len(line) and line[i + 1] == "/":
+                cut = i
+                break
+        out_lines.append(line[:cut])
+    return "\n".join(out_lines)
+
+
+def _load_config(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    raw = path.read_text(encoding="utf-8")
+    if path.suffix == ".jsonc":
+        raw = _strip_jsonc(raw)
+    data = json.loads(raw) if raw.strip() else {}
+    if not isinstance(data, dict):
+        raise ValueError(f"{path} root must be a JSON object")
+    return data
+
+
+def _write_config(path: Path, data: dict[str, Any], *, dry_run: bool) -> None:
+    if dry_run:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        backup = path.with_suffix(path.suffix + ".bak")
+        shutil.copy2(path, backup)
+    # Always write .json when source was .jsonc so we don't re-emit comments.
+    out = path if path.suffix != ".jsonc" else path.with_suffix(".json")
+    out.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+
+
+def _merge_mcp_servers(
+    data: dict[str, Any],
+    entry: dict[str, Any],
+    *,
+    force: bool,
+) -> tuple[dict[str, Any], str]:
+    servers = data.get("mcpServers")
+    if servers is None:
+        servers = {}
+        data["mcpServers"] = servers
+    if not isinstance(servers, dict):
+        raise ValueError("mcpServers must be an object")
+
+    existing = servers.get(SERVER_KEY)
+    if existing == entry:
+        return data, "unchanged"
+    if existing is not None and not force:
+        # Update in place when only the command path drifted (common after upgrade).
+        if isinstance(existing, dict) and existing.get("args") == entry.get("args"):
+            servers[SERVER_KEY] = entry
+            return data, "updated"
+        if isinstance(existing, dict):
+            servers[SERVER_KEY] = entry
+            return data, "updated"
+    servers[SERVER_KEY] = entry
+    return data, "added" if existing is None else "updated"
+
+
+def _merge_opencode(
+    data: dict[str, Any],
+    entry: dict[str, Any],
+    *,
+    force: bool,
+) -> tuple[dict[str, Any], str]:
+    mcp = data.get("mcp")
+    if mcp is None:
+        mcp = {}
+        data["mcp"] = mcp
+    if not isinstance(mcp, dict):
+        raise ValueError("mcp must be an object")
+    existing = mcp.get(SERVER_KEY)
+    if existing == entry:
+        return data, "unchanged"
+    if existing is not None and not force:
+        mcp[SERVER_KEY] = entry
+        return data, "updated"
+    mcp[SERVER_KEY] = entry
+    return data, "added" if existing is None else "updated"
+
+
+def _merge_windsurf(
+    data: dict[str, Any],
+    entry: dict[str, Any],
+    *,
+    force: bool,
+) -> tuple[dict[str, Any], str]:
+    # Windsurf uses the same mcpServers shape as Cursor in current builds.
+    return _merge_mcp_servers(data, entry, force=force)
+
+
+def register_host(
+    target: HostTarget,
+    *,
+    command: str | None = None,
+    agent: str = DEFAULT_AGENT,
+    force: bool = False,
+    dry_run: bool = False,
+) -> HostUpdate:
+    """Merge the Cade MCP entry into one host config."""
+    cmd = command or resolve_cade_command()
+    try:
+        data = _load_config(target.path)
+        if target.kind == HostKind.OPENCODE:
+            entry = opencode_entry(command=cmd, agent=agent)
+            data, status = _merge_opencode(data, entry, force=force)
+        elif target.kind in (HostKind.MCP_SERVERS, HostKind.WINDSURF):
+            entry = stdio_entry(command=cmd, agent=agent)
+            merge = _merge_windsurf if target.kind == HostKind.WINDSURF else _merge_mcp_servers
+            data, status = merge(data, entry, force=force)
+        else:
+            return HostUpdate(target.name, target.path, "skipped", "unknown host kind")
+
+        if status != "unchanged":
+            _write_config(target.path, data, dry_run=dry_run)
+            if dry_run:
+                status = f"would-{status}"
+        return HostUpdate(target.name, target.path, status)
+    except Exception as e:  # noqa: BLE001
+        return HostUpdate(target.name, target.path, "error", str(e))
+
+
+def install_into_hosts(
+    *,
+    home: Path | None = None,
+    command: str | None = None,
+    agent: str = DEFAULT_AGENT,
+    force: bool = False,
+    dry_run: bool = False,
+) -> list[HostUpdate]:
+    """Discover installed hosts and register Cade with each."""
+    updates: list[HostUpdate] = []
+    for target in discover_hosts(home):
+        updates.append(
+            register_host(
+                target,
+                command=command,
+                agent=agent,
+                force=force,
+                dry_run=dry_run,
+            )
+        )
+    return updates
+
+
+__all__ = [
+    "HostKind",
+    "HostTarget",
+    "HostUpdate",
+    "DEFAULT_AGENT",
+    "SERVER_KEY",
+    "discover_hosts",
+    "install_into_hosts",
+    "opencode_entry",
+    "register_host",
+    "resolve_cade_command",
+    "stdio_entry",
+]

{cade_cli-0.16.2 → cade_cli-0.16.4}/src/cadecoder/cli/onboarding.py

@@ -312,6 +312,22 @@ def finish_first_run_cloud(console: Console, *, prefer_skip_login: bool = False)
             "[bold]cade mcp authorize hub[/bold].[/dim]"
         )
 
+    # Register Cade in Claude Desktop / Cursor / Claude Code / … when present.
+    try:
+        from cadecoder.cli.mcp_hosts import install_into_hosts
+
+        updates = install_into_hosts()
+        touched = [u for u in updates if u.status in ("added", "updated")]
+        if touched:
+            names = ", ".join(u.name for u in touched)
+            console.print(
+                f"\n[green]✓[/green] Registered Cade as an MCP server in: {names}\n"
+                "[dim]Restart those apps, and keep [bold]cade daemon[/bold] running "
+                "(or just use [bold]cade[/bold] — it autostarts).[/dim]"
+            )
+    except Exception:  # noqa: BLE001
+        pass
+
 
 def run_onboarding(console: Console, *, force: bool = False) -> OnboardingResult:
     """Run the interactive model-setup wizard (step 1 of first-run).

{cade_cli-0.16.2 → cade_cli-0.16.4}/src/cadecoder/providers/anthropic.py

@@ -31,6 +31,11 @@ from cadecoder.providers.base import (
     StreamEvent,
     stream_with_retry,
 )
+from cadecoder.providers.http_client import (
+    is_decompress_error,
+    make_async_http_client,
+    make_sync_http_client,
+)
 
 # HTTP statuses from Anthropic that indicate a transient server-side issue
 # and are safe to retry. 529 is Anthropic's "Overloaded" code; 408/429/5xx
@@ -87,13 +92,18 @@ class AnthropicProvider(Provider):
         if not self.api_key:
             raise ProviderError("Anthropic API key not configured", ProviderType.ANTHROPIC)
 
-        self.client = AsyncAnthropic(api_key=self.api_key)
+        # Own the httpx client so we can pin Accept-Encoding (avoids brotli /
+        # zlib "incorrect header check" failures in frozen PyInstaller builds).
+        self._http_client = make_async_http_client()
+        self.client = AsyncAnthropic(api_key=self.api_key, http_client=self._http_client)
+        self._sync_http_client = None
         self._sync_client: Anthropic | None = None
 
     def _get_sync_client(self) -> Anthropic:
         """Get or create synchronous client for model fetching."""
         if self._sync_client is None:
-            self._sync_client = Anthropic(api_key=self.api_key)
+            self._sync_http_client = make_sync_http_client()
+            self._sync_client = Anthropic(api_key=self.api_key, http_client=self._sync_http_client)
         return self._sync_client
 
     @property
@@ -220,6 +230,9 @@ class AnthropicProvider(Provider):
             return ErrorClass.TRANSIENT
         if isinstance(exc, APIStatusError) and exc.status_code in _RETRIABLE_STATUSES:
             return ErrorClass.TRANSIENT
+        # Broken Content-Encoding on SSE streams (seen in frozen builds).
+        if is_decompress_error(exc):
+            return ErrorClass.TRANSIENT
         return ErrorClass.PERMANENT
 
     def format_error_for_user(self, exc: BaseException) -> str:
@@ -233,6 +246,11 @@ class AnthropicProvider(Provider):
                 return f"Anthropic service error ({exc.status_code}) — please retry."
         if isinstance(exc, APITimeoutError | APIConnectionError):
             return "Network error talking to Anthropic — please retry."
+        if is_decompress_error(exc):
+            return (
+                "Network/encoding error talking to Anthropic (response decompress failed) — "
+                "please retry."
+            )
         return str(exc)
 
     def stream(self, request: ProviderRequest) -> AsyncIterator[StreamEvent]:

cade_cli-0.16.4/src/cadecoder/providers/http_client.py

@@ -0,0 +1,52 @@
+"""Shared httpx client helpers for LLM providers.
+
+Frozen/PyInstaller builds have hit ``zlib.error: Error -3 while decompressing
+data: incorrect header check`` on Anthropic SSE streams when httpx negotiates
+brotli (``br``) or otherwise mishandles ``Content-Encoding``. Pinning
+``Accept-Encoding`` to gzip/deflate avoids that path while keeping compression.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+# Do not advertise ``br`` / ``zstd`` — those decoders are fragile in frozen
+# binaries and have produced "incorrect header check" failures on streams.
+_SAFE_ACCEPT_ENCODING = "gzip, deflate"
+
+
+def make_async_http_client(*, timeout: float = 600.0) -> httpx.AsyncClient:
+    """Return an AsyncClient safe for Anthropic/OpenAI streaming in frozen apps."""
+    return httpx.AsyncClient(
+        headers={"Accept-Encoding": _SAFE_ACCEPT_ENCODING},
+        timeout=httpx.Timeout(timeout, connect=10.0),
+        follow_redirects=True,
+    )
+
+
+def make_sync_http_client(*, timeout: float = 60.0) -> httpx.Client:
+    """Return a sync Client with the same encoding constraints."""
+    return httpx.Client(
+        headers={"Accept-Encoding": _SAFE_ACCEPT_ENCODING},
+        timeout=httpx.Timeout(timeout, connect=10.0),
+        follow_redirects=True,
+    )
+
+
+def is_decompress_error(exc: BaseException) -> bool:
+    """True when ``exc`` looks like a broken Content-Encoding decode."""
+    import zlib
+
+    if isinstance(exc, zlib.error):
+        return True
+    if isinstance(exc, httpx.DecodingError):
+        return True
+    msg = str(exc).lower()
+    return "incorrect header check" in msg or "while decompressing" in msg
+
+
+__all__ = [
+    "is_decompress_error",
+    "make_async_http_client",
+    "make_sync_http_client",
+]

{cade_cli-0.16.2 → cade_cli-0.16.4}/src/cadecoder/providers/openai.py

@@ -30,6 +30,11 @@ from cadecoder.providers.base import (
     StreamEvent,
     stream_with_retry,
 )
+from cadecoder.providers.http_client import (
+    is_decompress_error,
+    make_async_http_client,
+    make_sync_http_client,
+)
 
 # Retriable HTTP statuses — 408 timeout, 429 rate limit, 500/502/503/504 5xx,
 # 529 seen occasionally behind OpenAI-compatible proxies (Anthropic's code).
@@ -57,7 +62,13 @@ class OpenAIProvider(Provider):
         if not self.api_key:
             raise ProviderError("OpenAI API key not configured", ProviderType.OPENAI)
 
-        self.client = AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)
+        self._http_client = make_async_http_client()
+        self.client = AsyncOpenAI(
+            api_key=self.api_key,
+            base_url=self.base_url,
+            http_client=self._http_client,
+        )
+        self._sync_http_client = None
         self._sync_client: OpenAI | None = None
 
     # Curated fallback list of OpenAI cloud chat models, used when the live API
@@ -83,7 +94,12 @@ class OpenAIProvider(Provider):
     def _get_sync_client(self) -> OpenAI:
         """Get or create a synchronous client for model listing."""
         if self._sync_client is None:
-            self._sync_client = OpenAI(api_key=self.api_key, base_url=self.base_url)
+            self._sync_http_client = make_sync_http_client()
+            self._sync_client = OpenAI(
+                api_key=self.api_key,
+                base_url=self.base_url,
+                http_client=self._sync_http_client,
+            )
         return self._sync_client
 
     @property
@@ -173,6 +189,8 @@ class OpenAIProvider(Provider):
             return ErrorClass.TRANSIENT
         if isinstance(exc, APIStatusError) and exc.status_code in _RETRIABLE_STATUSES:
             return ErrorClass.TRANSIENT
+        if is_decompress_error(exc):
+            return ErrorClass.TRANSIENT
         return ErrorClass.PERMANENT
 
     def format_error_for_user(self, exc: BaseException) -> str:
@@ -184,6 +202,11 @@ class OpenAIProvider(Provider):
                 return f"OpenAI service error ({exc.status_code}) — please retry."
         if isinstance(exc, APITimeoutError | APIConnectionError):
             return "Network error talking to OpenAI — please retry."
+        if is_decompress_error(exc):
+            return (
+                "Network/encoding error talking to OpenAI (response decompress failed) — "
+                "please retry."
+            )
         return str(exc)
 
     def stream(self, request: ProviderRequest) -> AsyncIterator[StreamEvent]: