@mcpcn/mcp-notification 1.0.3 → 1.0.5

package/README.md

@@ -1,67 +1,167 @@
-# 通知MCP服务器
-
-跨平台系统通知MCP服务器，支持macOS、Windows和Linux系统。
-
-## 功能特性
-
-- 📢 发送系统通知
-- ⏰ 延迟发送
-- 🔄 重复通知
-- 🎵 声音支持
-- 🖥️ 跨平台支持（macOS、Windows、Linux）
-
-## 工具
-
-### send_notification
-发送系统通知
-
-**参数：**
-- `title` (必需): 通知标题
-- `message` (必需): 通知内容
-- `subtitle` (可选): 副标题
-- `sound` (可选): 是否播放声音（默认true）
-- `delay` (可选): 延迟发送（毫秒或"10s", "1m", "1h"格式）
-- `repeat` (可选): 重复间隔（毫秒或时间字符串）
-- `repeatCount` (可选): 重复次数
-
-### notification_task_management
-管理通知任务
-
-**参数：**
-- `action` (必需): 操作类型
-  - `stop_repeat_task`: 停止指定任务
-  - `stop_all_repeat_tasks`: 停止所有任务
-  - `get_active_repeat_tasks`: 获取活跃任务
-  - `get_repeat_task_info`: 获取任务信息
-- `taskId` (部分操作需要): 任务ID
-
-## 安装和使用
-
-```bash
-# 安装依赖
-pnpm install
-
-# 构建
-pnpm build
-
-# 运行
-pnpm start
-```
-
-## 平台支持
-
-- **macOS**: 使用AppleScript的`display notification`
-- **Windows**: 使用PowerShell的BalloonTip
-- **Linux**: 使用`notify-send`
-
-## 示例
-
-```json
-{
-  "title": "提醒",
-  "message": "这是一条测试通知",
-  "subtitle": "测试",
-  "sound": true,
-  "delay": "5s"
-}
-``` 
+# MCP 通知提醒服务器
+
+一个基于 Model Context Protocol (MCP) 的通知提醒服务器，提供设置提醒、查询提醒列表、取消提醒三种工具，并通过后端接口对接统一的提醒调度与分发。
+
+## 功能特性
+
+- 🔔 设置提醒：支持一次性、固定间隔循环、每日循环
+- 📋 查询列表：获取设备的待触发提醒列表（仅 `scheduled`）
+- ❌ 取消提醒：按 `id` 取消指定提醒
+- ⚡ MCP 协议集成：适配各类 MCP 客户端
+- 🌐 可配置后端地址：通过环境变量 `REMINDER_API_BASE` 指定
+
+## 安装
+
+### 前置要求
+
+- Node.js >= 18
+
+### 安装依赖
+
+```bash
+npm install
+```
+
+### 构建项目
+
+```bash
+npm run build
+```
+
+## 使用方法
+
+### 1. 直接运行
+
+```bash
+npm run start
+# 或
+node dist/index.js
+```
+
+### 2. 作为 MCP 服务器
+
+在您的 MCP 客户端配置中添加：
+
+```json
+{
+  "mcpServers": {
+    "通知提醒": {
+      "command": "node",
+      "args": ["/path/to/通知提醒新/dist/index.js"],
+      "env": {
+        "REMINDER_API_BASE": "https://www.rapido.chat/api"
+      }
+    }
+  }
+}
+```
+
+或使用已发布命令名（全局安装后）：
+
+```json
+{
+  "mcpServers": {
+    "通知提醒": {
+      "command": "notification-mcp",
+      "args": [],
+      "env": {
+        "REMINDER_API_BASE": "https://www.mcpcn.cc/api"
+      }
+    }
+  }
+}
+```
+
+## 工具说明
+
+### set_reminder
+
+设置通知提醒，支持以下模式（请求需携带会话头 `chatSessionId`，详见下文“会话标识”）：
+
+- 一次性（相对延时）
+  ```json
+  { "content": "开会", "repeat": "none", "delaySec": 300 }
+  ```
+
+- 一次性（绝对时间）
+  ```json
+  { "content": "开会", "repeat": "none", "triggerAt": "2025-11-15T20:00:00+08:00" }
+  ```
+
+- 间隔循环（每5分钟）
+  ```json
+  { "content": "喝水", "repeat": "interval", "intervalSec": 300 }
+  ```
+
+- 每日循环（每天18:00，北京时间）
+  ```json
+  { "content": "下班打卡", "repeat": "daily", "timeOfDay": "18:00", "tzOffsetMin": 480 }
+  ```
+
+参数：
+
+- `content` (string, 必需)
+- `repeat` (string, 必需)：`none|interval|daily`
+- `delaySec` (number, 可选)：一次性延时触发
+- `triggerAt` (string, 可选)：一次性绝对时间（RFC3339）
+- `intervalSec` (number, 可选)：间隔循环秒数
+- `timeOfDay` (string, 可选)：每日循环的时间（如 `18:00` 或 `18:00:00`）
+- `tzOffsetMin` (number, 可选)：时区偏移分钟（北京为 `480`）
+
+### list_reminders
+
+查询待触发提醒列表（请求需携带会话头 `chatSessionId`）：
+
+参数：无
+
+返回：提醒条目数组（仅 `scheduled` 状态）
+
+### cancel_reminder
+
+取消指定提醒（请求需携带会话头 `chatSessionId`）：
+
+参数：
+
+- `id` (string, 必需)
+
+## 会话标识
+
+MCP 客户端需在调用工具时携带 `meta.chatSessionId`，服务端会自动解析并将其作为 HTTP 请求头 `chatSessionId` 传给后端接口：
+
+- 解析来源：`request.meta.chatSessionId` 或 `request.params.meta.chatSessionId`
+- 请求头：`chatSessionId: <meta.chatSessionId>`
+
+## 后端接口
+
+默认后端基地址为 `https://www.mcpcn.cc/api`（可通过 `REMINDER_API_BASE` 修改）。接口为：
+
+- 设置提醒：`https://www.mcpcn.cc/api/reminder/set`
+- 列表查询：`https://www.mcpcn.cc/api/reminder/list`
+- 取消提醒：`https://www.mcpcn.cc/api/reminder/cancel`
+
+## 项目结构
+
+```
+通知提醒新/
+├── src/
+│   └── index.ts       # MCP 服务器实现（工具与接口调用）
+├── dist/
+│   └── index.js       # 构建输出文件
+├── package.json          # 项目配置（main/bin 脚本）
+├── tsconfig.json         # TypeScript 配置
+└── README.md            # 使用说明
+```
+
+## 技术栈
+
+- **TypeScript**
+- **Node.js**
+- **@modelcontextprotocol/sdk**
+
+## 许可证
+
+MIT License
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request！

package/dist/index.js

@@ -1,519 +1,157 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 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';
-const execAsync = promisify(exec);
-/**
- * Escapes special characters in strings for AppleScript
- */
-function escapeString(str) {
-    // Escape for both AppleScript and shell
-    return str
-        .replace(/'/g, "'\\''")
-        .replace(/"/g, '\\"');
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from '@modelcontextprotocol/sdk/types.js';
+const API_BASE = process.env.REMINDER_API_BASE || 'https://www.rapido.chat/api';
+async function postJson(path, body, chatSessionId) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (chatSessionId)
+        headers['chatSessionId'] = chatSessionId;
+    const resp = await fetch(`${API_BASE}${path}`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+    });
+    if (!resp.ok) {
+        throw new Error(`HTTP 错误: ${resp.status} ${resp.statusText}`);
+    }
+    return (await resp.json());
 }
-// 任务池：存储所有活跃的重复提醒任务
-const repeatNotificationPool = new Map();
-/**
- * 生成唯一任务ID
- */
-function generateNotificationId() {
-    return 'notification_' + Math.random().toString(36).substr(2, 9) + '_' + Date.now().toString(36);
+async function getJson(path, chatSessionId) {
+    const headers = {};
+    if (chatSessionId)
+        headers['chatSessionId'] = chatSessionId;
+    const resp = await fetch(`${API_BASE}${path}`, { headers });
+    if (!resp.ok) {
+        throw new Error(`HTTP 错误: ${resp.status} ${resp.statusText}`);
+    }
+    return (await resp.json());
 }
-/**
- * Validates notification parameters
- */
-function validateParams(params) {
-    if (!params.title || typeof params.title !== 'string') {
-        throw new Error('Title is required and must be a string');
-    }
-    if (!params.message || typeof params.message !== 'string') {
-        throw new Error('Message is required and must be a string');
-    }
-    if (params.subtitle && typeof params.subtitle !== 'string') {
-        throw new Error('Subtitle must be a string');
-    }
-}
-/**
- * Builds the AppleScript command for sending a notification
- */
-function buildNotificationCommand(params) {
-    const { title, message, subtitle, sound = true } = params;
-    let script = `display notification "${escapeString(message)}" with title "${escapeString(title)}"`;
-    if (subtitle) {
-        script += ` subtitle "${escapeString(subtitle)}"`;
-    }
-    if (sound) {
-        script += ` sound name "default"`;
-    }
-    return `osascript -e '${script}'`;
-}
-// 检测操作系统
-function getOS() {
-    const currentPlatform = process.platform;
-    if (currentPlatform === 'win32')
-        return 'windows';
-    if (currentPlatform === 'darwin')
-        return 'macos';
-    return 'linux';
-}
-// Windows 通知命令构建
-function buildWindowsNotificationCommand(params) {
-    const { title, message, sound = true } = params;
-    // 使用 PowerShell 的 BalloonTip
-    let script = `
-    Add-Type -AssemblyName System.Windows.Forms;
-    $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 += `
-    Start-Sleep -Seconds 1;
-    $notification.Dispose();
-  `;
-    return `powershell -Command "${script}"`;
-}
-// Linux 通知命令构建
-function buildLinuxNotificationCommand(params) {
-    const { title, message, subtitle, sound = true } = params;
-    let command = `notify-send "${escapeString(title)}" "${escapeString(message)}"`;
-    if (subtitle) {
-        // 将 subtitle 添加到消息中，因为 notify-send 不直接支持副标题
-        command = `notify-send "${escapeString(title)}" "${escapeString(subtitle)}\n${escapeString(message)}"`;
-    }
-    // 添加声音支持
-    if (sound) {
-        command += ` --hint=string:sound-name:message-new-instant`;
-    }
-    return command;
-}
-/**
- * 解析时间字符串为毫秒数
- */
-function parseTimeDelay(delay) {
-    if (typeof delay === 'number') {
-        return delay;
-    }
-    const timeString = delay.toLowerCase().trim();
-    const match = timeString.match(/^(\d+(?:\.\d+)?)\s*([smh]?)$/);
-    if (!match) {
-        throw new Error('Invalid time format. Use numbers (milliseconds) or strings like "10s", "1m", "1h"');
-    }
-    const value = parseFloat(match[1]);
-    const unit = match[2] || 'ms'; // 默认单位为毫秒
-    switch (unit) {
-        case 's': return value * 1000; // 秒
-        case 'm': return value * 60 * 1000; // 分钟  
-        case 'h': return value * 60 * 60 * 1000; // 小时
-        default: return value; // 毫秒
-    }
-}
-/**
- * Sends a notification using the appropriate platform command
- */
-async function sendNotification(params) {
-    // 如果有 repeat 参数，设置重复提醒
-    if (params.repeat !== undefined) {
-        const repeatMs = parseTimeDelay(params.repeat);
-        if (repeatMs <= 0) {
-            throw new Error('Repeat interval must be a positive number');
-        }
-        const notificationId = generateNotificationId();
-        const { repeat, repeatCount, ...notificationParams } = params;
-        const maxCount = repeatCount || Infinity;
-        // 创建重复发送的函数
-        const scheduleNextNotification = (currentCount) => {
-            if (currentCount >= maxCount) {
-                // 任务完成，从任务池中移除
-                repeatNotificationPool.delete(notificationId);
-                return;
-            }
-            const timeoutId = setTimeout(async () => {
-                try {
-                    // 检查任务是否还在任务池中（可能已被取消）
-                    const notification = repeatNotificationPool.get(notificationId);
-                    if (!notification)
-                        return;
-                    await sendNotification(notificationParams);
-                    // 更新任务信息
-                    notification.currentCount++;
-                    // 调度下一次通知
-                    scheduleNextNotification(currentCount + 1);
-                }
-                catch (error) {
-                    console.error('Repeated notification failed:', error);
-                    // 即使失败也继续下一次
-                    scheduleNextNotification(currentCount + 1);
-                }
-            }, repeatMs);
-            // 更新任务池中的任务信息
-            const notification = repeatNotificationPool.get(notificationId);
-            if (notification) {
-                // 清除旧的timeout
-                if (notification.timeoutId) {
-                    clearTimeout(notification.timeoutId);
-                }
-                notification.timeoutId = timeoutId;
-            }
-        };
-        // 创建任务并加入任务池
-        const notification = {
-            id: notificationId,
-            params,
-            timeoutId: null, // 稍后设置
-            currentCount: 0,
-            maxCount,
-            startTime: Date.now()
-        };
-        repeatNotificationPool.set(notificationId, notification);
-        // 如果有初始延迟，先等待延迟再开始重复
-        if (params.delay !== undefined) {
-            const delayMs = parseTimeDelay(params.delay);
-            notification.timeoutId = setTimeout(() => {
-                // 发送第一次通知并开始重复
-                sendNotification(notificationParams).then(() => {
-                    notification.currentCount = 1;
-                    scheduleNextNotification(1);
-                }).catch(error => {
-                    console.error('Initial repeated notification failed:', error);
-                    scheduleNextNotification(1);
-                });
-            }, delayMs);
-        }
-        else {
-            // 没有初始延迟，立即开始第一次通知
-            try {
-                await sendNotification(notificationParams);
-                notification.currentCount = 1;
-                scheduleNextNotification(1);
-            }
-            catch (error) {
-                console.error('Initial repeated notification failed:', error);
-                scheduleNextNotification(1);
-            }
-        }
-        return {
-            notificationId,
-            message: `Repeat notification notification created with ID: ${notificationId}`
-        };
-    }
-    // 如果有 delay 参数但没有 repeat，使用 setTimeout 延迟发送
-    if (params.delay !== undefined) {
-        const delayMs = parseTimeDelay(params.delay);
-        if (delayMs <= 0) {
-            throw new Error('Delay must be a positive number');
-        }
-        try {
-            // 设置延迟任务
-            setTimeout(async () => {
-                try {
-                    // 创建不包含 delay 的参数对象，避免无限递归
-                    const { delay, ...notificationParams } = params;
-                    await sendNotification(notificationParams);
-                }
-                catch (error) {
-                    console.error('Delayed notification failed:', error);
-                }
-            }, delayMs);
-            // 立即返回设置成功
-            return { message: 'Delayed notification scheduled successfully' };
-        }
-        catch (error) {
-            throw new Error('Failed to schedule delayed notification');
-        }
-    }
-    // 立即发送通知的逻辑
-    try {
-        validateParams(params);
-        const os = getOS();
-        let command;
-        switch (os) {
-            case 'macos':
-                command = buildNotificationCommand(params);
-                break;
-            case 'windows':
-                command = buildWindowsNotificationCommand(params);
-                break;
-            case 'linux':
-                command = buildLinuxNotificationCommand(params);
-                break;
-            default:
-                throw new Error(`Unsupported platform: ${os}`);
-        }
-        await execAsync(command);
-        return { message: 'Notification sent successfully' };
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw error;
-        }
-        // Handle different types of system errors
-        const err = error;
-        if (err.message.includes('execution error')) {
-            throw new Error('Failed to execute notification command');
-        }
-        else if (err.message.includes('permission')) {
-            throw new Error('Permission denied when trying to send notification');
-        }
-        else {
-            throw new Error(`Unexpected error: ${err.message}`);
-        }
-    }
-}
-/**
- * 停止指定的重复提醒任务
- */
-function stopRepeatNotification(notificationId) {
-    const notification = repeatNotificationPool.get(notificationId);
-    if (!notification) {
-        return false;
-    }
-    // 清除定时器
-    if (notification.timeoutId) {
-        clearTimeout(notification.timeoutId);
-    }
-    // 从任务池中移除
-    repeatNotificationPool.delete(notificationId);
-    return true;
-}
-/**
- * 停止所有重复提醒任务
- */
-function stopAllRepeatNotifications() {
-    const count = repeatNotificationPool.size;
-    // 清除所有定时器
-    for (const notification of repeatNotificationPool.values()) {
-        if (notification.timeoutId) {
-            clearTimeout(notification.timeoutId);
-        }
-    }
-    // 清空任务池
-    repeatNotificationPool.clear();
-    return count;
-}
-/**
- * 获取所有活跃的重复提醒任务信息
- */
-function getActiveRepeatNotifications() {
-    return Array.from(repeatNotificationPool.values()).map(notification => ({
-        ...notification,
-        // 不返回timeoutId，避免序列化问题
-        timeoutId: null
-    }));
-}
-/**
- * 获取指定任务的信息
- */
-function getRepeatNotificationInfo(notificationId) {
-    const notification = repeatNotificationPool.get(notificationId);
-    if (!notification) {
-        return null;
-    }
-    return {
-        ...notification,
-        // 不返回timeoutId，避免序列化问题
-        timeoutId: null
-    };
-}
-class NotificationServer {
+class ReminderServer {
     constructor() {
-        this.server = new Server({
-            name: 'notification-mcp',
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        // Error handling
+        this.server = new Server({ name: 'notification-mcp', version: '1.0.0' }, { capabilities: { tools: {} } });
+        this.setupHandlers();
         this.server.onerror = (error) => console.error('[MCP Error]', error);
         process.on('SIGINT', async () => {
             await this.server.close();
             process.exit(0);
         });
     }
-    setupToolHandlers() {
-        // List available tools
+    setupHandlers() {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
             tools: [
                 {
-                    name: 'send_notification',
-                    description: '发送系统通知或提醒',
+                    name: 'set_reminder',
+                    description: '设置通知提醒。支持一次性、按间隔循环、每日循环。',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            title: {
-                                type: 'string',
-                                description: '通知或提醒的标题',
-                            },
-                            message: {
-                                type: 'string',
-                                description: '通知或提醒的内容',
-                            },
-                            subtitle: {
-                                type: 'string',
-                                description: '可选的副标题',
-                            },
-                            sound: {
-                                type: 'boolean',
-                                description: '是否播放默认提示音',
-                                default: true,
-                            },
-                            delay: {
-                                oneOf: [
-                                    { type: 'number' },
-                                    { type: 'string' }
-                                ],
-                                description: '延迟发送通知或提醒（毫秒或时间字符串如"10s", "1m", "1h"）',
-                            },
-                            repeat: {
-                                oneOf: [
-                                    { type: 'number' },
-                                    { type: 'string' }
-                                ],
-                                description: '重复通知或提醒的间隔（毫秒或时间字符串如"10s", "1m", "1h"）',
-                            },
-                            repeatCount: {
-                                type: 'number',
-                                description: '重复次数（可选，如果设置了repeat但未设置此项则无限重复）',
-                                minimum: 1,
-                            },
+                            content: { type: 'string' },
+                            repeat: { type: 'string', enum: ['none', 'interval', 'daily'] },
+                            delaySec: { type: 'number' },
+                            triggerAt: { type: 'string', description: 'RFC3339 时间，例如 2025-11-15T20:00:00+08:00' },
+                            intervalSec: { type: 'number' },
+                            timeOfDay: { type: 'string', description: '例如 18:00 或 18:00:00' },
+                            tzOffsetMin: { type: 'number', description: '时区偏移分钟，例如北京为 480' },
                         },
-                        required: ['title', 'message'],
+                        required: ['content', 'repeat'],
                         additionalProperties: false,
                     },
                 },
                 {
-                    name: 'notification_task_management',
-                    description: '管理计划的通知或提醒任务',
+                    name: 'list_reminders',
+                    description: '获取设备的提醒列表（仅未触发的 scheduled）。',
                     inputSchema: {
                         type: 'object',
-                        properties: {
-                            action: {
-                                type: 'string',
-                                enum: ['stop_repeat_task', 'stop_all_repeat_tasks', 'get_active_repeat_tasks', 'get_repeat_task_info'],
-                                description: 'stop_repeat_task: 停止指定的重复通知或提醒任务. stop_all_repeat_tasks: 停止所有重复通知或提醒任务. get_active_repeat_tasks: 获取所有活跃的重复通知或提醒任务. get_repeat_task_info: 获取指定重复通知或提醒任务的信息.'
-                            },
-                            taskId: {
-                                type: 'string',
-                                description: '要管理的任务ID'
-                            }
-                        },
-                        required: ['action'],
-                        additionalProperties: false
-                    }
+                        properties: {},
+                        required: [],
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'cancel_reminder',
+                    description: '取消指定提醒。',
+                    inputSchema: {
+                        type: 'object',
+                        properties: { id: { type: 'string' } },
+                        required: ['id'],
+                        additionalProperties: false,
+                    },
                 },
             ],
         }));
-        // Handle tool execution
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             try {
                 if (!request.params.arguments || typeof request.params.arguments !== 'object') {
-                    throw new McpError(ErrorCode.InvalidParams, 'Invalid parameters');
+                    throw new McpError(ErrorCode.InvalidParams, '无效的参数');
+                }
+                const name = request.params.name;
+                const args = request.params.arguments;
+                const chatSessionId = request?.meta?.chatSessionId ??
+                    request?.params?.meta?.chatSessionId ??
+                    request?.params?.arguments?.meta?.chatSessionId;
+                if (!chatSessionId) {
+                    console.error('未在请求中检测到 chatSessionId（meta.chatSessionId）');
+                }
+                else {
+                    console.error(`接收到 chatSessionId: ${chatSessionId}`);
                 }
-                switch (request.params.name) {
-                    case 'send_notification': {
-                        const { title, message, subtitle, sound, delay, repeat, repeatCount } = request.params.arguments;
-                        if (typeof title !== 'string' || typeof message !== 'string') {
-                            throw new McpError(ErrorCode.InvalidParams, 'Title and message must be strings');
-                        }
-                        const params = {
-                            title,
-                            message,
-                            subtitle: typeof subtitle === 'string' ? subtitle : undefined,
-                            sound: typeof sound === 'boolean' ? sound : undefined,
-                            delay: (typeof delay === 'number' || typeof delay === 'string') ? delay : undefined,
-                            repeat: (typeof repeat === 'number' || typeof repeat === 'string') ? repeat : undefined,
-                            repeatCount: typeof repeatCount === 'number' ? repeatCount : undefined
-                        };
-                        const result = await sendNotification(params);
-                        return {
-                            content: [
-                                {
-                                    type: 'text',
-                                    text: result.notificationId ?
-                                        `${result.message}. Task ID: ${result.notificationId}` :
-                                        result.message,
-                                },
-                            ],
-                        };
+                if (name === 'set_reminder') {
+                    const params = {
+                        content: String(args.content || ''),
+                        repeat: String(args.repeat || ''),
+                        delaySec: args.delaySec,
+                        triggerAt: args.triggerAt,
+                        intervalSec: args.intervalSec,
+                        timeOfDay: args.timeOfDay,
+                        tzOffsetMin: args.tzOffsetMin,
+                    };
+                    const resp = await postJson('/reminder/set', params, chatSessionId);
+                    if (resp.code !== 0) {
+                        return { content: [{ type: 'text', text: `设置失败：${resp.msg}` }], isError: true };
                     }
-                    case 'notification_task_management': {
-                        const { action, taskId } = request.params.arguments;
-                        switch (action) {
-                            case 'stop_repeat_task': {
-                                const success = stopRepeatNotification(taskId);
-                                return {
-                                    content: [
-                                        {
-                                            type: 'text',
-                                            text: success ? `任务 ${taskId} 已成功停止` : `任务 ${taskId} 未找到`,
-                                        },
-                                    ],
-                                };
-                            }
-                            case 'stop_all_repeat_tasks': {
-                                const count = stopAllRepeatNotifications();
-                                return {
-                                    content: [
-                                        {
-                                            type: 'text',
-                                            text: `已停止 ${count} 个重复任务`,
-                                        },
-                                    ],
-                                };
-                            }
-                            case 'get_active_repeat_tasks': {
-                                const tasks = getActiveRepeatNotifications();
-                                return {
-                                    content: [
-                                        {
-                                            type: 'text',
-                                            text: JSON.stringify(tasks, null, 2),
-                                        },
-                                    ],
-                                };
-                            }
-                            case 'get_repeat_task_info': {
-                                const info = getRepeatNotificationInfo(taskId);
-                                return {
-                                    content: [
-                                        {
-                                            type: 'text',
-                                            text: info ? JSON.stringify(info, null, 2) : `任务 ${taskId} 未找到`,
-                                        },
-                                    ],
-                                };
-                            }
-                            default:
-                                throw new McpError(ErrorCode.MethodNotFound, `Unknown task management action: ${action}`);
-                        }
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ id: resp.data?.id, triggerAt: resp.data?.triggerAt, msg: resp.msg || '设置成功' }, null, 2),
+                            },
+                        ],
+                        isError: false,
+                    };
+                }
+                if (name === 'list_reminders') {
+                    const resp = await getJson(`/reminder/list`, chatSessionId);
+                    if (resp.code !== 0) {
+                        return { content: [{ type: 'text', text: `获取失败：${resp.msg}` }], isError: true };
+                    }
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(resp.data?.list ?? [], null, 2) }],
+                        isError: false,
+                    };
+                }
+                if (name === 'cancel_reminder') {
+                    const params = { id: String(args.id || '') };
+                    const resp = await postJson(`/reminder/cancel`, params, chatSessionId);
+                    if (resp.code !== 0) {
+                        return { content: [{ type: 'text', text: `取消失败：${resp.msg}` }], isError: true };
                     }
-                    default:
-                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+                    return { content: [{ type: 'text', text: resp.msg || '取消成功' }], isError: false };
                 }
+                throw new McpError(ErrorCode.MethodNotFound, `未知工具: ${name}`);
             }
             catch (error) {
-                throw error;
+                if (error instanceof McpError)
+                    throw error;
+                throw new McpError(ErrorCode.InternalError, `执行失败: ${error.message}`);
             }
         });
     }
     async run() {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
-        console.error('Notification MCP server running on stdio');
+        console.error('Reminder MCP server running on stdio');
     }
 }
-const server = new NotificationServer();
+const server = new ReminderServer();
 server.run().catch(console.error);

package/package.json

@@ -1,39 +1,41 @@
-{
-  "name": "@mcpcn/mcp-notification",
-  "version": "1.0.3",
-  "description": "系统通知MCP服务器",
-  "packageManager": "pnpm@8.12.1",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "notification-mcp": "./dist/index.js"
-  },
-  "files": [
-    "dist/**/*"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "keywords": [
-    "mcp",
-    "notification",
-    "系统通知",
-    "跨平台"
-  ],
-  "scripts": {
-    "build": "tsc && chmod +x dist/index.js",
-    "start": "node dist/index.js",
-    "dev": "tsc -w",
-    "clean": "rm -rf build",
-    "prepare": "pnpm clean && pnpm build"
-  },
-  "type": "module",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^22.10.2",
-    "typescript": "^5.7.2"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.4"
-  }
-}
+{
+  "name": "@mcpcn/mcp-notification",
+  "version": "1.0.5",
+  "description": "系统通知MCP服务器",
+  "packageManager": "yarn@1.22.22",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "notification-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "notification",
+    "通知提醒",
+    "schedule",
+    "interval",
+    "daily"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"try{require('fs').chmodSync('dist/index.js',0o755)}catch(e){}\"",
+    "start": "node dist/index.js",
+    "dev": "tsc -w",
+    "clean": "node -e \"try{require('fs').rmSync('dist',{recursive:true,force:true})}catch(e){}\"",
+    "prepare": "npm run clean && npm run build"
+  },
+  "type": "module",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4"
+  }
+}