chartremotely 0.3.1__tar.gz → 0.3.3__tar.gz

{chartremotely-0.3.1 → chartremotely-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.3.1
+Version: 0.3.3
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -219,7 +219,7 @@ Requires-Dist: pyobjc-framework-Quartz>=10; extra == "macos"
 Requires-Dist: pyobjc-framework-Security>=10; extra == "macos"
 Requires-Dist: mlx-whisper>=0.4.3; (sys_platform == "darwin" and platform_machine == "arm64") and extra == "macos"
 Provides-Extra: setup
-Requires-Dist: tollbooth-dpyc[nostr]==0.90.0; extra == "setup"
+Requires-Dist: tollbooth-dpyc[nostr]==0.102.1; extra == "setup"
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: ruff>=0.6; extra == "dev"
@@ -305,6 +305,7 @@ chartremotely serve                         run the local listener
 chartremotely pair                          adopt this display to an operator
 chartremotely relay                         hold a connection open for the operator
 chartremotely doctor                        check everything the agent needs
+chartremotely token                         print the local listener's access token
 ```
 
 `serve` and `relay` are two different transports and most setups want both.
@@ -421,19 +422,23 @@ curl -fsSL https://chartremotely.tollbooth-dpyc.com/install.sh | sh
 
 That installs [uv](https://docs.astral.sh/uv/) if it is missing, installs this
 agent from PyPI (`uv tool install --python 3.12 'chartremotely[macos,setup]'`),
-and runs `chartremotely setup`, which:
-
-1. proves who owns the display — your existing npub by answering a Nostr DM,
-   a key already saved on this Mac, or a new key it makes and saves for you
-   in the Keychain and, through Safari, in iCloud Passwords;
-2. pairs this Mac with that identity, with no code to copy;
-3. gives the Mac its tailnet address with `tailscale serve`;
-4. installs the listener and the relay as launchd agents;
-5. asks macOS for Accessibility and Screen Recording for the Python that runs them;
-6. fetches the Whisper speech model (about 1.6 GB, once) and your display names;
-7. makes this Mac's Shortcut, "ChartRemotely" (talk, or type when it asks),
-   opens it for import, and removes a "ChartRemotely Ask" an older setup left
-   in your library.
+and runs `chartremotely setup`. Setup first says what is installing — version,
+where it came from, the Python it runs on — lists its six steps, and asks
+before changing anything:
+
+1. **Identity** — proves who owns the display (your existing npub by answering
+   a Nostr DM, a key already saved on this Mac, or a new key it makes and saves
+   for you in the Keychain and, through Safari, in iCloud Passwords), then
+   pairs this Mac with that identity, with no code to copy;
+2. **Tailscale** — gives the Mac its tailnet address with `tailscale serve`;
+3. **Services** — installs the listener and the relay as launchd agents;
+4. **Permissions** — asks macOS for Accessibility and Screen Recording for the
+   Python that runs them;
+5. **Hearing** — fetches the Whisper speech model (about 1.6 GB, once) and
+   your display names;
+6. **Shortcut** — makes this Mac's Shortcut, "ChartRemotely" (talk, or type
+   when it asks), opens it for import, and removes a "ChartRemotely Ask" an
+   older setup left in your library.
 
 Run it again at any time: finished steps are skipped. `chartremotely doctor`
 reports anything still missing.
@@ -473,7 +478,11 @@ switch to a grid - discovery follows, and takes about a second.
 
 ## Status
 
-Early. The thinkorswim adapter works; the interfaces are still moving.
+In service. Releases are published to PyPI and installed with the one-line
+installer above; a paired Mac takes commands by voice, from the web app at
+<https://chartremotely.tollbooth-dpyc.com>, and from any MCP client through the
+operator ([ChartRemotely-mcp](https://github.com/lonniev/ChartRemotely-mcp)).
+thinkorswim is the one charting application it drives today.
 
 ## License
 

{chartremotely-0.3.1 → chartremotely-0.3.3}/README.md

@@ -78,6 +78,7 @@ chartremotely serve                         run the local listener
 chartremotely pair                          adopt this display to an operator
 chartremotely relay                         hold a connection open for the operator
 chartremotely doctor                        check everything the agent needs
+chartremotely token                         print the local listener's access token
 ```
 
 `serve` and `relay` are two different transports and most setups want both.
@@ -194,19 +195,23 @@ curl -fsSL https://chartremotely.tollbooth-dpyc.com/install.sh | sh
 
 That installs [uv](https://docs.astral.sh/uv/) if it is missing, installs this
 agent from PyPI (`uv tool install --python 3.12 'chartremotely[macos,setup]'`),
-and runs `chartremotely setup`, which:
-
-1. proves who owns the display — your existing npub by answering a Nostr DM,
-   a key already saved on this Mac, or a new key it makes and saves for you
-   in the Keychain and, through Safari, in iCloud Passwords;
-2. pairs this Mac with that identity, with no code to copy;
-3. gives the Mac its tailnet address with `tailscale serve`;
-4. installs the listener and the relay as launchd agents;
-5. asks macOS for Accessibility and Screen Recording for the Python that runs them;
-6. fetches the Whisper speech model (about 1.6 GB, once) and your display names;
-7. makes this Mac's Shortcut, "ChartRemotely" (talk, or type when it asks),
-   opens it for import, and removes a "ChartRemotely Ask" an older setup left
-   in your library.
+and runs `chartremotely setup`. Setup first says what is installing — version,
+where it came from, the Python it runs on — lists its six steps, and asks
+before changing anything:
+
+1. **Identity** — proves who owns the display (your existing npub by answering
+   a Nostr DM, a key already saved on this Mac, or a new key it makes and saves
+   for you in the Keychain and, through Safari, in iCloud Passwords), then
+   pairs this Mac with that identity, with no code to copy;
+2. **Tailscale** — gives the Mac its tailnet address with `tailscale serve`;
+3. **Services** — installs the listener and the relay as launchd agents;
+4. **Permissions** — asks macOS for Accessibility and Screen Recording for the
+   Python that runs them;
+5. **Hearing** — fetches the Whisper speech model (about 1.6 GB, once) and
+   your display names;
+6. **Shortcut** — makes this Mac's Shortcut, "ChartRemotely" (talk, or type
+   when it asks), opens it for import, and removes a "ChartRemotely Ask" an
+   older setup left in your library.
 
 Run it again at any time: finished steps are skipped. `chartremotely doctor`
 reports anything still missing.
@@ -246,7 +251,11 @@ switch to a grid - discovery follows, and takes about a second.
 
 ## Status
 
-Early. The thinkorswim adapter works; the interfaces are still moving.
+In service. Releases are published to PyPI and installed with the one-line
+installer above; a paired Mac takes commands by voice, from the web app at
+<https://chartremotely.tollbooth-dpyc.com>, and from any MCP client through the
+operator ([ChartRemotely-mcp](https://github.com/lonniev/ChartRemotely-mcp)).
+thinkorswim is the one charting application it drives today.
 
 ## License
 

{chartremotely-0.3.1 → chartremotely-0.3.3}/chartremotely/displays.py

@@ -21,7 +21,7 @@ import threading
 import time
 from collections.abc import Callable
 
-from . import config, keystore, mcpclient, requestlog
+from . import config, holder, mcpclient, requestlog
 from .config import DATA_DIR
 
 PATH = DATA_DIR / "displays.json"
@@ -81,11 +81,11 @@ def refresh(cfg: dict | None = None, client_for=None, path=None) -> list[str] |
     npub = cfg.get("owner_npub")
     if not (base and npub and cfg.get("agent_id")):
         return None
+    if not holder.connected(npub):
+        return None  # not signed in: a background refresh never opens a connection
     try:
-        token = keystore.load_token(npub)
-        if not token:
-            return None
-        payload = (client_for or mcpclient.Client)(base, timeout=30.0).call(TOOL, {"npub": npub, "dpop_token": token})
+        bearer = holder.bearer(base, npub)
+        payload = (client_for or mcpclient.Client)(base, timeout=30.0, bearer=bearer).call(TOOL, {"npub": npub})
     except Exception as exc:  # noqa: BLE001 - a missing list must never cost a reply
         requestlog.outcome("serve", TOOL, "", f"display list failed: {type(exc).__name__}")
         return None

chartremotely-0.3.3/chartremotely/holder.py

@@ -0,0 +1,123 @@
+"""This Mac as a *holder*: a connection the operator knows, into whose wallet
+the owner's npub is proven by Nostr DM.
+
+The agent holds no key and keeps no grant. It keeps only this connection's
+OAuth tokens, in the login Keychain (as the owner's voice sign-in), and names
+the npub on each priced call; the operator checks the grant it holds.
+
+Becoming a holder is the OAuth Authorization Code flow, run headless: the
+operator's ``/authorize`` approves at once (a holder holds nothing until a DM
+proves an npub into it), so the agent reads the code from the redirect
+instead of opening a browser. A refresh token is single-use, so each refresh
+stores the pair it returns.
+
+Stdlib only, like the rest of the listener.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import secrets
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from . import keystore
+
+REDIRECT_URI = "http://127.0.0.1/holder"
+#: Refresh this long before the access token lapses.
+REFRESH_EARLY_SECONDS = 60
+
+
+class HolderError(RuntimeError):
+    """The operator would not connect this Mac."""
+
+
+def _b64url(raw: bytes) -> str:
+    return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
+
+
+def _post(url: str, body: bytes, content_type: str) -> dict:
+    request = urllib.request.Request(url, data=body, method="POST", headers={"Content-Type": content_type})
+    try:
+        with urllib.request.urlopen(request, timeout=30) as response:
+            return json.loads(response.read().decode())
+    except urllib.error.HTTPError as exc:
+        raise HolderError(f"the operator refused ({exc.code})") from None
+    except OSError as exc:
+        raise HolderError(f"could not reach the operator: {exc}") from None
+
+
+class _KeepRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, *args, **kwargs):
+        return None
+
+
+def _token(base: str, form: dict, client_id: str) -> dict:
+    t = _post(f"{base}/token",
+              urllib.parse.urlencode({**form, "client_id": client_id, "resource": f"{base}/mcp"}).encode(),
+              "application/x-www-form-urlencoded")
+    return {"client_id": client_id, "access_token": t["access_token"], "refresh_token": t["refresh_token"],
+            "expires_at": time.time() + float(t.get("expires_in") or 3600)}
+
+
+def _login(base: str) -> dict:
+    client_id = _post(f"{base}/register", json.dumps({
+        "client_name": "ChartRemotely agent",
+        "redirect_uris": [REDIRECT_URI],
+        "grant_types": ["authorization_code", "refresh_token"],
+        "response_types": ["code"],
+        "token_endpoint_auth_method": "none",
+    }).encode(), "application/json")["client_id"]
+    verifier = _b64url(secrets.token_bytes(48))
+    state = _b64url(secrets.token_bytes(16))
+    query = urllib.parse.urlencode({
+        "response_type": "code", "client_id": client_id, "redirect_uri": REDIRECT_URI, "state": state,
+        "code_challenge": _b64url(hashlib.sha256(verifier.encode()).digest()),
+        "code_challenge_method": "S256", "resource": f"{base}/mcp",
+    })
+    try:
+        urllib.request.build_opener(_KeepRedirect).open(f"{base}/authorize?{query}", timeout=30)
+        raise HolderError("the operator did not redirect back")
+    except urllib.error.HTTPError as exc:
+        location = exc.headers.get("Location", "")
+    back = urllib.parse.parse_qs(urllib.parse.urlparse(location).query)
+    if back.get("state") != [state] or not back.get("code"):
+        raise HolderError("the operator's reply did not match this connection")
+    return _token(base, {"grant_type": "authorization_code", "code": back["code"][0],
+                         "redirect_uri": REDIRECT_URI, "code_verifier": verifier}, client_id)
+
+
+def _stored(npub: str) -> dict | None:
+    raw = keystore.load_token(npub)
+    try:
+        t = json.loads(raw) if raw else None
+    except ValueError:
+        return None  # a sign-in saved before this Mac connected as a holder
+    return t if isinstance(t, dict) and t.get("refresh_token") else None
+
+
+def bearer(base: str, npub: str) -> str:
+    """The bearer for the next call: refreshed when it is about to lapse, or a
+    fresh connection when there is none. Raises HolderError or KeystoreError."""
+    t = _stored(npub)
+    if t and t["expires_at"] - REFRESH_EARLY_SECONDS <= time.time():
+        try:
+            t = _token(base, {"grant_type": "refresh_token", "refresh_token": t["refresh_token"]}, t["client_id"])
+        except HolderError:
+            t = None
+    if not t:
+        t = _login(base)
+    keystore.save_token(npub, json.dumps(t))
+    return t["access_token"]
+
+
+def connected(npub: str) -> bool:
+    """True when this Mac has a connection to the operator for ``npub``."""
+    try:
+        return _stored(npub) is not None
+    except keystore.KeystoreError:
+        return False

{chartremotely-0.3.1 → chartremotely-0.3.3}/chartremotely/mcpclient.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import itertools
 import json
 import urllib.request
+from collections.abc import Callable
 
 PROTOCOL_VERSION = "2025-06-18"
 
@@ -53,19 +54,28 @@ def tool_payload(result: dict) -> dict:
 class Client:
     """A session with one operator's ``/mcp`` endpoint."""
 
-    def __init__(self, base_url: str, timeout: float = 60.0) -> None:
+    def __init__(self, base_url: str, timeout: float = 60.0, *, bearer: str = "",
+                 signer: Callable[[str, str, bytes], str] | None = None) -> None:
+        """``bearer`` is this Mac's holder token; ``signer`` signs each request
+        with a key (NIP-98) and wins over it. With neither, the call is anonymous."""
         self.url = base_url.rstrip("/") + "/mcp"
         self.timeout = timeout
+        self.bearer = bearer
+        self.signer = signer
         self.session: str | None = None
         self._ids = itertools.count(1)
 
     def _send(self, message: dict) -> dict:
+        # Identity rides on the connection: a signed request, this Mac's holder
+        # token, or (for free tools) an anonymous bearer.
+        body = json.dumps(message).encode()
         headers = {"Content-Type": "application/json",
-                   "Accept": "application/json, text/event-stream"}
+                   "Accept": "application/json, text/event-stream",
+                   "Authorization": (self.signer("POST", self.url, body) if self.signer
+                                     else f"Bearer {self.bearer or 'anonymous'}")}
         if self.session:
             headers["mcp-session-id"] = self.session
-        request = urllib.request.Request(
-            self.url, data=json.dumps(message).encode(), headers=headers, method="POST")
+        request = urllib.request.Request(self.url, data=body, headers=headers, method="POST")
         try:
             with urllib.request.urlopen(request, timeout=self.timeout) as response:
                 self.session = response.headers.get("mcp-session-id") or self.session

{chartremotely-0.3.1 → chartremotely-0.3.3}/chartremotely/patron.py

@@ -2,9 +2,9 @@
 
 The Mac plays by the operator's rules like any other MCP client. A chart
 change heard by voice is a call to the operator's own ``chart_show_chart``
-(and "read" to ``chart_read_chart``), made with the display owner's ``npub``
-and the ``dpop_token`` they earned by answering a Nostr DM - the same
-envelope every patron sends. The operator prices it, relays it to the named
+(and "read" to ``chart_read_chart``), made as the display owner's ``npub`` over
+this Mac's holder connection, into which the owner proved that npub by
+answering a Nostr DM. The operator prices it, relays it to the named
 display (blank "Where?": this Mac, by its agent_id), and that display's relay
 changes the chart and takes its picture. Nothing here drives the chart.
 
@@ -17,7 +17,7 @@ while the call finishes on its own and its outcome is logged.
 When the sign-in has expired the owner hears so, and one renewal runs in the
 background: a fresh ``chart_request_npub_proof`` DM, then
 ``chart_receive_npub_proof`` on a bounded, slowing schedule until they answer,
-and the new token goes back into the Keychain. The nsec is never asked for.
+which proves the npub into this Mac's connection again. The nsec is never asked for.
 
 Stdlib only (the Keychain behind a lazy import), like the relay.
 """
@@ -28,7 +28,7 @@ import threading
 import time
 from collections.abc import Callable
 
-from . import config, keystore, mcpclient, recent, requestlog
+from . import config, holder, keystore, mcpclient, recent, requestlog
 
 ERR = "ERR "
 #: How long a spoken reply waits for an early refusal before handing off.
@@ -39,7 +39,7 @@ READ_SECONDS = 25.0
 CALL_TIMEOUT = 60.0
 AS_IS = {"", "as is", "asis"}
 
-#: What the SDK answers when a paid call's dpop_token is missing, unknown or expired.
+#: What the SDK answers when the connection does not (or no longer) prove the npub.
 PROOF_CODES = frozenset({"proof_missing", "proof_required", "proof_refresh_needed", "proof_invalid"})
 EXPIRED = ERR + "Your ChartRemotely sign-in expired. Answer the DM on your phone to renew."
 REASON = "Your Mac's ChartRemotely voice control needs you to sign in again."
@@ -88,10 +88,15 @@ def refusal(payload: dict) -> str | None:
 
 # -- the call -----------------------------------------------------------------------
 
-def _call(base: str, tool: str, args: dict) -> dict:
-    """One tool call. Never raises: an unreachable operator is an ``error`` payload."""
+def _call(base: str, npub: str, tool: str, args: dict) -> dict:
+    """One tool call over this Mac's connection for ``npub``. Never raises: an
+    unreachable operator is an ``error`` payload."""
     try:
-        return mcpclient.Client(base, timeout=CALL_TIMEOUT).call(tool, args)
+        return mcpclient.Client(base, timeout=CALL_TIMEOUT, bearer=holder.bearer(base, npub)).call(tool, args)
+    except holder.HolderError as exc:
+        return {"success": False, "error": str(exc)}
+    except keystore.KeystoreError:
+        return {"success": False, "error": "The Keychain would not give me your ChartRemotely sign-in."}
     except mcpclient.McpError as exc:
         return {"success": False, "error": str(exc)}
     except Exception as exc:  # noqa: BLE001 - a background call must never kill the listener
@@ -117,21 +122,12 @@ def send(command: str, where: str, cfg: dict | None = None) -> str:
     if isinstance(mapped, str):
         return mapped
     tool, args = mapped
-    try:
-        token = keystore.load_token(npub)
-    except keystore.KeystoreError as exc:
-        requestlog.outcome("serve", tool, wanted, str(exc))
-        return ERR + "The Keychain would not give me your ChartRemotely sign-in."
-    if not token:
-        renew(base, npub)
-        return EXPIRED
-
-    envelope = {**args, "display": wanted or agent_id, "npub": npub, "dpop_token": token}
+    envelope = {**args, "display": wanted or agent_id, "npub": npub}
     box: dict = {}
     done = threading.Event()
 
     def work() -> None:
-        payload = _call(base, tool, envelope)
+        payload = _call(base, npub, tool, envelope)
         box["payload"] = payload
         settle(base, npub, tool, wanted, payload)
         if tool == "chart_show_chart" and refusal(payload) is None \
@@ -154,7 +150,7 @@ def send(command: str, where: str, cfg: dict | None = None) -> str:
 
 
 def settle(base: str, npub: str, tool: str, where: str, payload: dict) -> None:
-    """Log how a call ended (no token, no arguments) and renew an expired sign-in."""
+    """Log how a call ended (no arguments) and renew an expired sign-in."""
     if payload.get("error_code") in PROOF_CODES:
         renew(base, npub)
     requestlog.outcome("serve", tool, where, refusal(payload))
@@ -175,16 +171,16 @@ def renew(base: str, npub: str, sleep: Callable[[float], None] = time.sleep) ->
 
 def _renew(base: str, npub: str, sleep: Callable[[float], None]) -> None:
     try:
-        sent = _call(base, "chart_request_npub_proof", {"patron_npub": npub, "reason": REASON})
+        sent = _call(base, npub, "chart_request_npub_proof", {"patron_npub": npub, "reason": REASON})
         phrase = sent.get("dpop_token")
         if not phrase:
             requestlog.outcome("serve", "renew", "", refusal(sent) or "no proof request was sent")
             return
         for delay in RENEW_DELAYS:
             sleep(delay)
-            got = _call(base, "chart_receive_npub_proof", {"patron_npub": npub, "dpop_token": phrase})
+            got = _call(base, npub, "chart_receive_npub_proof", {"patron_npub": npub, "dpop_token": phrase})
             if got.get("success") is not False and not got.get("error"):
-                keystore.save_token(npub, str(got.get("dpop_token") or phrase))
+                # Proven into this Mac's connection; nothing to keep here.
                 requestlog.outcome("serve", "renew", "", None)
                 return
             if got.get("error_code") not in (NOT_YET, None):

{chartremotely-0.3.1 → chartremotely-0.3.3}/chartremotely/setup.py

@@ -34,7 +34,7 @@ import tempfile
 from collections.abc import Callable
 from pathlib import Path
 
-from . import config, mcpclient, relay
+from . import config, holder, mcpclient, relay
 from .terminal import Terminal, wants_color
 
 OPERATOR_URL = "https://chartremotely-mcp.fastmcp.app"
@@ -51,10 +51,12 @@ class SetupError(RuntimeError):
 
 # -- identity -----------------------------------------------------------------
 
-def prove_by_dm(client: mcpclient.Client, npub: str, ask: Ask, say: Say) -> str:
-    """Prove an existing npub by the Secure Courier DM. Returns the dpop_token.
+def prove_by_dm(client: mcpclient.Client, npub: str, ask: Ask, say: Say) -> None:
+    """Prove an existing npub by the Secure Courier DM, into this Mac's connection.
 
-    The human answers from their own Nostr client, so no key passes through here.
+    ``client`` carries this Mac's holder token, so the operator keeps the grant
+    for this connection. The human answers from their own Nostr client, so no
+    key passes through here.
     """
     sent = client.call("chart_request_npub_proof", {
         "patron_npub": npub, "verify_at": SITE,
@@ -71,7 +73,6 @@ def prove_by_dm(client: mcpclient.Client, npub: str, ask: Ask, say: Say) -> str:
     got = client.call("chart_receive_npub_proof", {"patron_npub": npub, "dpop_token": phrase})
     if got.get("error"):
         raise SetupError(got["error"])
-    return got.get("dpop_token") or phrase
 
 
 def new_key() -> tuple[str, str]:
@@ -82,11 +83,11 @@ def new_key() -> tuple[str, str]:
     return key.public_key.bech32(), key.bech32()
 
 
-def sign_once(nsec: str, tool: str) -> str:
-    """One kind-27235 proof for one tool call, signed by the SDK."""
-    from tollbooth.identity_proof import create_proof
+def signer_for(nsec: str) -> Callable[[str, str, bytes], str]:
+    """Signs each request with ``nsec`` (NIP-98), by the SDK."""
+    from tollbooth.identity_proof import sign_request
 
-    return create_proof(nsec, tool)
+    return lambda method, url, body: sign_request(nsec, method=method, url=url, body=body)
 
 
 def keep_for_human(npub: str, nsec: str, ask: Ask, say: Say) -> None:
@@ -106,11 +107,11 @@ def keep_for_human(npub: str, nsec: str, ask: Ask, say: Say) -> None:
         keystore.clear_if_unchanged(nsec)
 
 
-def identity(client: mcpclient.Client, ask: Ask, say: Say) -> tuple[str, str, bool]:
+def identity(base: str, ask: Ask, say: Say) -> tuple[str, mcpclient.Client, bool]:
     """Who owns this display, proven.
 
-    Returns (npub, proof for chart_pair_agent, whether that proof is a DM
-    sign-in the listener can keep using).
+    Returns (npub, a client that acts as that npub for chart_pair_agent, and
+    whether this Mac's connection now holds the npub for voice).
     """
     say("Your Nostr identity owns this display:")
     say("  1  I have an npub (I'll answer a Nostr DM to prove it)")
@@ -121,7 +122,9 @@ def identity(client: mcpclient.Client, ask: Ask, say: Say) -> tuple[str, str, bo
         npub = ask("Your npub: ").strip()
         if not npub.startswith("npub1"):
             raise SetupError("that is not an npub")
-        return npub, prove_by_dm(client, npub, ask, say), True
+        client = mcpclient.Client(base, bearer=holder.bearer(base, npub))
+        prove_by_dm(client, npub, ask, say)
+        return npub, client, True
     if choice == "2":
         from . import keystore
 
@@ -133,7 +136,7 @@ def identity(client: mcpclient.Client, ask: Ask, say: Say) -> tuple[str, str, bo
         picked = saved[int(ask("Which key? ").strip() or "1") - 1]
         nsec = keystore.load(picked)  # macOS asks the human first
         try:
-            return picked, sign_once(nsec, "chart_pair_agent"), False
+            return picked, mcpclient.Client(base, signer=signer_for(nsec)), False
         finally:
             del nsec
     if choice == "3":
@@ -141,7 +144,7 @@ def identity(client: mcpclient.Client, ask: Ask, say: Say) -> tuple[str, str, bo
         try:
             say(f"Your new npub is {npub}")
             keep_for_human(npub, nsec, ask, say)
-            return npub, sign_once(nsec, "chart_pair_agent"), False
+            return npub, mcpclient.Client(base, signer=signer_for(nsec)), False
         finally:
             del nsec
     raise SetupError("choose 1, 2 or 3")
@@ -149,40 +152,38 @@ def identity(client: mcpclient.Client, ask: Ask, say: Say) -> tuple[str, str, bo
 
 # -- the voice sign-in --------------------------------------------------------
 
-def keep_sign_in(npub: str, token: str) -> None:
-    """The owner's npub into the config; their sign-in into the Keychain, only."""
-    from . import keystore
-
-    keystore.save_token(npub, token)
+def keep_sign_in(npub: str) -> None:
+    """The owner's npub into the config. Their sign-in is this Mac's connection,
+    whose tokens the holder keeps in the Keychain."""
     config.update(owner_npub=npub)
 
 
 def has_sign_in(npub: str) -> bool:
-    from . import keystore
+    return holder.connected(npub)
 
-    try:
-        return bool(keystore.load_token(npub))
-    except keystore.KeystoreError:
-        return False
 
-
-def voice_sign_in(client: mcpclient.Client, npub: str, ask: Ask, say: Say) -> None:
+def voice_sign_in(base: str, npub: str, ask: Ask, say: Say) -> None:
     """Voice commands are priced tool calls made as the owner: prove the npub by DM for them."""
     config.update(owner_npub=npub)
     say(f"Voice commands are paid for by {npub[:12]}…, signed in by a Nostr DM.")
     if ask("Sign in for voice now? [Y/n] ").strip().lower().startswith("n"):
         say("Then your first voice command sends the DM.")
         return
-    keep_sign_in(npub, prove_by_dm(client, npub, ask, say))
+    prove_by_dm(mcpclient.Client(base, bearer=holder.bearer(base, npub)), npub, ask, say)
+    keep_sign_in(npub)
     say("Voice is signed in.")
 
 
 # -- pairing ------------------------------------------------------------------
 
-def pair(client: mcpclient.Client, base: str, npub: str, proof: str, label: str) -> dict:
-    """Adopt this machine's pairing code with the patron's proof, then collect."""
+def pair(client: mcpclient.Client, base: str, npub: str, label: str) -> dict:
+    """Adopt this machine's pairing code as the patron, then collect.
+
+    ``client`` proves the npub on its connection: signed with their key, or
+    this Mac's connection that holds it.
+    """
     code, expires_in = relay.open_code(base)
-    answer = client.call("chart_pair_agent", {"code": code, "label": label, "npub": npub, "dpop_token": proof})
+    answer = client.call("chart_pair_agent", {"code": code, "label": label, "npub": npub})
     if not answer.get("ok"):
         raise SetupError(answer.get("error") or "the operator refused the pairing")
     return relay.collect(base, code, expires_in)
@@ -250,7 +251,6 @@ def run(ask: Ask = input, say: Say = print, operator_url: str = OPERATOR_URL) ->
 
     # 1. Identity and pairing, unless this Mac is already paired.
     out.step(1, total, "Identity")
-    client = mcpclient.Client(base)
     if cfg.get("agent_id") and cfg.get("agent_secret"):
         out.ok(f"This Mac is already paired ({cfg['agent_id']}).")
         npub = cfg.get("owner_npub") or out.ask("Your npub (whose display this is): ").strip()
@@ -260,18 +260,18 @@ def run(ask: Ask = input, say: Say = print, operator_url: str = OPERATOR_URL) ->
             config.update(owner_npub=npub)
             out.ok("Voice is already signed in.")
         else:
-            voice_sign_in(client, npub, out.ask, out.say)
+            voice_sign_in(base, npub, out.ask, out.say)
     else:
-        npub, proof, by_dm = identity(client, out.ask, out.say)
+        npub, client, by_dm = identity(base, out.ask, out.say)
         label = out.ask("Name this display (e.g. Desk, Office wall): ").strip() or "display"
-        pair(client, base, npub, proof, label)
+        pair(client, base, npub, label)
         out.ok(f"Paired as “{label}”.")
         if by_dm:
-            keep_sign_in(npub, proof)
+            keep_sign_in(npub)
             out.ok("Voice is signed in with the same DM.")
         else:
-            voice_sign_in(client, npub, out.ask, out.say)
-        del proof
+            voice_sign_in(base, npub, out.ask, out.say)
+        del client
 
     # 2. Tailscale.
     from . import tailnet