@costrict/notify 1.0.5

package/.env.example

@@ -0,0 +1,21 @@
+# Notification Channel Configuration
+# ==================================
+
+# System Desktop Notification
+# Default: disabled
+NOTIFY_ENABLE_SYSTEM=false
+
+# Bark Notification (iOS/macOS push notifications)
+# Default: disabled
+NOTIFY_ENABLE_BARK=false
+BARK_URL=https://api.day.app/YOUR_BARK_KEY
+
+# WeChat Work (企微) Webhook Notification
+# Default: disabled
+NOTIFY_ENABLE_WECOM=false
+
+# Option 1: Configure with full webhook URL
+# WECOM_WEBHOOK_URL=https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=YOUR_KEY
+
+# Option 2: Configure with KEY only (URL will use default: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=)
+WECOM_WEBHOOK_KEY=YOUR_KEY

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# CoStrict-System-Notify
+
+Desktop notification plugin for CoStrict.
+
+## Features
+
+Monitors human intervention events and sends notifications via multiple channels when:
+
+- **Permission requests** - Tool execution requires user permission
+- **Question asked** - AI needs user input
+- **Session idle** - AI waiting for user input
+
+## Notification Channels
+
+### System Notification (Default Disabled)
+Desktop notifications using `node-notifier` - works across Windows, macOS, and Linux.
+
+### Bark Notification
+Push notifications via Bark service (iOS/macOS).
+
+### WeChat Work Webhook (Default Disabled)
+Push notifications via WeChat Work (企微) webhook service.
+
+## Configuration
+
+Configure notification channels using environment variables:
+
+```bash
+# Enable/disable notification channels (default: all disabled)
+NOTIFY_ENABLE_SYSTEM=true    # System notification (default: false)
+NOTIFY_ENABLE_BARK=false     # Bark notification (default: false)
+NOTIFY_ENABLE_WECOM=false    # WeChat Work notification (default: false)
+
+# Bark configuration (required if Bark enabled)
+BARK_URL="https://api.day.app/YOUR_BARK_KEY"
+
+# WeChat Work configuration (required if WeChat Work enabled)
+# Option 1: Full webhook URL
+WECOM_WEBHOOK_URL="https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=YOUR_KEY"
+
+# Option 2: Just the KEY (URL will use default base)
+WECOM_WEBHOOK_KEY="YOUR_KEY"
+```
+
+### Examples
+
+**Enable system notifications**:
+```bash
+export NOTIFY_ENABLE_SYSTEM=true
+```
+
+**Enable Bark notifications**:
+```bash
+export NOTIFY_ENABLE_BARK=true
+export BARK_URL="https://api.day.app/YOUR_BARK_KEY"
+```
+
+**Enable multiple channels**:
+```bash
+export NOTIFY_ENABLE_SYSTEM=true
+export NOTIFY_ENABLE_BARK=true
+export BARK_URL="https://api.day.app/YOUR_BARK_KEY"
+```
+
+**Enable WeChat Work notifications** (with KEY only):
+```bash
+export NOTIFY_ENABLE_WECOM=true
+export WECOM_WEBHOOK_KEY="YOUR_KEY"
+```
+
+**Enable WeChat Work notifications** (with full URL):
+```bash
+export NOTIFY_ENABLE_WECOM=true
+export WECOM_WEBHOOK_URL="https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=YOUR_KEY"
+```
+
+**Enable all channels**:
+```bash
+export NOTIFY_ENABLE_SYSTEM=true
+export NOTIFY_ENABLE_BARK=true
+export NOTIFY_ENABLE_WECOM=true
+export BARK_URL="https://api.day.app/YOUR_BARK_KEY"
+export WECOM_WEBHOOK_KEY="YOUR_KEY"
+```
+
+## Architecture
+
+The plugin implements a single hook:
+
+- **intervention.required hook** - Receives notification events and displays desktop notifications
+
+The filtering logic for idle events (main session vs sub-agent) is handled by the TDD plugin which triggers this hook. This plugin simply displays whatever notifications it receives.
+
+## Installation
+
+### Add to CoStrict Config
+
+Add to your `~/.config/costrict/config.json`:
+
+```json
+{
+  "plugin": ["@costrict/notify"]
+}
+```
+
+### Build Plugin
+
+```bash
+cd D:/DEV/costrict-notify
+bun install
+```
+
+No build step required - pure JavaScript implementation.
+
+### Configuration Template
+
+Copy `.env.example` to create your own environment configuration:
+
+```bash
+cp .env.example .env
+# Edit .env with your notification settings
+```
+
+## Project Structure
+
+```
+costrict-notify/
+├── src/
+│   └── index.js          # Main plugin code with multi-channel support
+├── package.json          # Dependencies and scripts
+├── .env.example          # Environment configuration template
+├── .gitignore           # Git ignore rules
+├── LICENSE              # MIT License
+└── README.md            # This file
+```
+
+## Notification Details
+
+### Permission Notification
+
+- **Trigger**: `intervention.required` hook (type: "permission")
+- **Title**: "需要权限"
+- **Message**: Permission request message
+
+### Question Notification
+
+- **Trigger**: `intervention.required` hook (type: "question")
+- **Title**: "问题"
+- **Message**: First question text
+
+### Idle Notification
+
+- **Trigger**: `intervention.required` hook (type: "idle")
+- **Title**: "会话空闲"
+- **Message**: "AI 正在等待您的输入"
+- **Filtered**: Only for main sessions (handled by TDD plugin)
+
+## Technical Details
+
+- Uses `node-notifier` v10.0.1 for cross-platform desktop notifications
+- Supports multiple notification channels (System, Bark, WeChat Work)
+- Configurable via environment variables
+- Implements `intervention.required` hook
+- Pure JavaScript - no build step required
+- Compatible with CoStrict plugin system
+- Smart filtering delegated to TDD plugin
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@costrict/notify",
+  "version": "1.0.5",
+  "description": "Multi-channel notification plugin for CoStrict - supports system desktop, Bark, and WeChat Work notifications",
+  "main": "src/index.js",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "opencode",
+    "costrict",
+    "plugin",
+    "notification",
+    "desktop",
+    "bark",
+    "wecom",
+    "wechat",
+    "webhook"
+  ],
+  "author": "",
+  "scripts": {
+    "test": "node test/notify.test.js"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "*",
+    "node-notifier": "^10.0.1"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  }
+}

package/src/index.js

@@ -0,0 +1,239 @@
+let notifierInstance = null;
+
+async function loadNotifier() {
+  if (notifierInstance) {
+    return notifierInstance;
+  }
+
+  try {
+    const notifierModule = await import("node-notifier");
+    const notifier = notifierModule.default || notifierModule;
+    return notifier;
+  } catch {
+    return null;
+  }
+}
+
+class SystemNotifier {
+  async notify(title, message, options = {}) {
+    const notifier = await loadNotifier();
+    if (!notifier) {
+      throw new Error("System notifier not available");
+    }
+
+    return new Promise((resolve, reject) => {
+      notifier.notify(
+        {
+          title,
+          message,
+          timeout: options.timeout || 5,
+          icon: "nothing",
+          appID: "CoStrict",
+          wait: false,
+        },
+        (err, response) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(response);
+          }
+        }
+      );
+    });
+  }
+}
+
+class BarkNotifier {
+  constructor() {
+    this.url = process.env.BARK_URL;
+  }
+
+  async notify(title, message, options = {}) {
+    if (!this.url) {
+      throw new Error("Bark URL not configured");
+    }
+
+    let url = `${this.url}/${encodeURIComponent(title)}/${encodeURIComponent(message)}`;
+    const params = {};
+
+    if (options.timeout) {
+      params.timeout = options.timeout;
+    }
+
+    if (Object.keys(params).length > 0) {
+      url += '?' + new URLSearchParams(params).toString();
+    }
+
+    await fetch(url);
+  }
+}
+
+class WecomNotifier {
+  constructor() {
+    const webhookUrl = process.env.WECOM_WEBHOOK_URL;
+    const webhookKey = process.env.WECOM_WEBHOOK_KEY;
+    
+    if (webhookUrl) {
+      this.webhookUrl = webhookUrl;
+    } else if (webhookKey) {
+      this.webhookUrl = `https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=${webhookKey}`;
+    } else {
+      this.webhookUrl = null;
+    }
+  }
+
+  async notify(title, message, options = {}) {
+    if (!this.webhookUrl) {
+      throw new Error("Wecom webhook URL or KEY not configured");
+    }
+
+    const content = `${title}\n${message}`;
+    
+    await fetch(this.webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        msgtype: "text",
+        text: {
+          content: content,
+        },
+      }),
+    });
+  }
+}
+
+async function sendNotification(title, message, options = {}) {
+  const enableSystem = process.env.NOTIFY_ENABLE_SYSTEM === "true";
+  const enableBark = process.env.NOTIFY_ENABLE_BARK === "true";
+  const enableWecom = process.env.NOTIFY_ENABLE_WECOM === "true";
+
+  const results = [];
+
+  if (enableSystem) {
+    try {
+      const systemNotifier = new SystemNotifier();
+      await systemNotifier.notify(title, message, options);
+      results.push({ type: "system", success: true });
+    } catch (error) {
+      results.push({ type: "system", success: false, error: error.message });
+    }
+  }
+
+  if (enableBark) {
+    try {
+      const barkNotifier = new BarkNotifier();
+      await barkNotifier.notify(title, message, options);
+      results.push({ type: "bark", success: true });
+    } catch (error) {
+      results.push({ type: "bark", success: false, error: error.message });
+    }
+  }
+
+  if (enableWecom) {
+    try {
+      const wecomNotifier = new WecomNotifier();
+      await wecomNotifier.notify(title, message, options);
+      results.push({ type: "wecom", success: true });
+    } catch (error) {
+      results.push({ type: "wecom", success: false, error: error.message });
+    }
+  }
+
+  const hasSuccess = results.some((r) => r.success);
+  return hasSuccess;
+}
+
+export async function CoStrictSystemNotifyPlugin(ctx) {
+  if (notifierInstance) {
+    notifierInstance = null;
+  }
+
+  const { client } = ctx;
+
+  return {
+    "intervention.required": async (input, output) => {
+      const { type, data, sessionID } = input;
+
+      let title = "CoStrict";
+      let message = "";
+      let timeout = 5;
+
+      let sessionTitle = "任务";
+      let userMessage = "";
+      let latestMessage = "";
+
+      if (sessionID && client?.session) {
+        try {
+          const session = await client.session.get({ path: { id: sessionID } });
+          if (session?.data?.title) {
+            sessionTitle = session.data.title.length > 50 ? session.data.title.slice(0, 50) + "..." : session.data.title;
+          }
+
+          const result = await client.session.messages({ path: { id: sessionID }, query: { limit: 10 } });
+          const data = result.data ?? [];
+          const lastUserMsg = data.findLast(m => m.info?.role === "user");
+          if (lastUserMsg?.parts) {
+            const textPart = lastUserMsg.parts.find(p => p.type === "text");
+            if (textPart?.text) {
+              userMessage = textPart.text.length > 100 ? textPart.text.slice(0, 100) + "..." : textPart.text;
+            }
+          }
+          const latestNonUserMsg = data.findLast(m => m.info?.role !== "user");
+          if (latestNonUserMsg?.parts) {
+            const textPart = latestNonUserMsg.parts.find(p => p.type === "text");
+            if (textPart?.text) {
+              latestMessage = textPart.text.length > 100 ? textPart.text.slice(0, 100) + "..." : textPart.text;
+            }
+          }
+        } catch (err) {
+          console.error("Failed to get session messages:", err);
+        }
+      }
+
+      let formattedMessage = "";
+
+      switch (type) {
+        case "permission":
+          title = "需要权限";
+          const permission = data.permission || "";
+          const pattern = Array.isArray(data.patterns) && data.patterns.length > 0 ? data.patterns[0] : "";
+          const permissionMessage = permission ? `[${permission}] ${pattern}` : (pattern || "工具需要权限才能执行");
+          formattedMessage = [
+            `会话标题：${sessionTitle}`,
+            `权限请求：${permissionMessage}`
+          ].join("\n");
+          break;
+
+        case "question":
+          title = "问题";
+          const firstQuestion =
+            Array.isArray(data.questions) && data.questions.length > 0
+              ? data.questions[0].question
+              : "请回答问题";
+          formattedMessage = [
+            `会话标题：${sessionTitle}`,
+            `待回答问题：${firstQuestion}`
+          ].join("\n");
+          break;
+
+        case "idle":
+          title = "会话空闲";
+          formattedMessage = [
+            `会话标题：${sessionTitle}`,
+            userMessage ? `用户上一条提问内容：${userMessage}` : "用户上一条提问内容：（无）",
+            latestMessage ? `最新一条消息：${latestMessage}` : "最新一条消息：（无）"
+          ].join("\n");
+          break;
+      }
+
+      try {
+        const success = await sendNotification(title, formattedMessage, { timeout });
+        output.handled = success;
+      } catch {
+        output.handled = false;
+      }
+    },
+  };
+}

package/test/bark-direct.test.js

@@ -0,0 +1,30 @@
+const barkUrl = process.env.BARK_URL;
+const title = "CoStrict 验证测试";
+const message = "Bark 通知功能正常工作";
+
+console.log("Testing Bark API directly...\n");
+console.log("BARK_URL:", barkUrl);
+console.log("Title:", title);
+console.log("Message:", message);
+console.log();
+
+if (!barkUrl) {
+  console.log("✗ BARK_URL not configured");
+  process.exit(1);
+}
+
+try {
+  let url = `${barkUrl}/${encodeURIComponent(title)}/${encodeURIComponent(message)}`;
+  url += '?timeout=5';
+  console.log("Sending request to:", url);
+  
+  const response = await fetch(url);
+  
+  console.log("\nResponse status:", response.status);
+  const data = await response.json();
+  console.log("Response data:", JSON.stringify(data, null, 2));
+  console.log("\n✓ Bark notification sent successfully!");
+} catch (error) {
+  console.log("\n✗ Bark notification failed:", error.message);
+  process.exit(1);
+}

package/test/bark-real.test.js

@@ -0,0 +1,83 @@
+import { promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const srcPath = path.join(__dirname, "..", "src", "index.js");
+
+const moduleContent = await fs.readFile(srcPath, "utf-8");
+
+const mockProcess = {
+  env: {
+    BARK_URL: process.env.BARK_URL,
+    NOTIFY_ENABLE_BARK: process.env.NOTIFY_ENABLE_BARK,
+    NOTIFY_ENABLE_SYSTEM: process.env.NOTIFY_ENABLE_SYSTEM,
+  },
+};
+
+const mockImport = async (module) => {
+  return {};
+};
+
+const loadNotifierFunction = new Function(
+  "mockProcess",
+  "mockImport",
+  `
+${moduleContent
+  .replace(/export async function/g, "async function")
+  .replace(/process\.env/g, "mockProcess.env")
+  .replace(/await import\(/g, "await mockImport(")}
+  
+return {
+  BarkNotifier,
+  sendNotification
+};
+`
+);
+
+const { BarkNotifier, sendNotification } = loadNotifierFunction(mockProcess, mockImport);
+
+console.log("Testing Bark notification with real API...\n");
+console.log("Environment variables:");
+console.log("  BARK_URL:", mockProcess.env.BARK_URL);
+console.log("  NOTIFY_ENABLE_BARK:", mockProcess.env.NOTIFY_ENABLE_BARK);
+console.log();
+
+try {
+  const barkNotifier = new BarkNotifier();
+  
+  console.log("Sending test notification via Bark...");
+  console.log("  Title: CoStrict 测试通知");
+  console.log("  Message: 这是一条测试消息");
+  
+  await barkNotifier.notify(
+    "CoStrict 测试通知",
+    "这是一条测试消息",
+    { timeout: 5 }
+  );
+  
+  console.log("\n✓ Bark notification sent successfully!");
+  
+  console.log("\nTesting sendNotification with Bark enabled...");
+  
+  mockProcess.env.NOTIFY_ENABLE_SYSTEM = "false";
+  mockProcess.env.NOTIFY_ENABLE_BARK = "true";
+  
+  const result = await sendNotification(
+    "CoStrict 测试通知 2",
+    "通过 sendNotification 发送",
+    { timeout: 5 }
+  );
+  
+  if (result) {
+    console.log("✓ sendNotification with Bark: Success!");
+  } else {
+    console.log("✗ sendNotification with Bark: Failed");
+    process.exit(1);
+  }
+  
+} catch (error) {
+  console.log("\n✗ Bark notification failed:", error.message);
+  process.exit(1);
+}

package/test/notify.test.js

@@ -0,0 +1,256 @@
+import assert from "node:assert";
+import { promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const srcPath = path.join(__dirname, "..", "src", "index.js");
+
+const moduleContent = await fs.readFile(srcPath, "utf-8");
+
+const exports = {};
+
+const mockProcess = {
+  env: {},
+};
+
+const mockImport = async (module) => {
+  if (module === "node-notifier") {
+    return {
+      notify: (options, callback) => {
+        callback(null, "success");
+      },
+    };
+  }
+  return {};
+};
+
+const loadNotifierFunction = new Function(
+  "mockProcess",
+  "mockImport",
+  `
+${moduleContent
+  .replace(/export async function/g, "async function")
+  .replace(/process\.env/g, "mockProcess.env")
+  .replace(/await import\(/g, "await mockImport(")}
+  
+ return {
+   SystemNotifier,
+   BarkNotifier,
+   WecomNotifier,
+   sendNotification,
+   CoStrictSystemNotifyPlugin
+ };
+
+`
+);
+
+const { SystemNotifier, BarkNotifier, WecomNotifier, sendNotification, CoStrictSystemNotifyPlugin } =
+  loadNotifierFunction(mockProcess, mockImport);
+
+console.log("Running SystemNotifier tests...");
+
+const systemNotifier = new SystemNotifier();
+
+try {
+  await systemNotifier.notify("Test Title", "Test Message");
+  console.log("✓ SystemNotifier.notify: Success");
+} catch (error) {
+  console.log("✗ SystemNotifier.notify: Failed -", error.message);
+  process.exit(1);
+}
+
+console.log("\nRunning BarkNotifier tests...");
+
+mockProcess.env.BARK_URL = "https://api.day.app/test";
+
+const barkNotifier = new BarkNotifier();
+
+try {
+  await barkNotifier.notify("Test Title", "Test Message");
+  console.log("✓ BarkNotifier.notify: Success");
+} catch (error) {
+  console.log("✗ BarkNotifier.notify: Failed -", error.message);
+  process.exit(1);
+}
+
+try {
+  mockProcess.env.BARK_URL = undefined;
+  const barkNotifierNoUrl = new BarkNotifier();
+  await barkNotifierNoUrl.notify("Test Title", "Test Message");
+  console.log("✗ BarkNotifier without URL: Should have thrown error");
+  process.exit(1);
+} catch (error) {
+  if (error.message === "Bark URL not configured") {
+    console.log("✓ BarkNotifier without URL: Correctly throws error");
+  } else {
+    console.log("✗ BarkNotifier without URL: Wrong error -", error.message);
+    process.exit(1);
+  }
+}
+
+console.log("\nRunning WecomNotifier tests...");
+
+mockProcess.env.WECOM_WEBHOOK_URL = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=test";
+
+const wecomNotifier = new WecomNotifier();
+
+try {
+  await wecomNotifier.notify("Test Title", "Test Message");
+  console.log("✓ WecomNotifier.notify (with URL): Success");
+} catch (error) {
+  console.log("✗ WecomNotifier.notify (with URL): Failed -", error.message);
+  process.exit(1);
+}
+
+try {
+  mockProcess.env.WECOM_WEBHOOK_URL = undefined;
+  const wecomNotifierNoUrl = new WecomNotifier();
+  await wecomNotifierNoUrl.notify("Test Title", "Test Message");
+  console.log("✗ WecomNotifier without URL: Should have thrown error");
+  process.exit(1);
+} catch (error) {
+  if (error.message === "Wecom webhook URL or KEY not configured") {
+    console.log("✓ WecomNotifier without URL: Correctly throws error");
+  } else {
+    console.log("✗ WecomNotifier without URL: Wrong error -", error.message);
+    process.exit(1);
+  }
+}
+
+mockProcess.env.WECOM_WEBHOOK_KEY = "test-key-123";
+
+const wecomNotifierWithKey = new WecomNotifier();
+
+try {
+  await wecomNotifierWithKey.notify("Test Title", "Test Message");
+  console.log("✓ WecomNotifier.notify (with KEY): Success");
+} catch (error) {
+  console.log("✗ WecomNotifier.notify (with KEY): Failed -", error.message);
+  process.exit(1);
+}
+
+try {
+  mockProcess.env.WECOM_WEBHOOK_KEY = undefined;
+  const wecomNotifierNoKey = new WecomNotifier();
+  await wecomNotifierNoKey.notify("Test Title", "Test Message");
+  console.log("✗ WecomNotifier without KEY: Should have thrown error");
+  process.exit(1);
+} catch (error) {
+  if (error.message === "Wecom webhook URL or KEY not configured") {
+    console.log("✓ WecomNotifier without KEY: Correctly throws error");
+  } else {
+    console.log("✗ WecomNotifier without KEY: Wrong error -", error.message);
+    process.exit(1);
+  }
+}
+
+console.log("\nRunning sendNotification tests...");
+
+mockProcess.env.NOTIFY_ENABLE_SYSTEM = "true";
+mockProcess.env.NOTIFY_ENABLE_BARK = "false";
+
+try {
+  const result = await sendNotification("Test Title", "Test Message");
+  assert.strictEqual(result, true, "sendNotification should return true");
+  console.log("✓ sendNotification (system only): Success");
+} catch (error) {
+  console.log("✗ sendNotification (system only): Failed -", error.message);
+  process.exit(1);
+}
+
+mockProcess.env.NOTIFY_ENABLE_SYSTEM = "false";
+mockProcess.env.NOTIFY_ENABLE_BARK = "true";
+mockProcess.env.BARK_URL = "https://api.day.app/test";
+
+try {
+  const result = await sendNotification("Test Title", "Test Message");
+  assert.strictEqual(result, true, "sendNotification should return true");
+  console.log("✓ sendNotification (bark only): Success");
+} catch (error) {
+  console.log("✗ sendNotification (bark only): Failed -", error.message);
+  process.exit(1);
+}
+
+mockProcess.env.NOTIFY_ENABLE_SYSTEM = "true";
+mockProcess.env.NOTIFY_ENABLE_BARK = "true";
+
+try {
+  const result = await sendNotification("Test Title", "Test Message");
+  assert.strictEqual(result, true, "sendNotification should return true");
+  console.log("✓ sendNotification (both): Success");
+} catch (error) {
+  console.log("✗ sendNotification (both): Failed -", error.message);
+  process.exit(1);
+}
+
+mockProcess.env.NOTIFY_ENABLE_SYSTEM = "false";
+mockProcess.env.NOTIFY_ENABLE_BARK = "false";
+mockProcess.env.NOTIFY_ENABLE_WECOM = "true";
+mockProcess.env.WECOM_WEBHOOK_KEY = "test-key-123";
+
+try {
+  const result = await sendNotification("Test Title", "Test Message");
+  assert.strictEqual(result, true, "sendNotification should return true");
+  console.log("✓ sendNotification (wecom only): Success");
+} catch (error) {
+  console.log("✗ sendNotification (wecom only): Failed -", error.message);
+  process.exit(1);
+}
+
+mockProcess.env.NOTIFY_ENABLE_SYSTEM = "true";
+mockProcess.env.NOTIFY_ENABLE_BARK = "true";
+mockProcess.env.NOTIFY_ENABLE_WECOM = "true";
+
+try {
+  const result = await sendNotification("Test Title", "Test Message");
+  assert.strictEqual(result, true, "sendNotification should return true");
+  console.log("✓ sendNotification (all): Success");
+} catch (error) {
+  console.log("✗ sendNotification (all): Failed -", error.message);
+  process.exit(1);
+}
+
+console.log("\nRunning CoStrictSystemNotifyPlugin tests...");
+
+mockProcess.env.NOTIFY_ENABLE_SYSTEM = "true";
+
+try {
+  const plugin = await CoStrictSystemNotifyPlugin();
+
+  const testCases = [
+    {
+      type: "permission",
+      data: { message: "Test permission message" },
+      expectedTitle: "需要权限",
+      expectedMessage: "Test permission message",
+    },
+    {
+      type: "question",
+      data: { questions: [{ question: "Test question?" }] },
+      expectedTitle: "问题",
+      expectedMessage: "Test question?",
+    },
+    {
+      type: "idle",
+      data: {},
+      expectedTitle: "会话空闲",
+      expectedMessage: "AI 正在等待您的输入",
+    },
+  ];
+
+  for (const testCase of testCases) {
+    const output = {};
+    await plugin["intervention.required"]({ ...testCase }, output);
+    assert.strictEqual(output.handled, true, "Plugin should handle the event");
+    console.log(
+      `✓ Plugin handles ${testCase.type} event: Success`
+    );
+  }
+} catch (error) {
+  console.log("✗ CoStrictSystemNotifyPlugin: Failed -", error.message);
+  process.exit(1);
+}
+
+console.log("\n✓ All tests passed!");