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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.15.8
+Version: 0.15.9
 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.8 → cade_cli-0.15.9}/pyproject.toml

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

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

@@ -204,7 +204,7 @@ def _init_imessage(cfg) -> None:  # noqa: ANN001 — ServeConfig, kept lazy for
     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("Install it first:  [bold]brew install steipete/tap/imsg[/bold]")
         console.print("[dim]Then re-run `cade serve init`. Skipping iMessage setup.[/dim]")
         return
 
@@ -236,7 +236,8 @@ def _init_imessage(cfg) -> None:  # noqa: ANN001 — ServeConfig, kept lazy for
     # 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]"
+        "Only these people can talk to the agent. Enter your own number/email "
+        "to chat with the agent in your Note-to-Self thread.[/dim]"
     )
     while True:
         raw = typer.prompt("Allowed sender (phone/email)").strip()

{cade_cli-0.15.8 → cade_cli-0.15.9}/src/cadecoder/serve/adapters/imessage.py

@@ -1,7 +1,8 @@
 """Apple iMessage adapter — bridges `cade serve` to Messages.app via `imsg`.
 
 macOS-only. All platform work is delegated to the `imsg` CLI
-(https://imsg.sh, `brew install imsg`), which reads inbound messages from
+(https://imsg.sh, `brew install steipete/tap/imsg`), which reads inbound
+messages from
 `~/Library/Messages/chat.db` and sends through Messages.app's AppleScript
 surface. The adapter runs one long-lived `imsg rpc` subprocess speaking
 JSON-RPC 2.0 over stdio (one JSON object per line) and consumes its
@@ -27,6 +28,17 @@ Permissions (see docs/adapters/imessage.md):
 Typing indicators are best-effort: they need the imsg IMCore bridge (SIP
 disabled + `imsg launch`), which most machines won't have. The adapter
 probes `imsg status --json` once at start and no-ops when unavailable.
+
+Self-chat (texting your own Apple ID) is supported and on by default: when
+the Mac shares the user's personal account, messages they send to their own
+handle (the "Note to Self" thread) count as inbound turns. Loop safety comes
+from tracking what the adapter itself sent — echo rows are dropped by sent
+guid, with a recently-sent-text fallback for the rare send whose guid the
+bridge couldn't report. Outgoing rows in *other* chats (the user texting
+friends, synced from any device) are never treated as inbound: a self-chat
+turn additionally requires the chat's handle to be one of the account's own
+handles, learned from ``destination_caller_id`` on outgoing traffic (or set
+explicitly via ``self_handles``).
 """
 
 from __future__ import annotations
@@ -38,6 +50,7 @@ import json
 import re
 import shutil
 import time
+from collections import deque
 from collections.abc import AsyncIterator
 from pathlib import Path
 from typing import Any
@@ -62,6 +75,12 @@ _TYPING_DURATION = "5s"
 _TYPING_MAX_FAILURES = 3
 _RECONNECT_MAX_ATTEMPTS = 5
 _VERIFY_DELAY_SECONDS = 5.0
+# Echo-suppression state for self-chat mode: how many of our own sent
+# message guids to remember, and how long a sent text stays matchable for
+# the fallback path (sends whose guid the bridge couldn't report).
+_SENT_GUID_LIMIT = 500
+_SENT_TEXT_LIMIT = 64
+_SENT_TEXT_TTL_SECONDS = 180.0
 
 _PERMISSION_HINT = (
     "imsg could not read the Messages database. Grant Full Disk Access to the "
@@ -87,6 +106,10 @@ def canonical_handle(handle: str, region: str = "US") -> str:
     from inbound traffic, not perfect international parsing.
     """
     value = (handle or "").strip()
+    # Messages sometimes prefixes routing handles with the alias type
+    # ("P:+1555…", "e:alice@…"); strip it so they compare like bare handles.
+    if len(value) > 2 and value[1] == ":" and value[0].lower() in ("p", "e"):
+        value = value[2:].strip()
     if not value:
         return ""
     if "@" in value:
@@ -180,6 +203,15 @@ class IMessageAdapter:
         }
         self._allowed_chats = set(settings.allowed_chats or [])
         self._allowed_services = {s.strip().lower() for s in (settings.allowed_services or [])}
+        # Self-chat support: this account's own handles (seeded from config,
+        # auto-learned from destination_caller_id on outgoing rows) plus the
+        # echo-suppression records of what this adapter itself sent.
+        self._own_handles = {
+            canonical_handle(h, region) for h in (settings.self_handles or []) if h.strip()
+        }
+        self._sent_guids: set[str] = set()
+        self._sent_guid_order: deque[str] = deque()
+        self._sent_texts: deque[tuple[str, float]] = deque(maxlen=_SENT_TEXT_LIMIT)
 
     # ------------------------------------------------------------- lifecycle
 
@@ -250,12 +282,42 @@ class IMessageAdapter:
                 params["region"] = self.settings.region
 
         await self._stop_typing(target)
+        # Record the text BEFORE the rpc call: the watch stream can echo our
+        # own send back faster than the send response arrives, and self-chat
+        # mode must never mistake that echo for a new user turn.
+        self._note_sent_text(msg.text)
         result = await self._rpc("send", params)
         guid = str(result.get("guid") or "")
-        if guid and self.settings.verify_delivery:
-            self._spawn_background(self._verify_delivery(guid), name="imessage-verify")
+        if guid:
+            self._remember_sent_guid(guid)
+            if self.settings.verify_delivery:
+                self._spawn_background(self._verify_delivery(guid), name="imessage-verify")
         return guid or str(result.get("id") or "")
 
+    # ------------------------------------------------------ echo suppression
+
+    def _remember_sent_guid(self, guid: str) -> None:
+        """Track a message guid this adapter sent (bounded)."""
+        if guid in self._sent_guids:
+            return
+        self._sent_guids.add(guid)
+        self._sent_guid_order.append(guid)
+        while len(self._sent_guid_order) > _SENT_GUID_LIMIT:
+            self._sent_guids.discard(self._sent_guid_order.popleft())
+
+    def _note_sent_text(self, text: str) -> None:
+        """Track sent text for the guid-less echo fallback (bounded + TTL)."""
+        self._sent_texts.append((text.strip(), time.monotonic()))
+
+    def _matches_recent_send(self, text: str) -> bool:
+        """True (consuming the record) when ``text`` matches a recent send."""
+        now = time.monotonic()
+        for index, (sent_text, sent_at) in enumerate(self._sent_texts):
+            if now - sent_at <= _SENT_TEXT_TTL_SECONDS and sent_text == text:
+                del self._sent_texts[index]
+                return True
+        return False
+
     async def _verify_delivery(self, guid: str) -> None:
         """Silent-failure guard: surface sends Messages accepted but dropped."""
         await asyncio.sleep(_VERIFY_DELAY_SECONDS)
@@ -395,7 +457,7 @@ class IMessageAdapter:
             return found
         raise IMessageBridgeError(
             f"imsg binary not found (cli_path={configured!r}). "
-            "Install it with `brew install imsg` or set cli_path in "
+            "Install it with `brew install steipete/tap/imsg` or set cli_path in "
             "[serve.adapters.imessage]."
         )
 
@@ -503,15 +565,23 @@ class IMessageAdapter:
         if isinstance(chat_id, int) and chat_id > 0:
             self._chat_rowids[chat_guid] = chat_id
 
-        # The watch stream echoes our own sends; without this the agent
-        # would answer itself in an infinite loop.
-        if message.get("is_from_me"):
-            return
         if message.get("is_reaction"):
             return
         text = str(message.get("text") or "").strip()
         if not text:
             return
+        region = self.settings.region or "US"
+
+        is_from_me = bool(message.get("is_from_me"))
+        if is_from_me:
+            # Learn this account's own handles from outgoing routing metadata
+            # regardless of whether self-chat is enabled — it costs nothing
+            # and makes the self-chat check reliable from the first message.
+            caller_id = canonical_handle(str(message.get("destination_caller_id") or ""), region)
+            if caller_id:
+                self._own_handles.add(caller_id)
+            if not self._accept_self_chat_message(message, chat_guid, text):
+                return
 
         service = chat_guid.split(";", 1)[0].strip().lower()
         if self._allowed_services and service not in self._allowed_services:
@@ -524,14 +594,24 @@ class IMessageAdapter:
             log.debug(f"iMessage dropped group message in {chat_guid} (allow_groups=false)")
             return
 
-        sender_raw = str(message.get("sender") or "")
+        if is_from_me:
+            # Self-chat turn: the "sender" is the account owner, identified by
+            # the thread's own handle (the raw sender column is often empty on
+            # self-sent rows).
+            sender_id = canonical_handle(handle_for_conversation(chat_guid) or "", region)
+            sender_name = str(message.get("sender_name") or "Me")
+        else:
+            sender_raw = str(message.get("sender") or "")
+            sender_id = canonical_handle(sender_raw, region)
+            sender_name = str(message.get("sender_name") or sender_raw or "unknown")
+
         guid = str(message.get("guid") or rowid)
         self._inbound.put_nowait(
             InboundMessage(
                 adapter=self.name,
                 conversation_id=chat_guid,
-                sender_id=canonical_handle(sender_raw, self.settings.region or "US"),
-                sender_name=str(message.get("sender_name") or sender_raw or "unknown"),
+                sender_id=sender_id,
+                sender_name=sender_name,
                 text=text,
                 message_id=guid,
                 reply_to_id=(
@@ -540,6 +620,35 @@ class IMessageAdapter:
             )
         )
 
+    def _accept_self_chat_message(self, message: dict[str, Any], chat_guid: str, text: str) -> bool:
+        """Decide whether an outgoing (``is_from_me``) row is a self-chat turn.
+
+        Loop safety first: anything this adapter itself sent is dropped, by
+        guid when the bridge reported one, else by matching recently-sent
+        text. What remains is only accepted as inbound when self-chat is
+        enabled, the thread is a DM, and the thread's handle is one of the
+        account's own handles — i.e. the user texting their own Apple ID.
+        Outgoing messages to anyone else are never turns.
+        """
+        guid = str(message.get("guid") or "")
+        if guid and guid in self._sent_guids:
+            # Consume the matching text record too, so a user later typing
+            # the same text as our reply isn't swallowed by the fallback.
+            self._matches_recent_send(text)
+            return False
+        if not self.settings.self_chat:
+            return False
+        if is_group_conversation(chat_guid):
+            return False
+        own_handle = canonical_handle(
+            handle_for_conversation(chat_guid) or "", self.settings.region or "US"
+        )
+        if not own_handle or own_handle not in self._own_handles:
+            return False
+        if self._matches_recent_send(text):
+            return False
+        return True
+
     async def _rpc(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
         """Send one JSON-RPC request and await its response.
 

{cade_cli-0.15.8 → cade_cli-0.15.9}/src/cadecoder/serve/config.py

@@ -94,6 +94,15 @@ class IMessageAdapterSettings(BaseAdapterSettings):
     # Check message.send_status a few seconds after each send and log an
     # error when Messages reports the send failed (silent-failure guard).
     verify_delivery: bool = True
+    # Answer in the user's own "Note to Self" thread when the Mac shares
+    # their personal Apple ID (no dedicated agent account). Loop-safe: the
+    # adapter's own replies are filtered by sent-message guid/text tracking.
+    # The user's own handle must still be in allowed_senders. DM-only.
+    self_chat: bool = True
+    # This account's own handles (phone/email) for self-chat detection.
+    # Usually left empty — they are learned automatically from outgoing
+    # message routing metadata. Set explicitly if detection misses.
+    self_handles: list[str] = Field(default_factory=list)
 
 
 def _discover_adapters() -> dict[str, type[BaseAdapterSettings]]:

{cade_cli-0.15.8 → cade_cli-0.15.9}/src/cadecoder/templates/serve/serve.toml.example

@@ -40,7 +40,7 @@ allowed_conversations = []                # optional: restrict desktop chat ids
 speak_replies = false                     # opt in to local Kokoro TTS replies
 
 [serve.adapters.imessage]
-# macOS only. Requires `brew install imsg` plus Full Disk Access for the
+# macOS only. Requires `brew install steipete/tap/imsg` plus Full Disk Access for the
 # process running `cade serve` (see docs/adapters/imessage.md).
 enabled = false
 cli_path = "imsg"
@@ -54,6 +54,8 @@ service = "imessage"                      # outbound service for direct sends
 region = "US"                             # country code for phone normalization
 typing_indicators = true                  # best-effort; needs the optional imsg bridge
 verify_delivery = true                    # log an error when Messages drops a send
+self_chat = true                          # answer in your own Note-to-Self thread
+self_handles = []                         # your own handles; auto-learned when empty
 
 # Additional adapters appear under [serve.adapters.<name>]. The full set of
 # supported adapters is whatever is registered in