cade-cli 0.15.6__tar.gz → 0.15.8__tar.gz

{cade_cli-0.15.6 → cade_cli-0.15.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.15.6
+Version: 0.15.8
 Summary: Cade - The CLI Agent from Arcade.dev
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://docs.arcade.dev

{cade_cli-0.15.6 → cade_cli-0.15.8}/pyproject.toml

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

{cade_cli-0.15.6 → cade_cli-0.15.8}/src/cade_mcp_local/resources.py

@@ -116,7 +116,7 @@ def register_resources(app: MCPApp, instructions: str) -> None:
         title="cade mem sources (active persona)",
         description=(
             "JSON listing of memory sources registered for the active persona "
-            "(equivalent to `cade mem list`). Read each call so the listing "
+            "(equivalent to `cade mem sources`). Read each call so the listing "
             "reflects sources added after server start."
         ),
         mime_type="application/json",

{cade_cli-0.15.6 → cade_cli-0.15.8}/src/cadecoder/cli/commands/agents.py

@@ -113,6 +113,15 @@ def list_agents() -> None:
     console.print(table)
 
 
+def _enabled_adapter_names(agent: AgentConfig) -> list[str]:
+    """Names of adapters enabled on an agent, sorted for stable display."""
+    return sorted(
+        name
+        for name, settings in agent.adapters.items()
+        if isinstance(settings, dict) and settings.get("enabled")
+    )
+
+
 def _resolve_or_current(name: str | None) -> AgentConfig:
     if name:
         agent = agent_mod.resolve(name)
@@ -147,14 +156,7 @@ def agent_info(
         )
     if agent.mcp:
         console.print(f"  [bold]MCP servers:[/bold] {', '.join(s.name for s in agent.mcp)}")
-    enabled_adapters = [
-        adapter
-        for adapter, settings in (
-            ("telegram", agent.adapters.telegram),
-            ("desktop", agent.adapters.desktop),
-        )
-        if settings.enabled
-    ]
+    enabled_adapters = _enabled_adapter_names(agent)
     if enabled_adapters:
         console.print(f"  [bold]Adapters:[/bold] {', '.join(enabled_adapters)}")
 
@@ -188,14 +190,7 @@ def agent_status() -> None:
     else:
         console.print("  [bold]Serve daemon:[/bold] [dim]stopped[/dim]")
 
-    enabled = [
-        adapter
-        for adapter, settings in (
-            ("telegram", agent.adapters.telegram),
-            ("desktop", agent.adapters.desktop),
-        )
-        if settings.enabled
-    ]
+    enabled = _enabled_adapter_names(agent)
     console.print(f"  [bold]Adapters:[/bold] {', '.join(enabled) or '(none)'}")
 
     try:

{cade_cli-0.15.6 → cade_cli-0.15.8}/src/cadecoder/cli/commands/mem.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
-from typing import Any
+from typing import Annotated, Any
 
 import typer
 from rich.console import Console
@@ -53,14 +53,19 @@ def _apply_memory_env() -> Path:
 def _load_librarian_app() -> Any:
     """Import and return librarian's Typer app (lazy, after the env is set).
 
-    The app is rebranded under ``cade mem``: the low-level ``index`` group is
-    replaced by a top-level ``update`` command (the former ``index build``) and
-    a cade-native ``status`` command that reports the current agent's memory
-    under "Agent Memory" branding.
+    The app is rebranded under ``cade mem``:
+
+    * the low-level ``index`` group becomes a top-level ``update`` command (the
+      former ``index build``);
+    * a cade-native ``status`` command reports the current agent's memory under
+      "Agent Memory" branding;
+    * ``list`` shows the agent's memory **documents** (what users expect from
+      "list"), while the source-directory listing moves to ``sources``.
     """
     from librarian.cli import app
 
     _remap_index_to_update(app)
+    _remap_list_to_docs(app)
     _add_status_command(app)
     return app
 
@@ -97,6 +102,52 @@ def _remap_index_to_update(app: Any) -> None:
         )(build_callback)
 
 
+def _remap_list_to_docs(app: Any) -> None:
+    """Make ``cade mem list`` show memory *documents*, not source directories.
+
+    librarian's top-level ``list`` lists registered source directories — a
+    power-user concept. Under ``cade mem``, "list" should show what's actually
+    in the agent's memory (its indexed documents, including anything the agent
+    saved via ``Memory_*`` tools). So the source listing moves to
+    ``cade mem sources`` and ``list`` is replaced by a cade-native command that
+    renders documents with the same output (and flags) as the in-chat
+    ``/mem list``.
+
+    Power users keep librarian's ``cade mem docs list`` (``--source`` /
+    ``--format`` / ``paths``) untouched.
+
+    Idempotent: safe to call more than once on the same app singleton.
+    """
+    if "sources" in _command_names(app):
+        return  # already remapped
+
+    commands = list(app.registered_commands)
+    list_sources_callback = next(
+        (
+            rc.callback
+            for rc in commands
+            if (rc.name or getattr(rc.callback, "__name__", "")) == "list"
+        ),
+        None,
+    )
+    if list_sources_callback is None:
+        return  # librarian build without a top-level `list` — leave as-is
+
+    # Drop the original top-level `list` (sources), re-register it as `sources`,
+    # and install the cade-native document listing as `list`.
+    app.registered_commands = [
+        rc for rc in commands if (rc.name or getattr(rc.callback, "__name__", "")) != "list"
+    ]
+    app.command(
+        name="sources",
+        help="List the source directories that feed this agent's memory.",
+    )(list_sources_callback)
+    app.command(
+        name="list",
+        help="List the documents stored in this agent's memory.",
+    )(_cade_mem_list)
+
+
 def _add_status_command(app: Any) -> None:
     """Register the cade-native ``status`` command (idempotent)."""
     if "status" in _command_names(app):
@@ -161,6 +212,86 @@ def _mem_status() -> None:
     out.print(table)
 
 
+def _mem_list(*, json_output: bool = False, limit: int = 50) -> None:
+    """Render the documents stored in the current agent's memory.
+
+    The single source of truth for both ``cade mem list`` (CLI) and the in-chat
+    ``/mem list`` command, so the two surfaces always agree. Reads the agent's
+    index directly via ``Database(db_path=...)`` (no env / no HOME side effects)
+    so it never clobbers a long-lived session, mirroring ``_read_memory_stats``.
+
+    Args:
+        json_output: Emit a JSON array (id/title/path/type) to stdout instead of
+            a table — for scripting and piping.
+        limit: Maximum number of documents to display.
+    """
+    import json
+
+    from rich.console import Console as _Console
+    from rich.table import Table
+
+    runtime = get_runtime()
+    memory_dir = ensure_memory_dir(runtime.persona_name)
+    db_path = memory_dir / ".librarian" / "index.db"
+
+    out = _Console()
+
+    documents: list[Any] = []
+    if db_path.exists():
+        try:
+            from librarian.storage.database import Database
+
+            documents = Database(db_path=str(db_path)).list_documents()
+        except Exception as exc:  # noqa: BLE001
+            if json_output:
+                print("[]")
+            else:
+                out.print(f"[red]Could not read this agent's memory:[/red] {exc}")
+            return
+
+    if json_output:
+        payload = [
+            {
+                "id": doc.id,
+                "title": doc.title,
+                "path": doc.path,
+                "type": doc.asset_type.value if getattr(doc, "asset_type", None) else "text",
+            }
+            for doc in documents[:limit]
+        ]
+        print(json.dumps(payload, indent=2, default=str))
+        return
+
+    if not documents:
+        out.print(
+            "[dim]No documents in this agent's memory yet — add docs or run 'cade mem update'.[/dim]"
+        )
+        return
+
+    home = str(Path.home())
+    table = Table(
+        title=f"Agent Memory — {len(documents)} document(s)",
+        show_header=True,
+        header_style="bold cyan",
+    )
+    table.add_column("ID", style="dim", width=4)
+    table.add_column("Title", style="green", max_width=44)
+    table.add_column("Path", style="blue", overflow="fold")
+    for doc in documents[:limit]:
+        table.add_row(str(doc.id), doc.title or "Untitled", doc.path.replace(home, "~"))
+    out.print(table)
+    if len(documents) > limit:
+        out.print(f"[dim]Showing {limit} of {len(documents)}. Use --limit to see more.[/dim]")
+
+
+def _cade_mem_list(
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    limit: Annotated[int, typer.Option("--limit", "-l", help="Max documents to show")] = 50,
+) -> None:
+    """List the documents stored in this agent's memory."""
+    _mem_list(json_output=json_output, limit=limit)
+
+
 def _run_mem(args: list[str]) -> int:
     """Run librarian's CLI in-process, branded as ``cade mem``.
 
@@ -248,7 +379,9 @@ def mem_command(ctx: typer.Context) -> None:
 __all__ = (
     "MEM_CONTEXT_SETTINGS",
     "_apply_memory_env",
+    "_cade_mem_list",
     "_load_librarian_app",
+    "_mem_list",
     "_run_mem",
     "_warm_memory",
     "mem_command",

{cade_cli-0.15.6 → cade_cli-0.15.8}/src/cadecoder/cli/commands/serve.py

@@ -28,7 +28,7 @@ from cadecoder.serve.secrets import store_secret
 
 serve_app = typer.Typer(
     name="serve",
-    help="Run a Cade persona over messaging channels (Telegram, etc.)",
+    help="Run a Cade persona over messaging channels (Telegram, iMessage, etc.)",
     invoke_without_command=True,
 )
 
@@ -131,7 +131,7 @@ def init_cmd(
     persona: Annotated[str | None, typer.Option(help="Persona for the daemon")] = None,
     yes: Annotated[bool, typer.Option("-y", "--yes", help="Skip confirmations")] = False,
 ) -> None:
-    """Interactive wizard: persist Telegram token and write the agent's serve config."""
+    """Interactive wizard: configure messaging adapters and write the agent's serve config."""
     target = config_path()
     cfg = load_config()
     if not yes and any(cfg.enabled_adapters()):
@@ -169,6 +169,11 @@ def init_cmd(
             if sender not in telegram.allowed_senders:
                 telegram.allowed_senders.append(sender)
 
+    if sys.platform == "darwin" and typer.confirm(
+        "Configure iMessage adapter now? (macOS Messages.app)", default=False
+    ):
+        _init_imessage(cfg)
+
     if not cfg.tools.allow and not cfg.tools.deny:
         # Local_* covers all cade_mcp_local tools (read/write/edit/search/tasks
         # /git/…); Memory_* covers the agent-library (librarian) tools renamed
@@ -186,6 +191,92 @@ def init_cmd(
     )
 
 
+def _init_imessage(cfg) -> None:  # noqa: ANN001 — ServeConfig, kept lazy for typer help speed
+    """Interactive iMessage adapter setup: binary check, permission probe, allowlist."""
+    import shutil
+    import subprocess
+
+    from cadecoder.serve.adapters.imessage import canonical_handle
+
+    imessage = cfg.adapters.get("imessage")
+    assert imessage is not None
+
+    binary = shutil.which(imessage.cli_path or "imsg")
+    if binary is None:
+        console.print("[yellow]imsg is not installed.[/yellow]")
+        console.print("Install it first:  [bold]brew install imsg[/bold]")
+        console.print("[dim]Then re-run `cade serve init`. Skipping iMessage setup.[/dim]")
+        return
+
+    # Full Disk Access probe — a failed read means macOS is blocking chat.db.
+    fda_ok = False
+    try:
+        probe = subprocess.run(
+            [binary, "chats", "--limit", "1", "--json"],
+            capture_output=True,
+            timeout=20,
+            check=False,
+        )
+        fda_ok = probe.returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        fda_ok = False
+    if fda_ok:
+        console.print("[green]Messages database is readable (Full Disk Access OK).[/green]")
+    else:
+        console.print("[yellow]Cannot read the Messages database yet.[/yellow]")
+        console.print(
+            "Grant Full Disk Access to your terminal (System Settings → "
+            "Privacy & Security → Full Disk Access), then fully restart it. "
+            "See docs/adapters/imessage.md for the launchd case."
+        )
+        if not typer.confirm("Enable the adapter anyway (grant access later)?", default=True):
+            return
+
+    # Fail-closed allowlist: loop until we get at least one plausible handle,
+    # mirroring the Telegram wizard — an empty list means nobody is answered.
+    console.print(
+        "[dim]Allowed senders: phone numbers (+15551234567) or iMessage emails. "
+        "Only these people can talk to the agent.[/dim]"
+    )
+    while True:
+        raw = typer.prompt("Allowed sender (phone/email)").strip()
+        handle = canonical_handle(raw, imessage.region or "US")
+        if "@" in handle or (handle.startswith("+") and len(handle) >= 9):
+            break
+        console.print("[yellow]That doesn't look like a phone/email. Ctrl-C to abort.[/yellow]")
+    if handle not in imessage.allowed_senders:
+        imessage.allowed_senders.append(handle)
+    while typer.confirm("Add another allowed sender?", default=False):
+        raw = typer.prompt("Allowed sender (phone/email)").strip()
+        extra = canonical_handle(raw, imessage.region or "US")
+        if ("@" in extra or (extra.startswith("+") and len(extra) >= 9)) and (
+            extra not in imessage.allowed_senders
+        ):
+            imessage.allowed_senders.append(extra)
+        else:
+            console.print("[yellow]Skipped (invalid or duplicate).[/yellow]")
+
+    imessage.allow_groups = typer.confirm("Allow group chats?", default=False)
+    imessage.enabled = True
+
+    # Typing indicators need the optional imsg IMCore bridge; report status
+    # so the operator isn't surprised either way. Never suggest disabling SIP.
+    typing_state = "unavailable (adapter will silently skip typing bubbles)"
+    try:
+        status = subprocess.run(
+            [binary, "status", "--json"], capture_output=True, timeout=10, check=False
+        )
+        if status.returncode == 0 and b"true" in status.stdout.lower():
+            typing_state = "bridge detected — typing bubbles active"
+    except (OSError, subprocess.TimeoutExpired):
+        pass
+    console.print(f"[dim]Typing indicators: {typing_state}.[/dim]")
+    console.print(
+        "[dim]Note: the first send will trigger a macOS Automation prompt "
+        "('control Messages') — approve it once.[/dim]"
+    )
+
+
 # --------------------------------------------------------------------------- status
 
 

{cade_cli-0.15.6 → cade_cli-0.15.8}/src/cadecoder/core/agent.py

@@ -74,36 +74,12 @@ class McpServer(BaseModel):
     tool_count: int = 0
 
 
-class TelegramAdapter(BaseModel):
-    """Telegram messaging adapter settings for a served agent."""
-
-    model_config = ConfigDict(extra="ignore")
-    enabled: bool = False
-    secret_ref: str = ""
-    allowed_senders: list[str] = Field(default_factory=list)
-    allowed_chats: list[str] = Field(default_factory=list)
-    drop_pending_updates: bool = True
-
-
-class DesktopAdapter(BaseModel):
-    """Desktop messaging adapter settings for a served agent."""
-
-    model_config = ConfigDict(extra="ignore")
-    enabled: bool = False
-    host: str = "127.0.0.1"
-    port: int = 8765
-    auth_token: str = ""
-    allowed_senders: list[str] = Field(default_factory=lambda: ["desktop"])
-    allowed_conversations: list[str] = Field(default_factory=list)
-    speak_replies: bool = False
-
-
-class Adapters(BaseModel):
-    """Container of per-adapter settings for a served agent."""
-
-    model_config = ConfigDict(extra="ignore")
-    telegram: TelegramAdapter = Field(default_factory=TelegramAdapter)
-    desktop: DesktopAdapter = Field(default_factory=DesktopAdapter)
+# Per-adapter serve settings, keyed by adapter name (``telegram``, ``desktop``,
+# ``imessage``, …). The agent file stores raw TOML tables; validation against
+# each adapter's typed settings class happens in ``cadecoder.serve.config``
+# via the adapter registry, so adding a new adapter never requires touching
+# this module.
+AdapterSections = dict[str, dict[str, Any]]
 
 
 class AgentConfig(BaseModel):
@@ -133,7 +109,7 @@ class AgentConfig(BaseModel):
     workspace: str | None = None
     log_level: str = "info"
     allow_spawn: bool = False
-    adapters: Adapters = Field(default_factory=Adapters)
+    adapters: AdapterSections = Field(default_factory=dict)
 
     # Guardrails (event-keyed table, merged with global cade.toml hooks at
     # runtime). ``disable_hooks`` opts out of named global hooks.

{cade_cli-0.15.6 → cade_cli-0.15.8}/src/cadecoder/serve/adapters/__init__.py

@@ -10,6 +10,7 @@ to the registry, never to concrete adapter modules.
 # drop a module in this directory and add one import line here.
 from cadecoder.serve.adapters import (
     desktop,  # noqa: F401
+    imessage,  # noqa: F401
     telegram,  # noqa: F401
 )
 from cadecoder.serve.adapters.base import (