soulsync 1.0.13 → 1.0.14

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "soulsync",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "SoulSync plugin for OpenClaw - cross-bot memory synchronization",
   "main": "index.js",
   "repository": {
     "type": "git",
     "url": "https://github.com/alanliuc-a11y/soulsync"
   },
+  "dependencies": {
+    "open": "^10.1.0"
+  },
   "openclaw": {
     "extensions": [
       "./index.js"

package/src/client.py

@@ -153,6 +153,22 @@ class OpenClawClient:
         else:
             error = response.json().get('error', 'Unknown error')
             raise Exception(f"Get profile failed: {error}")
+
+    def get_user_info(self) -> dict:
+        """获取当前登录用户信息
+        
+        Returns:
+            用户信息，包含 email, name, subscription_status
+        """
+        url = f"{self.cloud_url}/api/auth/user/info"
+        
+        response = self.session.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 user info failed: {error}")
     
     def connect_websocket(self, on_message_callback):
         """连接 WebSocket

package/src/config.js

@@ -0,0 +1,100 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+let config = null;
+
+function getPluginDir() {
+  return path.dirname(__filename);
+}
+
+function loadConfig() {
+  if (config) return config;
+  
+  const pluginDir = path.dirname(__filename);
+  const configPath = path.join(pluginDir, 'config.json');
+  
+  try {
+    if (fs.existsSync(configPath)) {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      return config;
+    }
+  } catch (e) {
+    console.error('[SoulSync] Error loading config:', e);
+  }
+  return null;
+}
+
+function saveConfig(newConfig) {
+  const pluginDir = path.dirname(__filename);
+  const configPath = path.join(pluginDir, 'config.json');
+  
+  try {
+    let existing = {};
+    if (fs.existsSync(configPath)) {
+      existing = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    config = { ...existing, ...newConfig };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return true;
+  } catch (e) {
+    console.error('[SoulSync] Error saving config:', e);
+    return false;
+  }
+}
+
+function clearConfig() {
+  const pluginDir = path.dirname(__filename);
+  const configPath = path.join(pluginDir, 'config.json');
+  
+  try {
+    if (fs.existsSync(configPath)) {
+      const existing = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      delete existing.token;
+      delete existing.email;
+      delete existing.device_id;
+      delete existing.device_name;
+      fs.writeFileSync(configPath, JSON.stringify(existing, null, 2));
+      config = existing;
+    }
+    return true;
+  } catch (e) {
+    console.error('[SoulSync] Error clearing config:', e);
+    return false;
+  }
+}
+
+function getDeviceName(deviceType = 'local') {
+  const hostname = os.hostname();
+  const platform = os.platform();
+  const username = os.userInfo().username;
+
+  let type = 'local';
+  if (deviceType === 'cloud') type = '云端';
+  else if (deviceType === 'ssh') type = 'SSH';
+  else {
+    if (platform === 'win32') type = 'Windows';
+    else if (platform === 'darwin') type = 'Mac';
+    else if (platform === 'linux') type = 'Linux';
+  }
+
+  if (deviceType === 'cloud') {
+    return `${type} Bot`;
+  }
+
+  return `${username}的${type}`;
+}
+
+function isAuthenticated() {
+  const cfg = loadConfig();
+  return cfg && cfg.token && cfg.email && cfg.email !== 'your-email@example.com';
+}
+
+module.exports = {
+  loadConfig,
+  saveConfig,
+  clearConfig,
+  getDeviceName,
+  isAuthenticated,
+  getPluginDir
+};

package/src/device-code.js

@@ -0,0 +1,150 @@
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+let pollingInterval = null;
+
+function getCloudUrl() {
+  const pluginDir = path.dirname(__filename);
+  const configPath = path.join(pluginDir, 'config.json');
+  try {
+    if (fs.existsSync(configPath)) {
+      const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      if (cfg.cloud_url) return cfg.cloud_url;
+    }
+  } catch (e) {}
+  return 'https://soulsync.work';
+}
+
+function makeRequest(method, urlPath, body = null) {
+  return new Promise((resolve, reject) => {
+    const cloudUrl = getCloudUrl();
+    const isHttps = cloudUrl.startsWith('https');
+    const client = isHttps ? https : http;
+    
+    const urlObj = new URL(cloudUrl + urlPath);
+    
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (isHttps ? 443 : 80),
+      path: urlObj.pathname + urlObj.search,
+      method: method,
+      headers: { 'Content-Type': 'application/json' }
+    };
+    
+    const req = client.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          resolve({ status: res.statusCode, body: json });
+        } catch (e) {
+          resolve({ status: res.statusCode, body: data });
+        }
+      });
+    });
+    
+    req.on('error', reject);
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+function requestDeviceCode() {
+  return makeRequest('POST', '/api/auth/device-code');
+}
+
+function pollForAuth(deviceCode) {
+  return makeRequest('GET', `/api/auth/device/${deviceCode}/status`);
+}
+
+function startPolling(deviceCode, onSuccess, onError) {
+  pollingInterval = setInterval(async () => {
+    try {
+      const result = await pollForAuth(deviceCode);
+      
+      if (result.body.status === 'authorized' && result.body.token) {
+        stopPolling();
+        onSuccess(result.body.token);
+        return;
+      }
+      
+      if (result.body.status === 'expired') {
+        stopPolling();
+        onError(new Error('Device code expired'));
+        return;
+      }
+      
+      if (result.body.status === 'not_found') {
+        stopPolling();
+        onError(new Error('Device code not found'));
+        return;
+      }
+    } catch (e) {
+      stopPolling();
+      onError(e);
+    }
+  }, 3000);
+}
+
+function stopPolling() {
+  if (pollingInterval) {
+    clearInterval(pollingInterval);
+    pollingInterval = null;
+  }
+}
+
+function savePendingAuth(deviceCode, authUrl) {
+  const homeDir = os.homedir();
+  const pendingDir = path.join(homeDir, '.soulsync');
+  const pendingFile = path.join(pendingDir, '.pending_auth');
+  
+  try {
+    if (!fs.existsSync(pendingDir)) {
+      fs.mkdirSync(pendingDir, { recursive: true });
+    }
+    fs.writeFileSync(pendingFile, JSON.stringify({ deviceCode, authUrl, timestamp: Date.now() }));
+    return true;
+  } catch (e) {
+    console.error('[SoulSync] Error saving pending auth:', e);
+    return false;
+  }
+}
+
+function loadPendingAuth() {
+  const homeDir = os.homedir();
+  const pendingFile = path.join(homeDir, '.soulsync', '.pending_auth');
+  
+  try {
+    if (fs.existsSync(pendingFile)) {
+      const data = JSON.parse(fs.readFileSync(pendingFile, 'utf-8'));
+      if (Date.now() - data.timestamp < 900000) {
+        return data;
+      }
+      fs.unlinkSync(pendingFile);
+    }
+  } catch (e) {}
+  return null;
+}
+
+function clearPendingAuth() {
+  const homeDir = os.homedir();
+  const pendingFile = path.join(homeDir, '.soulsync', '.pending_auth');
+  try {
+    if (fs.existsSync(pendingFile)) {
+      fs.unlinkSync(pendingFile);
+    }
+  } catch (e) {}
+}
+
+module.exports = {
+  requestDeviceCode,
+  startPolling,
+  stopPolling,
+  savePendingAuth,
+  loadPendingAuth,
+  clearPendingAuth
+};

package/src/oauth-server.js

@@ -0,0 +1,48 @@
+const http = require('http');
+const url = require('url');
+
+function createOAuthServer() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const parsedUrl = url.parse(req.url, true);
+      
+      if (parsedUrl.pathname === '/callback') {
+        const { token, state, error } = parsedUrl.query;
+        
+        if (error) {
+          res.writeHead(400, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h1>授权失败</h1><p>请关闭此窗口并重试。</p></body></html>');
+          server.close();
+          reject(new Error(error));
+          return;
+        }
+        
+        if (token) {
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end('<html><body><h1>授权成功！</h1><p>请关闭此窗口并返回终端。</p></body></html>');
+          server.close();
+          resolve({ token, state });
+          return;
+        }
+        
+        res.writeHead(400, { 'Content-Type': 'text/html' });
+        res.end('<html><body><h1>无效响应</h1></body></html>');
+        server.close();
+        reject(new Error('No token received'));
+        return;
+      }
+      
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not Found');
+    });
+    
+    server.listen(0, () => {
+      const port = server.address().port;
+      resolve({ server, port });
+    });
+    
+    server.on('error', reject);
+  });
+}
+
+module.exports = { createOAuthServer };

package/test_ssl_fix.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+测试 SSL 修复是否有效
+"""
+import ssl
+import sys
+
+print(f"Python 版本: {sys.version}")
+print(f"SSL 版本: {ssl.OPENSSL_VERSION}")
+print()
+
+# 测试 1: 使用 ssl.create_default_context()
+print("测试 1: 使用 ssl.create_default_context()")
+try:
+    import urllib.request
+    ctx = ssl.create_default_context()
+    ctx.minimum_version = ssl.TLSVersion.TLSv1_2
+    req = urllib.request.Request('https://soulsync.work/api/health')
+    response = urllib.request.urlopen(req, context=ctx)
+    print(f"✅ 成功: {response.read().decode()}")
+except Exception as e:
+    print(f"❌ 失败: {e}")
+
+print()
+
+# 测试 2: 使用 requests + TLSAdapter
+print("测试 2: 使用 requests + 自定义 TLSAdapter")
+try:
+    import requests
+    from requests.adapters import HTTPAdapter
+
+    class TLSAdapter(HTTPAdapter):
+        def init_poolmanager(self, *args, **kwargs):
+            ctx = ssl.create_default_context()
+            ctx.minimum_version = ssl.TLSVersion.TLSv1_2
+            kwargs['ssl_context'] = ctx
+            return super().init_poolmanager(*args, **kwargs)
+
+    session = requests.Session()
+    session.mount('https://', TLSAdapter())
+    response = session.get('https://soulsync.work/api/health')
+    print(f"✅ 成功: {response.text}")
+except Exception as e:
+    print(f"❌ 失败: {e}")
+
+print()
+
+# 测试 3: 直接 requests（无适配器）
+print("测试 3: 直接 requests（无适配器）")
+try:
+    import requests
+    response = requests.get('https://soulsync.work/api/health')
+    print(f"✅ 成功: {response.text}")
+except Exception as e:
+    print(f"❌ 失败: {e}")
+
+print()
+print("测试完成")