signal-bot/fake_signal/server.py
Krzysztof kuhy Rudnicki 7984c65f8a feat: register the bot as its own Signal account, no phone app needed
Shelter cannot work on this phone, and it would not have helped anyway.

It cannot work: setting a Device Owner makes Android enable
no_add_managed_profile, no_add_private_profile and no_add_clone_profile on
every user, which kills Shelter, Island, Private Space and app cloning
alike. Verified on-device rather than inferred -- `pm create-user
--profileOf 0 --managed` returns "Cannot add user: no_add_managed_profile is
enabled". This is the Android 11 COMP deprecation, enforced in three places
in DevicePolicyManagerService and unchanged through Android 16.

It would not have helped: a second Signal *app* is not a second Signal
*account*. Every account needs its own phone number, so the second number
was always the real requirement -- and once you have one, signal-cli can
register it as a PRIMARY device with no phone app, no QR scan and no work
profile at all. That is strictly better than both the linked-device setup
and the Shelter plan: the bot cannot read personal DMs and never posts as
the account owner.

scripts/register_bot.sh drives that flow. It gates on signal-cli >= 0.14.7
rather than hoping: stable container tag 0.100 bundles 0.14.5, and on
2026-03-06 Signal made the post-quantum ratchet mandatory and de-registered
every account whose client lacked it -- a stale client is how a bot dies
silently months later. Verified that the recommended CI tag really does
bundle 0.14.7 instead of assuming it.

Rehearsed offline, not written blind. fake_signal grew /v1/accounts,
/v1/register/{number}, /v1/register/{number}/verify/{token} and
/v1/groups/{number}, so the whole runbook including every error path
(missing captcha, stray verify, wrong code, unregistered number, empty group
list, out-of-range and non-numeric picks) runs against the fake. The picker
was proven to resolve the group the user actually pointed at.

Prompts now read from $SIGNAL_TTY instead of /dev/tty directly. A hard-coded
/dev/tty made the interactive path untestable without a real terminal; the
seam is the same idea as the injected clock and transport on the Python side,
and is what let the picker be rehearsed at all.

live_smoke.sh and register_bot.sh share scripts/lib_signal.sh so the two
cannot drift, and shellcheck now runs with -x so the sourced lib is actually
linted from its callers.

201 tests, 100% branch coverage, all 23 gates green.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013yaBT45KhHqxTKVCTA87iy
2026-08-29 13:41:13 +02:00

43 lines
1.5 KiB
Python

# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
"""A protocol-faithful fake of signal-cli-rest-api.
Serves the exact surface the bot uses, so the unmodified bot connects to it
by pointing API_BASE_URL at this process. A real local Signal server is not
achievable -- signal-cli compiles its endpoints and trust store in, and
Signal-Server needs FoundationDB, DynamoDB and Redis -- so faking this
boundary is the only way to exercise every feature without a real account.
"""
from __future__ import annotations
import os
from fastapi import FastAPI
from fake_signal.routes_account import build_account_router
from fake_signal.routes_api import build_api_router
from fake_signal.routes_control import build_control_router
from fake_signal.routes_fixtures import build_fixture_router
from fake_signal.state import State
def create_app(state: State | None = None) -> FastAPI:
"""Build the fake server, optionally sharing an existing State."""
app = FastAPI(title="fake-signal-cli-rest-api")
app.state.fake = state if state is not None else State()
app.include_router(build_api_router())
app.include_router(build_account_router())
app.include_router(build_fixture_router())
app.include_router(build_control_router())
return app
def default_state() -> State:
"""State whose self-URL matches the port the e2e script binds."""
host = os.getenv("FAKE_HOST", "127.0.0.1")
port = os.getenv("FAKE_PORT", "8099")
return State(base_url=f"http://{host}:{port}")
app = create_app(default_state())