chartremotely 0.2.4__tar.gz → 0.2.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.4
+Version: 0.2.5
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -319,15 +319,20 @@ ignores everything sent to it.
 
 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, by the name it was paired under. Say this
-   Mac's own name to stay here.
-
-The Shortcut talks to one Mac — the one that made it. When "Where?" names
-another of your displays, that Mac hands the command to the operator, which
-finds the display among yours by name only (case, spaces, hyphens,
-underscores and dots do not count: "Mac mini" is "mac-mini") and relays it.
-The reply you hear is the other display's. An unknown name is answered with
-the names you do have.
+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-0.2.4 → chartremotely-0.2.5}/README.md

@@ -95,15 +95,20 @@ ignores everything sent to it.
 
 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, by the name it was paired under. Say this
-   Mac's own name to stay here.
-
-The Shortcut talks to one Mac — the one that made it. When "Where?" names
-another of your displays, that Mac hands the command to the operator, which
-finds the display among yours by name only (case, spaces, hyphens,
-underscores and dots do not count: "Mac mini" is "mac-mini") and relays it.
-The reply you hear is the other display's. An unknown name is answered with
-the names you do have.
+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-0.2.4 → chartremotely-0.2.5}/chartremotely/config.py

@@ -34,8 +34,6 @@ DEFAULTS: dict = {
     "operator_url": None,
     "agent_id": None,
     "agent_secret": None,
-    # This display's name at the operator, for "Where?" in the Shortcut.
-    "display_label": None,
     "token": None,
     "port": 8899,
 }

{chartremotely-0.2.4 → chartremotely-0.2.5}/chartremotely/forward.py

@@ -1,11 +1,11 @@
 """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 own name, means this Mac. Any other name goes to the
-operator's ``/agent/forward``, which looks it up among the SAME owner's
-displays by name only and relays the command there; the target's reply is
-what gets spoken. No inference here and none at the operator: the name is
-compared ignoring case, spaces, hyphens, underscores and dots, and that is all.
+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.
 """
@@ -13,7 +13,6 @@ Stdlib only, like the relay, so it imports where the macOS drivers do not.
 from __future__ import annotations
 
 import json
-import re
 import urllib.error
 import urllib.request
 
@@ -23,21 +22,10 @@ ERR = "ERR "
 #: Longer than the operator's own wait on the target, so its 504 arrives first.
 TIMEOUT = 35.0
 
-_NAME_NOISE = re.compile(r"[\s\-_.]+")
-
-
-def display_key(name: str) -> str:
-    """A display name as it is matched. The operator's ``display_key``, exactly."""
-    return _NAME_NOISE.sub("", name or "").lower()
-
-
 def is_here(where: str, cfg: dict) -> bool:
-    """Whether ``where`` means this Mac: empty, its display name, or its agent_id."""
+    """Whether ``where`` means this Mac without asking: empty, or exactly its agent_id."""
     wanted = (where or "").strip()
-    if not wanted:
-        return True
-    label = cfg.get("display_label") or ""
-    return wanted == cfg.get("agent_id") or bool(label) and display_key(wanted) == display_key(label)
+    return not wanted or wanted == cfg.get("agent_id")
 
 
 def _post(url: str, payload: dict) -> tuple[int, dict]:
@@ -77,9 +65,6 @@ def route(command: str, where: str, cfg: dict | None = None) -> str | None:
     except (urllib.error.URLError, TimeoutError, OSError):
         return ERR + "I could not reach the operator."
     if status == 200 and body.get("self"):
-        # Told its own name: remember it, so next time needs no round trip.
-        if body.get("display"):
-            config.update(display_label=str(body["display"]))
         return None
     if status == 200:
         return str(body.get("reply") or "")

{chartremotely-0.2.4 → 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.4 → 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, forward, push
+from . import config, forward, push, requestlog
 from .vocab import answer
 
 
@@ -72,13 +72,18 @@ class Handler(BaseHTTPRequestHandler):
         """
         elsewhere = forward.route(request, where) if where and request else None
         if elsewhere is not None:
-            return self._reply(200, elsewhere)
+            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.4 → 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.4 → chartremotely-0.2.5}/chartremotely/setup.py

@@ -157,8 +157,6 @@ def run(ask: Ask = input, say: Say = print, operator_url: str = OPERATOR_URL) ->
         label = ask("Name this display (e.g. Desk, Office wall): ").strip() or "display"
         pair(client, base, npub, proof, label)
         del proof
-        # Kept so "Where? <this Mac's name>" runs here without asking the operator.
-        config.update(display_label=label)
         say(f"Paired as “{label}”.")
 
     # 3. Tailscale.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chartremotely
-Version: 0.2.4
+Version: 0.2.5
 Summary: Remote control of desktop charting applications on macOS
 Author: Lonnie VanZandt
 License: 
@@ -319,15 +319,20 @@ ignores everything sent to it.
 
 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, by the name it was paired under. Say this
-   Mac's own name to stay here.
-
-The Shortcut talks to one Mac — the one that made it. When "Where?" names
-another of your displays, that Mac hands the command to the operator, which
-finds the display among yours by name only (case, spaces, hyphens,
-underscores and dots do not count: "Mac mini" is "mac-mini") and relays it.
-The reply you hear is the other display's. An unknown name is answered with
-the names you do have.
+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-0.2.4 → chartremotely-0.2.5}/chartremotely.egg-info/SOURCES.txt

@@ -15,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
@@ -38,6 +39,7 @@ 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.4 → chartremotely-0.2.5}/pyproject.toml

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

{chartremotely-0.2.4 → chartremotely-0.2.5}/tests/test_forward.py

@@ -50,7 +50,7 @@ def operator(monkeypatch, tmp_path):
     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", display_label="Desk")
+    config.update(operator_url=base, agent_id="a1", agent_secret="s1")
     yield base
     server.shutdown()
 
@@ -90,13 +90,43 @@ def test_no_where_runs_here_exactly_as_before(listener):
     assert StubOperator.seen == []
 
 
-@pytest.mark.parametrize("said", ["Desk", "desk", " DESK ", "a1"])
-def test_this_macs_own_name_runs_here(listener, said):
+@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."
@@ -113,11 +143,9 @@ def test_an_unknown_name_is_spoken_back_with_the_owners_names(listener):
 
 # -- forward.route -----------------------------------------------------------------
 
-def test_the_operator_saying_self_runs_here_and_remembers_the_name(operator):
-    config.update(display_label=None)
+def test_the_operator_saying_self_runs_here(operator):
     StubOperator.answer = (200, {"self": True, "display": "Desk"})
     assert forward.route("read", "desk") is None
-    assert config.load()["display_label"] == "Desk"
 
 
 def test_an_offline_display_is_said_plainly(operator):
@@ -136,11 +164,6 @@ def test_an_unreachable_operator_is_an_error_not_an_exception(operator):
     assert forward.route("read", "attic") == "ERR I could not reach the operator."
 
 
-@pytest.mark.parametrize("said", ["Mac mini", "mac-mini", "macmini", "MAC_MINI", "mac.mini"])
-def test_the_name_rule_is_the_operators(said):
-    assert forward.display_key(said) == "macmini"
-
-
 # -- the Shortcut ------------------------------------------------------------------
 
 def test_the_shortcut_asks_where_after_scale_and_sends_it_beside_cmd():

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.4 → 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
@@ -203,7 +252,6 @@ def test_a_made_key_never_reaches_the_agents_config(monkeypatch, tmp_path):
     stored = (tmp_path / "config.json").read_text()
     assert NSEC not in stored and "proof-for" not in stored
     assert json.loads(stored)["agent_id"] == "a1"
-    assert json.loads(stored)["display_label"] == "Desk", "so \"Where? Desk\" stays on this Mac"
     assert kept == [NPUB], "the made key is handed to the human's Keychain"
     assert built == ["https://mac.example.ts.net/chart"]
     assert not any(NSEC in s for s in said), "the key is never printed"