cade-cli 0.15.0__tar.gz → 0.15.2__tar.gz

{cade_cli-0.15.0 → cade_cli-0.15.2}/PKG-INFO

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

{cade_cli-0.15.0 → cade_cli-0.15.2}/README.md

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

{cade_cli-0.15.0 → cade_cli-0.15.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.15.0"
+version = "0.15.2"
 description = "Cade - The CLI Agent from Arcade.dev"
 readme = "README.md"
 requires-python = ">=3.11"

{cade_cli-0.15.0 → cade_cli-0.15.2}/src/cade_mcp_local/server.py

@@ -74,6 +74,19 @@ external services. For those, use the appropriate remote/cloud tools instead.
 """
 
 
+def web_search_backend_configured() -> bool:
+    """True if the WebSearch tool has a usable backend.
+
+    WebSearch needs either an Arcade key (``ARCADE_API_KEY``) or a generic
+    HTTP/SearXNG endpoint (``CADE_WEB_SEARCH_URL``). When neither is set the
+    tool is not advertised, so the model never calls a search it can't run.
+    """
+    from cade_mcp_local.web.search.arcade import ArcadeSearchBackend
+    from cade_mcp_local.web.search.http import HttpBackend
+
+    return ArcadeSearchBackend.is_configured() or HttpBackend.is_configured()
+
+
 def create_app() -> MCPApp:
     """Create and configure the MCP application with all local tools."""
     app = MCPApp(
@@ -128,9 +141,20 @@ def create_app() -> MCPApp:
     # Structured clarification question for the user
     app.add_tool(ask_user_question_tool)
 
-    # Web tools (read external pages, search the open web)
+    # Web tools. WebFetch always works (httpx fallback + the agent's own LLM for
+    # extraction). WebSearch needs a backend — an Arcade key or a SearXNG/HTTP
+    # endpoint — so only advertise it when one is configured; otherwise the model
+    # would call it and hit a confusing "no search backend configured" error on
+    # first use. Once the user connects Omni, web search comes from the Arcade
+    # catalogue (Arcade_SelectTools/UseTool) instead.
+    #
+    # Note: this gates the shipped (frozen) binary, which serves the local tools
+    # via this create_app(). In source/dev mode the local server is run through
+    # arcade_mcp_server's directory discovery, which registers every @tool and
+    # bypasses this gate — developers typically have a key set anyway.
     app.add_tool(web_fetch_tool)
-    app.add_tool(web_search_tool)
+    if web_search_backend_configured():
+        app.add_tool(web_search_tool)
 
     # MCP resources: server instructions + memory sources for the active persona
     register_resources(app, SERVER_INSTRUCTIONS)

{cade_cli-0.15.0 → cade_cli-0.15.2}/src/cadecoder/cli/app.py

@@ -1,7 +1,75 @@
 """Main CLI application setup and entry point for CadeCoder."""
 
+import multiprocessing
 import os
-import warnings
+import sys
+
+# Defensive: harmless no-op on macOS/Linux, required on Windows if any bundled
+# dependency uses multiprocessing in a frozen build.
+multiprocessing.freeze_support()
+
+
+def _python_style_target(argv: list[str]) -> tuple[str, str, list[str]] | None:
+    """Classify a ``python``-style ``-m``/``-c`` invocation. Pure + testable.
+
+    Returns ``("module", name, rest)`` or ``("code", code, rest)`` if ``argv``
+    looks like ``<exe> -m <importable.module> ...`` or ``<exe> -c <code> ...``;
+    otherwise ``None``. A ``-m`` argument only counts when it's an importable
+    dotted module path (what a dependency passes to ``python -m``), so a real
+    chat message like ``-m "fix the bug"`` is never misclassified.
+    """
+    if len(argv) >= 2 and argv[1] == "-c":
+        return ("code", argv[2] if len(argv) >= 3 else "", list(argv[3:]))
+    if len(argv) >= 3 and argv[1] == "-m":
+        module = argv[2]
+        if "." in module and not any(c.isspace() for c in module):
+            try:
+                import importlib.util
+
+                if importlib.util.find_spec(module) is not None:
+                    return ("module", module, list(argv[3:]))
+            except (ImportError, ValueError):
+                pass
+    return None
+
+
+def _run_python_style_invocation_if_frozen() -> None:
+    """In frozen builds, emulate ``python -m <module>`` / ``python -c <code>``.
+
+    Several dependencies shell out to ``sys.executable`` assuming it is a Python
+    interpreter. The most damaging is arcade-core's detached PostHog usage
+    reporter, which runs ``[sys.executable, "-m", "arcade_core.usage"]`` for
+    every usage event. In a PyInstaller binary ``sys.executable`` is THIS cli,
+    so ``cade -m arcade_core.usage`` was parsed as single-message mode — it
+    started a whole agent, which emitted more usage events, each spawning
+    another agent: a fork bomb of hundreds of ``cade`` processes.
+
+    Intercept the Python-style ``-m``/``-c`` invocations here, before Typer sees
+    them, and run them via ``runpy``/``exec`` so the frozen binary behaves like
+    the interpreter the dependency expected. This both stops the fork bomb and
+    lets the telemetry subprocess do its (lightweight, one-shot) job. No-op for
+    normal use, including ``cade -m "a chat message"``.
+    """
+    if not getattr(sys, "frozen", False):
+        return
+    target = _python_style_target(sys.argv)
+    if target is None:
+        return
+    kind, what, rest = target
+    if kind == "code":
+        sys.argv = ["-c", *rest]
+        exec(compile(what, "<string>", "exec"), {"__name__": "__main__"})
+    else:
+        import runpy
+
+        sys.argv = [what, *rest]
+        runpy.run_module(what, run_name="__main__", alter_sys=True)
+    raise SystemExit(0)
+
+
+_run_python_style_invocation_if_frozen()
+
+import warnings  # noqa: E402
 
 # Set environment variable to disable tokenizers parallelism warning
 # This must be set before any imports that use tokenizers
@@ -390,8 +458,9 @@ def main_callback(
     # when not attached to an interactive terminal (piped/CI).
     from cadecoder.cli.onboarding import needs_onboarding, run_onboarding
 
+    did_onboard = False
     if needs_onboarding():
-        run_onboarding(console)
+        did_onboard = run_onboarding(console)
 
     # Interaction + runtime-backed commands run as the current agent, auto-creating
     # a `default` agent on first run via build_runtime → ensure_current_agent.
@@ -399,6 +468,16 @@ def main_callback(
     set_runtime(runtime)
     ctx.obj["runtime"] = runtime
 
+    # Right after first-run setup (runtime now available), offer to connect
+    # Arcade Omni so external tools work out of the box. No-op otherwise.
+    if did_onboard:
+        try:
+            from cadecoder.cli.commands.mcp import offer_connect_omni
+
+            offer_connect_omni(console)
+        except Exception:  # noqa: BLE001
+            pass
+
     # Handle single message mode
     if message is not None and ctx.invoked_subcommand is None:
         import sys

{cade_cli-0.15.0 → cade_cli-0.15.2}/src/cadecoder/cli/commands/auth.py

@@ -86,6 +86,16 @@ def login(
 
         log.info(f"User {whoami.email} logged in via OAuth.")
 
+        # Offer to connect Arcade Omni so the agent can use external tools
+        # (Gmail, Slack, web search, …) without a separate API key. No-op when
+        # non-interactive or already authorized.
+        try:
+            from cadecoder.cli.commands.mcp import offer_connect_omni
+
+            offer_connect_omni(console)
+        except Exception as e:  # noqa: BLE001
+            log.debug(f"omni connect offer skipped: {e}")
+
     except OAuthLoginError as e:
         console.print(f"\n[red]✗ Login failed:[/red] {escape(str(e))}")
         raise typer.Exit(code=1)

{cade_cli-0.15.0 → cade_cli-0.15.2}/src/cadecoder/cli/commands/mcp.py

@@ -12,10 +12,12 @@ from rich.console import Console
 from rich.table import Table
 
 from cadecoder.tools.manager import (
+    KNOWN_SERVERS,
     MCPAuthType,
     MCPServerConfig,
     MCPServerStore,
     MCPToolManager,
+    known_server_config,
 )
 from cadecoder.tools.manager.mcp import MCP_PROTOCOL_VERSION
 
@@ -37,15 +39,29 @@ def mcp_callback(ctx: typer.Context) -> None:
         raise typer.Exit(0)
 
 
+def _print_known_servers_hint(configured: set[str]) -> None:
+    """Show built-in known servers the user hasn't connected yet."""
+    available = [name for name in KNOWN_SERVERS if name not in configured]
+    if not available:
+        return
+    console.print("\n[dim]Connectable services (OAuth):[/dim]")
+    for name in available:
+        desc = KNOWN_SERVERS[name].get("description", "")
+        console.print(f"  [cyan]{name}[/cyan] — {desc}")
+    console.print(f"  [dim]Connect with [bold]cade mcp authorize {available[0]}[/bold].[/dim]")
+
+
 @mcp_app.command("list")
 def list_servers() -> None:
     """List all configured MCP servers."""
     store = MCPServerStore()
     servers = store.list_all()
+    configured = {s.name for s in servers}
 
     if not servers:
         console.print("[yellow]No MCP servers configured.[/yellow]")
         console.print("[dim]Use 'cade mcp add <name> <url>' to add a server.[/dim]")
+        _print_known_servers_hint(configured)
         return
 
     table = Table(title="MCP Servers")
@@ -62,7 +78,9 @@ def list_servers() -> None:
             server.last_connected.strftime("%Y-%m-%d %H:%M") if server.last_connected else "-"
         )
         auth_display = server.auth_type.value
-        if server.auth_type != MCPAuthType.NONE:
+        if server.auth_type == MCPAuthType.OAUTH:
+            auth_display += " ✓" if server.oauth_tokens else " ✗"
+        elif server.auth_type != MCPAuthType.NONE:
             auth_display += " ✓" if server.auth_value else " ✗"
 
         table.add_row(
@@ -75,6 +93,7 @@ def list_servers() -> None:
         )
 
     console.print(table)
+    _print_known_servers_hint(configured)
 
 
 @mcp_app.command("add")
@@ -343,40 +362,35 @@ class OAuthCallbackHandler(http.server.BaseHTTPRequestHandler):
         pass
 
 
-@mcp_app.command("authorize")
-def authorize_server(
-    name: Annotated[str, typer.Argument(help="Name of the server to authorize")],
-    client_id: Annotated[
-        str | None,
-        typer.Option("--client-id", "-c", help="OAuth client ID (auto-registers if not provided)"),
-    ] = None,
-    scope: Annotated[
-        str | None,
-        typer.Option("--scope", "-s", help="OAuth scopes (space-separated)"),
-    ] = None,
-    skip_dcr: Annotated[
-        bool,
-        typer.Option("--skip-dcr", help="Skip Dynamic Client Registration"),
-    ] = False,
-) -> None:
-    """Initiate OAuth authorization flow for an MCP server.
-
-    This command will:
-    1. Discover the authorization server from the MCP server
-    2. Register as a client (DCR) if no client_id is configured
-    3. Open a browser for you to authorize
-    4. Capture the callback and exchange the code for tokens
-    5. Store the tokens for future use
+def run_mcp_authorization(
+    name: str,
+    *,
+    client_id: str | None = None,
+    scope: str | None = None,
+    skip_dcr: bool = False,
+) -> bool:
+    """Run the MCP OAuth authorization flow for a server. Returns success.
+
+    If ``name`` isn't configured yet but is a built-in known server (e.g.
+    ``omni``), it's added in a disabled state first and only enabled once
+    authorization succeeds — so a cancelled/failed flow never leaves a broken
+    server that would error during chat.
     """
     global _oauth_result
     _oauth_result = {"code": None, "error": None}
 
     store = MCPServerStore()
     server = store.get(name)
-
-    if not server:
-        console.print(f"[red]Server '{name}' not found.[/red]")
-        raise typer.Exit(1)
+    if server is None:
+        server = known_server_config(name)
+        if server is None:
+            console.print(f"[red]Server '{name}' not found.[/red]")
+            console.print(
+                "[dim]Add it with 'cade mcp add <name> <url>', "
+                "or authorize a known server like 'omni'.[/dim]"
+            )
+            return False
+        store.add(server)  # persisted disabled; enabled on success
 
     if client_id:
         server.oauth_client_id = client_id
@@ -387,11 +401,10 @@ def authorize_server(
         manager = MCPToolManager(server, store)
 
         try:
-            # First, try to initialize to trigger 401 and discover auth server
+            # Initialize to trigger the 401 that advertises the auth server.
             console.print("[cyan]Discovering authorization server...[/cyan]")
 
             try:
-                # Make a test request to get 401
                 await manager._send_request(
                     "initialize",
                     {
@@ -401,6 +414,8 @@ def authorize_server(
                     },
                 )
                 console.print("[yellow]Server doesn't require authentication.[/yellow]")
+                server.enabled = True
+                store.add(server)
                 return True
             except Exception as e:
                 if "ToolAuthorizationRequired" not in str(type(e).__name__):
@@ -411,7 +426,7 @@ def authorize_server(
                 console.print("[red]Failed to discover authorization server.[/red]")
                 return False
 
-            # Perform DCR if needed (no client_id provided or configured)
+            # Perform DCR if no client_id is provided/configured.
             effective_client_id = client_id or server.oauth_client_id
             if not effective_client_id and not skip_dcr:
                 registration_endpoint = manager._auth_server_metadata.get("registration_endpoint")
@@ -447,19 +462,18 @@ def authorize_server(
                     console.print("[yellow]Tip: Provide a client_id with --client-id[/yellow]")
                     return False
 
-            # Start local callback server
+            # Start local callback server (redirect_uri is 127.0.0.1:9876/callback).
             server_address = ("127.0.0.1", 9876)
             httpd = http.server.HTTPServer(server_address, OAuthCallbackHandler)
             httpd.timeout = 300  # 5 minute timeout
 
-            # Generate new OAuth flow with proper PKCE
             auth_url, code_verifier, state = await manager._oauth_handler.start_oauth_flow(
                 manager._auth_server_metadata,
                 scope,
                 effective_client_id,
             )
-            # Update the manager's pending verifier to match this auth flow
-            # (the initial 401 discovery generated a different verifier)
+            # Match the manager's pending verifier to this auth flow (the initial
+            # 401 discovery generated a different verifier).
             manager._pending_code_verifier = code_verifier
             manager._pending_state = state
 
@@ -469,7 +483,6 @@ def authorize_server(
 
             console.print("[yellow]Waiting for authorization (5 min timeout)...[/yellow]")
 
-            # Handle one request
             def handle_callback() -> None:
                 httpd.handle_request()
 
@@ -485,22 +498,90 @@ def authorize_server(
                 console.print("[red]No authorization code received.[/red]")
                 return False
 
-            # Exchange code for tokens
             console.print("[cyan]Exchanging code for tokens...[/cyan]")
             success = await manager.complete_oauth_flow(_oauth_result["code"])
 
             if success:
+                server.enabled = True
+                store.add(server)
                 console.print(f"[green]✓[/green] Successfully authorized '{name}'")
                 return True
-            else:
-                console.print("[red]Failed to exchange code for tokens.[/red]")
-                return False
+            console.print("[red]Failed to exchange code for tokens.[/red]")
+            return False
 
         finally:
             await manager.close()
 
-    success = asyncio.run(run_oauth_flow())
-    if not success:
+    return asyncio.run(run_oauth_flow())
+
+
+def offer_connect_omni(target_console: Console | None = None) -> None:
+    """Offer to connect Arcade Omni (external tools) if not already authorized.
+
+    Called after ``cade login`` and after first-run onboarding. No-op when the
+    terminal isn't interactive or when Omni is already authorized, so it never
+    blocks scripted/CI use.
+    """
+    con = target_console or console
+
+    from cadecoder.cli.onboarding import can_prompt
+
+    if not can_prompt():
+        return
+
+    try:
+        store = MCPServerStore()  # get_runtime() auto-builds + ensures an agent
+    except Exception:  # noqa: BLE001
+        return
+
+    existing = store.get("omni")
+    if existing is not None and existing.oauth_tokens is not None:
+        return  # already connected
+
+    from rich.prompt import Confirm
+
+    con.print()
+    con.print(
+        "[bold]Connect external tools?[/bold] Arcade [cyan]Omni[/cyan] lets Cade use "
+        "Gmail, Slack, GitHub, web search and more — authorized with your Arcade login "
+        "(no API key needed)."
+    )
+    try:
+        proceed = Confirm.ask("Authorize Omni now? (opens your browser)", default=True, console=con)
+    except (KeyboardInterrupt, EOFError):
+        con.print()
+        return
+
+    if not proceed:
+        con.print("[dim]Skipped. Connect anytime with [bold]cade mcp authorize omni[/bold].[/dim]")
+        return
+
+    if not run_mcp_authorization("omni"):
+        con.print("[dim]You can retry later with [bold]cade mcp authorize omni[/bold].[/dim]")
+
+
+@mcp_app.command("authorize")
+def authorize_server(
+    name: Annotated[str, typer.Argument(help="Name of the server to authorize")],
+    client_id: Annotated[
+        str | None,
+        typer.Option("--client-id", "-c", help="OAuth client ID (auto-registers if not provided)"),
+    ] = None,
+    scope: Annotated[
+        str | None,
+        typer.Option("--scope", "-s", help="OAuth scopes (space-separated)"),
+    ] = None,
+    skip_dcr: Annotated[
+        bool,
+        typer.Option("--skip-dcr", help="Skip Dynamic Client Registration"),
+    ] = False,
+) -> None:
+    """Authorize an MCP server over OAuth (browser flow).
+
+    Works with any configured server, or a built-in known server by name
+    (e.g. ``cade mcp authorize omni`` to connect Arcade's external tools).
+    """
+    if not run_mcp_authorization(name, client_id=client_id, scope=scope, skip_dcr=skip_dcr):
         raise typer.Exit(1)
 
 

{cade_cli-0.15.0 → cade_cli-0.15.2}/src/cadecoder/tools/manager/__init__.py

@@ -7,11 +7,13 @@ from cadecoder.tools.manager.base import (
 )
 from cadecoder.tools.manager.composite import CompositeToolManager
 from cadecoder.tools.manager.config import (
+    KNOWN_SERVERS,
     MCPAuthType,
     MCPOAuthTokens,
     MCPServerConfig,
     MCPServerStore,
     MCPTransportType,
+    known_server_config,
 )
 from cadecoder.tools.manager.mcp import MCPOAuthHandler, MCPToolManager
 
@@ -30,4 +32,7 @@ __all__ = [
     "MCPAuthType",
     "MCPOAuthTokens",
     "MCPTransportType",
+    # Known remote servers
+    "KNOWN_SERVERS",
+    "known_server_config",
 ]

{cade_cli-0.15.0 → cade_cli-0.15.2}/src/cadecoder/tools/manager/config.py

@@ -147,6 +147,40 @@ class MCPServerConfig:
         )
 
 
+# Built-in, well-known remote MCP servers a user can connect with one command
+# (`cade mcp authorize <name>`). They are *not* added to an agent until the user
+# authorizes them, so they never break a fresh install. Omni is Arcade's
+# meta-discovery server: once authorized over OAuth it exposes the whole Arcade
+# tool catalog (Gmail, Slack, GitHub, web search, …) via SelectTools/UseTool —
+# no ARCADE_API_KEY required (auth rides the user's Arcade login).
+KNOWN_SERVERS: dict[str, dict[str, str]] = {
+    "omni": {
+        "url": "https://omni.arcade.dev/mcp",
+        "description": (
+            "Arcade Omni — discover & run external tools (Gmail, Slack, GitHub, web search, …)"
+        ),
+    },
+}
+
+
+def known_server_config(name: str) -> "MCPServerConfig | None":
+    """Return a fresh, disabled OAuth config for a built-in known server.
+
+    Disabled by default so it is only connected after a successful
+    ``cade mcp authorize <name>`` (which flips ``enabled`` on).
+    """
+    info = KNOWN_SERVERS.get(name)
+    if info is None:
+        return None
+    return MCPServerConfig(
+        name=name,
+        url=info["url"],
+        transport=MCPTransportType.HTTP,
+        auth_type=MCPAuthType.OAUTH,
+        enabled=False,
+    )
+
+
 class MCPServerStore:
     """Persistent storage for the current agent's MCP server configurations.