soulsync 1.0.0

package/config.json

@@ -0,0 +1,17 @@
+{
+  "cloud_url": "http://localhost:3000",
+  "email": "",
+  "password": "",
+  "workspace": "./workspace",
+  "memory_file": "MEMORY.md",
+  "watch_files": [
+    "SOUL.md",
+    "IDENTITY.md",
+    "USER.md",
+    "AGENTS.md",
+    "TOOLS.md",
+    "skills.json",
+    "memory/",
+    "MEMORY.md"
+  ]
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "soulsync",
+  "version": "1.0.0",
+  "description": "SoulSync plugin for OpenClaw - cross-bot memory synchronization",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alanliuc-a11y/soulsync.git"
+  },
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "bot-memory",
+    "bot-soulsync"
+  ],
+  "author": "Alan Liu",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/alanliuc-a11y/soulsync/issues"
+  },
+  "homepage": "https://github.com/alanliuc-a11y/soulsync#readme",
+ 	"openclaw": {
+   		 "plugin": true,
+  		  "type": "python"
+	}
+}

package/requirements.txt

@@ -0,0 +1,3 @@
+requests>=2.28.0
+watchdog>=3.0.0
+websocket-client>=1.6.0

package/src/client.py

@@ -0,0 +1,224 @@
+import json
+import os
+import uuid
+import requests
+import websocket
+
+
+class OpenClawClient:
+    """OpenClaw 插件的 API/WS 客户端"""
+    
+    def __init__(self, config: dict):
+        self.config = config
+        self.cloud_url = config.get('cloud_url', '').rstrip('/')
+        self.token = None
+        self.user_id = None
+        self.device_id = self._load_or_generate_device_id()
+        self.ws = None
+        self.ws_thread = None
+    
+    def _load_or_generate_device_id(self) -> str:
+        """加载或生成设备ID"""
+        plugin_dir = os.path.dirname(os.path.dirname(__file__))
+        device_id_file = os.path.join(plugin_dir, 'device_id')
+        
+        if os.path.exists(device_id_file):
+            with open(device_id_file, 'r') as f:
+                return f.read().strip()
+        
+        new_device_id = str(uuid.uuid4())
+        with open(device_id_file, 'w') as f:
+            f.write(new_device_id)
+        
+        print(f"Generated new device_id: {new_device_id}")
+        return new_device_id
+    
+    def _save_token(self, token: str):
+        """保存 token"""
+        plugin_dir = os.path.dirname(os.path.dirname(__file__))
+        token_file = os.path.join(plugin_dir, 'token')
+        with open(token_file, 'w') as f:
+            f.write(token)
+        self.token = token
+    
+    def _load_token(self) -> str:
+        """加载 token"""
+        plugin_dir = os.path.dirname(os.path.dirname(__file__))
+        token_file = os.path.join(plugin_dir, 'token')
+        
+        if os.path.exists(token_file):
+            with open(token_file, 'r') as f:
+                return f.read().strip()
+        
+        return None
+    
+    def _get_headers(self) -> dict:
+        """获取请求头"""
+        headers = {'Content-Type': 'application/json'}
+        if self.token:
+            headers['Authorization'] = f'Bearer {self.token}'
+        return headers
+    
+    def authenticate(self, email: str = None, password: str = None) -> dict:
+        """认证：注册或登录
+        
+        Args:
+            email: 邮箱 (首次注册需要)
+            password: 密码 (首次注册需要)
+            
+        Returns:
+            认证结果
+        """
+        self.token = self._load_token()
+        
+        if self.token:
+            try:
+                profile = self.get_profile()
+                print(f"Using existing token, user: {profile.get('email', 'unknown')}")
+                return profile
+            except Exception as e:
+                print(f"Token invalid, re-authenticating: {e}")
+                self.token = None
+        
+        if not email:
+            email = self.config.get('email', '')
+        if not password:
+            password = self.config.get('password', '')
+        
+        if not email or not password:
+            raise ValueError("Email and password required for first-time authentication")
+        
+        url = f"{self.cloud_url}/api/auth/device"
+        data = {
+            'device_id': self.device_id,
+            'email': email,
+            'password': password
+        }
+        
+        response = requests.post(url, json=data, headers={'Content-Type': 'application/json'})
+        
+        if response.status_code == 201:
+            result = response.json()
+            self.token = result.get('token')
+            self.user_id = result.get('user_id')
+            self._save_token(self.token)
+            print(f"Registered new user: {email}")
+            return result
+        elif response.status_code == 200:
+            result = response.json()
+            self.token = result.get('token')
+            self.user_id = result.get('user_id')
+            self._save_token(self.token)
+            print(f"Logged in: {email}")
+            return result
+        else:
+            error = response.json().get('error', 'Unknown error')
+            raise Exception(f"Authentication failed: {error}")
+    
+    def upload_memory(self, content: str) -> dict:
+        """上传记忆
+        
+        Args:
+            content: 记忆内容
+            
+        Returns:
+            上传结果
+        """
+        url = f"{self.cloud_url}/api/memories"
+        data = {'content': content}
+        
+        response = requests.post(url, json=data, headers=self._get_headers())
+        
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 403:
+            error = response.json().get('error', 'Subscription required')
+            raise Exception(f"Upload failed: {error}")
+        else:
+            error = response.json().get('error', 'Unknown error')
+            raise Exception(f"Upload failed: {error}")
+    
+    def download_memory(self) -> dict:
+        """下载记忆
+        
+        Returns:
+            包含 content, version 等信息的字典
+        """
+        url = f"{self.cloud_url}/api/memories"
+        
+        response = requests.get(url, headers=self._get_headers())
+        
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 404:
+            return {'content': '', 'version': 0}
+        else:
+            error = response.json().get('error', 'Unknown error')
+            raise Exception(f"Download failed: {error}")
+    
+    def get_profile(self) -> dict:
+        """获取用户信息
+        
+        Returns:
+            用户信息
+        """
+        url = f"{self.cloud_url}/api/memories/profile"
+        
+        response = requests.get(url, headers=self._get_headers())
+        
+        if response.status_code == 200:
+            return response.json()
+        else:
+            error = response.json().get('error', 'Unknown error')
+            raise Exception(f"Get profile failed: {error}")
+    
+    def connect_websocket(self, on_message_callback):
+        """连接 WebSocket
+        
+        Args:
+            on_message_callback: 消息回调函数
+        """
+        ws_url = self.cloud_url.replace('http', 'ws') + '/ws'
+        
+        def on_ws_message(ws, message):
+            try:
+                data = json.loads(message)
+                on_message_callback(data)
+            except Exception as e:
+                print(f"WebSocket message error: {e}")
+        
+        def on_ws_error(ws, error):
+            print(f"WebSocket error: {error}")
+        
+        def on_ws_close(ws, close_status_code, close_msg):
+            print(f"WebSocket closed: {close_status_code} - {close_msg}")
+        
+        def on_ws_open(ws):
+            print("WebSocket connected")
+            if self.token:
+                ws.send(json.dumps({'type': 'auth', 'token': self.token}))
+        
+        self.ws = websocket.WebSocketApp(
+            ws_url,
+            on_message=on_ws_message,
+            on_error=on_ws_error,
+            on_close=on_ws_close,
+            on_open=on_ws_open
+        )
+        
+        self.ws.on_pong = lambda ws, data: None
+        
+        import threading
+        self.ws_thread = threading.Thread(target=self.ws.run_forever, daemon=True)
+        self.ws_thread.start()
+    
+    def disconnect_websocket(self):
+        """断开 WebSocket 连接"""
+        if self.ws:
+            self.ws.close()
+            self.ws = None
+    
+    def send_ping(self):
+        """发送 ping 保持连接"""
+        if self.ws and self.ws.sock and self.ws.sock.connected:
+            self.ws.send(json.dumps({'type': 'ping'}))

package/src/main.py

@@ -0,0 +1,198 @@
+import json
+import os
+import sys
+import time
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'base'))
+
+from src.client import OpenClawClient
+from src.watcher import OpenClawMultiWatcher
+from src.version_manager import VersionManager
+from src.profiles import ProfilesClient
+from src.sync import ProfileSync
+
+
+class SoulSyncPlugin:
+    """SoulSync OpenClaw 插件主类"""
+    
+    def __init__(self):
+        self.config = None
+        self.client = None
+        self.profiles_client = None
+        self.watcher = None
+        self.version_manager = None
+        self.profile_sync = None
+        self.running = False
+    
+    def load_config(self):
+        """加载配置文件"""
+        config_path = os.path.join(os.path.dirname(__file__), '..', 'config.json')
+        
+        if not os.path.exists(config_path):
+            raise FileNotFoundError(f"Config file not found: {config_path}")
+        
+        with open(config_path, 'r', encoding='utf-8') as f:
+            self.config = json.load(f)
+        
+        workspace = self.config.get('workspace', './workspace')
+        workspace = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', workspace))
+        
+        watch_files = self.config.get('watch_files', ['MEMORY.md', 'memory/'])
+        
+        self.config['workspace'] = workspace
+        self.config['watch_files'] = watch_files
+        
+        print(f"Config loaded:")
+        print(f"  Cloud URL: {self.config.get('cloud_url')}")
+        print(f"  Workspace: {workspace}")
+        print(f"  Watch files: {watch_files}")
+    
+    def initialize(self):
+        """初始化组件"""
+        print("\n=== Initializing SoulSync Plugin ===\n")
+        
+        self.client = OpenClawClient(self.config)
+        
+        email = self.config.get('email')
+        password = self.config.get('password')
+        
+        if not email or not password:
+            print("WARNING: Email and password not configured!")
+            print("Please edit config.json and add your email and password\n")
+        
+        try:
+            self.client.authenticate(email, password)
+        except Exception as e:
+            print(f"Authentication error: {e}")
+            print("Please check your config.json and try again\n")
+            raise
+        
+        profile = self.client.get_profile()
+        print(f"\nLogged in as: {profile.get('email')}")
+        subscription = profile.get('subscription', {})
+        print(f"Subscription: {subscription.get('status')} (days remaining: {subscription.get('daysRemaining', 0)})\n")
+        
+        versions_file = os.path.join(os.path.dirname(__file__), '..', 'versions.json')
+        self.version_manager = VersionManager(versions_file)
+        
+        self.profiles_client = ProfilesClient(
+            self.config.get('cloud_url'),
+            self.client.token
+        )
+        
+        self.profile_sync = ProfileSync(
+            self.profiles_client,
+            self.version_manager,
+            self.config.get('workspace')
+        )
+        
+        print("Pulling all profiles from cloud...")
+        self.profile_sync.pull_all()
+        
+        print("\nStarting file watcher...")
+        watch_files = self.config.get('watch_files', [])
+        self.watcher = OpenClawMultiWatcher(
+            self.config.get('workspace'),
+            watch_files,
+            self.on_file_change
+        )
+        self.watcher.start()
+        
+        print("\nConnecting to WebSocket...")
+        self.client.connect_websocket(self.on_websocket_message)
+        
+        self.running = True
+    
+    def on_file_change(self, event_type: str, relative_path: str, absolute_path: str = None):
+        """文件变化回调"""
+        print(f"\n[File {event_type}] {relative_path}")
+        
+        if event_type in ['modified', 'created']:
+            time.sleep(0.5)
+            
+            try:
+                self.profile_sync.push_file(relative_path)
+                print(f"Upload completed: {relative_path}")
+            except Exception as e:
+                print(f"Upload error: {e}")
+        
+        elif event_type == 'deleted':
+            print(f"File deleted (not synced to cloud): {relative_path}")
+    
+    def on_websocket_message(self, data: dict):
+        """WebSocket 消息回调"""
+        event = data.get('event')
+        
+        if event == 'file_updated':
+            file_path = data.get('file_path')
+            version = data.get('version')
+            print(f"\n[WebSocket] File updated: {file_path} (v{version})")
+            try:
+                self.profile_sync.on_remote_change(file_path, version)
+            except Exception as e:
+                print(f"Sync error: {e}")
+        
+        elif event == 'new_memory':
+            print(f"\n[WebSocket] New memory available!")
+            try:
+                self.profile_sync.pull_all()
+                print("Memory synced from remote")
+            except Exception as e:
+                print(f"Sync error: {e}")
+        
+        elif data.get('type') == 'authenticated':
+            print(f"[WebSocket] Authenticated, socket_id: {data.get('socket_id')}")
+        elif data.get('type') == 'error':
+            print(f"[WebSocket] Error: {data.get('message')}")
+    
+    def run(self):
+        """运行插件"""
+        print("\n" + "=" * 50)
+        print("SoulSync OpenClaw Plugin (Multi-File Sync)")
+        print("=" * 50 + "\n")
+        
+        try:
+            self.load_config()
+            self.initialize()
+            
+            print("\n=== Plugin Running ===")
+            print("Press Ctrl+C to stop\n")
+            
+            while self.running:
+                time.sleep(1)
+                
+                if hasattr(self.client, 'ws') and self.client.ws:
+                    if not self.client.ws.sock or not self.client.ws.sock.connected:
+                        print("WebSocket disconnected, reconnecting...")
+                        try:
+                            self.client.connect_websocket(self.on_websocket_message)
+                        except Exception as e:
+                            print(f"Reconnect error: {e}")
+        
+        except KeyboardInterrupt:
+            print("\n\nShutting down...")
+        except Exception as e:
+            print(f"Error: {e}")
+        finally:
+            self.stop()
+    
+    def stop(self):
+        """停止插件"""
+        self.running = False
+        
+        if self.watcher:
+            self.watcher.stop()
+        
+        if self.client:
+            self.client.disconnect_websocket()
+        
+        print("Plugin stopped")
+
+
+def main():
+    plugin = SoulSyncPlugin()
+    plugin.run()
+
+
+if __name__ == '__main__':
+    main()

package/src/profiles.py

@@ -0,0 +1,110 @@
+import requests
+
+
+class ProfilesClient:
+    """Profiles API 客户端"""
+    
+    def __init__(self, cloud_url: str, token: str = None):
+        self.cloud_url = cloud_url.rstrip('/')
+        self.token = token
+    
+    def _get_headers(self) -> dict:
+        """获取请求头"""
+        headers = {'Content-Type': 'application/json'}
+        if self.token:
+            headers['Authorization'] = f'Bearer {self.token}'
+        return headers
+    
+    def set_token(self, token: str):
+        """设置 token"""
+        self.token = token
+    
+    def get_profiles(self, path: str = None) -> dict:
+        """获取 profiles
+        
+        Args:
+            path: 可选的文件路径
+            
+        Returns:
+            包含 files 列表的字典
+        """
+        url = f"{self.cloud_url}/api/profiles"
+        if path:
+            url += f"?path={path}"
+        
+        response = requests.get(url, headers=self._get_headers())
+        
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 404:
+            return {'files': []}
+        else:
+            error = response.json().get('error', 'Unknown error')
+            raise Exception(f"Get profiles failed: {error}")
+    
+    def upload_profile(self, file_path: str, content: str, version: int) -> dict:
+        """上传 profile
+        
+        Args:
+            file_path: 文件路径
+            content: 文件内容
+            version: 当前版本号
+            
+        Returns:
+            成功时返回 {file_path, version, updated_at}
+            冲突时抛出异常
+        """
+        url = f"{self.cloud_url}/api/profiles"
+        data = {
+            'file_path': file_path,
+            'content': content,
+            'version': version
+        }
+        
+        response = requests.post(url, json=data, headers=self._get_headers())
+        
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 409:
+            result = response.json()
+            raise ConflictError(
+                result.get('latest_content', ''),
+                result.get('latest_version', 0)
+            )
+        elif response.status_code == 403:
+            error = response.json().get('error', 'Subscription required')
+            raise Exception(f"Upload failed: {error}")
+        else:
+            error = response.json().get('error', 'Unknown error')
+            raise Exception(f"Upload failed: {error}")
+    
+    def sync_profiles(self, since: str = '0') -> dict:
+        """增量同步 profiles
+        
+        Args:
+            since: 时间戳
+            
+        Returns:
+            包含 files 列表和 server_time 的字典
+        """
+        url = f"{self.cloud_url}/api/profiles/sync?since={since}"
+        
+        response = requests.get(url, headers=self._get_headers())
+        
+        if response.status_code == 200:
+            return response.json()
+        elif response.status_code == 403:
+            error = response.json().get('error', 'Subscription required')
+            raise Exception(f"Sync failed: {error}")
+        else:
+            error = response.json().get('error', 'Unknown error')
+            raise Exception(f"Sync failed: {error}")
+
+
+class ConflictError(Exception):
+    """版本冲突异常"""
+    
+    def __init__(self, latest_content: str, latest_version: int):
+        self.latest_content = latest_content
+        self.latest_version = latest_version
+        super().__init__(f"Version conflict: latest version is {latest_version}")

package/src/sync.py

@@ -0,0 +1,140 @@
+import os
+import time
+from src.profiles import ProfilesClient, ConflictError
+
+
+class ProfileSync:
+    """多文件同步逻辑"""
+    
+    def __init__(self, client: ProfilesClient, version_manager, workspace: str):
+        self.client = client
+        self.version_manager = version_manager
+        self.workspace = os.path.abspath(workspace)
+        self.is_syncing = False
+    
+    def pull_all(self) -> int:
+        """从云端拉取所有文件
+        
+        Returns:
+            拉取的文件数量
+        """
+        print("[Sync] Pulling all profiles from cloud...")
+        self.is_syncing = True
+        
+        try:
+            result = self.client.sync_profiles(since='0')
+            files = result.get('files', [])
+            
+            if not files:
+                print("[Sync] No files in cloud")
+                return 0
+            
+            count = 0
+            for file_info in files:
+                file_path = file_info.get('file_path')
+                content = file_info.get('content')
+                version = file_info.get('version')
+                
+                if file_path and content is not None:
+                    self._write_local_file(file_path, content)
+                    self.version_manager.set_version(file_path, version)
+                    count += 1
+                    print(f"[Sync] Downloaded: {file_path} (v{version})")
+            
+            print(f"[Sync] Pulled {count} files")
+            return count
+        finally:
+            self.is_syncing = False
+    
+    def push_file(self, file_path: str):
+        """推送单个文件到云端
+        
+        Args:
+            file_path: 文件相对路径
+        """
+        if self.is_syncing:
+            print(f"[Sync] Skipping push, currently syncing: {file_path}")
+            return
+        
+        print(f"[Sync] Pushing file: {file_path}")
+        
+        content = self._read_local_file(file_path)
+        if content is None:
+            print(f"[Sync] File not found or read error: {file_path}")
+            return
+        
+        local_version = self.version_manager.get_version(file_path)
+        
+        try:
+            result = self.client.upload_profile(file_path, content, local_version)
+            
+            new_version = result.get('version')
+            self.version_manager.set_version(file_path, new_version)
+            
+            print(f"[Sync] Uploaded: {file_path} (v{new_version})")
+            
+        except ConflictError as e:
+            print(f"[Sync] Version conflict for {file_path}, pulling latest...")
+            
+            self._write_local_file(file_path, e.latest_content)
+            self.version_manager.set_version(file_path, e.latest_version)
+            
+            print(f"[Sync] Resolved conflict: {file_path} (now v{e.latest_version})")
+        
+        except Exception as e:
+            print(f"[Sync] Upload error: {e}")
+    
+    def on_remote_change(self, file_path: str, version: int):
+        """远程文件变化回调
+        
+        Args:
+            file_path: 文件相对路径
+            version: 新版本号
+        """
+        print(f"[Sync] Remote change detected: {file_path} (v{version})")
+        
+        local_version = self.version_manager.get_version(file_path)
+        
+        if version > local_version:
+            try:
+                result = self.client.get_profiles(path=file_path)
+                files = result.get('files', [])
+                
+                if files:
+                    file_info = files[0]
+                    content = file_info.get('content')
+                    
+                    self._write_local_file(file_path, content)
+                    self.version_manager.set_version(file_path, version)
+                    
+                    print(f"[Sync] Pulled remote change: {file_path} (v{version})")
+            except Exception as e:
+                print(f"[Sync] Pull remote change error: {e}")
+    
+    def _read_local_file(self, file_path: str) -> str:
+        """读取本地文件"""
+        full_path = os.path.join(self.workspace, file_path)
+        
+        if not os.path.exists(full_path):
+            return None
+        
+        try:
+            with open(full_path, 'r', encoding='utf-8') as f:
+                return f.read()
+        except Exception as e:
+            print(f"[Sync] Read error {file_path}: {e}")
+            return None
+    
+    def _write_local_file(self, file_path: str, content: str):
+        """写入本地文件"""
+        full_path = os.path.join(self.workspace, file_path)
+        
+        directory = os.path.dirname(full_path)
+        if directory and not os.path.exists(directory):
+            os.makedirs(directory, exist_ok=True)
+        
+        try:
+            with open(full_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+        except Exception as e:
+            print(f"[Sync] Write error {file_path}: {e}")

package/src/version_manager.py

@@ -0,0 +1,61 @@
+import json
+import os
+
+
+class VersionManager:
+    """本地版本管理"""
+    
+    def __init__(self, versions_file: str):
+        self.versions_file = versions_file
+        self.versions = {}
+        self.load()
+    
+    def load(self):
+        """加载版本文件"""
+        if os.path.exists(self.versions_file):
+            try:
+                with open(self.versions_file, 'r', encoding='utf-8') as f:
+                    self.versions = json.load(f)
+            except Exception as e:
+                print(f"Failed to load versions file: {e}")
+                self.versions = {}
+        else:
+            self.versions = {}
+    
+    def save(self):
+        """保存版本文件"""
+        try:
+            directory = os.path.dirname(self.versions_file)
+            if directory and not os.path.exists(directory):
+                os.makedirs(directory, exist_ok=True)
+            
+            with open(self.versions_file, 'w', encoding='utf-8') as f:
+                json.dump(self.versions, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            print(f"Failed to save versions file: {e}")
+    
+    def get_version(self, file_path: str) -> int:
+        """获取文件版本"""
+        return self.versions.get(file_path, 0)
+    
+    def set_version(self, file_path: str, version: int):
+        """设置文件版本"""
+        self.versions[file_path] = version
+        self.save()
+    
+    def increment_version(self, file_path: str) -> int:
+        """递增版本"""
+        current = self.get_version(file_path)
+        new_version = current + 1
+        self.set_version(file_path, new_version)
+        return new_version
+    
+    def update_versions(self, updates: dict):
+        """批量更新版本"""
+        for file_path, version in updates.items():
+            self.versions[file_path] = version
+        self.save()
+    
+    def get_all_versions(self) -> dict:
+        """获取所有版本"""
+        return self.versions.copy()

package/src/watcher.py

@@ -0,0 +1,133 @@
+import os
+import time
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler, FileSystemEvent
+
+
+class OpenClawMultiWatcher(FileSystemEventHandler):
+    """OpenClaw 多文件/目录监听器"""
+    
+    def __init__(self, workspace: str, watch_paths: list, callback):
+        self.workspace = os.path.abspath(workspace)
+        self.watch_paths = watch_paths
+        self.callback = callback
+        self.observer = None
+        self.last_events = {}
+        self.debounce_seconds = 1
+        self.ignore_patterns = ['.tmp', '.swp', '.bak', '~']
+    
+    def start(self):
+        """开始监听"""
+        if not os.path.exists(self.workspace):
+            os.makedirs(self.workspace, exist_ok=True)
+        
+        self.observer = Observer()
+        
+        for watch_path in self.watch_paths:
+            full_path = os.path.join(self.workspace, watch_path)
+            
+            if watch_path.endswith('/'):
+                dir_name = watch_path.rstrip('/')
+                if not os.path.exists(full_path):
+                    os.makedirs(full_path, exist_ok=True)
+                    print(f"Created directory: {full_path}")
+                
+                self.observer.schedule(self, full_path, recursive=True)
+                print(f"Watching directory: {watch_path}")
+            else:
+                directory = os.path.dirname(full_path)
+                if directory and not os.path.exists(directory):
+                    os.makedirs(directory, exist_ok=True)
+                
+                if not os.path.exists(full_path):
+                    with open(full_path, 'w', encoding='utf-8') as f:
+                        pass
+                    print(f"Created file: {watch_path}")
+                
+                self.observer.schedule(self, os.path.dirname(full_path), recursive=False)
+                print(f"Watching file: {watch_path}")
+        
+        self.observer.start()
+        print(f"Started watching {len(self.watch_paths)} paths in {self.workspace}")
+    
+    def stop(self):
+        """停止监听"""
+        if self.observer:
+            self.observer.stop()
+            self.observer.join()
+            print("Stopped watching")
+    
+    def _should_ignore(self, path: str) -> bool:
+        """检查是否应该忽略"""
+        basename = os.path.basename(path)
+        for pattern in self.ignore_patterns:
+            if pattern in basename:
+                return True
+        return False
+    
+    def _get_relative_path(self, absolute_path: str) -> str:
+        """获取相对路径"""
+        if absolute_path.startswith(self.workspace):
+            relative = absolute_path[len(self.workspace):].lstrip('/')
+            return relative
+        return absolute_path
+    
+    def _debounce_check(self, file_path: str) -> bool:
+        """防抖检查"""
+        current_time = time.time()
+        last_time = self.last_events.get(file_path, 0)
+        
+        if current_time - last_time < self.debounce_seconds:
+            return False
+        
+        self.last_events[file_path] = current_time
+        return True
+    
+    def on_modified(self, event):
+        """文件被修改"""
+        if event.is_directory:
+            return
+        
+        event_path = os.path.abspath(event.src_path)
+        
+        if self._should_ignore(event_path):
+            return
+        
+        if self._debounce_check(event_path):
+            relative_path = self._get_relative_path(event_path)
+            print(f"[Watcher] File modified: {relative_path}")
+            self._trigger_callback('modified', relative_path, event_path)
+    
+    def on_created(self, event):
+        """文件被创建"""
+        if event.is_directory:
+            return
+        
+        event_path = os.path.abspath(event.src_path)
+        
+        if self._should_ignore(event_path):
+            return
+        
+        if self._debounce_check(event_path):
+            relative_path = self._get_relative_path(event_path)
+            print(f"[Watcher] File created: {relative_path}")
+            self._trigger_callback('created', relative_path, event_path)
+    
+    def on_deleted(self, event):
+        """文件被删除"""
+        if event.is_directory:
+            return
+        
+        event_path = os.path.abspath(event.src_path)
+        
+        if self._should_ignore(event_path):
+            return
+        
+        relative_path = self._get_relative_path(event_path)
+        print(f"[Watcher] File deleted: {relative_path}")
+        self._trigger_callback('deleted', relative_path, event_path)
+    
+    def _trigger_callback(self, event_type: str, relative_path: str, absolute_path: str = None):
+        """触发回调函数"""
+        if self.callback:
+            self.callback(event_type, relative_path, absolute_path)

package/workspace/MEMORY.md

@@ -0,0 +1,5 @@
+# Memory
+
+This is your SoulSync memory file.
+
+Start writing your memories here, and they will be automatically synced to the cloud!