fix: 恢复 rsync 误删的近期开发(agents/skills/mcp/knowledge/workflow/tenant/billing/storage/privacy/promotion/achievement/automation/code-exec/developer/distribution/im-bot/portal/casdoor 等后端模块 + 对应前端页面路由, 补回 main.py 挂载与 App.tsx 路由

backend/python/platform_bridge/sync_client.py

@@ -0,0 +1,133 @@
+"""
+Platform Bridge - Cloud-to-Local Agent Bridge
+==============================================
+WorkBuddy-compatible sync client for local Goose agent.
+
+Provides:
+- Periodic knowledge base sync
+- Usage metrics collection and reporting
+- License validation and refresh
+- Platform health monitoring
+"""
+import os
+import json
+import time
+import hashlib
+from datetime import datetime, timedelta
+
+# Import the MCP server client
+from .mcp_server import PlatformBridgeClient
+
+
+class SyncManager:
+    """Manages periodic synchronization between local agent and cloud platform"""
+
+    def __init__(self, client: PlatformBridgeClient = None):
+        self.client = client or PlatformBridgeClient()
+        self.sync_interval = 3600  # Default: 1 hour
+        self.last_sync = {}
+        self.last_license_check = None
+        self.last_usage_report = None
+        self.usage_buffer = []
+
+    def configure(self, config: dict):
+        """Configure sync parameters from privacy config"""
+        frequency_map = {
+            "realtime": 60,
+            "hourly": 3600,
+            "daily": 86400,
+            "manual": None,  # No auto sync
+        }
+        freq = config.get("sync_frequency", "daily")
+        self.sync_interval = frequency_map.get(freq, 86400)
+        self.client.user_id = config.get("user_id", self.client.user_id)
+
+    def should_sync_kb(self, kb_id: int) -> bool:
+        """Check if a KB needs syncing"""
+        last = self.last_sync.get(kb_id, 0)
+        return (time.time() - last) >= self.sync_interval
+
+    def sync_kb(self, kb_id: int) -> dict:
+        """Sync a single knowledge base"""
+        result = self.client.sync_knowledge_base(kb_id)
+        self.last_sync[kb_id] = time.time()
+        return result
+
+    def sync_all(self, kb_ids: list) -> list:
+        """Sync all configured knowledge bases"""
+        results = []
+        for kb_id in kb_ids:
+            if self.should_sync_kb(kb_id):
+                result = self.sync_kb(kb_id)
+                results.append({"kb_id": kb_id, "result": result})
+        return results
+
+    def check_license(self, license_key: str) -> dict:
+        """Check if license is still valid"""
+        now = time.time()
+        if self.last_license_check and (now - self.last_license_check) < 3600:
+            return {"valid": True, "cached": True}
+
+        result = self.client.validate_license(license_key)
+        self.last_license_check = now
+        return result
+
+    def track_usage(self, event_type: str, metadata: dict = None):
+        """Buffer a usage event for reporting"""
+        self.usage_buffer.append({
+            "type": event_type,
+            "timestamp": time.time(),
+            "metadata": metadata or {},
+        })
+
+    def report_usage(self) -> dict:
+        """Submit buffered usage events"""
+        if not self.usage_buffer:
+            return {"reported": 0}
+
+        events = self.usage_buffer[:]
+        self.usage_buffer = []
+
+        metrics = {
+            "event_count": len(events),
+            "event_types": {},
+            "time_range": {
+                "start": min(e["timestamp"] for e in events),
+                "end": max(e["timestamp"] for e in events),
+            }
+        }
+
+        for e in events:
+            t = e["type"]
+            metrics["event_types"][t] = metrics["event_types"].get(t, 0) + 1
+
+        result = self.client.report_usage(metrics)
+        self.last_usage_report = time.time()
+        result["reported"] = len(events)
+        return result
+
+    def health_check(self) -> dict:
+        """Run a full health check"""
+        platform = self.client.check_health()
+        config = self.client.get_privacy_config()
+
+        return {
+            "platform": platform,
+            "privacy_mode": config.get("data", {}).get("privacy_mode", "unknown"),
+            "pending_events": len(self.usage_buffer),
+            "last_license_check": self.last_license_check,
+            "last_usage_report": self.last_usage_report,
+        }
+
+
+def create_sync_manager(api_url: str = None, user_id: str = None) -> SyncManager:
+    """Factory function to create a configured SyncManager"""
+    client = PlatformBridgeClient(api_url=api_url, user_id=user_id)
+    manager = SyncManager(client)
+
+    # Load config
+    config_result = client.get_privacy_config()
+    if config_result.get("code") == 0:
+        manager.configure(config_result["data"])
+
+    return manager