@myassis/gateway 1.0.0

package/dist/services/agent/AgentManager.js

@@ -0,0 +1,265 @@
+import { v4 as uuidv4 } from 'uuid';
+import { Agent } from './Agent';
+import { sessionManager } from '../session/SessionManager';
+import { authStore } from '@/stores/authStore';
+import { getLogger } from '@pocketclaw/shared';
+import appConfig from '@/config';
+const logger = getLogger('AgentManager');
+/**
+ * AgentManager - Business logic layer
+ * Manages multiple agents in memory
+ */
+export class AgentManager {
+    store;
+    agents = null;
+    initialized = false;
+    constructor(store) {
+        this.store = store;
+    }
+    /**
+     * Initialize - Load all agents from database on startup
+     */
+    initialize() {
+        if (this.initialized) {
+            logger.warn('Already initialized');
+            return;
+        }
+        const userId = this.getCurrentUserId();
+        if (!userId) {
+            logger.info('No user logged in, skipping initialization');
+            this.initialized = true;
+            return;
+        }
+        this.agents = new Map();
+        // Load all agents from database
+        const agentDataList = this.store.findByUserId(userId);
+        for (const agentData of agentDataList) {
+            const agent = new Agent(agentData, this.store, this);
+            this.agents.set(agent.id, agent);
+        }
+        // If no agents exist, create default "MyClaw" agent
+        if (this.agents.size === 0) {
+            logger.info('No agents found, creating default "MyClaw" agent');
+            this.createDefaultAgent(userId);
+        }
+        // Ensure exactly one agent has isCurrent=true
+        const hasCurrent = Array.from(this.agents.values()).some(a => a.isCurrent);
+        if (!hasCurrent) {
+            const first = Array.from(this.agents.values())[0];
+            if (first) {
+                first.isCurrent = true;
+                first.save();
+            }
+        }
+        this.initialized = true;
+        logger.info(`Initialized with ${this.agents.size} agents for user ${userId}`);
+    }
+    /**
+     * Get current user ID
+     */
+    getCurrentUserId() {
+        const user = authStore.getUser();
+        return user ? String(user.id) : null;
+    }
+    /**
+     * Create default "MyClaw" agent
+     */
+    createDefaultAgent(userId) {
+        const agentData = {
+            id: uuidv4(),
+            userId,
+            name: appConfig.appName,
+            description: '默认 AI 助手',
+            systemPrompt: undefined,
+            avatar: undefined,
+            config: undefined,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            isCurrent: true,
+        };
+        this.store.insert(agentData);
+        const agent = new Agent(agentData, this.store, this);
+        this.agents.set(agent.id, agent);
+        // Create default session
+        agent.createSession({ title: '新会话' });
+        logger.info(`Created default agent: ${agent.id}`);
+        return agent;
+    }
+    /**
+     * Get agent list summary
+     */
+    getAgentList() {
+        this.ensureInitialized();
+        const userId = this.getCurrentUserId();
+        if (!userId)
+            return [];
+        const agentDataList = this.store.findByUserId(userId);
+        return agentDataList.map(data => {
+            const sessions = sessionManager.getUserSessions();
+            const agentSessions = sessions
+                .filter(s => s.agentId === data.id)
+                .map(s => ({
+                id: s.id,
+                title: s.title,
+                createdAt: s.createdAt,
+                updatedAt: s.updatedAt,
+                isCurrent: s.isCurrent,
+                unreadCount: s.unreadCount
+            }));
+            return {
+                ...data,
+                sessionCount: agentSessions.length,
+                sessions: agentSessions,
+                unreadCount: agentSessions.reduce((sum, item) => sum + item.unreadCount, 0)
+            };
+        });
+    }
+    /**
+     * Get agent by ID
+     */
+    getAgent(agentId) {
+        this.ensureInitialized();
+        return this.agents.get(agentId) || null;
+    }
+    /**
+     * Create new agent
+     */
+    createAgent(config) {
+        const userId = this.getCurrentUserId();
+        if (!userId) {
+            throw new Error('No user logged in, cannot create agent');
+        }
+        // Check if name already exists
+        const existing = this.store.findByName(userId, config.name);
+        if (existing) {
+            throw new Error(`Agent with name "${config.name}" already exists`);
+        }
+        const agentData = {
+            id: uuidv4(),
+            userId,
+            name: config.name,
+            description: config.description,
+            systemPrompt: config.systemPrompt,
+            avatar: config.avatar,
+            config: config.config,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        this.store.insert(agentData);
+        const agent = new Agent(agentData, this.store, this);
+        this.agents.set(agent.id, agent);
+        // Create default session
+        agent.createSession({ title: '新会话' });
+        logger.info(`Created agent: ${agent.name} (${agent.id})`);
+        return agent;
+    }
+    /**
+     * Update agent
+     */
+    updateAgent(agentId, updates) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return null;
+        // Check name conflict
+        if (updates.name && updates.name !== agent.name) {
+            const userId = this.getCurrentUserId();
+            const existing = this.store.findByName(userId, updates.name);
+            if (existing && existing.id !== agentId) {
+                throw new Error(`Agent with name "${updates.name}" already exists`);
+            }
+        }
+        agent.update(updates);
+        return agent;
+    }
+    /**
+     * Delete agent
+     */
+    deleteAgent(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent)
+            return false;
+        // Cannot delete the last agent
+        if (this.agents.size <= 1) {
+            throw new Error('Cannot delete the last agent');
+        }
+        const wasCurrent = agent.isCurrent;
+        // Delete all sessions under this agent
+        const sessions = agent.getSessions();
+        for (const session of sessions) {
+            sessionManager.deleteSession(session.id);
+        }
+        // Delete agent
+        this.store.delete(agentId);
+        this.agents.delete(agentId);
+        // If deleted agent was current, set first remaining as current
+        if (wasCurrent && this.agents.size > 0) {
+            const first = Array.from(this.agents.values())[0];
+            if (first) {
+                first.isCurrent = true;
+                first.save();
+            }
+        }
+        logger.info(`Deleted agent: ${agentId}`);
+        return true;
+    }
+    /**
+     * Set current agent (when user views it)
+     */
+    setCurrentAgent(agentId) {
+        this.ensureInitialized();
+        // 清除旧当前 Agent 的 isCurrent 标记
+        const old = Array.from(this.agents.values()).find(a => a.isCurrent);
+        if (old) {
+            old.isCurrent = false;
+            old.save();
+        }
+        // 设置新当前 Agent
+        if (agentId) {
+            const next = this.agents.get(agentId);
+            if (next) {
+                next.isCurrent = true;
+                next.save();
+            }
+        }
+    }
+    /**
+     * Get current agent
+     */
+    getCurrentAgent() {
+        this.ensureInitialized();
+        return Array.from(this.agents.values()).find(a => a.isCurrent) || null;
+    }
+    /**
+     * Get sessions under an agent
+     */
+    getAgentSessions(agentId) {
+        const sessions = sessionManager.getUserSessions();
+        return sessions
+            .filter(s => s.agentId === agentId)
+            .map(s => ({
+            id: s.id,
+            title: s.title,
+            createdAt: s.createdAt,
+            updatedAt: s.updatedAt,
+        }));
+    }
+    /**
+     * Reload (for login switch)
+     */
+    reload() {
+        this.initialized = false;
+        this.agents = null;
+        this.initialize();
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            this.initialize();
+        }
+    }
+}
+// Export singleton
+export let agentManager;
+export function initAgentManager(store) {
+    agentManager = new AgentManager(store);
+    return agentManager;
+}

package/dist/services/agent/AgentStore.js

@@ -0,0 +1,73 @@
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('AgentStore');
+/**
+ * AgentStore - Data access layer
+ * Operates on SQLite database
+ */
+export class AgentStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initTable();
+    }
+    initTable() {
+        // Ensure agents table exists
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT,
+        system_prompt TEXT,
+        avatar TEXT,
+        config TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+        logger.info('Tables initialized');
+    }
+    // ========== Agent Operations ==========
+    insert(agent) {
+        this.db.prepare(`
+      INSERT INTO agents (id, user_id, name, description, system_prompt, avatar, config, created_at, updated_at, is_current)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(agent.id, agent.userId, agent.name, agent.description || null, agent.systemPrompt || null, agent.avatar || null, agent.config || null, agent.createdAt, agent.updatedAt, agent.isCurrent ? 1 : 0);
+    }
+    update(agent) {
+        this.db.prepare(`
+      UPDATE agents 
+      SET name = ?, description = ?, system_prompt = ?, avatar = ?, config = ?, updated_at = ?, is_current = ?
+      WHERE id = ?
+    `).run(agent.name, agent.description || null, agent.systemPrompt || null, agent.avatar || null, agent.config || null, agent.updatedAt, agent.isCurrent ? 1 : 0, agent.id);
+    }
+    delete(id) {
+        this.db.prepare('DELETE FROM agents WHERE id = ?').run(id);
+    }
+    findById(id) {
+        const row = this.db.prepare('SELECT * FROM agents WHERE id = ?').get(id);
+        return row ? this.rowToData(row) : null;
+    }
+    findByUserId(userId) {
+        const rows = this.db.prepare('SELECT * FROM agents WHERE user_id = ? ORDER BY updated_at DESC').all(userId);
+        return rows.map(row => this.rowToData(row));
+    }
+    findByName(userId, name) {
+        const row = this.db.prepare('SELECT * FROM agents WHERE user_id = ? AND name = ?').get(userId, name);
+        return row ? this.rowToData(row) : null;
+    }
+    rowToData(row) {
+        return {
+            id: row.id,
+            userId: row.user_id,
+            name: row.name,
+            description: row.description || undefined,
+            systemPrompt: row.system_prompt || undefined,
+            avatar: row.avatar || undefined,
+            config: row.config || undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            isCurrent: !!row.is_current,
+        };
+    }
+}

package/dist/services/dataService.js

@@ -0,0 +1,293 @@
+/**
+ * Gateway 数据服务层
+ * 直接转发服务端数据，不做二次包装
+ *
+ * 服务端路由结构：
+ * - /api/v1/auth/*    - 认证路由 (login, register, logout, me, profile, password, account)
+ * - /api/v1/data/*    - 用户数据路由 (models, skills, tasks, settings)
+ * - /api/v1/skill-hubs/* - 技能库路由
+ */
+import { authApi, skillsApi, skillHubApi, modelsApi, settingsApi } from '../api';
+import { authStore, memoryStore, persistStore } from '../stores';
+import { taskService } from './TaskService';
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('DataService');
+// ============ 认证服务 ============
+export const authService = {
+    // 登录
+    login: async (account, password, platform) => {
+        const response = await authApi.login({ account, password, platform });
+        if (response.success && response.data) {
+            const expiresIn = response.data.expiresIn || 86400;
+            authStore.save({
+                token: response.data.accessToken,
+                refreshToken: response.data.refreshToken,
+                expiresIn,
+                expiresAt: Date.now() + expiresIn * 1000,
+                user: response.data.user
+            });
+        }
+        return response;
+    },
+    // 注册
+    register: async (account, password, platform) => {
+        const response = await authApi.register({
+            account,
+            password,
+            nickname: account,
+            platform
+        });
+        if (response.success && response.data) {
+            const expiresIn = response.data.expiresIn || 86400;
+            authStore.save({
+                token: response.data.accessToken,
+                refreshToken: response.data.refreshToken,
+                expiresIn,
+                expiresAt: Date.now() + expiresIn * 1000,
+                user: response.data.user
+            });
+        }
+        return response;
+    },
+    // 登出
+    logout: async () => {
+        try {
+            await authApi.logout();
+        }
+        catch (e) {
+            // 忽略错误
+        }
+        authStore.clear();
+        return { success: true };
+    },
+    // 获取当前用户
+    me: () => authApi.me(),
+    // 更新资料
+    updateProfile: (data) => authApi.updateProfile(data),
+    // 修改密码
+    changePassword: (oldPassword, newPassword) => authApi.changePassword({ oldPassword, newPassword }),
+    // 删除账号
+    deleteAccount: (password) => authApi.deleteAccount({ password }),
+    // 获取认证状态
+    isAuthenticated: () => authStore.isAuthenticated(),
+    // 获取当前用户（从内存）
+    getUser: () => authStore.get()?.user || null,
+    // 获取 Token
+    getToken: () => authStore.getToken(),
+    // 刷新 Token
+    refresh: async (refreshToken) => {
+        const response = await authApi.refresh(refreshToken);
+        if (response.success && response.accessToken) {
+            authStore.updateToken(response.accessToken, response.refreshToken);
+        }
+        return response;
+    },
+    // 检查认证（供 Desktop 使用）
+    checkAuth: async () => {
+        const isAuth = authStore.isAuthenticated();
+        const user = authStore.get()?.user || null;
+        return { success: true, authenticated: isAuth, user };
+    }
+};
+// ============ 技能服务 (用户已安装的技能) ============
+export const skillsService = {
+    list: async () => await skillsApi.list(),
+    get: (skillId) => skillsApi.get(skillId),
+    install: async (skillHubId) => {
+        // 1. 从技能库获取技能详情
+        const hubResult = await skillHubApi.get(skillHubId);
+        if (!hubResult.success || !hubResult.data) {
+            return { success: false, error: '获取技能详情失败' };
+        }
+        const hub = hubResult.data;
+        // 2. 创建用户技能记录
+        const skillData = {
+            name: hub.name,
+            description: hub.description || '',
+            content: hub.content || '',
+            icon: hub.icon,
+            templateId: skillHubId,
+            isActive: true,
+            apiKeyRequired: hub.apiKeyRequired || false,
+        };
+        const response = await skillsApi.create(skillData);
+        if (response.success) {
+            // 3. 增加安装计数
+            await skillHubApi.install(skillHubId);
+        }
+        return response;
+    },
+    update: (skillId, data) => skillsApi.update(skillId, data),
+    uninstall: async (skillId) => await skillsApi.uninstall(skillId),
+    setApiKey: (skillId, apiKey) => {
+        persistStore.setSkillApiKey(skillId, apiKey);
+        return { success: true };
+    },
+    getApiKey: async (skillId) => {
+        const apikey = persistStore.getSkillApiKey(skillId);
+        if (!apikey) {
+            // 判断是否有内置 apikey
+            const skill = (await skillsService.get(skillId)).data;
+            if (skill.templateId) {
+                const skillHub = (await skillHubService.get(skill.templateId)).data;
+                if (skillHub?.builtinApikey) {
+                    persistStore.setSkillApiKey(skillId, skillHub.builtinApikey);
+                    return { success: true, apiKey: skillHub.builtinApikey };
+                }
+            }
+        }
+        return { success: true, apiKey: apikey?.apiKey };
+    },
+    rate: (skillId, score) => skillsApi.rate(skillId, { score }),
+    parse: (content) => skillsApi.parse({ content }),
+    create: async (data) => {
+        const response = await skillsApi.create(data);
+        if (response.success) {
+            // 创建成功后更新技能列表缓存
+            const listResponse = await skillsApi.list();
+            if (listResponse.success) {
+                memoryStore.set('skills', listResponse.data);
+            }
+        }
+        return response;
+    },
+};
+// ============ 技能库服务 (可安装的技能) ============
+export const skillHubService = {
+    list: (params) => skillHubApi.list(params),
+    get: (hubId) => skillHubApi.get(hubId),
+    categories: () => skillHubApi.categories(),
+    preinstalled: () => skillHubApi.preinstalled(),
+    user: () => skillHubApi.user(),
+    checkUsed: (hubId) => skillHubApi.checkUsed(hubId),
+    rate: (hubId, rating) => skillHubApi.rate(hubId, rating),
+    userRating: (hubId) => skillHubApi.userRating(hubId),
+    install: (hubId) => skillHubApi.install(hubId),
+    use: (hubId) => skillHubApi.use(hubId),
+};
+// ============ 模型服务 ============
+export const modelsService = {
+    list: () => modelsApi.list(),
+    get: (modelId) => modelsApi.get(modelId),
+    create: (data) => modelsApi.create(data),
+    update: (modelId, data) => modelsApi.update(modelId, data),
+    delete: (modelId) => modelsApi.delete(modelId),
+    setPrimary: (modelId) => modelsApi.setPrimary(modelId),
+};
+export const tasksService = {
+    list: async (params, userId) => {
+        const result = await taskService.listTasks({
+            status: params?.status,
+            userId,
+            page: params?.page ? parseInt(params.page) : undefined,
+            pageSize: params?.pageSize ? parseInt(params.pageSize) : undefined,
+        });
+        return { success: true, data: result.tasks, total: result.total };
+    },
+    get: async (taskId) => {
+        const task = await taskService.getTask(taskId);
+        if (!task)
+            return { success: false, error: 'Task not found' };
+        return { success: true, data: task };
+    },
+    create: async (data, userId) => {
+        const uid = userId || data?.userId || 'local';
+        try {
+            const result = await taskService.createTask({
+                userId: uid,
+                title: data.title,
+                description: data.description,
+                taskType: data.taskType,
+                recurrenceRule: data.recurrenceRule,
+                intervalValue: data.intervalValue,
+                intervalUnit: data.intervalUnit,
+                scheduledAt: data.scheduledAt,
+                startTime: data.startTime,
+                endTime: data.endTime,
+                platformApply: data.platformApply,
+                pushToken: data.pushToken,
+            });
+            return { success: true, data: { id: result.id, isLocal: result.isLocal } };
+        }
+        catch (error) {
+            logger.error('[tasksService] Create failed', { error });
+            return { success: false, error: error.message };
+        }
+    },
+    update: async (taskId, data) => {
+        try {
+            const result = await taskService.updateTask(taskId, {
+                title: data.title,
+                description: data.description,
+                taskType: data.taskType,
+                recurrenceRule: data.recurrenceRule,
+                intervalValue: data.intervalValue,
+                intervalUnit: data.intervalUnit,
+                scheduledAt: data.scheduledAt,
+                startTime: data.startTime,
+                endTime: data.endTime,
+                status: data.status,
+                platformApply: data.platformApply,
+                pushToken: data.pushToken,
+            });
+            return { success: result };
+        }
+        catch (error) {
+            logger.error('[tasksService] Update failed', { taskId, error });
+            return { success: false, error: error.message };
+        }
+    },
+    delete: async (taskId) => {
+        try {
+            const result = await taskService.deleteTask(taskId);
+            return { success: result };
+        }
+        catch (error) {
+            logger.error('[tasksService] Delete failed', { taskId, error });
+            return { success: false, error: error.message };
+        }
+    },
+    cancel: async (taskId) => {
+        try {
+            const result = await taskService.cancelTask(taskId);
+            return { success: result };
+        }
+        catch (error) {
+            logger.error('[tasksService] Cancel failed', { taskId, error });
+            return { success: false, error: error.message };
+        }
+    },
+    updateStatus: async (taskId, status) => {
+        try {
+            const result = await taskService.updateTaskStatus(taskId, status);
+            return { success: result };
+        }
+        catch (error) {
+            logger.error('[tasksService] UpdateStatus failed', { taskId, status, error });
+            return { success: false, error: error.message };
+        }
+    },
+};
+// ============ 设置服务 ============
+export const settingsService = {
+    get: async () => {
+        const settings = memoryStore.get('settings'); // 预热缓存
+        if (settings) {
+            return { success: true, data: settings };
+        }
+        else {
+            const response = await settingsApi.get();
+            if (response.success) {
+                memoryStore.set('settings', response.data); // 更新缓存
+            }
+            return response;
+        }
+    },
+    update: async (data) => {
+        const response = await settingsApi.update(data);
+        if (response.success) {
+            memoryStore.set('settings', response.data); // 更新缓存
+        }
+        return response;
+    },
+};

package/dist/services/index.js

@@ -0,0 +1,15 @@
+// Re-export all services from dataService
+export { authService, skillsService, skillHubService, modelsService, settingsService, } from './dataService';
+// Re-export tasksService from dataService (server-only tasks)
+export { tasksService } from './dataService';
+// Re-export session manager
+export { sessionManager } from './session';
+// Re-export task services
+export { taskSchedulerService } from './TaskSchedulerService';
+export { taskService } from './TaskService';
+export { localTaskService } from './LocalTaskService';
+// Re-export notification and holiday services
+export { notificationService } from './NotificationService';
+// Re-export task stores
+export { TaskStore } from './task/TaskStore';
+export { PushTokenStore } from './task/PushTokenStore';