@freely01/opencode-notify 0.4.0 → 0.4.1

package/cli.ts

@@ -105,7 +105,7 @@ function cmdCheck() {
   let hasError = false
 
   for (const [name, ch] of Object.entries(channels)) {
-    if (!ch || !ch.enabled) continue
+    if (!ch || !ch.mode || ch.mode === "none") continue
 
     switch (name) {
       case "system":
@@ -177,23 +177,25 @@ async function cmdTest(channel?: string) {
     allChannels.push([name, enabled, sender])
   }
 
-  add("system_message", !!(channels.system_message?.enabled), async () => {
+  const modeOk = (m: string | undefined): boolean => m !== undefined && m !== "none"
+
+  add("system_message", modeOk(channels.system_message?.mode), async () => {
     await new SystemSender().send(SAMPLE_MSG)
   })
 
-  if (channels.custom_webhook?.enabled && channels.custom_webhook.url) {
+  if (modeOk(channels.custom_webhook?.mode) && channels.custom_webhook?.url) {
     add("custom_webhook", true, async () => {
       await new CustomWebhookSender(channels.custom_webhook!).send(SAMPLE_MSG)
     })
   }
 
-  if (channels.wechat_work?.enabled && channels.wechat_work.webhook_url) {
+  if (modeOk(channels.wechat_work?.mode) && channels.wechat_work?.webhook_url) {
     add("wechat_work", true, async () => {
       await new WechatWorkSender(channels.wechat_work!).send(SAMPLE_MSG)
     })
   }
 
-  if (channels.feishu?.enabled && channels.feishu.webhook_url) {
+  if (modeOk(channels.feishu?.mode) && channels.feishu?.webhook_url) {
     add("feishu", true, async () => {
       await new FeishuSender(channels.feishu!).send(SAMPLE_MSG)
     })
@@ -303,13 +305,13 @@ function cmdInfo() {
     console.log(`\n  🔔 通知渠道:`)
     const channelNames: [string, any, string][] = [
       ["系统消息", ch.system_message, ""],
-      ["屏幕跑马灯", ch.screen_flash, ch.screen_flash?.enabled ? `强度${ch.screen_flash.intensity ?? 0.9}` : ""],
+      ["屏幕跑马灯", ch.screen_flash, ch.screen_flash?.mode !== "none" ? `强度${ch.screen_flash?.intensity ?? 0.9}` : ""],
       ["自定义 Webhook", ch.custom_webhook, ch.custom_webhook?.url ?? ""],
       ["企业微信", ch.wechat_work, ch.wechat_work?.webhook_url ? `${ch.wechat_work.webhook_url.slice(0, 40)}...` : ""],
       ["飞书", ch.feishu, ch.feishu?.webhook_url ? `${ch.feishu.webhook_url.slice(0, 40)}...` : ""],
     ]
     for (const [label, config, url] of channelNames) {
-      if (config?.enabled) {
+      if (config?.mode !== "none") {
         const urlInfo = url ? ` ${url}` : ""
         console.log(`     ✅ ${label}${urlInfo}`)
       } else {

package/config.ts

@@ -1,6 +1,14 @@
+/**
+ * 渠道模式
+ * - "all"         → 即时通知 + 延迟推送都启用
+ * - "delay_only"  → 仅用于延迟推送（不弹即时通知）
+ * - "none"        → 禁用
+ */
+export type ChannelMode = "all" | "delay_only" | "none"
+
 /** 通知渠道配置 */
 export interface ChannelConfig {
-  enabled: boolean
+  mode: ChannelMode
   /**
    * 渠道级事件过滤 — 仅这些事件触发本渠道通知
    * 不填或留空则继承全局 events
@@ -171,9 +179,17 @@ channels:
   #   Linux  - 使用 notify-send (需 libnotify 包，桌面版通常预装)
   #   Windows - 使用 PowerShell New-BurntToastNotification
   #             (需额外安装 BurntToast 模块)
+  #
+  # mode 可选值:
+  #   all         → 启用即时通知（是否延迟推送由下方 remote_delay_channels 独立控制）
+  #   delay_only  → 仅用于远程延迟推送，不弹即时通知
+  #   none        → 禁用
+  #
+  # 纯即时通知（不延迟推送）：mode: all 且不要加入 remote_delay_channels 即可。
+  # 纯延迟推送（不即时通知）：mode: delay_only 并加入 remote_delay_channels。
   # ---------------------------------------------------------------------------
   system_message:
-    enabled: true                    # true=启用, false=禁用
+    mode: all                        # all | delay_only | none
 
   # ---------------------------------------------------------------------------
   # 屏幕跑马灯 (Linux X11 专用)
@@ -184,7 +200,7 @@ channels:
   # 取消下方注释启用：
   # ---------------------------------------------------------------------------
   # screen_flash:
-  #   enabled: true
+  #   mode: all                      # all | delay_only | none
   #   duration: 3.5                  # 持续秒数
   #   speed: 5.0                     # 移动速度因子
   #   intensity: 0.85                # 不透明度 0.0~1.0
@@ -198,7 +214,7 @@ channels:
   # 取消下方注释并填入 webhook_url 启用：
   # ---------------------------------------------------------------------------
   # wechat_work:
-  #   enabled: true
+  #   mode: all                      # all | delay_only | none
   #   webhook_url: "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx"
 
   # ---------------------------------------------------------------------------
@@ -210,7 +226,7 @@ channels:
   # 取消下方注释并填入 webhook_url 启用：
   # ---------------------------------------------------------------------------
   # feishu:
-  #   enabled: true
+  #   mode: all                      # all | delay_only | none
   #   webhook_url: "https://open.feishu.cn/open-apis/bot/v2/hook/xxx"
 
   # ---------------------------------------------------------------------------
@@ -231,7 +247,7 @@ channels:
   # 取消下方注释并配置 url 启用：
   # ---------------------------------------------------------------------------
   # custom_webhook:
-  #   enabled: true
+  #   mode: all                      # all | delay_only | none
   #   url: ""
   #   method: "POST"                  # 请求方法: "POST" | "GET"
   #   headers: {}                     # 自定义请求头
@@ -305,6 +321,12 @@ session_stale_timeout_ms: 600000     # 超时会话自动淘汰（毫秒）
 # 正常通知发出后，如果用户长时间未操作，针对指定渠道额外再推送一次。
 # 用户回到 opencode TUI 操作 → 自动取消所有待发延迟通知。
 #
+# 只影响此列表中的渠道，不在列表中的渠道为"纯即时通知"。
+# 结合 mode 使用：
+#   mode: all         + 在此列表中 → 即时 + 延迟
+#   mode: all         + 不在列表中 → 纯即时（不延迟推送）
+#   mode: delay_only  + 在此列表中 → 纯延迟（不弹即时通知）
+#
 # 适用场景：用户离开电脑后，系统通知可能一闪而过没看到，
 # 延迟推送在用户仍未回来时再次尝试发出。
 #
@@ -383,11 +405,11 @@ export function mergeConfig(base: PluginConfig, overrides: PluginConfig): Plugin
 /** 默认配置 */
 const DEFAULT_CONFIG: Required<Pick<PluginConfig, "suppress_when_active" | "activity_timeout_ms" | "suppress_events_when_active" | "session_stale_timeout_ms" | "remote_delay_seconds" | "remote_delay_max_count">> & PluginConfig = {
   channels: {
-    system_message: { enabled: true },
-    screen_flash: { enabled: false },
-    wechat_work: { enabled: false },
-    feishu: { enabled: false },
-    custom_webhook: { enabled: false },
+    system_message: { mode: "all" },
+    screen_flash: { mode: "none" },
+    wechat_work: { mode: "none" },
+    feishu: { mode: "none" },
+    custom_webhook: { mode: "none" },
   },
   events: [
     "permission_required",
@@ -421,39 +443,39 @@ export function resolveConfig(options: PluginConfig): PluginConfig {
   return {
     channels: {
       system_message: {
-        enabled:
-          options.channels?.system_message?.enabled ??
-          DEFAULT_CONFIG.channels!.system_message!.enabled,
+        mode:
+          options.channels?.system_message?.mode ??
+          DEFAULT_CONFIG.channels!.system_message!.mode,
         events: chEvents(options.channels?.system_message),
       },
       screen_flash: {
-        enabled:
-          options.channels?.screen_flash?.enabled ??
-          DEFAULT_CONFIG.channels!.screen_flash!.enabled,
+        mode:
+          options.channels?.screen_flash?.mode ??
+          DEFAULT_CONFIG.channels!.screen_flash!.mode,
         duration: options.channels?.screen_flash?.duration,
         speed: options.channels?.screen_flash?.speed,
         intensity: options.channels?.screen_flash?.intensity,
         events: chEvents(options.channels?.screen_flash),
       },
       wechat_work: {
-        enabled:
-          options.channels?.wechat_work?.enabled ??
-          DEFAULT_CONFIG.channels!.wechat_work!.enabled,
+        mode:
+          options.channels?.wechat_work?.mode ??
+          DEFAULT_CONFIG.channels!.wechat_work!.mode,
         webhook_url: options.channels?.wechat_work?.webhook_url || undefined,
         events: chEvents(options.channels?.wechat_work),
       },
       feishu: {
-        enabled:
-          options.channels?.feishu?.enabled ??
-          DEFAULT_CONFIG.channels!.feishu!.enabled,
+        mode:
+          options.channels?.feishu?.mode ??
+          DEFAULT_CONFIG.channels!.feishu!.mode,
         webhook_url: options.channels?.feishu?.webhook_url || undefined,
         events: chEvents(options.channels?.feishu),
       },
       custom_webhook: {
-        enabled:
-          options.channels?.custom_webhook?.enabled ??
-          DEFAULT_CONFIG.channels?.custom_webhook?.enabled ??
-          false,
+        mode:
+          options.channels?.custom_webhook?.mode ??
+          DEFAULT_CONFIG.channels?.custom_webhook?.mode ??
+          "none",
         url: options.channels?.custom_webhook?.url || undefined,
         method: options.channels?.custom_webhook?.method ?? "POST",
         headers: options.channels?.custom_webhook?.headers,

package/delayed-dispatcher.ts

@@ -96,6 +96,26 @@ export class DelayedDispatcher {
     }
   }
 
+  /**
+   * 在通知正文追加或替换延迟推送标记
+   *
+   * 清除正文末尾已有的旧标记行，追加最新标记。
+   * 标记格式：
+   *   ─────────────────
+   *   ⚠️ 延迟推送 第2/3次（下次约 15:31:00）
+   */
+  private markDelayBody(body: string, current: number, total: number, delayMs: number): string {
+    // 移除旧标记（从末尾 ─── 分隔线到最后）
+    const clean = body.replace(/\n─{3,}[\s\S]*$/, "")
+    if (current < total) {
+      const next = new Date(Date.now() + delayMs)
+      const t = `${String(next.getHours()).padStart(2, "0")}:${String(next.getMinutes()).padStart(2, "0")}:${String(next.getSeconds()).padStart(2, "0")}`
+      return `${clean}\n─────────────────\n⚠️ 延迟推送 第${current}/${total}次（下次约 ${t}）`
+    }
+    // 最后一次推送，不显示下次时间
+    return `${clean}\n─────────────────\n⚠️ 延迟推送 第${current}/${total}次（最终）`
+  }
+
   /**
    * 调度单次延迟发送
    */
@@ -108,6 +128,10 @@ export class DelayedDispatcher {
     entry.timeoutId = setTimeout(() => {
       entry.timeoutId = null
 
+      // 在正文追加延迟标记（第几次 / 共几次 / 间隔秒数）
+      const sendCount = entry.count + 1  // 1-based
+      msg.body = this.markDelayBody(msg.body, sendCount, this.maxCount, this.delayMs)
+
       // 发送延迟通知
       const sender = this.senders.get(ch)
       if (sender) {

package/index.ts

@@ -2,6 +2,7 @@ import type { Plugin } from "@opencode-ai/plugin"
 import type { PluginConfig } from "./config.js"
 import { resolveConfig, loadYamlConfig, mergeConfig, ensureConfigFile } from "./config.js"
 import { route } from "./events.js"
+import { enrich } from "./message.js"
 import { Dispatcher } from "./dispatcher.js"
 import { FileStore } from "./store.js"
 import { SystemSender } from "./senders/system/index.js"
@@ -85,8 +86,9 @@ const plugin: Plugin = async (_input, options) => {
 
       // 会话生命周期事件
       if (type === "session.created") {
-        tracker.register(sessionID)
-        debug(`→ 会话已创建, 会话=${sessionID}`)
+        const title = properties.info?.title
+        tracker.register(sessionID, title)
+        debug(`→ 会话已创建, 会话=${sessionID}${title ? ` title="${title}"` : ""}`)
       }
       if (type === "session.deleted") {
         tracker.remove(sessionID)
@@ -102,7 +104,11 @@ const plugin: Plugin = async (_input, options) => {
       const msg = route(event, cfg.events)
       if (!msg) return  // 不关心的事件
 
-      debug(`→ 匹配通知: ${msg.event}`)
+      // 注入会话标题（任务描述），增强通知内容
+      const sessionTitle = tracker.getSessionTitle(sessionID)
+      enrich(msg, sessionTitle)
+
+      debug(`→ 匹配通知: ${msg.event}${sessionTitle ? ` sessionTitle="${sessionTitle}"` : ""}`)
 
       // 会话感知抑制判定
       let shouldSuppress = cfg.suppress_when_active && suppressEvents.includes(msg.event)
@@ -121,7 +127,10 @@ const plugin: Plugin = async (_input, options) => {
       }
 
       if (shouldSuppress) {
-        info(`→ 会话 ${sessionID} 活跃中，跳过通知 (${msg.event})`)
+        info(`→ 会话 ${sessionID} 活跃中，跳过即时通知 (${msg.event})`)
+        // 仍调度延迟推送：用户可能在电脑前屏上可见所以抑制，
+        // 但万一用户已离开电脑，延迟推送能在用户未回来时再次提醒
+        delayedDispatcher?.schedule(msg)
         return
       }
 
@@ -140,50 +149,57 @@ interface BuildSendersResult {
   senderMap: Map<string, import("./senders/types.js").Sender>
 }
 
-function addSender(
-  senders: import("./senders/types.js").Sender[],
-  sender: import("./senders/types.js").Sender,
-  events: string[],
-  label: string,
-  extra?: string,
-): import("./senders/types.js").Sender {
-  const filtered = new FilteredSender(sender, events)
-  senders.push(filtered)
-  const evt = events.length < 6 ? `events=${JSON.stringify(events)}` : `events=${events.length}个`
-  info(`${label}已启用 (${evt})${extra ? `, ${extra}` : ""}`)
-  return filtered
-}
-
 function buildSenders(cfg: PluginConfig): BuildSendersResult {
   const senders: import("./senders/types.js").Sender[] = []
   const senderMap = new Map<string, import("./senders/types.js").Sender>()
   const globalEvents = cfg.events ?? []
 
-  if (cfg.channels?.system_message?.enabled) {
-    const events = cfg.channels.system_message.events ?? globalEvents
-    const s = addSender(senders, new SystemSender(), events, "系统通知")
-    senderMap.set("system_message", s)
-  }
-  if (cfg.channels?.screen_flash?.enabled) {
-    const events = cfg.channels.screen_flash.events ?? globalEvents
-    const s = addSender(senders, new ScreenFlashSender(cfg.channels.screen_flash), events, "屏幕跑马灯")
-    senderMap.set("screen_flash", s)
-  }
-  if (cfg.channels?.custom_webhook?.enabled && cfg.channels.custom_webhook.url) {
-    const events = cfg.channels.custom_webhook.events ?? globalEvents
-    const s = addSender(senders, new CustomWebhookSender(cfg.channels.custom_webhook), events, "自定义 Webhook")
-    senderMap.set("custom_webhook", s)
-  }
-  if (cfg.channels?.wechat_work?.enabled && cfg.channels.wechat_work.webhook_url) {
-    const events = cfg.channels.wechat_work.events ?? globalEvents
-    const s = addSender(senders, new WechatWorkSender(cfg.channels.wechat_work), events, "企业微信")
-    senderMap.set("wechat_work", s)
-  }
-  if (cfg.channels?.feishu?.enabled && cfg.channels.feishu.webhook_url) {
-    const events = cfg.channels.feishu.events ?? globalEvents
-    const s = addSender(senders, new FeishuSender(cfg.channels.feishu), events, "飞书")
-    senderMap.set("feishu", s)
+  /**
+   * 注册渠道发送器
+   * @param key      渠道键名
+   * @param mode     渠道模式
+   * @param chEvents 渠道级事件过滤
+   * @param create   创建原始 Sender 的回调
+   * @param label    日志标签
+   */
+  function register(
+    key: string,
+    mode: string | undefined,
+    chEvents: string[] | undefined,
+    create: () => import("./senders/types.js").Sender,
+    label: string,
+  ): void {
+    if (mode === "none" || !mode) return  // 禁用
+
+    const evts = chEvents ?? globalEvents
+    const raw = create()
+    const filtered = new FilteredSender(raw, evts)
+
+    if (mode === "delay_only") {
+      // 仅延迟推送：不进 senders[]，只入 senderMap
+      senderMap.set(key, filtered)
+      info(`${label}已启用 (delay_only, 仅延迟推送)`)
+    } else {
+      // all：即时通知 + 延迟推送
+      senders.push(filtered)
+      senderMap.set(key, filtered)
+      const evtStr = evts.length < 6 ? `events=${JSON.stringify(evts)}` : `events=${evts.length}个`
+      info(`${label}已启用 (${evtStr})`)
+    }
   }
+
+  const ch = cfg.channels
+  register("system_message", ch?.system_message?.mode, ch?.system_message?.events,
+    () => new SystemSender(), "系统通知")
+  register("screen_flash", ch?.screen_flash?.mode, ch?.screen_flash?.events,
+    () => new ScreenFlashSender(ch?.screen_flash!), "屏幕跑马灯")
+  register("custom_webhook", ch?.custom_webhook?.mode, ch?.custom_webhook?.events,
+    () => new CustomWebhookSender(ch?.custom_webhook!), "自定义 Webhook")
+  register("wechat_work", ch?.wechat_work?.mode, ch?.wechat_work?.events,
+    () => new WechatWorkSender(ch?.wechat_work!), "企业微信")
+  register("feishu", ch?.feishu?.mode, ch?.feishu?.events,
+    () => new FeishuSender(ch?.feishu!), "飞书")
+
   return { senders, senderMap }
 }
 

package/message.ts

@@ -28,9 +28,7 @@ const EVENT_LABELS: Record<string, string> = {
  */
 function shortSession(sessionID: string): string {
   if (!sessionID || sessionID === "unknown") return "未知"
-  return sessionID.length > 11
-    ? sessionID.slice(0, 11) + "…"
-    : sessionID
+  return sessionID
 }
 
 /**
@@ -38,12 +36,9 @@ function shortSession(sessionID: string): string {
  * @param event 事件类型
  * @param sessionID 会话 ID（可选，传入后在标题前加会话标签）
  */
-export function formatTitle(event: string, sessionID?: string): string {
+export function formatTitle(event: string, _sessionID?: string): string {
   const label = EVENT_LABELS[event] ?? event
-  const prefix = sessionID && sessionID !== "unknown"
-    ? `[${shortSession(sessionID)}] `
-    : ""
-  return `${prefix}opencode - ${label}`
+  return `opencode - ${label}`
 }
 
 /**
@@ -85,3 +80,29 @@ export function formatBody(msg: Message): string {
     `时间：${time}`,
   ].join("\n")
 }
+
+/** 截断标题到指定长度 */
+function shortTitle(title: string, maxLen = 20): string {
+  if (title.length <= maxLen) return title
+  return title.slice(0, maxLen - 1) + "…"
+}
+
+/**
+ * 增强通知消息：注入会话标题
+ *
+ * - 标题：`[短标题] 事件标签`（替换 `opencode - 事件标签`）
+ * - 正文：追加一行 `任务：完整标题`
+ *
+ * @param msg 原始通知消息
+ * @param sessionTitle 会话标题（用户输入的问题/任务描述），为空则不增强
+ * @returns 增强后的消息（原地修改并返回）
+ */
+export function enrich(msg: Message, sessionTitle?: string): Message {
+  if (!sessionTitle) return msg
+
+  const label = EVENT_LABELS[msg.event] ?? msg.event
+  msg.title = `[${shortTitle(sessionTitle)}] ${label}`
+  // 用"任务"行替换"详情"行（详情的事件细节在会话标题下显得冗余）
+  msg.body = msg.body.replace(/^详情：.*$/m, `任务：${sessionTitle}`)
+  return msg
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freely01/opencode-notify",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "opencode 通知插件 - 监听会话事件并通过多渠道推送通知",
   "type": "module",
   "main": "index.ts",

package/senders/feishu.ts

@@ -47,18 +47,6 @@ export class FeishuSender implements Sender {
             tag: "markdown",
             content: msg.body,
           },
-          {
-            tag: "hr",
-          },
-          {
-            tag: "note",
-            elements: [
-              {
-                tag: "plain_text",
-                content: `会话: ${msg.sessionID}`,
-              },
-            ],
-          },
         ],
       },
     })

package/senders/wechat-work.ts

@@ -33,12 +33,11 @@ export class WechatWorkSender implements Sender {
       throw new Error("wechat_work: webhook_url not configured")
     }
 
-    // 构造 markdown 内容
+    // 构造 markdown 内容（msg.body 已包含事件/会话/详情/时间/延迟标记）
     const content = [
       `**${msg.title}**`,
       "",
       msg.body,
-      `> 会话: ${msg.sessionID}`,
     ].join("\n")
 
     const body = JSON.stringify({

package/session-tracker.ts

@@ -20,6 +20,8 @@ export interface SessionInfo {
   lastActivity: number
   /** 会话创建时间 */
   createdAt: number
+  /** 会话标题（用户输入的问题/任务描述） */
+  title?: string
 }
 
 const CLEANUP_INTERVAL_MS = 5 * 60 * 1000  // 5 分钟
@@ -69,17 +71,26 @@ export class SessionTracker {
   }
 
   /** 注册新会话 */
-  register(sessionID: string): void {
+  register(sessionID: string, title?: string): void {
     if (sessionID === "unknown") return
-    if (!this.sessions.has(sessionID)) {
+    const existing = this.sessions.get(sessionID)
+    if (existing) {
+      if (title) existing.title = title
+    } else {
       this.sessions.set(sessionID, {
         sessionID,
         lastActivity: Date.now(),
         createdAt: Date.now(),
+        title,
       })
     }
   }
 
+  /** 获取会话标题 */
+  getSessionTitle(sessionID: string): string | undefined {
+    return this.sessions.get(sessionID)?.title
+  }
+
   /** 移除会话 */
   remove(sessionID: string): void {
     this.sessions.delete(sessionID)