chartremotely 0.2.7__tar.gz → 0.2.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.7
+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.7 → 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.7 → chartremotely-0.2.9}/chartremotely/answer.py

@@ -10,12 +10,14 @@ from typing import NamedTuple
 
 
 class Answer(NamedTuple):
-    """A command's reply, plus the symbol it put on the chart when it did.
+    """A command's reply, plus the symbol and scale it put on the chart when it did.
 
     ``symbol`` is set only by a successful chart change that named one; the
     picture of that change is labelled with it, so a label never depends on
-    how the reply happens to be worded.
+    how the reply happens to be worded. ``scale`` is the time frame the reply
+    states ("half", "30 minutes"), or None when the change could not tell.
     """
 
     reply: str
     symbol: str | None = None
+    scale: str | None = None

{chartremotely-0.2.7 → 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.7 → 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.7 → 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.7 → chartremotely-0.2.9}/chartremotely/push.py

@@ -3,9 +3,9 @@
 A chart changed by voice goes straight to this machine over the tailnet, so
 the operator never hears of it. Once a change is answered — after the reply
 ("… Good luck.") has been sent — one picture of the chart pane is pushed up so
-the patron's browser can offer it, labelled with the symbol the last command
-of the burst put on the chart (the symbol field is read only as a fallback:
-it can be stale). The operator keeps the newest picture per symbol,
+the patron's browser can offer it, labelled with the symbol and scale the
+last command of the burst put on the chart (the symbol field is read only as
+a fallback: it can be stale; the scale is never read back). The operator keeps the newest picture per symbol,
 encrypted, for an hour each.
 
 Three rules keep it out of the way:
@@ -44,10 +44,16 @@ _NOT_A_CHANGE = frozenset({"resolve", "scale", "read", "snapshot"})
 #: the same shape; anything else is left off rather than sent.
 SYMBOL = re.compile(r"^[A-Z0-9./^$-]{1,15}$")
 
+#: What a scale label may look like on the wire: the words a reply states
+#: ("half", "30 minutes", "1 day"). The operator checks the same shape.
+SCALE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9 .:/-]{0,23}$")
+
 _state = threading.Condition()
 #: The symbol the last successful chart-changing command put on the chart.
 #: A burst's picture carries the LAST one; a change that names none keeps it.
 _named: str | None = None
+#: The scale the last chart-changing command stated; kept the same way.
+_scaled: str | None = None
 _due: float | None = None
 _worker: threading.Thread | None = None
 
@@ -66,12 +72,22 @@ def symbol_label(raw: object) -> str | None:
     return label if SYMBOL.match(label) else None
 
 
-def payload(cfg: dict, image: str, symbol: str | None = None) -> tuple[str, dict] | None:
+def scale_label(raw: object) -> str | None:
+    """The chart's scale as sent to the operator, or None when it is not scale-shaped."""
+    if not isinstance(raw, str):
+        return None
+    label = " ".join(raw.split())
+    return label if SCALE.match(label) else None
+
+
+def payload(cfg: dict, image: str, symbol: str | None = None,
+            scale: str | None = None) -> tuple[str, dict] | None:
     """Where to send a picture and what to send, or None when not paired.
 
     ``symbol`` is what the chart showed when the picture was taken; it is left
     out when unknown or not symbol-shaped, and the operator files the picture
-    under a plain "Chart".
+    under a plain "Chart". ``scale`` is the time frame the last change stated;
+    it is left out the same way.
     """
     base = (cfg.get("operator_url") or "").rstrip("/")
     agent_id, secret = cfg.get("agent_id"), cfg.get("agent_secret")
@@ -81,6 +97,9 @@ def payload(cfg: dict, image: str, symbol: str | None = None) -> tuple[str, dict
     label = symbol_label(symbol)
     if label:
         body["symbol"] = label
+    scaled = scale_label(scale)
+    if scaled:
+        body["scale"] = scaled
     return f"{base}/agent/snapshot", body
 
 
@@ -98,16 +117,19 @@ def _showing() -> str | None:
         return None
 
 
-def after_reply(request: str, reply: str, symbol: str | None = None) -> None:
+def after_reply(request: str, reply: str, symbol: str | None = None,
+                scale: str | None = None) -> None:
     """Call once a reply has been sent. Schedules a picture if the chart changed.
 
-    ``symbol`` is what the command put on the chart (vocab.Answer.symbol), when
-    it named one; a change that names none keeps the previous command's.
+    ``symbol`` and ``scale`` are what the command put on the chart
+    (vocab.Answer), when it named them; a change that names neither keeps the
+    previous command's.
     """
-    global _named
+    global _named, _scaled
     if changes_chart(request, reply):
         with _state:
             _named = symbol_label(symbol) or _named
+            _scaled = scale_label(scale) or _scaled
         schedule()
 
 
@@ -144,9 +166,9 @@ def push_now() -> None:
         with guilock.driving():
             image = snapshot.as_reply(snapshot.shrink(window.capture()))
             with _state:
-                label = _named
+                label, scaled = _named, _scaled
             label = label or _showing()
-        url, body = payload(cfg, image, label)
+        url, body = payload(cfg, image, label, scaled)
         relay._post(url, body, timeout=30)
     except Exception:  # noqa: BLE001, S110 - deliberate: see the module docstring
         pass

{chartremotely-0.2.7 → chartremotely-0.2.9}/chartremotely/relay.py

@@ -147,6 +147,6 @@ def run(operator_url: str | None = None, once: bool = False) -> None:
             requestlog.request("relay", command, "", reply)
             # After the reply, never before: the picture of a changed chart.
             from . import push
-            push.after_reply(command, reply, result.symbol)
+            push.after_reply(command, reply, result.symbol, result.scale)
         if once:
             return

{chartremotely-0.2.7 → 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.7 → 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)
+        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>``.