fix(watchd): resolve aliases, sync state at startup, tell the truth when a log is empty (#91)

Three defects from the first live run of the daemon against a real
homeserver. #88 said the sync loop was unverified; this is what running
it found.

## Every send through the socket failed

Commands hand the daemon the room argument a human typed, normally an
alias. They cannot resolve it themselves — resolving needs credentials,
and the daemon is holding those — so the socket received
`#test:example.org` and passed it to `room_send`, which wants a room id.

```
Error: LocalProtocolError: No such room with id #test:example.org found.
```

The daemon resolves now, checking its watched rooms first so the common
case costs nothing.

## And then it still failed, on the id

```
Error: LocalProtocolError: No such room with id !CkTNagkk...:example.org found.
```

A sync resumed from a stored token returns only what is new, so nio's
room list stayed empty — and `room_send` looks the room up there to
decide how to encrypt. The daemon now does one `full_state=True` sync
before serving anything.

Two errors, one message, different causes. The second only became
visible once the first was fixed, which is the ordinary shape of this: a
fix does not confirm a diagnosis, it exposes the next thing.

## The reader blamed the daemon for being absent while it was running

Any missing log produced:

```
No log for !room:example.org.
Start the daemon and add the room to watch_rooms:
  matrix-watchd.py --start
```

A missing log has three causes, and that message names one. The most
common in practice is the one it does not cover: the daemon is running,
it is watching that room, and nothing has been said yet — a sync does
not replay history, so the log starts at the first event after the
daemon began watching. Telling someone to restart a healthy daemon is
worse than saying nothing.

It now asks the daemon over the socket and distinguishes the three,
exiting 0 for the case that is not an error.

## Verification

End to end against a live homeserver, in `#test` as the repository's
testing note requires:

```
$ matrix-send-e2ee.py '#test:example.org' "…"
Event ID: $k40enVvKZjibK3EjppBjqa3fU924dRlT9182CM3n6xY

$ matrix-watch.py '#test:example.org' --once
since last: 1 messages, 0 mentioning you
[10:34] Sebastian Mendel: 🤖 Daemon-Test: Runde durch den Socket
```

Socket in, homeserver, daemon sync, decryption, log, reader. A second
message sent while a reader was already following appeared in it within
the poll interval.

44 existing tests still pass. No test is added here: all three defects
are in the seam between the daemon and a live homeserver, which is the
part #88 documented as not unit-testable, and a mock of nio's room list
would assert my model of nio rather than nio.

Author: CybotTM

skills/matrix-communication/scripts/matrix-watch.py

@@ -25,6 +25,7 @@
 
 from _lib import (
     cursor_path,
+    daemon_request,
     load_config,
     log_path,
     read_cursor,
@@ -130,9 +131,27 @@ def main() -> int:
     cursor = cursor_path(directory, room_id, args.cursor)
 
     if not log.exists():
+        # A missing log has two very different causes, and saying the wrong one
+        # sends people to restart a daemon that is already running.
+        status = daemon_request({"op": "status"})
+        if status and status.get("ok") and room_id in status.get("rooms", []):
+            print(
+                f"Watching {room_id}, nothing logged yet.\n"
+                "The log starts at the first event after the daemon began "
+                "watching; a sync does not replay history.",
+                file=sys.stderr,
+            )
+            return 0
+        if status and status.get("ok"):
+            print(
+                f"The daemon is running but not watching {room_id}.\n"
+                'Add it to "watch_rooms" in ~/.config/matrix/config.json and '
+                "restart it.",
+                file=sys.stderr,
+            )
+            return 1
         print(
-            f"No log for {room_id}.\n"
-            "Start the daemon and add the room to watch_rooms:\n"
+            f"No log for {room_id}, and no daemon is running.\n"
             "  matrix-watchd.py --start",
             file=sys.stderr,
         )

skills/matrix-communication/scripts/matrix-watchd.py

@@ -268,6 +268,24 @@ async def dispatch(self, request: dict) -> dict:
         except Exception as exc:  # noqa: BLE001  # a bad request must not kill the daemon
             return {"ok": False, "error": f"{type(exc).__name__}: {exc}"}
 
+    def room_id_for(self, room: str) -> str:
+        """Turn whatever the caller typed into a room id.
+
+        Commands hand over the argument a human wrote, which is usually an
+        alias - they cannot resolve it themselves, because resolving needs
+        credentials and the daemon is holding those. Watched rooms are already
+        mapped, so the common case costs nothing.
+        """
+        if room.startswith("!"):
+            return room
+        for room_id, label in self.rooms.items():
+            if label == room:
+                return room_id
+        resolved = resolve_room_alias(self.config, room)
+        if resolved:
+            return resolved
+        raise ValueError(f"cannot resolve room {room!r}")
+
     async def op_send(self, request: dict) -> dict:
         content = {
             "msgtype": request.get("msgtype") or "m.text",
@@ -287,7 +305,7 @@ async def op_send(self, request: dict) -> dict:
             }
 
         response = await self.client.room_send(
-            room_id=request["room"],
+            room_id=self.room_id_for(request["room"]),
             message_type="m.room.message",
             content=content,
             ignore_unverified_devices=True,
@@ -296,7 +314,7 @@ async def op_send(self, request: dict) -> dict:
 
     async def op_react(self, request: dict) -> dict:
         response = await self.client.room_send(
-            room_id=request["room"],
+            room_id=self.room_id_for(request["room"]),
             message_type="m.reaction",
             content={
                 "m.relates_to": {
@@ -311,7 +329,7 @@ async def op_react(self, request: dict) -> dict:
 
     async def op_redact(self, request: dict) -> dict:
         response = await self.client.room_redact(
-            room_id=request["room"],
+            room_id=self.room_id_for(request["room"]),
             event_id=request["event_id"],
             reason=request.get("reason"),
         )
@@ -369,6 +387,14 @@ async def run(self) -> int:
         server = await asyncio.start_unix_server(self.handle_client, str(path))
         os.chmod(path, 0o600)
 
+        # One state-carrying sync before anything is served. A sync resumed from
+        # a stored token returns only what is new, so nio's room list stays
+        # empty - and room_send looks a room up there to decide how to encrypt.
+        # Without this the first send fails with "No such room with id", which
+        # names the room it was just handed.
+        await self.client.sync(timeout=10000, full_state=True)
+        self.last_sync = int(time.time())
+
         print(f"watching {len(self.rooms)} room(s), socket at {path}")
 
         sync_task = asyncio.create_task(self.sync_loop())