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

opencode_talk_bridge/scheduler.py

@@ -0,0 +1,144 @@
+"""Scheduled tasks: run a prompt in a conversation later or on an interval.
+
+A SQLite-backed task store plus a daemon thread that fires due tasks via a
+runner callback (the bridge wires this to start a normal prompt turn). One-shot
+tasks are deleted after firing; recurring tasks are rescheduled by their
+interval. Times are Unix timestamps so the schedule survives restarts.
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+import threading
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+
+log = logging.getLogger(__name__)
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS scheduled_tasks (
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    token      TEXT NOT NULL,
+    prompt     TEXT NOT NULL,
+    run_at     INTEGER NOT NULL,
+    interval_s INTEGER NOT NULL DEFAULT 0,
+    created_at INTEGER NOT NULL DEFAULT 0
+);
+"""
+
+
+@dataclass
+class Task:
+    id: int
+    token: str
+    prompt: str
+    run_at: int
+    interval_s: int
+
+
+class TaskStore:
+    def __init__(self, db_path: str) -> None:
+        self._conn = sqlite3.connect(db_path, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._lock = threading.Lock()
+        with self._lock:
+            self._conn.executescript(_SCHEMA)
+            self._conn.commit()
+
+    def close(self) -> None:
+        with self._lock:
+            self._conn.close()
+
+    def add(self, token: str, prompt: str, run_at: int, interval_s: int = 0, *, now: int = 0) -> int:
+        with self._lock:
+            cur = self._conn.execute(
+                "INSERT INTO scheduled_tasks (token, prompt, run_at, interval_s, created_at)"
+                " VALUES (?, ?, ?, ?, ?)",
+                (token, prompt, run_at, interval_s, now),
+            )
+            self._conn.commit()
+            return int(cur.lastrowid)
+
+    def list(self, token: str) -> list[Task]:
+        with self._lock:
+            rows = self._conn.execute(
+                "SELECT * FROM scheduled_tasks WHERE token = ? ORDER BY run_at", (token,)
+            ).fetchall()
+        return [_row_to_task(r) for r in rows]
+
+    def count(self) -> int:
+        with self._lock:
+            return int(self._conn.execute("SELECT COUNT(*) FROM scheduled_tasks").fetchone()[0])
+
+    def delete(self, task_id: int) -> None:
+        with self._lock:
+            self._conn.execute("DELETE FROM scheduled_tasks WHERE id = ?", (task_id,))
+            self._conn.commit()
+
+    def due(self, now: int) -> list[Task]:
+        with self._lock:
+            rows = self._conn.execute(
+                "SELECT * FROM scheduled_tasks WHERE run_at <= ? ORDER BY run_at", (now,)
+            ).fetchall()
+        return [_row_to_task(r) for r in rows]
+
+    def reschedule(self, task_id: int, new_run_at: int) -> None:
+        with self._lock:
+            self._conn.execute("UPDATE scheduled_tasks SET run_at = ? WHERE id = ?", (new_run_at, task_id))
+            self._conn.commit()
+
+
+def _row_to_task(row: sqlite3.Row) -> Task:
+    return Task(
+        id=row["id"],
+        token=row["token"],
+        prompt=row["prompt"],
+        run_at=row["run_at"],
+        interval_s=row["interval_s"],
+    )
+
+
+class Scheduler:
+    """Polls the task store and fires due tasks via ``runner(token, prompt)``."""
+
+    def __init__(
+        self,
+        store: TaskStore,
+        runner: Callable[[str, str], None],
+        *,
+        tick: float = 30.0,
+        clock: Callable[[], int] | None = None,
+    ) -> None:
+        self._store = store
+        self._runner = runner
+        self._tick = tick
+        self._clock = clock or (lambda: int(time.time()))
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        self._thread = threading.Thread(target=self._loop, name="scheduler", daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop.set()
+
+    def _loop(self) -> None:
+        while not self._stop.is_set():
+            self.run_due()
+            self._stop.wait(self._tick)
+
+    def run_due(self) -> None:
+        """Fire all due tasks once (also usable directly in tests)."""
+        now = self._clock()
+        for task in self._store.due(now):
+            try:
+                self._runner(task.token, task.prompt)
+            except Exception:  # noqa: BLE001 - a bad task must not kill the loop
+                log.exception("scheduled task %s failed", task.id)
+            if task.interval_s > 0:
+                self._store.reschedule(task.id, now + task.interval_s)
+            else:
+                self._store.delete(task.id)

opencode_talk_bridge/sessions.py

@@ -0,0 +1,141 @@
+"""SQLite-backed mapping of Talk conversations to OpenCode sessions.
+
+One row per watched conversation. Persists across bridge restarts so that
+``last_known_message_id`` survives (no replay of chat history) and a
+conversation stays bound to its OpenCode session and chosen model.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import threading
+from dataclasses import dataclass
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS conversations (
+    token                 TEXT PRIMARY KEY,
+    opencode_session_id   TEXT,
+    model                 TEXT,
+    agent                 TEXT,
+    directory             TEXT,
+    tts_enabled           INTEGER NOT NULL DEFAULT 0,
+    last_known_message_id INTEGER NOT NULL DEFAULT 0,
+    updated_at            INTEGER NOT NULL DEFAULT 0
+);
+"""
+
+# Columns added after 0.1.x; applied idempotently for existing databases.
+_MIGRATIONS = (
+    "ALTER TABLE conversations ADD COLUMN agent TEXT",
+    "ALTER TABLE conversations ADD COLUMN directory TEXT",
+    "ALTER TABLE conversations ADD COLUMN tts_enabled INTEGER NOT NULL DEFAULT 0",
+)
+
+
+@dataclass
+class ConversationState:
+    token: str
+    opencode_session_id: str | None
+    model: str | None
+    last_known_message_id: int
+    agent: str | None = None
+    directory: str | None = None
+    tts_enabled: bool = False
+
+
+class SessionStore:
+    """Thread-safe SQLite store. A single connection guarded by a lock."""
+
+    def __init__(self, db_path: str) -> None:
+        # check_same_thread=False: the SSE thread and poll loop may both touch it,
+        # serialised by self._lock.
+        self._conn = sqlite3.connect(db_path, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._lock = threading.Lock()
+        with self._lock:
+            self._conn.executescript(_SCHEMA)
+            for migration in _MIGRATIONS:
+                try:
+                    self._conn.execute(migration)
+                except sqlite3.OperationalError:
+                    pass  # column already exists
+            self._conn.commit()
+
+    def close(self) -> None:
+        with self._lock:
+            self._conn.close()
+
+    def __enter__(self) -> SessionStore:
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+    # --- reads -------------------------------------------------------------
+
+    def get(self, token: str) -> ConversationState | None:
+        with self._lock:
+            row = self._conn.execute("SELECT * FROM conversations WHERE token = ?", (token,)).fetchone()
+        return _row_to_state(row) if row else None
+
+    def get_or_create(self, token: str) -> ConversationState:
+        existing = self.get(token)
+        if existing is not None:
+            return existing
+        with self._lock:
+            self._conn.execute("INSERT OR IGNORE INTO conversations (token) VALUES (?)", (token,))
+            self._conn.commit()
+        return ConversationState(token=token, opencode_session_id=None, model=None, last_known_message_id=0)
+
+    def session_id_for(self, token: str) -> str | None:
+        state = self.get(token)
+        return state.opencode_session_id if state else None
+
+    # --- writes ------------------------------------------------------------
+
+    def set_session(self, token: str, session_id: str | None, *, now: int = 0) -> None:
+        self._upsert(token, "opencode_session_id", session_id, now)
+
+    def set_model(self, token: str, model: str | None, *, now: int = 0) -> None:
+        self._upsert(token, "model", model, now)
+
+    def set_agent(self, token: str, agent: str | None, *, now: int = 0) -> None:
+        self._upsert(token, "agent", agent, now)
+
+    def set_directory(self, token: str, directory: str | None, *, now: int = 0) -> None:
+        self._upsert(token, "directory", directory, now)
+
+    def set_tts(self, token: str, enabled: bool, *, now: int = 0) -> None:
+        self._upsert(token, "tts_enabled", 1 if enabled else 0, now)
+
+    def update_last_message_id(self, token: str, message_id: int, *, now: int = 0) -> None:
+        self._upsert(token, "last_known_message_id", message_id, now)
+
+    def clear_session(self, token: str, *, now: int = 0) -> None:
+        """Forget the OpenCode session binding (e.g. on /new) but keep last id."""
+        self.set_session(token, None, now=now)
+
+    def _upsert(self, token: str, column: str, value: object, now: int) -> None:
+        # column is from a fixed internal set — never user input.
+        with self._lock:
+            self._conn.execute(
+                f"""INSERT INTO conversations (token, {column}, updated_at)
+                    VALUES (?, ?, ?)
+                    ON CONFLICT(token) DO UPDATE SET {column} = excluded.{column},
+                                                     updated_at = excluded.updated_at""",
+                (token, value, now),
+            )
+            self._conn.commit()
+
+
+def _row_to_state(row: sqlite3.Row) -> ConversationState:
+    keys = row.keys()
+    return ConversationState(
+        token=row["token"],
+        opencode_session_id=row["opencode_session_id"],
+        model=row["model"],
+        last_known_message_id=row["last_known_message_id"],
+        agent=row["agent"] if "agent" in keys else None,
+        directory=row["directory"] if "directory" in keys else None,
+        tts_enabled=bool(row["tts_enabled"]) if "tts_enabled" in keys else False,
+    )

opencode_talk_bridge/status.py

@@ -0,0 +1,88 @@
+"""Atomic JSON status file — the interface for the Swift menubar app.
+
+The menubar app polls this file; it must always be valid JSON, so writes go to
+a temp file and are atomically renamed into place. The schema is a stable
+contract documented in the README.
+
+State machine::
+
+    starting -> polling <-> working
+                  |  \\-> opencode_down
+                  \\-> error
+                  -> stopped   (clean shutdown)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import threading
+from typing import Any
+
+# Allowed top-level states (documented in the README contract).
+STATES = ("starting", "polling", "working", "opencode_down", "error", "stopped")
+
+
+class StatusWriter:
+    def __init__(self, path: str) -> None:
+        self._path = path
+        self._lock = threading.Lock()
+        self._state: dict[str, Any] = {
+            "state": "starting",
+            "since": 0,
+            "opencode_healthy": False,
+            "conversations": [],
+            "last_error": None,
+            "version": _version(),
+        }
+
+    def update(
+        self,
+        *,
+        state: str | None = None,
+        since: int | None = None,
+        opencode_healthy: bool | None = None,
+        conversations: list[str] | None = None,
+        last_error: str | None = ...,  # sentinel: ... means "leave unchanged"
+    ) -> None:
+        with self._lock:
+            if state is not None:
+                if state not in STATES:
+                    raise ValueError(f"unknown state {state!r}")
+                self._state["state"] = state
+            if since is not None:
+                self._state["since"] = since
+            if opencode_healthy is not None:
+                self._state["opencode_healthy"] = opencode_healthy
+            if conversations is not None:
+                self._state["conversations"] = list(conversations)
+            if last_error is not ...:
+                self._state["last_error"] = last_error
+            self._flush()
+
+    def snapshot(self) -> dict[str, Any]:
+        with self._lock:
+            return dict(self._state)
+
+    def _flush(self) -> None:
+        data = json.dumps(self._state, indent=2)
+        directory = os.path.dirname(os.path.abspath(self._path)) or "."
+        os.makedirs(directory, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(dir=directory, prefix=".status-", suffix=".tmp")
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                fh.write(data)
+            os.replace(tmp, self._path)  # atomic on POSIX
+        except BaseException:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            raise
+
+
+def _version() -> str:
+    from . import __version__
+
+    return __version__

opencode_talk_bridge/streaming.py

@@ -0,0 +1,78 @@
+"""Live response streaming via Talk message editing.
+
+OpenCode emits ``message.part.updated`` events whose ``TextPart.text`` is the
+*cumulative* text of that part. The SSE thread feeds those into a ``StreamState``
+keyed by OpenCode ``sessionID``; the state edits a single Talk message at most
+once per ``throttle`` seconds (each edit is a full REST call, so we throttle
+harder than Telegram would). ``finalize`` forces a last edit with the
+authoritative text once the blocking prompt returns.
+
+A monotonic clock is injected so throttling is deterministic in tests.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+
+# Talk rejects empty edits and has a max length; keep a safety cap.
+_MAX_LEN = 30000
+
+
+class StreamState:
+    def __init__(
+        self,
+        token: str,
+        message_id: int,
+        editor: Callable[[str, int, str], None],
+        *,
+        throttle: float = 1.5,
+        clock: Callable[[], float] | None = None,
+    ) -> None:
+        self.token = token
+        self.message_id = message_id
+        self._edit = editor
+        self._throttle = throttle
+        self._clock = clock or _monotonic
+        self._lock = threading.Lock()
+        # Cumulative text per (messageID, partID), joined in insertion order.
+        self._parts: dict[tuple[str, str], str] = {}
+        self._order: list[tuple[str, str]] = []
+        self._last_edit = float("-inf")
+        self._last_rendered = ""
+
+    def update_part(self, message_id: str, part_id: str, text: str) -> None:
+        """Record the latest cumulative text of a text part, then maybe edit."""
+        key = (message_id, part_id)
+        with self._lock:
+            if key not in self._parts:
+                self._order.append(key)
+            self._parts[key] = text
+            rendered = self._render()
+            now = self._clock()
+            if rendered and rendered != self._last_rendered and (now - self._last_edit) >= self._throttle:
+                self._flush(rendered, now)
+
+    def finalize(self, text: str | None = None) -> None:
+        """Force a final edit. If ``text`` is given it replaces the buffer."""
+        with self._lock:
+            rendered = text if text is not None else self._render()
+            if rendered and rendered != self._last_rendered:
+                self._flush(rendered, self._clock())
+
+    def _render(self) -> str:
+        return "\n".join(self._parts[k] for k in self._order if self._parts[k]).strip()[:_MAX_LEN]
+
+    def _flush(self, rendered: str, now: float) -> None:
+        try:
+            self._edit(self.token, self.message_id, rendered)
+            self._last_rendered = rendered
+            self._last_edit = now
+        except Exception:  # noqa: BLE001 - a failed edit must not kill the SSE loop
+            pass
+
+
+def _monotonic() -> float:
+    import time
+
+    return time.monotonic()

opencode_talk_bridge/stt.py

@@ -0,0 +1,48 @@
+"""Speech-to-text via an OpenAI-compatible ``/audio/transcriptions`` endpoint.
+
+Used to transcribe incoming Talk voice notes into a prompt. Compatible with
+OpenAI, Groq, Together, and self-hosted Whisper servers.
+"""
+
+from __future__ import annotations
+
+import httpx
+
+
+class STTError(Exception):
+    """Transcription failed."""
+
+
+class STTClient:
+    def __init__(
+        self,
+        url: str,
+        *,
+        api_key: str | None = None,
+        model: str = "whisper-large-v3-turbo",
+        language: str | None = None,
+        timeout: float = 120.0,
+    ) -> None:
+        self._url = url.rstrip("/") + "/audio/transcriptions"
+        self._model = model
+        self._language = language
+        headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
+        self._client = httpx.Client(headers=headers, timeout=timeout)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def transcribe(self, audio: bytes, filename: str = "audio.ogg") -> str:
+        data: dict[str, str] = {"model": self._model}
+        if self._language:
+            data["language"] = self._language
+        try:
+            resp = self._client.post(self._url, files={"file": (filename, audio)}, data=data)
+        except httpx.HTTPError as exc:
+            raise STTError(f"transcription request failed: {exc}") from exc
+        if resp.status_code >= 400:
+            raise STTError(f"transcription -> HTTP {resp.status_code}: {resp.text[:200]}")
+        try:
+            return (resp.json().get("text") or "").strip()
+        except ValueError as exc:
+            raise STTError(f"non-JSON transcription response: {exc}") from exc

opencode_talk_bridge/talk.py

@@ -0,0 +1,171 @@
+"""Nextcloud Talk gateway used by the bridge.
+
+Two concerns, two underlying clients from ``nextcloud-talk-core`` (never
+reimplemented here):
+
+  - **Sending / sharing / listing**: the high-level ``TalkClient``.
+  - **Polling**: the low-level ``OCSClient``, called directly so we can read the
+    raw ``actorId`` / ``actorType`` per message. The core ``Message`` model
+    collapses the author to a display name (``actorDisplayName``), which is unfit
+    for the security allowlist — so polling parses the raw OCS dicts itself,
+    mirroring core's ``wait_for_messages`` request exactly.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from nextcloud_talk_core import (
+    Conversation,
+    NextcloudTalkError,
+    OCSClient,
+    Settings,
+    TalkClient,
+)
+
+from .webdav import WebDavClient, WebDavError
+
+
+@dataclass(frozen=True)
+class FileRef:
+    """A file shared into the conversation (WebDAV ``path`` + mime)."""
+
+    name: str
+    path: str
+    mimetype: str
+
+    @property
+    def is_audio(self) -> bool:
+        return self.mimetype.startswith("audio/")
+
+
+@dataclass(frozen=True)
+class IncomingMessage:
+    id: int
+    actor_id: str
+    actor_type: str
+    actor_display_name: str
+    text: str
+    timestamp: int
+    is_system: bool
+    files: tuple[FileRef, ...] = ()
+
+
+def _parse_message(raw: dict[str, Any]) -> IncomingMessage:
+    files = tuple(
+        FileRef(
+            name=p.get("name", ""),
+            path=p.get("path", ""),
+            mimetype=p.get("mimetype", ""),
+        )
+        for p in (raw.get("messageParameters") or {}).values()
+        if isinstance(p, dict) and p.get("type") == "file" and p.get("path")
+    )
+    return IncomingMessage(
+        id=int(raw["id"]),
+        actor_id=raw.get("actorId", ""),
+        actor_type=raw.get("actorType", ""),
+        actor_display_name=raw.get("actorDisplayName", ""),
+        text=raw.get("message", ""),
+        timestamp=int(raw.get("timestamp", 0)),
+        is_system=raw.get("systemMessage", "") != "" or raw.get("messageType") == "system",
+        files=files,
+    )
+
+
+class TalkGateway:
+    """Polling + posting against Nextcloud Talk."""
+
+    def __init__(self, settings: Settings) -> None:
+        self._settings = settings
+        self._talk = TalkClient(settings)
+        self._ocs = OCSClient(settings)
+        self._webdav = WebDavClient(settings)
+        self.own_user = settings.nc_user
+
+    def close(self) -> None:
+        self._talk.close()
+        self._ocs.close()
+        self._webdav.close()
+
+    def __enter__(self) -> TalkGateway:
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+    # --- read --------------------------------------------------------------
+
+    def list_conversations(self) -> list[Conversation]:
+        return self._talk.list_conversations()
+
+    def latest_message_id(self, token: str) -> int:
+        """Most recent message id in a conversation, or 0 if empty.
+
+        Used to initialise the long-poll cursor so a freshly-watched
+        conversation does not replay its whole history.
+        """
+        data = self._ocs.get(
+            f"/api/v1/chat/{token}",
+            params={"lookIntoFuture": 0, "limit": 1},
+        )
+        if not data:
+            return 0
+        return max(int(m["id"]) for m in data)
+
+    def poll(self, token: str, last_known_message_id: int, timeout: int = 30) -> list[IncomingMessage]:
+        """Long-poll for new messages after ``last_known_message_id``.
+
+        Mirrors ``nextcloud_talk_core.TalkClient.wait_for_messages`` but returns
+        raw-parsed messages including the stable author id. Returns [] on
+        timeout with no new messages.
+        """
+        timeout = min(timeout, 60)
+        data = self._ocs.get(
+            f"/api/v1/chat/{token}",
+            params={
+                "lookIntoFuture": 1,
+                "lastKnownMessageId": last_known_message_id,
+                "limit": 100,
+                "timeout": timeout,
+            },
+            # HTTP timeout must outlast the server-side long-poll.
+            timeout=timeout + 30,
+        )
+        if not data:
+            return []
+        return [_parse_message(m) for m in data]
+
+    # --- write -------------------------------------------------------------
+
+    def send(self, token: str, text: str, reply_to: int | None = None) -> int:
+        """Post a message; return its id (so it can be edited for streaming)."""
+        msg = self._talk.send_message(token, text, reply_to=reply_to)
+        return msg.id
+
+    def edit(self, token: str, message_id: int, text: str) -> None:
+        """Edit a previously-sent message (own messages, ≤24 h)."""
+        self._talk.edit_message(token, message_id, text)
+
+    def download(self, webdav_path: str) -> bytes:
+        """Download a file from Nextcloud by its WebDAV path (for attachments)."""
+        return self._webdav.download(webdav_path)
+
+    def upload_and_share(
+        self,
+        token: str,
+        remote_path: str,
+        content: bytes,
+        *,
+        caption: str | None = None,
+        content_type: str = "text/markdown",
+    ) -> None:
+        """Upload ``content`` to the server via WebDAV, then share it into the
+        conversation. Uploading first removes the dependency on a desktop sync
+        client having already pushed the file."""
+        path = self._webdav.upload(remote_path, content, content_type=content_type)
+        self._talk.share_file(token, path, caption=caption)
+
+
+__all__ = ["FileRef", "IncomingMessage", "TalkGateway", "NextcloudTalkError", "WebDavError"]