mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-10 18:17:02 +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.7 KiB
Python
80 lines
2.7 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""The endpoints the real signal-cli-rest-api exposes."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
from fastapi import APIRouter, Request, WebSocket, WebSocketDisconnect
|
|
from fastapi.responses import JSONResponse, Response
|
|
|
|
from fake_signal.state import PIXEL_PNG, State
|
|
|
|
|
|
def _state(request: Request) -> State:
|
|
"""Return the State attached to the running app."""
|
|
state: State = request.app.state.fake
|
|
return state
|
|
|
|
|
|
def build_api_router() -> APIRouter:
|
|
"""Build the router mirroring the real container's API."""
|
|
router = APIRouter()
|
|
|
|
@router.get("/v1/about")
|
|
async def about(request: Request) -> dict[str, Any]:
|
|
return {"build": 2, "mode": _state(request).mode, "versions": ["v1", "v2"]}
|
|
|
|
@router.get("/v1/qrcodelink")
|
|
async def qrcodelink(device_name: str = "signal-api") -> Response:
|
|
# The real endpoint returns a PNG, which is why the live runbook has
|
|
# to open an image rather than print a string.
|
|
return Response(
|
|
content=PIXEL_PNG,
|
|
media_type="image/png",
|
|
headers={"X-Device-Name": device_name},
|
|
)
|
|
|
|
@router.post("/v2/send")
|
|
async def send(request: Request, payload: dict[str, Any]) -> JSONResponse:
|
|
_state(request).record_send(payload)
|
|
return JSONResponse({"timestamp": 1719177917717}, status_code=201)
|
|
|
|
@router.get("/v1/attachments")
|
|
async def list_attachments(request: Request) -> list[str]:
|
|
return list(_state(request).attachments)
|
|
|
|
@router.delete("/v1/attachments/{attachment_id}")
|
|
async def delete_attachment(request: Request, attachment_id: str) -> Response:
|
|
attachments = _state(request).attachments
|
|
if attachment_id in attachments:
|
|
attachments.remove(attachment_id)
|
|
return Response(status_code=204)
|
|
|
|
_add_receive_route(router)
|
|
|
|
return router
|
|
|
|
|
|
def _add_receive_route(router: APIRouter) -> None:
|
|
"""Attach the WebSocket receive endpoint.
|
|
|
|
Split out so the router builder stays under the complexity cap.
|
|
"""
|
|
|
|
@router.websocket("/v1/receive/{number}")
|
|
async def receive(websocket: WebSocket, number: str) -> None:
|
|
state: State = websocket.app.state.fake
|
|
await websocket.accept()
|
|
await websocket.send_json({"envelope": {"subscribed": number}})
|
|
state.sockets.append(websocket)
|
|
try:
|
|
while True:
|
|
# Blocks until the client goes away. The bot never sends.
|
|
await websocket.receive_text()
|
|
except WebSocketDisconnect:
|
|
pass
|
|
finally:
|
|
# Branchless: a conditional remove leaves an arc no test can reach.
|
|
state.sockets[:] = [s for s in state.sockets if s is not websocket]
|