@myassis/gateway 1.0.0

package/dist/stores/authStore.js

@@ -0,0 +1,178 @@
+/**
+ * Gateway 认证存储模块
+ * 负责管理 Token 和用户信息的内存存储与持久化
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { getLogger } from '@pocketclaw/shared';
+import { sessionManager } from '@/services/session';
+const logger = getLogger('authStore');
+// 认证数据存储文件路径（使用应用数据目录，支持 STORAGE_DIR 环境变量）
+const AUTH_STORAGE_DIR = process.env.STORAGE_DIR || path.join(os.homedir(), 'myclaw-gateway-storage');
+const AUTH_STORAGE_FILE = path.join(AUTH_STORAGE_DIR, 'auth', 'auth.json');
+// 内存中的认证数据
+let auth = null;
+// 确保存储目录存在
+function ensureStorageDir() {
+    const dir = path.dirname(AUTH_STORAGE_FILE);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+// 从本地文件加载认证数据
+function loadFromFile() {
+    try {
+        if (fs.existsSync(AUTH_STORAGE_FILE)) {
+            const data = fs.readFileSync(AUTH_STORAGE_FILE, 'utf-8');
+            const authData = JSON.parse(data);
+            // 检查 token 是否过期
+            if (authData.expiresAt && authData.expiresAt < Date.now()) {
+                logger.debug('Token expired, clearing...');
+                clearAuth();
+                return null;
+            }
+            logger.debug('Auth data loaded from file');
+            return authData;
+        }
+    }
+    catch (error) {
+        console.error('Failed to load auth from file:', error);
+    }
+    return null;
+}
+// 保存认证数据到本地文件
+function saveAuthToFile(authData) {
+    ensureStorageDir();
+    try {
+        fs.writeFileSync(AUTH_STORAGE_FILE, JSON.stringify(authData, null, 2), 'utf-8');
+        logger.debug('Auth data saved to file');
+    }
+    catch (error) {
+        console.error('Failed to save auth to file:', error);
+    }
+}
+// 清除本地认证文件
+function clearAuthFile() {
+    try {
+        if (fs.existsSync(AUTH_STORAGE_FILE)) {
+            fs.unlinkSync(AUTH_STORAGE_FILE);
+            logger.debug('Auth file cleared');
+        }
+    }
+    catch (error) {
+        console.error('Failed to clear auth file:', error);
+    }
+}
+// 清除认证数据
+function clearAuth() {
+    auth = null;
+    clearAuthFile();
+}
+/**
+ * 认证存储管理器
+ */
+export const authStore = {
+    /**
+     * 初始化：从本地加载认证数据到内存
+     * 应在 Gateway 启动时调用
+     */
+    load() {
+        auth = loadFromFile();
+        if (auth) {
+            logger.debug('Initialized with user:', auth.user.nickname);
+        }
+        else {
+            logger.debug('Initialized, no valid auth data');
+        }
+    },
+    /**
+     * 保存认证数据（内存 + 本地）
+     */
+    save(authData) {
+        auth = authData;
+        saveAuthToFile(authData);
+        // 用户登录后初始化 SessionManager
+        sessionManager.initialize();
+        logger.debug('Auth saved for user:', authData.user.nickname);
+    },
+    /**
+     * 获取当前认证数据
+     */
+    get() {
+        return auth;
+    },
+    /**
+     * 获取用户信息
+     */
+    getUser() {
+        return auth?.user || null;
+    },
+    /**
+     * 获取 Token（自动检查过期）
+     */
+    getToken() {
+        if (!auth) {
+            return null;
+        }
+        // 检查是否过期（预留 60 秒缓冲时间）
+        if (auth.expiresAt && auth.expiresAt < Date.now() + 60000) {
+            logger.debug('Token expired');
+            return null;
+        }
+        return auth.token;
+    },
+    /**
+     * 获取刷新 Token
+     */
+    getRefreshToken() {
+        return auth?.refreshToken || null;
+    },
+    /**
+     * 更新 Token
+     */
+    updateToken(token, expiresIn, refreshToken) {
+        if (auth) {
+            auth.token = token;
+            if (expiresIn) {
+                auth.expiresIn = expiresIn;
+                auth.expiresAt = Date.now() + expiresIn * 1000;
+            }
+            if (refreshToken) {
+                auth.refreshToken = refreshToken;
+            }
+            saveAuthToFile(auth);
+            logger.debug('Token updated');
+        }
+    },
+    /**
+     * 获取用户 ID
+     */
+    getUserId() {
+        return auth?.user?.id || null;
+    },
+    /**
+     * 是否已认证
+     */
+    isAuthenticated() {
+        return this.getToken() !== null;
+    },
+    /**
+     * 清除认证数据（内存 + 本地）
+     */
+    clear() {
+        clearAuth();
+        logger.debug('Auth cleared');
+    },
+    /**
+     * 更新用户信息
+     */
+    updateUser(userData) {
+        if (auth) {
+            auth.user = { ...auth.user, ...userData };
+            saveAuthToFile(auth);
+            logger.debug('User updated:', auth.user?.nickname || auth.user?.email);
+        }
+    },
+};
+export default authStore;

package/dist/stores/index.js

@@ -0,0 +1,6 @@
+/**
+ * Gateway Stores 统一导出
+ */
+export { memoryStore } from './memoryStore';
+export { persistStore } from './persistStore';
+export { authStore } from './authStore';

package/dist/stores/memoryStore.js

@@ -0,0 +1,191 @@
+/**
+ * Gateway 内存存储模块
+ * 用于缓存用户会话、API 响应等临时数据
+ */
+// 内存缓存
+const cache = new Map();
+// 默认过期时间（毫秒）
+const DEFAULT_TTL = 5 * 60 * 1000; // 5分钟
+// 用户会话缓存 TTL
+const SESSION_TTL = 30 * 60 * 1000; // 30分钟
+// API 响应缓存 TTL
+const API_CACHE_TTL = 2 * 60 * 1000; // 2分钟
+// 清理过期缓存（每分钟执行一次）
+setInterval(() => {
+    const now = Date.now();
+    cache.forEach((item, key) => {
+        if (item.expiresAt < now) {
+            cache.delete(key);
+        }
+    });
+}, 60 * 1000);
+/**
+ * 内存存储管理器
+ */
+export const memoryStore = {
+    /**
+     * 设置缓存
+     */
+    set(key, value, ttl = DEFAULT_TTL) {
+        const expiresAt = Date.now() + ttl;
+        cache.set(key, { value, expiresAt });
+    },
+    /**
+     * 获取缓存
+     */
+    get(key) {
+        const item = cache.get(key);
+        if (!item) {
+            return null;
+        }
+        if (Date.now() > item.expiresAt) {
+            cache.delete(key);
+            return null;
+        }
+        return item.value;
+    },
+    /**
+     * 删除缓存
+     */
+    delete(key) {
+        cache.delete(key);
+    },
+    /**
+     * 清空所有缓存
+     */
+    clear() {
+        cache.clear();
+    },
+    /**
+     * 检查键是否存在
+     */
+    has(key) {
+        const item = cache.get(key);
+        if (!item)
+            return false;
+        if (Date.now() > item.expiresAt) {
+            cache.delete(key);
+            return false;
+        }
+        return true;
+    },
+    // ==================== 用户会话相关 ====================
+    /**
+     * 缓存用户会话
+     */
+    setSession(userId, sessionData) {
+        this.set(`session:${userId}`, sessionData, SESSION_TTL);
+    },
+    /**
+     * 获取用户会话
+     */
+    getSession(userId) {
+        const key = `session:${userId}`;
+        const item = cache.get(key);
+        if (!item)
+            return null;
+        if (Date.now() > item.expiresAt) {
+            cache.delete(key);
+            return null;
+        }
+        return item.value;
+    },
+    /**
+     * 删除用户会话
+     */
+    deleteSession(userId) {
+        this.delete(`session:${userId}`);
+    },
+    // ==================== API 缓存相关 ====================
+    /**
+     * 缓存 API 响应
+     */
+    setApiCache(key, data) {
+        this.set(`api:${key}`, data, API_CACHE_TTL);
+    },
+    /**
+     * 获取 API 缓存
+     */
+    getApiCache(key) {
+        const item = cache.get(`api:${key}`);
+        if (!item)
+            return null;
+        if (Date.now() > item.expiresAt) {
+            cache.delete(`api:${key}`);
+            return null;
+        }
+        return item.value;
+    },
+    /**
+     * 清除用户相关的 API 缓存
+     */
+    clearUserApiCache(userId) {
+        // 清理用户相关的缓存
+        const keysToDelete = [];
+        cache.forEach((_, key) => {
+            if (key.startsWith(`user:${userId}:`) || key.startsWith(`skills:${userId}`)) {
+                keysToDelete.push(key);
+            }
+        });
+        keysToDelete.forEach(key => cache.delete(key));
+    },
+    // ==================== 技能相关缓存 ====================
+    /**
+     * 缓存技能列表
+     */
+    setSkillsCache(userId, skills) {
+        this.set(`skills:${userId}`, skills, API_CACHE_TTL);
+    },
+    /**
+     * 获取技能列表缓存
+     */
+    getSkillsCache(userId) {
+        const item = cache.get(`skills:${userId}`);
+        if (!item)
+            return null;
+        if (Date.now() > item.expiresAt) {
+            cache.delete(`skills:${userId}`);
+            return null;
+        }
+        return item.value;
+    },
+    /**
+     * 清除技能缓存
+     */
+    clearSkillsCache(userId) {
+        this.delete(`skills:${userId}`);
+    },
+    // ==================== 技能库缓存 ====================
+    /**
+     * 缓存技能库列表
+     */
+    setSkillHubCache(key, data) {
+        this.set(`skillhub:list:${key}`, data, API_CACHE_TTL);
+    },
+    /**
+     * 获取技能库列表缓存
+     */
+    getSkillHubCache(key) {
+        const item = cache.get(`skillhub:list:${key}`);
+        if (!item)
+            return null;
+        if (Date.now() > item.expiresAt) {
+            cache.delete(`skillhub:list:${key}`);
+            return null;
+        }
+        return item.value;
+    },
+    /**
+     * 清除技能库缓存
+     */
+    clearSkillHubCache() {
+        const keysToDelete = [];
+        cache.forEach((_, key) => {
+            if (key.startsWith('skillhub:')) {
+                keysToDelete.push(key);
+            }
+        });
+        keysToDelete.forEach(key => cache.delete(key));
+    }
+};
+export default memoryStore;

package/dist/stores/persistStore.js

@@ -0,0 +1,317 @@
+/**
+ * Gateway 持久化存储模块
+ * 用于存储配置、限流数据等需要持久化的数据
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('persistStore');
+// 存储文件路径（跨平台兼容）
+const STORAGE_DIR = process.env.STORAGE_DIR || path.join(os.homedir(), 'myclaw-gateway-storage');
+const STORAGE_FILE = path.join(STORAGE_DIR, 'persist.json');
+// 确保存储目录存在
+function ensureStorageDir() {
+    if (!fs.existsSync(STORAGE_DIR)) {
+        fs.mkdirSync(STORAGE_DIR, { recursive: true });
+    }
+}
+// 读取存储文件
+function readStorage() {
+    ensureStorageDir();
+    try {
+        logger.debug(`Reading storage from ${STORAGE_FILE}`);
+        if (fs.existsSync(STORAGE_FILE)) {
+            const data = fs.readFileSync(STORAGE_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    catch (error) {
+        logger.error(`Failed to read storage: ${error}`);
+    }
+    return {};
+}
+// 写入存储文件
+function writeStorage(data) {
+    ensureStorageDir();
+    try {
+        fs.writeFileSync(STORAGE_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (error) {
+        logger.error(`Failed to write storage: ${error}`);
+    }
+}
+/**
+ * 持久化存储管理器
+ */
+export const persistStore = {
+    /**
+     * 获取值
+     */
+    get(key, defaultValue) {
+        const storage = readStorage();
+        const value = storage[key];
+        return value !== undefined ? value : (defaultValue ?? null);
+    },
+    /**
+     * 设置值
+     */
+    set(key, value) {
+        const storage = readStorage();
+        storage[key] = value;
+        writeStorage(storage);
+    },
+    /**
+     * 删除值
+     */
+    delete(key) {
+        const storage = readStorage();
+        delete storage[key];
+        writeStorage(storage);
+    },
+    /**
+     * 清空所有数据
+     */
+    clear() {
+        writeStorage({});
+    },
+    /**
+     * 获取所有键
+     */
+    keys() {
+        return Object.keys(readStorage());
+    },
+    /**
+     * 检查键是否存在
+     */
+    has(key) {
+        const storage = readStorage();
+        return key in storage;
+    },
+    // ==================== 限流相关 ====================
+    /**
+     * 获取请求计数（用于限流）
+     */
+    getRateLimitCount(identifier, windowMs = 60000) {
+        const key = `ratelimit:${identifier}`;
+        const data = this.get(key);
+        if (!data || Date.now() > data.resetAt) {
+            // 窗口已过期，重置计数
+            const resetAt = Date.now() + windowMs;
+            this.set(key, { count: 1, resetAt });
+            return 1;
+        }
+        return data.count;
+    },
+    /**
+     * 增加请求计数
+     */
+    incrementRateLimit(identifier, windowMs = 60000) {
+        const key = `ratelimit:${identifier}`;
+        const data = this.get(key);
+        if (!data || Date.now() > data.resetAt) {
+            const resetAt = Date.now() + windowMs;
+            this.set(key, { count: 1, resetAt });
+            return 1;
+        }
+        const newCount = data.count + 1;
+        this.set(key, { count: newCount, resetAt: data.resetAt });
+        return newCount;
+    },
+    // ==================== 配置管理 ====================
+    /**
+     * 获取网关配置
+     */
+    getConfig(key, defaultValue) {
+        const value = this.get(`config:${key}`);
+        return (value ?? defaultValue);
+    },
+    /**
+     * 设置网关配置
+     */
+    setConfig(key, value) {
+        this.set(`config:${key}`, value);
+    },
+    // ==================== 服务健康状态 ====================
+    /**
+     * 获取服务健康状态
+     */
+    getServiceHealth(service) {
+        return this.get(`health:${service}`, {
+            healthy: true,
+            lastCheck: Date.now(),
+            failures: 0
+        });
+    },
+    /**
+     * 更新服务健康状态
+     */
+    setServiceHealth(service, healthy) {
+        const current = this.getServiceHealth(service);
+        const failures = healthy ? 0 : current.failures + 1;
+        this.set(`health:${service}`, {
+            healthy,
+            lastCheck: Date.now(),
+            failures
+        });
+    },
+    // ==================== 用户相关 ====================
+    /**
+     * 记录用户最后活跃时间
+     */
+    setUserLastActive(userId) {
+        this.set(`user:${userId}:lastActive`, Date.now());
+    },
+    /**
+     * 获取用户最后活跃时间
+     */
+    getUserLastActive(userId) {
+        const value = this.get(`user:${userId}:lastActive`);
+        return (value ?? 0);
+    },
+    // ==================== 模型 API Key 管理 ====================
+    /**
+     * 生成 API Key 存储 Key
+     * 格式: apikey:{modelId} (雪花ID已唯一)
+     */
+    _getApiKeyKey(modelId) {
+        return `apikey:${modelId}`;
+    },
+    /**
+     * 存储模型 API Key
+     * @param modelId 模型ID（雪花ID，唯一）
+     * @param apiKey API Key 值
+     */
+    setModelApiKey(modelId, apiKey) {
+        const key = this._getApiKeyKey(modelId);
+        this.set(key, {
+            apiKey,
+            updatedAt: Date.now()
+        });
+    },
+    /**
+     * 获取模型 API Key
+     * @param modelId 模型ID（雪花ID，唯一）
+     * @returns API Key 或 null
+     */
+    getModelApiKey(modelId) {
+        const key = this._getApiKeyKey(modelId);
+        const data = this.get(key);
+        logger.debug('PersistStore', `Getting API Key for modelId: ${modelId}, found: ${data ? 'yes' : 'no'}`);
+        return data?.apiKey ?? null;
+    },
+    /**
+     * 删除模型 API Key
+     * @param modelId 模型ID
+     */
+    deleteModelApiKey(modelId) {
+        const key = this._getApiKeyKey(modelId);
+        this.delete(key);
+    },
+    /**
+     * 检查模型 API Key 是否存在
+     * @param modelId 模型ID
+     */
+    hasModelApiKey(modelId) {
+        const key = this._getApiKeyKey(modelId);
+        return this.has(key);
+    },
+    // ==================== 技能 API Key 管理 ====================
+    /**
+     * 存储技能 API Key（本地存储，不上传服务端）
+     * @param skillId 技能ID（雪花ID，唯一）
+     * @param apiKey API Key 值
+     * @param apiBaseUrl 可选的 API Base URL
+     */
+    setSkillApiKey(skillId, apiKey) {
+        const key = `skill_apikey:${skillId}`;
+        this.set(key, {
+            apiKey,
+            updatedAt: Date.now()
+        });
+    },
+    /**
+     * 获取技能 API Key
+     * @param skillId 技能ID
+     * @returns API Key 配置或 null
+     */
+    getSkillApiKey(skillId) {
+        const key = `skill_apikey:${skillId}`;
+        const data = this.get(key);
+        return data ? { apiKey: data.apiKey } : null;
+    },
+    /**
+     * 删除技能 API Key
+     * @param skillId 技能ID
+     */
+    deleteSkillApiKey(skillId) {
+        const key = `skill_apikey:${skillId}`;
+        this.delete(key);
+    },
+    /**
+     * 检查技能 API Key 是否存在
+     * @param skillId 技能ID
+     */
+    hasSkillApiKey(skillId) {
+        const key = `skill_apikey:${skillId}`;
+        return this.has(key);
+    },
+    // ==================== 本地用户设置（不上传服务端） ====================
+    /**
+     * 获取本地用户设置
+     */
+    getLocalUserSetting(key, defaultValue) {
+        const settings = (this.get('localUserSetting', {}) || {});
+        return settings[key] ?? (defaultValue ?? null);
+    },
+    /**
+     * 设置本地用户设置
+     */
+    setLocalUserSetting(key, value) {
+        const settings = (this.get('localUserSetting', {}) || {});
+        settings[key] = value;
+        this.set('localUserSetting', settings);
+    },
+    /**
+     * 获取所有本地用户设置
+     */
+    getAllLocalUserSettings() {
+        return (this.get('localUserSetting', {}) || {});
+    },
+    /**
+     * 批量设置本地用户设置
+     */
+    setLocalUserSettings(settings) {
+        const current = (this.get('localUserSetting', {}) || {});
+        this.set('localUserSetting', { ...current, ...settings });
+    },
+    /**
+     * 删除本地用户设置
+     */
+    deleteLocalUserSetting(key) {
+        const settings = (this.get('localUserSetting', {}) || {});
+        delete settings[key];
+        this.set('localUserSetting', settings);
+    },
+    /**
+     * 清理不活跃用户（30天未活跃）
+     */
+    cleanupInactiveUsers() {
+        const storage = readStorage();
+        const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1000;
+        let cleaned = 0;
+        Object.keys(storage).forEach(key => {
+            if (key.startsWith('user:') && key.endsWith(':lastActive')) {
+                if (storage[key] < thirtyDaysAgo) {
+                    delete storage[key];
+                    cleaned++;
+                }
+            }
+        });
+        if (cleaned > 0) {
+            writeStorage(storage);
+        }
+        return cleaned;
+    }
+};
+export default persistStore;