dfcode-remote 0.1.0__py3-none-any.whl

dfcode_remote/__init__.py

@@ -0,0 +1,3 @@
+"""dfcode-remote: Feishu bridge for dfcode."""
+
+__version__ = "0.1.0"

dfcode_remote/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as `python -m dfcode_remote`."""
+
+from dfcode_remote.cli import main
+
+if __name__ == "__main__":
+    main()

dfcode_remote/cli.py

@@ -0,0 +1,106 @@
+"""Entry point for the dfcode Feishu bridge.
+
+Usage:
+    dfcode-remote
+    dfcode-remote --dfcode-url http://host:4096
+    python -m dfcode_remote
+"""
+
+import argparse
+import asyncio
+import logging
+import signal
+import sys
+
+from dfcode_remote.dfcode_client.client import DfcodeClient
+from dfcode_remote.lark_client.bot import start_bot_async
+from dfcode_remote.lark_client.card_service import CardService
+from dfcode_remote.lark_client.event_listener import EventListener
+from dfcode_remote.lark_client.handler import Handler
+from dfcode_remote.utils.config import Config
+from dfcode_remote.utils.persistence import Persistence
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="dfcode Feishu bridge")
+    parser.add_argument(
+        "--dfcode-url", default=None, help="Override DFCODE_URL from env"
+    )
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
+    return parser.parse_args()
+
+
+async def _run(config: Config) -> None:
+    client = DfcodeClient(
+        base_url=config.dfcode_url,
+        directory=config.dfcode_directory,
+        username=config.dfcode_username or None,
+        password=config.dfcode_password or None,
+    )
+    card_service = CardService(config.feishu_app_id, config.feishu_app_secret)
+    persistence = Persistence()
+    handler = Handler(config, client, card_service, persistence)
+    listener = EventListener(
+        dfcode_url=config.dfcode_url,
+        client=client,
+        card_service=card_service,
+        persistence=persistence,
+        handler=handler,
+        enable_urgent=config.enable_urgent,
+    )
+
+    logger.info("dfcode URL: %s", config.dfcode_url)
+    logger.info("Feishu app_id: %s", config.feishu_app_id)
+
+    async def sse_task() -> None:
+        await listener.run()
+
+    async def bot_task() -> None:
+        await start_bot_async(
+            config.feishu_app_id,
+            config.feishu_app_secret,
+            handler.handle_message,
+            handler.handle_card_action,
+        )
+
+    loop = asyncio.get_running_loop()
+
+    def _shutdown(sig: signal.Signals) -> None:
+        logger.info("Received %s — shutting down", sig.name)
+        for task in asyncio.all_tasks(loop):
+            task.cancel()
+
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        loop.add_signal_handler(sig, lambda s=sig: _shutdown(s))
+
+    try:
+        await asyncio.gather(sse_task(), bot_task())
+    except asyncio.CancelledError:
+        logger.info("Shutdown complete")
+    finally:
+        await client.close()
+        await card_service.close()
+
+
+def main() -> None:
+    args = _parse_args()
+
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+
+    config = Config.load()
+
+    if args.dfcode_url:
+        config.dfcode_url = args.dfcode_url
+
+    if not config.feishu_app_id or not config.feishu_app_secret:
+        logger.error("FEISHU_APP_ID and FEISHU_APP_SECRET must be set")
+        sys.exit(1)
+
+    asyncio.run(_run(config))

dfcode_remote/dfcode_client/__init__.py

@@ -0,0 +1,4 @@
+from dfcode_remote.dfcode_client.client import DfcodeClient
+from dfcode_remote.dfcode_client.sse import sse_stream, SSEEvent
+
+__all__ = ["DfcodeClient", "sse_stream", "SSEEvent"]

dfcode_remote/dfcode_client/client.py

@@ -0,0 +1,196 @@
+import httpx
+from typing import Optional
+
+from dfcode_remote.dfcode_client.types import (
+    ActiveSessionInfo,
+    SessionInfo,
+    SessionStatus,
+    MessageInfo,
+)
+
+
+class DfcodeAPIError(Exception):
+    """Raised when the dfcode API returns an error response."""
+
+    def __init__(self, status: int, message: str, url: str = ""):
+        self.status = status
+        self.url = url
+        super().__init__(f"dfcode API error {status}: {message} (url={url})")
+
+
+class DfcodeClient:
+    """Async HTTP client wrapping the dfcode REST API."""
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:4096",
+        directory: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.directory = directory
+        headers: dict[str, str] = {}
+        if directory:
+            headers["x-dfcode-directory"] = directory
+        auth = None
+        if username and password:
+            auth = httpx.BasicAuth(username, password)
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            headers=headers,
+            auth=auth,
+            timeout=httpx.Timeout(30.0, connect=10.0),
+        )
+
+    async def __aenter__(self) -> "DfcodeClient":
+        return self
+
+    async def __aexit__(self, *exc) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        """Close the underlying HTTP client."""
+        await self._client.aclose()
+
+    async def _request(self, method: str, path: str, **kwargs) -> httpx.Response:
+        """Send a request and raise on non-2xx status."""
+        resp = await self._client.request(method, path, **kwargs)
+        if resp.status_code >= 400:
+            text = resp.text
+            raise DfcodeAPIError(resp.status_code, text, url=str(resp.url))
+        return resp
+
+    # --- Global ---
+
+    async def health(self) -> dict:
+        """GET /global/health"""
+        resp = await self._request("GET", "/global/health")
+        return resp.json()
+
+    # --- Sessions ---
+
+    async def list_sessions(self) -> list[SessionInfo]:
+        """GET /session"""
+        resp = await self._request("GET", "/session")
+        return [SessionInfo.from_dict(s) for s in resp.json()]
+
+    async def list_active_sessions(self) -> list[ActiveSessionInfo]:
+        """GET /session/active"""
+        resp = await self._request("GET", "/session/active")
+        return [ActiveSessionInfo.from_dict(s) for s in resp.json()]
+
+    async def get_active_session(self, session_id: str) -> ActiveSessionInfo:
+        """GET /session/active/{id}"""
+        resp = await self._request("GET", f"/session/active/{session_id}")
+        return ActiveSessionInfo.from_dict(resp.json())
+
+    async def create_session(self, title: Optional[str] = None) -> SessionInfo:
+        """POST /session"""
+        body: dict = {}
+        if title:
+            body["title"] = title
+        resp = await self._request("POST", "/session", json=body)
+        return SessionInfo.from_dict(resp.json())
+
+    async def get_session(self, session_id: str) -> SessionInfo:
+        """GET /session/{id}"""
+        resp = await self._request("GET", f"/session/{session_id}")
+        return SessionInfo.from_dict(resp.json())
+
+    async def delete_session(self, session_id: str) -> bool:
+        """DELETE /session/{id}"""
+        resp = await self._request("DELETE", f"/session/{session_id}")
+        return resp.status_code < 400
+
+    async def get_status(self) -> dict[str, SessionStatus]:
+        """GET /session/status"""
+        resp = await self._request("GET", "/session/status")
+        data = resp.json()
+        return {k: SessionStatus.from_dict(v) for k, v in data.items()}
+
+    async def prompt_async(self, session_id: str, text: str) -> None:
+        """POST /session/{id}/prompt_async — returns 204 immediately."""
+        await self._request(
+            "POST",
+            f"/session/{session_id}/prompt_async",
+            json={"parts": [{"type": "text", "text": text}]},
+        )
+
+    async def prompt_active_async(self, session_id: str, text: str) -> None:
+        """POST /session/active/{id}/prompt_async — cross-project active session prompt."""
+        await self._request(
+            "POST",
+            f"/session/active/{session_id}/prompt_async",
+            json={"parts": [{"type": "text", "text": text}]},
+        )
+
+    async def prompt_async_in_project(
+        self,
+        session_id: str,
+        text: str,
+        project_root: str,
+    ) -> None:
+        """POST /session/{id}/prompt_async with explicit project directory context."""
+        await self._request(
+            "POST",
+            f"/session/{session_id}/prompt_async",
+            json={"parts": [{"type": "text", "text": text}]},
+            headers={"x-dfcode-directory": project_root},
+        )
+
+    async def abort(self, session_id: str) -> bool:
+        """POST /session/{id}/abort"""
+        resp = await self._request("POST", f"/session/{session_id}/abort")
+        return resp.status_code < 400
+
+    async def get_messages(self, session_id: str) -> list[MessageInfo]:
+        """GET /session/{id}/message"""
+        resp = await self._request("GET", f"/session/{session_id}/message")
+        return [MessageInfo.from_dict(m) for m in resp.json()]
+
+    # --- Permissions ---
+
+    async def reply_permission(
+        self,
+        request_id: str,
+        reply: str,
+        message: Optional[str] = None,
+    ) -> bool:
+        """POST /permission/{id}/reply"""
+        body: dict = {"reply": reply}
+        if message:
+            body["message"] = message
+        resp = await self._request("POST", f"/permission/{request_id}/reply", json=body)
+        return resp.status_code < 400
+
+    async def list_permissions(self) -> list[dict]:
+        """GET /permission"""
+        resp = await self._request("GET", "/permission")
+        return resp.json()
+
+    # --- Questions ---
+
+    async def reply_question(self, request_id: str, answers: list[list[str]]) -> bool:
+        """POST /question/{id}/reply
+
+        Each element in answers corresponds to one question.
+        Each answer is a list of selected labels (even for single-select).
+        Example: [["Yes"]] for a single question with one selection.
+        """
+        resp = await self._request(
+            "POST",
+            f"/question/{request_id}/reply",
+            json={"answers": answers},
+        )
+        return resp.status_code < 400
+
+    async def reject_question(self, request_id: str) -> bool:
+        """POST /question/{id}/reject"""
+        resp = await self._request("POST", f"/question/{request_id}/reject")
+        return resp.status_code < 400
+
+    async def list_questions(self) -> list[dict]:
+        """GET /question"""
+        resp = await self._request("GET", "/question")
+        return resp.json()

dfcode_remote/dfcode_client/sse.py

@@ -0,0 +1,105 @@
+import asyncio
+import json
+import logging
+from typing import AsyncIterator, Optional
+
+import httpx
+
+from dfcode_remote.dfcode_client.types import SSEEvent
+
+logger = logging.getLogger(__name__)
+
+_INITIAL_BACKOFF = 1.0
+_MAX_BACKOFF = 30.0
+_HEARTBEAT_TIMEOUT = 60.0
+
+
+async def sse_stream(
+    url: str,
+    headers: Optional[dict[str, str]] = None,
+) -> AsyncIterator[SSEEvent]:
+    """Connect to a dfcode SSE endpoint and yield parsed events.
+
+    Auto-reconnects with exponential backoff on connection loss.
+    Reconnects if no data received within the heartbeat timeout (60s).
+    """
+    backoff = _INITIAL_BACKOFF
+
+    while True:
+        try:
+            async with httpx.AsyncClient(timeout=None) as client:
+                async with client.stream(
+                    "GET",
+                    url,
+                    headers={**(headers or {}), "Accept": "text/event-stream"},
+                ) as resp:
+                    if resp.status_code >= 400:
+                        logger.error("SSE connect failed: %d", resp.status_code)
+                        await asyncio.sleep(backoff)
+                        backoff = min(backoff * 2, _MAX_BACKOFF)
+                        continue
+
+                    # Connected — reset backoff
+                    backoff = _INITIAL_BACKOFF
+
+                    async for event in _parse_stream(resp):
+                        yield event
+
+        except asyncio.CancelledError:
+            logger.debug("SSE stream cancelled")
+            return
+
+        except (httpx.HTTPError, OSError) as exc:
+            logger.warning(
+                "SSE connection error: %s — reconnecting in %.0fs", exc, backoff
+            )
+            await asyncio.sleep(backoff)
+            backoff = min(backoff * 2, _MAX_BACKOFF)
+
+
+async def _parse_stream(resp: httpx.Response) -> AsyncIterator[SSEEvent]:
+    """Parse SSE frames from an httpx streaming response with heartbeat timeout."""
+    buffer = ""
+
+    async for chunk in _timeout_iter(resp.aiter_text(), _HEARTBEAT_TIMEOUT):
+        buffer += chunk
+        while "\n\n" in buffer:
+            frame, buffer = buffer.split("\n\n", 1)
+            event = _parse_frame(frame)
+            if event:
+                yield event
+
+
+async def _timeout_iter(aiter, timeout: float):
+    """Wrap an async iterator with a per-item timeout. Raises TimeoutError on expiry."""
+    ait = aiter.__aiter__()
+    while True:
+        try:
+            item = await asyncio.wait_for(ait.__anext__(), timeout=timeout)
+            yield item
+        except StopAsyncIteration:
+            return
+        except asyncio.TimeoutError:
+            logger.warning("SSE heartbeat timeout (%.0fs) — will reconnect", timeout)
+            return
+
+
+def _parse_frame(frame: str) -> Optional[SSEEvent]:
+    """Parse a single SSE frame into an SSEEvent, or None if unparseable."""
+    for line in frame.strip().splitlines():
+        if line.startswith("data:"):
+            payload = line[len("data:") :].strip()
+            if not payload:
+                continue
+            try:
+                data = json.loads(payload)
+                if (
+                    isinstance(data, dict)
+                    and "payload" in data
+                    and isinstance(data["payload"], dict)
+                ):
+                    data = data["payload"]
+                return SSEEvent.from_dict(data)
+            except (json.JSONDecodeError, KeyError) as exc:
+                logger.debug("Failed to parse SSE data: %s", exc)
+    return None

dfcode_remote/dfcode_client/types.py

@@ -0,0 +1,213 @@
+from dataclasses import dataclass, field
+from typing import Optional, Any
+
+
+@dataclass
+class SessionInfo:
+    """Represents a dfcode session."""
+
+    id: str
+    title: str
+    directory: str
+    parentID: Optional[str] = None
+    time: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "SessionInfo":
+        return cls(
+            id=data["id"],
+            title=data.get("title", ""),
+            directory=data.get("directory", ""),
+            parentID=data.get("parentID"),
+            time=data.get("time", {}),
+        )
+
+
+@dataclass
+class SessionStatus:
+    """Session processing status."""
+
+    type: str  # "idle" | "busy" | "retry"
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "SessionStatus":
+        return cls(type=data.get("type", "idle"))
+
+
+@dataclass
+class ActiveSessionInfo:
+    """A cross-project active session item from /session/active."""
+
+    id: str
+    title: str = ""
+    directory: str = ""
+    projectRoot: str = ""
+    projectID: str = ""
+    parentID: Optional[str] = None
+    time: dict = field(default_factory=dict)
+    status: SessionStatus = field(default_factory=lambda: SessionStatus(type="idle"))
+    activity: dict = field(default_factory=dict)
+    attachable: bool = False
+    continueable: bool = False
+    rank: int = 0
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ActiveSessionInfo":
+        return cls(
+            id=data["id"],
+            title=data.get("title", ""),
+            directory=data.get("directory", ""),
+            projectRoot=data.get("projectRoot", data.get("directory", "")),
+            projectID=data.get("projectID", ""),
+            parentID=data.get("parentID"),
+            time=data.get("time", {}),
+            status=SessionStatus.from_dict(data.get("status", {})),
+            activity=data.get("activity", {}),
+            attachable=data.get("attachable", False),
+            continueable=data.get("continueable", False),
+            rank=data.get("rank", 0),
+        )
+
+
+@dataclass
+class PartInfo:
+    """Message part — discriminated union on 'type' field."""
+
+    type: str
+    id: Optional[str] = None
+    text: Optional[str] = None
+    time: Optional[dict] = None
+    callID: Optional[str] = None
+    tool: Optional[str] = None
+    state: Optional[dict] = None
+    cost: Optional[dict] = None
+    tokens: Optional[dict] = None
+    sessionID: Optional[str] = None
+    messageID: Optional[str] = None
+    raw: Optional[dict] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "PartInfo":
+        t = data.get("type", "")
+        if t == "text":
+            return cls(
+                type=t,
+                id=data.get("id"),
+                text=data.get("text"),
+                time=data.get("time"),
+                sessionID=data.get("sessionID"),
+                messageID=data.get("messageID"),
+            )
+        if t == "tool":
+            return cls(
+                type=t,
+                id=data.get("id"),
+                callID=data.get("callID"),
+                tool=data.get("tool"),
+                state=data.get("state"),
+                time=data.get("time"),
+                sessionID=data.get("sessionID"),
+                messageID=data.get("messageID"),
+            )
+        if t == "step-finish":
+            return cls(
+                type=t,
+                id=data.get("id"),
+                cost=data.get("cost"),
+                tokens=data.get("tokens"),
+                time=data.get("time"),
+                sessionID=data.get("sessionID"),
+                messageID=data.get("messageID"),
+            )
+        if t == "reasoning":
+            return cls(
+                type=t,
+                id=data.get("id"),
+                text=data.get("text"),
+                time=data.get("time"),
+                sessionID=data.get("sessionID"),
+                messageID=data.get("messageID"),
+            )
+        return cls(
+            type=t,
+            id=data.get("id"),
+            sessionID=data.get("sessionID"),
+            messageID=data.get("messageID"),
+            raw=data,
+        )
+
+
+@dataclass
+class MessageInfo:
+    """A message in a session."""
+
+    id: str
+    sessionID: str
+    role: str
+    parts: list[PartInfo] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "MessageInfo":
+        info = data.get("info", data)
+        parts = [PartInfo.from_dict(p) for p in data.get("parts", [])]
+        return cls(
+            id=info.get("id", ""),
+            sessionID=info.get("sessionID", ""),
+            role=info.get("role", ""),
+            parts=parts,
+        )
+
+
+@dataclass
+class PermissionRequest:
+    """A pending permission request from dfcode."""
+
+    id: str
+    sessionID: str
+    permission: str
+    patterns: list[str] = field(default_factory=list)
+    metadata: dict = field(default_factory=dict)
+    tool: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "PermissionRequest":
+        return cls(
+            id=data["id"],
+            sessionID=data.get("sessionID", ""),
+            permission=data.get("permission", ""),
+            patterns=data.get("patterns", []),
+            metadata=data.get("metadata", {}),
+            tool=data.get("tool"),
+        )
+
+
+@dataclass
+class QuestionRequest:
+    """A pending question from dfcode."""
+
+    id: str
+    sessionID: str
+    questions: list[dict] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "QuestionRequest":
+        return cls(
+            id=data["id"],
+            sessionID=data.get("sessionID", ""),
+            questions=data.get("questions", []),
+        )
+
+
+@dataclass
+class SSEEvent:
+    """A parsed Server-Sent Event."""
+
+    type: str
+    properties: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "SSEEvent":
+        return cls(
+            type=data.get("type", ""),
+            properties=data.get("properties", {}),
+        )

dfcode_remote/lark_client/__init__.py

@@ -0,0 +1,19 @@
+from dfcode_remote.lark_client.bot import start_bot_async
+from dfcode_remote.lark_client.card_builder import (
+    build_streaming_card,
+    build_frozen_card,
+    build_menu_card,
+    build_command_response_card,
+)
+from dfcode_remote.lark_client.card_service import CardService
+from dfcode_remote.lark_client.event_listener import EventListener
+
+__all__ = [
+    "start_bot_async",
+    "build_streaming_card",
+    "build_frozen_card",
+    "build_menu_card",
+    "build_command_response_card",
+    "CardService",
+    "EventListener",
+]