mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-21 22:12:30 +01:00
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
134 lines
4.7 KiB
Python
134 lines
4.7 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""Runtime configuration, read once from the environment and validated eagerly."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
from dataclasses import dataclass
|
|
from typing import Final
|
|
from urllib.parse import urlsplit, urlunsplit
|
|
|
|
from dotenv import load_dotenv
|
|
|
|
DEFAULT_API_BASE_URL: Final = "http://localhost:9922"
|
|
DEFAULT_DATABASE_PATH: Final = "signal_bot.sqlite3"
|
|
DEFAULT_REPORT_HOUR: Final = 21
|
|
DEFAULT_REPORT_MINUTE: Final = 37
|
|
DEFAULT_COOLDOWN_SECONDS: Final = 10
|
|
DEFAULT_CAT_API_URL: Final = "https://api.thecatapi.com/v1/images/search"
|
|
DEFAULT_DOG_API_URL: Final = "https://dog.ceo/api/breeds/image/random"
|
|
MAX_HOUR: Final = 23
|
|
MAX_MINUTE: Final = 59
|
|
|
|
_WS_SCHEMES: Final = {"http": "ws", "https": "wss"}
|
|
|
|
|
|
class ConfigError(RuntimeError):
|
|
"""Raised when the environment does not describe a runnable bot."""
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class Config:
|
|
"""Everything the bot needs to know, resolved and validated."""
|
|
|
|
phone_number: str
|
|
group_id: str
|
|
group_id_send: str
|
|
api_base_url: str = DEFAULT_API_BASE_URL
|
|
database_path: str = DEFAULT_DATABASE_PATH
|
|
report_hour: int = DEFAULT_REPORT_HOUR
|
|
report_minute: int = DEFAULT_REPORT_MINUTE
|
|
cooldown_seconds: int = DEFAULT_COOLDOWN_SECONDS
|
|
# Overridable so the offline environment can serve fixture images
|
|
# without the bot knowing it is not talking to the real APIs.
|
|
cat_api_url: str = DEFAULT_CAT_API_URL
|
|
dog_api_url: str = DEFAULT_DOG_API_URL
|
|
|
|
@property
|
|
def receive_url(self) -> str:
|
|
"""WebSocket URL the bot subscribes to for incoming envelopes."""
|
|
parts = urlsplit(self.api_base_url)
|
|
scheme = _WS_SCHEMES.get(parts.scheme, parts.scheme)
|
|
path = f"/v1/receive/{self.phone_number}"
|
|
query = "send_read_receipts=false"
|
|
return urlunsplit((scheme, parts.netloc, path, query, ""))
|
|
|
|
@property
|
|
def send_url(self) -> str:
|
|
"""REST endpoint for outgoing messages and attachments."""
|
|
return f"{self.api_base_url}/v2/send"
|
|
|
|
@property
|
|
def attachments_url(self) -> str:
|
|
"""REST endpoint listing server-side stored attachments."""
|
|
return f"{self.api_base_url}/v1/attachments"
|
|
|
|
@property
|
|
def about_url(self) -> str:
|
|
"""REST endpoint reporting the container build and its mode."""
|
|
return f"{self.api_base_url}/v1/about"
|
|
|
|
|
|
def _require(env: dict[str, str], key: str) -> str:
|
|
"""Return a non-empty environment value or raise ConfigError."""
|
|
value = env.get(key, "").strip()
|
|
if not value:
|
|
msg = (
|
|
f"{key} is required and must not be empty. "
|
|
"A linked Signal device sees every chat on the account, so the bot "
|
|
"refuses to start without an explicit group to scope itself to."
|
|
)
|
|
raise ConfigError(msg)
|
|
return value
|
|
|
|
|
|
def _positive_int(env: dict[str, str], key: str, default: int) -> int:
|
|
"""Return an int environment value, falling back to default when unset."""
|
|
raw = env.get(key, "").strip()
|
|
if not raw:
|
|
return default
|
|
try:
|
|
value = int(raw)
|
|
except ValueError:
|
|
msg = f"{key} must be an integer, got {raw!r}"
|
|
raise ConfigError(msg) from None
|
|
if value < 0:
|
|
msg = f"{key} must not be negative, got {value}"
|
|
raise ConfigError(msg)
|
|
return value
|
|
|
|
|
|
def load_config(env: dict[str, str] | None = None, *, use_dotenv: bool = True) -> Config:
|
|
"""Build a Config from the environment, failing loudly on anything missing.
|
|
|
|
Args:
|
|
env: Mapping to read instead of os.environ. Used by the tests.
|
|
use_dotenv: Load a local .env file first. Disabled in tests.
|
|
|
|
Returns:
|
|
A validated, immutable Config.
|
|
"""
|
|
if env is None:
|
|
if use_dotenv:
|
|
load_dotenv()
|
|
env = dict(os.environ)
|
|
|
|
hour = _positive_int(env, "REPORT_HOUR", DEFAULT_REPORT_HOUR)
|
|
minute = _positive_int(env, "REPORT_MINUTE", DEFAULT_REPORT_MINUTE)
|
|
if hour > MAX_HOUR or minute > MAX_MINUTE:
|
|
msg = f"REPORT_HOUR/REPORT_MINUTE out of range: {hour:02d}:{minute:02d}"
|
|
raise ConfigError(msg)
|
|
|
|
return Config(
|
|
phone_number=_require(env, "PHONE_NUMBER"),
|
|
group_id=_require(env, "GROUP_ID"),
|
|
group_id_send=_require(env, "GROUP_ID_SEND"),
|
|
api_base_url=env.get("API_BASE_URL", "").strip() or DEFAULT_API_BASE_URL,
|
|
database_path=env.get("DATABASE_PATH", "").strip() or DEFAULT_DATABASE_PATH,
|
|
report_hour=hour,
|
|
report_minute=minute,
|
|
cooldown_seconds=_positive_int(env, "COOLDOWN_SECONDS", DEFAULT_COOLDOWN_SECONDS),
|
|
cat_api_url=env.get("CAT_API_URL", "").strip() or DEFAULT_CAT_API_URL,
|
|
dog_api_url=env.get("DOG_API_URL", "").strip() or DEFAULT_DOG_API_URL,
|
|
)
|