mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-10 19: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
88 lines
2.9 KiB
Python
88 lines
2.9 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""Outbound HTTP for the image commands.
|
|
|
|
Every outbound request goes through this one injectable client, so the tests
|
|
and the offline environment can serve fixtures without the bot knowing.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
from typing import TYPE_CHECKING, Final
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Sequence
|
|
|
|
import httpx
|
|
|
|
|
|
class ImageFetchError(RuntimeError):
|
|
"""Raised when an upstream image API did not yield a usable image."""
|
|
|
|
|
|
class ImageFetcher:
|
|
"""Resolves an image URL from a JSON API and returns it base64-encoded."""
|
|
|
|
def __init__(self, client: httpx.AsyncClient) -> None:
|
|
"""Store the injected HTTP client."""
|
|
self._client = client
|
|
|
|
async def fetch_base64(self, api_url: str, url_path: Sequence[str | int]) -> str:
|
|
"""Fetch an image and return it as base64.
|
|
|
|
Args:
|
|
api_url: JSON endpoint that names an image.
|
|
url_path: Keys/indices to walk in the JSON to reach the image URL.
|
|
|
|
Returns:
|
|
The image bytes, base64-encoded.
|
|
|
|
Raises:
|
|
ImageFetchError: The JSON did not contain a usable URL.
|
|
"""
|
|
response = await self._client.get(api_url)
|
|
response.raise_for_status()
|
|
image_url = _walk(response.json(), url_path)
|
|
|
|
# Never written to disk: the original bot named a local file after the
|
|
# remote URL's last path segment and wrote it into the process CWD.
|
|
image = await self._client.get(image_url)
|
|
image.raise_for_status()
|
|
return base64.b64encode(image.content).decode("ascii")
|
|
|
|
|
|
_MISSING: Final = object()
|
|
|
|
|
|
def _in_range(items: list[object], index: int) -> bool:
|
|
"""True when index addresses a real element, counting from either end."""
|
|
return -len(items) <= index < len(items)
|
|
|
|
|
|
def _step(node: object, key: str | int, path: Sequence[str | int]) -> object:
|
|
"""Descend one level into a JSON document.
|
|
|
|
Narrows explicitly instead of indexing blindly, so a malformed upstream
|
|
response raises ImageFetchError rather than a TypeError from deeper in.
|
|
"""
|
|
found: object = _MISSING
|
|
if isinstance(key, str) and isinstance(node, dict):
|
|
found = node.get(key, _MISSING)
|
|
elif isinstance(key, int) and isinstance(node, list) and _in_range(node, key):
|
|
found = node[key]
|
|
if found is _MISSING:
|
|
msg = f"image API response has no element at {path!r}"
|
|
raise ImageFetchError(msg)
|
|
return found
|
|
|
|
|
|
def _walk(document: object, path: Sequence[str | int]) -> str:
|
|
"""Walk a JSON document along path and return the string found there."""
|
|
node: object = document
|
|
for key in path:
|
|
node = _step(node, key, path)
|
|
if not isinstance(node, str) or not node:
|
|
msg = f"image API element at {path!r} is not a URL: {node!r}"
|
|
raise ImageFetchError(msg)
|
|
return node
|