@myassis/gateway 1.0.0

package/dist/services/TaskService.js

@@ -0,0 +1,240 @@
+/**
+ * Gateway 统一任务服务
+ *
+ * 根据 platformApply 路由任务到本地存储或服务器 API
+ *
+ * 路由规则：
+ * - platformApply === currentPlatform → 本地 SQLite 存储（localTaskService）
+ * - platformApply !== currentPlatform → 服务器 API（tasksApi）
+ */
+import { tasksApi } from '../api';
+import { localTaskService } from './LocalTaskService';
+import { getLogger } from '@pocketclaw/shared';
+import { getPlatform } from '@pocketclaw/shared/dist/utils/system.js';
+// 当前网关平台标识
+const CURRENT_PLATFORM = process.env.GATEWAY_PLATFORM || getPlatform();
+const logger = getLogger('TaskService');
+/**
+ * 判断任务是否应该存储在本地
+ */
+function isLocalTask(platformApply) {
+    // 默认保存到本地 SQLite
+    if (!platformApply)
+        return true;
+    if (platformApply === CURRENT_PLATFORM)
+        return true;
+    return false;
+}
+class TaskService {
+    /**
+     * 创建任务（自动路由）
+     */
+    async createTask(data) {
+        const isLocal = isLocalTask(data.platformApply);
+        logger.info('[TaskService] 创建任务', {
+            title: data.title,
+            platformApply: data.platformApply,
+            currentPlatform: CURRENT_PLATFORM,
+            route: isLocal ? 'local' : 'server',
+        });
+        if (isLocal) {
+            const task = localTaskService.createTask({
+                userId: data.userId,
+                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 { id: task.id, isLocal: true };
+        }
+        else {
+            const result = await tasksApi.create({
+                user_id: data.userId,
+                title: data.title,
+                description: data.description,
+                task_type: data.taskType,
+                recurrence_rule: data.recurrenceRule,
+                interval_value: data.intervalValue,
+                interval_unit: data.intervalUnit,
+                scheduled_at: typeof data.scheduledAt === 'object'
+                    ? new Date(data.scheduledAt).toISOString()
+                    : data.scheduledAt,
+                start_time: data.startTime
+                    ? (typeof data.startTime === 'object' ? new Date(data.startTime).toISOString() : data.startTime)
+                    : undefined,
+                end_time: data.endTime
+                    ? (typeof data.endTime === 'object' ? new Date(data.endTime).toISOString() : data.endTime)
+                    : undefined,
+                platform_apply: data.platformApply,
+            });
+            return { id: String(result.id || result), isLocal: false };
+        }
+    }
+    /**
+     * 获取任务（自动路由 - 先本地后服务器）
+     */
+    async getTask(taskId) {
+        const localTask = localTaskService.getTask(taskId);
+        if (localTask)
+            return localTask;
+        try {
+            const result = await tasksApi.get(taskId);
+            return this.transformServerTask(result);
+        }
+        catch (error) {
+            logger.warn('[TaskService] 获取服务器任务失败', { taskId, error });
+            return null;
+        }
+    }
+    /**
+     * 获取任务列表（合并本地和服务器）
+     */
+    async listTasks(params) {
+        const localResult = localTaskService.listTasks(params);
+        let serverTasks = [];
+        try {
+            const serverResult = await tasksApi.list({
+                status: params?.status,
+                page: params?.page ? String(params.page) : undefined,
+                pageSize: params?.pageSize ? String(params.pageSize) : undefined,
+            });
+            if (Array.isArray(serverResult)) {
+                serverTasks = serverResult.map(t => this.transformServerTask(t)).filter(Boolean);
+            }
+            else if (serverResult?.data && Array.isArray(serverResult.data)) {
+                serverTasks = serverResult.data.map(t => this.transformServerTask(t)).filter(Boolean);
+            }
+        }
+        catch (error) {
+            logger.warn('[TaskService] 获取服务器任务列表失败', { error });
+        }
+        const localIds = new Set(localResult.tasks.map(t => t.id));
+        const mergedTasks = [
+            ...localResult.tasks,
+            ...serverTasks.filter(t => !localIds.has(t.id)),
+        ];
+        mergedTasks.sort((a, b) => b.scheduledAt - a.scheduledAt);
+        return { tasks: mergedTasks, total: mergedTasks.length };
+    }
+    /**
+     * 更新任务（自动路由）
+     */
+    async updateTask(taskId, data) {
+        const localTask = localTaskService.getTask(taskId);
+        if (localTask) {
+            const result = localTaskService.updateTask(taskId, data);
+            return result !== null;
+        }
+        else {
+            try {
+                await tasksApi.update(taskId, {
+                    title: data.title,
+                    description: data.description,
+                    task_type: data.taskType,
+                    recurrence_rule: data.recurrenceRule,
+                    interval_value: data.intervalValue,
+                    interval_unit: data.intervalUnit,
+                    scheduled_at: data.scheduledAt
+                        ? (typeof data.scheduledAt === 'object' ? new Date(data.scheduledAt).toISOString() : data.scheduledAt)
+                        : undefined,
+                    start_time: data.startTime
+                        ? (typeof data.startTime === 'object' ? new Date(data.startTime).toISOString() : data.startTime)
+                        : undefined,
+                    end_time: data.endTime
+                        ? (typeof data.endTime === 'object' ? new Date(data.endTime).toISOString() : data.endTime)
+                        : undefined,
+                    status: data.status,
+                });
+                return true;
+            }
+            catch (error) {
+                logger.error('[TaskService] 更新服务器任务失败', { taskId, error });
+                return false;
+            }
+        }
+    }
+    /**
+     * 删除任务（自动路由）
+     */
+    async deleteTask(taskId) {
+        const localTask = localTaskService.getTask(taskId);
+        if (localTask) {
+            return localTaskService.deleteTask(taskId);
+        }
+        else {
+            try {
+                await tasksApi.delete(taskId);
+                return true;
+            }
+            catch (error) {
+                logger.error('[TaskService] 删除服务器任务失败', { taskId, error });
+                return false;
+            }
+        }
+    }
+    /**
+     * 更新任务状态
+     */
+    async updateTaskStatus(taskId, status) {
+        const localTask = localTaskService.getTask(taskId);
+        if (localTask) {
+            await localTaskService.updateTaskStatus(taskId, status);
+            return true;
+        }
+        else {
+            try {
+                await tasksApi.updateStatus(taskId, { status });
+                return true;
+            }
+            catch (error) {
+                logger.error('[TaskService] 更新服务器任务状态失败', { taskId, status, error });
+                return false;
+            }
+        }
+    }
+    /**
+     * 完成任务
+     */
+    async completeTask(taskId) {
+        return this.updateTaskStatus(taskId, 'completed');
+    }
+    /**
+     * 取消任务
+     */
+    async cancelTask(taskId) {
+        return this.updateTaskStatus(taskId, 'cancelled');
+    }
+    /**
+     * 转换服务器任务格式
+     */
+    transformServerTask(serverTask) {
+        if (!serverTask)
+            return null;
+        return {
+            id: String(serverTask.id || serverTask.task_id),
+            userId: String(serverTask.user_id || serverTask.userId),
+            title: serverTask.title || '',
+            description: serverTask.description,
+            taskType: serverTask.task_type || serverTask.taskType || 'one_time',
+            recurrenceRule: serverTask.recurrence_rule || serverTask.recurrenceRule,
+            intervalValue: serverTask.interval_value || serverTask.intervalValue,
+            intervalUnit: serverTask.interval_unit || serverTask.intervalUnit,
+            scheduledAt: new Date(serverTask.scheduled_at || serverTask.scheduledAt).getTime(),
+            startTime: serverTask.start_time ? new Date(serverTask.start_time).getTime() : undefined,
+            endTime: serverTask.end_time ? new Date(serverTask.end_time).getTime() : undefined,
+            status: serverTask.status || 'pending',
+            platformApply: serverTask.platform_apply || serverTask.platformApply,
+            pushToken: serverTask.push_token || serverTask.pushToken,
+            createdAt: new Date(serverTask.created_at || serverTask.createdAt).getTime(),
+            updatedAt: new Date(serverTask.updated_at || serverTask.updatedAt).getTime(),
+        };
+    }
+}
+export const taskService = new TaskService();

package/dist/services/WebSocketService.js

@@ -0,0 +1,236 @@
+/**
+ * WebSocket 服务
+ * 负责实时消息推送，使用 ws 库实现
+ */
+import { WebSocketServer, WebSocket } from 'ws';
+import { authStore } from '../stores/index.js';
+import { getLogger } from '@pocketclaw/shared';
+const logger = getLogger('WebSocketService');
+class WebSocketService {
+    wss = null;
+    clients = new Map();
+    heartbeatInterval = null;
+    /**
+     * 初始化 WebSocket 服务器，挂载到 HTTP Server 上
+     */
+    initialize(server) {
+        this.wss = new WebSocketServer({ server, path: '/ws' });
+        // 防止 WebSocketServer error 事件未监听导致进程崩溃（如 EADDRINUSE）
+        this.wss.on('error', (err) => {
+            logger.error('WebSocketServer error:', err);
+        });
+        this.wss.on('connection', (ws, req) => {
+            const clientKey = this.getClientKey(req);
+            if (!clientKey) {
+                logger.warn('连接无标识，断开');
+                ws.close(4001, 'Unauthorized');
+                return;
+            }
+            const userId = clientKey;
+            logger.info(`用户 ${userId} 已连接`);
+            const client = {
+                ws,
+                userId,
+                connectedAt: Date.now(),
+                isAlive: true,
+            };
+            // 如果同一用户已有连接，关闭旧连接
+            const existingClient = this.clients.get(userId);
+            if (existingClient && existingClient.ws.readyState === WebSocket.OPEN) {
+                existingClient.ws.close(4002, 'Replaced by new connection');
+            }
+            this.clients.set(userId, client);
+            // 心跳检测
+            ws.on('pong', () => {
+                if (this.clients.has(userId)) {
+                    this.clients.get(userId).isAlive = true;
+                }
+            });
+            // 接收消息
+            ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    this.handleMessage(userId, message);
+                }
+                catch {
+                    logger.warn(`用户 ${userId} 发送了无效消息`);
+                }
+            });
+            // 断开连接
+            ws.on('close', () => {
+                logger.info(`用户 ${userId} 已断开`);
+                this.clients.delete(userId);
+            });
+            ws.on('error', (error) => {
+                logger.error(`用户 ${userId} 连接错误:`, error);
+                this.clients.delete(userId);
+            });
+            // 发送连接成功消息
+            this.sendToUser(userId, {
+                type: 'connected',
+                payload: {
+                    userId,
+                    timestamp: Date.now(),
+                },
+            });
+        });
+        // 启动心跳检测
+        this.heartbeatInterval = setInterval(() => {
+            this.wss.clients.forEach((ws) => {
+                const client = Array.from(this.clients.values()).find(c => c.ws === ws);
+                if (!client)
+                    return;
+                if (!client.isAlive) {
+                    logger.info(`用户 ${client.userId} 心跳超时，断开`);
+                    this.clients.delete(client.userId);
+                    return ws.terminate();
+                }
+                client.isAlive = false;
+                ws.ping();
+            });
+        }, 30000);
+        logger.info('WebSocket 服务已启动，路径: /ws');
+    }
+    /**
+     * 从请求中提取用户标识
+     * Desktop 不存储 token，Gateway 直接信任连接并使用已登录用户的 ID
+     */
+    getClientKey(req) {
+        // 直接使用 authStore 中的用户 ID（Gateway 登录后的用户）
+        const userId = authStore.getUserId();
+        if (userId) {
+            return String(userId);
+        }
+        return null;
+    }
+    /**
+     * 处理客户端发来的消息
+     */
+    handleMessage(userId, message) {
+        switch (message.type) {
+            case 'ping':
+                this.sendToUser(userId, { type: 'pong', payload: { timestamp: Date.now() } });
+                break;
+            case 'subscribe':
+                logger.debug(`用户 ${userId} 订阅: ${message.payload?.channel || 'all'}`);
+                break;
+            default:
+                logger.debug(`收到用户 ${userId} 的消息: ${message.type}`);
+        }
+    }
+    /**
+     * 向指定用户发送消息
+     */
+    sendToUser(userId, message) {
+        const client = this.clients.get(String(userId));
+        if (!client || client.ws.readyState !== WebSocket.OPEN) {
+            return false;
+        }
+        try {
+            client.ws.send(JSON.stringify(message));
+            return true;
+        }
+        catch (error) {
+            logger.error(`发送消息给用户 ${userId} 失败:`, error);
+            return false;
+        }
+    }
+    /**
+     * 检查用户是否在线
+     */
+    isUserOnline(userId) {
+        const client = this.clients.get(String(userId));
+        return !!client && client.ws.readyState === WebSocket.OPEN;
+    }
+    /**
+     * 发送任务通知
+     */
+    sendTaskNotification(task) {
+        return this.sendToUser(String(task.userId), {
+            type: 'task_notification',
+            payload: {
+                id: task.id,
+                title: task.title,
+                description: task.description,
+                status: task.status,
+                scheduledAt: task.scheduledAt,
+            },
+        });
+    }
+    /**
+     * 发送任务触发通知给 Desktop（要求 Desktop 在当前会话执行任务）
+     * 返回 true 表示发送成功（Desktop 在线），false 表示 Desktop 不在线
+     */
+    sendTaskTrigger(task) {
+        return this.sendToUser(String(task.userId), {
+            type: 'task_trigger',
+            payload: {
+                id: task.id,
+                title: task.title,
+                description: task.description,
+                taskType: task.taskType,
+                scheduledAt: task.scheduledAt,
+            },
+        });
+    }
+    /**
+     * 发送更新提示给用户
+     * 无 nssm 时通过此方法推送到 Desktop，显示手动更新对话框
+     */
+    sendUpdateRequired(userId, message) {
+        return this.sendToUser(userId, {
+            type: 'update_required',
+            payload: {
+                message,
+                timestamp: Date.now(),
+            },
+        });
+    }
+    /**
+     * 广播消息给所有在线用户
+     */
+    broadcast(message) {
+        const data = JSON.stringify(message);
+        this.clients.forEach((client) => {
+            if (client.ws.readyState === WebSocket.OPEN) {
+                try {
+                    client.ws.send(data);
+                }
+                catch (error) {
+                    logger.error(`广播消息给用户 ${client.userId} 失败:`, error);
+                }
+            }
+        });
+    }
+    /**
+     * 获取在线用户数
+     */
+    getOnlineCount() {
+        return this.clients.size;
+    }
+    /**
+     * 获取在线用户列表
+     */
+    getOnlineUsers() {
+        return Array.from(this.clients.keys());
+    }
+    /**
+     * 关闭 WebSocket 服务器
+     */
+    shutdown() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        this.clients.forEach((client) => {
+            client.ws.close(1001, 'Server shutting down');
+        });
+        this.clients.clear();
+        if (this.wss) {
+            this.wss.close();
+            this.wss = null;
+        }
+        logger.info('WebSocket 服务已关闭');
+    }
+}
+export const webSocketService = new WebSocketService();

package/dist/services/agent/Agent.js

@@ -0,0 +1,120 @@
+import { v4 as uuidv4 } from 'uuid';
+import { sessionManager } from '../session/SessionManager';
+/**
+ * Agent - Business logic entity
+ * Represents an AI agent with independent system prompt and multiple sessions
+ */
+export class Agent {
+    id;
+    userId;
+    name;
+    description;
+    systemPrompt;
+    avatar;
+    config;
+    createdAt;
+    updatedAt;
+    isCurrent; // 是否是当前正在查看的 Agent
+    store;
+    constructor(data, store, agentManager) {
+        this.id = data.id;
+        this.userId = data.userId;
+        this.name = data.name;
+        this.description = data.description;
+        this.systemPrompt = data.systemPrompt;
+        this.avatar = data.avatar;
+        this.config = data.config;
+        this.createdAt = data.createdAt;
+        this.updatedAt = data.updatedAt;
+        this.isCurrent = data.isCurrent || false;
+        this.store = store;
+    }
+    /**
+     * Get all sessions under this agent
+     */
+    getSessions() {
+        const allSessions = sessionManager.getUserSessions();
+        return allSessions.filter(s => s.agentId === this.id);
+    }
+    /**
+     * Create new session under this agent
+     */
+    createSession(config = {}) {
+        const session = sessionManager.createSession({
+            id: config.id || uuidv4(),
+            title: config.title || '新会话',
+            selectModelId: config.selectModelId,
+            agentId: this.id, // Associate with this agent
+        });
+        return session;
+    }
+    /**
+     * Update session under this agent
+     */
+    updateSession(sessionId, data) {
+        const session = this.getSession(sessionId);
+        if (!session)
+            return null;
+        return sessionManager.updateSession(sessionId, data);
+    }
+    /**
+     * Delete session under this agent
+     */
+    deleteSession(sessionId) {
+        const session = this.getSession(sessionId);
+        if (!session)
+            return false;
+        return sessionManager.deleteSession(sessionId);
+    }
+    /**
+     * Get session under this agent
+     */
+    getSession(sessionId) {
+        const session = sessionManager.getSession(sessionId);
+        if (session && session.agentId === this.id) {
+            return session;
+        }
+        return null;
+    }
+    /**
+     * Update agent info
+     */
+    update(updates) {
+        if (updates.name !== undefined)
+            this.name = updates.name;
+        if (updates.description !== undefined)
+            this.description = updates.description;
+        if (updates.systemPrompt !== undefined)
+            this.systemPrompt = updates.systemPrompt;
+        if (updates.avatar !== undefined)
+            this.avatar = updates.avatar;
+        if (updates.config !== undefined)
+            this.config = updates.config;
+        this.updatedAt = Date.now();
+        this.save();
+    }
+    /**
+     * Save to database
+     */
+    save() {
+        const data = {
+            id: this.id,
+            userId: this.userId,
+            name: this.name,
+            description: this.description,
+            systemPrompt: this.systemPrompt,
+            avatar: this.avatar,
+            config: this.config,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            isCurrent: this.isCurrent,
+        };
+        this.store.update(data);
+    }
+    /**
+     * Delete agent (will cascade delete all sessions)
+     */
+    delete() {
+        this.store.delete(this.id);
+    }
+}