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
80 lines
2.8 KiB
Python
80 lines
2.8 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""Reusable gates that wrap a command handler.
|
|
|
|
These are the mechanisms salvaged from the unmerged vote and rate-limit
|
|
branches, detached from the NSFW command they were originally written for.
|
|
They only decide whether a handler may run; recording a successful use is the
|
|
dispatcher's job, so stacking two gates cannot double-count one invocation.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import functools
|
|
from collections.abc import Callable
|
|
|
|
from signal_bot.registry import CommandContext, Handler
|
|
|
|
Decorator = Callable[[Handler], Handler]
|
|
|
|
|
|
def cooldown(seconds: float, message: str) -> Decorator:
|
|
"""Refuse a command until `seconds` have passed since that user's last use.
|
|
|
|
The original bot shared one cooldown window across every user and every
|
|
command, so one person's cat picture silenced everybody.
|
|
"""
|
|
|
|
def decorate(handler: Handler) -> Handler:
|
|
@functools.wraps(handler)
|
|
async def wrapper(ctx: CommandContext) -> None:
|
|
last = ctx.store.last_used(ctx.message.source_uuid, ctx.command_name)
|
|
if last is not None and ctx.now - last < seconds:
|
|
remaining = seconds - (ctx.now - last)
|
|
await ctx.reply(message.format(seconds=int(remaining) + 1))
|
|
return
|
|
await handler(ctx)
|
|
|
|
return wrapper
|
|
|
|
return decorate
|
|
|
|
|
|
def daily_limit(max_uses: int, message: str) -> Decorator:
|
|
"""Allow a command at most `max_uses` times per user per calendar day."""
|
|
|
|
def decorate(handler: Handler) -> Handler:
|
|
@functools.wraps(handler)
|
|
async def wrapper(ctx: CommandContext) -> None:
|
|
used = ctx.store.uses_today(ctx.message.source_uuid, ctx.command_name, ctx.day)
|
|
if used >= max_uses:
|
|
await ctx.reply(message.format(max_uses=max_uses, used=used))
|
|
return
|
|
await handler(ctx)
|
|
|
|
return wrapper
|
|
|
|
return decorate
|
|
|
|
|
|
def vote_gated(required: int, window_seconds: float, message: str) -> Decorator:
|
|
"""Run a command only once `required` distinct people ask within a window.
|
|
|
|
A repeat vote from the same person is ignored, and the tally is cleared
|
|
once the command fires so the next run starts from zero.
|
|
"""
|
|
|
|
def decorate(handler: Handler) -> Handler:
|
|
@functools.wraps(handler)
|
|
async def wrapper(ctx: CommandContext) -> None:
|
|
ctx.store.add_vote(ctx.command_name, ctx.message.source_uuid, ctx.now)
|
|
votes = ctx.store.count_votes(ctx.command_name, ctx.now - window_seconds)
|
|
if votes < required:
|
|
await ctx.reply(message.format(votes=votes, required=required))
|
|
return
|
|
ctx.store.clear_votes(ctx.command_name)
|
|
await handler(ctx)
|
|
|
|
return wrapper
|
|
|
|
return decorate
|