mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-10 18:07:29 +01:00
Krzysztof kuhy Rudnicki
6bde3493a4
The bot did not work. `run.sh` started a FastAPI app whose
`@app.on_event("startup")` awaited `asyncio.gather()` on two infinite
tasks, so uvicorn never finished starting up and no HTTP was ever served;
the readme's `python main.py` was a no-op with no `__main__` block and no
`uvicorn.run()` call. All three CI workflows were red, one referencing an
`environment.yml` that does not exist.
Rewritten as a package behind an injectable transport seam, which is what
makes the offline environment possible.
Bugs fixed:
- startup deadlock: lifespan spawns the loops instead of awaiting them
- sticker filter read dataMessage.sticker even on syncMessage envelopes, so
the account's own stickers were never filtered (e038772, 53028cc, 07fa90d,
2416cef all fought this symptom)
- no websocket reconnect: a container restart killed the bot silently
- blocking `requests` inside async functions stalled the event loop
- every counted message DMed the whole tally to the bot itself
- images were written to CWD under a filename taken from the remote URL
- one global 10s cooldown shared across all users and commands
- dead code: RECEIVE_URL, get_attachments (no call site), USER_MESSAGE_COUNT
- .env.sample declared PRIMARY/SECONDARY_PHONE_NUMBER and MODE, none read
Scoping is now an enforced invariant. A linked device receives every DM and
every group on the account; GROUP_ID was the only thing narrowing that and
defaulted to "". Config refuses to start unscoped, direct messages are
dropped explicitly rather than by a falsy check, and a scenario asserts that
DMs and other groups produce zero outbound messages.
Offline environment: fake_signal/ serves the real protocol surface, so the
unmodified bot connects to it by pointing API_BASE_URL at it. scripts/e2e.sh
boots both, replays 7 scenarios and exits non-zero on mismatch. A local
Signal server is not achievable (signal-cli compiles its endpoints and trust
store in; Signal-Server needs FoundationDB), so faking this boundary is the
only way to test every feature without an account.
Transport pinned to bbernhard/signal-cli-rest-api:0.100 with
MODE=json-rpc-native. The readme pinned 0.167-dev; the dev tag series counts
separately, so that was older than 0.100, not newer. /v1/receive is only a
WebSocket in a json-rpc mode, so the mode is verified at startup.
Repo standards: ruff select=ALL, mypy --strict, 189 tests at 100% branch
coverage, 250-line cap, exact pins at newest stable, shared gates delegated
to ~/utils, one CI workflow replacing three red ones. No noqa, no
type: ignore, no coverage omits anywhere.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013yaBT45KhHqxTKVCTA87iy
106 lines
3.3 KiB
Python
106 lines
3.3 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""Parsing of signal-cli-rest-api envelopes into a flat, typed message."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from dataclasses import dataclass
|
|
from typing import Any
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class IncomingMessage:
|
|
"""One inbound Signal message, normalised across envelope shapes.
|
|
|
|
signal-cli reports messages from other people under ``dataMessage`` and
|
|
the account's own outgoing messages under ``syncMessage.sentMessage``.
|
|
The two carry the same fields at different depths; everything downstream
|
|
works on this flattened form instead of re-deriving the nesting.
|
|
"""
|
|
|
|
source_uuid: str
|
|
source_name: str
|
|
group_id: str | None
|
|
text: str | None
|
|
has_sticker: bool
|
|
is_reaction: bool
|
|
|
|
@property
|
|
def is_direct_message(self) -> bool:
|
|
"""True when the message did not arrive via a group.
|
|
|
|
A linked device receives every direct conversation on the account, so
|
|
this is the discriminator that keeps the bot scoped to its group.
|
|
"""
|
|
return self.group_id is None
|
|
|
|
|
|
def _payload(envelope: dict[str, Any]) -> dict[str, Any] | None:
|
|
"""Return the dataMessage or sentMessage body, whichever is present."""
|
|
data = envelope.get("dataMessage")
|
|
if isinstance(data, dict):
|
|
return data
|
|
sync = envelope.get("syncMessage")
|
|
if isinstance(sync, dict):
|
|
sent = sync.get("sentMessage")
|
|
if isinstance(sent, dict):
|
|
return sent
|
|
return None
|
|
|
|
|
|
def _group_id(payload: dict[str, Any]) -> str | None:
|
|
"""Return the group id, or None for a direct message."""
|
|
info = payload.get("groupInfo")
|
|
if not isinstance(info, dict):
|
|
return None
|
|
group_id = info.get("groupId")
|
|
if not isinstance(group_id, str) or not group_id:
|
|
return None
|
|
return group_id
|
|
|
|
|
|
def _text(payload: dict[str, Any]) -> str | None:
|
|
"""Return the message body, or None when there is no text."""
|
|
message = payload.get("message")
|
|
if not isinstance(message, str):
|
|
return None
|
|
return message
|
|
|
|
|
|
def parse_envelope(raw: str | bytes) -> IncomingMessage | None:
|
|
"""Parse one raw websocket frame.
|
|
|
|
Args:
|
|
raw: The JSON frame exactly as received.
|
|
|
|
Returns:
|
|
The normalised message, or None when the frame carries no message
|
|
body at all (receipts, typing indicators, malformed JSON).
|
|
"""
|
|
try:
|
|
decoded = json.loads(raw)
|
|
except json.JSONDecodeError, UnicodeDecodeError:
|
|
return None
|
|
if not isinstance(decoded, dict):
|
|
return None
|
|
|
|
envelope = decoded.get("envelope")
|
|
if not isinstance(envelope, dict):
|
|
return None
|
|
|
|
payload = _payload(envelope)
|
|
if payload is None:
|
|
return None
|
|
|
|
return IncomingMessage(
|
|
source_uuid=str(envelope.get("sourceUuid", "")),
|
|
source_name=str(envelope.get("sourceName", "")),
|
|
group_id=_group_id(payload),
|
|
text=_text(payload),
|
|
# The original bot looked for the sticker under dataMessage even when
|
|
# the envelope was a syncMessage, so its own stickers were never
|
|
# filtered. Reading it off the resolved payload fixes both shapes.
|
|
has_sticker=isinstance(payload.get("sticker"), dict),
|
|
is_reaction=isinstance(payload.get("reaction"), dict),
|
|
)
|