mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-10 19:27:20 +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
82 lines
2.7 KiB
Python
82 lines
2.7 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""Drive a running fake server through a scenario, and adjudicate the result.
|
|
|
|
Exits non-zero on any mismatch, so scripts/e2e.sh is a real gate rather than
|
|
a log to read.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import asyncio
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import httpx
|
|
|
|
from fake_signal.scenario import Scenario, check, load_scenario
|
|
|
|
SETTLE_SECONDS = 0.35
|
|
|
|
|
|
def _emit(line: str) -> None:
|
|
"""Write one report line to stdout."""
|
|
sys.stdout.write(f"{line}\n")
|
|
|
|
|
|
def _groups(args: argparse.Namespace) -> dict[str, str]:
|
|
"""Map the scenario's symbolic group names onto real ids."""
|
|
return {"watched": args.group_id, "reply": args.group_id_send, "other": args.other_group}
|
|
|
|
|
|
async def run_scenario(
|
|
base_url: str, scenario: Scenario, groups: dict[str, str], *, settle: float
|
|
) -> list[str]:
|
|
"""Inject every frame, wait for the bot to react, then compare."""
|
|
async with httpx.AsyncClient(base_url=base_url, timeout=10.0) as client:
|
|
await client.post("/_control/reset")
|
|
for injection in scenario.inject:
|
|
await client.post("/_control/inject", json={"raw": injection.to_frame(groups)})
|
|
await asyncio.sleep(settle)
|
|
response = await client.get("/_control/sent")
|
|
response.raise_for_status()
|
|
return check(scenario, response.json(), groups)
|
|
|
|
|
|
def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
|
|
"""Parse the injector's command line."""
|
|
parser = argparse.ArgumentParser(description="Replay a scenario against the bot.")
|
|
parser.add_argument("scenarios", nargs="+", type=Path)
|
|
parser.add_argument("--base-url", default="http://127.0.0.1:8099")
|
|
parser.add_argument("--group-id", required=True)
|
|
parser.add_argument("--group-id-send", required=True)
|
|
parser.add_argument("--other-group", default="group-other==")
|
|
parser.add_argument("--settle", type=float, default=SETTLE_SECONDS)
|
|
return parser.parse_args(argv)
|
|
|
|
|
|
async def _main_async(args: argparse.Namespace) -> int:
|
|
"""Run every scenario, reporting failures as they happen."""
|
|
groups = _groups(args)
|
|
failed = 0
|
|
for path in args.scenarios:
|
|
scenario = load_scenario(path)
|
|
failures = await run_scenario(args.base_url, scenario, groups, settle=args.settle)
|
|
if failures:
|
|
failed += 1
|
|
_emit(f"FAIL {scenario.name}")
|
|
for line in failures:
|
|
_emit(f" {line}")
|
|
else:
|
|
_emit(f"ok {scenario.name}")
|
|
return 1 if failed else 0
|
|
|
|
|
|
def main(argv: list[str] | None = None) -> int:
|
|
"""Entry point. Returns a process exit code."""
|
|
return asyncio.run(_main_async(parse_args(argv)))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|