@aliwey/bmo 2.0.0

package/storage/storage.py

@@ -0,0 +1,265 @@
+"""
+Storage layer for chat history, sessions, and memory.
+Supports JSONL backend with multi-session per chat.
+"""
+
+import json
+from uuid import uuid4
+from datetime import datetime
+from typing import Optional, List, Dict
+from abc import ABC, abstractmethod
+
+from models.chat_models import ChatSession, UserMemory
+from config.settings import (
+    STORAGE_TYPE, SESSIONS_FILE, ACTIVE_SESSIONS_FILE,
+    USER_MEMORY_FILE, MAX_HISTORY_PER_CHAT, DATABASE_FILE,
+)
+
+
+class StorageBackend(ABC):
+    @abstractmethod
+    def save_session(self, session: ChatSession) -> bool:
+        pass
+
+    @abstractmethod
+    def load_session(self, chat_id: int) -> Optional[ChatSession]:
+        pass
+
+    @abstractmethod
+    def delete_session(self, chat_id: int) -> bool:
+        pass
+
+    @abstractmethod
+    def add_message(self, chat_id: int, sender: str, content: str, interface: str = 'telegram') -> bool:
+        pass
+
+    @abstractmethod
+    def save_memory(self, memory: UserMemory) -> bool:
+        pass
+
+    @abstractmethod
+    def load_memory(self, chat_id: int) -> Optional[UserMemory]:
+        pass
+
+
+class JSONLStorage(StorageBackend):
+    def __init__(self):
+        self.sessions_file = SESSIONS_FILE
+        self.active_file = ACTIVE_SESSIONS_FILE
+        self.memory_file = USER_MEMORY_FILE
+        self.sessions_file.parent.mkdir(parents=True, exist_ok=True)
+        self.memory_file.parent.mkdir(parents=True, exist_ok=True)
+        self._migrate_from_json()
+
+    # ── Migration ─────────────────────────────────────────────────────────────
+
+    def _migrate_from_json(self):
+        old_file = self.sessions_file.with_suffix(".json")
+        if not self.sessions_file.exists() and old_file.exists():
+            try:
+                with open(old_file, "r") as f:
+                    data = json.load(f)
+                if data:
+                    self._save_all_sessions(data)
+                print(f"Migrated sessions from {old_file} to {self.sessions_file}")
+            except Exception as e:
+                print(f"Migration error: {e}")
+
+    # ── Sessions file (JSONL) ──────────────────────────────────────────────
+    # Internal format: {session_id: session_dict}
+
+    def _load_all_sessions(self) -> Dict[str, dict]:
+        if not self.sessions_file.exists():
+            return {}
+        data = {}
+        try:
+            with open(self.sessions_file, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        obj = json.loads(line)
+                        sid = obj.get("session_id") or obj.get("chat_id")
+                        if sid:
+                            data[str(sid)] = obj
+                    except json.JSONDecodeError:
+                        continue
+        except Exception:
+            return {}
+        return data
+
+    def _save_all_sessions(self, data: Dict[str, dict]):
+        with open(self.sessions_file, "w", encoding="utf-8") as f:
+            for sid in sorted(data.keys()):
+                f.write(json.dumps(data[sid], ensure_ascii=False) + "\n")
+
+    # ── Active sessions map ─────────────────────────────────────────────────
+    # Format: {chat_id: active_session_id}
+
+    def _load_active_map(self) -> Dict[str, str]:
+        if self.active_file.exists():
+            try:
+                with open(self.active_file, "r") as f:
+                    return json.load(f)
+            except Exception:
+                return {}
+        return {}
+
+    def _save_active_map(self, data: Dict[str, str]):
+        with open(self.active_file, "w") as f:
+            json.dump(data, f, indent=2)
+
+    # ── Session CRUD (multi-session aware) ──────────────────────────────────
+
+    def save_session(self, session: ChatSession) -> bool:
+        try:
+            if not session.session_id:
+                session.session_id = str(uuid4())
+            db = self._load_all_sessions()
+            db[session.session_id] = session.to_dict()
+            self._save_all_sessions(db)
+            active = self._load_active_map()
+            active[str(session.chat_id)] = session.session_id
+            self._save_active_map(active)
+            return True
+        except Exception as e:
+            print(f"Error saving session: {e}")
+            return False
+
+    def load_session(self, chat_id: int) -> Optional[ChatSession]:
+        try:
+            active = self._load_active_map()
+            session_id = active.get(str(chat_id))
+            db = self._load_all_sessions()
+
+            if session_id and session_id in db:
+                return ChatSession.from_dict(db[session_id])
+
+            # Auto-migrate: find any session for this chat, pick newest
+            candidates = []
+            for sid, data in db.items():
+                if data.get("chat_id") == chat_id:
+                    candidates.append((sid, data))
+            if candidates:
+                candidates.sort(key=lambda x: x[1].get("updated_at", 0), reverse=True)
+                best_sid, best_data = candidates[0]
+                if not best_data.get("session_id"):
+                    best_data["session_id"] = best_sid
+                    db[best_sid] = best_data
+                    self._save_all_sessions(db)
+                active[str(chat_id)] = best_sid
+                self._save_active_map(active)
+                return ChatSession.from_dict(best_data)
+
+            return None
+        except Exception as e:
+            print(f"Error loading session: {e}")
+            return None
+
+    def delete_session(self, chat_id: int) -> bool:
+        try:
+            active = self._load_active_map()
+            session_id = active.pop(str(chat_id), None)
+            if session_id:
+                db = self._load_all_sessions()
+                db.pop(session_id, None)
+                self._save_all_sessions(db)
+            self._save_active_map(active)
+            return True
+        except Exception as e:
+            print(f"Error deleting session: {e}")
+            return False
+
+    def add_message(self, chat_id: int, sender: str, content: str, interface: str = 'telegram') -> bool:
+        try:
+            session = self.load_session(chat_id)
+            if session:
+                session.add_message(sender, content)
+                if len(session.messages) > MAX_HISTORY_PER_CHAT:
+                    session.messages = session.messages[-MAX_HISTORY_PER_CHAT:]
+                return self.save_session(session)
+            return False
+        except Exception as e:
+            print(f"Error adding message: {e}")
+            return False
+
+    def get_session_by_id(self, session_id: str) -> Optional[ChatSession]:
+        try:
+            db = self._load_all_sessions()
+            data = db.get(session_id)
+            return ChatSession.from_dict(data) if data else None
+        except Exception as e:
+            print(f"Error loading session by ID: {e}")
+            return None
+
+    def list_chat_sessions(self, chat_id: int) -> List[dict]:
+        db = self._load_all_sessions()
+        active = self._load_active_map()
+        active_id = active.get(str(chat_id))
+        result = []
+        for sid, data in db.items():
+            if data.get("chat_id") == chat_id:
+                result.append({
+                    "session_id": sid,
+                    "title": data.get("title", "") or sid[:8],
+                    "msg_count": len(data.get("messages", [])),
+                    "updated_at": data.get("updated_at", 0),
+                    "is_active": sid == active_id,
+                })
+        result.sort(key=lambda x: x["updated_at"], reverse=True)
+        return result
+
+    def switch_session(self, chat_id: int, session_id: str) -> bool:
+        db = self._load_all_sessions()
+        if session_id not in db:
+            return False
+        active = self._load_active_map()
+        active[str(chat_id)] = session_id
+        self._save_active_map(active)
+        return True
+
+    # ── Memory ────────────────────────────────────────────────────────────────
+
+    def _load_memory_db(self) -> Dict:
+        if self.memory_file.exists():
+            try:
+                with open(self.memory_file, "r") as f:
+                    return json.load(f)
+            except Exception:
+                return {}
+        return {}
+
+    def _save_memory_db(self, data: Dict):
+        with open(self.memory_file, "w") as f:
+            json.dump(data, f, indent=2)
+
+    def save_memory(self, memory: UserMemory) -> bool:
+        try:
+            db = self._load_memory_db()
+            db[str(memory.chat_id)] = memory.to_dict()
+            self._save_memory_db(db)
+            return True
+        except Exception as e:
+            print(f"Error saving memory: {e}")
+            return False
+
+    def load_memory(self, chat_id: int) -> Optional[UserMemory]:
+        try:
+            db = self._load_memory_db()
+            data = db.get(str(chat_id))
+            if data:
+                return UserMemory.from_dict(data)
+            return None
+        except Exception as e:
+            print(f"Error loading memory: {e}")
+            return None
+
+    def list_sessions(self) -> List[int]:
+        db = self._load_all_sessions()
+        return list({d.get("chat_id") for d in db.values() if d.get("chat_id")})
+
+
+def get_storage() -> StorageBackend:
+    from storage.sqlite_storage import SQLiteStorage
+    return SQLiteStorage(db_path=str(DATABASE_FILE))

package/tools/bfp_relay.py

@@ -0,0 +1,359 @@
+import argparse
+import asyncio
+import json
+import logging
+import os
+import time
+from datetime import datetime, timezone
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import uvicorn
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+log = logging.getLogger("bfp-relay")
+
+DEFAULT_PORT = 9753
+TTL_SECONDS = 300
+CLEANUP_INTERVAL = 60
+
+
+class BFPRelay:
+    def __init__(self, host: str = "0.0.0.0", port: int = DEFAULT_PORT, persist_path: str = None):
+        self.host = host
+        self.port = port
+        self.persist_path = persist_path
+        self._agents: dict[str, dict] = {}
+        self._ws_clients: set[WebSocket] = set()
+        self._ws_by_did: dict[str, WebSocket] = {}
+        self._pending_responses: dict[str, asyncio.Future] = {}
+        self._app: FastAPI | None = None
+        self._cleanup_task: asyncio.Task | None = None
+
+    def _validate_did(self, did: str) -> None:
+        if not did.startswith("did:bfp:"):
+            raise ValueError(f"Invalid DID format '{did}' — must start with 'did:bfp:'")
+
+    def register(self, did: str, endpoint: str, caps: list, pubkey: str, name: str = None) -> dict:
+        self._validate_did(did)
+        now = time.time()
+        self._agents[did] = {
+            "endpoint": endpoint,
+            "capabilities": caps or [],
+            "publicKey": pubkey,
+            "name": name or did.split(":")[-1][:24],
+            "lastSeen": now,
+        }
+        self._persist()
+        log.info("REGISTER  did=%s  endpoint=%s  caps=%s", did, endpoint, caps)
+        return {"status": "ok", "ttl": TTL_SECONDS}
+
+    def resolve(self, did: str) -> dict | None:
+        agent = self._agents.get(did)
+        if agent is None:
+            return None
+        now = time.time()
+        if now - agent["lastSeen"] > TTL_SECONDS:
+            self.unregister(did)
+            return None
+        log.info("RESOLVE   did=%s  endpoint=%s", did, agent["endpoint"])
+        return {
+            "did": did,
+            "endpoint": agent["endpoint"],
+            "capabilities": agent["capabilities"],
+            "lastSeen": agent["lastSeen"],
+        }
+
+    def list_agents(self, capability: str = None) -> list[dict]:
+        now = time.time()
+        stale = [did for did, a in self._agents.items() if now - a["lastSeen"] > TTL_SECONDS]
+        for did in stale:
+            self.unregister(did)
+        agents = []
+        for did, a in self._agents.items():
+            if capability and capability not in a["capabilities"]:
+                continue
+            agents.append({
+                "did": did,
+                "name": a["name"],
+                "capabilities": a["capabilities"],
+                "lastSeen": a["lastSeen"],
+            })
+        agents.sort(key=lambda x: x["lastSeen"], reverse=True)
+        return agents
+
+    def unregister(self, did: str) -> None:
+        if did in self._agents:
+            del self._agents[did]
+            self._persist()
+            log.info("UNREGISTER did=%s", did)
+
+    def get_agent_count(self) -> int:
+        now = time.time()
+        self._agents = {d: a for d, a in self._agents.items() if now - a["lastSeen"] <= TTL_SECONDS}
+        return len(self._agents)
+
+    def _persist(self) -> None:
+        if not self.persist_path:
+            return
+        data = {did: info for did, info in self._agents.items()}
+        tmp = self.persist_path + ".tmp"
+        try:
+            with open(tmp, "w") as f:
+                json.dump(data, f)
+            os.replace(tmp, self.persist_path)
+        except OSError as e:
+            log.warning("persist failed: %s", e)
+
+    def _load(self) -> None:
+        if not self.persist_path or not os.path.exists(self.persist_path):
+            return
+        try:
+            with open(self.persist_path) as f:
+                data = json.load(f)
+            now = time.time()
+            for did, info in data.items():
+                if now - info.get("lastSeen", 0) <= TTL_SECONDS:
+                    self._agents[did] = info
+            log.info("loaded %d agents from %s", len(self._agents), self.persist_path)
+        except (OSError, json.JSONDecodeError) as e:
+            log.warning("load failed: %s", e)
+
+    def _build_app(self) -> FastAPI:
+        app = FastAPI(title="BFP Relay", version="1.0.0")
+
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+        @app.post("/register")
+        async def register_endpoint(body: dict):
+            did = body.get("did", "").strip()
+            endpoint = body.get("endpoint", "").strip()
+            caps = body.get("capabilities", [])
+            pubkey = body.get("publicKey", "")
+            name = body.get("name")
+            if not did or not endpoint:
+                raise HTTPException(status_code=400, detail="did and endpoint are required")
+            try:
+                result = self.register(did, endpoint, caps, pubkey, name)
+            except ValueError as e:
+                raise HTTPException(status_code=400, detail=str(e))
+            return result
+
+        @app.get("/resolve/{did:path}")
+        async def resolve_endpoint(did: str):
+            did = did.strip()
+            result = self.resolve(did)
+            if result is None:
+                raise HTTPException(status_code=404, detail=f"agent {did} not found")
+            return result
+
+        @app.get("/list")
+        async def list_endpoint(capability: str = None):
+            return {"agents": self.list_agents(capability)}
+
+        @app.delete("/unregister/{did:path}")
+        async def unregister_endpoint(did: str):
+            did = did.strip()
+            self.unregister(did)
+            return {"status": "ok"}
+
+        @app.get("/health")
+        async def health_endpoint():
+            return {"status": "ok", "agentCount": self.get_agent_count()}
+
+        @app.websocket("/ws")
+        async def websocket_endpoint(ws: WebSocket):
+            await ws.accept()
+            self._ws_clients.add(ws)
+            log.info("WS connect  clients=%d", len(self._ws_clients))
+            registered_did = None
+            try:
+                while True:
+                    data = await ws.receive_text()
+                    msg = json.loads(data)
+                    action = msg.get("action")
+                    if action == "register":
+                        try:
+                            did = msg["did"]
+                            result = self.register(
+                                did, msg["endpoint"],
+                                msg.get("capabilities", []),
+                                msg.get("publicKey", ""),
+                                msg.get("name"),
+                            )
+                            self._ws_by_did[did] = ws
+                            registered_did = did
+                            await ws.send_json({"type": "register_result", **result})
+                            await self._broadcast_agent_list()
+                        except (ValueError, KeyError) as e:
+                            await ws.send_json({"type": "error", "detail": str(e)})
+                    elif action == "resolve":
+                        result = self.resolve(msg["did"])
+                        if result is None:
+                            await ws.send_json({"type": "resolve_result", "found": False})
+                        else:
+                            await ws.send_json({"type": "resolve_result", "found": True, **result})
+                    elif action == "list":
+                        agents = self.list_agents(msg.get("capability"))
+                        await ws.send_json({"type": "list_result", "agents": agents})
+                    elif action == "forward":
+                        target_did = msg.get("targetDid")
+                        payload = msg.get("payload", {})
+                        target = self.resolve(target_did)
+                        if target is None:
+                            await ws.send_json({"type": "forward_result", "status": "not_found"})
+                        else:
+                            await self._relay_forward(target_did, target["endpoint"], payload, ws)
+                    elif action == "send":
+                        target_did = msg.get("targetDid")
+                        payload = msg.get("payload", {})
+                        request_id = msg.get("requestId", "")
+                        target_ws = self._ws_by_did.get(target_did)
+                        if target_ws is None:
+                            await ws.send_json({"type": "send_result", "status": "offline", "requestId": request_id})
+                        else:
+                            future = asyncio.get_event_loop().create_future()
+                            self._pending_responses[request_id] = future
+                            try:
+                                await target_ws.send_json({
+                                    "type": "relay_message",
+                                    "fromDid": msg.get("fromDid", ""),
+                                    "payload": payload,
+                                    "requestId": request_id,
+                                })
+                                resp = await asyncio.wait_for(future, timeout=60.0)
+                                await ws.send_json({"type": "send_result", "status": "delivered", "response": resp, "requestId": request_id})
+                            except asyncio.TimeoutError:
+                                await ws.send_json({"type": "send_result", "status": "timeout", "requestId": request_id})
+                            finally:
+                                self._pending_responses.pop(request_id, None)
+                    elif action == "relay_response":
+                        request_id = msg.get("requestId", "")
+                        future = self._pending_responses.get(request_id)
+                        if future and not future.done():
+                            future.set_result(msg.get("payload", {}))
+                    else:
+                        await ws.send_json({"type": "error", "detail": f"unknown action: {action}"})
+            except WebSocketDisconnect:
+                pass
+            finally:
+                self._ws_clients.discard(ws)
+                if registered_did:
+                    self._ws_by_did.pop(registered_did, None)
+                log.info("WS disconnect  clients=%d", len(self._ws_clients))
+                await self._broadcast_agent_list()
+
+        return app
+
+    async def _broadcast_agent_list(self) -> None:
+        agents = self.list_agents()
+        msg = json.dumps({"type": "agent_list", "agents": agents})
+        stale = set()
+        for ws in self._ws_clients:
+            try:
+                await ws.send_text(msg)
+            except Exception:
+                stale.add(ws)
+        self._ws_clients -= stale
+
+    async def _relay_forward(self, target_did: str, target_endpoint: str, payload: dict, source_ws: WebSocket) -> None:
+        import aiohttp
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"{target_endpoint}/bfp/inbox",
+                    json={"from": "relay", "payload": payload},
+                    timeout=aiohttp.ClientTimeout(total=10),
+                ) as resp:
+                    if resp.ok:
+                        body = await resp.json()
+                        await source_ws.send_json({
+                            "type": "forward_result",
+                            "status": "delivered",
+                            "response": body,
+                        })
+                    else:
+                        await source_ws.send_json({
+                            "type": "forward_result",
+                            "status": "delivery_failed",
+                            "httpStatus": resp.status,
+                        })
+        except Exception as e:
+            await source_ws.send_json({
+                "type": "forward_result",
+                "status": "delivery_failed",
+                "detail": str(e),
+            })
+
+    async def _cleanup_loop(self) -> None:
+        while True:
+            await asyncio.sleep(CLEANUP_INTERVAL)
+            before = len(self._agents)
+            self.get_agent_count()
+            after = len(self._agents)
+            if before != after:
+                log.info("cleanup  removed=%d  remaining=%d", before - after, after)
+                await self._broadcast_agent_list()
+
+    def start(self) -> None:
+        self._load()
+        app = self._build_app()
+        self._app = app
+
+        config = uvicorn.Config(
+            app,
+            host=self.host,
+            port=self.port,
+            log_level="info",
+            access_log=True,
+        )
+        server = uvicorn.Server(config)
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        self._cleanup_task = loop.create_task(self._cleanup_loop())
+
+        try:
+            log.info("BFP Relay starting on %s:%s", self.host, self.port)
+            server.run()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            self.stop()
+
+    def stop(self) -> None:
+        if self._cleanup_task:
+            self._cleanup_task.cancel()
+        self._persist()
+        log.info("BFP Relay stopped")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="BFP Relay Directory Server")
+    parser.add_argument("--host", default="0.0.0.0", help="Bind address")
+    parser.add_argument("--port", type=int, default=DEFAULT_PORT, help=f"Port (default: {DEFAULT_PORT})")
+    parser.add_argument("--persist", default=None, help="Path to JSON file for persistence")
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.getLogger("bfp-relay").setLevel(logging.DEBUG)
+
+    relay = BFPRelay(host=args.host, port=args.port, persist_path=args.persist)
+    relay.start()
+
+
+if __name__ == "__main__":
+    main()

package/tools/get_session_summaries.py

@@ -0,0 +1,45 @@
+"""
+BMO Session Summary Tool
+Built-in alternative to MCP get_session_summaries
+Usage: python get_session_summaries.py <chat_id> [count]
+"""
+import sqlite3
+import sys
+import os
+
+DB_PATH = os.path.join(os.path.dirname(__file__), "..", "data", "bot.db")
+
+def get_session_summaries(chat_id, count=5):
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        SELECT id, created_at, summary 
+        FROM sessions 
+        WHERE chat_id = ? 
+        ORDER BY created_at DESC 
+        LIMIT ?
+    """, (str(chat_id), count))
+    
+    results = cursor.fetchall()
+    conn.close()
+    
+    if not results:
+        return f"No sessions found for chat_id: {chat_id}"
+    
+    output = []
+    for session_id, created_at, summary in results:
+        import datetime
+        dt = datetime.datetime.fromtimestamp(created_at)
+        output.append(f"📅 {dt.strftime('%Y-%m-%d %H:%M')} | ID: {session_id[:8]}...")
+        if summary:
+            output.append(f"   {summary[:200]}...")
+        output.append("")
+    
+    return "\n".join(output)
+
+if __name__ == "__main__":
+    from config.settings import OWNER_ID
+    chat_id = sys.argv[1] if len(sys.argv) > 1 else str(OWNER_ID)
+    count = int(sys.argv[2]) if len(sys.argv) > 2 else 5
+    print(get_session_summaries(chat_id, count))