opencode-talk-bridge 0.2.7__py3-none-any.whl

opencode_talk_bridge/commands.py

@@ -0,0 +1,60 @@
+"""Parse incoming Talk messages into commands or plain prompts.
+
+Pure functions — no I/O — so the parser is trivially unit-testable. A message
+whose first token is a known ``/word`` becomes a :class:`Command`; everything
+else is a :class:`Prompt`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# Known slash-commands. Keep in sync with the help text and the README.
+COMMANDS = (
+    "new",
+    "session",
+    "sessions",
+    "model",
+    "agent",
+    "projects",
+    "worktree",
+    "messages",
+    "commands",
+    "skills",
+    "mcps",
+    "rename",
+    "detach",
+    "tts",
+    "task",
+    "tasklist",
+    "stop",
+    "status",
+    "help",
+)
+
+
+@dataclass(frozen=True)
+class Command:
+    name: str
+    arg: str  # remainder of the line after the command, stripped (may be empty)
+
+
+@dataclass(frozen=True)
+class Prompt:
+    text: str
+
+
+def parse(message: str) -> Command | Prompt:
+    text = message.strip()
+    if not text.startswith("/"):
+        return Prompt(text=text)
+
+    first, _, rest = text.partition(" ")
+    name = first[1:].lower()
+    if name in COMMANDS:
+        return Command(name=name, arg=rest.strip())
+    # Unknown slash-word: treat as a plain prompt rather than silently dropping.
+    return Prompt(text=text)
+
+
+# The help text is localised in messages.py (key "help"), not here.

opencode_talk_bridge/config.py

@@ -0,0 +1,169 @@
+"""Runtime configuration for the bridge.
+
+Everything is loaded from the environment (optionally seeded from a `.env`
+file). The Nextcloud Talk credentials are delegated to
+``nextcloud_talk_core.Settings``; the bridge owns the rest.
+
+The single hard security invariant lives here: an empty allowlist raises, so
+the bridge cannot start without one (see README threat model).
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from nextcloud_talk_core import Settings
+
+
+class ConfigError(Exception):
+    """Raised when the bridge configuration is missing or invalid."""
+
+
+def load_dotenv(path: str | os.PathLike[str] = ".env") -> None:
+    """Seed os.environ from a simple `.env` file if present.
+
+    Intentionally minimal (no external dependency): ``KEY=VALUE`` per line,
+    ``#`` comments, optional surrounding quotes. Existing environment variables
+    are never overwritten, so launchd/shell env always wins over the file.
+    """
+    p = Path(path)
+    if not p.is_file():
+        return
+    for raw in p.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key = key.strip()
+        value = value.strip().strip('"').strip("'")
+        if key and key not in os.environ:
+            os.environ[key] = value
+
+
+def _split_csv(value: str) -> list[str]:
+    return [item.strip() for item in value.split(",") if item.strip()]
+
+
+@dataclass(frozen=True)
+class Config:
+    """Validated bridge configuration."""
+
+    talk: Settings
+    conversations: tuple[str, ...]
+    watch_all: bool
+    allowed_users: frozenset[str]
+
+    opencode_url: str
+    opencode_username: str | None
+    opencode_password: str | None
+    opencode_directory: str | None
+    opencode_model: str | None
+
+    db_path: str
+    status_file: str
+    # WebDAV folder (relative to the Nextcloud user root) the bridge uploads
+    # code/long-output attachments into before sharing them. None disables
+    # attachments (long output is posted as text instead).
+    share_webdav_dir: str | None
+    log_level: str
+
+    # Interaction / streaming
+    response_streaming: bool
+    stream_throttle_ms: int
+    hide_tool_messages: bool
+    hide_thinking: bool
+    track_background_sessions: bool
+    list_limit: int
+    bot_locale: str
+
+    # Phase 3: voice
+    stt_url: str | None
+    stt_key: str | None
+    stt_model: str
+    stt_language: str | None
+    tts_url: str | None
+    tts_key: str | None
+    tts_model: str
+    tts_voice: str
+    task_limit: int
+
+    poll_timeout: int = 30
+    attachment_threshold: int = field(default=1500)
+
+    @classmethod
+    def from_env(cls) -> Config:
+        talk = Settings.from_env()
+
+        allowed = frozenset(_split_csv(os.environ.get("ALLOWED_USERS", "")))
+        if not allowed:
+            raise ConfigError(
+                "ALLOWED_USERS is empty. Refusing to start: set it to a "
+                "comma-separated list of Talk user IDs allowed to issue commands."
+            )
+
+        raw_convos = os.environ.get("TALK_CONVERSATIONS", "").strip()
+        watch_all = raw_convos.lower() == "all"
+        conversations = tuple(_split_csv(raw_convos)) if not watch_all else ()
+        if not watch_all and not conversations:
+            raise ConfigError(
+                "TALK_CONVERSATIONS is empty. Set it to one or more conversation "
+                'tokens, or "all" to watch every conversation.'
+            )
+
+        opencode_url = os.environ.get("OPENCODE_URL", "http://127.0.0.1:4096").strip().rstrip("/")
+
+        return cls(
+            talk=talk,
+            conversations=conversations,
+            watch_all=watch_all,
+            allowed_users=allowed,
+            opencode_url=opencode_url,
+            opencode_username=_or_none(os.environ.get("OPENCODE_USERNAME")),
+            opencode_password=_or_none(os.environ.get("OPENCODE_PASSWORD")),
+            opencode_directory=_or_none(os.environ.get("OPENCODE_DIRECTORY")),
+            opencode_model=_or_none(os.environ.get("OPENCODE_MODEL")),
+            db_path=os.environ.get("DB_PATH", "bridge.sqlite3").strip(),
+            status_file=os.environ.get("STATUS_FILE", "status.json").strip(),
+            share_webdav_dir=_or_none(os.environ.get("SHARE_WEBDAV_DIR")),
+            log_level=os.environ.get("LOG_LEVEL", "INFO").strip().upper(),
+            response_streaming=_bool(os.environ.get("RESPONSE_STREAMING"), True),
+            stream_throttle_ms=_int(os.environ.get("STREAM_THROTTLE_MS"), 1500),
+            hide_tool_messages=_bool(os.environ.get("HIDE_TOOL_MESSAGES"), False),
+            hide_thinking=_bool(os.environ.get("HIDE_THINKING"), True),
+            track_background_sessions=_bool(os.environ.get("TRACK_BACKGROUND_SESSIONS"), True),
+            list_limit=_int(os.environ.get("LIST_LIMIT"), 10),
+            bot_locale=os.environ.get("BOT_LOCALE", "de").strip().lower() or "de",
+            stt_url=_or_none(os.environ.get("STT_API_URL")),
+            stt_key=_or_none(os.environ.get("STT_API_KEY")),
+            stt_model=os.environ.get("STT_MODEL", "whisper-large-v3-turbo").strip(),
+            stt_language=_or_none(os.environ.get("STT_LANGUAGE")),
+            tts_url=_or_none(os.environ.get("TTS_API_URL")),
+            tts_key=_or_none(os.environ.get("TTS_API_KEY")),
+            tts_model=os.environ.get("TTS_MODEL", "gpt-4o-mini-tts").strip(),
+            tts_voice=os.environ.get("TTS_VOICE", "alloy").strip(),
+            task_limit=_int(os.environ.get("TASK_LIMIT"), 10),
+        )
+
+
+def _or_none(value: str | None) -> str | None:
+    if value is None:
+        return None
+    value = value.strip()
+    return value or None
+
+
+def _bool(value: str | None, default: bool) -> bool:
+    if value is None or not value.strip():
+        return default
+    return value.strip().lower() in ("1", "true", "yes", "on")
+
+
+def _int(value: str | None, default: int) -> int:
+    if value is None or not value.strip():
+        return default
+    try:
+        return int(value.strip())
+    except ValueError:
+        return default

opencode_talk_bridge/events.py

@@ -0,0 +1,85 @@
+"""Classify OpenCode SSE event payloads into typed bridge events.
+
+Keeps the parsing of OpenCode's large ``GlobalEvent`` union out of the bridge:
+``classify`` turns a raw payload (``{"type", "properties"}``) into one of a few
+simple dataclasses the bridge acts on, or ``None`` for events we ignore. This is
+pure and unit-testable; the bridge owns the side effects.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class TextDelta:
+    session_id: str
+    message_id: str
+    part_id: str
+    text: str
+
+
+@dataclass(frozen=True)
+class ToolEvent:
+    session_id: str
+    tool: str
+    status: str
+    call_id: str
+
+
+@dataclass(frozen=True)
+class ReasoningDelta:
+    session_id: str
+    text: str
+
+
+@dataclass(frozen=True)
+class PermissionEvent:
+    request: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class QuestionEvent:
+    request: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class SessionIdle:
+    session_id: str
+
+
+@dataclass(frozen=True)
+class SessionError:
+    session_id: str
+
+
+Event = TextDelta | ToolEvent | ReasoningDelta | PermissionEvent | QuestionEvent | SessionIdle | SessionError
+
+
+def classify(payload: dict[str, Any]) -> Event | None:
+    etype = payload.get("type")
+    props = payload.get("properties") or {}
+
+    if etype == "message.part.updated":
+        part = props.get("part") or {}
+        ptype = part.get("type")
+        sid = part.get("sessionID", "")
+        if ptype == "text":
+            return TextDelta(sid, part.get("messageID", ""), part.get("id", ""), part.get("text", ""))
+        if ptype == "tool":
+            state = part.get("state") or {}
+            return ToolEvent(sid, part.get("tool", ""), state.get("status", ""), part.get("callID", ""))
+        if ptype == "reasoning":
+            return ReasoningDelta(sid, part.get("text", ""))
+        return None
+
+    if etype == "permission.asked":
+        return PermissionEvent(props)
+    if etype == "question.asked":
+        return QuestionEvent(props)
+    if etype == "session.idle":
+        return SessionIdle(props.get("sessionID", ""))
+    if etype == "session.error":
+        return SessionError(props.get("sessionID", ""))
+    return None

opencode_talk_bridge/init.py

@@ -0,0 +1,118 @@
+"""Interactive ``.env`` generator (``opencode-talk-bridge --init``).
+
+Prompts for the essential settings and writes a ``.env`` (chmod 600, since it
+holds the app password). Advanced options (streaming, STT/TTS, scheduler) keep
+their defaults and can be added later from ``.env.example``. Input functions are
+injectable so the flow is unit-testable.
+"""
+
+from __future__ import annotations
+
+import getpass
+import os
+import sys
+from collections.abc import Callable
+
+# (key, label, default, required, secret) — order preserved in the written file.
+_FIELDS: list[tuple[str, str, str, bool, bool]] = [
+    ("NC_URL", "Nextcloud base URL (https://…)", "", True, False),
+    ("NC_USER", "Nextcloud username", "", True, False),
+    ("NC_APP_PASSWORD", "Nextcloud app password (hidden)", "", True, True),
+    (
+        "TALK_CONVERSATIONS",
+        "Talk conversation token(s) to watch (comma-separated, or 'all')",
+        "",
+        True,
+        False,
+    ),
+    ("ALLOWED_USERS", "Allowed Talk user IDs (comma-separated logins)", "", True, False),
+    ("OPENCODE_URL", "OpenCode server URL", "http://127.0.0.1:4096", False, False),
+    ("OPENCODE_USERNAME", "OpenCode Basic-Auth user (blank if unsecured)", "", False, False),
+    ("OPENCODE_PASSWORD", "OpenCode Basic-Auth password (blank if unsecured)", "", False, True),
+    ("SHARE_WEBDAV_DIR", "WebDAV folder for code/TTS attachments (blank to disable)", "", False, False),
+    ("BOT_LOCALE", "UI language (de/en)", "de", False, False),
+]
+
+
+def _is_url(value: str) -> bool:
+    return value.startswith("http://") or value.startswith("https://")
+
+
+def run_init(
+    env_path: str = ".env",
+    *,
+    ask: Callable[[str], str] | None = None,
+    ask_secret: Callable[[str], str] | None = None,
+    out: Callable[[str], None] | None = None,
+    confirm: Callable[[str], bool] | None = None,
+) -> int:
+    ask = ask or input
+    ask_secret = ask_secret or getpass.getpass
+    out = out or print
+    confirm = confirm or _default_confirm
+
+    if not _interactive(ask):
+        out("--init requires an interactive terminal.")
+        return 2
+
+    if os.path.exists(env_path) and not confirm(f"{env_path} exists — overwrite?"):
+        out("Aborted; existing file kept.")
+        return 1
+
+    out("Setting up opencode-talk-bridge. Press Enter to accept a [default].\n")
+    values: dict[str, str] = {}
+    for key, label, default, required, secret in _FIELDS:
+        validate = _is_url if key in ("NC_URL", "OPENCODE_URL") else None
+        values[key] = _prompt(ask, ask_secret, out, label, default, required, secret, validate)
+
+    _write_env(env_path, values)
+    out(f"\n✅ Wrote {env_path} (chmod 600).")
+    out("Next: `opencode-talk-bridge --check`, then `opencode-talk-bridge`.")
+    out("More options (streaming, STT/TTS, scheduler) are documented in .env.example.")
+    return 0
+
+
+def _prompt(
+    ask: Callable[[str], str],
+    ask_secret: Callable[[str], str],
+    out: Callable[[str], None],
+    label: str,
+    default: str,
+    required: bool,
+    secret: bool,
+    validate: Callable[[str], bool] | None,
+) -> str:
+    suffix = f" [{default}]" if default else ""
+    while True:
+        raw = ask_secret(f"{label}: ") if secret else ask(f"{label}{suffix}: ")
+        value = raw.strip() or default
+        if not value:
+            if required:
+                out("  → required, please enter a value.")
+                continue
+            return ""
+        if validate and not validate(value):
+            out("  → must start with http:// or https://")
+            continue
+        return value
+
+
+def _write_env(env_path: str, values: dict[str, str]) -> None:
+    lines = ["# opencode-talk-bridge configuration (generated by --init).", ""]
+    for key, _label, _default, _required, _secret in _FIELDS:
+        lines.append(f"{key}={values.get(key, '')}")
+    content = "\n".join(lines) + "\n"
+    # Write 0600 from the start so the app password is never world-readable.
+    fd = os.open(env_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as fh:
+        fh.write(content)
+    os.chmod(env_path, 0o600)
+
+
+def _interactive(ask: Callable[[str], str]) -> bool:
+    # Only enforce a real TTY for the built-in input(); injected asks pass.
+    return ask is not input or sys.stdin.isatty()
+
+
+def _default_confirm(question: str) -> bool:
+    return input(f"{question} [y/N] ").strip().lower() in ("y", "yes", "j", "ja")

opencode_talk_bridge/messages.py

@@ -0,0 +1,226 @@
+"""Localised user-facing strings (i18n).
+
+A tiny catalog keyed by message id, with German (default) and English. The
+bridge builds a translator via ``translator(BOT_LOCALE)`` and calls
+``self._t("key", **fields)``. Unknown locales fall back to German; unknown keys
+fall back to the key itself.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+DE: dict[str, str] = {
+    "working": "🔧 OpenCode arbeitet …",
+    "busy": "⏳ Ich arbeite noch an der vorherigen Anfrage – bitte warten oder /stop.",
+    "down": "⚠️ OpenCode ist nicht erreichbar. Bitte den Server prüfen.",
+    "error": "⚠️ Fehler: {error}",
+    "oc_error": "⚠️ OpenCode-Fehler – bitte erneut versuchen.",
+    "unexpected": "⚠️ Unerwarteter Fehler – die Anfrage wurde übersprungen.",
+    "no_answer": "(keine Antwort)",
+    "aborted": "🛑 Abgebrochen.",
+    "attached_as_file": "📎 Antwort als Datei angehängt.",
+    "session_error": "⚠️ OpenCode meldet einen Fehler.",
+    "thinking": "💭 denkt nach …",
+    "bg_done": "✅ Hintergrund-Session fertig.",
+    # sessions
+    "new_session": "🆕 Neue OpenCode-Session beim nächsten Prompt.",
+    "session_is": "Session: {sid}",
+    "no_session_yet": "Noch keine Session.",
+    "no_session": "Keine Session.",
+    "no_running_session": "Keine laufende Session.",
+    "session_switched": "✅ Session gewechselt: {sid}",
+    "detached": "🔌 Von der Session getrennt. Der nächste Prompt startet eine neue.",
+    "no_sessions": "Keine Sessions vorhanden. Schreib einfach einen Prompt.",
+    "rename_usage": "Nutzung: /rename <neuer Titel>",
+    "no_session_rename": "Keine Session zum Umbenennen.",
+    "renamed": "✅ Umbenannt: {title}",
+    # model / agent
+    "model_format": "Format: /model providerID/modelID",
+    "model_set": "✅ Modell gesetzt: {model}",
+    "model_current": "Aktuelles Modell: {model}\nSetzen: /model providerID/modelID",
+    "agent_set": "✅ Agent gesetzt: {agent}",
+    "no_agents": "Keine Agenten verfügbar. Setzen: /agent <name>",
+    # pickers
+    "pick_number": "_Antworte mit der Nummer._",
+    "nothing_to_pick": "Nichts zur Auswahl.",
+    "title_sessions": "🗂 Sessions:",
+    "title_models": "🧠 Modelle:",
+    "title_agents": "🎭 Agenten:",
+    "title_projects": "📁 Projekte:",
+    "title_worktrees": "🌿 Worktrees:",
+    "title_commands": "⚡ Commands:",
+    "title_skills": "🧩 Skills:",
+    "title_mcps": "🔌 MCP-Server:",
+    "title_messages": "💬 Nachrichten:",
+    "title_action": "Aktion:",
+    "no_projects": "Keine Projekte gefunden.",
+    "no_worktrees": "Keine Worktrees gefunden.",
+    "no_commands": "Keine Commands verfügbar.",
+    "no_skills": "Keine Skills verfügbar.",
+    "no_mcps": "Keine MCP-Server konfiguriert.",
+    "no_messages": "Keine Nachrichten.",
+    "dir_switched": "✅ {kind} gewechselt: {directory}\nNeue Session beim nächsten Prompt.",
+    "reverted": "↩️ Zurückgesetzt.",
+    "mcp_toggled": "🔌 {name} {state}.",
+    "mcp_on": "aktiviert",
+    "mcp_off": "deaktiviert",
+    "action_revert": "↩️ Revert (hierhin zurück)",
+    "action_fork": "🍴 Fork (neue Session ab hier)",
+    # permission / question
+    "perm_once": "🔐 erlaubt (einmal).",
+    "perm_always": "🔐 erlaubt (immer).",
+    "perm_reject": "🔐 abgelehnt.",
+    "answered": "✅ {answer}",
+    # tts
+    "tts_unconfigured": "TTS ist nicht konfiguriert (TTS_API_URL / TTS_API_KEY).",
+    "tts_on": "🔊 Sprachausgabe aktiviert.",
+    "tts_off": "🔊 Sprachausgabe deaktiviert.",
+    # scheduled tasks
+    "no_scheduler": "Geplante Aufgaben sind nicht aktiv.",
+    "task_usage": "Nutzung: /task <Minuten> <Prompt>  oder  /task every <Minuten> <Prompt>",
+    "task_limit": "Limit erreicht ({limit} Aufgaben). Erst eine löschen (/tasklist).",
+    "task_created": "⏰ Aufgabe geplant (in {minutes} min).",
+    "task_none": "Keine geplanten Aufgaben.",
+    "task_deleted": "🗑 Aufgabe gelöscht.",
+    "title_tasks": "⏰ Geplante Aufgaben:",
+    # status
+    "status": "📊 OpenCode: {health}\nSession: {sid}\nModell: {model}\nAgent: {agent}",
+    "reachable": "✅ erreichbar",
+    "unreachable": "⚠️ nicht erreichbar",
+    "help": (
+        "🤖 *opencode-talk-bridge*\n"
+        "Schreib eine Nachricht, um OpenCode zu prompten. Befehle:\n"
+        "• /new — neue OpenCode-Session\n"
+        "• /session — aktuelle Session-ID anzeigen\n"
+        "• /sessions — Sessions auflisten & wechseln\n"
+        "• /rename <Titel> — aktuelle Session umbenennen\n"
+        "• /detach — von der Session trennen\n"
+        "• /messages — Nachrichten durchsuchen, dann Revert/Fork\n"
+        "• /model [providerID/modelID] — Modell anzeigen/wählen/setzen\n"
+        "• /agent [name] — Agent anzeigen/wählen/setzen (plan/build)\n"
+        "• /projects — OpenCode-Projekt wechseln\n"
+        "• /worktree — Git-Worktree wechseln\n"
+        "• /commands — eigene OpenCode-Commands ausführen\n"
+        "• /skills — OpenCode-Skills ausführen\n"
+        "• /mcps — MCP-Server aktivieren/deaktivieren\n"
+        "• /tts — Sprachausgabe umschalten (falls konfiguriert)\n"
+        "• /task <Min> <Prompt> — Aufgabe planen (/task every <Min> … für wiederkehrend)\n"
+        "• /tasklist — geplante Aufgaben anzeigen/löschen\n"
+        "• /stop — aktuellen Lauf abbrechen\n"
+        "• /status — Bridge- & OpenCode-Status\n"
+        "• /help — diese Nachricht\n"
+        "Picker: mit der Nummer antworten. Permission: `ja` (einmal), "
+        "`immer` (immer), `nein` (ablehnen)."
+    ),
+}
+
+EN: dict[str, str] = {
+    "working": "🔧 OpenCode is working …",
+    "busy": "⏳ Still working on the previous request – please wait or /stop.",
+    "down": "⚠️ OpenCode is unreachable. Please check the server.",
+    "error": "⚠️ Error: {error}",
+    "oc_error": "⚠️ OpenCode error – please try again.",
+    "unexpected": "⚠️ Unexpected error – the request was skipped.",
+    "no_answer": "(no answer)",
+    "aborted": "🛑 Aborted.",
+    "attached_as_file": "📎 Answer attached as a file.",
+    "session_error": "⚠️ OpenCode reported an error.",
+    "thinking": "💭 thinking …",
+    "bg_done": "✅ Background session finished.",
+    "new_session": "🆕 New OpenCode session on the next prompt.",
+    "session_is": "Session: {sid}",
+    "no_session_yet": "No session yet.",
+    "no_session": "No session.",
+    "no_running_session": "No running session.",
+    "session_switched": "✅ Session switched: {sid}",
+    "detached": "🔌 Detached from the session. The next prompt starts a new one.",
+    "no_sessions": "No sessions yet. Just send a prompt.",
+    "rename_usage": "Usage: /rename <new title>",
+    "no_session_rename": "No session to rename.",
+    "renamed": "✅ Renamed: {title}",
+    "model_format": "Format: /model providerID/modelID",
+    "model_set": "✅ Model set: {model}",
+    "model_current": "Current model: {model}\nSet: /model providerID/modelID",
+    "agent_set": "✅ Agent set: {agent}",
+    "no_agents": "No agents available. Set: /agent <name>",
+    "pick_number": "_Reply with the number._",
+    "nothing_to_pick": "Nothing to choose.",
+    "title_sessions": "🗂 Sessions:",
+    "title_models": "🧠 Models:",
+    "title_agents": "🎭 Agents:",
+    "title_projects": "📁 Projects:",
+    "title_worktrees": "🌿 Worktrees:",
+    "title_commands": "⚡ Commands:",
+    "title_skills": "🧩 Skills:",
+    "title_mcps": "🔌 MCP servers:",
+    "title_messages": "💬 Messages:",
+    "title_action": "Action:",
+    "no_projects": "No projects found.",
+    "no_worktrees": "No worktrees found.",
+    "no_commands": "No commands available.",
+    "no_skills": "No skills available.",
+    "no_mcps": "No MCP servers configured.",
+    "no_messages": "No messages.",
+    "dir_switched": "✅ {kind} switched: {directory}\nNew session on the next prompt.",
+    "reverted": "↩️ Reverted.",
+    "mcp_toggled": "🔌 {name} {state}.",
+    "mcp_on": "enabled",
+    "mcp_off": "disabled",
+    "action_revert": "↩️ Revert (back to here)",
+    "action_fork": "🍴 Fork (new session from here)",
+    "perm_once": "🔐 allowed (once).",
+    "perm_always": "🔐 allowed (always).",
+    "perm_reject": "🔐 rejected.",
+    "answered": "✅ {answer}",
+    "tts_unconfigured": "TTS is not configured (TTS_API_URL / TTS_API_KEY).",
+    "tts_on": "🔊 Spoken replies enabled.",
+    "tts_off": "🔊 Spoken replies disabled.",
+    "no_scheduler": "Scheduled tasks are not enabled.",
+    "task_usage": "Usage: /task <minutes> <prompt>  or  /task every <minutes> <prompt>",
+    "task_limit": "Limit reached ({limit} tasks). Delete one first (/tasklist).",
+    "task_created": "⏰ Task scheduled (in {minutes} min).",
+    "task_none": "No scheduled tasks.",
+    "task_deleted": "🗑 Task deleted.",
+    "title_tasks": "⏰ Scheduled tasks:",
+    "status": "📊 OpenCode: {health}\nSession: {sid}\nModel: {model}\nAgent: {agent}",
+    "reachable": "✅ reachable",
+    "unreachable": "⚠️ unreachable",
+    "help": (
+        "🤖 *opencode-talk-bridge*\n"
+        "Send a message to prompt OpenCode. Commands:\n"
+        "• /new — start a fresh OpenCode session\n"
+        "• /session — show the current session id\n"
+        "• /sessions — list & switch recent sessions\n"
+        "• /rename <title> — rename the current session\n"
+        "• /detach — detach from the current session\n"
+        "• /messages — browse messages, then revert or fork\n"
+        "• /model [providerID/modelID] — show, pick, or set the model\n"
+        "• /agent [name] — show, pick, or set the agent (plan/build)\n"
+        "• /projects — switch the OpenCode project\n"
+        "• /worktree — switch the git worktree\n"
+        "• /commands — browse & run custom OpenCode commands\n"
+        "• /skills — browse & run OpenCode skills\n"
+        "• /mcps — enable/disable MCP servers\n"
+        "• /tts — toggle spoken replies (if configured)\n"
+        "• /task <min> <prompt> — schedule a task (/task every <min> … to repeat)\n"
+        "• /tasklist — list/delete scheduled tasks\n"
+        "• /stop — abort the current run\n"
+        "• /status — bridge & OpenCode health\n"
+        "• /help — this message\n"
+        "Pickers: reply with the number. Permission: `ja` (once), "
+        "`immer` (always), `nein` (deny)."
+    ),
+}
+
+CATALOG: dict[str, dict[str, str]] = {"de": DE, "en": EN}
+
+
+def translator(locale: str) -> Callable[..., str]:
+    table = CATALOG.get(locale, DE)
+
+    def t(key: str, **fields: object) -> str:
+        template = table.get(key) or DE.get(key, key)
+        return template.format(**fields) if fields else template
+
+    return t