takopi-slack-plugin 0.0.15__py3-none-any.whl

takopi_slack_plugin/client.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import anyio
+import httpx
+
+from takopi.api import get_logger
+
+logger = get_logger(__name__)
+
+
+class SlackApiError(RuntimeError):
+    def __init__(
+        self,
+        message: str,
+        *,
+        error: str | None = None,
+        status_code: int | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.error = error
+        self.status_code = status_code
+
+
+@dataclass(frozen=True, slots=True)
+class SlackAuth:
+    user_id: str
+    team_id: str | None = None
+    bot_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class SlackMessage:
+    ts: str
+    text: str | None
+    user: str | None
+    bot_id: str | None
+    subtype: str | None
+    thread_ts: str | None
+
+    @classmethod
+    def from_api(cls, payload: dict[str, Any]) -> "SlackMessage":
+        return cls(
+            ts=str(payload.get("ts") or ""),
+            text=payload.get("text"),
+            user=payload.get("user"),
+            bot_id=payload.get("bot_id"),
+            subtype=payload.get("subtype"),
+            thread_ts=payload.get("thread_ts"),
+        )
+
+
+class SlackClient:
+    def __init__(
+        self,
+        token: str,
+        *,
+        base_url: str = "https://slack.com/api",
+        timeout_s: float = 30.0,
+    ) -> None:
+        self._token = token
+        self._client = httpx.AsyncClient(
+            base_url=base_url,
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=timeout_s,
+        )
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def _request(
+        self,
+        method: str,
+        endpoint: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return await _request_with_client(
+            self._client,
+            method,
+            endpoint,
+            params=params,
+            json=json,
+        )
+
+    async def auth_test(self) -> SlackAuth:
+        payload = await self._request("POST", "/auth.test")
+        user_id = payload.get("user_id")
+        if not isinstance(user_id, str) or not user_id:
+            raise SlackApiError("Missing user_id in auth.test response")
+        return SlackAuth(
+            user_id=user_id,
+            team_id=payload.get("team_id"),
+            bot_id=payload.get("bot_id"),
+        )
+
+    async def post_message(
+        self,
+        *,
+        channel_id: str,
+        text: str,
+        blocks: list[dict[str, Any]] | None = None,
+        thread_ts: str | None = None,
+        reply_broadcast: bool | None = None,
+    ) -> SlackMessage:
+        data: dict[str, Any] = {
+            "channel": channel_id,
+            "text": text,
+            "mrkdwn": True,
+        }
+        if blocks is not None:
+            data["blocks"] = blocks
+        if thread_ts is not None:
+            data["thread_ts"] = thread_ts
+        if reply_broadcast is not None:
+            data["reply_broadcast"] = reply_broadcast
+        payload = await self._request("POST", "/chat.postMessage", json=data)
+        message = payload.get("message")
+        if not isinstance(message, dict):
+            raise SlackApiError("Slack postMessage missing message payload")
+        return SlackMessage.from_api(message)
+
+    async def update_message(
+        self,
+        *,
+        channel_id: str,
+        ts: str,
+        text: str,
+        blocks: list[dict[str, Any]] | None = None,
+    ) -> SlackMessage:
+        data: dict[str, Any] = {
+            "channel": channel_id,
+            "ts": ts,
+            "text": text,
+            "mrkdwn": True,
+        }
+        if blocks is not None:
+            data["blocks"] = blocks
+        payload = await self._request("POST", "/chat.update", json=data)
+        message = payload.get("message")
+        if not isinstance(message, dict):
+            raise SlackApiError("Slack update missing message payload")
+        return SlackMessage.from_api(message)
+
+    async def delete_message(self, *, channel_id: str, ts: str) -> bool:
+        data = {"channel": channel_id, "ts": ts}
+        await self._request("POST", "/chat.delete", json=data)
+        return True
+
+    async def post_response(
+        self,
+        *,
+        response_url: str,
+        text: str,
+        response_type: str = "ephemeral",
+        replace_original: bool | None = None,
+        delete_original: bool | None = None,
+    ) -> None:
+        payload: dict[str, Any] = {
+            "text": text,
+            "response_type": response_type,
+        }
+        if replace_original is not None:
+            payload["replace_original"] = replace_original
+        if delete_original is not None:
+            payload["delete_original"] = delete_original
+        async with httpx.AsyncClient(timeout=15.0) as client:
+            try:
+                response = await client.post(response_url, json=payload)
+            except httpx.HTTPError as exc:
+                logger.warning("slack.response_failed", error=str(exc))
+                return
+        if response.status_code >= 400:
+            logger.warning(
+                "slack.response_failed",
+                status_code=response.status_code,
+                body=response.text,
+            )
+
+async def _request_with_client(
+    client: httpx.AsyncClient,
+    method: str,
+    endpoint: str,
+    *,
+    params: dict[str, Any] | None = None,
+    json: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    while True:
+        try:
+            response = await client.request(
+                method, endpoint, params=params, json=json
+            )
+        except httpx.HTTPError as exc:
+            logger.warning("slack.network_error", error=str(exc))
+            raise SlackApiError("Slack request failed") from exc
+
+        if response.status_code == 429:
+            retry_after = response.headers.get("Retry-After")
+            try:
+                delay = int(retry_after) if retry_after is not None else 1
+            except ValueError:
+                delay = 1
+            logger.info("slack.rate_limited", retry_after=delay)
+            await anyio.sleep(delay)
+            continue
+
+        if response.status_code >= 400:
+            raise SlackApiError(
+                f"Slack HTTP {response.status_code}",
+                status_code=response.status_code,
+            )
+
+        try:
+            payload = response.json()
+        except ValueError as exc:
+            raise SlackApiError("Slack response was not JSON") from exc
+
+        if payload.get("ok") is not True:
+            error = payload.get("error")
+            raise SlackApiError(
+                f"Slack API error: {error}",
+                error=error,
+                status_code=response.status_code,
+            )
+
+        return payload
+
+
+async def open_socket_url(
+    app_token: str,
+    *,
+    base_url: str = "https://slack.com/api",
+    timeout_s: float = 30.0,
+) -> str:
+    token = app_token.strip()
+    if not token:
+        raise SlackApiError("Missing Slack app token")
+    async with httpx.AsyncClient(
+        base_url=base_url,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=timeout_s,
+    ) as client:
+        payload = await _request_with_client(
+            client,
+            "POST",
+            "/apps.connections.open",
+        )
+    url = payload.get("url")
+    if not isinstance(url, str) or not url.strip():
+        raise SlackApiError("Slack socket url missing")
+    return url.strip()

takopi_slack_plugin/commands/__init__.py

@@ -0,0 +1,3 @@
+from .dispatch import dispatch_command, split_command_args
+
+__all__ = ["dispatch_command", "split_command_args"]

takopi_slack_plugin/commands/dispatch.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import shlex
+from collections.abc import Awaitable, Callable
+
+import anyio
+from takopi.commands import CommandContext, get_command
+from takopi.config import ConfigError
+from takopi.logging import get_logger
+from takopi.model import EngineId, ResumeToken
+from takopi.runner_bridge import RunningTasks
+from takopi.runners.run_options import EngineRunOptions
+from takopi.transport import MessageRef
+
+from .executor import SlackCommandExecutor
+
+logger = get_logger(__name__)
+
+
+def split_command_args(text: str) -> tuple[str, ...]:
+    if not text.strip():
+        return ()
+    try:
+        return tuple(shlex.split(text))
+    except ValueError:
+        return tuple(text.split())
+
+
+async def dispatch_command(
+    cfg,
+    *,
+    command_id: str,
+    args_text: str,
+    full_text: str,
+    channel_id: str,
+    message_id: str,
+    thread_id: str | None,
+    reply_ref: MessageRef | None,
+    reply_text: str | None,
+    running_tasks: RunningTasks,
+    on_thread_known: Callable[[ResumeToken, anyio.Event], Awaitable[None]] | None,
+    default_engine_override: EngineId | None,
+    default_context,
+    engine_overrides_resolver: Callable[[EngineId], Awaitable[EngineRunOptions | None]]
+    | None,
+) -> bool:
+    allowlist = cfg.runtime.allowlist
+
+    executor = SlackCommandExecutor(
+        exec_cfg=cfg.exec_cfg,
+        runtime=cfg.runtime,
+        running_tasks=running_tasks,
+        on_thread_known=on_thread_known,
+        engine_overrides_resolver=engine_overrides_resolver,
+        channel_id=channel_id,
+        user_msg_id=message_id,
+        thread_id=thread_id,
+        show_resume_line=True,
+        default_engine_override=default_engine_override,
+        default_context=default_context,
+    )
+
+    message_ref = MessageRef(
+        channel_id=channel_id,
+        message_id=message_id,
+        thread_id=thread_id,
+    )
+
+    try:
+        backend = get_command(command_id, allowlist=allowlist, required=False)
+    except ConfigError as exc:
+        await executor.send(f"error:\n{exc}", reply_to=message_ref, notify=True)
+        return True
+
+    if backend is None:
+        return False
+
+    try:
+        plugin_config = cfg.runtime.plugin_config(command_id)
+    except ConfigError as exc:
+        await executor.send(f"error:\n{exc}", reply_to=message_ref, notify=True)
+        return True
+
+    ctx = CommandContext(
+        command=command_id,
+        text=full_text,
+        args_text=args_text,
+        args=split_command_args(args_text),
+        message=message_ref,
+        reply_to=reply_ref,
+        reply_text=reply_text,
+        config_path=cfg.runtime.config_path,
+        plugin_config=plugin_config,
+        runtime=cfg.runtime,
+        executor=executor,
+    )
+
+    try:
+        result = await backend.handle(ctx)
+    except Exception as exc:
+        logger.exception(
+            "command.failed",
+            command=command_id,
+            error=str(exc),
+            error_type=exc.__class__.__name__,
+        )
+        await executor.send(f"error:\n{exc}", reply_to=message_ref, notify=True)
+        return True
+
+    if result is not None:
+        reply_to = message_ref if result.reply_to is None else result.reply_to
+        await executor.send(result.text, reply_to=reply_to, notify=result.notify)
+
+    return True

takopi_slack_plugin/commands/executor.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Sequence
+from dataclasses import dataclass
+
+import anyio
+
+from takopi.commands import CommandExecutor, RunMode, RunRequest, RunResult
+from takopi.context import RunContext
+from takopi.model import EngineId, ResumeToken
+from takopi.runner_bridge import ExecBridgeConfig, RunningTasks
+from takopi.runners.run_options import EngineRunOptions
+from takopi.transport import MessageRef, RenderedMessage, SendOptions
+from takopi.transport_runtime import TransportRuntime
+
+from ..engine import run_engine
+
+
+class _CaptureTransport:
+    def __init__(self) -> None:
+        self._next_id = 1
+        self.last_message: RenderedMessage | None = None
+
+    async def send(
+        self,
+        *,
+        channel_id: int | str,
+        message: RenderedMessage,
+        options: SendOptions | None = None,
+    ) -> MessageRef:
+        thread_id = options.thread_id if options is not None else None
+        ref = MessageRef(channel_id=channel_id, message_id=self._next_id)
+        self._next_id += 1
+        self.last_message = message
+        return MessageRef(
+            channel_id=ref.channel_id,
+            message_id=ref.message_id,
+            thread_id=thread_id,
+        )
+
+    async def edit(
+        self, *, ref: MessageRef, message: RenderedMessage, wait: bool = True
+    ) -> MessageRef:
+        _ = wait
+        self.last_message = message
+        return ref
+
+    async def delete(self, *, ref: MessageRef) -> bool:
+        _ = ref
+        return True
+
+    async def close(self) -> None:
+        return None
+
+
+@dataclass(slots=True)
+class SlackCommandExecutor(CommandExecutor):
+    exec_cfg: ExecBridgeConfig
+    runtime: TransportRuntime
+    running_tasks: RunningTasks
+    on_thread_known: Callable[[ResumeToken, anyio.Event], Awaitable[None]] | None
+    engine_overrides_resolver: Callable[
+        [EngineId], Awaitable[EngineRunOptions | None]
+    ] | None
+    channel_id: str
+    user_msg_id: str
+    thread_id: str | None
+    show_resume_line: bool
+    default_engine_override: EngineId | None
+    default_context: RunContext | None
+
+    def _apply_default_context(self, request: RunRequest) -> RunRequest:
+        if request.context is not None or self.default_context is None:
+            return request
+        return RunRequest(
+            prompt=request.prompt,
+            engine=request.engine,
+            context=self.default_context,
+        )
+
+    def _apply_default_engine(self, request: RunRequest) -> RunRequest:
+        if request.engine is not None or self.default_engine_override is None:
+            return request
+        return RunRequest(
+            prompt=request.prompt,
+            engine=self.default_engine_override,
+            context=request.context,
+        )
+
+    async def send(
+        self,
+        message: RenderedMessage | str,
+        *,
+        reply_to: MessageRef | None = None,
+        notify: bool = True,
+    ) -> MessageRef | None:
+        rendered = (
+            message
+            if isinstance(message, RenderedMessage)
+            else RenderedMessage(text=message)
+        )
+        reply_ref = (
+            MessageRef(
+                channel_id=self.channel_id,
+                message_id=self.user_msg_id,
+                thread_id=self.thread_id,
+            )
+            if reply_to is None
+            else reply_to
+        )
+        return await self.exec_cfg.transport.send(
+            channel_id=self.channel_id,
+            message=rendered,
+            options=SendOptions(
+                reply_to=reply_ref,
+                notify=notify,
+                thread_id=self.thread_id,
+            ),
+        )
+
+    async def run_one(
+        self, request: RunRequest, *, mode: RunMode = "emit"
+    ) -> RunResult:
+        request = self._apply_default_context(request)
+        request = self._apply_default_engine(request)
+        engine = self.runtime.resolve_engine(
+            engine_override=request.engine,
+            context=request.context,
+        )
+        run_options = None
+        if self.engine_overrides_resolver is not None:
+            run_options = await self.engine_overrides_resolver(engine)
+
+        if mode == "capture":
+            capture = _CaptureTransport()
+            exec_cfg = ExecBridgeConfig(
+                transport=capture,
+                presenter=self.exec_cfg.presenter,
+                final_notify=False,
+            )
+            await run_engine(
+                exec_cfg=exec_cfg,
+                runtime=self.runtime,
+                running_tasks={},
+                channel_id=self.channel_id,
+                user_msg_id=self.user_msg_id,
+                text=request.prompt,
+                resume_token=None,
+                context=request.context,
+                engine_override=engine,
+                thread_id=self.thread_id,
+                on_thread_known=self.on_thread_known,
+                run_options=run_options,
+            )
+            return RunResult(engine=engine, message=capture.last_message)
+
+        await run_engine(
+            exec_cfg=self.exec_cfg,
+            runtime=self.runtime,
+            running_tasks=self.running_tasks,
+            channel_id=self.channel_id,
+            user_msg_id=self.user_msg_id,
+            text=request.prompt,
+            resume_token=None,
+            context=request.context,
+            engine_override=engine,
+            thread_id=self.thread_id,
+            on_thread_known=self.on_thread_known,
+            run_options=run_options,
+        )
+        return RunResult(engine=engine, message=None)
+
+    async def run_many(
+        self,
+        requests: Sequence[RunRequest],
+        *,
+        mode: RunMode = "emit",
+        parallel: bool = False,
+    ) -> list[RunResult]:
+        if not parallel:
+            return [await self.run_one(request, mode=mode) for request in requests]
+        results: list[RunResult | None] = [None] * len(requests)
+
+        async with anyio.create_task_group() as tg:
+
+            async def run_idx(idx: int, request: RunRequest) -> None:
+                results[idx] = await self.run_one(request, mode=mode)
+
+            for idx, request in enumerate(requests):
+                tg.start_soon(run_idx, idx, request)
+
+        return [result for result in results if result is not None]

takopi_slack_plugin/config.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal
+
+from takopi.api import ConfigError
+
+
+@dataclass(frozen=True, slots=True)
+class SlackTransportSettings:
+    bot_token: str
+    channel_id: str
+    app_token: str
+    message_overflow: Literal["trim", "split"] = "split"
+
+    @classmethod
+    def from_config(
+        cls, config: object, *, config_path: Path
+    ) -> "SlackTransportSettings":
+        if isinstance(config, SlackTransportSettings):
+            return config
+        if not isinstance(config, dict):
+            raise ConfigError(
+                f"Invalid `transports.slack` in {config_path}; expected a table."
+            )
+
+        bot_token = _require_str(config, "bot_token", config_path=config_path)
+        channel_id = _require_str(config, "channel_id", config_path=config_path)
+        app_token = _require_str(config, "app_token", config_path=config_path)
+
+        message_overflow = config.get("message_overflow", "split")
+        if not isinstance(message_overflow, str):
+            raise ConfigError(
+                f"Invalid `transports.slack.message_overflow` in {config_path}; "
+                "expected a string."
+            )
+        message_overflow = message_overflow.strip()
+        if message_overflow not in {"trim", "split"}:
+            raise ConfigError(
+                f"Invalid `transports.slack.message_overflow` in {config_path}; "
+                "expected 'trim' or 'split'."
+            )
+
+        return cls(
+            bot_token=bot_token,
+            channel_id=channel_id,
+            app_token=app_token,
+            message_overflow=message_overflow,
+        )
+
+
+def _require_str(config: dict[str, Any], key: str, *, config_path: Path) -> str:
+    value = config.get(key)
+    if not isinstance(value, str) or not value.strip():
+        raise ConfigError(
+            f"Invalid `transports.slack.{key}` in {config_path}; "
+            "expected a non-empty string."
+        )
+    return value.strip()