chartremotely 0.2.8__tar.gz → 0.2.9__tar.gz

{chartremotely-0.2.8 → chartremotely-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.8
+Version: 0.2.9
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -321,16 +321,33 @@ ignores everything sent to it.
 2. **What scale?** — a time frame mnemonic (below), or "as is".
 3. **Where?** — which display. Leave it blank to stay on this Mac.
 
-The Shortcut talks to one Mac — the one that made it. Any name said at
-"Where?" goes to the operator, which finds the display among yours and
-relays the command there (or back here, if the name is this Mac's). Names
-may be loose: for a display paired as "Mac mini", "mac-mini", "mini mac",
-"mini", "macm" and even "mack meeny" all work. The reply you hear is that
-display's. A name that could mean several displays is answered with them,
-and an unknown name with the names you do have.
+The Shortcut talks to one Mac — the one that made it. That Mac looks up the
+company and the scale itself (free: a table, never the chart), then acts as
+an ordinary patron of the operator: it calls the priced `chart_show_chart`
+tool with your npub, your sign-in token and the display named at "Where?"
+(this Mac when blank). A voice change costs what `chart_show_chart` costs.
+Siri answers within about three seconds — "Chart PLTR at half scale sent to
+Mac-mini. Good luck." — and the chart changes a moment later through that
+display's relay, which also takes its picture. Names may be loose: for a
+display paired as "Mac mini", "mac-mini", "mini mac", "mini", "macm" and even
+"mack meeny" all work. A refusal that comes back quickly — a balance too low,
+a display that is unknown or not answering — is spoken instead, in the
+operator's words. "Read" calls `chart_read_chart` and speaks what the chart
+shows.
+
+**Signing in.** The first `chartremotely setup` proves your npub by a Nostr
+DM: reply from your Nostr client, and choose a long `cache_duration` in the
+reply (e.g. `30 days`, or `unlimited`) so voice keeps working — left alone it
+lasts 2 hours. The token the operator returns is kept in this Mac's login
+Keychain ("ChartRemotely voice sign-in"), never in the config or a log; your
+nsec is never asked for. When it expires you hear "Your ChartRemotely sign-in
+expired. Answer the DM on your phone to renew." — a fresh DM is already on its
+way, and once you answer it (within about half an hour) the next command
+works again.
 
 Each command handled is logged as one line — time, the command's first word,
-the "Where?" as said, and the reply if it was an ERR — to
+the "Where?" as said, and the reply if it was an ERR — plus one line when its
+tool call ends (the tool, "Where?" and any refusal) — to
 `~/Library/Logs/chartremotely-serve.log` (voice) or `chartremotely-relay.log`
 (from the operator). Never a token, a secret or a picture.
 

{chartremotely-0.2.8 → chartremotely-0.2.9}/README.md

@@ -97,16 +97,33 @@ ignores everything sent to it.
 2. **What scale?** — a time frame mnemonic (below), or "as is".
 3. **Where?** — which display. Leave it blank to stay on this Mac.
 
-The Shortcut talks to one Mac — the one that made it. Any name said at
-"Where?" goes to the operator, which finds the display among yours and
-relays the command there (or back here, if the name is this Mac's). Names
-may be loose: for a display paired as "Mac mini", "mac-mini", "mini mac",
-"mini", "macm" and even "mack meeny" all work. The reply you hear is that
-display's. A name that could mean several displays is answered with them,
-and an unknown name with the names you do have.
+The Shortcut talks to one Mac — the one that made it. That Mac looks up the
+company and the scale itself (free: a table, never the chart), then acts as
+an ordinary patron of the operator: it calls the priced `chart_show_chart`
+tool with your npub, your sign-in token and the display named at "Where?"
+(this Mac when blank). A voice change costs what `chart_show_chart` costs.
+Siri answers within about three seconds — "Chart PLTR at half scale sent to
+Mac-mini. Good luck." — and the chart changes a moment later through that
+display's relay, which also takes its picture. Names may be loose: for a
+display paired as "Mac mini", "mac-mini", "mini mac", "mini", "macm" and even
+"mack meeny" all work. A refusal that comes back quickly — a balance too low,
+a display that is unknown or not answering — is spoken instead, in the
+operator's words. "Read" calls `chart_read_chart` and speaks what the chart
+shows.
+
+**Signing in.** The first `chartremotely setup` proves your npub by a Nostr
+DM: reply from your Nostr client, and choose a long `cache_duration` in the
+reply (e.g. `30 days`, or `unlimited`) so voice keeps working — left alone it
+lasts 2 hours. The token the operator returns is kept in this Mac's login
+Keychain ("ChartRemotely voice sign-in"), never in the config or a log; your
+nsec is never asked for. When it expires you hear "Your ChartRemotely sign-in
+expired. Answer the DM on your phone to renew." — a fresh DM is already on its
+way, and once you answer it (within about half an hour) the next command
+works again.
 
 Each command handled is logged as one line — time, the command's first word,
-the "Where?" as said, and the reply if it was an ERR — to
+the "Where?" as said, and the reply if it was an ERR — plus one line when its
+tool call ends (the tool, "Where?" and any refusal) — to
 `~/Library/Logs/chartremotely-serve.log` (voice) or `chartremotely-relay.log`
 (from the operator). Never a token, a secret or a picture.
 

{chartremotely-0.2.8 → chartremotely-0.2.9}/chartremotely/assets/shortcut-template.plist

@@ -1066,17 +1066,6 @@
 				<false/>
 			</dict>
 		</dict>
-		<dict>
-			<key>WFWorkflowActionIdentifier</key>
-			<string>is.workflow.actions.speaktext</string>
-			<key>WFWorkflowActionParameters</key>
-			<dict>
-				<key>WFSpeakTextWait</key>
-				<false/>
-				<key>WFText</key>
-				<string>On it, requesting your chart now. Look at your screen or visit the website for the screen capture.</string>
-			</dict>
-		</dict>
 		<dict>
 			<key>WFWorkflowActionIdentifier</key>
 			<string>is.workflow.actions.downloadurl</string>

{chartremotely-0.2.8 → chartremotely-0.2.9}/chartremotely/config.py

@@ -34,6 +34,9 @@ DEFAULTS: dict = {
     "operator_url": None,
     "agent_id": None,
     "agent_secret": None,
+    # Whose display this is: the npub voice commands are billed to. Its
+    # sign-in (the dpop_token) lives in the login Keychain, never here.
+    "owner_npub": None,
     "token": None,
     "port": 8899,
 }

{chartremotely-0.2.8 → chartremotely-0.2.9}/chartremotely/keystore.py

@@ -1,4 +1,8 @@
-"""Keep a patron's Nostr key for the patron, never for this agent.
+"""Keep a patron's secrets in their login Keychain, never in this agent's files.
+
+Two kinds, never mixed: the Nostr key ``setup`` may make for the human, and
+the voice sign-in - the ``dpop_token`` the operator returns once the owner
+has proven their npub by DM - which the listener passes on each priced call.
 
 A key made by ``setup`` belongs to the human. It goes into their login
 Keychain as an internet password for the ChartRemotely site, and it is
@@ -8,8 +12,8 @@ tool cannot write a synchronizable Keychain item itself (that needs an
 entitled app: ``errSecMissingEntitlement``), which is why Safari does the
 syncing.
 
-Nothing here writes the key to the agent's config, a log, a URL or a
-command line. It travels as ``kSecValueData`` or on a pipe, and nowhere else.
+Nothing here writes a key or a token to the agent's config, a log, a URL or
+a command line. Each travels as ``kSecValueData`` or on a pipe, and nowhere else.
 """
 
 from __future__ import annotations
@@ -19,6 +23,8 @@ import threading
 
 SERVER = "chartremotely.tollbooth-dpyc.com"
 LABEL = "ChartRemotely — Nostr key"
+#: The voice sign-in is a generic password under this service, one per npub.
+TOKEN_SERVICE = "ChartRemotely voice sign-in"
 CLIPBOARD_SECONDS = 60
 
 ERR_DUPLICATE = -25299
@@ -43,15 +49,43 @@ def item_query(npub: str) -> dict:
             S.kSecAttrAccount: npub}
 
 
+def _upsert(query: dict, label: str, secret: bytes, what: str) -> None:
+    """Add one item, or replace the secret of the one already there."""
+    S = _security()
+    status = S.SecItemAdd({**query, S.kSecAttrLabel: label, S.kSecValueData: secret}, None)[0]
+    if status == ERR_DUPLICATE:
+        status = S.SecItemUpdate(query, {S.kSecValueData: secret})
+    if status != 0:
+        raise KeystoreError(f"the Keychain refused to save the {what} (status {status})")
+
+
 def save(npub: str, nsec: str) -> None:
     """Store (or replace) the patron's key in their login Keychain."""
+    _upsert(item_query(npub), LABEL, nsec.encode(), "key")
+
+
+def token_query(npub: str) -> dict:
+    """The attributes that name one npub's voice sign-in. The token is never among them."""
     S = _security()
-    secret = nsec.encode()
-    status = S.SecItemAdd({**item_query(npub), S.kSecAttrLabel: LABEL, S.kSecValueData: secret}, None)[0]
-    if status == ERR_DUPLICATE:
-        status = S.SecItemUpdate(item_query(npub), {S.kSecValueData: secret})
+    return {S.kSecClass: S.kSecClassGenericPassword,
+            S.kSecAttrService: TOKEN_SERVICE,
+            S.kSecAttrAccount: npub}
+
+
+def save_token(npub: str, token: str) -> None:
+    """Store (or replace) the voice sign-in for ``npub``."""
+    _upsert(token_query(npub), TOKEN_SERVICE, token.encode(), "sign-in")
+
+
+def load_token(npub: str) -> str | None:
+    """The voice sign-in for ``npub``; None when there is none yet."""
+    S = _security()
+    status, data = S.SecItemCopyMatching({**token_query(npub), S.kSecReturnData: True}, None)
+    if status == ERR_NOT_FOUND or (status == 0 and data is None):
+        return None
     if status != 0:
-        raise KeystoreError(f"the Keychain refused to save the key (status {status})")
+        raise KeystoreError(f"the Keychain would not give the sign-in (status {status})")
+    return bytes(data).decode()
 
 
 def saved_npubs() -> list[str]:

chartremotely-0.2.9/chartremotely/patron.py

@@ -0,0 +1,194 @@
+"""The listener as an ordinary patron: a voice command becomes a priced tool call.
+
+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
+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.
+
+Siri should not wait for the chart. The call starts in the background; a
+refusal that comes back within :data:`HANDOFF_SECONDS` (sign-in expired, not
+enough balance, no such display) is spoken, and otherwise the hand-off is
+spoken at once - "Chart PLTR at half scale sent to Mac-mini. Good luck." -
+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.
+
+Stdlib only (the Keychain behind a lazy import), like the relay.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections.abc import Callable
+
+from . import config, keystore, mcpclient, requestlog
+
+ERR = "ERR "
+#: How long a spoken reply waits for an early refusal before handing off.
+HANDOFF_SECONDS = 3.0
+#: "read" is answered with what the chart shows, so it may wait longer.
+READ_SECONDS = 25.0
+#: Bounds a cold operator plus the relay's own wait; the reply never waits on it.
+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.
+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."
+#: Seconds between looks for the owner's reply: quick at first, then patient;
+#: about half an hour in all, then the renewal gives up until the next command.
+RENEW_DELAYS = (15.0,) * 4 + (30.0,) * 6 + (60.0,) * 25
+#: The one receive answer that means "not yet" rather than "stop".
+NOT_YET = "courier_not_found"
+
+
+# -- what a spoken command asks of the operator ----------------------------------
+
+def tool_for(command: str) -> tuple[str, dict] | str:
+    """The priced tool and its arguments for one command, or an ERR sentence.
+
+    ``set TICKER | scale`` -> chart_show_chart; ``read`` -> chart_read_chart;
+    a bare name -> chart_show_chart with that name. ``snapshot`` has a
+    priced tool, but a picture cannot be spoken: it is refused here.
+    """
+    verb, _, rest = command.partition(" ")
+    verb = verb.lower()
+    if verb == "set":
+        ticker, _, scale = rest.partition("|")
+        scale = scale.strip()
+        return "chart_show_chart", {"security": ticker.strip(),
+                                    "scale": "" if scale.lower() in AS_IS else scale}
+    if verb == "read":
+        return "chart_read_chart", {}
+    if verb == "snapshot":
+        return ERR + "A picture cannot be spoken. See your screens at chartremotely.tollbooth-dpyc.com."
+    return "chart_show_chart", {"security": command, "scale": ""}
+
+
+def handoff(args: dict, where: str) -> str:
+    """What to say once a chart change is on its way: what, and where to."""
+    at = f" at {args['scale']} scale" if args.get("scale") else ""
+    return f"Chart {args['security']}{at} sent to {where or 'this Mac'}. Good luck."
+
+
+def refusal(payload: dict) -> str | None:
+    """The operator's reason for refusing, when it refused; else None."""
+    if payload.get("success") is False or payload.get("ok") is False or payload.get("error"):
+        return str(payload.get("error") or payload.get("result") or "the operator refused")
+    return None
+
+
+# -- the call -----------------------------------------------------------------------
+
+def _call(base: str, tool: str, args: dict) -> dict:
+    """One tool call. Never raises: an unreachable operator is an ``error`` payload."""
+    try:
+        return mcpclient.Client(base, timeout=CALL_TIMEOUT).call(tool, args)
+    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
+        return {"success": False, "error": f"the call failed: {type(exc).__name__}"}
+
+
+def send(command: str, where: str, cfg: dict | None = None) -> str:
+    """Ask the operator's priced tool for one command, for the display named ``where``.
+
+    Returns the sentence to speak. Never raises.
+    """
+    cfg = cfg or config.load()
+    base = (cfg.get("operator_url") or "").rstrip("/")
+    agent_id, npub = cfg.get("agent_id"), cfg.get("owner_npub")
+    if not (base and agent_id):
+        return ERR + "This Mac is not paired, so it cannot change a chart. Run chartremotely setup."
+    if not npub:
+        return ERR + "This Mac does not know whose display it is. Run chartremotely setup."
+    # The Shortcut splices this Mac's own replies ("PLTR\n") into the command.
+    wanted = " ".join((where or "").split())
+    command = " ".join((command or "").split())
+    mapped = tool_for(command)
+    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}
+    box: dict = {}
+    done = threading.Event()
+
+    def work() -> None:
+        payload = _call(base, tool, envelope)
+        box["payload"] = payload
+        settle(base, npub, tool, wanted, payload)
+        done.set()
+
+    threading.Thread(target=work, name=f"call-{tool}", daemon=True).start()
+    if not done.wait(READ_SECONDS if tool == "chart_read_chart" else HANDOFF_SECONDS):
+        return handoff(args, wanted) if tool == "chart_show_chart" else \
+            f"Reading {wanted or 'this Mac'}; the answer is taking a while."
+    payload = box["payload"]
+    if payload.get("error_code") in PROOF_CODES:
+        return EXPIRED
+    if (why := refusal(payload)) is not None:
+        return ERR + why.removeprefix(ERR)
+    if tool == "chart_read_chart":
+        return str(payload.get("result") or "")
+    return handoff(args, wanted)
+
+
+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."""
+    if payload.get("error_code") in PROOF_CODES:
+        renew(base, npub)
+    requestlog.outcome("serve", tool, where, refusal(payload))
+
+
+# -- renewing an expired sign-in ------------------------------------------------------
+
+_renewing = threading.Lock()
+
+
+def renew(base: str, npub: str, sleep: Callable[[float], None] = time.sleep) -> bool:
+    """Start one background renewal; False when one is already under way."""
+    if not _renewing.acquire(blocking=False):
+        return False
+    threading.Thread(target=_renew, args=(base, npub, sleep), name="renew-sign-in", daemon=True).start()
+    return True
+
+
+def _renew(base: str, npub: str, sleep: Callable[[float], None]) -> None:
+    try:
+        sent = _call(base, "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})
+            if got.get("success") is not False and not got.get("error"):
+                keystore.save_token(npub, str(got.get("dpop_token") or phrase))
+                requestlog.outcome("serve", "renew", "", None)
+                return
+            if got.get("error_code") not in (NOT_YET, None):
+                requestlog.outcome("serve", "renew", "", refusal(got))
+                return
+        requestlog.outcome("serve", "renew", "", "the DM was not answered in time")
+    except Exception as exc:  # noqa: BLE001 - renewal must never take the listener down
+        requestlog.outcome("serve", "renew", "", f"renewal failed: {type(exc).__name__}")
+    finally:
+        _renewing.release()

{chartremotely-0.2.8 → chartremotely-0.2.9}/chartremotely/requestlog.py

@@ -39,3 +39,15 @@ def request(source: str, command: str, where: str, reply: str) -> None:
         print(line(source, command, where, reply), file=sys.stderr, flush=True)
     except (OSError, ValueError):
         pass
+
+
+def outcome(source: str, tool: str, where: str, error: str | None) -> None:
+    """One line for how a background tool call ended: the tool, the "Where?",
+    and the refusal when there was one. Never its arguments or the sign-in."""
+    parts = [time.strftime("%Y-%m-%dT%H:%M:%S%z"), source, f"tool={_clean(tool or '-', 48)}",
+             f"where={_clean(where or '', WHERE_MAX)!r}",
+             f"error={_clean(error, ERR_MAX)!r}" if error else "ok"]
+    try:
+        print(" ".join(parts), file=sys.stderr, flush=True)
+    except (OSError, ValueError):
+        pass

{chartremotely-0.2.8 → chartremotely-0.2.9}/chartremotely/server.py

@@ -17,9 +17,12 @@ import secrets
 import urllib.parse
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
-from . import config, forward, push, requestlog
+from . import config, patron, requestlog
 from .vocab import answer
 
+#: Verbs answered here, for free: they look something up and leave the chart alone.
+LOOKUPS = frozenset({"resolve", "scale"})
+
 
 class Handler(BaseHTTPRequestHandler):
     token = ""
@@ -64,20 +67,23 @@ class Handler(BaseHTTPRequestHandler):
                      (query.get("where") or [""])[0].strip())
 
     def _answer(self, request: str, where: str = "") -> None:
-        """Reply first; only then schedule the picture of a changed chart.
-
-        ``where`` names the display the command is for, as dictated. Another
-        display's command is forwarded and its reply spoken; that display
-        pushes its own picture, so none is scheduled here.
+        """Answer a lookup here; ask the operator's priced tool for the rest.
+
+        ``resolve`` and ``scale`` are the Shortcut's free checks before it
+        asks for a change: they read a table, never the chart. Everything
+        else is a patron's tool call (see :mod:`patron`) - ``where`` names the
+        display as dictated, blank meaning this Mac. The reply is the
+        hand-off, spoken at once; the chart changes after, through a relay,
+        which also takes its picture.
         """
-        elsewhere = forward.route(request, where) if where and request else None
-        if elsewhere is not None:
-            self._reply(200, elsewhere)
-            return requestlog.request("serve", request, where, elsewhere)
-        result = answer(request)
-        self._reply(200, result.reply)
-        requestlog.request("serve", request, where, result.reply)
-        push.after_reply(request, result.reply, result.symbol, result.scale)
+        if request.partition(" ")[0].lower() in LOOKUPS:
+            reply = answer(request).reply
+        elif request:
+            reply = patron.send(request, where)
+        else:
+            reply = "ERR I didn't catch that."
+        self._reply(200, reply)
+        requestlog.request("serve", request, where, reply)
 
     def log_message(self, *args) -> None:
         """Silence the stock access log: its request line can carry ``?t=<token>``.

{chartremotely-0.2.8 → chartremotely-0.2.9}/chartremotely/setup.py

@@ -9,6 +9,9 @@ again is always safe:
    passwords - and used once, in memory, to sign the pairing. It is never
    written to this agent's config.
 2. **Pairing**, without a code to copy: setup adopts this machine's code itself.
+   **Voice sign-in**: the ``dpop_token`` from the owner's DM proof, kept in
+   the login Keychain (their npub goes in the config), so the listener can
+   call the operator's priced tools as that patron.
 3. **Tailscale**: the Mac's tailnet address, with ``/chart`` forwarded to the agent.
 4. **Services**: the listener and the relay, under launchd.
 5. **Permissions**: Accessibility and Screen Recording, asked for by the
@@ -53,6 +56,8 @@ def prove_by_dm(client: mcpclient.Client, npub: str, ask: Ask, say: Say) -> str:
     say(f"A Nostr DM is on its way to {npub[:12]}…")
     say(f"Its confirmation code is: {phrase}")
     say("Reply to the DM from your Nostr client only if the codes match.")
+    say("In your reply you may set cache_duration - e.g. 30 days, or unlimited - so voice")
+    say("keeps working that long; left alone, the sign-in lasts 2 hours.")
     ask("Press Return once you have replied… ")
     got = client.call("chart_receive_npub_proof", {"patron_npub": npub, "dpop_token": phrase})
     if got.get("error"):
@@ -92,8 +97,12 @@ 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]:
-    """Who owns this display, proven. Returns (npub, proof for chart_pair_agent)."""
+def identity(client: mcpclient.Client, ask: Ask, say: Say) -> tuple[str, str, 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).
+    """
     say("Your Nostr identity owns this display.")
     say("  1  I have an npub (I'll answer a Nostr DM to prove it)")
     say("  2  Use a key saved on this Mac")
@@ -103,7 +112,7 @@ def identity(client: mcpclient.Client, ask: Ask, say: Say) -> tuple[str, str]:
         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)
+        return npub, prove_by_dm(client, npub, ask, say), True
     if choice == "2":
         from . import keystore
 
@@ -115,7 +124,7 @@ def identity(client: mcpclient.Client, ask: Ask, say: Say) -> tuple[str, str]:
         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")
+            return picked, sign_once(nsec, "chart_pair_agent"), False
         finally:
             del nsec
     if choice == "3":
@@ -123,12 +132,42 @@ def identity(client: mcpclient.Client, ask: Ask, say: Say) -> tuple[str, str]:
         try:
             say(f"Your new npub is {npub}")
             keep_for_human(npub, nsec, ask, say)
-            return npub, sign_once(nsec, "chart_pair_agent")
+            return npub, sign_once(nsec, "chart_pair_agent"), False
         finally:
             del nsec
     raise SetupError("choose 1, 2 or 3")
 
 
+# -- 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)
+    config.update(owner_npub=npub)
+
+
+def has_sign_in(npub: str) -> bool:
+    from . import keystore
+
+    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:
+    """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))
+    say("Voice is signed in.")
+
+
 # -- pairing ------------------------------------------------------------------
 
 def pair(client: mcpclient.Client, base: str, npub: str, proof: str, label: str) -> dict:
@@ -148,16 +187,28 @@ def run(ask: Ask = input, say: Say = print, operator_url: str = OPERATOR_URL) ->
     token = config.ensure_token()
 
     # 1-2. Identity and pairing, unless this Mac is already paired.
+    client = mcpclient.Client(base)
     if cfg.get("agent_id") and cfg.get("agent_secret"):
         say(f"This Mac is already paired ({cfg['agent_id']}).")
-        npub = ""
+        npub = cfg.get("owner_npub") or ask("Your npub (whose display this is): ").strip()
+        if not npub.startswith("npub1"):
+            raise SetupError("that is not an npub")
+        if has_sign_in(npub):
+            config.update(owner_npub=npub)
+            say("Voice is already signed in.")
+        else:
+            voice_sign_in(client, npub, ask, say)
     else:
-        client = mcpclient.Client(base)
-        npub, proof = identity(client, ask, say)
+        npub, proof, by_dm = identity(client, ask, say)
         label = ask("Name this display (e.g. Desk, Office wall): ").strip() or "display"
         pair(client, base, npub, proof, label)
-        del proof
         say(f"Paired as “{label}”.")
+        if by_dm:
+            keep_sign_in(npub, proof)
+            say("Voice is signed in with the same DM.")
+        else:
+            voice_sign_in(client, npub, ask, say)
+        del proof
 
     # 3. Tailscale.
     from . import tailnet

{chartremotely-0.2.8 → chartremotely-0.2.9}/chartremotely.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.8
+Version: 0.2.9
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -321,16 +321,33 @@ ignores everything sent to it.
 2. **What scale?** — a time frame mnemonic (below), or "as is".
 3. **Where?** — which display. Leave it blank to stay on this Mac.
 
-The Shortcut talks to one Mac — the one that made it. Any name said at
-"Where?" goes to the operator, which finds the display among yours and
-relays the command there (or back here, if the name is this Mac's). Names
-may be loose: for a display paired as "Mac mini", "mac-mini", "mini mac",
-"mini", "macm" and even "mack meeny" all work. The reply you hear is that
-display's. A name that could mean several displays is answered with them,
-and an unknown name with the names you do have.
+The Shortcut talks to one Mac — the one that made it. That Mac looks up the
+company and the scale itself (free: a table, never the chart), then acts as
+an ordinary patron of the operator: it calls the priced `chart_show_chart`
+tool with your npub, your sign-in token and the display named at "Where?"
+(this Mac when blank). A voice change costs what `chart_show_chart` costs.
+Siri answers within about three seconds — "Chart PLTR at half scale sent to
+Mac-mini. Good luck." — and the chart changes a moment later through that
+display's relay, which also takes its picture. Names may be loose: for a
+display paired as "Mac mini", "mac-mini", "mini mac", "mini", "macm" and even
+"mack meeny" all work. A refusal that comes back quickly — a balance too low,
+a display that is unknown or not answering — is spoken instead, in the
+operator's words. "Read" calls `chart_read_chart` and speaks what the chart
+shows.
+
+**Signing in.** The first `chartremotely setup` proves your npub by a Nostr
+DM: reply from your Nostr client, and choose a long `cache_duration` in the
+reply (e.g. `30 days`, or `unlimited`) so voice keeps working — left alone it
+lasts 2 hours. The token the operator returns is kept in this Mac's login
+Keychain ("ChartRemotely voice sign-in"), never in the config or a log; your
+nsec is never asked for. When it expires you hear "Your ChartRemotely sign-in
+expired. Answer the DM on your phone to renew." — a fresh DM is already on its
+way, and once you answer it (within about half an hour) the next command
+works again.
 
 Each command handled is logged as one line — time, the command's first word,
-the "Where?" as said, and the reply if it was an ERR — to
+the "Where?" as said, and the reply if it was an ERR — plus one line when its
+tool call ends (the tool, "Where?" and any refusal) — to
 `~/Library/Logs/chartremotely-serve.log` (voice) or `chartremotely-relay.log`
 (from the operator). Never a token, a secret or a picture.