Key channel history by identity and mark channel openness in chat
Store channel messages under a slot-independent channel identity (sha256 of the effective secret) instead of the raw slot index, so reordering or re-keying slots no longer scrambles history. DB schema v3->v4 adds a channel_id column with an idempotent migration and a lazy backfill that maps legacy rows to the channel currently in each slot. Recognize the firmware's fixed-key default "Public" channel as public: add DEFAULT_PUBLIC_SECRET / KNOWN_PUBLIC_SECRETS and split is_name_derived (key reproducible from the name, so it can be re-derived on write) from is_public_channel (shared meshwide). The default channel no longer mislabels itself as private, and its well-known key is preserved on edit/reorder. Lead each chat picker row with a glyph: the channel's openness marker (# name-derived, globe fixed-key public, lock private) or, for a direct chat, a speech balloon once we've exchanged messages and a person before. A shared channel_glyph() keeps the channel manager and the picker in sync. Round out the messaging UX: live callable row titles and plain-text filtering in the TUI select screen, plus assorted device-picker, monitor, route-map, and config-editor menu refinements. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
1 parent
b289565d96
commit
4c725bd22a
19 files changed
+858
-89
No files matched your search
@@ -21,6 +21,16 @@ CHANNEL_SECRET_BYTES = 16
|
||||
#: The default public channel every MeshCore device ships with on slot 0.
|
||||
DEFAULT_PUBLIC_NAME = "public"
|
||||
|
||||
#: MeshCore's built-in public channel ships on slot 0 as ``Public`` with this fixed 16-byte
|
||||
#: key — it is *not* derived from the name, so it can't be recognized by the ``#`` / name-key
|
||||
#: heuristics and must be matched on its well-known secret instead.
|
||||
DEFAULT_PUBLIC_SECRET = bytes.fromhex("8b3387e9c5cdea6ac9e5edbaa115cd72")
|
||||
|
||||
#: Secrets of well-known public channels — public (shared meshwide) regardless of their name
|
||||
#: or whether their key is name-derived. Today just the firmware default above; a frozenset so
|
||||
#: further authoritative public channels can be added over time.
|
||||
KNOWN_PUBLIC_SECRETS = frozenset({DEFAULT_PUBLIC_SECRET})
|
||||
|
||||
|
||||
def is_public_name(name: str) -> bool:
|
||||
"""Whether a channel name is a public one whose key derives from the name.
|
||||
@@ -35,6 +45,41 @@ def is_public_name(name: str) -> bool:
|
||||
return name.startswith("#")
|
||||
|
||||
|
||||
def is_name_derived(name: str, secret: bytes) -> bool:
|
||||
"""Whether a channel's key is reproducible from its name.
|
||||
|
||||
``True`` for a ``#``-prefixed name and for any channel whose stored secret already equals
|
||||
``derive_secret(name)``. Such a channel need not store its key — the firmware recomputes it
|
||||
from the name — so re-keying or reordering it can pass no secret at all.
|
||||
|
||||
Args:
|
||||
name: The channel name.
|
||||
secret: The 16-byte secret stored in the slot.
|
||||
|
||||
Returns:
|
||||
``True`` if the name alone reproduces the key.
|
||||
"""
|
||||
return is_public_name(name) or bytes(secret) == derive_secret(name)
|
||||
|
||||
|
||||
def is_public_channel(name: str, secret: bytes) -> bool:
|
||||
"""Whether a channel is public — shared across the mesh rather than a private, off-mesh one.
|
||||
|
||||
A channel counts as public when its key is name-derived (see :func:`is_name_derived`) *or*
|
||||
it is a :data:`KNOWN_PUBLIC_SECRETS` channel — notably the firmware's default ``Public``,
|
||||
whose key is a fixed well-known value rather than one derived from its name. The latter is
|
||||
why a plain name/``#`` check alone would mislabel it as private.
|
||||
|
||||
Args:
|
||||
name: The channel name.
|
||||
secret: The 16-byte secret stored in the slot.
|
||||
|
||||
Returns:
|
||||
``True`` if the channel is public.
|
||||
"""
|
||||
return is_name_derived(name, secret) or bytes(secret) in KNOWN_PUBLIC_SECRETS
|
||||
|
||||
|
||||
def derive_secret(name: str) -> bytes:
|
||||
"""Derive a channel's 16-byte secret from its name, exactly as the firmware does.
|
||||
|
||||
@@ -96,6 +141,44 @@ def full_channel_hash(secret: bytes) -> str:
|
||||
return sha256(bytes(secret)).hexdigest()
|
||||
|
||||
|
||||
def effective_secret(name: str, secret: bytes) -> bytes:
|
||||
"""Return the key a channel actually encrypts with, resolving public channels by name.
|
||||
|
||||
A public channel's key is *derived from its name*, so the key material a device happens
|
||||
to have stored in the slot (some firmware/simulators keep zeros) is not its true secret.
|
||||
Private channels use their stored secret as-is.
|
||||
|
||||
Args:
|
||||
name: The channel name (a leading ``#`` marks it public).
|
||||
secret: The 16-byte secret stored in the slot.
|
||||
|
||||
Returns:
|
||||
The channel's effective 16-byte secret.
|
||||
"""
|
||||
if is_name_derived(name, secret):
|
||||
return derive_secret(name)
|
||||
return bytes(secret)
|
||||
|
||||
|
||||
def channel_identity(name: str, secret: bytes) -> str:
|
||||
"""Return a channel's stable identity — independent of which slot it occupies.
|
||||
|
||||
The identity is ``sha256`` of the channel's :func:`effective_secret`, so it is intrinsic
|
||||
to the channel itself (its key material) rather than to its UX position. Reordering
|
||||
channel slots therefore never changes a channel's identity, and every device that shares
|
||||
the channel — a public channel by name, a private one by its exchanged key — computes the
|
||||
same value. Hashing keeps the raw secret out of anything the identity is stored in.
|
||||
|
||||
Args:
|
||||
name: The channel name.
|
||||
secret: The 16-byte secret stored in the slot.
|
||||
|
||||
Returns:
|
||||
A 64-character lowercase hex identity.
|
||||
"""
|
||||
return full_channel_hash(effective_secret(name, secret))
|
||||
|
||||
|
||||
def channel_hash(secret: bytes) -> str:
|
||||
"""Return the 2-hex-character channel hash MeshCore shows for a secret.
|
||||
|
||||
|
||||
@@ -455,6 +455,7 @@ class MeshCoreDevice(Device):
|
||||
name=info.get("adv_name", name),
|
||||
public_key=info.get("public_key", ""),
|
||||
key_prefix=info.get("public_key", "")[:12],
|
||||
last_seen=_advert_time(info.get("last_advert")),
|
||||
)
|
||||
)
|
||||
return contacts
|
||||
@@ -1456,6 +1457,27 @@ def _as_float(value: object) -> Optional[float]:
|
||||
return None
|
||||
|
||||
|
||||
def _advert_time(last_advert: object) -> Optional[datetime]:
|
||||
"""Convert a contact's ``last_advert`` Unix timestamp to a UTC datetime.
|
||||
|
||||
The firmware reports the seconds-since-epoch of a contact's most recent advert; a
|
||||
zero/absent/garbage value means "never heard", which maps to ``None``.
|
||||
|
||||
Args:
|
||||
last_advert: The raw ``last_advert`` field from a contact payload.
|
||||
|
||||
Returns:
|
||||
A timezone-aware UTC :class:`datetime`, or ``None`` when unknown.
|
||||
"""
|
||||
try:
|
||||
seconds = int(last_advert) # type: ignore[arg-type]
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
if seconds <= 0:
|
||||
return None
|
||||
return datetime.fromtimestamp(seconds, tz=timezone.utc)
|
||||
|
||||
|
||||
def _mock_pub(prefix: str) -> str:
|
||||
"""Build a 32-byte mock public key from a short hex prefix (simulator only).
|
||||
|
||||
|
||||
+32
-10
@@ -119,25 +119,28 @@ class Ack:
|
||||
|
||||
|
||||
def conversation_key(
|
||||
is_channel: bool, channel_idx: Optional[int], peer: Optional[str]
|
||||
is_channel: bool, channel_id: Optional[str], peer: Optional[str]
|
||||
) -> str:
|
||||
"""Return a stable key identifying a chat conversation.
|
||||
|
||||
A conversation is either a channel or a direct exchange with one contact; this key
|
||||
is how history, unread counts, and the live screen all agree on which thread a message
|
||||
belongs to.
|
||||
belongs to. It is deliberately keyed on something *intrinsic* to the conversation — a
|
||||
channel's identity (derived from its secret; see
|
||||
:func:`~meshtools.core.channels.channel_identity`) and a contact's key prefix — never on
|
||||
a slot index or list position, so reordering channels never re-points history.
|
||||
|
||||
Args:
|
||||
is_channel: Whether the conversation is a channel.
|
||||
channel_idx: The channel slot (for channel conversations).
|
||||
channel_id: The channel's slot-independent identity (for channel conversations).
|
||||
peer: The contact's key prefix (for direct conversations).
|
||||
|
||||
Returns:
|
||||
``"chan:<idx>"`` for a channel or ``"dm:<peer>"`` (lowercased) for a direct
|
||||
``"chan:<identity>"`` for a channel or ``"dm:<peer>"`` (lowercased) for a direct
|
||||
exchange.
|
||||
"""
|
||||
if is_channel:
|
||||
return f"chan:{channel_idx}"
|
||||
return f"chan:{channel_id}"
|
||||
return f"dm:{(peer or '').lower()}"
|
||||
|
||||
|
||||
@@ -155,7 +158,11 @@ class ChatMessage:
|
||||
text: The message body.
|
||||
outbound: ``True`` if we sent it, ``False`` if we received it.
|
||||
is_channel: Whether it belongs to a channel rather than a direct exchange.
|
||||
channel_idx: The channel slot, for channel messages.
|
||||
channel_id: The channel's slot-independent identity, for channel messages. This is
|
||||
what the message is keyed to, so its history follows the channel across slot
|
||||
reorders (see :func:`~meshtools.core.channels.channel_identity`).
|
||||
channel_idx: The channel slot the message went out on / arrived on. Retained only
|
||||
for reference and legacy backfill — the conversation key never uses it.
|
||||
peer: The other party's key prefix, for direct messages.
|
||||
peer_name: A friendly name for the peer/channel, snapshotted for display.
|
||||
snr: Signal-to-noise ratio (dB) of an inbound reception, if reported.
|
||||
@@ -167,6 +174,7 @@ class ChatMessage:
|
||||
text: str
|
||||
outbound: bool = False
|
||||
is_channel: bool = False
|
||||
channel_id: Optional[str] = None
|
||||
channel_idx: Optional[int] = None
|
||||
peer: Optional[str] = None
|
||||
peer_name: Optional[str] = None
|
||||
@@ -177,17 +185,24 @@ class ChatMessage:
|
||||
@property
|
||||
def key(self) -> str:
|
||||
"""The key of the conversation this message belongs to."""
|
||||
return conversation_key(self.is_channel, self.channel_idx, self.peer)
|
||||
return conversation_key(self.is_channel, self.channel_id, self.peer)
|
||||
|
||||
@classmethod
|
||||
def from_message(
|
||||
cls, message: "Message", *, peer_name: Optional[str] = None
|
||||
cls,
|
||||
message: "Message",
|
||||
*,
|
||||
peer_name: Optional[str] = None,
|
||||
channel_id: Optional[str] = None,
|
||||
) -> "ChatMessage":
|
||||
"""Build an inbound :class:`ChatMessage` from a received :class:`Message`.
|
||||
|
||||
Args:
|
||||
message: The inbound message delivered by the event hub.
|
||||
peer_name: A friendly name for the sender, resolved from contacts if known.
|
||||
channel_id: The channel's resolved identity (channel messages only). The wire
|
||||
carries only a slot index, so the caller resolves it to the channel's
|
||||
intrinsic identity before recording.
|
||||
|
||||
Returns:
|
||||
The equivalent inbound :class:`ChatMessage`.
|
||||
@@ -196,6 +211,7 @@ class ChatMessage:
|
||||
text=message.text,
|
||||
outbound=False,
|
||||
is_channel=message.is_channel,
|
||||
channel_id=channel_id if message.is_channel else None,
|
||||
channel_idx=message.channel,
|
||||
peer=None if message.is_channel else (message.sender or None),
|
||||
peer_name=peer_name,
|
||||
@@ -215,13 +231,19 @@ class Conversation:
|
||||
Attributes:
|
||||
label: Display name (e.g. ``#general`` or ``Alice``).
|
||||
is_channel: Whether this is a channel rather than a direct conversation.
|
||||
channel_idx: The channel slot, for channels.
|
||||
channel_idx: The channel slot to address for sending / live matching, for channels.
|
||||
channel_id: The channel's slot-independent identity, used to key its history (see
|
||||
:func:`~meshtools.core.channels.channel_identity`).
|
||||
secret: The channel's 16-byte secret, for channels — used only to show its
|
||||
public/private openness marker; ``None`` when unknown.
|
||||
contact: The contact, for direct conversations.
|
||||
"""
|
||||
|
||||
label: str
|
||||
is_channel: bool
|
||||
channel_idx: Optional[int] = None
|
||||
channel_id: Optional[str] = None
|
||||
secret: Optional[bytes] = None
|
||||
contact: Optional[Contact] = None
|
||||
|
||||
@property
|
||||
@@ -234,7 +256,7 @@ class Conversation:
|
||||
@property
|
||||
def key(self) -> str:
|
||||
"""The conversation's stable key (see :func:`conversation_key`)."""
|
||||
return conversation_key(self.is_channel, self.channel_idx, self.peer)
|
||||
return conversation_key(self.is_channel, self.channel_id, self.peer)
|
||||
|
||||
|
||||
@dataclass(slots=True)
|
||||
|
||||
@@ -10,7 +10,7 @@ from __future__ import annotations
|
||||
import sqlite3
|
||||
from pathlib import Path
|
||||
|
||||
SCHEMA_VERSION = 3
|
||||
SCHEMA_VERSION = 4
|
||||
|
||||
_SCHEMA = """
|
||||
CREATE TABLE IF NOT EXISTS schema_meta (
|
||||
@@ -98,7 +98,8 @@ CREATE TABLE IF NOT EXISTS messages (
|
||||
run_id INTEGER REFERENCES runs(id) ON DELETE SET NULL,
|
||||
outbound INTEGER NOT NULL DEFAULT 0,
|
||||
is_channel INTEGER NOT NULL DEFAULT 0,
|
||||
channel_idx INTEGER,
|
||||
channel_id TEXT, -- a channel's slot-independent identity (its history key)
|
||||
channel_idx INTEGER, -- the slot it went out on / arrived on (reference only)
|
||||
peer TEXT,
|
||||
peer_name TEXT,
|
||||
text TEXT NOT NULL,
|
||||
@@ -112,7 +113,6 @@ CREATE INDEX IF NOT EXISTS idx_trace_hops_trace ON trace_hops(trace_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_tx_samples_run ON tx_samples(run_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_observations_run ON observations(run_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_observations_node ON observations(node);
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_channel ON messages(channel_idx);
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_peer ON messages(peer);
|
||||
"""
|
||||
|
||||
@@ -131,9 +131,30 @@ def connect(db_path: Path) -> sqlite3.Connection:
|
||||
conn.row_factory = sqlite3.Row
|
||||
conn.execute("PRAGMA foreign_keys = ON;")
|
||||
conn.executescript(_SCHEMA)
|
||||
_migrate(conn)
|
||||
conn.execute(
|
||||
"INSERT OR REPLACE INTO schema_meta(key, value) VALUES ('version', ?)",
|
||||
(str(SCHEMA_VERSION),),
|
||||
)
|
||||
conn.commit()
|
||||
return conn
|
||||
|
||||
|
||||
def _migrate(conn: sqlite3.Connection) -> None:
|
||||
"""Bring an existing database's tables up to the current schema.
|
||||
|
||||
``executescript(_SCHEMA)`` only *creates* missing tables (``IF NOT EXISTS``); it cannot
|
||||
add a column to a table an older version already created. Column additions are applied
|
||||
here, guarded so the migration is idempotent and safe to run on every open. Indexes on
|
||||
added columns are created here too (not in ``_SCHEMA``), so ``executescript`` never
|
||||
references a column an older database hasn't grown yet.
|
||||
"""
|
||||
columns = {row["name"] for row in conn.execute("PRAGMA table_info(messages)")}
|
||||
if "channel_id" not in columns:
|
||||
# v3 -> v4: channel history moved from being keyed by slot index to a
|
||||
# slot-independent channel identity. Existing rows are backfilled lazily at runtime
|
||||
# (see Repository.backfill_channel_ids) once the device's channels can be read.
|
||||
conn.execute("ALTER TABLE messages ADD COLUMN channel_id TEXT")
|
||||
conn.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_messages_channel_id ON messages(channel_id)"
|
||||
)
|
||||
@@ -403,12 +403,13 @@ class Repository:
|
||||
peer = msg.peer.lower() if msg.peer else None
|
||||
cur = self._conn.execute(
|
||||
"INSERT INTO messages "
|
||||
"(run_id, outbound, is_channel, channel_idx, peer, peer_name, text, snr, "
|
||||
"acked, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
||||
"(run_id, outbound, is_channel, channel_id, channel_idx, peer, peer_name, text, "
|
||||
"snr, acked, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
||||
(
|
||||
run_id,
|
||||
int(msg.outbound),
|
||||
int(msg.is_channel),
|
||||
msg.channel_id,
|
||||
msg.channel_idx,
|
||||
peer,
|
||||
msg.peer_name,
|
||||
@@ -425,7 +426,7 @@ class Repository:
|
||||
self,
|
||||
*,
|
||||
is_channel: bool,
|
||||
channel_idx: Optional[int] = None,
|
||||
channel_id: Optional[str] = None,
|
||||
peer: Optional[str] = None,
|
||||
limit: int = 200,
|
||||
) -> list[ChatMessage]:
|
||||
@@ -433,7 +434,7 @@ class Repository:
|
||||
|
||||
Args:
|
||||
is_channel: Whether to load a channel conversation.
|
||||
channel_idx: The channel slot (channel conversations).
|
||||
channel_id: The channel's slot-independent identity (channel conversations).
|
||||
peer: The contact key prefix (direct conversations).
|
||||
limit: Maximum number of messages to return.
|
||||
|
||||
@@ -441,7 +442,7 @@ class Repository:
|
||||
The messages in chronological order (ready to render as a transcript).
|
||||
"""
|
||||
if is_channel:
|
||||
where, params = "is_channel = 1 AND channel_idx = ?", [channel_idx]
|
||||
where, params = "is_channel = 1 AND channel_id = ?", [channel_id]
|
||||
else:
|
||||
where, params = "is_channel = 0 AND peer = ?", [(peer or "").lower()]
|
||||
rows = self._conn.execute(
|
||||
@@ -463,11 +464,38 @@ class Repository:
|
||||
rows = self._conn.execute(
|
||||
"SELECT * FROM messages WHERE id IN ("
|
||||
" SELECT MAX(id) FROM messages GROUP BY "
|
||||
" CASE WHEN is_channel = 1 THEN 'chan:' || channel_idx "
|
||||
" CASE WHEN is_channel = 1 THEN 'chan:' || channel_id "
|
||||
" ELSE 'dm:' || peer END)"
|
||||
).fetchall()
|
||||
return {msg.key: msg for msg in (self._row_to_chat(r) for r in rows)}
|
||||
|
||||
def backfill_channel_ids(self, mapping: dict[int, str]) -> int:
|
||||
"""Give legacy channel messages an identity, keyed by the slot they were stored on.
|
||||
|
||||
Messages written before channel history was keyed by identity have a ``NULL``
|
||||
``channel_id``. There is no record of which channel occupied each slot back then, so
|
||||
the best available guess is the channel *currently* at that slot. ``mapping`` maps a
|
||||
slot index to the identity of the channel now there; only rows still missing an
|
||||
identity are touched, so this is safe to run on every startup.
|
||||
|
||||
Args:
|
||||
mapping: Slot index to the current channel identity at that slot.
|
||||
|
||||
Returns:
|
||||
The number of legacy rows given an identity.
|
||||
"""
|
||||
changed = 0
|
||||
for idx, channel_id in mapping.items():
|
||||
cur = self._conn.execute(
|
||||
"UPDATE messages SET channel_id = ? "
|
||||
"WHERE is_channel = 1 AND channel_id IS NULL AND channel_idx = ?",
|
||||
(channel_id, idx),
|
||||
)
|
||||
changed += cur.rowcount
|
||||
if changed:
|
||||
self._conn.commit()
|
||||
return changed
|
||||
|
||||
@staticmethod
|
||||
def _row_to_chat(row: sqlite3.Row) -> ChatMessage:
|
||||
"""Rebuild a :class:`ChatMessage` from a ``messages`` row."""
|
||||
@@ -475,6 +503,7 @@ class Repository:
|
||||
text=row["text"],
|
||||
outbound=bool(row["outbound"]),
|
||||
is_channel=bool(row["is_channel"]),
|
||||
channel_id=row["channel_id"],
|
||||
channel_idx=row["channel_idx"],
|
||||
peer=row["peer"],
|
||||
peer_name=row["peer_name"],
|
||||
|
||||
@@ -16,8 +16,10 @@ communications, not overheard noise, so they are always recorded while a device
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from typing import TYPE_CHECKING, Optional
|
||||
|
||||
from ..core.channels import channel_identity
|
||||
from ..core.connection import Unsubscribe
|
||||
from ..core.events import EventKind, MeshEvent
|
||||
from ..core.models import ChatMessage, Contact, Message, utcnow
|
||||
@@ -25,6 +27,20 @@ from ..core.models import ChatMessage, Contact, Message, utcnow
|
||||
if TYPE_CHECKING:
|
||||
from ..context import AppContext
|
||||
|
||||
#: Channel slots the firmware exposes; matches the chat/channel-manager probes.
|
||||
_MAX_CHANNELS = 8
|
||||
|
||||
|
||||
def _fallback_channel_id(idx: Optional[int]) -> str:
|
||||
"""Identity for a channel we can't read (an unconfigured/unknown slot).
|
||||
|
||||
Only used when the device has no channel to identify at ``idx`` — a degenerate case a
|
||||
configured channel never hits. It is still slot-derived (there is nothing intrinsic to
|
||||
key on), so it is the one place the old slot coupling survives, and only for channels
|
||||
that have no real identity yet.
|
||||
"""
|
||||
return f"slot:{idx}"
|
||||
|
||||
|
||||
class ChatService:
|
||||
"""Records inbound messages to history and tracks unread counts per conversation.
|
||||
@@ -47,6 +63,10 @@ class ChatService:
|
||||
self._unread: dict[str, int] = {}
|
||||
self._active: Optional[str] = None
|
||||
self._session_count = 0
|
||||
# Cache of channel slot index -> the channel's intrinsic identity. The wire only
|
||||
# tells us a message's slot index, so this bridges it to the identity history is
|
||||
# keyed by. Rebuilt from the device on demand (see :meth:`refresh_channels`).
|
||||
self._channel_ids: dict[int, str] = {}
|
||||
|
||||
@property
|
||||
def active(self) -> bool:
|
||||
@@ -79,6 +99,50 @@ class ChatService:
|
||||
if key is not None:
|
||||
self._unread.pop(key, None)
|
||||
|
||||
async def refresh_channels(self) -> None:
|
||||
"""Rebuild the slot-index -> channel-identity map from the device's channel table.
|
||||
|
||||
The map is what lets an inbound message (which carries only a slot index) be recorded
|
||||
against its channel's intrinsic identity. It is rebuilt wholesale so a reordered,
|
||||
renamed, re-keyed, or cleared slot is reflected accurately.
|
||||
"""
|
||||
device = await self._ctx.device()
|
||||
ids: dict[int, str] = {}
|
||||
for idx in range(_MAX_CHANNELS):
|
||||
try:
|
||||
payload = await device.get_channel(idx)
|
||||
except Exception: # noqa: BLE001 - firmware may not support channel reads
|
||||
break
|
||||
if not payload:
|
||||
continue # an empty slot; keep scanning (slots can be non-contiguous)
|
||||
name = str(payload.get("channel_name") or "")
|
||||
secret = bytes(payload.get("channel_secret") or b"\x00" * 16)
|
||||
ids[idx] = channel_identity(name, secret)
|
||||
self._channel_ids = ids
|
||||
|
||||
async def channel_id_for(self, idx: int) -> str:
|
||||
"""Resolve a channel slot index to its intrinsic identity (reading the device once).
|
||||
|
||||
Refreshes the cache on a miss, then falls back to a slot-derived identity only if the
|
||||
device has no channel there. The fallback is cached so a stream of messages on an
|
||||
unconfigured slot doesn't re-read the device on every one.
|
||||
|
||||
Args:
|
||||
idx: The channel slot index the wire reported.
|
||||
|
||||
Returns:
|
||||
The channel's identity, suitable for keying its history.
|
||||
"""
|
||||
cid = self._channel_ids.get(idx)
|
||||
if cid is not None:
|
||||
return cid
|
||||
await self.refresh_channels()
|
||||
cid = self._channel_ids.get(idx)
|
||||
if cid is None:
|
||||
cid = _fallback_channel_id(idx)
|
||||
self._channel_ids[idx] = cid
|
||||
return cid
|
||||
|
||||
async def start(self) -> None:
|
||||
"""Begin recording inbound messages to history. Idempotent.
|
||||
|
||||
@@ -107,6 +171,22 @@ class ChatService:
|
||||
self._unsubscribe = self._ctx.events.subscribe(on_event, EventKind.MESSAGE)
|
||||
self._run_id = run_id
|
||||
self._ctx.log.info("chat recording (run %s)", run_id)
|
||||
await self._prime_channels()
|
||||
|
||||
async def _prime_channels(self) -> None:
|
||||
"""Warm the channel-identity cache and backfill legacy (index-keyed) history.
|
||||
|
||||
Reading the channels up front means most inbound messages resolve their identity
|
||||
from the cache without a device round-trip. It also backfills any pre-identity
|
||||
messages using the channels currently in each slot — best-effort, since the old
|
||||
slot-to-channel mapping wasn't recorded.
|
||||
"""
|
||||
try:
|
||||
await self.refresh_channels()
|
||||
if self._channel_ids:
|
||||
self._ctx.repo.backfill_channel_ids(dict(self._channel_ids))
|
||||
except Exception as exc: # noqa: BLE001 - priming is best-effort, never fatal
|
||||
self._ctx.log.debug("chat: channel priming failed: %s", exc)
|
||||
|
||||
async def stop(self) -> None:
|
||||
"""Stop recording and close the run record. Idempotent.
|
||||
@@ -134,11 +214,38 @@ class ChatService:
|
||||
def _record_inbound(self, run_id: int, message: Message) -> None:
|
||||
"""Persist one inbound message and bump its conversation's unread count.
|
||||
|
||||
Channel messages are keyed by identity, but the wire carries only a slot index. When
|
||||
the slot is already cached this resolves synchronously; on a cache miss (a channel
|
||||
added since the last device read) resolution is deferred to the event loop so the
|
||||
message is still recorded against its intrinsic identity.
|
||||
|
||||
Args:
|
||||
run_id: The owning background ``chat`` run.
|
||||
message: The received message to record.
|
||||
"""
|
||||
chat = ChatMessage.from_message(message)
|
||||
if message.is_channel:
|
||||
channel_id = self._channel_ids.get(message.channel)
|
||||
if channel_id is None:
|
||||
asyncio.ensure_future(self._resolve_then_record(run_id, message))
|
||||
return
|
||||
else:
|
||||
channel_id = None
|
||||
self._store_inbound(run_id, message, channel_id)
|
||||
|
||||
async def _resolve_then_record(self, run_id: int, message: Message) -> None:
|
||||
"""Resolve an uncached channel's identity off the event loop, then record it."""
|
||||
try:
|
||||
channel_id = await self.channel_id_for(message.channel)
|
||||
except Exception as exc: # noqa: BLE001 - fall back rather than drop the message
|
||||
self._ctx.log.debug("chat: channel resolve failed: %s", exc)
|
||||
channel_id = _fallback_channel_id(message.channel)
|
||||
self._store_inbound(run_id, message, channel_id)
|
||||
|
||||
def _store_inbound(
|
||||
self, run_id: int, message: Message, channel_id: Optional[str]
|
||||
) -> None:
|
||||
"""Persist an inbound message under a resolved identity and bump its unread count."""
|
||||
chat = ChatMessage.from_message(message, channel_id=channel_id)
|
||||
self._session_count += 1
|
||||
if chat.key != self._active:
|
||||
self._unread[chat.key] = self._unread.get(chat.key, 0) + 1
|
||||
@@ -192,6 +299,7 @@ class ChatService:
|
||||
text=text,
|
||||
outbound=True,
|
||||
is_channel=True,
|
||||
channel_id=await self.channel_id_for(index),
|
||||
channel_idx=index,
|
||||
peer_name=label,
|
||||
created_at=utcnow(),
|
||||
|
||||
+168
-22
@@ -13,17 +13,20 @@ send, so ``history`` reflects the full transcript regardless of which path produ
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from typing import Any, Optional
|
||||
import time
|
||||
from typing import Any, Callable, Optional, Union
|
||||
|
||||
import typer
|
||||
from rich.table import Table
|
||||
from rich.text import Text
|
||||
|
||||
from ..context import AppContext
|
||||
from ..core.channels import DEFAULT_PUBLIC_SECRET, channel_identity
|
||||
from ..core.connection import Device
|
||||
from ..core.events import EventKind, MeshEvent
|
||||
from ..core.models import ChatMessage, Contact, Conversation
|
||||
from ..ui.tui import Choice, Separator
|
||||
from ..ui.widgets import channel_glyph
|
||||
from .base import Tool, ToolResult, register
|
||||
|
||||
#: How many channel slots to probe when listing channels to chat on.
|
||||
@@ -108,17 +111,25 @@ class ChatTool(Tool):
|
||||
device = await ctx.device()
|
||||
channels = await _read_channels(device)
|
||||
contacts = await device.get_contacts()
|
||||
# A stable snapshot orders the rows (so the list doesn't reshuffle under the cursor),
|
||||
# while a self-refreshing view feeds each row's live preview (see _LiveLasts).
|
||||
lasts = ctx.repo.last_chat_messages()
|
||||
live = _LiveLasts(ctx, seed=lasts)
|
||||
|
||||
items: list = [Separator("── Channels ──")]
|
||||
for conversation in channels:
|
||||
items.append(Choice(title=_title(ctx, conversation, lasts), value=conversation))
|
||||
items.append(Choice(title=_row_title(ctx, conversation, live), value=conversation))
|
||||
|
||||
items.append(Separator("── Direct ──"))
|
||||
if contacts:
|
||||
for contact in contacts:
|
||||
conversation = Conversation(label=contact.name, is_channel=False, contact=contact)
|
||||
items.append(Choice(title=_title(ctx, conversation, lasts), value=conversation))
|
||||
# List contacts by recency — those with messages first, newest exchange at the
|
||||
# top — then the never-contacted ones alphabetically (see _recency_key).
|
||||
direct = [
|
||||
Conversation(label=c.name, is_channel=False, contact=c) for c in contacts
|
||||
]
|
||||
direct.sort(key=lambda conv: _recency_key(conv, lasts))
|
||||
for conversation in direct:
|
||||
items.append(Choice(title=_row_title(ctx, conversation, live), value=conversation))
|
||||
else:
|
||||
items.append(Separator(" (no contacts yet — receive an advert first)"))
|
||||
|
||||
@@ -187,8 +198,9 @@ class ChatTool(Tool):
|
||||
channel = params.get("channel")
|
||||
to = params.get("to")
|
||||
if channel is not None:
|
||||
channel_id = await ctx.chat.channel_id_for(int(channel))
|
||||
messages = ctx.repo.recent_chat_messages(
|
||||
is_channel=True, channel_idx=int(channel), limit=limit
|
||||
is_channel=True, channel_id=channel_id, limit=limit
|
||||
)
|
||||
label = f"#{channel}"
|
||||
else:
|
||||
@@ -382,11 +394,27 @@ async def _read_channels(device: Device) -> list[Conversation]:
|
||||
break
|
||||
if channel:
|
||||
name = str(channel.get("channel_name") or idx)
|
||||
secret = bytes(channel.get("channel_secret") or b"\x00" * 16)
|
||||
conversations.append(
|
||||
Conversation(label=name, is_channel=True, channel_idx=idx)
|
||||
Conversation(
|
||||
label=name,
|
||||
is_channel=True,
|
||||
channel_idx=idx,
|
||||
channel_id=channel_identity(name, secret),
|
||||
secret=secret,
|
||||
)
|
||||
)
|
||||
if not any(c.channel_idx == 0 for c in conversations):
|
||||
conversations.insert(0, Conversation(label="Public", is_channel=True, channel_idx=0))
|
||||
conversations.insert(
|
||||
0,
|
||||
Conversation(
|
||||
label="Public",
|
||||
is_channel=True,
|
||||
channel_idx=0,
|
||||
channel_id="slot:0",
|
||||
secret=DEFAULT_PUBLIC_SECRET,
|
||||
),
|
||||
)
|
||||
return conversations
|
||||
|
||||
|
||||
@@ -411,29 +439,147 @@ def _resolve_contact(contacts: list[Contact], needle: str) -> Contact:
|
||||
raise typer.BadParameter(f"no contact matches {needle!r}")
|
||||
|
||||
|
||||
def _title(ctx: AppContext, conversation: Conversation, lasts: dict) -> str:
|
||||
"""Build a picker row title: label, an unread marker, and a last-message snippet.
|
||||
def _recency_key(conversation: Conversation, lasts: dict) -> tuple:
|
||||
"""Sort key ordering conversations by recency, then name.
|
||||
|
||||
Choice titles render as plain text, so markup is avoided; the unread count shows as a
|
||||
``●`` badge and the most recent message as a short trailing preview.
|
||||
Conversations that have been chatted with sort first, most-recent exchange at the top;
|
||||
those never chatted with sort after them, alphabetically by label. The leading ``0``/``1``
|
||||
keeps the two groups apart so their differently-typed tie-breakers never compare.
|
||||
|
||||
Args:
|
||||
ctx: Shared application context (for the unread count).
|
||||
conversation: The conversation the row represents.
|
||||
conversation: The conversation to rank.
|
||||
lasts: Map of conversation key to its most recent message.
|
||||
|
||||
Returns:
|
||||
A single-line plain-text title.
|
||||
A tuple usable as a ``sorted`` key.
|
||||
"""
|
||||
parts = [conversation.label]
|
||||
unread = ctx.chat.unread(conversation.key)
|
||||
if unread:
|
||||
parts.append(f" ● {unread}")
|
||||
last: Optional[ChatMessage] = lasts.get(conversation.key)
|
||||
if last is not None:
|
||||
who = "you: " if last.outbound else ""
|
||||
parts.append(f" · {who}{last.text[:32]}")
|
||||
return "".join(parts)
|
||||
return (0, -last.created_at.timestamp())
|
||||
return (1, conversation.label.casefold())
|
||||
|
||||
|
||||
class _LiveLasts:
|
||||
"""A self-refreshing view of each conversation's most recent message.
|
||||
|
||||
The picker snapshots :meth:`~meshtools.persistence.repository.Repository.last_chat_messages`
|
||||
once to *order* the rows (so the list never reshuffles under the cursor), but the row
|
||||
previews read through this so a message arriving while the list is open updates the
|
||||
sender/text preview on the next repaint. It re-queries the repository at most a few times a
|
||||
second (bounded by ``ttl``) rather than once per row per repaint, so a wide list stays cheap.
|
||||
"""
|
||||
|
||||
def __init__(self, ctx: AppContext, *, seed: dict, ttl: float = 0.5) -> None:
|
||||
"""Bind to a context, seeding the cache with the snapshot already loaded at open."""
|
||||
self._ctx = ctx
|
||||
self._ttl = ttl
|
||||
self._cache = seed
|
||||
self._at = time.monotonic()
|
||||
|
||||
def get(self, key: str) -> Optional[ChatMessage]:
|
||||
"""Return the latest message for ``key``, refreshing the cache once its TTL lapses."""
|
||||
now = time.monotonic()
|
||||
if now - self._at >= self._ttl:
|
||||
try:
|
||||
self._cache = self._ctx.repo.last_chat_messages()
|
||||
except Exception: # noqa: BLE001 - keep the last good snapshot on a read error
|
||||
pass
|
||||
self._at = now
|
||||
return self._cache.get(key)
|
||||
|
||||
|
||||
#: Column width (display cells) the conversation label is padded/ellipsized to, so the unread
|
||||
#: badge and message preview line up in fixed lanes down the picker.
|
||||
_LABEL_WIDTH = 22
|
||||
#: Width of the unread-badge lane between the label and the preview (fits ``● 999``).
|
||||
_BADGE_WIDTH = 5
|
||||
#: Longest message preview shown before it is ellipsized.
|
||||
_PREVIEW_WIDTH = 42
|
||||
|
||||
|
||||
def _row_title(
|
||||
ctx: AppContext, conversation: Conversation, lasts: "_LiveLasts"
|
||||
) -> Callable[[], Union[str, Text]]:
|
||||
"""Return a picker-row title *callable* the select screen re-renders on each repaint.
|
||||
|
||||
Both the unread badge and the last-message preview are read live, so a message arriving
|
||||
while the picker sits open updates that row's ``●`` count *and* its sender/text preview on
|
||||
the next repaint (the session already repaints ~1×/s for the header).
|
||||
|
||||
Args:
|
||||
ctx: Shared application context (for the live unread count).
|
||||
conversation: The conversation the row represents.
|
||||
lasts: The self-refreshing latest-message view feeding the preview.
|
||||
|
||||
Returns:
|
||||
A zero-argument callable producing the current row title.
|
||||
"""
|
||||
return lambda: _title(ctx, conversation, lasts)
|
||||
|
||||
|
||||
def _title(
|
||||
ctx: AppContext, conversation: Conversation, lasts: "_LiveLasts"
|
||||
) -> Union[str, Text]:
|
||||
"""Build a picker row as fixed-width columns: label, unread badge, message preview.
|
||||
|
||||
Alignment carries the readability: the label is padded to a fixed lane, the unread ``●``
|
||||
badge sits in its own lane, and the preview lines up across every row regardless of how
|
||||
long the names or counts are. When there is unread, the row is returned as a Rich
|
||||
:class:`~rich.text.Text` so the ``●`` glyph alone can be tinted red; otherwise a plain
|
||||
string suffices.
|
||||
|
||||
Args:
|
||||
ctx: Shared application context (for the live unread count).
|
||||
conversation: The conversation the row represents.
|
||||
lasts: The self-refreshing latest-message view.
|
||||
|
||||
Returns:
|
||||
The row title — a plain ``str``, or a ``Text`` with a red ``●`` when unread.
|
||||
"""
|
||||
unread = ctx.chat.unread(conversation.key)
|
||||
badge = f"● {unread}" if unread else ""
|
||||
last = lasts.get(conversation.key)
|
||||
preview = _preview(last) if last is not None else ""
|
||||
# A channel leads with its openness marker (# / 🌐 / 🔒); a direct chat with a person glyph
|
||||
# — 💬 once we've exchanged messages, 👤 for a contact we haven't talked to yet. Every glyph
|
||||
# is one double-width cell, so the label lane still lines up across rows.
|
||||
if conversation.is_channel:
|
||||
glyph = channel_glyph(conversation.label, conversation.secret)
|
||||
else:
|
||||
glyph = "💬" if last is not None else "👤"
|
||||
line = f"{glyph} {_fit(conversation.label, _LABEL_WIDTH)} {badge:<{_BADGE_WIDTH}} {preview}".rstrip()
|
||||
if not unread:
|
||||
return line
|
||||
text = Text(line)
|
||||
dot = line.index("●") # only the badge carries this glyph; colour just it red
|
||||
text.stylize("err", dot, dot + 1)
|
||||
return text
|
||||
|
||||
|
||||
def _preview(last: ChatMessage, *, width: int = _PREVIEW_WIDTH) -> str:
|
||||
"""One-line preview of the latest message, ``you:``-prefixed when we sent it.
|
||||
|
||||
Only our own outbound messages get an author prefix. Inbound channel messages already
|
||||
carry the sender's node name inline in their text (the firmware embeds it), and an inbound
|
||||
direct message's author is the row's own label — so neither needs one added here.
|
||||
|
||||
Args:
|
||||
last: The most recent message in the conversation.
|
||||
width: The column budget before the preview is ellipsized.
|
||||
|
||||
Returns:
|
||||
A single-line, length-bounded preview string.
|
||||
"""
|
||||
who = "you: " if last.outbound else ""
|
||||
body = f"{who}{last.text}".replace("\n", " ")
|
||||
return body[: width - 1] + "…" if len(body) > width else body
|
||||
|
||||
|
||||
def _fit(text: str, width: int) -> str:
|
||||
"""Left-justify ``text`` to ``width`` columns, ellipsizing anything that would overflow."""
|
||||
if len(text) > width:
|
||||
return text[: width - 1] + "…"
|
||||
return text.ljust(width)
|
||||
|
||||
|
||||
def _history_table(label: str, messages: list[ChatMessage]) -> Table:
|
||||
|
||||
@@ -36,24 +36,26 @@ class DevicesTool(Tool):
|
||||
order = 5
|
||||
|
||||
async def prompt_params(self, ctx: AppContext) -> dict[str, Any]:
|
||||
"""In the menu, offer to change the session's active device.
|
||||
"""In the menu, show the device picker so the user can change the active device.
|
||||
|
||||
The picker itself carries a "Back" row, so it reads like every other menu screen
|
||||
rather than a bare yes/no confirmation.
|
||||
|
||||
Args:
|
||||
ctx: Shared application context.
|
||||
|
||||
Returns:
|
||||
``{"select": True}`` when the user opted to re-pick a device, else ``{}``.
|
||||
Always ``{}`` — the table in :meth:`run` reflects the (possibly changed) device.
|
||||
"""
|
||||
if ctx.mock:
|
||||
return {}
|
||||
change = await ctx.ui.confirm("Change the active companion device?", default=False)
|
||||
if not change:
|
||||
return {}
|
||||
|
||||
from ..ui.device_picker import prompt_device
|
||||
|
||||
devices = discover_devices()
|
||||
chosen = await prompt_device(ctx.ui, devices, ctx.device_store.load())
|
||||
chosen = await prompt_device(
|
||||
ctx.ui, devices, ctx.device_store.load(), cancel_label="Back"
|
||||
)
|
||||
if chosen is not None:
|
||||
ctx.selected_device = chosen
|
||||
ctx.port_override = chosen.port
|
||||
@@ -61,7 +63,7 @@ class DevicesTool(Tool):
|
||||
f"[ok]●[/ok] active device set to [accent]{chosen.label}[/accent] "
|
||||
"[muted](remembered once it connects)[/muted]"
|
||||
)
|
||||
return {"select": True}
|
||||
return {}
|
||||
|
||||
async def run(self, ctx: AppContext, params: dict[str, Any]) -> ToolResult:
|
||||
"""Enumerate serial devices and render them as a table.
|
||||
|
||||
@@ -23,7 +23,7 @@ from rich.text import Text
|
||||
|
||||
from ..context import AppContext
|
||||
from ..core.models import HeardNode
|
||||
from ..ui.tui import Choice
|
||||
from ..ui.tui import Choice, Separator
|
||||
from .base import Tool, ToolResult, register
|
||||
|
||||
|
||||
@@ -52,6 +52,7 @@ class MonitorTool(Tool):
|
||||
[
|
||||
Choice(toggle_label, value="toggle"),
|
||||
Choice("View heard nodes (all time)", value="view"),
|
||||
Separator(" "),
|
||||
Choice("Back", value="__back__"),
|
||||
],
|
||||
)
|
||||
|
||||
@@ -19,11 +19,12 @@ from ..context import AppContext
|
||||
from ..services import route_stability, trace_runner
|
||||
from ..services.route_stability import RouteGraph
|
||||
from ..ui.theme import snr_style
|
||||
from ..ui.tui import Choice
|
||||
from ..ui.tui import Choice, Separator
|
||||
from ..viz.route_graph import render_route_graph
|
||||
from .base import Tool, ToolResult, register
|
||||
|
||||
_WHOLE_MESH = "(whole mesh)"
|
||||
_BACK = "__back__"
|
||||
|
||||
|
||||
@register
|
||||
@@ -47,9 +48,14 @@ class RouteMapTool(Tool):
|
||||
targets = ctx.repo.traced_targets()
|
||||
choice = await ctx.ui.select(
|
||||
"Map routing for:",
|
||||
[Choice(_WHOLE_MESH, _WHOLE_MESH), *(Choice(t, t) for t in targets)],
|
||||
[
|
||||
Choice(_WHOLE_MESH, _WHOLE_MESH),
|
||||
*(Choice(t, t) for t in targets),
|
||||
Separator(" "),
|
||||
Choice("Back", _BACK),
|
||||
],
|
||||
)
|
||||
if choice is None:
|
||||
if choice in (None, _BACK):
|
||||
return None
|
||||
samples = await ctx.ui.text(
|
||||
"Take how many fresh traces first? (0 = use stored history only)",
|
||||
|
||||
+47
-11
@@ -23,9 +23,11 @@ from rich.text import Text
|
||||
|
||||
from ..core.channels import (
|
||||
channel_hash,
|
||||
channel_identity,
|
||||
derive_secret,
|
||||
full_channel_hash,
|
||||
is_public_name,
|
||||
is_name_derived,
|
||||
is_public_channel,
|
||||
normalize_secret,
|
||||
parse_share_url,
|
||||
random_secret,
|
||||
@@ -35,6 +37,7 @@ from ..core.connection import Device
|
||||
from ..core.models import Conversation
|
||||
from .qr import qr_text
|
||||
from .tui import Choice, Separator
|
||||
from .widgets import channel_glyph
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from ..context import AppContext
|
||||
@@ -72,10 +75,18 @@ class ChannelSlot:
|
||||
name: str
|
||||
secret: bytes
|
||||
|
||||
@property
|
||||
def is_name_derived(self) -> bool:
|
||||
"""Whether this channel's key is reproducible from its name (so it needn't be stored)."""
|
||||
return is_name_derived(self.name, self.secret)
|
||||
|
||||
@property
|
||||
def is_public(self) -> bool:
|
||||
"""Whether this channel's key is derived from its name (a public channel)."""
|
||||
return is_public_name(self.name) or self.secret == derive_secret(self.name)
|
||||
"""Whether this channel is public (shared meshwide) rather than a private one.
|
||||
|
||||
Covers both name-derived channels and the firmware's fixed-key default ``Public``.
|
||||
"""
|
||||
return is_public_channel(self.name, self.secret)
|
||||
|
||||
@property
|
||||
def hash(self) -> str:
|
||||
@@ -87,10 +98,21 @@ class ChannelSlot:
|
||||
"""The channel's complete ``sha256(secret)`` digest; its first byte is :attr:`hash`."""
|
||||
return full_channel_hash(self.secret)
|
||||
|
||||
@property
|
||||
def identity(self) -> str:
|
||||
"""The channel's slot-independent identity, used to key its chat history."""
|
||||
return channel_identity(self.name, self.secret)
|
||||
|
||||
@property
|
||||
def conversation(self) -> Conversation:
|
||||
"""A :class:`~meshtools.core.models.Conversation` for opening this channel in chat."""
|
||||
return Conversation(label=self.name, is_channel=True, channel_idx=self.idx)
|
||||
return Conversation(
|
||||
label=self.name,
|
||||
is_channel=True,
|
||||
channel_idx=self.idx,
|
||||
channel_id=self.identity,
|
||||
secret=self.secret,
|
||||
)
|
||||
|
||||
|
||||
async def manage_channels(ctx: "AppContext") -> int:
|
||||
@@ -166,8 +188,9 @@ def _next_free_slot(slots: list[ChannelSlot]) -> Optional[int]:
|
||||
|
||||
def _slot_label(slot: ChannelSlot) -> str:
|
||||
"""Format a channel for a menu row: name, public/private, and hash (no slot index)."""
|
||||
lock = "# public " if slot.is_public else "🔒 private"
|
||||
return f"{slot.name:<18.18} {lock} hash {slot.hash}"
|
||||
glyph = channel_glyph(slot.name, slot.secret) # # / 🌐 / 🔒
|
||||
word = "private" if glyph == "🔒" else "public"
|
||||
return f"{slot.name:<18.18} {glyph} {word:<7} hash {slot.hash}"
|
||||
|
||||
|
||||
# --- menus -------------------------------------------------------------------
|
||||
@@ -212,6 +235,7 @@ async def _channel_detail(ctx: "AppContext", device: Device, slot: ChannelSlot)
|
||||
Choice(title="💬 Open in chat", value=_CHAT),
|
||||
Choice(title="✎ Rename / change key", value=_EDIT),
|
||||
Choice(title="🗑 Clear this slot", value=_CLEAR),
|
||||
Separator(" "),
|
||||
Choice(title="Back", value=_BACK),
|
||||
],
|
||||
)
|
||||
@@ -324,7 +348,7 @@ async def _edit(ctx: "AppContext", device: Device, slot: ChannelSlot) -> bool:
|
||||
name = name.strip()
|
||||
key = await ctx.ui.text(
|
||||
"Channel key (32 hex chars; blank to derive from the name):",
|
||||
default="" if slot.is_public else slot.secret.hex(),
|
||||
default="" if slot.is_name_derived else slot.secret.hex(),
|
||||
validate=_optional_secret,
|
||||
)
|
||||
if key is None:
|
||||
@@ -351,8 +375,8 @@ async def _clear(ctx: "AppContext", device: Device, slot: ChannelSlot) -> bool:
|
||||
|
||||
|
||||
async def _write_slot(device: Device, idx: int, slot: ChannelSlot) -> None:
|
||||
"""Write ``slot``'s contents into slot ``idx`` (public channels re-derive their key)."""
|
||||
secret = None if slot.is_public else slot.secret
|
||||
"""Write ``slot``'s contents into slot ``idx`` (name-derived channels re-derive their key)."""
|
||||
secret = None if slot.is_name_derived else slot.secret
|
||||
await device.set_channel(idx, slot.name, secret)
|
||||
|
||||
|
||||
@@ -388,7 +412,13 @@ async def _reorder_channels(
|
||||
order = await ctx.ui.reorder("Reorder channels", labels)
|
||||
if not order or order == list(range(len(slots))):
|
||||
return 0 # cancelled or left unchanged
|
||||
return await _apply_order(device, slots, order)
|
||||
changes = await _apply_order(device, slots, order)
|
||||
if changes:
|
||||
# Chat history is keyed by each channel's intrinsic identity, not its slot, so it
|
||||
# follows the channels automatically — reordering needs no history migration. Just
|
||||
# refresh the slot-index→identity cache so freshly-moved slots resolve correctly.
|
||||
await ctx.chat.refresh_channels()
|
||||
return changes
|
||||
|
||||
|
||||
# --- shared views ------------------------------------------------------------
|
||||
@@ -423,7 +453,13 @@ async def _show_key(ctx: "AppContext", slot: ChannelSlot) -> None:
|
||||
table.add_column("", style="muted")
|
||||
table.add_column("")
|
||||
table.add_row("Name", Text(slot.name, style="brand"))
|
||||
table.add_row("Type", "public (key from name)" if slot.is_public else "private")
|
||||
if slot.is_name_derived:
|
||||
kind = "public (key from name)"
|
||||
elif slot.is_public:
|
||||
kind = "public (default channel)"
|
||||
else:
|
||||
kind = "private"
|
||||
table.add_row("Type", kind)
|
||||
table.add_row("Hash", _hash_text(slot.full_hash))
|
||||
table.add_row("Key", Text(slot.secret.hex(), style="warn"))
|
||||
table.add_row("Link", Text(share_url(slot.name, slot.secret), style="accent"))
|
||||
|
||||
@@ -470,7 +470,7 @@ async def open_chat(ctx: "AppContext", conversation: Conversation) -> int:
|
||||
|
||||
history = ctx.repo.recent_chat_messages(
|
||||
is_channel=conversation.is_channel,
|
||||
channel_idx=conversation.channel_idx,
|
||||
channel_id=conversation.channel_id,
|
||||
peer=conversation.peer,
|
||||
limit=_HISTORY_LIMIT,
|
||||
)
|
||||
@@ -492,7 +492,11 @@ async def open_chat(ctx: "AppContext", conversation: Conversation) -> int:
|
||||
message = event.message
|
||||
if message is not None and _belongs(message, conversation):
|
||||
peer_name = names.get((message.sender or "").lower())
|
||||
screen.append(ChatMessage.from_message(message, peer_name=peer_name))
|
||||
screen.append(
|
||||
ChatMessage.from_message(
|
||||
message, peer_name=peer_name, channel_id=conversation.channel_id
|
||||
)
|
||||
)
|
||||
|
||||
unsubscribe = ctx.events.subscribe(on_event, EventKind.MESSAGE)
|
||||
try:
|
||||
|
||||
@@ -237,13 +237,15 @@ async def _stage_preset(ctx: AppContext, pending: dict[str, Any]) -> None:
|
||||
"""Pick a standard radio preset and stage all of its fields for review/apply."""
|
||||
from ..core.device_config import RADIO_PRESETS
|
||||
|
||||
items = [
|
||||
items: list = [
|
||||
Choice(
|
||||
title=f"{p.name}: {p.freq} MHz, BW {p.bw}, SF{p.sf}, CR{p.cr} — {p.help}",
|
||||
value=i,
|
||||
)
|
||||
for i, p in enumerate(RADIO_PRESETS)
|
||||
]
|
||||
items.append(Separator(" "))
|
||||
items.append(Choice(title="Back", value=None))
|
||||
idx = await ctx.ui.select("Apply which radio preset?", items)
|
||||
if idx is None:
|
||||
return
|
||||
@@ -303,6 +305,7 @@ async def _danger_zone(ctx: AppContext, device: Any, snapshot: dict) -> bool:
|
||||
Choice("Export private key", value="export_key"),
|
||||
Choice("Import private key", value="import_key"),
|
||||
Choice("Factory reset (erase all)", value="factory_reset"),
|
||||
Separator(" "),
|
||||
Choice("Back", value=None),
|
||||
],
|
||||
)
|
||||
|
||||
@@ -32,6 +32,8 @@ async def prompt_device(
|
||||
ui: "Ui",
|
||||
devices: list[DiscoveredDevice],
|
||||
remembered: Optional[RememberedDevice],
|
||||
*,
|
||||
cancel_label: str = "Skip (use --mock / configure later)",
|
||||
) -> Optional[DiscoveredDevice]:
|
||||
"""Prompt the user to choose a companion device.
|
||||
|
||||
@@ -39,10 +41,12 @@ async def prompt_device(
|
||||
ui: The interactive UI surface used to render the picker.
|
||||
devices: Discovered devices (likely-LoRa first).
|
||||
remembered: The remembered default, if any, used to mark and preselect a row.
|
||||
cancel_label: Label for the final "don't pick" row — "Skip…" at startup (there is
|
||||
no going back yet), "Back" when re-picking from the devices tool.
|
||||
|
||||
Returns:
|
||||
The chosen :class:`DiscoveredDevice`, or ``None`` if the user cancelled or chose to
|
||||
skip device selection (e.g. to run against ``--mock`` / configure later).
|
||||
The chosen :class:`DiscoveredDevice`, or ``None`` if the user cancelled or chose the
|
||||
cancel row (e.g. to run against ``--mock`` / configure later).
|
||||
"""
|
||||
if not devices:
|
||||
await ui.view(
|
||||
@@ -70,6 +74,6 @@ async def prompt_device(
|
||||
default = device
|
||||
|
||||
items.append(Separator(" "))
|
||||
items.append(Choice(title="skip (use --mock / configure later)", value=None))
|
||||
items.append(Choice(title=cancel_label, value=None))
|
||||
|
||||
return await ui.select("Select a companion device:", items, default=default)
|
||||
@@ -9,7 +9,7 @@ arbitrary objects, so the same screen drives the main menu (tool names), the dev
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Any, Optional
|
||||
from typing import Any, Callable, Optional, Union
|
||||
|
||||
from rich.text import Text
|
||||
|
||||
@@ -22,13 +22,26 @@ class Choice:
|
||||
"""One selectable row.
|
||||
|
||||
Attributes:
|
||||
title: Text shown for the row.
|
||||
title: Text shown for the row — a plain string or a Rich :class:`~rich.text.Text`
|
||||
(for a coloured segment such as an unread badge). Either may instead be a
|
||||
zero-argument callable resolved fresh on every repaint, so a row can track state
|
||||
that changes while the list is open.
|
||||
value: Value returned when the row is chosen.
|
||||
"""
|
||||
|
||||
title: str
|
||||
title: Union[str, Text, Callable[[], Union[str, Text]]]
|
||||
value: Any
|
||||
|
||||
@property
|
||||
def label(self) -> Union[str, Text]:
|
||||
"""The row's current text, resolving a callable title on each read."""
|
||||
return self.title() if callable(self.title) else self.title
|
||||
|
||||
|
||||
def _plain(label: Union[str, Text]) -> str:
|
||||
"""The plain-text form of a row label, for filtering (a :class:`Text` keeps its ``plain``)."""
|
||||
return label.plain if isinstance(label, Text) else label
|
||||
|
||||
|
||||
@dataclass
|
||||
class Separator:
|
||||
@@ -93,7 +106,9 @@ class SelectScreen(Screen):
|
||||
return self._items
|
||||
needle = self._filter.lower()
|
||||
return [
|
||||
it for it in self._items if isinstance(it, Choice) and needle in it.title.lower()
|
||||
it
|
||||
for it in self._items
|
||||
if isinstance(it, Choice) and needle in _plain(it.label).lower()
|
||||
]
|
||||
|
||||
def _choices(self, rows: Optional[list] = None) -> list:
|
||||
@@ -120,7 +135,15 @@ class SelectScreen(Screen):
|
||||
is_sel = item is selected
|
||||
pointer = "❯ " if is_sel else " "
|
||||
style = "brand" if is_sel else ""
|
||||
text = Text(pointer + item.title, style=style, no_wrap=True, overflow="ellipsis")
|
||||
label = item.label
|
||||
# A Text label carries its own spans (e.g. a red badge); keep them and lay the
|
||||
# row's base style underneath, so the highlight tints the row while the badge
|
||||
# keeps its colour. A plain string is styled uniformly as before.
|
||||
text = Text(pointer, style=style)
|
||||
text.append_text(label if isinstance(label, Text) else Text(label))
|
||||
text.style = style
|
||||
text.no_wrap = True
|
||||
text.overflow = "ellipsis"
|
||||
text.truncate(width)
|
||||
lines.append(render_to_ansi(text, width))
|
||||
if not choices:
|
||||
|
||||
+45
-1
@@ -18,6 +18,7 @@ from rich.table import Table
|
||||
from rich.text import Text
|
||||
|
||||
from .. import __version__
|
||||
from ..core.channels import is_name_derived, is_public_channel, is_public_name
|
||||
from ..core.models import (
|
||||
LOCAL_DEVICE_LABEL,
|
||||
Contact,
|
||||
@@ -34,6 +35,30 @@ if TYPE_CHECKING:
|
||||
#: Maps a hop's raw key-prefix hash to a display label (a contact name when known).
|
||||
NodeResolver = Callable[[Optional[str]], Optional[str]]
|
||||
|
||||
|
||||
def channel_glyph(name: str, secret: Optional[bytes]) -> str:
|
||||
"""The one-character openness marker for a channel, shared across channel-facing screens.
|
||||
|
||||
``#`` marks a name-derived (``#``-style) channel, ``🌐`` a fixed-key well-known public
|
||||
channel (e.g. the firmware default ``Public``), and ``🔒`` a private one. Every glyph is a
|
||||
single double-width cell, so callers can prefix rows with ``"{glyph} "`` without disturbing
|
||||
column alignment. When the secret is unknown, the name alone is used to guess.
|
||||
|
||||
Args:
|
||||
name: The channel name.
|
||||
secret: The channel's 16-byte secret, or ``None`` when only the name is known.
|
||||
|
||||
Returns:
|
||||
A single-character glyph.
|
||||
"""
|
||||
if secret is None:
|
||||
return "#" if is_public_name(name) else "🔒"
|
||||
if is_name_derived(name, secret):
|
||||
return "#"
|
||||
if is_public_channel(name, secret):
|
||||
return "🌐"
|
||||
return "🔒"
|
||||
|
||||
#: Non-breaking space, used in the route line to keep ``name (hash)`` and a node's
|
||||
#: trailing arrow on the same line so wraps only ever land *after* an arrow.
|
||||
_NBSP = " "
|
||||
@@ -411,6 +436,24 @@ def stats_panel(
|
||||
return Panel(body, title="[accent]trace summary[/accent]", border_style="accent", expand=False)
|
||||
|
||||
|
||||
def _contact_recency_key(contact: Contact) -> tuple:
|
||||
"""Sort key ordering contacts by last-heard time (newest first), then name.
|
||||
|
||||
Contacts with a known ``last_seen`` sort first, most-recent advert at the top; those
|
||||
never heard sort after them, alphabetically. The leading ``0``/``1`` keeps the two
|
||||
groups apart so their differently-typed tie-breakers never compare.
|
||||
|
||||
Args:
|
||||
contact: The contact to rank.
|
||||
|
||||
Returns:
|
||||
A tuple usable as a ``sorted`` key.
|
||||
"""
|
||||
if contact.last_seen is not None:
|
||||
return (0, -contact.last_seen.timestamp())
|
||||
return (1, contact.name.casefold())
|
||||
|
||||
|
||||
def nodes_table(
|
||||
self_name: str,
|
||||
self_key: str,
|
||||
@@ -442,7 +485,8 @@ def nodes_table(
|
||||
highlighted_hash(self_key, prefix_bytes) if self_key else unknown,
|
||||
)
|
||||
table.add_section()
|
||||
for c in contacts:
|
||||
# Most-recently-heard contacts first; those never heard fall to the end, alphabetically.
|
||||
for c in sorted(contacts, key=_contact_recency_key):
|
||||
table.add_row(
|
||||
Text(c.name, style="brand"),
|
||||
highlighted_hash(c.public_key, prefix_bytes) if c.public_key else unknown,
|
||||
|
||||
+67
-1
@@ -17,6 +17,7 @@ from meshtools.context import AppContext
|
||||
from meshtools.core.admin_store import AdminStore
|
||||
from meshtools.core.channels import (
|
||||
CHANNEL_SECRET_BYTES,
|
||||
DEFAULT_PUBLIC_SECRET,
|
||||
channel_hash,
|
||||
derive_secret,
|
||||
full_channel_hash,
|
||||
@@ -29,7 +30,13 @@ from meshtools.core.config import Settings
|
||||
from meshtools.core.device_store import DeviceStore
|
||||
from meshtools.persistence.repository import Repository
|
||||
from meshtools.tools.channels import ChannelsTool
|
||||
from meshtools.ui.channels import ChannelSlot, _apply_order, _next_free_slot, _read_slots
|
||||
from meshtools.services.chat_service import ChatService
|
||||
from meshtools.ui.channels import (
|
||||
ChannelSlot,
|
||||
_apply_order,
|
||||
_next_free_slot,
|
||||
_read_slots,
|
||||
)
|
||||
from meshtools.ui.qr import qr_text
|
||||
|
||||
_ANSI = re.compile(r"\x1b\[[0-9;]*m")
|
||||
@@ -131,8 +138,18 @@ def test_channel_slot_classifies_public_and_private() -> None:
|
||||
assert derived.is_public # key derived from the name, even without a leading #
|
||||
private = ChannelSlot(idx=2, name="Ops", secret=bytes(range(16)))
|
||||
assert not private.is_public
|
||||
assert not private.is_name_derived
|
||||
# The firmware default "Public" is public but keyed by a fixed well-known secret, not by
|
||||
# its name — so it reads as public without being name-derived (its key must be preserved).
|
||||
default_public = ChannelSlot(idx=0, name="Public", secret=DEFAULT_PUBLIC_SECRET)
|
||||
assert default_public.is_public
|
||||
assert not default_public.is_name_derived
|
||||
assert channel_hash(DEFAULT_PUBLIC_SECRET) == "11" # the fingerprint devices report for it
|
||||
assert private.conversation.is_channel and private.conversation.channel_idx == 2
|
||||
assert private.conversation.label == "Ops" # raw name, no forced leading '#'
|
||||
# The conversation is keyed by the channel's identity, not its slot.
|
||||
assert private.conversation.channel_id == private.identity
|
||||
assert private.conversation.key == f"chan:{private.identity}"
|
||||
|
||||
|
||||
def test_next_free_slot_finds_gaps_and_full() -> None:
|
||||
@@ -162,6 +179,55 @@ async def test_apply_order_relays_channels_into_new_positions(ctx: AppContext) -
|
||||
assert after[2].name == "Alpha" and after[2].secret == bytes(range(16))
|
||||
|
||||
|
||||
def test_channel_identity_is_stable_across_slot_moves() -> None:
|
||||
"""A channel's identity depends on its key material, not on which slot it occupies."""
|
||||
at_two = ChannelSlot(idx=2, name="Ops", secret=bytes(range(16)))
|
||||
at_five = ChannelSlot(idx=5, name="Ops", secret=bytes(range(16)))
|
||||
assert at_two.identity == at_five.identity # same channel, different slot → same identity
|
||||
|
||||
other = ChannelSlot(idx=2, name="Ops", secret=bytes(range(16, 32)))
|
||||
assert other.identity != at_two.identity # a different key → a different channel
|
||||
|
||||
|
||||
async def test_reorder_keeps_history_because_key_is_intrinsic(ctx: AppContext) -> None:
|
||||
"""Reordering channels leaves each channel's transcript with it — no migration needed.
|
||||
|
||||
Reproduces the reported bug's setup (a channel moved to a new slot) and asserts the fix:
|
||||
because history is keyed by channel identity rather than slot, the moved channel keeps
|
||||
its own messages and the slot it landed on inherits none.
|
||||
"""
|
||||
device = await ctx.device()
|
||||
await device.set_channel(0, "Alpha", bytes(range(16)))
|
||||
await device.set_channel(1, "Beta", bytes(range(16, 32)))
|
||||
|
||||
chat = ChatService(ctx)
|
||||
await chat.start()
|
||||
try:
|
||||
await chat.send_channel(0, "hello from alpha", label="Alpha")
|
||||
await chat.send_channel(1, "hello from beta", label="Beta")
|
||||
|
||||
slots = await _read_slots(device)
|
||||
before = {s.name: s for s in slots}
|
||||
alpha_id, beta_id = before["Alpha"].identity, before["Beta"].identity
|
||||
|
||||
# Swap the two channels' slots, then refresh the service's slot→identity cache.
|
||||
writes = await _apply_order(device, slots, [1, 0])
|
||||
assert writes == 2
|
||||
await chat.refresh_channels()
|
||||
|
||||
after = {s.name: s for s in await _read_slots(device)}
|
||||
assert after["Alpha"].idx == 1 and after["Beta"].idx == 0 # slots actually swapped
|
||||
assert after["Alpha"].identity == alpha_id # identity is unchanged by the move
|
||||
|
||||
# History still resolves per channel by identity — no transcript was inherited.
|
||||
alpha_msgs = ctx.repo.recent_chat_messages(is_channel=True, channel_id=alpha_id)
|
||||
beta_msgs = ctx.repo.recent_chat_messages(is_channel=True, channel_id=beta_id)
|
||||
assert [m.text for m in alpha_msgs] == ["hello from alpha"]
|
||||
assert [m.text for m in beta_msgs] == ["hello from beta"]
|
||||
finally:
|
||||
await chat.stop()
|
||||
|
||||
|
||||
# -- the tool against the simulator -------------------------------------------
|
||||
|
||||
|
||||
|
||||
+144
-12
@@ -20,6 +20,7 @@ def _strip_ansi(text: str) -> str:
|
||||
"""Remove ANSI color escapes from rendered lines for plain-text assertions."""
|
||||
return _ANSI.sub("", text)
|
||||
|
||||
from meshtools.core.channels import DEFAULT_PUBLIC_SECRET, derive_secret
|
||||
from meshtools.core.connection import MockDevice
|
||||
from meshtools.core.events import MeshEvent
|
||||
from meshtools.core.models import (
|
||||
@@ -32,6 +33,7 @@ from meshtools.core.models import (
|
||||
from meshtools.persistence.repository import Repository
|
||||
from meshtools.services.chat_service import ChatService
|
||||
from meshtools.services.event_hub import EventHub
|
||||
from meshtools.tools.chat import _LiveLasts, _preview, _title
|
||||
from meshtools.ui.chat import ChatScreen
|
||||
from meshtools.ui.tui.screen import CANCEL
|
||||
|
||||
@@ -72,8 +74,8 @@ def repo(tmp_path: Path) -> Repository:
|
||||
|
||||
|
||||
def test_conversation_key_distinguishes_channels_and_directs() -> None:
|
||||
"""Channel and direct keys are stable and case-insensitive on the peer."""
|
||||
assert conversation_key(True, 0, None) == "chan:0"
|
||||
"""Channel keys use the channel's identity; direct keys are case-insensitive on the peer."""
|
||||
assert conversation_key(True, "deadbeef", None) == "chan:deadbeef"
|
||||
assert conversation_key(False, None, "AABBCC") == "dm:aabbcc"
|
||||
|
||||
contact = Contact(name="Alice", public_key="d4e5" + "0" * 60, key_prefix="d4e5f6a7")
|
||||
@@ -81,8 +83,8 @@ def test_conversation_key_distinguishes_channels_and_directs() -> None:
|
||||
assert conv.key == "dm:d4e5f6a7"
|
||||
assert conv.peer == "d4e5f6a7"
|
||||
|
||||
chan = Conversation(label="#public", is_channel=True, channel_idx=2)
|
||||
assert chan.key == "chan:2"
|
||||
chan = Conversation(label="#public", is_channel=True, channel_idx=2, channel_id="deadbeef")
|
||||
assert chan.key == "chan:deadbeef" # keyed by identity, not the slot index
|
||||
assert chan.peer is None
|
||||
|
||||
|
||||
@@ -174,23 +176,152 @@ def test_record_and_load_direct_conversation(repo: Repository) -> None:
|
||||
|
||||
|
||||
def test_record_and_load_channel_conversation(repo: Repository) -> None:
|
||||
"""Channel messages are keyed by slot, isolated from direct messages."""
|
||||
repo.record_chat_message(ChatMessage(text="c0", is_channel=True, channel_idx=0))
|
||||
repo.record_chat_message(ChatMessage(text="c1", is_channel=True, channel_idx=1))
|
||||
"""Channel messages are keyed by channel identity, isolated from direct messages."""
|
||||
repo.record_chat_message(ChatMessage(text="c0", is_channel=True, channel_id="aa00"))
|
||||
repo.record_chat_message(ChatMessage(text="c1", is_channel=True, channel_id="bb11"))
|
||||
|
||||
assert [m.text for m in repo.recent_chat_messages(is_channel=True, channel_idx=0)] == ["c0"]
|
||||
assert [m.text for m in repo.recent_chat_messages(is_channel=True, channel_idx=1)] == ["c1"]
|
||||
assert [m.text for m in repo.recent_chat_messages(is_channel=True, channel_id="aa00")] == ["c0"]
|
||||
assert [m.text for m in repo.recent_chat_messages(is_channel=True, channel_id="bb11")] == ["c1"]
|
||||
|
||||
|
||||
def test_last_chat_messages_returns_latest_per_conversation(repo: Repository) -> None:
|
||||
"""The picker preview shows the newest message in each conversation."""
|
||||
repo.record_chat_message(ChatMessage(text="old", peer="aa"))
|
||||
repo.record_chat_message(ChatMessage(text="new", peer="aa"))
|
||||
repo.record_chat_message(ChatMessage(text="chan", is_channel=True, channel_idx=0))
|
||||
repo.record_chat_message(ChatMessage(text="chan", is_channel=True, channel_id="aa00"))
|
||||
|
||||
lasts = repo.last_chat_messages()
|
||||
assert lasts["dm:aa"].text == "new"
|
||||
assert lasts["chan:0"].text == "chan"
|
||||
assert lasts["chan:aa00"].text == "chan"
|
||||
|
||||
|
||||
# -- picker row rendering -----------------------------------------------------
|
||||
|
||||
|
||||
class _FakeChat:
|
||||
"""Stand-in for the chat service exposing just the unread lookup a row title reads."""
|
||||
|
||||
def __init__(self, unread: dict[str, int]) -> None:
|
||||
self._unread = unread
|
||||
|
||||
def unread(self, key: str) -> int:
|
||||
return self._unread.get(key, 0)
|
||||
|
||||
|
||||
class _RowCtx:
|
||||
"""Minimal ctx exposing only what the picker-row helpers touch (repo + chat)."""
|
||||
|
||||
def __init__(self, repo: Repository, unread: dict[str, int] | None = None) -> None:
|
||||
self.repo = repo
|
||||
self.chat = _FakeChat(unread or {})
|
||||
|
||||
|
||||
def test_live_lasts_refreshes_preview_after_ttl(repo: Repository) -> None:
|
||||
"""A new message becomes visible through _LiveLasts once the cache TTL lapses."""
|
||||
repo.record_chat_message(ChatMessage(text="first", is_channel=True, channel_id="c0"))
|
||||
live = _LiveLasts(_RowCtx(repo), seed=repo.last_chat_messages(), ttl=0) # 0 => always fresh
|
||||
assert live.get("chan:c0").text == "first"
|
||||
repo.record_chat_message(ChatMessage(text="second", is_channel=True, channel_id="c0"))
|
||||
assert live.get("chan:c0").text == "second" # picked up live, not stuck on the seed
|
||||
|
||||
|
||||
def test_live_lasts_serves_seed_within_ttl(repo: Repository) -> None:
|
||||
"""Within the TTL the seeded snapshot is served without re-querying the repository."""
|
||||
live = _LiveLasts(_RowCtx(repo), seed={"chan:c0": ChatMessage(text="seed")}, ttl=999)
|
||||
repo.record_chat_message(ChatMessage(text="later", is_channel=True, channel_id="c0"))
|
||||
assert live.get("chan:c0").text == "seed"
|
||||
|
||||
|
||||
def test_preview_prefixes_own_messages_only() -> None:
|
||||
"""Only outbound messages get a ``you:`` prefix; inbound text is shown verbatim.
|
||||
|
||||
Channel senders are embedded inline in the message text by the firmware, so no author is
|
||||
synthesized (that would double it), and a direct message's author is the row label.
|
||||
"""
|
||||
chan_in = ChatMessage(text="Bob: hi", is_channel=True, channel_idx=0) # sender inline
|
||||
assert _preview(chan_in) == "Bob: hi"
|
||||
dm_in = ChatMessage(text="hey", peer="aa", peer_name="Bob")
|
||||
assert _preview(dm_in) == "hey"
|
||||
mine = ChatMessage(text="yo", outbound=True, is_channel=True, channel_idx=0)
|
||||
assert _preview(mine) == "you: yo"
|
||||
|
||||
|
||||
def test_preview_ellipsizes_long_text() -> None:
|
||||
"""An over-long preview is clipped to the width budget with a trailing ellipsis."""
|
||||
long = ChatMessage(text="x" * 100, is_channel=True, channel_idx=0)
|
||||
out = _preview(long, width=10)
|
||||
assert len(out) == 10 and out.endswith("…")
|
||||
|
||||
|
||||
def test_title_shows_badge_and_author_preview(repo: Repository) -> None:
|
||||
"""A channel row renders its live unread badge and its author-prefixed preview."""
|
||||
conv = Conversation(label="General", is_channel=True, channel_idx=0, channel_id="c0")
|
||||
ctx = _RowCtx(repo, unread={"chan:c0": 3})
|
||||
last = ChatMessage(text="Bob: hi there", is_channel=True, channel_id="c0") # sender inline
|
||||
title = _title(ctx, conv, {"chan:c0": last})
|
||||
line = title.plain # a Text, since there is unread
|
||||
assert line.startswith("🔒 General") # a private channel leads with its openness glyph
|
||||
assert "● 3" in line
|
||||
assert "Bob: hi there" in line
|
||||
|
||||
|
||||
def test_title_reddens_only_the_unread_dot(repo: Repository) -> None:
|
||||
"""With unread the row is a Text whose ``●`` glyph (only) is styled red; else a plain str."""
|
||||
from rich.text import Text
|
||||
|
||||
conv = Conversation(label="General", is_channel=True, channel_idx=0, channel_id="c0")
|
||||
unread = _title(_RowCtx(repo, unread={"chan:c0": 2}), conv, {})
|
||||
assert isinstance(unread, Text)
|
||||
dot = unread.plain.index("●")
|
||||
reddened = [
|
||||
span for span in unread.spans if span.style == "err" and span.start <= dot < span.end
|
||||
]
|
||||
assert reddened and all(span.end - span.start == 1 for span in reddened) # just the glyph
|
||||
|
||||
read = _title(_RowCtx(repo, unread={}), conv, {})
|
||||
assert isinstance(read, str) # no badge -> plain string, no styling
|
||||
|
||||
|
||||
def test_title_preview_column_aligns_regardless_of_label_length(repo: Repository) -> None:
|
||||
"""The preview starts at the same column whether the label is short or (clipped) long."""
|
||||
ctx = _RowCtx(repo)
|
||||
short = Conversation(label="A", is_channel=True, channel_idx=0, channel_id="c0")
|
||||
long = Conversation(label="A much longer channel name here", is_channel=True, channel_idx=1, channel_id="c1")
|
||||
m0 = ChatMessage(text="X: hello", is_channel=True, channel_id="c0")
|
||||
m1 = ChatMessage(text="Y: hello", is_channel=True, channel_id="c1")
|
||||
l0 = _title(ctx, short, {"chan:c0": m0})
|
||||
l1 = _title(ctx, long, {"chan:c1": m1})
|
||||
assert l0.index("X: hello") == l1.index("Y: hello")
|
||||
|
||||
|
||||
def test_title_leads_with_openness_glyph(repo: Repository) -> None:
|
||||
"""Channel rows lead with an openness glyph: # name-derived, 🌐 fixed-key public, 🔒 private."""
|
||||
ctx = _RowCtx(repo)
|
||||
head = lambda conv: _title(ctx, conv, {}).split(" ", 1)[0]
|
||||
named = Conversation(
|
||||
label="#general", is_channel=True, channel_id="c0", secret=derive_secret("#general")
|
||||
)
|
||||
public = Conversation(
|
||||
label="Public", is_channel=True, channel_id="c1", secret=DEFAULT_PUBLIC_SECRET
|
||||
)
|
||||
private = Conversation(
|
||||
label="Ops", is_channel=True, channel_id="c2", secret=bytes(range(16))
|
||||
)
|
||||
assert head(named) == "#"
|
||||
assert head(public) == "🌐"
|
||||
assert head(private) == "🔒"
|
||||
|
||||
|
||||
def test_title_contact_glyph_reflects_conversation_history(repo: Repository) -> None:
|
||||
"""A contact shows 💬 once we've exchanged messages, 👤 before any conversation exists."""
|
||||
ctx = _RowCtx(repo)
|
||||
contact = Conversation(
|
||||
label="Alice", is_channel=False, contact=Contact(name="Alice", public_key="d4" + "0" * 62)
|
||||
)
|
||||
head = lambda lasts: _title(ctx, contact, lasts).split(" ", 1)[0]
|
||||
assert head({}) == "👤" # no history yet — a contact we haven't talked to
|
||||
last = ChatMessage(text="hi", peer=contact.peer)
|
||||
assert head({contact.key: last}) == "💬" # we've exchanged messages
|
||||
|
||||
|
||||
# -- chat service -------------------------------------------------------------
|
||||
@@ -430,7 +561,8 @@ async def test_service_send_records_outbound(repo: Repository) -> None:
|
||||
assert sent.outbound is True and sent.acked is True
|
||||
|
||||
await chat.send_channel(0, "hello all", label="#public")
|
||||
stored = repo.recent_chat_messages(is_channel=True, channel_idx=0)
|
||||
channel_id = await chat.channel_id_for(0)
|
||||
stored = repo.recent_chat_messages(is_channel=True, channel_id=channel_id)
|
||||
assert [m.text for m in stored] == ["hello all"]
|
||||
assert stored[0].outbound is True
|
||||
finally:
|
||||
|
||||
@@ -116,6 +116,23 @@ def test_select_cursor_line_tracks_selection() -> None:
|
||||
assert screen.cursor_line() == 2
|
||||
|
||||
|
||||
def test_select_callable_title_re_renders_live() -> None:
|
||||
"""A callable title is resolved on every repaint, so a live badge tracks state."""
|
||||
unread = {"n": 0}
|
||||
screen = SelectScreen("pick", [Choice(lambda: f"chan ● {unread['n']}", 1)])
|
||||
assert "chan ● 0" in "\n".join(screen.render_body(40))
|
||||
unread["n"] = 3 # a message arrived while the list is open
|
||||
assert "chan ● 3" in "\n".join(screen.render_body(40))
|
||||
|
||||
|
||||
def test_select_filter_matches_callable_title() -> None:
|
||||
"""Type-to-filter matches against a callable title's current text."""
|
||||
screen = SelectScreen("pick", [Choice(lambda: "alpha", 1), Choice("beta", 2)])
|
||||
screen.handle("text", "alp")
|
||||
assert [r.label for r in screen._rows()] == ["alpha"]
|
||||
assert _run(screen, "enter") == 1
|
||||
|
||||
|
||||
# --- scroll ------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
Reference in new issue
Block a user