@myassis/gateway 1.0.0

package/dist/services/ServiceManager.js

@@ -0,0 +1,348 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import fs from 'fs';
+import axios from 'axios';
+import { fileURLToPath } from 'url';
+const execAsync = promisify(exec);
+export const SERVICE_NAME = 'myclaw-gateway';
+export const SERVICE_DISPLAY_NAME = 'MyClaw Desktop Gateway Service';
+// ─── 平台无关工具 ────────────────────────────────────────────
+function getServiceScript() {
+    // pkg 环境
+    const execDir = path.dirname(process.execPath);
+    const pkgScript = path.join(execDir, 'gateway', 'dist', 'index.js');
+    if (fs.existsSync(pkgScript))
+        return pkgScript;
+    // 开发模式
+    const devScript = path.join(process.cwd(), 'dist', 'index.js');
+    if (fs.existsSync(devScript))
+        return devScript;
+    return pkgScript;
+}
+function getNodeExec() {
+    return process.execPath;
+}
+// ─── Windows 实现 ───────────────────────────────────────────
+async function queryServiceWindows() {
+    try {
+        const { stdout } = await execAsync(`sc query ${SERVICE_NAME}`, { timeout: 5000 });
+        return { installed: true, running: stdout.includes('RUNNING') };
+    }
+    catch {
+        return { installed: false, running: false };
+    }
+}
+async function installWindows() {
+    const script = getServiceScript();
+    const workDir = path.dirname(script);
+    const nodeExe = getNodeExec();
+    const { installed } = await queryServiceWindows();
+    if (installed)
+        await stopService();
+    const nssmPath = path.join(path.dirname(process.execPath), 'nssm.exe');
+    const useNssm = fs.existsSync(nssmPath);
+    try {
+        if (useNssm) {
+            await execAsync(`"${nssmPath}" install ${SERVICE_NAME} "${nodeExe}" "${script}"`, { timeout: 15000, cwd: workDir });
+            await execAsync(`"${nssmPath}" set ${SERVICE_NAME} AppDirectory "${workDir}"`, { timeout: 10000 });
+            await execAsync(`"${nssmPath}" set ${SERVICE_NAME} DisplayName "${SERVICE_DISPLAY_NAME}"`, { timeout: 10000 });
+            await execAsync(`"${nssmPath}" set ${SERVICE_NAME} Start SERVICE_AUTO_START`, { timeout: 10000 });
+        }
+        else {
+            await execAsync(`sc create ${SERVICE_NAME} binPath= "\\"${nodeExe}\\" \\"${script}\\"" DisplayName= "${SERVICE_DISPLAY_NAME}" start= auto`, { timeout: 15000 });
+        }
+        await startService();
+        return { success: true, message: '服务安装并启动成功' };
+    }
+    catch (err) {
+        return { success: false, message: `安装失败: ${err.message}` };
+    }
+}
+async function uninstallWindows() {
+    try {
+        await stopService();
+        const nssmPath = path.join(path.dirname(process.execPath), 'nssm.exe');
+        if (fs.existsSync(nssmPath)) {
+            await execAsync(`"${nssmPath}" remove ${SERVICE_NAME} confirm`, { timeout: 10000 });
+        }
+        else {
+            await execAsync(`sc delete ${SERVICE_NAME}`, { timeout: 10000 });
+        }
+        return { success: true, message: '服务卸载成功' };
+    }
+    catch (err) {
+        return { success: false, message: `卸载失败: ${err.message}` };
+    }
+}
+async function startServiceWindows() {
+    try {
+        await execAsync(`sc start ${SERVICE_NAME}`, { timeout: 10000 });
+        return { success: true, message: '服务启动成功' };
+    }
+    catch (err) {
+        return { success: false, message: `启动失败: ${err.message}` };
+    }
+}
+async function restartServiceWindows() {
+    const nssmPath = path.join(path.dirname(process.execPath), 'nssm.exe');
+    // 无 nssm 时需要用户手动更新
+    if (!fs.existsSync(nssmPath)) {
+        const info = await getServiceInfo();
+        if (info.installed) {
+            return {
+                success: false,
+                message: '检测到您尚未安装 nssm，无法自动重启服务。请手动执行以下步骤更新 Gateway：\n' +
+                    '1. 在桌面上停止 Gateway 服务（系统托盘 → 右键 → 退出）\n' +
+                    '2. 运行 `npm install -g @myclaw/gateway@latest`\n' +
+                    '3. 重新启动 Gateway 服务\n\n' +
+                    '如需自动重启功能，请从 https://nssm.cc/download 下载 nssm 并放置到 Gateway 同目录下',
+            };
+        }
+        // 服务未安装时，可直接更新
+    }
+    try {
+        await execAsync(`"${nssmPath}" restart ${SERVICE_NAME}`, { timeout: 15000 });
+        return { success: true, message: '服务重启成功' };
+    }
+    catch (err) {
+        return { success: false, message: `重启失败: ${err.message}` };
+    }
+}
+async function stopServiceWindows() {
+    try {
+        await execAsync(`sc stop ${SERVICE_NAME}`, { timeout: 10000 });
+        return { success: true, message: '服务停止成功' };
+    }
+    catch (err) {
+        return { success: false, message: `停止失败: ${err.message}` };
+    }
+}
+// ─── Linux / macOS 实现 ─────────────────────────────────────
+async function queryServiceLinux() {
+    try {
+        const { stdout } = await execAsync(`systemctl is-active ${SERVICE_NAME}`, { timeout: 5000 });
+        const running = stdout.trim() === 'active';
+        return { installed: true, running };
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 4)
+            return { installed: false, running: false };
+        const msg = err.stdout?.toString() || '';
+        if (msg.trim() === 'inactive' || msg.trim() === 'failed') {
+            return { installed: true, running: false };
+        }
+        return { installed: false, running: false };
+    }
+}
+async function installLinux() {
+    const script = getServiceScript();
+    const workDir = path.dirname(script);
+    const nodeExe = getNodeExec();
+    try {
+        const { installed } = await queryServiceLinux();
+        if (installed)
+            await stopService();
+        const unitContent = `[Unit]
+Description=${SERVICE_DISPLAY_NAME}
+After=network.target
+
+[Service]
+Type=simple
+User=${process.env.USER || 'root'}
+WorkingDirectory=${workDir}
+ExecStart=${nodeExe} ${script}
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
+`;
+        await fs.promises.writeFile('/tmp/myclaw-gateway.service', unitContent, 'utf8');
+        await execAsync('cp /tmp/myclaw-gateway.service /etc/systemd/system/myclaw-gateway.service', { timeout: 10000 });
+        await execAsync('systemctl daemon-reload', { timeout: 10000 });
+        await execAsync('systemctl enable myclaw-gateway', { timeout: 10000 });
+        await execAsync('systemctl start myclaw-gateway', { timeout: 10000 });
+        return { success: true, message: '服务安装并启动成功' };
+    }
+    catch (err) {
+        return { success: false, message: `安装失败: ${err.message}` };
+    }
+}
+async function uninstallLinux() {
+    try {
+        await execAsync('systemctl stop myclaw-gateway', { timeout: 10000 });
+        await execAsync('systemctl disable myclaw-gateway', { timeout: 10000 });
+        await execAsync('rm -f /etc/systemd/system/myclaw-gateway.service', { timeout: 10000 });
+        await execAsync('systemctl daemon-reload', { timeout: 10000 });
+        return { success: true, message: '服务卸载成功' };
+    }
+    catch (err) {
+        return { success: false, message: `卸载失败: ${err.message}` };
+    }
+}
+async function startServiceLinux() {
+    try {
+        await execAsync(`systemctl start ${SERVICE_NAME}`, { timeout: 10000 });
+        return { success: true, message: '服务启动成功' };
+    }
+    catch (err) {
+        return { success: false, message: `启动失败: ${err.message}` };
+    }
+}
+async function restartServiceLinux() {
+    try {
+        await execAsync(`systemctl restart ${SERVICE_NAME}`, { timeout: 15000 });
+        return { success: true, message: '服务重启成功' };
+    }
+    catch (err) {
+        return { success: false, message: `重启失败: ${err.message}` };
+    }
+}
+async function stopServiceLinux() {
+    try {
+        await execAsync(`systemctl stop ${SERVICE_NAME}`, { timeout: 10000 });
+        return { success: true, message: '服务停止成功' };
+    }
+    catch (err) {
+        return { success: false, message: `停止失败: ${err.message}` };
+    }
+}
+// ─── 平台分发 ───────────────────────────────────────────────
+export async function getServiceInfo() {
+    const platform = process.platform;
+    let installed = false;
+    let running = false;
+    if (platform === 'win32') {
+        const r = await queryServiceWindows();
+        installed = r.installed;
+        running = r.running;
+    }
+    else if (platform === 'linux' || platform === 'darwin') {
+        const r = await queryServiceLinux();
+        installed = r.installed;
+        running = r.running;
+    }
+    return {
+        installed,
+        running,
+        displayName: SERVICE_DISPLAY_NAME,
+        canManage: platform === 'win32' || platform === 'linux',
+        platform,
+    };
+}
+export async function installService() {
+    const platform = process.platform;
+    if (platform === 'win32')
+        return installWindows();
+    if (platform === 'linux')
+        return installLinux();
+    return { success: false, message: `当前平台 ${platform} 不支持自动安装服务` };
+}
+export async function uninstallService() {
+    const platform = process.platform;
+    if (platform === 'win32')
+        return uninstallWindows();
+    if (platform === 'linux')
+        return uninstallLinux();
+    return { success: false, message: `当前平台 ${platform} 不支持自动卸载服务` };
+}
+export async function startService() {
+    const platform = process.platform;
+    if (platform === 'win32')
+        return startServiceWindows();
+    if (platform === 'linux')
+        return startServiceLinux();
+    return { success: false, message: `当前平台 ${platform} 不支持自动启动服务` };
+}
+export async function stopService() {
+    const platform = process.platform;
+    if (platform === 'win32')
+        return stopServiceWindows();
+    if (platform === 'linux')
+        return stopServiceLinux();
+    return { success: false, message: `当前平台 ${platform} 不支持自动停止服务` };
+}
+export async function restartService() {
+    const platform = process.platform;
+    if (platform === 'win32')
+        return restartServiceWindows();
+    if (platform === 'linux')
+        return restartServiceLinux();
+    return { success: false, message: `当前平台 ${platform} 不支持自动重启服务` };
+}
+// ─── 版本更新 ─────────────────────────────────────────
+function getPackageVersion() {
+    try {
+        const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.join(scriptDir, '..', '..', 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            return pkg.version || '0.0.0';
+        }
+    }
+    catch {
+        // ignore
+    }
+    return '0.0.0';
+}
+function compareVersions(a, b) {
+    const pa = (a || '0.0.0').split('.').map(Number);
+    const pb = (b || '0.0.0').split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const va = pa[i] || 0;
+        const vb = pb[i] || 0;
+        if (va < vb)
+            return -1;
+        if (va > vb)
+            return 1;
+    }
+    return 0;
+}
+export async function checkForUpdates() {
+    try {
+        const currentVersion = getPackageVersion();
+        const response = await axios.get('https://registry.npmjs.org/@myclaw/gateway/latest', { timeout: 10000 });
+        const latestVersion = response.data.version;
+        if (!latestVersion) {
+            return { hasUpdate: false, currentVersion, latestVersion: currentVersion, error: '无法获取最新版本' };
+        }
+        const hasUpdate = compareVersions(currentVersion, latestVersion) < 0;
+        return { hasUpdate, currentVersion, latestVersion };
+    }
+    catch (err) {
+        return { hasUpdate: false, currentVersion: '0.0.0', latestVersion: '0.0.0', error: err.message };
+    }
+}
+export async function updateService() {
+    try {
+        const check = await checkForUpdates();
+        if (check.error) {
+            return { success: false, message: `检查更新失败: ${check.error}` };
+        }
+        if (!check.hasUpdate) {
+            return { success: true, message: `已是最新版本 ${check.currentVersion}` };
+        }
+        console.log(`发现新版本 ${check.latestVersion}，正在更新...`);
+        const { stdout, stderr } = await execAsync('npm install -g @myclaw/gateway@latest', { timeout: 120000 });
+        if (stdout)
+            console.log(stdout);
+        if (stderr)
+            console.error(stderr);
+        console.log('✅ npm 更新完成');
+        const info = await getServiceInfo();
+        if (info.installed) {
+            console.log('正在重启服务...');
+            const r = await restartService();
+            if (!r.success) {
+                return { success: false, message: `更新成功但服务重启失败: ${r.message}` };
+            }
+        }
+        return { success: true, message: `更新成功: ${check.currentVersion} → ${check.latestVersion}` };
+    }
+    catch (err) {
+        return { success: false, message: `更新失败: ${err.message}` };
+    }
+}

package/dist/services/TaskSchedulerService.js

@@ -0,0 +1,195 @@
+/**
+ * Gateway 任务调度服务
+ * 基于 SQLite 数据库的任务调度
+ * 每分钟检查待执行任务并发送通知
+ */
+import { taskStore } from './task/TaskStore';
+import { webSocketService } from './WebSocketService';
+import { sessionManager } from './session';
+import { getLogger, getUTCTimeKey, formatUTCForLog, holidayService } from '@pocketclaw/shared';
+import { tasksService } from './dataService';
+const logger = getLogger('TaskSchedulerService');
+const EXPIRED_THRESHOLD = 60 * 60 * 1000; // 1小时
+const CHECK_INTERVAL = 60 * 1000; // 1分钟
+class TaskSchedulerService {
+    intervalId = null;
+    initialized = false;
+    constructor() {
+    }
+    /**
+     * 初始化 - 启动调度器
+     */
+    start() {
+        if (this.initialized) {
+            logger.warn('Already initialized');
+            return;
+        }
+        logger.info('Starting Task Scheduler Service...');
+        // 预加载节假日数据
+        this.preloadHolidayData();
+        // 立即执行一次检查
+        this.processCurrentMinuteTasks();
+        this.processCurrentMinuteExpiredTasks();
+        // 每分钟检查任务
+        this.intervalId = setInterval(() => {
+            this.processCurrentMinuteTasks();
+            this.processCurrentMinuteExpiredTasks();
+        }, CHECK_INTERVAL);
+        this.initialized = true;
+        logger.info('Task Scheduler Service started');
+    }
+    /**
+     * 停止调度器
+     */
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+            this.initialized = false;
+            logger.info('Task Scheduler Service stopped');
+        }
+    }
+    /**
+     * 预加载节假日数据
+     */
+    async preloadHolidayData() {
+        try {
+            await holidayService.preloadYears([new Date().getFullYear()]);
+            logger.info('Holiday data preloaded');
+        }
+        catch (error) {
+            logger.error('Failed to preload holiday data:', error);
+        }
+    }
+    async processCurrentMinuteExpiredTasks() {
+        try {
+            const now = Date.now();
+            const nowBeforeHour = now - EXPIRED_THRESHOLD;
+            const response = await tasksService.list();
+            if (!response.success) {
+                logger.error('获取任务失败');
+                return;
+            }
+            // 获取过期待执行任务
+            const tasks = response.data.filter(x => x.scheduledAt < nowBeforeHour && x.status !== 'completed' && x.status !== 'expired' && x.status !== 'error');
+            if (tasks.length > 0) {
+                for (let task of tasks) {
+                    await tasksService.updateStatus(task.id, 'expired');
+                }
+            }
+        }
+        catch (error) {
+            logger.error(error);
+        }
+    }
+    /**
+     * 处理当前分钟的任务
+     */
+    async processCurrentMinuteTasks() {
+        try {
+            const now = Date.now();
+            const nowBeforeHour = now - EXPIRED_THRESHOLD;
+            const timeKey = getUTCTimeKey(new Date());
+            const response = await tasksService.list();
+            if (!response.success) {
+                logger.error('获取任务失败');
+                return;
+            }
+            // 获取待执行任务
+            const tasks = response.data.filter(x => x.scheduledAt >= nowBeforeHour && x.scheduledAt <= now && x.status === 'pending');
+            if (tasks.length > 0) {
+                logger.info(`Found ${tasks.length} tasks to execute at ${timeKey}`);
+                for (const task of tasks) {
+                    await this.executeTask(task);
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Error processing tasks:', error);
+        }
+    }
+    /**
+     * 执行任务
+     */
+    async executeTask(task) {
+        try {
+            // 更新任务状态为 notifying
+            taskStore.updateStatus(task.id, 'notifying');
+            logger.info(`Executing task: ${task.title}`, {
+                taskId: task.id,
+                scheduledAt: formatUTCForLog(task.scheduledAt),
+            });
+            // 优先通过 WebSocket 通知 Desktop 在线执行任务
+            const wsSent = webSocketService.sendTaskTrigger({
+                id: task.id,
+                title: task.title,
+                description: task.description,
+                taskType: task.taskType,
+                scheduledAt: task.scheduledAt,
+                userId: task.userId,
+            });
+            if (wsSent) {
+                // Desktop 在线，由 Desktop 端播放铃声并执行任务
+                logger.info(`Task ${task.title}: WebSocket notification sent to Desktop`);
+                await tasksService.updateStatus(task.id, 'notifying');
+            }
+            else {
+                // Desktop 不在线，Gateway 本地直接执行任务
+                logger.info(`Task ${task.title}: No WebSocket, executing locally`);
+                await tasksService.updateStatus(task.id, 'running');
+                await this.executeTaskLocally(task);
+                await tasksService.updateStatus(task.id, 'completed');
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to execute task ${task.id}:`, error);
+            taskStore.updateStatus(task.id, 'failed');
+        }
+    }
+    /**
+     * Gateway 本地执行任务（Desktop 不在线时）
+     * 选取 isCurrent=true 的 Session，通过 streamChat 发送给大模型
+     */
+    async executeTaskLocally(task) {
+        try {
+            const currentSession = sessionManager.getCurrentSession();
+            if (!currentSession) {
+                logger.warn(`No current session found, cannot execute task: ${task.title}`);
+                return;
+            }
+            const taskContent = task.description || task.title;
+            const userMessageId = `task-user-${task.id}`;
+            const assistantMessageId = `task-assistant-${task.id}`;
+            logger.info(`Executing task locally in session ${currentSession.id}:${currentSession.title}: ${task.title}`);
+            // res=null 表示本地执行，不需要 SSE 响应
+            await currentSession.streamChat(taskContent, [], null, userMessageId, assistantMessageId);
+            logger.info(`Local task execution completed: ${task.title}`);
+        }
+        catch (error) {
+            logger.error(`Local task execution failed for ${task.title}:`, error);
+        }
+    }
+    /**
+     * 获取调度器状态
+     */
+    getStatus() {
+        const pendingCount = taskStore.findByStatus('pending').length;
+        const notifyingCount = taskStore.findByStatus('notifying').length;
+        const completedCount = taskStore.findByStatus('completed').length;
+        const failedCount = taskStore.findByStatus('failed').length;
+        const expiredCount = taskStore.findByStatus('expired').length;
+        return {
+            initialized: this.initialized,
+            running: this.intervalId !== null,
+            checkInterval: CHECK_INTERVAL,
+            totalTasks: taskStore.count(),
+            pendingTasks: pendingCount,
+            notifyingTasks: notifyingCount,
+            completedTasks: completedCount,
+            failedTasks: failedCount,
+            expiredTasks: expiredCount,
+            nextCheck: formatUTCForLog(Date.now() + CHECK_INTERVAL),
+        };
+    }
+}
+export const taskSchedulerService = new TaskSchedulerService();