chartremotely 0.2.8__tar.gz → 0.2.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.8
+Version: 0.2.10
 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.10}/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.10}/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.10}/chartremotely/ax.py

@@ -22,7 +22,7 @@ from __future__ import annotations
 import time
 
 import Quartz
-from AppKit import NSWorkspace
+from AppKit import NSRunningApplication, NSWorkspace
 from ApplicationServices import (
     AXUIElementCopyActionNames,
     AXUIElementCopyAttributeValue,
@@ -57,11 +57,25 @@ class NotRunning(RuntimeError):
     """thinkorswim is not running."""
 
 
+def app_for(pid: int):
+    """The running application with ``pid``, looked up now; None if gone.
+
+    Never from ``NSWorkspace.runningApplications()``: that list only
+    refreshes on a run loop, which the listener and relay never spin, so an
+    app launched (or quit) after they started is missing from it (or lingers).
+    """
+    return NSRunningApplication.runningApplicationWithProcessIdentifier_(pid)
+
+
 def running_app():
-    for a in NSWorkspace.sharedWorkspace().runningApplications():
-        if APP_NAME.lower() in (a.localizedName() or "").lower():
-            return a
-    raise NotRunning(f"{APP_NAME} is not running")
+    """thinkorswim, found through the window server's live list of windows."""
+    for w in Quartz.CGWindowListCopyWindowInfo(
+            Quartz.kCGWindowListOptionAll, Quartz.kCGNullWindowID) or []:
+        if APP_NAME.lower() in (w.get("kCGWindowOwnerName") or "").lower():
+            app = app_for(w["kCGWindowOwnerPID"])
+            if app is not None:
+                return app
+    raise NotRunning(f"{APP_NAME} is not open on this Mac")
 
 
 def handle(app=None):

{chartremotely-0.2.8 → chartremotely-0.2.10}/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.10}/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.10/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.10}/chartremotely/requestlog.py

@@ -39,3 +39,24 @@ 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
+
+
+def note(source: str, text: str) -> None:
+    """One free-form line, e.g. what it took to bring the chart in front. Never raises."""
+    try:
+        print(f"{time.strftime('%Y-%m-%dT%H:%M:%S%z')} {source} {_clean(text, ERR_MAX)}",
+              file=sys.stderr, flush=True)
+    except (OSError, ValueError):
+        pass

chartremotely-0.2.10/chartremotely/screen.py

@@ -0,0 +1,116 @@
+"""Decisions about what is on screen, made from a snapshot of the window list.
+
+Getting the chart in front of someone takes macOS calls - unhide, activate,
+un-minimise, raise, hide what covers it - but deciding WHICH window is the
+chart, WHETHER it is on screen yet and WHAT covers it needs none of them. That
+half lives here, over plain dicts shaped like Quartz's window list, so it runs
+(and is tested) where PyObjC is absent. :mod:`window` feeds it.
+
+A window is a dict with ``kCGWindowOwnerPID``, ``kCGWindowLayer`` and
+``kCGWindowBounds`` (``X``, ``Y``, ``Width``, ``Height``), as
+``CGWindowListCopyWindowInfo`` reports it: front to back, on-screen only.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+
+Frame = tuple[float, float, float, float]
+
+#: Points of slack when matching the accessibility frame to the window list.
+TOLERANCE = 2.0
+
+
+def overlaps(a: dict, b: dict) -> bool:
+    """Whether two bounds dicts share any area."""
+    return not (a.get("X", 0) + a.get("Width", 0) <= b.get("X", 0)
+                or a.get("X", 0) >= b.get("X", 0) + b.get("Width", 0)
+                or a.get("Y", 0) + a.get("Height", 0) <= b.get("Y", 0)
+                or a.get("Y", 0) >= b.get("Y", 0) + b.get("Height", 0))
+
+
+def largest(windows: Iterable[dict], pid: int) -> dict | None:
+    """The largest window ``pid`` has on screen."""
+    best, best_area = None, -1.0
+    for w in windows:
+        if w.get("kCGWindowOwnerPID") != pid:
+            continue
+        b = w.get("kCGWindowBounds") or {}
+        area = b.get("Width", 0) * b.get("Height", 0)
+        if area > best_area:
+            best, best_area = w, area
+    return best
+
+
+def showing(windows: Iterable[dict], pid: int, frame: Frame) -> dict | None:
+    """The on-screen window of ``pid`` whose bounds are ``frame``, or None.
+
+    ``frame`` is the chart window's (x, y, w, h) as the accessibility tree
+    reports it. Matching on it, rather than taking the app's largest window,
+    means a detached thinkorswim window left on screen does not count as the
+    chart being back.
+    """
+    for w in windows:
+        if w.get("kCGWindowOwnerPID") != pid:
+            continue
+        b = w.get("kCGWindowBounds") or {}
+        got = (b.get("X", 0), b.get("Y", 0), b.get("Width", 0), b.get("Height", 0))
+        if all(abs(g - f) <= TOLERANCE for g, f in zip(got, frame, strict=True)):
+            return w
+    return None
+
+
+def covering(windows: Iterable[dict], bounds: dict, pid: int,
+             regular: Iterable[int]) -> list[int]:
+    """Pids of ordinary apps with a window overlapping ``bounds``.
+
+    Only ``regular`` apps count: system overlays keep permanent full-screen
+    windows that are neither hideable nor actually in the way. Negative
+    layers are desktop furniture, never in front of the chart.
+    """
+    allowed = set(regular) - {pid}
+    found = [w["kCGWindowOwnerPID"] for w in windows
+             if w.get("kCGWindowOwnerPID") in allowed
+             and w.get("kCGWindowLayer", 0) >= 0
+             and overlaps(w.get("kCGWindowBounds") or {}, bounds)]
+    return list(dict.fromkeys(found))
+
+
+def wait_for(probe: Callable[[], object], timeout: float = 2.0, interval: float = 0.1,
+             clock: Callable[[], float] = time.monotonic,
+             sleep: Callable[[float], None] = time.sleep):
+    """Poll ``probe`` until it returns something truthy, for at most ``timeout`` seconds.
+
+    Returns that value, or None when time ran out. Always probes at least once.
+    """
+    deadline = clock() + timeout
+    while True:
+        found = probe()
+        if found:
+            return found
+        if clock() >= deadline:
+            return None
+        sleep(interval)
+
+
+@dataclass(frozen=True)
+class Presented:
+    """What it took to get the chart in front of the viewer."""
+
+    unhid: bool = False
+    unminimized: bool = False
+    raised: bool = False
+    hid: tuple[str, ...] = ()
+
+    def __bool__(self) -> bool:
+        return self.unhid or self.unminimized or self.raised or bool(self.hid)
+
+    def __str__(self) -> str:
+        done = [word for word, did in (("unhid", self.unhid),
+                                       ("unminimized", self.unminimized),
+                                       ("raised", self.raised)) if did]
+        if self.hid:
+            done.append("hid " + ", ".join(self.hid))
+        return "; ".join(done) or "already in front"

{chartremotely-0.2.8 → chartremotely-0.2.10}/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>``.