mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-22 16:12:37 +01:00
Some checks are pending
CI / check (push) Waiting to run
Adds !papież / !papiez / !pope: a random pope as a photo, captioned with his Latin name, reign and pl.wikipedia link. popes.json already carried a Commons portrait filename for all 267 and nothing had ever consumed it. The Latin name comes from the Latin column of Poczet papieży, not from the la.wikipedia sitelink. The sitelink resolved for all 267 and was still wrong: la.wikipedia numbers several popes differently, so #154 came out as "Stefan IX — Stephanus X" in a single caption, which reads as an off-by-one. The table's own column says "Stephanus Nonus" and cannot disagree with the name beside it. LATIN_OVERRIDES ships empty; it is a tripwire, not a backlog. Portraits are cached on disk under CacheDirectory=signal-bot, named from the ordinal so no upstream string ever reaches a path, and bounded at 267 entries so nothing needs evicting. Verified that CacheDirectory wins against ProtectHome=read-only before relying on it. Also adds POST /_selftest and scripts/selftest.sh. Signal never delivers an account its own sends, so no command has ever been exercised end-to-end without asking a human to type it. This injects a real frame into the live dispatcher; it is loopback-only and refuses any group not in SELFTEST_GROUPS, which is empty by default. Verified against the real endpoints, not just the fake: 267/267 portraits resolve on Commons, regeneration is byte-identical on every previously shipped field, and !papież was driven 7 times through the live dispatcher in testbot, returning distinct popes. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015d48t4qsQLBJnDwDeo2Nom
165 lines
6.3 KiB
Python
165 lines
6.3 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""Transport adapter for bbernhard/signal-cli-rest-api.
|
|
|
|
Receive is a WebSocket, which the container only exposes when it runs in one
|
|
of the json-rpc modes; in normal/native mode the same path silently degrades
|
|
to a polling GET, so the mode is verified at startup rather than assumed.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
from collections.abc import AsyncIterator, Awaitable, Callable
|
|
from typing import TYPE_CHECKING, Any, Final
|
|
|
|
from websockets.asyncio.client import connect as ws_connect
|
|
from websockets.exceptions import WebSocketException
|
|
|
|
if TYPE_CHECKING:
|
|
import httpx
|
|
|
|
from signal_bot.config import Config
|
|
from signal_bot.quoting import Quote
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
INITIAL_BACKOFF: Final = 1.0
|
|
MAX_BACKOFF: Final = 30.0
|
|
# Exactly this mode. See verify_mode for why "json-rpc-native" is not enough.
|
|
REQUIRED_MODE: Final = "json-rpc"
|
|
BACKOFF_FACTOR: Final = 2.0
|
|
_OK_STATUSES: Final = frozenset({200, 201, 204})
|
|
|
|
Connector = Callable[[str], Any]
|
|
Sleeper = Callable[[float], Awaitable[None]]
|
|
|
|
|
|
class TransportError(RuntimeError):
|
|
"""Raised when the Signal REST API rejects a request."""
|
|
|
|
|
|
class RestTransport:
|
|
"""Talks to the signal-cli-rest-api container over REST plus a WebSocket."""
|
|
|
|
def __init__(
|
|
self,
|
|
config: Config,
|
|
client: httpx.AsyncClient,
|
|
*,
|
|
connector: Connector | None = None,
|
|
sleeper: Sleeper | None = None,
|
|
max_reconnects: int | None = None,
|
|
) -> None:
|
|
"""Wire the adapter to its config and its injectable I/O.
|
|
|
|
Args:
|
|
config: Resolved runtime configuration.
|
|
client: HTTP client used for every REST call.
|
|
connector: WebSocket connect callable. Injected by the tests.
|
|
sleeper: Async sleep used for reconnect backoff.
|
|
max_reconnects: Stop after this many reconnects. None means forever.
|
|
"""
|
|
self._config = config
|
|
self._client = client
|
|
self._connect = connector if connector is not None else ws_connect
|
|
self._sleep = sleeper if sleeper is not None else asyncio.sleep
|
|
self._max_reconnects = max_reconnects
|
|
|
|
async def verify_mode(self) -> str:
|
|
"""Return the container's mode, raising unless it exposes a WebSocket.
|
|
|
|
Raises:
|
|
TransportError: The container is not running a json-rpc mode.
|
|
"""
|
|
response = await self._client.get(self._config.about_url)
|
|
response.raise_for_status()
|
|
body = response.json()
|
|
mode = str(body.get("mode", "")) if isinstance(body, dict) else ""
|
|
if mode != REQUIRED_MODE:
|
|
msg = (
|
|
f"signal-cli-rest-api is running in mode {mode!r}, not "
|
|
f"{REQUIRED_MODE!r}. 'normal' exposes no receive WebSocket at "
|
|
"all, and 'json-rpc-native' is a GraalVM build with no AWT, so "
|
|
'every attachment send fails with "Can\'t load library: awt" '
|
|
"while text replies keep working. Recreate the container with "
|
|
f"MODE={REQUIRED_MODE}."
|
|
)
|
|
raise TransportError(msg)
|
|
return mode
|
|
|
|
async def receive(self) -> AsyncIterator[str]:
|
|
"""Yield raw envelope frames, reconnecting with backoff when dropped."""
|
|
backoff = INITIAL_BACKOFF
|
|
reconnects = 0
|
|
while True:
|
|
try:
|
|
async with self._connect(self._config.receive_url) as socket:
|
|
backoff = INITIAL_BACKOFF
|
|
async for frame in socket:
|
|
yield frame if isinstance(frame, str) else frame.decode()
|
|
except (WebSocketException, OSError) as exc:
|
|
logger.warning("signal websocket dropped: %s", exc)
|
|
if self._max_reconnects is not None and reconnects >= self._max_reconnects:
|
|
return
|
|
reconnects += 1
|
|
await self._sleep(backoff)
|
|
backoff = min(backoff * BACKOFF_FACTOR, MAX_BACKOFF)
|
|
|
|
async def _post_send(self, payload: dict[str, Any]) -> None:
|
|
"""POST one send payload and raise unless the API accepted it."""
|
|
response = await self._client.post(self._config.send_url, json=payload)
|
|
if response.status_code not in _OK_STATUSES:
|
|
msg = f"send failed with HTTP {response.status_code}: {response.text}"
|
|
raise TransportError(msg)
|
|
|
|
async def send_text(self, text: str, recipient: str, quote: Quote | None = None) -> None:
|
|
"""Send a plain-text message, optionally quoting one message."""
|
|
payload: dict[str, Any] = {
|
|
"message": text,
|
|
"number": self._config.phone_number,
|
|
"recipients": [recipient],
|
|
}
|
|
if quote is not None:
|
|
payload.update(quote.payload())
|
|
await self._post_send(payload)
|
|
|
|
async def send_image(
|
|
self,
|
|
image_base64: str,
|
|
recipient: str,
|
|
quote: Quote | None = None,
|
|
caption: str = "",
|
|
) -> None:
|
|
"""Send an image attachment, captioned in the same payload.
|
|
|
|
Verified against the container on 2026-08-30: a non-empty "message"
|
|
alongside base64_attachments comes back as one timestamp, so Signal
|
|
renders it as a single captioned photo rather than two messages.
|
|
"""
|
|
payload: dict[str, Any] = {
|
|
"message": caption,
|
|
"base64_attachments": [image_base64],
|
|
"number": self._config.phone_number,
|
|
"recipients": [recipient],
|
|
}
|
|
if quote is not None:
|
|
payload.update(quote.payload())
|
|
await self._post_send(payload)
|
|
|
|
async def list_attachments(self) -> list[str]:
|
|
"""Return the ids of attachments stored server-side."""
|
|
response = await self._client.get(self._config.attachments_url)
|
|
response.raise_for_status()
|
|
body = response.json()
|
|
if not isinstance(body, list):
|
|
return []
|
|
return [str(item) for item in body]
|
|
|
|
async def delete_attachment(self, attachment_id: str) -> None:
|
|
"""Delete one stored attachment by id."""
|
|
response = await self._client.delete(f"{self._config.attachments_url}/{attachment_id}")
|
|
if response.status_code not in _OK_STATUSES:
|
|
msg = f"attachment delete failed with HTTP {response.status_code}"
|
|
raise TransportError(msg)
|