mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-11 13:27:48 +01:00
Krzysztof kuhy Rudnicki
a202317072
A "!cat" in a busy group produced a cat picture floating loose in the chat with
nothing tying it to whoever asked. Replies now quote the triggering message.
The container advertises this and always could: /v1/about reports
capabilities {"v2/send": ["quotes", "mentions"]}, and /v2/send takes
quote_timestamp, quote_author and quote_message. What was missing was on this
side -- parse_envelope discarded the envelope's timestamp, which is the id
Signal quotes a message by, so nothing downstream could have built a quote even
in principle. IncomingMessage now carries it, preferring the payload's own
value over the envelope's for the case where they ever disagree.
Quote is a value object rather than three more parameters threaded through
every send: the Transport protocol has five methods and two of them send.
CommandContext grows reply_image() so quoting lives in one place instead of
each handler reaching for ctx.transport itself, which is what animals.py did.
quote_of() returns None when the timestamp or author is missing. Answering the
room is a worse reply than a quoted one but a much better outcome than a
payload the container rejects.
The e2e gate learned to tell the two apart: Expectation.quotes demands a send
either does or does not point at a message, defaulting to None so the ten
existing scenarios stay indifferent. Without it the fake would have accepted an
unquoted reply as a pass.
Verified in the testbot group on a real Signal client before this bump, per
kuhy's rule that a bump is a publish rather than a checkpoint: he sent !cat and
confirmed the picture renders attached to his message as a reply.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015d48t4qsQLBJnDwDeo2Nom
108 lines
3.5 KiB
Python
108 lines
3.5 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""Command lookup: trigger words to handlers.
|
|
|
|
Reimplements the idea behind the unmerged ``rules.py`` branch: triggers are
|
|
data, not a chain of if-statements, so aliases (including the Unicode-styled
|
|
ones people actually type) cost one tuple entry each.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Awaitable, Callable, Iterable
|
|
from dataclasses import dataclass
|
|
from typing import TYPE_CHECKING
|
|
|
|
from signal_bot.quoting import quote_of
|
|
|
|
if TYPE_CHECKING:
|
|
from signal_bot.config import Config
|
|
from signal_bot.models import IncomingMessage
|
|
from signal_bot.store import Store
|
|
from signal_bot.transport_base import Transport
|
|
|
|
COMMAND_PREFIX = "!"
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class CommandContext:
|
|
"""Everything a command handler is allowed to touch."""
|
|
|
|
message: IncomingMessage
|
|
group_id: str
|
|
transport: Transport
|
|
store: Store
|
|
config: Config
|
|
command_name: str
|
|
now: float
|
|
day: str
|
|
|
|
async def reply(self, text: str) -> None:
|
|
"""Answer the message that triggered this command, in its group.
|
|
|
|
There is no configurable reply target. A command answers where it
|
|
was asked, which is the only routing that stays correct once the
|
|
bot watches a test group and a production group at once -- and it
|
|
quotes the asker, so a busy group can tell which "!cat" this is.
|
|
"""
|
|
await self.transport.send_text(text, self.group_id, quote_of(self.message))
|
|
|
|
async def reply_image(self, image_base64: str) -> None:
|
|
"""Answer the triggering message with an image, quoting it."""
|
|
await self.transport.send_image(image_base64, self.group_id, quote_of(self.message))
|
|
|
|
|
|
Handler = Callable[[CommandContext], Awaitable[None]]
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class Command:
|
|
"""A named command and every phrase that triggers it."""
|
|
|
|
name: str
|
|
triggers: frozenset[str]
|
|
handler: Handler
|
|
|
|
|
|
class DuplicateTriggerError(ValueError):
|
|
"""Raised when two commands claim the same trigger word."""
|
|
|
|
|
|
class CommandRegistry:
|
|
"""Maps trigger words to commands."""
|
|
|
|
def __init__(self) -> None:
|
|
"""Start with no commands registered."""
|
|
self._by_trigger: dict[str, Command] = {}
|
|
self._commands: list[Command] = []
|
|
|
|
def register(self, name: str, triggers: Iterable[str], handler: Handler) -> Command:
|
|
"""Register one command under every one of its triggers.
|
|
|
|
Raises:
|
|
DuplicateTriggerError: A trigger is already claimed.
|
|
"""
|
|
normalised = frozenset(t.strip().lower() for t in triggers)
|
|
for trigger in sorted(normalised):
|
|
if trigger in self._by_trigger:
|
|
msg = f"trigger {trigger!r} is already registered"
|
|
raise DuplicateTriggerError(msg)
|
|
command = Command(name=name, triggers=normalised, handler=handler)
|
|
for trigger in normalised:
|
|
self._by_trigger[trigger] = command
|
|
self._commands.append(command)
|
|
return command
|
|
|
|
def resolve(self, text: str | None) -> Command | None:
|
|
"""Return the command a message body triggers, or None."""
|
|
if not text:
|
|
return None
|
|
candidate = text.strip().lower()
|
|
if not candidate.startswith(COMMAND_PREFIX):
|
|
return None
|
|
return self._by_trigger.get(candidate)
|
|
|
|
@property
|
|
def commands(self) -> list[Command]:
|
|
"""Every registered command, in registration order."""
|
|
return list(self._commands)
|