diff --git a/meshterm/core/channels.py b/meshterm/core/channels.py index e0bc29f..4566d90 100644 --- a/meshterm/core/channels.py +++ b/meshterm/core/channels.py @@ -12,6 +12,7 @@ so the app never needs the radio's own decode to read a channel it holds the key from __future__ import annotations +import re import secrets from dataclasses import dataclass from datetime import datetime, timezone @@ -22,6 +23,35 @@ from urllib.parse import parse_qs, quote, urlsplit from Crypto.Cipher import AES from Crypto.Hash import HMAC, SHA256 as _SHA256 +#: Matches the ``Name: message`` convention channel senders use to identify themselves +#: (the protocol carries no sender field). The name is 1–20 non-colon characters and must +#: be followed by ``": "`` — conservative enough to leave ``http://…`` and ``note:x`` alone. +SENDER_PREFIX = re.compile(r"^([^\s:][^:]{0,19}):[ \t]+(.*)$", re.DOTALL) + + +def split_channel_sender(text: str) -> tuple[Optional[str], str]: + """Split a channel message into ``(sender_name, body)`` when it carries a name prefix. + + Channel messages have no sender field on the wire, so senders identify themselves by + prefixing the text with ``Name: ``. Lifting that name out lets a transcript show it + as a coloured header, a feed name *who* spoke, and the message-paths matcher compare + an on-air body against a stored one. + + Args: + text: The raw channel message text. + + Returns: + ``(name, body)`` when a plausible ``Name: `` prefix is present, else + ``(None, text)``. + """ + match = SENDER_PREFIX.match(text) + if match is None: + return None, text + name, body = match.group(1).strip(), match.group(2) + if not name or name.isdigit() or body.startswith("//"): # reject URLs / timestamps + return None, text + return name, body + #: A channel shared secret is exactly 16 bytes (128-bit), per the MeshCore protocol. CHANNEL_SECRET_BYTES = 16 diff --git a/meshterm/persistence/repository.py b/meshterm/persistence/repository.py index 393c037..d259e1b 100644 --- a/meshterm/persistence/repository.py +++ b/meshterm/persistence/repository.py @@ -726,8 +726,39 @@ class Repository: "FROM observations WHERE observed_at >= ? ORDER BY observed_at DESC LIMIT ?", (since.isoformat(), limit), ).fetchall() + return self._hydrate_observations(reversed(rows)) + + def packet_frames_between( + self, start: datetime, end: datetime, *, limit: int = 2000 + ) -> list[Observation]: + """RX-logged ``packet`` frames inside a closed time window, oldest first. + + The message-paths view's feed: every relayed frame the radio reported in the + window around a chat message, raw crypto fields included, so a channel frame + can be decrypted and matched to the message and a direct frame correlated by + time. Timestamps compare as ISO strings, like every observation query. + + Args: + start: The window's inclusive start. + end: The window's inclusive end. + limit: Hard cap on rows (oldest kept — the window centres on the message). + + Returns: + The window's ``packet`` observations, oldest first. + """ + rows = self._conn.execute( + "SELECT node, name, kind, node_type, snr, rssi, lat, lon, path, observed_at, " + "chan_hash, cipher_mac, crypted, payload_typename " + "FROM observations WHERE kind = 'packet' AND observed_at >= ? " + "AND observed_at <= ? ORDER BY observed_at ASC LIMIT ?", + (start.isoformat(), end.isoformat(), limit), + ).fetchall() + return self._hydrate_observations(rows) + + def _hydrate_observations(self, rows) -> list[Observation]: # noqa: ANN001 - sqlite rows + """Rebuild :class:`Observation` values from full observation rows, in order.""" observations: list[Observation] = [] - for row in reversed(rows): + for row in rows: try: observed_at = datetime.fromisoformat(row["observed_at"]) except (TypeError, ValueError): diff --git a/meshterm/services/message_paths.py b/meshterm/services/message_paths.py new file mode 100644 index 0000000..d1f2e4d --- /dev/null +++ b/meshterm/services/message_paths.py @@ -0,0 +1,164 @@ +"""Recover the paths a chat message rode in on, from the stored packet log. + +The radio's RX log records every frame it decodes — including the relay path each one +traversed — and the recorder has been persisting those as ``packet`` observations all +along. A message heard more than once (a channel broadcast rebroadcast by several +repeaters, a flood that reached us two ways) therefore left one logged frame *per +arrival*, each with its own path and SNR. This module matches those frames back to a +chat message so the chat screen can show, on demand, every way the message reached us: + +* **Channel messages** match by content: a ``GRP_TXT`` frame names its channel only by + a one-byte hash, but we hold the channel's key, so + :func:`~meshterm.core.channels.decrypt_channel_text` can confirm the channel by MAC + and recover the plaintext. A frame whose text equals the message's (allowing for the + ``Name: `` sender prefix convention on either side) is one arrival of that message — + our own broadcasts included, since a repeater's rebroadcast of us is overheard and + logged like anything else. +* **Direct messages** ride ECDH-encrypted ``TXT_MSG`` frames that only the companion + can decrypt, so no content match is possible from the log. Frames of that class + logged within a tight window around the message are offered instead, clearly billed + as matched by time — honest evidence, not a claim. + +Nothing here transmits; it is a read-model over the repository. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from datetime import datetime, timedelta +from typing import TYPE_CHECKING, Optional + +from ..core.channels import decrypt_channel_text, split_channel_sender +from ..core.models import ChatMessage, Observation + +if TYPE_CHECKING: + from ..persistence.repository import Repository + +#: How far around a channel message the log is searched. Wide, because an inbound +#: message is stamped with the *sender's* clock, which may drift from ours by minutes. +_CHANNEL_WINDOW = timedelta(minutes=15) + +#: How far around a direct message the log is searched. Tight, because time proximity +#: is the only evidence tying an encrypted frame to the message. +_DIRECT_WINDOW = timedelta(seconds=90) + +#: Frame classes that carry a direct (addressed) text message. +_DIRECT_TYPENAMES = frozenset({"TXT_MSG"}) + + +@dataclass(slots=True) +class Arrival: + """One logged copy of a message reaching this radio. + + Attributes: + when: When the frame was heard. + hops: The relay path it rode, in propagation order (empty = arrived direct). + snr: Reception SNR in dB — of the *last relay*, as with every packet row. + resend: The sender's resend counter for this copy (0 = the original send), + recovered from a decrypted channel frame; always 0 for direct frames. + """ + + when: datetime + hops: tuple[str, ...] + snr: Optional[float] + resend: int = 0 + + +def _frame_hops(observation: Observation) -> tuple[str, ...]: + """An observation's relay path as hop hashes (empty = direct).""" + return tuple(h for h in (observation.path or "").split(",") if h) + + +def _texts_match(wire: str, stored: str) -> bool: + """Whether an on-air text and a stored chat text are the same message body. + + An inbound message is stored verbatim off the wire (sender prefix included), so an + exact match covers it. Our own outbound messages are stored as typed while the + radio prepends the ``Name: `` sender convention — so the wire text also matches + when its prefix-stripped body equals the stored text. Comparison is + whitespace-trimmed but otherwise exact: paths are evidence, and a fuzzy match + would fabricate some. + """ + wire, stored = wire.strip(), stored.strip() + if wire == stored: + return True + _sender, body = split_channel_sender(wire) + body = body.strip() + return bool(body) and body == stored + + +def channel_arrivals( + repo: "Repository", + message: ChatMessage, + *, + channel_name: str, + secret: bytes, +) -> list[Arrival]: + """Every logged arrival of a channel message, matched by decrypted content. + + Args: + repo: The repository holding the packet log. + message: The chat message whose arrivals to find (in- or outbound). + channel_name: The conversation's channel name (for the decrypt attempt). + secret: The channel's 16-byte key. + + Returns: + The matching arrivals, oldest first (resends of the same message included, + each carrying its ``resend`` counter). + """ + frames = repo.packet_frames_between( + message.created_at - _CHANNEL_WINDOW, message.created_at + _CHANNEL_WINDOW + ) + arrivals: list[Arrival] = [] + for frame in frames: + raw = frame.raw if isinstance(frame.raw, dict) else {} + if raw.get("payload_typename") != "GRP_TXT": + continue + chan_hash = raw.get("chan_hash") + cipher_mac = raw.get("cipher_mac") + crypted = raw.get("crypted") + if not (chan_hash and cipher_mac and crypted): + continue + decrypted = decrypt_channel_text( + chan_hash, cipher_mac, crypted, [(channel_name, secret)] + ) + if decrypted is None or not _texts_match(decrypted.text, message.text): + continue + arrivals.append( + Arrival( + when=frame.observed_at, + hops=_frame_hops(frame), + snr=frame.snr, + resend=decrypted.attempt, + ) + ) + return arrivals + + +def direct_frames_near(repo: "Repository", message: ChatMessage) -> list[Arrival]: + """Direct-message frames logged around ``message``, matched by time alone. + + Direct frames are encrypted to their recipient, so the log can't confirm which + message a frame carried — the caller must present these as time-correlated + evidence, not a claim (see the module docstring). + + Args: + repo: The repository holding the packet log. + message: The chat message to search around. + + Returns: + The window's direct-class frames, oldest first. + """ + frames = repo.packet_frames_between( + message.created_at - _DIRECT_WINDOW, message.created_at + _DIRECT_WINDOW + ) + return [ + Arrival(when=f.observed_at, hops=_frame_hops(f), snr=f.snr) + for f in frames + if isinstance(f.raw, dict) and f.raw.get("payload_typename") in _DIRECT_TYPENAMES + ] + + +def distinct_paths(arrivals: list[Arrival]) -> int: + """How many distinct relay paths a set of arrivals covers.""" + return len({a.hops for a in arrivals}) diff --git a/meshterm/ui/chat.py b/meshterm/ui/chat.py index f633453..c4eabe7 100644 --- a/meshterm/ui/chat.py +++ b/meshterm/ui/chat.py @@ -22,6 +22,7 @@ from typing import TYPE_CHECKING, Any, Awaitable, Callable, Optional from rich.console import Group, RenderableType from rich.text import Text +from ..core.channels import split_channel_sender from ..core.events import EventKind, MeshEvent from ..core.models import ChatMessage, Contact, Conversation, Message, utcnow from .theme import name_style, snr_style @@ -29,6 +30,7 @@ from .tui.prompt import _LineEditor from .tui.render import render_hanging, render_lines, right_aligned_tail from .tui.screen import CANCEL, Screen from .tui.spinner import Spinner +from .widgets import path_text if TYPE_CHECKING: from ..context import AppContext @@ -36,11 +38,6 @@ if TYPE_CHECKING: #: How many past messages to load into the transcript when a conversation opens. _HISTORY_LIMIT = 200 -#: Matches the ``Name: message`` convention channel senders use to identify themselves -#: (the protocol carries no sender field). The name is 1–20 non-colon characters and must -#: be followed by ``": "`` — conservative enough to leave ``http://…`` and ``note:x`` alone. -_SENDER_PREFIX = re.compile(r"^([^\s:][^:]{0,19}):[ \t]+(.*)$", re.DOTALL) - #: Matches an ``@[Name]`` mention token, as the reply flow primes into the compose line (see #: :meth:`ChatScreen._begin_reply`). The transcript renders each as a bare ``@Name`` colored #: in that sender's hue instead of showing the literal brackets. Name is 1–20 non-``]`` chars. @@ -86,34 +83,23 @@ def _sender_hue(sender: str) -> str: return name_style(sender) -def _split_channel_sender(text: str) -> tuple[Optional[str], str]: - """Split a channel message into ``(sender_name, body)`` when it carries a name prefix. - - Channel messages have no sender field on the wire, so senders identify themselves by - prefixing the text with ``Name: ``. Lifting that name out lets the transcript show it - as a colored header and keep the body clean. - - Args: - text: The raw channel message text. - - Returns: - ``(name, body)`` when a plausible ``Name: `` prefix is present, else ``(None, text)``. - """ - match = _SENDER_PREFIX.match(text) - if match is None: - return None, text - name, body = match.group(1).strip(), match.group(2) - if not name or name.isdigit() or body.startswith("//"): # reject URLs / timestamps - return None, text - return name, body +#: The sender-prefix parser, shared app-wide from the protocol layer (the transcript, +#: the conversation picker, the dashboard feed, and the message-paths matcher must all +#: split ``Name: body`` identically). Kept under its old private name for the callers +#: that import it from here. +_split_channel_sender = split_channel_sender class ChatScreen(Screen): """A live conversation: a scrolling transcript above a pinned input line. - The transcript auto-sticks to the newest message (and snaps back to the bottom whenever - you type or send). Scrolling up with the arrows / PageUp detaches from the bottom to - read history; End re-attaches. Enter sends the current line; Esc leaves the chat. + The transcript auto-sticks to the newest message (and snaps back to the bottom + whenever you type or send). ↑ picks a message — the pick walks with ↑↓/PgUp/PgDn + and carries the view with it; ^End (or Esc) returns focus to the compose line. + Enter sends the current line, or acts on a picked message: in a channel it primes + a reply ``@mention``, in a direct chat it opens the message's delivery paths. ^P + opens the paths of the picked (or latest) message in either kind. Esc leaves the + chat once nothing is picked. """ floating = False @@ -127,6 +113,7 @@ class ChatScreen(Screen): names: dict[str, str], session, # noqa: ANN001 - TuiSession, imported lazily to avoid a cycle resend: Optional[Callable[[ChatMessage], Awaitable[ChatMessage]]] = None, + paths: Optional[Callable[[ChatMessage], Awaitable[None]]] = None, ) -> None: """Build the chat screen. @@ -141,6 +128,8 @@ class ChatScreen(Screen): request repaints when messages arrive or a send completes. resend: Async callable that re-attempts delivery of an unacknowledged direct message, updating it in place (direct chats only; ``None`` for channels). + paths: Async callable that presents the delivery paths of one message (the + ^P view); ``None`` leaves the affordance quietly inert. """ super().__init__() self.title = conversation.label @@ -148,6 +137,7 @@ class ChatScreen(Screen): self._messages = list(messages) self._send = send self._resend = resend + self._paths = paths self._names = names self._session = session self._editor = _LineEditor() @@ -158,22 +148,24 @@ class ChatScreen(Screen): self._spinner = Spinner() self._status = "" self._stick = True # keep the newest message in view until the user scrolls up - # Channel-only reply selection: index of the highlighted message (or None when the - # compose line is focused), plus the body line it rendered on so the frame keeps it - # in view. Direct chats keep the flat, free-scrolling view and never select. + self._paths_open = False # one paths dialog at a time + # The pick: index of the highlighted message (or None when the compose line is + # focused), plus the body line it rendered on so the frame keeps it in view. self._selected: Optional[int] = None self._selected_line: Optional[int] = None @property def footer_hint(self) -> str: - """Key hint, reflecting whether a message is picked for reply (channels only).""" - if not self._is_channel: - if any(m.outbound and m.acked is False for m in self._messages): - return "Enter send · ^R retry failed · ↑↓/PgUp scroll · ^End latest · Esc back" - return "Enter send · ↑↓/PgUp scroll · ^End latest · Esc back" + """Key hint, reflecting whether a message is picked and what Enter does to it.""" if self._selected is not None: - return "Enter reply (@mention) · ↑↓ pick · ^End/Esc cancel" - return "Enter send · ↑ pick a message to reply · Esc back" + if self._is_channel: + return "Enter reply (@mention) · ^P paths · ↑↓ pick · ^End/Esc cancel" + return "Enter paths · ↑↓ pick · ^End/Esc cancel" + if not self._is_channel and any( + m.outbound and m.acked is False for m in self._messages + ): + return "Enter send · ↑ pick a message · ^R retry failed · ^P paths · Esc back" + return "Enter send · ↑ pick a message · ^P paths · Esc back" # --- live updates -------------------------------------------------------- @@ -213,8 +205,8 @@ class ChatScreen(Screen): Text("─" * width, style="muted"), compose, ] - if self._is_channel and self._selected is not None: - footer_parts.append(self._reply_banner()) + if self._selected is not None: + footer_parts.append(self._pick_banner()) if self._status: footer_parts.append(Text(self._status, style="muted")) lines += render_lines(Group(*footer_parts), width) @@ -422,13 +414,23 @@ class ChatScreen(Screen): glyph, style = _DELIVERED if acked else _FAILED return Text(glyph, style=style) - def _reply_banner(self) -> Text: - """One-line cue shown above the input when a message is picked to reply to.""" + def _pick_banner(self) -> Text: + """One-line cue shown above the input while a message is picked. + + Channels lead with the reply affordance (Enter's job there); direct chats with + the paths view (their Enter). Both mention what the pick is for, so the state + never reads as a mystery highlight. + """ message = self._messages[self._selected] sender, _ = self._sender_and_body(message) who = "this message" if message.outbound or sender == "·" else sender + if self._is_channel: + return Text( + f"↩ Enter to reply to {who} with an @mention · End to cancel", + style="accent", + ) return Text( - f"↩ Enter to reply to {who} with an @mention · End to cancel", style="accent" + "Enter to see the paths this message took · End to cancel", style="accent" ) def _sender_style(self, sender: str, *, is_self: bool = False) -> str: @@ -448,67 +450,34 @@ class ChatScreen(Screen): # --- input --------------------------------------------------------------- def handle(self, action: str, data: str = "") -> None: - """Dispatch a key: channels navigate a reply selection; direct chats free-scroll.""" - if self._is_channel: - self._handle_channel(action, data) - else: - self._handle_flat(action, data) + """Dispatch a key: pick and act on messages, edit the compose line, or leave. - def _handle_flat(self, action: str, data: str = "") -> None: - """Direct-chat input: send on Enter, scroll the transcript, edit, or leave on Esc. - - Home/End and Ctrl+←/→ act on the compose line (like any text field); scrolling the - transcript is on the arrows, PageUp/PageDown (a screenful), Ctrl+Home/End (top / live - tail), and Ctrl+PageUp/PageDown (previous / next day divider). - """ - if action == "enter": - self._submit() - elif action == "retry": - self._retry() - elif action == "escape": - self.resolve(CANCEL) - elif action == "up": - self._detach_and(self.scroll_lines, -1) - elif action == "pageup": - self._detach_and(self.scroll_pages, -1) - elif action == "down": - self._detach_and(self.scroll_lines, 1) - elif action == "pagedown": - self._detach_and(self.scroll_pages, 1) - elif action == "ctrl_home": - self._detach_and(self.scroll_to_top) - elif action == "ctrl_pageup": - self._detach_and(self.scroll_to_section_start) - elif action == "ctrl_pagedown": - self._detach_and(self.scroll_to_next_section) - elif action == "ctrl_end": - self._stick = True # snap back to the live tail / compose line - else: - if self._editor.edit(action, data): - self._status = "" # trimming clears the "too long" notice - self._stick = True # touching the compose line snaps back to the live tail - - def _detach_and(self, move: Callable[..., None], *args: Any) -> None: - """Detach from the live tail and run a scroll move (the shared scroll helpers).""" - self._stick = False - move(*args) - - def _handle_channel(self, action: str, data: str = "") -> None: - """Channel input: arrows pick a message to reply to; Enter sends or starts a reply. - - With no message picked the view behaves like the compose line (Enter sends). Moving - up enters the selection from the newest message; moving down past the newest (or - End) returns focus to the compose line and clears the selection. Enter on a picked - message primes the input with an ``@mention`` instead of sending. + Both chat kinds share one model. With no message picked, Enter sends and typing + edits the compose line. ↑ picks the newest message; the pick then walks with + ↑↓, PgUp/PgDn (a screenful), Ctrl+Home (the very first message), and + Ctrl+PgUp/PgDn (day dividers), carrying the view with it. Enter on a picked + message primes a reply ``@mention`` in a channel and opens the delivery paths + in a direct chat; ^P opens the paths of the picked (or latest) message in + either kind. ^End (or moving past the newest) returns to the compose line; + Esc peels the pick first, the screen second. """ if action == "enter": if self._selected is not None: - self._begin_reply() + if self._is_channel: + self._begin_reply() + else: + self._open_paths(self._selected) else: self._submit() + elif action == "paths": + target = self._selected if self._selected is not None else len(self._messages) - 1 + self._open_paths(target) + elif action == "retry": + if not self._is_channel: + self._retry() elif action == "escape": if self._selected is not None: - self._clear_selection() # first Esc deselects; next leaves the chat + self._clear_selection() # first Esc unpicks; next leaves the chat self._session.invalidate() else: self.resolve(CANCEL) @@ -533,11 +502,27 @@ class ChatScreen(Screen): self._stick = True # jump back to the live tail / compose line else: if self._editor.edit(action, data): - # Touching the compose line returns focus there — nothing stays selected. + # Touching the compose line returns focus there — nothing stays picked. self._status = "" # trimming clears the "too long" notice self._clear_selection() self._stick = True + def _open_paths(self, index: Optional[int]) -> None: + """Float the delivery-paths view for the message at ``index`` (one at a time).""" + if index is None or not self._messages or self._paths is None or self._paths_open: + return + message = self._messages[max(0, min(index, len(self._messages) - 1))] + self._paths_open = True + + async def run() -> None: + try: + await self._paths(message) + finally: + self._paths_open = False + self._session.invalidate() + + asyncio.ensure_future(run()) + def _move_selection(self, delta: int) -> None: """Move the reply selection by ``delta`` messages (negative = toward older). @@ -815,8 +800,15 @@ async def open_chat(ctx: "AppContext", conversation: Conversation) -> int: assert conversation.contact is not None return await ctx.chat.resend_direct(conversation.contact, message) + paths = await _make_paths_presenter(ctx, conversation, device) screen = ChatScreen( - conversation, history, send=send, names=names, session=session, resend=resend + conversation, + history, + send=send, + names=names, + session=session, + resend=resend, + paths=paths, ) ctx.chat.set_active(conversation.key) @@ -868,3 +860,148 @@ def _belongs(message: Message, conversation: Conversation) -> bool: if not sender or not peer: return False return sender.startswith(peer) or peer.startswith(sender) + + +# --- message paths (the ^P view) ----------------------------------------------------- + + +async def _make_paths_presenter( + ctx: "AppContext", + conversation: Conversation, + device, # noqa: ANN001 - core Device; typed at the source +) -> Callable[[ChatMessage], Awaitable[None]]: + """Build the async presenter behind the chat's ^P delivery-paths view. + + Gathers what the presenter needs once per chat open: a hop-name resolver over the + contacts plus every name the recorder ever overheard (the app-wide rule that a + nameable node never shows as a bare hash), our own node's name for the white + ``you``, the routing prefix width for the hash highlights, and — for a channel — + its secret, read from the device when the conversation didn't carry one (a picker + conversation knows its identity but not always its key). + + Args: + ctx: The shared application context. + conversation: The conversation the chat screen is opening. + device: The connected device (already awaited by the caller). + + Returns: + An async callable presenting one message's paths in a floating window. + """ + from ..services import trace_runner + from ..services.message_paths import ( + channel_arrivals, + direct_frames_near, + distinct_paths, + ) + from .timemachine_screen import _routing_prefix_bytes + + session = ctx.ui.session + resolve = trace_runner.make_node_resolver( + await device.get_contacts(), ctx.repo.node_names() + ) + prefix_bytes = await _routing_prefix_bytes(ctx) + self_name: Optional[str] = None + try: + self_name = str((await device.get_self_info()).get("name") or "") or None + except Exception: # noqa: BLE001 - a nameless self just skips the white highlight + self_name = None + + secret = conversation.secret + if conversation.is_channel and not secret and conversation.channel_idx is not None: + try: + payload = await device.get_channel(conversation.channel_idx) + raw = (payload or {}).get("channel_secret") + secret = bytes(raw) if raw else None + except Exception: # noqa: BLE001 - no key, no decrypt; the view says so honestly + secret = None + + async def present(message: ChatMessage) -> None: + if conversation.is_channel and secret: + arrivals = channel_arrivals( + ctx.repo, message, channel_name=conversation.label, secret=secret + ) + body = _paths_view( + message, arrivals, matched=True, resolve=resolve, + prefix_bytes=prefix_bytes, self_name=self_name, + summary=f"heard {len(arrivals)} time{'s' if len(arrivals) != 1 else ''}" + f" · {distinct_paths(arrivals)} distinct " + f"path{'s' if distinct_paths(arrivals) != 1 else ''}" + if arrivals else "no copies in the packet log", + ) + elif conversation.is_channel: + body = Text( + "This channel's key isn't at hand, so overheard frames can't be " + "matched to the message.", + style="muted", + ) + else: + arrivals = direct_frames_near(ctx.repo, message) + body = _paths_view( + message, arrivals, matched=False, resolve=resolve, + prefix_bytes=prefix_bytes, self_name=self_name, + summary="direct frames are encrypted — matched by time alone (±90 s)", + ) + await session.scroll(body, title="Message paths") + + return present + + +def _paths_view( + message: ChatMessage, + arrivals: list, + *, + matched: bool, + resolve, # noqa: ANN001 - NodeResolver + prefix_bytes: int, + self_name: Optional[str], + summary: str, +) -> Group: + """Lay one message's arrivals out: the quoted text, a summary, then one row each. + + Every row reads through the shared compact path widget, so a path here looks + exactly like the same path in the dashboard feed or the packet viewer: time, + reception SNR, then ``direct`` or the relay chain (with a resend counter when a + decrypted channel frame carried one). + """ + quoted = message.text.replace("\n", " ") + if len(quoted) > 64: + quoted = quoted[:63] + "…" + head = Text(f"“{quoted}”") + stamp = Text(message.created_at.astimezone().strftime("%b %d %H:%M"), style="muted") + stamp.append(" · ", style="muted") + stamp.append(summary, style="muted" if matched else "warn") + + parts: list[RenderableType] = [head, stamp] + if not arrivals: + parts.append(Text()) + if matched: + parts.append(Text( + "Nothing overheard — the radio only logs frames it hears while " + "MeshTerm is listening.", style="muted", + )) + else: + parts.append(Text("No direct-message frames logged in the window.", style="muted")) + return Group(*parts) + + parts.append(Text()) + for arrival in arrivals: + row = Text(no_wrap=True, overflow="ellipsis") + row.append(arrival.when.astimezone().strftime("%H:%M:%S"), style="muted") + row.append(" ") + if arrival.snr is not None: + row.append(f"{arrival.snr:+5.1f} dB", style=snr_style(arrival.snr)) + else: + row.append(" " * 8, style="muted") + row.append(" ") + if arrival.hops: + row.append("via ", style="muted") + row.append_text( + path_text( + arrival.hops, resolve, + prefix_bytes=prefix_bytes, self_name=self_name, empty="direct", + ) + ) + if arrival.resend: + row.append(f" (resend #{arrival.resend})", style="muted") + parts.append(row) + return Group(*parts) diff --git a/meshterm/ui/dashboard_screen.py b/meshterm/ui/dashboard_screen.py index 9a376c4..409a7d5 100644 --- a/meshterm/ui/dashboard_screen.py +++ b/meshterm/ui/dashboard_screen.py @@ -34,7 +34,6 @@ drops the feed highlight, then backs out. from __future__ import annotations import asyncio -import re from collections import Counter, deque from statistics import median from typing import TYPE_CHECKING, Any, Optional, Sequence @@ -43,6 +42,7 @@ from rich.console import Group, RenderableType from rich.table import Table from rich.text import Text +from ..core.channels import split_channel_sender from ..core.events import EventKind, MeshEvent from ..core.models import NODE_TYPE_REPEATER, Observation, utcnow from ..persistence.repository import ACTIVITY_WINDOW @@ -95,19 +95,15 @@ _FEED_LABEL_MIN_WIDTH = 76 _GRID_LABEL_W = 9 -#: A channel message carries no sender field on the wire, so senders self-identify by -#: prefixing ``Name: `` (mirrors the chat transcript's own parse). Lifting the name out -#: lets the feed's node lane show *who* sent it rather than the bare channel it came in on. -_SENDER_PREFIX = re.compile(r"^([^\s:][^:]{0,19}):[ \t]+\S") - - def _channel_sender(text: Optional[str]) -> Optional[str]: - """The sender named by a channel message's ``Name: `` prefix, or ``None`` if absent.""" - match = _SENDER_PREFIX.match(text or "") - if match is None: - return None - name = match.group(1).strip() - return name if name and not name.isdigit() else None + """The sender named by a channel message's ``Name: `` prefix, or ``None`` if absent. + + The shared protocol-layer parse (see + :func:`~meshterm.core.channels.split_channel_sender`), so the feed's node lane names + exactly the sender the chat transcript would. + """ + name, _body = split_channel_sender(text or "") + return name def _span_label(minutes: int) -> str: diff --git a/meshterm/ui/tui/session.py b/meshterm/ui/tui/session.py index 32058a6..193870a 100644 --- a/meshterm/ui/tui/session.py +++ b/meshterm/ui/tui/session.py @@ -66,6 +66,7 @@ _KEY_ACTIONS: dict[Any, str] = { Keys.Delete: "delete", Keys.Tab: "tab", Keys.ControlR: "retry", + Keys.ControlP: "paths", } diff --git a/tests/test_chat.py b/tests/test_chat.py index 5f1d0ea..0a2d60d 100644 --- a/tests/test_chat.py +++ b/tests/test_chat.py @@ -769,14 +769,19 @@ async def test_chat_screen_retry_resends_failed_message() -> None: assert "✓" in "\n".join(screen.render_body(60)) -def test_chat_screen_scroll_detaches_and_end_reattaches() -> None: - """Scrolling up detaches from the live tail; End re-sticks to the bottom.""" - screen = _screen(_StubSession(), send=None) - assert screen._stick is True +def test_chat_screen_up_picks_and_ctrl_end_returns_to_compose() -> None: + """↑ picks the newest message (detaching from the tail); ^End returns to compose.""" + messages = [ + ChatMessage(text="hi", peer="d4e5f6a7"), + ChatMessage(text="reply", outbound=True, peer="d4e5f6a7", acked=True), + ] + screen = _screen(_StubSession(), send=None, messages=messages) + assert screen._stick is True and screen._selected is None screen.handle("up") assert screen._stick is False - screen.handle("end") - assert screen._stick is True + assert screen._selected == len(screen._messages) - 1 # the newest message + screen.handle("ctrl_end") + assert screen._stick is True and screen._selected is None def test_split_channel_sender_extracts_name_prefix() -> None: @@ -870,30 +875,87 @@ def test_chat_home_end_and_word_keys_move_the_compose_cursor() -> None: assert screen._editor.cursor == 6 # start of "world" -def test_chat_scroll_keys_detach_and_reattach_to_the_tail() -> None: - """PageUp/Ctrl+Home detach from the live tail; Ctrl+End snaps back to it.""" +async def test_chat_paths_key_opens_the_picked_or_latest_message() -> None: + """^P presents the picked message's paths — or the latest, when nothing is picked.""" + import asyncio + + shown: list[str] = [] + + async def paths(message) -> None: # noqa: ANN001 - ChatMessage + shown.append(message.text) + + messages = [ + ChatMessage(text="first", peer="d4e5f6a7"), + ChatMessage(text="second", peer="d4e5f6a7"), + ] + conv = Conversation( + label="Alice", + is_channel=False, + contact=Contact(name="Alice", public_key="d4" + "0" * 62, key_prefix="d4e5f6a7"), + ) + screen = ChatScreen( + conv, messages, send=None, names={}, session=_StubSession(), paths=paths + ) + screen.handle("paths") # nothing picked → the latest message + await asyncio.sleep(0) + assert shown == ["second"] + + screen.handle("up") + screen.handle("up") # pick the older message + screen.handle("paths") + await asyncio.sleep(0) + assert shown == ["second", "first"] + + +async def test_chat_direct_enter_on_a_pick_opens_paths() -> None: + """In a direct chat, Enter on a picked message opens its paths (channels reply).""" + import asyncio + + shown: list[str] = [] + + async def paths(message) -> None: # noqa: ANN001 - ChatMessage + shown.append(message.text) + + messages = [ChatMessage(text="only", peer="d4e5f6a7")] + conv = Conversation( + label="Alice", + is_channel=False, + contact=Contact(name="Alice", public_key="d4" + "0" * 62, key_prefix="d4e5f6a7"), + ) + screen = ChatScreen( + conv, messages, send=None, names={}, session=_StubSession(), paths=paths + ) + screen.handle("up") + assert "Enter paths" in screen.footer_hint + screen.handle("enter") + await asyncio.sleep(0) + assert shown == ["only"] + + +def test_chat_pick_walks_with_page_keys_and_ctrl_home() -> None: + """PgUp walks the pick a screenful back; ^Home jumps it to the very first message.""" screen = _screen(_StubSession(), send=None, messages=_two_day_messages()) lines = screen.render_body(60) screen.note_metrics(total=len(lines), viewport=5) screen.handle("pageup") - assert screen._stick is False # a screenful up detaches from the tail + assert screen._stick is False and screen._selected is not None screen.handle("ctrl_home") - assert screen.scroll == 0 and screen._stick is False + assert screen._selected == 0 # the very first message screen.handle("ctrl_end") - assert screen._stick is True # re-attached to the newest message + assert screen._stick is True and screen._selected is None -def test_chat_ctrl_page_scrolls_between_day_dividers() -> None: - """Ctrl+PageDown/PageUp move the transcript scroll between day dividers.""" +def test_chat_ctrl_page_picks_across_day_dividers() -> None: + """Ctrl+PageDown/PageUp move the pick between day boundaries (both chat kinds).""" screen = _screen(_StubSession(), send=None, messages=_two_day_messages()) - lines = screen.render_body(60) - screen.note_metrics(total=len(lines), viewport=5) - (idx0, _), (idx1, _) = screen._sticky_headers - screen.scroll = 0 + starts = screen._day_start_indices() + assert len(starts) == 2 + screen.handle("ctrl_home") + assert screen._selected == 0 screen.handle("ctrl_pagedown") - assert screen.scroll == idx1 and screen._stick is False # to the second day's divider + assert screen._selected == starts[1] # first message of the second day screen.handle("ctrl_pageup") - assert screen.scroll == idx0 # back to the first day's divider + assert screen._selected == starts[0] # back to the first day def _two_day_channel_messages(): diff --git a/tests/test_message_paths.py b/tests/test_message_paths.py new file mode 100644 index 0000000..048c5ba --- /dev/null +++ b/tests/test_message_paths.py @@ -0,0 +1,135 @@ +"""Message-paths tests: matching a chat message back to its logged arrivals. + +Channel arrivals are matched by decrypting overheard GRP_TXT frames with the channel's +own key (firmware-shaped frames are built here exactly as the packet-viewer tests build +theirs); direct arrivals are matched by time alone. Everything runs against a real +temporary repository, so the window query is exercised too. +""" + +from __future__ import annotations + +from datetime import timedelta +from pathlib import Path + +from Crypto.Cipher import AES +from Crypto.Hash import HMAC, SHA256 + +from meshterm.core.channels import channel_hash, derive_secret +from meshterm.core.models import ChatMessage, Observation, utcnow +from meshterm.persistence.repository import Repository +from meshterm.services.message_paths import ( + channel_arrivals, + direct_frames_near, + distinct_paths, +) + +SECRET = derive_secret("#general") + + +def _grp_txt_raw(secret: bytes, text: str, *, attempt: int = 0) -> dict: + """A firmware-shaped GRP_TXT packet payload for ``text``, encrypted under ``secret``.""" + plain = (0).to_bytes(4, "little") + bytes([attempt]) + text.encode("utf-8") + plain += b"\x00" * (-len(plain) % 16) + crypted = AES.new(secret, AES.MODE_ECB).encrypt(plain) + mac = HMAC.new(secret, digestmod=SHA256) + mac.update(crypted) + return { + "payload_typename": "GRP_TXT", + "chan_hash": channel_hash(secret), + "cipher_mac": mac.digest()[:2].hex(), + "crypted": crypted.hex(), + } + + +def _repo(tmp_path: Path) -> tuple[Repository, int]: + repo = Repository(tmp_path / "test.db") + run_id = repo.start_run("monitor", {}, None) + return repo, run_id + + +def _record_frame(repo: Repository, run_id: int, *, when, path: str, raw: dict, snr=2.0): + repo.record_observation( + run_id, + Observation(node=None, kind="packet", path=path, snr=snr, observed_at=when, raw=raw), + ) + + +def test_channel_arrivals_match_by_decrypted_content(tmp_path: Path) -> None: + """Every overheard copy of a channel message surfaces, each with its own path.""" + repo, run = _repo(tmp_path) + now = utcnow() + wire = "Alice: hi mesh" + _record_frame(repo, run, when=now - timedelta(seconds=5), path="3d63", raw=_grp_txt_raw(SECRET, wire)) + _record_frame(repo, run, when=now - timedelta(seconds=3), path="3d63,a1b2", raw=_grp_txt_raw(SECRET, wire)) + _record_frame(repo, run, when=now - timedelta(seconds=1), path="", raw=_grp_txt_raw(SECRET, "Alice: other")) + + message = ChatMessage(text=wire, is_channel=True, created_at=now) + arrivals = channel_arrivals(repo, message, channel_name="#general", secret=SECRET) + assert [a.hops for a in arrivals] == [("3d63",), ("3d63", "a1b2")] + assert distinct_paths(arrivals) == 2 + repo.close() + + +def test_channel_arrivals_tolerate_the_sender_prefix_on_the_wire(tmp_path: Path) -> None: + """Our own outbound message (stored as typed) matches its prefixed on-air copies.""" + repo, run = _repo(tmp_path) + now = utcnow() + _record_frame( + repo, run, when=now + timedelta(seconds=2), path="3d63", + raw=_grp_txt_raw(SECRET, "Homestead: on my way"), + ) + message = ChatMessage(text="on my way", outbound=True, is_channel=True, created_at=now) + arrivals = channel_arrivals(repo, message, channel_name="#general", secret=SECRET) + assert len(arrivals) == 1 and arrivals[0].hops == ("3d63",) + repo.close() + + +def test_channel_arrivals_carry_the_resend_counter(tmp_path: Path) -> None: + """A decrypted frame's resend counter rides along, telling copies from retries.""" + repo, run = _repo(tmp_path) + now = utcnow() + _record_frame(repo, run, when=now, path="", raw=_grp_txt_raw(SECRET, "Alice: hi", attempt=0)) + _record_frame( + repo, run, when=now + timedelta(seconds=9), path="", + raw=_grp_txt_raw(SECRET, "Alice: hi", attempt=1), + ) + message = ChatMessage(text="Alice: hi", is_channel=True, created_at=now) + arrivals = channel_arrivals(repo, message, channel_name="#general", secret=SECRET) + assert [a.resend for a in arrivals] == [0, 1] + assert distinct_paths(arrivals) == 1 # both arrived direct + repo.close() + + +def test_channel_arrivals_ignore_frames_outside_the_window(tmp_path: Path) -> None: + """A matching frame far outside the message's window is someone else's message.""" + repo, run = _repo(tmp_path) + now = utcnow() + _record_frame( + repo, run, when=now - timedelta(hours=2), path="3d63", + raw=_grp_txt_raw(SECRET, "Alice: hi"), + ) + message = ChatMessage(text="Alice: hi", is_channel=True, created_at=now) + assert channel_arrivals(repo, message, channel_name="#general", secret=SECRET) == [] + repo.close() + + +def test_direct_frames_match_by_time_only(tmp_path: Path) -> None: + """Direct frames are encrypted, so the window's TXT_MSG frames are the evidence.""" + repo, run = _repo(tmp_path) + now = utcnow() + _record_frame( + repo, run, when=now + timedelta(seconds=3), path="3d63", + raw={"payload_typename": "TXT_MSG"}, + ) + _record_frame( # a channel frame in the window is not direct-message evidence + repo, run, when=now + timedelta(seconds=4), path="", + raw=_grp_txt_raw(SECRET, "Alice: hi"), + ) + _record_frame( # a direct frame far outside the tight window doesn't correlate + repo, run, when=now + timedelta(minutes=10), path="", + raw={"payload_typename": "TXT_MSG"}, + ) + message = ChatMessage(text="see you at 8", peer="d4e5", created_at=now) + arrivals = direct_frames_near(repo, message) + assert len(arrivals) == 1 and arrivals[0].hops == ("3d63",) + repo.close()