@mcpcn/mcp-notification 1.0.3 → 1.0.4

package/dist/index.js

@@ -4,7 +4,60 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 const execAsync = promisify(exec);
+// ---- Global cancellation state (cross-process) ----
+const GLOBAL_STATE_DIR = path.join(os.homedir(), '.mcp', 'notification-mcp');
+const GLOBAL_CANCEL_FILE = path.join(GLOBAL_STATE_DIR, 'cancel.json');
+function ensureStateDir() {
+    try {
+        if (!fs.existsSync(GLOBAL_STATE_DIR)) {
+            fs.mkdirSync(GLOBAL_STATE_DIR, { recursive: true });
+        }
+    }
+    catch { }
+}
+function readCancelState() {
+    try {
+        const raw = fs.readFileSync(GLOBAL_CANCEL_FILE, 'utf8');
+        const data = JSON.parse(raw);
+        return {
+            stopAll: Boolean(data.stopAll),
+            canceledIds: Array.isArray(data.canceledIds) ? data.canceledIds : [],
+        };
+    }
+    catch {
+        return { stopAll: false, canceledIds: [] };
+    }
+}
+function writeCancelState(state) {
+    ensureStateDir();
+    fs.writeFileSync(GLOBAL_CANCEL_FILE, JSON.stringify(state), 'utf8');
+}
+function isGlobalStopAll() {
+    return Boolean(readCancelState().stopAll);
+}
+function isGloballyCanceled(id) {
+    const state = readCancelState();
+    return Boolean(state.stopAll) || (state.canceledIds || []).includes(id);
+}
+function setGlobalStopAll(flag) {
+    const state = readCancelState();
+    state.stopAll = flag;
+    writeCancelState(state);
+}
+function cancelTaskGlobally(id) {
+    const state = readCancelState();
+    const set = new Set(state.canceledIds || []);
+    set.add(id);
+    state.canceledIds = Array.from(set);
+    writeCancelState(state);
+}
+function clearGlobalCancel() {
+    writeCancelState({ stopAll: false, canceledIds: [] });
+}
 /**
  * Escapes special characters in strings for AppleScript
  */
@@ -97,6 +150,46 @@ function buildLinuxNotificationCommand(params) {
     }
     return command;
 }
+// 直接执行：macOS 通知
+async function executeMacNotification(params) {
+    const command = buildNotificationCommand(params);
+    await execAsync(command);
+}
+// 直接执行：Windows 通知
+async function executeWindowsNotification(params) {
+    const { title, message, sound = true } = params;
+    let script = `
+    Add-Type -AssemblyName System.Windows.Forms;
+    Add-Type -AssemblyName System.Drawing;
+    $notification = New-Object System.Windows.Forms.NotifyIcon;
+    $notification.Icon = [System.Drawing.SystemIcons]::Information;
+    $notification.BalloonTipTitle = "${escapeString(title)}";
+    $notification.BalloonTipText = "${escapeString(message)}";
+    $notification.Visible = $true;
+    $notification.ShowBalloonTip(5000);
+  `;
+    if (sound) {
+        script += `
+    [System.Media.SystemSounds]::Asterisk.Play();
+    `;
+    }
+    script += `
+    $sw = [Diagnostics.Stopwatch]::StartNew();
+    while ($sw.ElapsedMilliseconds -lt 6000) {
+      [System.Windows.Forms.Application]::DoEvents();
+      Start-Sleep -Milliseconds 100;
+    }
+    $notification.Dispose();
+  `;
+    const encoded = Buffer.from(script, 'utf16le').toString('base64');
+    const command = `powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encoded}`;
+    await execAsync(command);
+}
+// 直接执行：Linux 通知
+async function executeLinuxNotification(params) {
+    const command = buildLinuxNotificationCommand(params);
+    await execAsync(command);
+}
 /**
  * 解析时间字符串为毫秒数
  */
@@ -140,6 +233,12 @@ async function sendNotification(params) {
             }
             const timeoutId = setTimeout(async () => {
                 try {
+                    // 全局取消检查（支持重启后仍能停止）
+                    if (isGloballyCanceled(notificationId)) {
+                        // 从任务池中移除并停止
+                        repeatNotificationPool.delete(notificationId);
+                        return;
+                    }
                     // 检查任务是否还在任务池中（可能已被取消）
                     const notification = repeatNotificationPool.get(notificationId);
                     if (!notification)
@@ -147,13 +246,17 @@ async function sendNotification(params) {
                     await sendNotification(notificationParams);
                     // 更新任务信息
                     notification.currentCount++;
-                    // 调度下一次通知
-                    scheduleNextNotification(currentCount + 1);
+                    // 调度下一次通知（再次检查 stopAll）
+                    if (!isGlobalStopAll()) {
+                        scheduleNextNotification(currentCount + 1);
+                    }
                 }
                 catch (error) {
                     console.error('Repeated notification failed:', error);
                     // 即使失败也继续下一次
-                    scheduleNextNotification(currentCount + 1);
+                    if (!isGlobalStopAll()) {
+                        scheduleNextNotification(currentCount + 1);
+                    }
                 }
             }, repeatMs);
             // 更新任务池中的任务信息
@@ -181,6 +284,10 @@ async function sendNotification(params) {
             const delayMs = parseTimeDelay(params.delay);
             notification.timeoutId = setTimeout(() => {
                 // 发送第一次通知并开始重复
+                if (isGloballyCanceled(notificationId)) {
+                    repeatNotificationPool.delete(notificationId);
+                    return;
+                }
                 sendNotification(notificationParams).then(() => {
                     notification.currentCount = 1;
                     scheduleNextNotification(1);
@@ -193,6 +300,10 @@ async function sendNotification(params) {
         else {
             // 没有初始延迟，立即开始第一次通知
             try {
+                if (isGloballyCanceled(notificationId)) {
+                    repeatNotificationPool.delete(notificationId);
+                    return { message: 'Notification canceled before start' };
+                }
                 await sendNotification(notificationParams);
                 notification.currentCount = 1;
                 scheduleNextNotification(1);
@@ -214,9 +325,27 @@ async function sendNotification(params) {
             throw new Error('Delay must be a positive number');
         }
         try {
-            // 设置延迟任务
-            setTimeout(async () => {
+            // 生成任务ID，并加入任务池，便于后续管理/取消
+            const notificationId = generateNotificationId();
+            const record = {
+                id: notificationId,
+                params,
+                timeoutId: null,
+                currentCount: 0,
+                maxCount: 1,
+                startTime: Date.now(),
+            };
+            repeatNotificationPool.set(notificationId, record);
+            const timeoutId = setTimeout(async () => {
                 try {
+                    if (isGloballyCanceled(notificationId)) {
+                        repeatNotificationPool.delete(notificationId);
+                        return;
+                    }
+                    // 如果任务已被取消并从池中移除，则不再执行
+                    const exists = repeatNotificationPool.get(notificationId);
+                    if (!exists)
+                        return;
                     // 创建不包含 delay 的参数对象，避免无限递归
                     const { delay, ...notificationParams } = params;
                     await sendNotification(notificationParams);
@@ -224,9 +353,15 @@ async function sendNotification(params) {
                 catch (error) {
                     console.error('Delayed notification failed:', error);
                 }
+                finally {
+                    // 单次延迟任务执行完成后从任务池移除
+                    repeatNotificationPool.delete(notificationId);
+                }
             }, delayMs);
-            // 立即返回设置成功
-            return { message: 'Delayed notification scheduled successfully' };
+            // 回填 timeoutId
+            record.timeoutId = timeoutId;
+            // 返回任务ID，便于调用方管理
+            return { notificationId, message: 'Delayed notification scheduled successfully' };
         }
         catch (error) {
             throw new Error('Failed to schedule delayed notification');
@@ -236,21 +371,19 @@ async function sendNotification(params) {
     try {
         validateParams(params);
         const os = getOS();
-        let command;
         switch (os) {
             case 'macos':
-                command = buildNotificationCommand(params);
+                await executeMacNotification(params);
                 break;
             case 'windows':
-                command = buildWindowsNotificationCommand(params);
+                await executeWindowsNotification(params);
                 break;
             case 'linux':
-                command = buildLinuxNotificationCommand(params);
+                await executeLinuxNotification(params);
                 break;
             default:
                 throw new Error(`Unsupported platform: ${os}`);
         }
-        await execAsync(command);
         return { message: 'Notification sent successfully' };
     }
     catch (error) {
@@ -402,7 +535,7 @@ class NotificationServer {
                         properties: {
                             action: {
                                 type: 'string',
-                                enum: ['stop_repeat_task', 'stop_all_repeat_tasks', 'get_active_repeat_tasks', 'get_repeat_task_info'],
+                                enum: ['stop_repeat_task', 'stop_all_repeat_tasks', 'get_active_repeat_tasks', 'get_repeat_task_info', 'stop_all_repeat_tasks_globally', 'stop_repeat_task_globally', 'clear_global_state'],
                                 description: 'stop_repeat_task: 停止指定的重复通知或提醒任务. stop_all_repeat_tasks: 停止所有重复通知或提醒任务. get_active_repeat_tasks: 获取所有活跃的重复通知或提醒任务. get_repeat_task_info: 获取指定重复通知或提醒任务的信息.'
                             },
                             taskId: {
@@ -447,6 +580,7 @@ class NotificationServer {
                                         result.message,
                                 },
                             ],
+                            isError: false,
                         };
                     }
                     case 'notification_task_management': {
@@ -461,6 +595,7 @@ class NotificationServer {
                                             text: success ? `任务 ${taskId} 已成功停止` : `任务 ${taskId} 未找到`,
                                         },
                                     ],
+                                    isError: false,
                                 };
                             }
                             case 'stop_all_repeat_tasks': {
@@ -472,8 +607,33 @@ class NotificationServer {
                                             text: `已停止 ${count} 个重复任务`,
                                         },
                                     ],
+                                    isError: false,
+                                };
+                            }
+                            case 'stop_repeat_task_globally': {
+                                if (typeof taskId !== 'string') {
+                                    throw new McpError(ErrorCode.InvalidParams, 'taskId is required for stop_repeat_task_globally');
+                                }
+                                cancelTaskGlobally(taskId);
+                                // 也尝试本进程内停止
+                                const success = stopRepeatNotification(taskId);
+                                return {
+                                    content: [{ type: 'text', text: `已全局标记停止任务 ${taskId}` + (success ? '（并停止本进程任务）' : '') }],
+                                    isError: false,
                                 };
                             }
+                            case 'stop_all_repeat_tasks_globally': {
+                                setGlobalStopAll(true);
+                                const count = stopAllRepeatNotifications();
+                                return {
+                                    content: [{ type: 'text', text: `已全局标记停止所有重复任务，并停止本进程内 ${count} 个任务` }],
+                                    isError: false,
+                                };
+                            }
+                            case 'clear_global_state': {
+                                clearGlobalCancel();
+                                return { content: [{ type: 'text', text: '已清除全局停止状态' }], isError: false };
+                            }
                             case 'get_active_repeat_tasks': {
                                 const tasks = getActiveRepeatNotifications();
                                 return {
@@ -483,6 +643,7 @@ class NotificationServer {
                                             text: JSON.stringify(tasks, null, 2),
                                         },
                                     ],
+                                    isError: false,
                                 };
                             }
                             case 'get_repeat_task_info': {
@@ -494,6 +655,7 @@ class NotificationServer {
                                             text: info ? JSON.stringify(info, null, 2) : `任务 ${taskId} 未找到`,
                                         },
                                     ],
+                                    isError: false,
                                 };
                             }
                             default:
@@ -505,7 +667,11 @@ class NotificationServer {
                 }
             }
             catch (error) {
-                throw error;
+                const message = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{ type: 'text', text: `Error: ${message}` }],
+                    isError: true,
+                };
             }
         });
     }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@mcpcn/mcp-notification",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "系统通知MCP服务器",
-  "packageManager": "pnpm@8.12.1",
+  "packageManager": "yarn@1.22.22",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -24,8 +24,8 @@
     "build": "tsc && chmod +x dist/index.js",
     "start": "node dist/index.js",
     "dev": "tsc -w",
-    "clean": "rm -rf build",
-    "prepare": "pnpm clean && pnpm build"
+    "clean": "rm -rf dist",
+    "prepare": "npm run clean && npm run build"
   },
   "type": "module",
   "license": "MIT",