aethergraph 0.1.0a1__py3-none-any.whl

aethergraph/plugins/channel/utils/telegram_utils.py

@@ -0,0 +1,324 @@
+import hmac
+import json
+from typing import Any
+
+import aiohttp
+from fastapi import APIRouter, HTTPException, Request
+
+from aethergraph.services.continuations.continuation import Correlator
+
+router = APIRouter()
+
+# Reuse one aiohttp session with timeouts
+_aiohttp_session: aiohttp.ClientSession | None = None
+
+
+def _http_session() -> aiohttp.ClientSession:
+    global _aiohttp_session
+    if _aiohttp_session is None or _aiohttp_session.closed:
+        timeout = aiohttp.ClientTimeout(
+            total=40,  # > 30
+            connect=5,
+            sock_read=35,  # > 30
+        )
+        connector = aiohttp.TCPConnector(limit=50, ttl_dns_cache=300)
+        _aiohttp_session = aiohttp.ClientSession(timeout=timeout, connector=connector)
+    return _aiohttp_session
+
+
+def _verify_secret(request: Request):
+    TELEGRAM_WEBHOOK_SECRET = (
+        request.app.state.settings.telegram.webhook_secret.get_secret_value() or ""
+    )
+    if not TELEGRAM_WEBHOOK_SECRET:
+        raise HTTPException(401, "no telegram webhook secret configured")
+    if TELEGRAM_WEBHOOK_SECRET:
+        hdr = request.headers.get("X-Telegram-Bot-Api-Secret-Token")
+        if not hmac.compare_digest(hdr or "", TELEGRAM_WEBHOOK_SECRET):
+            raise HTTPException(401, "bad telegram webhook secret")
+
+
+def _channel_key(chat_id: int, topic_id: int | None) -> str:
+    base = f"tg:chat/{int(chat_id)}"
+    return f"{base}:topic/{int(topic_id)}" if topic_id else base
+
+
+# ---- helpers ----
+async def _tg_get_file_path(file_id: str, token: str) -> str | None:
+    if not token:
+        return None
+    api = f"https://api.telegram.org/bot{token}/getFile"
+    async with _http_session().post(api, json={"file_id": file_id}) as r:
+        if r.status != 200:
+            return None
+        data = await r.json()
+        if not data.get("ok"):
+            return None
+        return (data.get("result") or {}).get("file_path")
+
+
+async def _tg_download_file(file_path: str, token: str) -> bytes:
+    url = f"https://api.telegram.org/file/bot{token}/{file_path}"
+    async with _http_session().get(url) as r:
+        r.raise_for_status()
+        return await r.read()
+
+
+# -------- NEW: background worker that does the heavy lifting --------
+async def _process_update(container, payload: dict, token: str):
+    try:
+        # Callback queries (inline button presses)
+        cq = payload.get("callback_query")
+        if cq:
+            msg = cq.get("message") or {}
+            chat = msg.get("chat") or {}
+            chat_id = chat.get("id")
+            topic_id = msg.get("message_thread_id")
+            ch_key = _channel_key(chat_id, topic_id)
+
+            data_raw = cq.get("data") or ""
+            choice = "reject"
+            resume_key = None
+
+            # Accept JSON or compact "c=...|k=..." forms
+            try:
+                data = json.loads(data_raw)
+                choice = str(data.get("choice", "reject"))
+                resume_key = data.get("resume_key") or data.get("k")
+            except Exception:
+                try:
+                    parts = dict(p.split("=", 1) for p in data_raw.split("|") if "=" in p)
+                    choice = parts.get("c", "reject")
+                    resume_key = parts.get("k")
+                except Exception:
+                    choice = str(data_raw)
+
+            choice_l = choice.lower()
+            # approved = choice_l.startswith("approve") or choice_l in {"yes","y","ok"} # resolve from choice string
+
+            token = None
+            run_id = None
+            node_id = None
+
+            # Resolve alias → token (preferred)
+            if resume_key and hasattr(container.cont_store, "token_from_alias"):
+                token = container.cont_store.token_from_alias(resume_key)
+
+            if token and hasattr(container.cont_store, "get_by_token"):
+                cont = container.cont_store.get_by_token(token)
+                if cont:
+                    run_id, node_id = cont.run_id, cont.node_id
+
+            # Fallback: thread-scoped correlator
+            if not token:
+                corr = Correlator(
+                    scheme="tg", channel=ch_key, thread=str(topic_id or ""), message=""
+                )
+                cont = await container.cont_store.find_by_correlator(corr=corr)
+                if cont:
+                    run_id, node_id, token = cont.run_id, cont.node_id, cont.token
+
+            if token and run_id and node_id:
+                await container.resume_router.resume(
+                    run_id=run_id,
+                    node_id=node_id,
+                    token=token,
+                    payload={
+                        "choice": choice_l,
+                        "telegram": {
+                            "callback_id": cq.get("id"),
+                            "message_id": msg.get("message_id"),
+                            "chat_id": chat_id,
+                        },
+                    },
+                )
+
+            # Ack the button press to stop the spinner
+            try:
+                tg_adapter = container.channels.adapters.get("tg")
+                if tg_adapter:
+                    await tg_adapter._api("answerCallbackQuery", callback_query_id=cq.get("id"))
+            except Exception:
+                pass
+            return
+
+        # Regular messages / uploads
+        msg = payload.get("message")
+        if not msg:
+            return
+        if (msg.get("from") or {}).get("is_bot"):
+            return
+
+        chat = msg.get("chat") or {}
+        chat_id = chat.get("id")
+        topic_id = msg.get("message_thread_id")
+        ch_key = _channel_key(chat_id, topic_id)
+        text = (msg.get("text") or msg.get("caption") or "") or ""
+
+        files: list[dict[str, Any]] = []
+
+        # Photos
+        photos = msg.get("photo") or []
+        if photos:
+            ph = photos[-1]
+            file_id = ph.get("file_id")
+            size = ph.get("file_size")
+            name = f"photo_{file_id}.jpg"
+            file_path = await _tg_get_file_path(file_id, token)
+            if file_path:
+                try:
+                    data = await _tg_download_file(file_path, token)
+                    uri = await _stage_and_save(
+                        container, data=data, name=name, ch_key=ch_key, cont=None
+                    )
+                    files.append(
+                        _file_ref(
+                            file_id=file_id,
+                            name=name,
+                            mimetype="image/jpeg",
+                            size=size,
+                            uri=uri,
+                            ch_key=ch_key,
+                            ts=msg.get("date"),
+                        )
+                    )
+                except Exception as e:
+                    container.logger and container.logger.for_run().warning(
+                        f"Telegram photo download failed: {e}"
+                    )
+
+        # Documents
+        doc = msg.get("document")
+        if doc:
+            file_id = doc.get("file_id")
+            size = doc.get("file_size")
+            name = doc.get("file_name") or f"document_{file_id}"
+            mime = _normalize_mime_by_name(name, doc.get("mime_type"))
+            file_path = await _tg_get_file_path(file_id, token)
+            if file_path:
+                try:
+                    data = await _tg_download_file(file_path, token)
+                    uri = _stage_and_save(container, data=data, name=name, ch_key=ch_key, cont=None)
+                    files.append(
+                        _file_ref(
+                            file_id=file_id,
+                            name=name,
+                            mimetype=mime,
+                            size=size,
+                            uri=uri,
+                            ch_key=ch_key,
+                            ts=msg.get("date"),
+                        )
+                    )
+                except Exception as e:
+                    container.logger and container.logger.for_run().warning(
+                        f"Telegram document download failed: {e}"
+                    )
+
+        if files:
+            await _append_inbox(container, ch_key, files)
+
+        # Look up continuation by thread-scoped correlator (message-less)
+        cont = None
+        corr = Correlator(scheme="tg", channel=ch_key, thread=str(topic_id or ""), message="")
+        cont = await container.cont_store.find_by_correlator(corr=corr)
+        container.logger and container.logger.for_run().debug(
+            f"[TG] inbound: text='{text}' files={len(files)} cont={bool(cont)}"
+        )
+
+        if not cont:
+            return
+
+        payload_out = {
+            "text": text,
+            "telegram": {"message_id": msg.get("message_id"), "chat_id": chat_id},
+        }
+        if cont.kind in ("user_files", "user_input_or_files"):
+            payload_out["files"] = files
+
+        await container.resume_router.resume(cont.run_id, cont.node_id, cont.token, payload_out)
+
+    except Exception as e:
+        container.logger and container.logger.for_run().error(
+            f"Telegram inbound processing error: {e}", exc_info=True
+        )
+
+
+# ---- file helpers ----
+def _normalize_mime_by_name(name: str | None, hint: str | None) -> str:
+    extmap = {
+        "png": "image/png",
+        "jpg": "image/jpeg",
+        "jpeg": "image/jpeg",
+        "gif": "image/gif",
+        "webp": "image/webp",
+        "tif": "image/tiff",
+        "tiff": "image/tiff",
+        "bmp": "image/bmp",
+        "svg": "image/svg+xml",
+        "pdf": "application/pdf",
+        "csv": "text/csv",
+        "json": "application/json",
+        "yaml": "text/yaml",
+        "yml": "text/yaml",
+        "txt": "text/plain",
+        "md": "text/markdown",
+        "zip": "application/zip",
+        "gz": "application/gzip",
+        "tar": "application/x-tar",
+        "7z": "application/x-7z-compressed",
+        "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "mph": "application/octet-stream",
+    }
+    if hint:
+        return hint.lower()
+    if name and "." in name:
+        ext = name.lower().rsplit(".", 1)[-1]
+        return extmap.get(ext, "application/octet-stream")
+    return "application/octet-stream"
+
+
+async def _stage_and_save(container, *, data: bytes, name: str, ch_key: str, cont) -> str:
+    tmp = container.artifacts.tmp_path(suffix=f"_{name}")
+    with open(tmp, "wb") as f:
+        f.write(data)
+    run_id = cont.run_id if cont else "ad-hoc"
+    node_id = cont.node_id if cont else "telegram"
+    art = await container.artifacts.save_file(
+        path=tmp,
+        kind="upload",
+        run_id=run_id,
+        graph_id="channel",
+        node_id=node_id,
+        tool_name="telegram.upload",
+        tool_version="0.0.1",
+        labels={"source": "telegram", "channel": ch_key, "name": name},
+    )
+    return getattr(art, "uri", None) or f"file://{tmp}"
+
+
+def _file_ref(
+    *, file_id: str, name: str, mimetype: str, size: int | None, uri: str, ch_key: str, ts: Any
+):
+    return {
+        "id": file_id,
+        "name": name,
+        "mimetype": mimetype or "",
+        "size": size,
+        "uri": uri,
+        "url_private": None,
+        "platform": "telegram",
+        "channel_key": ch_key,
+        "ts": ts,
+    }
+
+
+async def _append_inbox(container, ch_key: str, file_refs: list[dict[str, Any]]):
+    kv = getattr(container, "kv_hot", None)
+    if kv:
+        await kv.list_append_unique(f"inbox://{ch_key}", file_refs, id_key="id")
+    else:
+        logger = getattr(container, "logger", None)
+        logger and logger.for_run().warning("No KV present; uploads inbox not stored.")

aethergraph/plugins/channel/websockets/slack_ws.py

@@ -0,0 +1,68 @@
+from aethergraph.utils.optdeps import require
+
+from ..utils.slack_utils import handle_slack_events_common, handle_slack_interactive_common
+
+try:
+    require(pkg="slack_sdk", extra="slack")
+    from slack_sdk.socket_mode.aiohttp import SocketModeClient
+    from slack_sdk.socket_mode.request import SocketModeRequest
+    from slack_sdk.web.async_client import AsyncWebClient
+except ImportError:
+    raise ImportError(
+        "slack_sdk is required for SlackSocketModeRunner; please install aethergraph with the [slack] extra."
+    ) from None
+
+
+class SlackSocketModeRunner:
+    def __init__(self, container, settings):
+        self.container = container
+        self.settings = settings
+
+        self.bot_token = (
+            settings.slack.bot_token.get_secret_value() if settings.slack.bot_token else ""
+        )
+        self.app_token = (
+            settings.slack.app_token.get_secret_value() if settings.slack.app_token else ""
+        )  # xapp-...
+
+        self.web_client = AsyncWebClient(token=self.bot_token)
+        self.client: SocketModeClient | None = None
+
+    async def _handle_socket_request(self, client: SocketModeClient, req: SocketModeRequest):
+        # events from Slack
+        if req.type == "events_api":
+            # req.payload has same shape as HTTP Events API body
+            await handle_slack_events_common(self.container, self.settings, req.payload)
+            await client.send_socket_mode_response({"envelope_id": req.envelope_id})
+            return
+
+        # interactive actions (buttons, etc.)
+        if req.type == "interactive":
+            # payload is already parsed JSON dict
+            payload = req.payload
+            await handle_slack_interactive_common(self.container, payload)
+            await client.send_socket_mode_response({"envelope_id": req.envelope_id})
+            return
+
+        # other request types (slash commands, shortcuts, etc.) can be added later
+        await client.send_socket_mode_response({"envelope_id": req.envelope_id})
+
+    async def start(self):
+        lg = self.container.logger.for_run()
+        if not (self.bot_token and self.app_token):
+            lg.warning(
+                "[Slack SocketMode] bot_token or app_token not configured; skipping Socket Mode startup."
+            )
+            return
+
+        self.client = SocketModeClient(
+            app_token=self.app_token,
+            web_client=self.web_client,
+        )
+        # register listener
+        self.client.socket_mode_request_listeners.append(self._handle_socket_request)
+
+        lg.info("[Slack SocketMode] connecting to Slack...")
+        await self.client.connect()
+        # NOTE: this call returns immediately; the internal loop lives with the event loop
+        lg.info("[Slack SocketMode] connected.")

aethergraph/plugins/channel/websockets/telegram_polling.py

@@ -0,0 +1,151 @@
+# telegram_polling.py
+import asyncio
+import json
+from typing import Any
+
+import aiohttp
+
+from ..utils.telegram_utils import _http_session, _process_update
+
+
+class TelegramPollingRunner:
+    def __init__(self, container, settings):
+        self.container = container
+        self.settings = settings
+        self.bot_token: str = settings.telegram.bot_token.get_secret_value() or ""
+        self._stop = False
+
+    async def stop(self):
+        self._stop = True
+
+    async def _fetch_updates(self, offset: int | None) -> list[dict[str, Any]]:
+        if not self.bot_token:
+            self.container.logger.for_run().warning(
+                "[TelegramPolling] no bot token, skipping fetch"
+            )
+            return []
+
+        api = f"https://api.telegram.org/bot{self.bot_token}/getUpdates"
+        params: dict[str, Any] = {"timeout": 30}
+        if offset is not None:
+            params["offset"] = offset
+
+        try:
+            sess = _http_session()
+            async with sess.get(api, params=params) as r:
+                status = r.status
+                # Read raw text so we can log even if JSON parse fails
+                raw = await r.text()
+
+                if status != 200:
+                    self.container.logger.for_run().warning(
+                        f"[TelegramPolling] non-200 status: {status}, returning empty list"
+                    )
+                    return []
+
+                try:
+                    data = json.loads(raw)
+                except Exception as e:
+                    self.container.logger.for_run().error(
+                        f"[TelegramPolling] JSON decode error: {e}"
+                    )
+                    return []
+
+                if not data.get("ok"):
+                    self.container.logger.for_run().warning(
+                        f"[TelegramPolling] ok=false in response: {data}"
+                    )
+                    return []
+
+                result = data.get("result") or []
+                if result:
+                    first_id = result[0].get("update_id")
+                    last_id = result[-1].get("update_id")
+                    self.container.logger.for_run().info(
+                        f"[TelegramPolling] got {len(result)} updates, ids {first_id}..{last_id}"
+                    )
+                else:
+                    self.container.logger.for_run().info(
+                        "[TelegramPolling] got 0 updates in this poll"
+                    )
+
+                return result
+
+        except asyncio.TimeoutError:
+            self.container.logger.for_run().warning(
+                "[TelegramPolling] asyncio.TimeoutError while fetching updates"
+            )
+            return []
+        except aiohttp.ClientError as e:
+            self.container.logger.for_run().error(f"[TelegramPolling] aiohttp.ClientError: {e}")
+            return []
+        except Exception as e:
+            self.container.logger.for_run().error(
+                f"[TelegramPolling] unexpected error in _fetch_updates: {e}"
+            )
+            return []
+        except aiohttp.ClientConnectionError as e:
+            self.container.logger.for_run().warning(f"[TelegramPolling] ClientConnectionError: {e}")
+
+    async def _fetch_updates_(self, offset: int | None) -> list[dict[str, Any]]:
+        if not self.bot_token:
+            return []
+        api = f"https://api.telegram.org/bot{self.bot_token}/getUpdates"
+        params: dict[str, Any] = {"timeout": 30}
+        if offset is not None:
+            params["offset"] = offset
+
+        async with _http_session().get(api, params=params) as r:
+            if r.status != 200:
+                return []
+            data = await r.json()
+            if not data.get("ok"):
+                return []
+            return data.get("result") or []
+
+    async def start(self):
+        if not self.bot_token:
+            self.container.logger.for_run().warning(
+                "[TelegramPolling] not started: missing bot token"
+            )
+            return
+
+        self.container.logger.for_run().info("[TelegramPolling] starting polling loop...")
+
+        offset: int | None = None
+
+        # OPTIONAL: initial drain of old updates so we only react to new ones
+        try:
+            initial_updates = await self._fetch_updates(offset=None)
+            if initial_updates:
+                last_id = initial_updates[-1].get("update_id")
+                if last_id is not None:
+                    offset = last_id + 1
+        except Exception as e:
+            self.container.logger.for_run().error(f"[TelegramPolling] initial drain failed: {e}")
+
+        while not self._stop:
+            try:
+                self.container.logger.for_run().info(
+                    f"[TelegramPolling] fetching updates with offset={offset}..."
+                )
+                updates = await self._fetch_updates(offset)
+                self.container.logger.for_run().info(
+                    f"[TelegramPolling] fetched {len(updates)} updates."
+                )
+                if updates:
+                    # process each, then bump offset past the last one
+                    for upd in updates:
+                        await _process_update(self.container, upd, self.bot_token)
+
+                    last_id = updates[-1].get("update_id")
+                    if last_id is not None:
+                        offset = last_id + 1
+                # if no updates, loop back (Telegram held the connection up to timeout)
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self.container.logger.for_run().error(f"[TelegramPolling] error: {e}")
+                await asyncio.sleep(5)
+
+        self.container.logger.for_run().info("[TelegramPolling] stopped.")

aethergraph/plugins/mcp/fs_server.py

@@ -0,0 +1,128 @@
+# Minimal MCP filesystem server over stdio JSON-RPC (cross-platform)
+import json
+import os
+import sys
+import traceback
+
+TOOLS = [
+    {
+        "name": "readFile",
+        "description": "Read a text file",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}},
+            "required": ["path"],
+        },
+    },
+    {
+        "name": "writeFile",
+        "description": "Write text to a file",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}, "text": {"type": "string"}},
+            "required": ["path", "text"],
+        },
+    },
+    {
+        "name": "listDir",
+        "description": "List directory entries",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}},
+            "required": ["path"],
+        },
+    },
+    {
+        "name": "stat",
+        "description": "Stat a file or directory",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}},
+            "required": ["path"],
+        },
+    },
+]
+
+
+def _ok(id, result):
+    return {"jsonrpc": "2.0", "id": id, "result": result}
+
+
+def _err(id, code=-32000, msg="Server error", data=None):
+    e = {"jsonrpc": "2.0", "id": id, "error": {"code": code, "message": msg}}
+    if data is not None:
+        e["error"]["data"] = data
+    return e
+
+
+def list_tools():
+    return TOOLS
+
+
+def call(name, args):
+    if name == "readFile":
+        p = args["path"]
+        with open(p, encoding="utf-8") as f:
+            txt = f.read()
+        return {"text": txt}
+    if name == "writeFile":
+        p, t = args["path"], args["text"]
+        os.makedirs(os.path.dirname(p) or ".", exist_ok=True)
+        with open(p, "w", encoding="utf-8") as f:
+            f.write(t)
+        return {"ok": True, "bytes": len(t)}
+    if name == "listDir":
+        p = args["path"]
+        entries = []
+        for name in os.listdir(p):
+            fp = os.path.join(p, name)
+            entries.append(
+                {
+                    "name": name,
+                    "is_dir": os.path.isdir(fp),
+                    "size": os.path.getsize(fp) if os.path.isfile(fp) else None,
+                }
+            )
+        return {"entries": entries}
+    if name == "stat":
+        p = args["path"]
+        st = os.stat(p)
+        return {"path": p, "is_dir": os.path.isdir(p), "size": st.st_size, "mtime": st.st_mtime}
+    raise ValueError(f"Unknown tool: {name}")
+
+
+def main():
+    stdin = sys.stdin
+    stdout = sys.stdout
+    while True:
+        line = stdin.readline()
+        if not line:
+            break
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            req = json.loads(line)
+            mid = req.get("id")
+            method = req.get("method")
+            params = req.get("params") or {}
+            if method == "tools/list":
+                resp = _ok(mid, list_tools())
+            elif method == "tools/call":
+                name = params.get("name")
+                args = params.get("arguments") or {}
+                resp = _ok(mid, call(name, args))
+            elif method == "resources/list":
+                resp = _ok(mid, [])  # not used in this minimal server
+            elif method == "resources/read":
+                resp = _ok(mid, {"uri": params.get("uri"), "data": None})
+            else:
+                resp = _err(mid, msg=f"Unknown method {method}")
+        except Exception as e:
+            resp = _err(req.get("id"), msg=str(e), data=traceback.format_exc())
+        stdout.write(json.dumps(resp) + "\n")
+        stdout.flush()
+
+
+if __name__ == "__main__":
+    main()