xyberos-slack 0.1.0__tar.gz

xyberos_slack-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: xyberos-slack
+Version: 0.1.0
+Summary: Slack Web API plugin (RFC-0019, M7): post messages, list channels
+License: Apache-2.0
+Keywords: xyberos,plugin,slack,tool
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: xyberos>=1.0
+
+# xyberos-slack
+
+**Slack Web API plugin — RFC-0019, M7 (community wave).** Post messages and
+list channels from Xyberos agents via the Slack Web API. Stdlib-only with an
+injectable transport for tests.
+
+## Install
+
+```bash
+pip install -e ./slack
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_slack import SlackPlugin
+
+app = create_app()
+app.load_plugin(SlackPlugin())              # token from SLACK_TOKEN
+
+app.tools.execute("slack_post_message", None, channel="general", text="hello")
+app.tools.execute("slack_list_channels", None, limit=100)
+```
+
+## Tools
+
+| Tool | Notes |
+| ---- | ----- |
+| `slack_post_message(channel, text)` | post to a channel |
+| `slack_list_channels(limit=100)` | public channels |
+
+Requires `SLACK_TOKEN` (a bot token with `chat:write` / `channels:read`).
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Canned responses via an injectable transport — no network.
+
+## Ship location
+
+Plugin (`xyberos.plugins` entry point) — community wave (M7).

xyberos_slack-0.1.0/README.md

@@ -0,0 +1,46 @@
+# xyberos-slack
+
+**Slack Web API plugin — RFC-0019, M7 (community wave).** Post messages and
+list channels from Xyberos agents via the Slack Web API. Stdlib-only with an
+injectable transport for tests.
+
+## Install
+
+```bash
+pip install -e ./slack
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_slack import SlackPlugin
+
+app = create_app()
+app.load_plugin(SlackPlugin())              # token from SLACK_TOKEN
+
+app.tools.execute("slack_post_message", None, channel="general", text="hello")
+app.tools.execute("slack_list_channels", None, limit=100)
+```
+
+## Tools
+
+| Tool | Notes |
+| ---- | ----- |
+| `slack_post_message(channel, text)` | post to a channel |
+| `slack_list_channels(limit=100)` | public channels |
+
+Requires `SLACK_TOKEN` (a bot token with `chat:write` / `channels:read`).
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Canned responses via an injectable transport — no network.
+
+## Ship location
+
+Plugin (`xyberos.plugins` entry point) — community wave (M7).

xyberos_slack-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xyberos-slack"
+version = "0.1.0"
+description = "Slack Web API plugin (RFC-0019, M7): post messages, list channels"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+dependencies = ["xyberos>=1.0"]
+keywords = ["xyberos", "plugin", "slack", "tool"]
+
+[project.entry-points."xyberos.plugins"]
+slack = "xyberos_slack.plugin:plugin"
+
+[tool.setuptools]
+packages = ["xyberos_slack"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]

xyberos_slack-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xyberos_slack-0.1.0/tests/test_client.py

@@ -0,0 +1,49 @@
+"""Tests for the Slack Web API client (injectable transport, no network)."""
+
+from __future__ import annotations
+
+import pytest
+from xyberos.exceptions.provider import ProviderError
+
+from xyberos_slack import SlackClient
+
+
+def _fake_request():
+    def request(method, url, **kwargs):
+        if url.endswith("/chat.postMessage"):
+            return 200, {"ok": True, "channel": "C123", "ts": "1700000000.000001"}
+        if url.endswith("/conversations.list"):
+            return 200, {"ok": True, "channels": [{"id": "C123", "name": "general"}]}
+        return 200, {"ok": False, "error": "not_authed"}
+
+    return request
+
+
+def test_post_message():
+    request = _fake_request()
+    client = SlackClient(token="t", request=request)
+    result = client.post_message("general", "hello")
+    assert result == {"ok": True, "channel": "C123", "ts": "1700000000.000001"}
+
+
+def test_list_channels():
+    request = _fake_request()
+    client = SlackClient(token="t", request=request)
+    channels = client.list_channels(limit=50)
+    assert channels == [{"id": "C123", "name": "general"}]
+
+
+def test_slack_ok_false_raises():
+    def request(method, url, **kwargs):
+        return 200, {"ok": False, "error": "not_authed"}
+
+    client = SlackClient(token="t", request=request)
+    with pytest.raises(ProviderError, match="not_authed"):
+        client.list_channels()
+
+
+def test_requires_token():
+    request = _fake_request()
+    client = SlackClient(token=None, request=request)
+    with pytest.raises(ProviderError, match="token"):
+        client.post_message("general", "hi")

xyberos_slack-0.1.0/tests/test_plugin.py

@@ -0,0 +1,28 @@
+"""Tests for loading the Slack plugin into a Xyberos app."""
+
+from __future__ import annotations
+
+from xyberos import create_app
+
+from xyberos_slack import SlackPlugin
+
+
+def _fake_request():
+    def request(method, url, **kwargs):
+        if url.endswith("/chat.postMessage"):
+            return 200, {"ok": True, "channel": "C123", "ts": "1"}
+        return 200, {"ok": True, "channels": [{"id": "C123", "name": "general"}]}
+
+    return request
+
+
+def test_plugin_registers_and_executes():
+    app = create_app()
+    app.load_plugin(SlackPlugin(token="t", request=_fake_request()))
+    assert "slack_post_message" in app.tools.names
+    assert "slack_list_channels" in app.tools.names
+
+    result = app.tools.execute("slack_post_message", None, channel="general", text="hi")
+    assert result["ok"] is True
+
+    app.unload_plugin("slack")

xyberos_slack-0.1.0/xyberos_slack/__init__.py

@@ -0,0 +1,6 @@
+"""Slack Web API plugin (RFC-0019, M7)."""
+
+from .client import SlackClient
+from .plugin import SlackPlugin
+
+__all__ = ["SlackClient", "SlackPlugin"]

xyberos_slack-0.1.0/xyberos_slack/client.py

@@ -0,0 +1,68 @@
+"""A minimal Slack Web API client (stdlib ``urllib``, injectable transport)."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from xyberos.exceptions.provider import ProviderError
+
+from .http import RequestTransport, default_request
+
+
+def _raise_for_status(status: int, body: Any) -> None:
+    if 200 <= status < 300:
+        return
+    message = body if isinstance(body, str) else str(body)
+    raise ProviderError(f"Slack API returned HTTP {status}: {message[:200]}")
+
+
+class SlackClient:
+    """Thin client for the Slack Web API."""
+
+    def __init__(
+        self,
+        token: str | None = None,
+        *,
+        base_url: str = "https://slack.com/api",
+        request: RequestTransport | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._token = token if token is not None else os.getenv("SLACK_TOKEN")
+        self._base_url = base_url.rstrip("/")
+        self._request = request or default_request
+        self._timeout = timeout
+
+    def post_message(self, channel: str, text: str) -> dict[str, Any]:
+        status, body = self._request(
+            "POST",
+            f"{self._base_url}/chat.postMessage",
+            json_body={"channel": channel, "text": text},
+            headers=self._headers(),
+            timeout=self._timeout,
+        )
+        _raise_for_status(status, body)
+        self._check_ok(body, "post_message")
+        return {"ok": True, "channel": body.get("channel"), "ts": body.get("ts")}
+
+    def list_channels(self, limit: int = 100) -> list[dict[str, Any]]:
+        status, body = self._request(
+            "GET",
+            f"{self._base_url}/conversations.list",
+            query={"types": "public_channel", "limit": limit},
+            headers=self._headers(),
+            timeout=self._timeout,
+        )
+        _raise_for_status(status, body)
+        self._check_ok(body, "list_channels")
+        return [{"id": channel.get("id"), "name": channel.get("name")} for channel in body.get("channels", [])]
+
+    def _headers(self) -> dict[str, str]:
+        if not self._token:
+            raise ProviderError("Slack requires a token (set SLACK_TOKEN)")
+        return {"Authorization": f"Bearer {self._token}"}
+
+    @staticmethod
+    def _check_ok(body: Any, action: str) -> None:
+        if isinstance(body, dict) and body.get("ok") is False:
+            raise ProviderError(f"Slack '{action}' failed: {body.get('error')}")

xyberos_slack-0.1.0/xyberos_slack/http.py

@@ -0,0 +1,57 @@
+"""A tiny stdlib HTTP helper (no third-party deps).
+
+``default_request`` performs one HTTP request with ``urllib`` and returns
+``(status, body)`` where ``body`` is parsed JSON when the response is JSON,
+otherwise raw text. Injectable so tests run without a network.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Callable
+
+#: (method, url, *, json_body, headers, query, timeout) -> (status, body)
+RequestTransport = Callable[..., tuple[int, Any]]
+
+
+def default_request(
+    method: str,
+    url: str,
+    *,
+    json_body: Any = None,
+    headers: dict[str, str] | None = None,
+    query: dict[str, Any] | None = None,
+    timeout: float = 30.0,
+) -> tuple[int, Any]:
+    """Send one request and return ``(status, parsed_json_or_text)``."""
+    final_url = url
+    if query:
+        separator = "&" if "?" in url else "?"
+        final_url = url + separator + urllib.parse.urlencode(query)
+
+    data: bytes | None = None
+    request_headers = dict(headers or {})
+    if json_body is not None:
+        data = json.dumps(json_body).encode("utf-8")
+        request_headers.setdefault("Content-Type", "application/json")
+
+    request = urllib.request.Request(
+        final_url, data=data, headers=request_headers, method=method
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            raw = response.read()
+            content_type = response.headers.get("Content-Type", "")
+    except urllib.error.HTTPError as exc:
+        return exc.code, exc.read().decode("utf-8", errors="replace")
+
+    text = raw.decode("utf-8", errors="replace")
+    if "application/json" in content_type or text.lstrip().startswith("{"):
+        try:
+            return 200, json.loads(text)
+        except json.JSONDecodeError:
+            return 200, text
+    return 200, text

xyberos_slack-0.1.0/xyberos_slack/plugin.py

@@ -0,0 +1,60 @@
+"""Slack plugin entry point (RFC-0019, M7)."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from xyberos.contracts import Plugin, Tool
+from xyberos.tools import FunctionTool
+
+from .client import SlackClient
+from .http import RequestTransport
+
+
+def _pop_tool(registry: Any, name: str) -> None:
+    unregister = getattr(registry, "unregister", None)
+    if callable(unregister):
+        unregister(name)
+        return
+    store = getattr(registry, "_tools", None)
+    if isinstance(store, dict):
+        cast(dict[str, Any], store).pop(name, None)
+
+
+class SlackPlugin(Plugin):
+    """Registers Slack tools (post messages / list channels)."""
+
+    def __init__(self, token: str | None = None, *, request: RequestTransport | None = None) -> None:
+        self._client = SlackClient(token, request=request)
+
+    @property
+    def name(self) -> str:
+        return "slack"
+
+    def tools(self) -> list[Tool]:
+        client = self._client
+
+        def _post_message(channel: str, text: str) -> dict[str, Any]:
+            return client.post_message(channel, text)
+
+        def _list_channels(limit: int = 100) -> list[dict[str, Any]]:
+            return client.list_channels(limit)
+
+        return [
+            FunctionTool("slack_post_message", _post_message, description="Post a message to a Slack channel."),
+            FunctionTool("slack_list_channels", _list_channels, description="List public Slack channels."),
+        ]
+
+    def register(self, kernel: object) -> None:
+        registry = kernel.resolve("tools")
+        for tool in self.tools():
+            registry.register(tool)
+
+    def unregister(self, kernel: object) -> None:
+        registry = kernel.resolve("tools")
+        for tool in self.tools():
+            _pop_tool(registry, tool.name)
+
+
+#: Auto-discovered by ``app.load_entry_points()``.
+plugin = SlackPlugin()

xyberos_slack-0.1.0/xyberos_slack.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: xyberos-slack
+Version: 0.1.0
+Summary: Slack Web API plugin (RFC-0019, M7): post messages, list channels
+License: Apache-2.0
+Keywords: xyberos,plugin,slack,tool
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: xyberos>=1.0
+
+# xyberos-slack
+
+**Slack Web API plugin — RFC-0019, M7 (community wave).** Post messages and
+list channels from Xyberos agents via the Slack Web API. Stdlib-only with an
+injectable transport for tests.
+
+## Install
+
+```bash
+pip install -e ./slack
+```
+
+## Usage
+
+```python
+from xyberos import create_app
+from xyberos_slack import SlackPlugin
+
+app = create_app()
+app.load_plugin(SlackPlugin())              # token from SLACK_TOKEN
+
+app.tools.execute("slack_post_message", None, channel="general", text="hello")
+app.tools.execute("slack_list_channels", None, limit=100)
+```
+
+## Tools
+
+| Tool | Notes |
+| ---- | ----- |
+| `slack_post_message(channel, text)` | post to a channel |
+| `slack_list_channels(limit=100)` | public channels |
+
+Requires `SLACK_TOKEN` (a bot token with `chat:write` / `channels:read`).
+
+## Tests
+
+```bash
+pip install pytest
+pytest tests/
+```
+
+Canned responses via an injectable transport — no network.
+
+## Ship location
+
+Plugin (`xyberos.plugins` entry point) — community wave (M7).

xyberos_slack-0.1.0/xyberos_slack.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+tests/test_client.py
+tests/test_plugin.py
+xyberos_slack/__init__.py
+xyberos_slack/client.py
+xyberos_slack/http.py
+xyberos_slack/plugin.py
+xyberos_slack.egg-info/PKG-INFO
+xyberos_slack.egg-info/SOURCES.txt
+xyberos_slack.egg-info/dependency_links.txt
+xyberos_slack.egg-info/entry_points.txt
+xyberos_slack.egg-info/requires.txt
+xyberos_slack.egg-info/top_level.txt

xyberos_slack-0.1.0/xyberos_slack.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xyberos_slack-0.1.0/xyberos_slack.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[xyberos.plugins]
+slack = xyberos_slack.plugin:plugin

xyberos_slack-0.1.0/xyberos_slack.egg-info/requires.txt

@@ -0,0 +1 @@
+xyberos>=1.0

xyberos_slack-0.1.0/xyberos_slack.egg-info/top_level.txt

@@ -0,0 +1 @@
+xyberos_slack