topos-node 0.1.6__tar.gz → 0.1.8__tar.gz

{topos_node-0.1.6 → topos_node-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 0.1.6
+Version: 0.1.8
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai

{topos_node-0.1.6 → topos_node-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "0.1.6"
+version = "0.1.8"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"

{topos_node-0.1.6 → topos_node-0.1.8}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "0.1.6"
-__version_info__ = (0, 1, 6)
+__version__ = "0.1.8"
+__version_info__ = (0, 1, 8)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-0.1.6 → topos_node-0.1.8}/topos/api/device.py

@@ -12,12 +12,12 @@ router = APIRouter()
 
 @router.get("/device/info", response_model=DeviceInfoResponse, dependencies=[Depends(require_api_key)])
 async def get_device_info(services: Services = Depends(get_services)):
-    return await services.device.get_device_info()
+    return await services.device.get_device_info(context=None)
 
 
 @router.get("/device_info", response_model=DeviceInfoResponse, dependencies=[Depends(require_api_key)])
 async def get_device_info_alias(services: Services = Depends(get_services)):
-    return await services.device.get_device_info()
+    return await services.device.get_device_info(context=None)
 
 
 @router.post("/device_name", response_model=DeviceNameResponse, dependencies=[Depends(require_api_key)])

{topos_node-0.1.6 → topos_node-0.1.8}/topos/control_plane_client.py

@@ -103,6 +103,24 @@ class ControlPlaneClient:
         self._task = asyncio.create_task(self._run())
         logger.info("Control plane client starting: %s", self.control_plane_url)
 
+    def _restart_if_task_stopped(self) -> None:
+        # Self-heal if the reconnect loop exited unexpectedly while the app is still running.
+        if self._stop.is_set() or not self._task or not self._task.done():
+            return
+        reason = "unknown"
+        try:
+            exc = self._task.exception()
+            if exc is not None:
+                reason = repr(exc)
+        except asyncio.CancelledError:
+            reason = "cancelled"
+        logger.warning(
+            "Control plane background task stopped unexpectedly; restarting endpoint=%s reason=%s",
+            self.control_plane_url,
+            reason,
+        )
+        self.start()
+
     async def wait_until_connected(self, timeout_s: float | None = None) -> bool:
         timeout = float(timeout_s) if timeout_s is not None else float(settings.connection_readiness_timeout_seconds)
         try:
@@ -292,6 +310,7 @@ class ControlPlaneClient:
     async def send_message(self, message: Dict[str, Any]) -> None:
         """Send an unsolicited message to the control plane (e.g., progress updates)."""
         if not self._ws:
+            self._restart_if_task_stopped()
             await self._enqueue_presence_message(message)
             logger.warning("Queued presence message; control plane currently disconnected")
             return

{topos_node-0.1.6 → topos_node-0.1.8}/topos/core/api_models.py

@@ -95,6 +95,7 @@ class DeviceInfoResponse(BaseModel):
     engine_mode: str
     llm_enabled: bool
     database_mode: str
+    database_version: Optional[str] = None
     engine_name: Optional[str]
     engine_version: Optional[str] = None
     system: Dict[str, Any]

{topos_node-0.1.6 → topos_node-0.1.8}/topos/core/handlers.py

@@ -1139,6 +1139,15 @@ async def handle_control_plane_request(message: Dict[str, Any]) -> Optional[Dict
     _payload = message.get("payload") or {}
     _mcp_source = _payload.get("mcp_source")
     _mcp_requester_id = _payload.get("mcp_requester_id")
+    if msg_type == "migrate_browser_plugin_app_id":
+        from .state import _migrate_legacy_browser_plugin_app_ids
+
+        conn = get_db_connection()
+        if not conn:
+            return {"id": req_id, "status": "error", "error": "Database not available"}
+        updated = _migrate_legacy_browser_plugin_app_ids(conn)
+        return {"id": req_id, "status": "ok", "payload": {"updated_rows": updated}}
+
     if msg_type == "get_request_counts":
         """Return UMA + MCP request counts from engine DB (for CP proxy or direct frontend)."""
         payload = message.get("payload") or {}
@@ -1759,8 +1768,10 @@ async def handle_control_plane_request(message: Dict[str, Any]) -> Optional[Dict
         except Exception as exc:  # noqa: BLE001
             return {"id": req_id, "status": "error", "error": str(exc)}
     if msg_type == "get_device_info":
+        payload = message.get("payload") or {}
+        context = payload if isinstance(payload, dict) else {}
         try:
-            result = await get_services().device.get_device_info()
+            result = await get_services().device.get_device_info(context=context)
             return {"id": req_id, "status": "ok", "payload": result.model_dump()}
         except Exception as exc:  # noqa: BLE001
             return {"id": req_id, "status": "error", "error": str(exc)}

{topos_node-0.1.6 → topos_node-0.1.8}/topos/core/state.py

@@ -14,6 +14,8 @@ from typing import Any, Dict, Optional
 
 MCP_REQUEST_LOG_TABLE = "mcp_request_log"
 UMA_ACCESS_REQUESTS_TABLE = "uma_access_requests"
+LEGACY_BROWSER_PLUGIN_APP_ID = "browser-plugin"
+BROWSER_HISTORY_PLUGIN_APP_ID = "browser-history-plugin"
 
 
 def derive_uma_access_context(owner_user_id: str, requesting_user_id: Optional[str]) -> str:
@@ -401,6 +403,29 @@ def _ensure_uma_access_requests_table(conn: sqlite3.Connection) -> None:
                 conn.commit()
     except Exception as exc:
         logger.warning("Failed to ensure uma_access_requests table exists: %s", exc)
+    else:
+        _migrate_legacy_browser_plugin_app_ids(conn)
+
+
+def _migrate_legacy_browser_plugin_app_ids(conn: sqlite3.Connection) -> int:
+    """Rewrite engine Activity counts from browser-plugin → browser-history-plugin (idempotent)."""
+    try:
+        cursor = conn.execute(
+            f"UPDATE {UMA_ACCESS_REQUESTS_TABLE} SET app_id = ? WHERE app_id = ?",
+            (BROWSER_HISTORY_PLUGIN_APP_ID, LEGACY_BROWSER_PLUGIN_APP_ID),
+        )
+        if cursor.rowcount:
+            conn.commit()
+            logger.info(
+                "Migrated %s uma_access_requests rows: %s → %s",
+                cursor.rowcount,
+                LEGACY_BROWSER_PLUGIN_APP_ID,
+                BROWSER_HISTORY_PLUGIN_APP_ID,
+            )
+        return int(cursor.rowcount or 0)
+    except Exception as exc:
+        logger.warning("browser-plugin app_id migration on engine failed: %s", exc)
+        return 0
 
 
 def record_uma_request(
@@ -463,6 +488,7 @@ def get_uma_request_counts(
         "total_read_requests": 0,
         "total_write_requests": 0,
         "by_app": [],
+        "by_app_requester": [],
         "by_requesting_user": [],
         "access_attribution": {
             "window_days": since_days or 0,
@@ -510,6 +536,38 @@ def get_uma_request_counts(
                 for aid, d in sorted(by_app.items())
             ]
 
+            cursor = conn.execute(
+                f"""SELECT app_id, requesting_user_id, requesting_user_email, request_type
+                    FROM {UMA_ACCESS_REQUESTS_TABLE}
+                    WHERE owner_user_id = ? AND created_at >= ?""",
+                (owner_user_id, since_ts),
+            )
+            by_app_req: Dict[str, Dict[str, Any]] = {}
+            for row in cursor.fetchall():
+                app_id_val = (row[0] or "").strip() if len(row) > 0 else ""
+                rid = (row[1] or "").strip() if len(row) > 1 else ""
+                remail = (row[2] or "").strip() if len(row) > 2 else ""
+                rt = (row[3] or "").strip().lower() if len(row) > 3 else ""
+                key = f"{app_id_val}\0{rid}\0{remail}"
+                if key not in by_app_req:
+                    by_app_req[key] = {
+                        "app_id": app_id_val or None,
+                        "requesting_user_id": rid or None,
+                        "requesting_user_email": remail or None,
+                        "read_requests": 0,
+                        "write_requests": 0,
+                    }
+                if rt == "read":
+                    by_app_req[key]["read_requests"] += 1
+                elif rt == "write":
+                    by_app_req[key]["write_requests"] += 1
+            app_req_ranked = []
+            for d in by_app_req.values():
+                tr = int(d["read_requests"]) + int(d["write_requests"])
+                app_req_ranked.append({**d, "total_requests": tr})
+            app_req_ranked.sort(key=lambda x: -x["total_requests"])
+            out["by_app_requester"] = app_req_ranked[:50]
+
             cursor = conn.execute(
                 f"""SELECT requesting_user_id, requesting_user_email, request_type, access_context
                     FROM {UMA_ACCESS_REQUESTS_TABLE}

{topos_node-0.1.6 → topos_node-0.1.8}/topos/services/interfaces.py

@@ -31,7 +31,7 @@ class SyncService(Protocol):
 class DeviceService(Protocol):
     async def get_pairing_code(self) -> PairingCodeResponse: ...
     async def pair_device(self, pairing_code: str, keep_existing_data: bool) -> PairDeviceResponse: ...
-    async def get_device_info(self) -> DeviceInfoResponse: ...
+    async def get_device_info(self, context: Optional[Dict[str, Any]] = None) -> DeviceInfoResponse: ...
     async def set_device_name(self, device_name: str) -> DeviceNameResponse: ...
 
 

{topos_node-0.1.6 → topos_node-0.1.8}/topos/services/local.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import sqlite3
 from typing import Any, Dict, Optional
 
+from ..__version__ import __version__
 from ..core.api_models import (
     DeviceInfoResponse,
     DeviceNameResponse,
@@ -61,7 +63,8 @@ class LocalDeviceService:
         _ = (pairing_code, keep_existing_data)
         raise HTTPException(status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Pairing not implemented")
 
-    async def get_device_info(self) -> DeviceInfoResponse:
+    async def get_device_info(self, context: Optional[Dict[str, Any]] = None) -> DeviceInfoResponse:
+        _ = context
         # Get user_id from database (set by connection_info handler) or fall back to settings
         user_id = None
         if state.db_conn:
@@ -92,8 +95,9 @@ class LocalDeviceService:
             engine_mode=state.get_engine_mode(),
             llm_enabled=settings.enable_llm and state.get_engine_mode() == "full",
             database_mode=settings.topos_database_mode,
+            database_version=sqlite3.sqlite_version if settings.topos_database_mode in {"local", "sqlite"} else None,
             engine_name=device_name,
-            engine_version=None,
+            engine_version=__version__,
             system=state.get_system_info(),
             last_sync_at=last_sync_at,
             last_received_hlc_ts=last_received_hlc_ts,

{topos_node-0.1.6 → topos_node-0.1.8}/topos/services/postgres.py

@@ -7,7 +7,9 @@ from uuid import uuid4
 
 from fastapi import HTTPException, status
 
+from ..__version__ import __version__
 from ..config.settings import settings
+from ..core import state
 from ..core.api_models import (
     DeviceInfoResponse,
     DeviceNameResponse,
@@ -22,6 +24,7 @@ from ..storage.db.postgres import (
     connect_postgres,
     execute_query,
     fetch_all,
+    fetch_one,
 )
 
 
@@ -364,20 +367,80 @@ class PostgresDbService:
         }
 
 
+def _hosted_postgres_version() -> Optional[str]:
+    try:
+        with connect_postgres() as conn:
+            row = fetch_one(conn, "SELECT version() AS version", ())
+            if row and row[0]:
+                return str(row[0]).strip() or None
+    except Exception:
+        return None
+    return None
+
+
+def _hosted_dataset_id(context: Optional[Dict[str, Any]], user_id: Optional[str]) -> Optional[str]:
+    ctx = context if isinstance(context, dict) else {}
+    explicit = str(ctx.get("dataset_id") or "").strip()
+    if explicit:
+        return explicit
+    if not user_id:
+        return None
+    tenant_id = str(ctx.get("tenant_id") or "").strip()
+    if tenant_id:
+        return f"{user_id}:default:{tenant_id}"
+    default_dataset = (settings.topos_default_dataset_id or "default").strip() or "default"
+    return f"{user_id}:{default_dataset}"
+
+
 class HostedDeviceService:
     async def get_pairing_code(self) -> PairingCodeResponse:
-        raise NotImplementedError("HostedDeviceService not implemented yet")
+        raise HTTPException(
+            status_code=status.HTTP_501_NOT_IMPLEMENTED,
+            detail="Pairing is not available for hosted runtimes",
+        )
 
     async def pair_device(self, pairing_code: str, keep_existing_data: bool) -> PairDeviceResponse:
         _ = (pairing_code, keep_existing_data)
-        raise NotImplementedError("HostedDeviceService not implemented yet")
+        raise HTTPException(
+            status_code=status.HTTP_501_NOT_IMPLEMENTED,
+            detail="Pairing is not available for hosted runtimes",
+        )
 
-    async def get_device_info(self) -> DeviceInfoResponse:
-        raise NotImplementedError("HostedDeviceService not implemented yet")
+    async def get_device_info(self, context: Optional[Dict[str, Any]] = None) -> DeviceInfoResponse:
+        ctx = context if isinstance(context, dict) else {}
+        user_id = str(ctx.get("owner_user_id") or settings.topos_user_id or "").strip() or None
+        dataset_id = _hosted_dataset_id(ctx, user_id)
+        engine_mode = state.get_engine_mode()
+        device_name = (settings.engine_name or "").strip() or None
+
+        return DeviceInfoResponse(
+            user_id=user_id,
+            dataset_id=dataset_id,
+            sync_connected=False,
+            sync_enabled=False,
+            engine_class=state.get_engine_class(),
+            engine_mode=engine_mode,
+            llm_enabled=bool(settings.enable_llm and engine_mode == "full"),
+            database_mode=settings.topos_database_mode or "postgres",
+            database_version=_hosted_postgres_version(),
+            engine_name=device_name,
+            engine_version=__version__,
+            system={},
+            last_sync_at=None,
+            last_received_hlc_ts=None,
+            last_received_op_id=None,
+            oplog_count=None,
+            oplog_bytes=None,
+            ops_since_last_sync=None,
+            oplog_bytes_since_last_sync=None,
+        )
 
     async def set_device_name(self, device_name: str) -> DeviceNameResponse:
         _ = device_name
-        raise NotImplementedError("HostedDeviceService not implemented yet")
+        raise HTTPException(
+            status_code=status.HTTP_501_NOT_IMPLEMENTED,
+            detail="Device rename is not available for hosted runtimes",
+        )
 
 
 class HostedSyncService:

{topos_node-0.1.6 → topos_node-0.1.8}/topos_node.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 0.1.6
+Version: 0.1.8
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai