chartremotely 0.2.3__tar.gz → 0.2.5__tar.gz

{chartremotely-0.2.3 → chartremotely-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.3
+Version: 0.2.5
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -313,6 +313,27 @@ certificate to keep alive. Pairing alone does not start it: a display that is
 paired but has no `relay` running reports `connected: false` and silently
 ignores everything sent to it.
 
+## Voice
+
+"Hey Siri, ChartRemotely" asks three questions:
+
+1. **Which company?** — a spoken name or a spelled ticker.
+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.
+
+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
+`~/Library/Logs/chartremotely-serve.log` (voice) or `chartremotely-relay.log`
+(from the operator). Never a token, a secret or a picture.
+
 ## Running it as a service
 
 `chartremotely setup` installs both transports as launchd agents

{chartremotely-0.2.3 → chartremotely-0.2.5}/README.md

@@ -89,6 +89,27 @@ certificate to keep alive. Pairing alone does not start it: a display that is
 paired but has no `relay` running reports `connected: false` and silently
 ignores everything sent to it.
 
+## Voice
+
+"Hey Siri, ChartRemotely" asks three questions:
+
+1. **Which company?** — a spoken name or a spelled ticker.
+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.
+
+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
+`~/Library/Logs/chartremotely-serve.log` (voice) or `chartremotely-relay.log`
+(from the operator). Never a token, a secret or a picture.
+
 ## Running it as a service
 
 `chartremotely setup` installs both transports as launchd agents

{chartremotely-0.2.3 → chartremotely-0.2.5}/chartremotely/assets/shortcut-template.plist

@@ -1039,6 +1039,21 @@
 				<integer>2</integer>
 			</dict>
 		</dict>
+		<dict>
+			<key>WFWorkflowActionIdentifier</key>
+			<string>is.workflow.actions.ask</string>
+			<key>WFWorkflowActionParameters</key>
+			<dict>
+				<key>CustomOutputName</key>
+				<string>Where</string>
+				<key>UUID</key>
+				<string>6F0B7C51-2D4E-4A8B-9C3F-0E5D8A1B7C42</string>
+				<key>WFAskActionPrompt</key>
+				<string>Where?</string>
+				<key>WFInputType</key>
+				<string>Text</string>
+			</dict>
+		</dict>
 		<dict>
 			<key>WFWorkflowActionIdentifier</key>
 			<string>is.workflow.actions.downloadurl</string>
@@ -1160,6 +1175,42 @@
 									<string>WFTextTokenString</string>
 								</dict>
 							</dict>
+							<dict>
+								<key>WFItemType</key>
+								<integer>0</integer>
+								<key>WFKey</key>
+								<dict>
+									<key>Value</key>
+									<dict>
+										<key>string</key>
+										<string>where</string>
+									</dict>
+									<key>WFSerializationType</key>
+									<string>WFTextTokenString</string>
+								</dict>
+								<key>WFValue</key>
+								<dict>
+									<key>Value</key>
+									<dict>
+										<key>attachmentsByRange</key>
+										<dict>
+											<key>{0, 1}</key>
+											<dict>
+												<key>OutputName</key>
+												<string>Where</string>
+												<key>OutputUUID</key>
+												<string>6F0B7C51-2D4E-4A8B-9C3F-0E5D8A1B7C42</string>
+												<key>Type</key>
+												<string>ActionOutput</string>
+											</dict>
+										</dict>
+										<key>string</key>
+										<string></string>
+									</dict>
+									<key>WFSerializationType</key>
+									<string>WFTextTokenString</string>
+								</dict>
+							</dict>
 						</array>
 					</dict>
 					<key>WFSerializationType</key>

chartremotely-0.2.5/chartremotely/forward.py

@@ -0,0 +1,75 @@
+"""Send a spoken command on to another of the owner's displays.
+
+The Shortcut asks "Where?" and passes the dictated answer through verbatim.
+Empty, or this Mac's exact agent_id, means this Mac. Any other name goes to
+the operator's ``/agent/forward``, which is the one place names are matched:
+it finds the display among the SAME owner's displays (loosely - "mini mac"
+finds "Mac mini") and relays the command there, or answers that the name is
+this Mac's own. The target's reply is what gets spoken.
+
+Stdlib only, like the relay, so it imports where the macOS drivers do not.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+
+from . import config
+
+ERR = "ERR "
+#: Longer than the operator's own wait on the target, so its 504 arrives first.
+TIMEOUT = 35.0
+
+def is_here(where: str, cfg: dict) -> bool:
+    """Whether ``where`` means this Mac without asking: empty, or exactly its agent_id."""
+    wanted = (where or "").strip()
+    return not wanted or wanted == cfg.get("agent_id")
+
+
+def _post(url: str, payload: dict) -> tuple[int, dict]:
+    """POST JSON; the status and the JSON body, for error statuses too."""
+    request = urllib.request.Request(
+        url, data=json.dumps(payload).encode(), method="POST",
+        headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(request, timeout=TIMEOUT) as response:
+            status, raw = response.status, response.read()
+    except urllib.error.HTTPError as exc:
+        status, raw = exc.code, exc.read()
+    try:
+        body = json.loads(raw.decode("utf-8", "replace") or "{}")
+    except ValueError:
+        body = {}
+    return status, body if isinstance(body, dict) else {}
+
+
+def route(command: str, where: str, cfg: dict | None = None) -> str | None:
+    """The reply of the display named ``where``, or None when that display is this Mac.
+
+    Never raises: every failure is a short ``ERR`` sentence to be spoken.
+    """
+    cfg = cfg or config.load()
+    if is_here(where, cfg):
+        return None
+    base = (cfg.get("operator_url") or "").rstrip("/")
+    agent_id, secret = cfg.get("agent_id"), cfg.get("agent_secret")
+    if not (base and agent_id and secret):
+        return ERR + "This Mac is not paired, so it can only drive its own chart."
+    wanted = where.strip()
+    try:
+        status, body = _post(f"{base}/agent/forward",
+                             {"agent_id": agent_id, "secret": secret,
+                              "display": wanted, "cmd": command})
+    except (urllib.error.URLError, TimeoutError, OSError):
+        return ERR + "I could not reach the operator."
+    if status == 200 and body.get("self"):
+        return None
+    if status == 200:
+        return str(body.get("reply") or "")
+    if status == 404:
+        names = [str(n) for n in body.get("displays") or []]
+        yours = f" Yours: {', '.join(names)}." if names else ""
+        return ERR + f'No display named "{wanted}".{yours}'
+    return ERR + str(body.get("error") or f"the operator answered {status}")

{chartremotely-0.2.3 → chartremotely-0.2.5}/chartremotely/relay.py

@@ -18,7 +18,7 @@ import time
 import urllib.error
 import urllib.request
 
-from . import config
+from . import config, requestlog
 from .answer import Answer
 
 #: Poll window. The operator holds a request open for slightly less than
@@ -144,6 +144,7 @@ def run(operator_url: str | None = None, once: bool = False) -> None:
                       timeout=20)
             except (urllib.error.URLError, TimeoutError, OSError):
                 pass          # the caller has already timed out and refunded
+            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)

chartremotely-0.2.5/chartremotely/requestlog.py

@@ -0,0 +1,41 @@
+"""One line to stderr per command handled, so a spoken ERR can be diagnosed.
+
+launchd sends stderr to ``~/Library/Logs/chartremotely-<service>.log``. The
+line carries only what is needed to tell requests apart: the time, the verb
+(the command's first word, never its arguments), the "Where?" as dictated,
+and the reply when it is an ERR. Never a token, a secret or a picture.
+
+Stdlib only, like the relay, so it imports where the macOS drivers do not.
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+
+WHERE_MAX = 64
+ERR_MAX = 200
+
+
+def _clean(text: str, limit: int) -> str:
+    """``text`` on one line, printable only, at most ``limit`` characters."""
+    flat = "".join(c if c.isprintable() else " " for c in text)
+    return flat[:limit]
+
+
+def line(source: str, command: str, where: str, reply: str) -> str:
+    """The log line for one request (see the module doc)."""
+    verb = _clean((command or "").split(maxsplit=1)[0] if (command or "").strip() else "-", 32)
+    parts = [time.strftime("%Y-%m-%dT%H:%M:%S%z"), source, f"verb={verb}",
+             f"where={_clean(where or '', WHERE_MAX)!r}"]
+    if (reply or "").startswith("ERR"):
+        parts.append(f"reply={_clean(reply, ERR_MAX)!r}")
+    return " ".join(parts)
+
+
+def request(source: str, command: str, where: str, reply: str) -> None:
+    """Write :func:`line` to stderr. Never raises: logging must not cost a reply."""
+    try:
+        print(line(source, command, where, reply), file=sys.stderr, flush=True)
+    except (OSError, ValueError):
+        pass

{chartremotely-0.2.3 → chartremotely-0.2.5}/chartremotely/server.py

@@ -17,7 +17,7 @@ import secrets
 import urllib.parse
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
-from . import config, push
+from . import config, forward, push, requestlog
 from .vocab import answer
 
 
@@ -42,13 +42,16 @@ class Handler(BaseHTTPRequestHandler):
             return self._reply(403, "ERR forbidden")
         length = int(self.headers.get("Content-Length") or 0)
         raw = self.rfile.read(length).decode("utf-8", "replace").strip()
+        where = ""
         # Shortcuts posts JSON most cleanly; curl and scripts post raw text.
         if raw.startswith("{"):
             try:
-                raw = str(json.loads(raw).get("cmd") or "").strip()
-            except ValueError:
+                body = json.loads(raw)
+                raw = str(body.get("cmd") or "").strip()
+                where = str(body.get("where") or "").strip()
+            except (ValueError, AttributeError):
                 return self._reply(400, "ERR bad JSON")
-        self._answer(raw)
+        self._answer(raw, where)
 
     def do_GET(self) -> None:
         parsed = urllib.parse.urlparse(self.path)
@@ -57,16 +60,30 @@ class Handler(BaseHTTPRequestHandler):
         query = urllib.parse.parse_qs(parsed.query)
         if not self._authorised((query.get("t") or [None])[0]):
             return self._reply(403, "ERR forbidden")
-        self._answer((query.get("cmd") or [""])[0].strip())
+        self._answer((query.get("cmd") or [""])[0].strip(),
+                     (query.get("where") or [""])[0].strip())
 
-    def _answer(self, request: str) -> None:
-        """Reply first; only then schedule the picture of a changed chart."""
+    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.
+        """
+        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)
 
     def log_message(self, *args) -> None:
-        """Silence. Requests carry spoken input; do not write it to a log."""
+        """Silence the stock access log: its request line can carry ``?t=<token>``.
+
+        Each handled command is logged by :mod:`requestlog` instead, verb only.
+        """
 
 
 def serve(port: int | None = None) -> None:

{chartremotely-0.2.3 → chartremotely-0.2.5}/chartremotely/services.py

@@ -56,6 +56,10 @@ def render(label: str, args: list[str], *, keep_alive: bool, log: Path) -> str:
 """
 
 
+class ServiceError(RuntimeError):
+    """launchd would not start a service; the reason is launchctl's own."""
+
+
 def _domain() -> str:
     return f"gui/{os.getuid()}"
 
@@ -65,17 +69,32 @@ def loaded(label: str) -> bool:
                           capture_output=True, check=False).returncode == 0
 
 
-def install(command: str) -> Path:
-    """Write and (re)start one service. Idempotent."""
+def install(command: str, settle: float = 10.0) -> Path:
+    """Write and (re)start one service. Idempotent.
+
+    ``bootout`` returns before launchd has let go of the label, and a
+    ``bootstrap`` in that window fails with "5: Input/output error" - which
+    left a re-run of setup with the listener stopped. So wait for the label to
+    be gone, and give ``bootstrap`` a few more tries while launchd settles.
+    """
     label = LABELS[command]
     path = AGENTS_DIR / f"{label}.plist"
     AGENTS_DIR.mkdir(parents=True, exist_ok=True)
     path.write_text(render(label, [executable(), command], keep_alive=True,
                            log=LOG_DIR / f"chartremotely-{command}.log"))
+    deadline = time.monotonic() + settle
     if loaded(label):
         subprocess.run(["launchctl", "bootout", f"{_domain()}/{label}"], capture_output=True, check=False)
-    subprocess.run(["launchctl", "bootstrap", _domain(), str(path)], check=True)
-    return path
+        while loaded(label) and time.monotonic() < deadline:
+            time.sleep(0.25)
+    while True:
+        ran = subprocess.run(["launchctl", "bootstrap", _domain(), str(path)],
+                             capture_output=True, text=True, check=False)
+        if ran.returncode == 0:
+            return path
+        if time.monotonic() >= deadline:
+            raise ServiceError(f"launchd would not start {label}: {(ran.stderr or ran.stdout).strip()[:200]}")
+        time.sleep(0.5)
 
 
 def probe_permissions(request: bool, out: Path, timeout: float = 30.0) -> dict:

{chartremotely-0.2.3 → chartremotely-0.2.5}/chartremotely.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.3
+Version: 0.2.5
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -313,6 +313,27 @@ certificate to keep alive. Pairing alone does not start it: a display that is
 paired but has no `relay` running reports `connected: false` and silently
 ignores everything sent to it.
 
+## Voice
+
+"Hey Siri, ChartRemotely" asks three questions:
+
+1. **Which company?** — a spoken name or a spelled ticker.
+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.
+
+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
+`~/Library/Logs/chartremotely-serve.log` (voice) or `chartremotely-relay.log`
+(from the operator). Never a token, a secret or a picture.
+
 ## Running it as a service
 
 `chartremotely setup` installs both transports as launchd agents

{chartremotely-0.2.3 → chartremotely-0.2.5}/chartremotely.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ chartremotely/ax.py
 chartremotely/cli.py
 chartremotely/config.py
 chartremotely/doctor.py
+chartremotely/forward.py
 chartremotely/guilock.py
 chartremotely/keystore.py
 chartremotely/layout.py
@@ -14,6 +15,7 @@ chartremotely/mcpclient.py
 chartremotely/push.py
 chartremotely/registry.py
 chartremotely/relay.py
+chartremotely/requestlog.py
 chartremotely/resolve.py
 chartremotely/scales.py
 chartremotely/server.py
@@ -34,8 +36,10 @@ chartremotely.egg-info/entry_points.txt
 chartremotely.egg-info/requires.txt
 chartremotely.egg-info/top_level.txt
 chartremotely/assets/shortcut-template.plist
+tests/test_forward.py
 tests/test_push.py
 tests/test_relay.py
+tests/test_requestlog.py
 tests/test_resolve.py
 tests/test_setup.py
 tests/test_snapshot.py

{chartremotely-0.2.3 → chartremotely-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "chartremotely"
-version = "0.2.3"
+version = "0.2.5"
 description = "Remote control of desktop charting applications on macOS"
 readme = "README.md"
 requires-python = ">=3.12"

chartremotely-0.2.5/tests/test_forward.py

@@ -0,0 +1,178 @@
+"""Where?: this Mac, or another of the owner's displays through the operator.
+
+The operator is a stub HTTP server and vocab is a stand-in, so this runs on
+Linux without the macOS drivers.
+"""
+
+import importlib
+import json
+import plistlib
+import sys
+import threading
+import types
+import urllib.request
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import ClassVar
+
+import pytest
+
+from chartremotely import config, forward, shortcut
+from chartremotely.answer import Answer
+
+
+class StubOperator(BaseHTTPRequestHandler):
+    """``/agent/forward`` answering with whatever a test queues."""
+
+    answer: ClassVar[tuple[int, dict]] = (200, {})
+    seen: ClassVar[list] = []
+
+    def do_POST(self):
+        body = json.loads(self.rfile.read(int(self.headers.get("Content-Length") or 0)))
+        type(self).seen.append((self.path, body))
+        status, payload = type(self).answer
+        raw = json.dumps(payload).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(raw)))
+        self.end_headers()
+        self.wfile.write(raw)
+
+    def log_message(self, *args):
+        pass
+
+
+@pytest.fixture
+def operator(monkeypatch, tmp_path):
+    monkeypatch.setattr(config, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(config, "CONFIG_PATH", tmp_path / "config.json")
+    StubOperator.seen = []
+    StubOperator.answer = (200, {"display": "Mac Mini", "reply": "Showing PLTR at daily. Good luck."})
+    server = HTTPServer(("127.0.0.1", 0), StubOperator)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    base = f"http://127.0.0.1:{server.server_address[1]}"
+    config.update(operator_url=base, agent_id="a1", agent_secret="s1")
+    yield base
+    server.shutdown()
+
+
+@pytest.fixture
+def listener(operator, monkeypatch):
+    """The Shortcut's listener, with a stand-in vocab. Returns (post, ran, pictures)."""
+    ran, pictures = [], []
+    fake_vocab = types.ModuleType("chartremotely.vocab")
+    fake_vocab.answer = lambda cmd: ran.append(cmd) or Answer("Showing PLTR at daily. Good luck.", "PLTR")
+    monkeypatch.setitem(sys.modules, "chartremotely.vocab", fake_vocab)
+    monkeypatch.delitem(sys.modules, "chartremotely.server", raising=False)
+    server = importlib.import_module("chartremotely.server")   # bound to the stand-in vocab
+    from chartremotely import push
+    monkeypatch.setattr(push, "after_reply", lambda *a: pictures.append(a))
+    server.Handler.token = "T0KEN"
+    http = HTTPServer(("127.0.0.1", 0), server.Handler)
+    threading.Thread(target=http.serve_forever, daemon=True).start()
+
+    def post(body):
+        request = urllib.request.Request(
+            f"http://127.0.0.1:{http.server_address[1]}/chart", data=json.dumps(body).encode(),
+            method="POST", headers={"Content-Type": "application/json", "X-Token": "T0KEN"})
+        with urllib.request.urlopen(request, timeout=10) as response:
+            return response.read().decode().strip()
+
+    yield post, ran, pictures
+    http.shutdown()
+
+
+# -- the listener ----------------------------------------------------------------
+
+def test_no_where_runs_here_exactly_as_before(listener):
+    post, ran, pictures = listener
+    assert post({"cmd": "set PLTR | daily"}) == "Showing PLTR at daily. Good luck."
+    assert ran == ["set PLTR | daily"] and len(pictures) == 1
+    assert StubOperator.seen == []
+
+
+@pytest.mark.parametrize("said", ["", "  ", "a1", " a1 "])
+def test_blank_or_this_macs_agent_id_runs_here_without_asking(listener, said):
+    post, ran, _ = listener
+    post({"cmd": "set PLTR | daily", "where": said})
+    assert ran == ["set PLTR | daily"] and StubOperator.seen == []
+
+
+@pytest.mark.parametrize("said", ["Desk", "desk", "mini mac", "A1"])
+def test_every_name_is_matched_by_the_operator_not_here(listener, said):
+    post, ran, _ = listener
+    StubOperator.answer = (200, {"self": True, "display": "Desk"})
+    post({"cmd": "set PLTR | daily", "where": said})
+    assert [body["display"] for _, body in StubOperator.seen] == [said.strip()]
+    assert ran == ["set PLTR | daily"], "the operator said it is this Mac, so it runs here"
+
+
+def test_is_here_is_blank_or_the_exact_agent_id():
+    cfg = {"agent_id": "a1"}
+    assert forward.is_here("", cfg) and forward.is_here(" a1 ", cfg)
+    assert not forward.is_here("A1", cfg) and not forward.is_here("Desk", cfg)
+    assert forward.is_here("", {}) and not forward.is_here("a1", {})
+
+
+def test_each_request_is_logged_once_without_the_token_or_arguments(listener, capsys):
+    post, _, _ = listener
+    capsys.readouterr()
+    post({"cmd": "set PLTR | daily", "where": "desk"})
+    StubOperator.answer = (404, {"error": "no display named 'kitchen'", "displays": ["Desk"]})
+    post({"cmd": "read", "where": "kitchen"})
+    lines = capsys.readouterr().err.strip().splitlines()
+    assert len(lines) == 2
+    assert "serve verb=set where='desk'" in lines[0] and "reply=" not in lines[0]
+    assert "verb=read where='kitchen' reply='ERR No display named \"kitchen\". Yours: Desk.'" in lines[1]
+    for line in lines:
+        assert "T0KEN" not in line and "s1" not in line and "PLTR" not in line
+
+
+def test_another_name_is_forwarded_verbatim_and_its_reply_spoken(listener):
+    post, ran, pictures = listener
+    assert post({"cmd": "set PLTR | daily", "where": "mac-mini"}) == "Showing PLTR at daily. Good luck."
+    assert StubOperator.seen == [("/agent/forward", {
+        "agent_id": "a1", "secret": "s1", "display": "mac-mini", "cmd": "set PLTR | daily"})]
+    assert ran == [] and pictures == [], "the target runs it and pushes its own picture"
+
+
+def test_an_unknown_name_is_spoken_back_with_the_owners_names(listener):
+    post, _, _ = listener
+    StubOperator.answer = (404, {"error": "no display named 'kitchen'", "displays": ["Desk", "Mac Mini"]})
+    assert post({"cmd": "read", "where": "kitchen"}) == 'ERR No display named "kitchen". Yours: Desk, Mac Mini.'
+
+
+# -- forward.route -----------------------------------------------------------------
+
+def test_the_operator_saying_self_runs_here(operator):
+    StubOperator.answer = (200, {"self": True, "display": "Desk"})
+    assert forward.route("read", "desk") is None
+
+
+def test_an_offline_display_is_said_plainly(operator):
+    StubOperator.answer = (503, {"error": "attic is offline", "display": "attic"})
+    assert forward.route("read", "attic") == "ERR attic is offline"
+
+
+def test_an_unpaired_mac_can_only_drive_itself(operator):
+    config.update(agent_id=None, agent_secret=None)
+    assert forward.route("read", "attic").startswith("ERR This Mac is not paired")
+    assert forward.route("read", "") is None
+
+
+def test_an_unreachable_operator_is_an_error_not_an_exception(operator):
+    config.update(operator_url="http://127.0.0.1:1")
+    assert forward.route("read", "attic") == "ERR I could not reach the operator."
+
+
+# -- the Shortcut ------------------------------------------------------------------
+
+def test_the_shortcut_asks_where_after_scale_and_sends_it_beside_cmd():
+    actions = plistlib.loads(shortcut.template())["WFWorkflowActions"]
+    prompts = [a["WFWorkflowActionParameters"].get("WFAskActionPrompt") for a in actions]
+    assert prompts.index("Where?") > prompts.index("What scale?")
+    final = actions[prompts.index("Where?") + 1]["WFWorkflowActionParameters"]
+    fields = {i["WFKey"]["Value"]["string"]: i["WFValue"]["Value"]
+              for i in final["WFJSONValues"]["Value"]["WFDictionaryFieldValueItems"]}
+    assert fields["cmd"]["string"] == "set  | ", "the vocab grammar is unchanged"
+    where = actions[prompts.index("Where?")]["WFWorkflowActionParameters"]["UUID"]
+    assert fields["where"]["attachmentsByRange"]["{0, 1}"]["OutputUUID"] == where

{chartremotely-0.2.3 → chartremotely-0.2.5}/tests/test_relay.py

@@ -143,7 +143,7 @@ def test_the_wire_logic_imports_without_the_macos_drivers():
 
     forbidden = {"Quartz", "AppKit", "ApplicationServices", "CoreFoundation"}
     for name in ("relay", "resolve", "scales", "config", "registry", "snapshot", "push", "guilock",
-                 "mcpclient", "keystore", "services", "tailnet", "shortcut", "setup"):
+                 "mcpclient", "keystore", "services", "tailnet", "shortcut", "setup", "forward"):
         tree = ast.parse(Path(f"chartremotely/{name}.py").read_text())
         for node in ast.walk(tree):
             if isinstance(node, ast.Import):

chartremotely-0.2.5/tests/test_requestlog.py

@@ -0,0 +1,23 @@
+"""The one log line per request: enough to diagnose an ERR, nothing secret."""
+
+from chartremotely import requestlog
+
+
+def test_a_line_carries_time_source_verb_and_where_only():
+    line = requestlog.line("serve", "set PLTR | daily", "mac mini", "Showing PLTR at daily.")
+    stamp, rest = line.split(" ", 1)
+    assert stamp[:4].isdigit() and "T" in stamp
+    assert rest == "serve verb=set where='mac mini'"
+
+
+def test_an_err_reply_is_kept_truncated_and_on_one_line():
+    reply = "ERR no\nsuch display " + "x" * 500
+    line = requestlog.line("relay", "read", "", reply)
+    assert "\n" not in line
+    logged = line.split("reply=", 1)[1]
+    assert logged.startswith("'ERR no such display") and len(logged) == requestlog.ERR_MAX + 2
+
+
+def test_where_is_truncated_and_an_empty_command_is_a_dash():
+    line = requestlog.line("serve", "", "w" * 100, "ERR empty")
+    assert "verb=- " in line and f"where='{'w' * requestlog.WHERE_MAX}'" in line

{chartremotely-0.2.3 → chartremotely-0.2.5}/tests/test_setup.py

@@ -72,6 +72,55 @@ def test_plist_values_are_escaped():
     assert plistlib.loads(text.encode())["ProgramArguments"] == ["/p<q>"]
 
 
+@pytest.fixture
+def fake_launchd(monkeypatch, tmp_path):
+    """A launchd that lets go of a label only after a few polls, as the real one does."""
+    state = {"loaded": True, "polls_until_gone": 3, "bootstrap_failures": 0, "calls": []}
+
+    def loaded(label):
+        if state["loaded"] and state.get("booted_out"):
+            state["polls_until_gone"] -= 1
+            if state["polls_until_gone"] <= 0:
+                state["loaded"] = False
+        return state["loaded"]
+
+    def run(args, **kwargs):
+        state["calls"].append(args[1])
+        if args[1] == "bootout":
+            state["booted_out"] = True
+            return types.SimpleNamespace(returncode=0, stdout="", stderr="")
+        if state["loaded"] or state["bootstrap_failures"] > 0:
+            state["bootstrap_failures"] = max(0, state["bootstrap_failures"] - 1)
+            return types.SimpleNamespace(returncode=5, stdout="", stderr="Bootstrap failed: 5: Input/output error")
+        state["loaded"] = True
+        return types.SimpleNamespace(returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr(services, "AGENTS_DIR", tmp_path)
+    monkeypatch.setattr(services, "loaded", loaded)
+    monkeypatch.setattr(services.subprocess, "run", run)
+    monkeypatch.setattr(services.time, "sleep", lambda s: None)
+    monkeypatch.setattr(services, "executable", lambda: "/usr/local/bin/chartremotely")
+    return state
+
+
+def test_reinstalling_a_running_service_waits_for_launchd_to_let_go(fake_launchd):
+    services.install("serve")
+    assert fake_launchd["calls"] == ["bootout", "bootstrap"]
+    assert fake_launchd["loaded"] is True
+
+
+def test_a_bootstrap_refused_while_launchd_settles_is_tried_again(fake_launchd):
+    fake_launchd["bootstrap_failures"] = 2
+    services.install("serve")
+    assert fake_launchd["calls"].count("bootstrap") == 3
+
+
+def test_a_bootstrap_that_never_succeeds_stops_setup_with_launchds_reason(fake_launchd, monkeypatch):
+    fake_launchd["bootstrap_failures"] = 10**6
+    with pytest.raises(services.ServiceError, match="Input/output error"):
+        services.install("serve", settle=0)
+
+
 # -- the Keychain and the clipboard ---------------------------------------------
 
 @pytest.fixture