@freely01/opencode-notify 0.1.0

package/events.ts

@@ -0,0 +1,110 @@
+// Event 类型来自 @opencode-ai/sdk/gen/types.gen.d.ts
+// 但通过 event hook 收到时是 { type: string; properties: any }
+// 这里直接使用 any 避免对 SDK 内部类型的依赖
+import type { Message } from "./message.js"
+import { formatTitle, defaultBody } from "./message.js"
+
+/**
+ * 将 opencode event hook 收到的 Event 映射为内部通知 Message
+ *
+ * 实际事件类型 (from @opencode-ai/sdk gen types):
+ * - "permission.updated"      → 新权限请求
+ * - "permission.replied"      → 权限已回复
+ * - "session.idle"            → 会话空闲（等待输入）
+ * - "session.status"          → 会话状态变化（含 idle/busy/retry）
+ * - "session.error"           → 会话错误
+ * - "session.created"         → 新会话
+ *
+ * @returns Message | null — 不关心的事件返回 null
+ */
+export function route(
+  event: { type: string; properties: Record<string, any> },
+  enabledEvents?: string[],
+): Message | null {
+  const enabled = new Set(enabledEvents ?? [])
+  const { type, properties } = event
+
+  // question.asked — 通用问题询问（权限/确认等均走此事件）
+  // properties 结构待实测确认
+  if (type === "question.asked" && enabled.has("permission_required")) {
+    const text = properties.text ?? properties.message ?? ""
+    return {
+      agent: "opencode",
+      event: "permission_required",
+      sessionID: properties.sessionID ?? "unknown",
+      title: formatTitle("permission_required"),
+      body: text ? `需要确认: ${truncate(text, 200)}` : defaultBody("permission_required"),
+    }
+  }
+
+  // permission.asked — 工具权限请求
+  if (type === "permission.asked" && enabled.has("permission_required")) {
+    // properties: { id, sessionID, permission, patterns, metadata, always, tool }
+    // tool 可能是对象 { name, ... } 或字符串
+    const toolName = typeof properties.tool === "object" && properties.tool
+      ? (properties.tool.name ?? properties.tool.type ?? "")
+      : (properties.tool ?? "")
+    const permission = properties.permission ?? ""
+    const desc = [toolName, permission].filter(Boolean).join(" - ")
+    return {
+      agent: "opencode",
+      event: "permission_required",
+      sessionID: properties.sessionID ?? "unknown",
+      title: formatTitle("permission_required"),
+      body: desc
+        ? `操作「${desc}」需要您的授权许可`
+        : defaultBody("permission_required"),
+    }
+  }
+
+  // 会话错误 → run_failed
+  if (type === "session.error" && enabled.has("run_failed")) {
+    const err = properties.error
+    const errMsg = err?.message ?? err?.name ?? defaultBody("run_failed")
+    return {
+      agent: "opencode",
+      event: "run_failed",
+      sessionID: properties.sessionID ?? "unknown",
+      title: formatTitle("run_failed"),
+      body: `错误: ${truncate(String(errMsg), 200)}`,
+    }
+  }
+
+  // 会话空闲 → input_required
+  if (type === "session.idle" && enabled.has("input_required")) {
+    return {
+      agent: "opencode",
+      event: "input_required",
+      sessionID: properties.sessionID ?? "unknown",
+      title: formatTitle("input_required"),
+      body: defaultBody("input_required"),
+    }
+  }
+
+  // session.status 也可能包含 idle 状态
+  if (type === "session.status" && enabled.has("input_required")) {
+    const status = properties.status
+    if (status?.type === "idle") {
+      return {
+        agent: "opencode",
+        event: "input_required",
+        sessionID: properties.sessionID ?? "unknown",
+        title: formatTitle("input_required"),
+        body: defaultBody("input_required"),
+      }
+    }
+  }
+
+  // 新会话创建 → 可跟踪任务开始
+  // 当前暂不直接通知，留作 run_completed 检测的基础
+  if (type === "session.created") {
+    // 预留: 可在这里记录会话开始时间，用于后续推断任务完成
+    return null
+  }
+
+  return null
+}
+
+function truncate(s: string, maxLen: number): string {
+  return s.length > maxLen ? s.slice(0, maxLen - 3) + "..." : s
+}

package/index.ts

@@ -0,0 +1,137 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import type { PluginConfig } from "./config.js"
+import { resolveConfig, loadYamlConfig, mergeConfig } from "./config.js"
+import { route } from "./events.js"
+import { Dispatcher } from "./dispatcher.js"
+import { FileStore } from "./store.js"
+import { SystemSender } from "./senders/system.js"
+import { ScreenFlashSender } from "./senders/screen-flash.js"
+import { CustomWebhookSender } from "./senders/custom-webhook.js"
+import { WechatWorkSender } from "./senders/wechat-work.js"
+import { FeishuSender } from "./senders/feishu.js"
+import { FilteredSender } from "./senders/types.js"
+import { writeFileSync, mkdirSync, existsSync } from "node:fs"
+import { homedir } from "node:os"
+import { join, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const MARQUEE_SCRIPT = join(__dirname, "scripts", "marquee.py")
+
+const LOG_DIR = join(homedir(), ".opencode-notify")
+const LOG_FILE = join(LOG_DIR, "plugin.log")
+
+let debugEnabled = false
+
+function enableDebug() {
+  debugEnabled = true
+}
+
+function log(msg: string) {
+  if (!debugEnabled) return
+  try {
+    if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true })
+    writeFileSync(LOG_FILE, `[${new Date().toISOString()}] ${msg}\n`, { flag: "a" })
+  } catch {
+    // 日志写入失败不影响主流程
+  }
+}
+
+// 用户活跃事件类型
+const USER_ACTIVITY_EVENTS = new Set([
+  "message.updated",
+  "permission.replied",
+  "question.replied",
+  "command.executed",
+  "tui.command.execute",
+])
+
+const plugin: Plugin = async (_input, options) => {
+  // 加载 YAML 配置 + 合并 plugin options
+  const yamlCfg = loadYamlConfig() ?? {}
+  const merged = mergeConfig(yamlCfg, options as PluginConfig ?? {})
+  const cfg = resolveConfig(merged)
+  if (cfg.debug_log) enableDebug()
+  const store = new FileStore()
+  const senders = buildSenders(cfg)
+  const dispatcher = new Dispatcher(store, cfg.dedupe_seconds ?? 60, senders)
+  // 用户活跃追踪
+  let lastActivity = Date.now()
+  const suppressActive = cfg.suppress_when_active ?? true
+  const activityTimeout = cfg.activity_timeout_ms ?? 30_000
+
+  log(`插件已加载, debug_log=${cfg.debug_log}, events=${JSON.stringify(cfg.events)}, suppressActive=${suppressActive}, timeout=${activityTimeout}ms`)
+
+  return {
+    // event 总线 — 所有事件通过此钩子
+    event: async ({ event }) => {
+      const { type, properties } = event as any
+      const propKeys = properties ? Object.keys(properties).join(",") : ""
+
+      // 调试日志：记录所有事件（随时可关闭）
+      log(`[event] type=${type} keys=${propKeys}`)
+
+      // 用户活跃事件追踪
+      if (USER_ACTIVITY_EVENTS.has(type)) {
+        lastActivity = Date.now()
+        log(`→ 用户活跃事件, 重置活跃时间`)
+      }
+
+      // 活跃抑制检查
+      if (suppressActive) {
+        const idleMs = Date.now() - lastActivity
+        if (idleMs < activityTimeout) {
+          // 用户活跃中，跳过通知
+          return
+        }
+      }
+
+      const msg = route(event, cfg.events)
+      if (msg) {
+        log(`→ 匹配通知: ${msg.event}`)
+        await dispatcher.dispatch(msg)
+      }
+    },
+  }
+}
+
+function addSender(
+  senders: import("./senders/types.js").Sender[],
+  sender: import("./senders/types.js").Sender,
+  events: string[],
+  label: string,
+  extra?: string,
+) {
+  senders.push(new FilteredSender(sender, events))
+  const evt = events.length < 6 ? `events=${JSON.stringify(events)}` : `events=${events.length}个`
+  log(`${label}已启用 (${evt})${extra ? `, ${extra}` : ""}`)
+}
+
+function buildSenders(cfg: PluginConfig) {
+  const senders: import("./senders/types.js").Sender[] = []
+  const globalEvents = cfg.events ?? []
+
+  if (cfg.channels?.system_message?.enabled) {
+    const events = cfg.channels.system_message.events ?? globalEvents
+    addSender(senders, new SystemSender(), events, "系统通知")
+  }
+  if (cfg.channels?.screen_flash?.enabled) {
+    const events = cfg.channels.screen_flash.events ?? globalEvents
+    addSender(senders, new ScreenFlashSender(cfg.channels.screen_flash), events, "屏幕跑马灯")
+  }
+  if (cfg.channels?.custom_webhook?.enabled && cfg.channels.custom_webhook.url) {
+    const events = cfg.channels.custom_webhook.events ?? globalEvents
+    addSender(senders, new CustomWebhookSender(cfg.channels.custom_webhook), events, "自定义 Webhook")
+  }
+  if (cfg.channels?.wechat_work?.enabled && cfg.channels.wechat_work.webhook_url) {
+    const events = cfg.channels.wechat_work.events ?? globalEvents
+    addSender(senders, new WechatWorkSender(cfg.channels.wechat_work), events, "企业微信")
+  }
+  if (cfg.channels?.feishu?.enabled && cfg.channels.feishu.webhook_url) {
+    const events = cfg.channels.feishu.events ?? globalEvents
+    addSender(senders, new FeishuSender(cfg.channels.feishu), events, "飞书")
+  }
+  return senders
+}
+
+export default plugin

package/message.ts

@@ -0,0 +1,50 @@
+/** 内部通知消息 */
+export interface Message {
+  /** 触发事件的 agent 名称 */
+  agent: string
+  /** 通知事件类型 */
+  event: string
+  /** 会话 ID，用于去重 */
+  sessionID: string
+  /** 通知标题 */
+  title: string
+  /** 通知正文 */
+  body: string
+  /** 工作目录 */
+  workspace?: string
+}
+
+/** 事件中文标签映射 */
+const EVENT_LABELS: Record<string, string> = {
+  permission_required: "需要授权",
+  input_required: "等待输入",
+  run_completed: "任务完成",
+  run_failed: "任务失败",
+  session_idle: "会话空闲",
+}
+
+/**
+ * 格式化通知标题
+ */
+export function formatTitle(event: string): string {
+  const label = EVENT_LABELS[event] ?? event
+  return `opencode - ${label}`
+}
+
+/**
+ * 创建默认通知正文
+ */
+export function defaultBody(event: string): string {
+  switch (event) {
+    case "permission_required":
+      return "Agent 需要您的授权许可"
+    case "input_required":
+      return "Agent 正在等待您的输入"
+    case "run_completed":
+      return "任务执行完成"
+    case "run_failed":
+      return "任务执行失败"
+    default:
+      return `事件: ${event}`
+  }
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@freely01/opencode-notify",
+  "version": "0.1.0",
+  "description": "opencode 通知插件 - 监听会话事件并通过多渠道推送通知",
+  "type": "module",
+  "main": "index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./cli": "./cli.ts"
+  },
+  "bin": {
+    "opencode-notify": "cli.ts"
+  },
+  "files": [
+    "*.ts",
+    "senders/",
+    "scripts/marquee.py",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "opencode",
+    "notification",
+    "plugin",
+    "notify"
+  ],
+  "author": "luyanfeng",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/luyanfeng/opencode-notify.git"
+  },
+  "bugs": {
+    "url": "https://github.com/luyanfeng/opencode-notify/issues"
+  },
+  "homepage": "https://github.com/luyanfeng/opencode-notify#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "latest",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.9.1",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.1"
+  }
+}

package/scripts/marquee.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+屏幕四边跑马灯效果 — GTK 透明覆盖层
+
+用法:
+  python3 marquee.py [duration] [speed] [intensity]
+
+参数:
+  duration   持续秒数 (默认 3.0)
+  speed      移动速度因子 (默认 4.0)
+  intensity  不透明度 0.0–1.0 (默认 0.9)
+
+依赖: Python 3 + PyGObject (Ubuntu GNOME 内置)
+"""
+
+import gi
+import sys
+import time
+import signal
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, GLib, Gdk
+import cairo as _cairo
+
+# 跑马灯颜色序列：红 → 橙 → 黄 → 绿 → 蓝
+MARQUEE_COLORS = [
+    (1.0, 0.2, 0.1),
+    (1.0, 0.6, 0.0),
+    (1.0, 1.0, 0.0),
+    (0.0, 1.0, 0.0),
+    (0.0, 0.6, 1.0),
+]
+
+
+class MarqueeWindow(Gtk.Window):
+    def __init__(self, duration=3.0, speed=4.0, intensity=0.9):
+        super().__init__(type=Gtk.WindowType.POPUP)
+        self.set_title("opencode-marquee")
+        self.set_decorated(False)
+        self.set_app_paintable(True)
+        self.set_keep_above(True)
+        self.set_accept_focus(False)
+        self.set_skip_taskbar_hint(True)
+        # 覆盖所有工作区
+        self.stick()
+
+        # 获取主显示器尺寸
+        screen = Gdk.Screen.get_default()
+        display = screen.get_display()
+        monitor = display.get_primary_monitor() if display else screen.get_monitor(0)
+        geo = monitor.get_geometry()
+        self.screen_w = geo.width
+        self.screen_h = geo.height
+        self.set_default_size(self.screen_w, self.screen_h)
+        self.move(geo.x, geo.y)
+
+        self.border_w = 6          # 边框厚度 (px)
+        self.light_w = 28          # 单个灯宽度 (px)
+        self.light_gap = 12        # 灯间距 (px)
+        self.speed = speed
+        self.intensity = min(max(intensity, 0.0), 1.0)
+        self.duration = duration
+        self.start_time = time.monotonic()
+        self.t = 0.0
+
+        # 设置透明背景
+        self._setup_transparency()
+
+        self.connect("realize", self._on_realize)
+        self.connect("draw", self.on_draw)
+        self.connect("screen-changed", self.on_screen_changed)
+
+        # 60fps 动画循环
+        GLib.timeout_add(16, self.on_tick)
+
+    def _setup_transparency(self):
+        """配置 RGBA 透明支持"""
+        visual = self.get_screen().get_rgba_visual()
+        if visual:
+            self.set_visual(visual)
+        else:
+            # 没有 RGBA 支持时回退为整体窗口透明度
+            self.set_opacity(self.intensity)
+
+    def _on_realize(self, widget):
+        """窗口实时化后，设置空的输入区域 → 点击穿透"""
+        surf = _cairo.ImageSurface(_cairo.Format.A1, 1, 1)
+        empty = Gdk.cairo_region_create_from_surface(surf)
+        if empty:
+            widget.input_shape_combine_region(empty)
+
+    def on_screen_changed(self, widget, old_screen):
+        self._setup_transparency()
+
+    def on_draw(self, widget, cr):
+        w = self.screen_w
+        h = self.screen_h
+        bw = self.border_w
+        t = self.t
+        step = self.light_w + self.light_gap
+
+        # 清空为全透明
+        cr.set_source_rgba(0, 0, 0, 0)
+        cr.set_operator(_cairo.Operator.SOURCE)
+        cr.paint()
+        cr.set_operator(_cairo.Operator.OVER)
+
+        # 构造所有灯光的 (x, y, width, height, side_index)
+        lights = []
+
+        # 上边：从左向右
+        offset = (t * self.speed * step) % (w + self.light_w * 2)
+        for i in range(0, w + step, step):
+            x = (i + offset) % (w + self.light_w * 4) - self.light_w * 2
+            lights.append((x, 0, self.light_w, bw, 0))
+
+        # 右边：从上向下
+        offset = (t * self.speed * step) % (h + self.light_w * 2)
+        for i in range(0, h + step, step):
+            y = (i + offset) % (h + self.light_w * 4) - self.light_w * 2
+            lights.append((w - bw, y, bw, self.light_w, 1))
+
+        # 下边：从右向左
+        offset = (t * self.speed * step) % (w + self.light_w * 2)
+        for i in range(0, w + step, step):
+            x = (w + self.light_w * 4 - (i + offset)) % (w + self.light_w * 4) - self.light_w * 2
+            lights.append((x, h - bw, self.light_w, bw, 2))
+
+        # 左边：从下向上
+        offset = (t * self.speed * step) % (h + self.light_w * 2)
+        for i in range(0, h + step, step):
+            y = (h + self.light_w * 4 - (i + offset)) % (h + self.light_w * 4) - self.light_w * 2
+            lights.append((0, y, bw, self.light_w, 3))
+
+        # 绘制灯光
+        nc = len(MARQUEE_COLORS)
+        for idx, (lx, ly, lw, lh, side) in enumerate(lights):
+            r, g, b = MARQUEE_COLORS[(idx + side) % nc]
+            fade = 0.5 + 0.5 * (1.0 - abs(float(idx % 5) / 5.0 - 0.5) * 2)
+            cr.set_source_rgba(r, g, b, fade * self.intensity)
+            cr.rectangle(lx, ly, lw, lh)
+            cr.fill()
+
+        return True
+
+    def on_tick(self):
+        elapsed = time.monotonic() - self.start_time
+        if elapsed >= self.duration:
+            Gtk.main_quit()
+            return False
+        self.t = elapsed
+        self.queue_draw()
+        return True
+
+
+def main():
+    # 解析命令行参数
+    duration = float(sys.argv[1]) if len(sys.argv) > 1 else 3.0
+    speed = float(sys.argv[2]) if len(sys.argv) > 2 else 4.0
+    intensity = float(sys.argv[3]) if len(sys.argv) > 3 else 0.9
+
+    # 检查 DISPLAY
+    import os
+    if not os.environ.get("DISPLAY"):
+        print("marquee: DISPLAY 未设置，跳过", file=sys.stderr)
+        sys.exit(1)
+
+    win = MarqueeWindow(duration=duration, speed=speed, intensity=intensity)
+    win.show_all()
+
+    # 优雅退出
+    signal.signal(signal.SIGINT, lambda s, f: Gtk.main_quit())
+    signal.signal(signal.SIGTERM, lambda s, f: Gtk.main_quit())
+
+    Gtk.main()
+
+
+if __name__ == "__main__":
+    main()

package/senders/custom-webhook.ts

@@ -0,0 +1,87 @@
+import type { Sender } from "./types.js"
+import type { Message } from "../message.js"
+import type { CustomWebhookChannelConfig } from "../config.js"
+
+/**
+ * 自定义 Webhook 发送器
+ *
+ * 支持任意 HTTP Webhook 服务，通过模板配置请求体。
+ * 模板占位符: {{title}} {{body}} {{event}} {{agent}} {{sessionID}}
+ *
+ * Gotify 配置示例:
+ * ```json
+ * {
+ *   "enabled": true,
+ *   "url": "https://gotify.example.com/message",
+ *   "method": "POST",
+ *   "headers": { "X-Gotify-Key": "YOUR_APP_TOKEN" },
+ *   "template": "{\"title\":\"{{title}}\",\"message\":\"{{body}}\",\"priority\":5}"
+ * }
+ * ```
+ */
+export class CustomWebhookSender implements Sender {
+  readonly name = "custom_webhook"
+  private config: CustomWebhookChannelConfig
+
+  constructor(config: CustomWebhookChannelConfig) {
+    this.config = config
+  }
+
+  async send(msg: Message): Promise<void> {
+    const { url, method = "POST", headers = {}, template } = this.config
+
+    if (!url) {
+      throw new Error("custom_webhook: url not configured")
+    }
+
+    // 构造请求体
+    let body: string | undefined
+    if (template) {
+      body = this.interpolate(template, msg)
+    } else {
+      // 默认 JSON 格式
+      body = JSON.stringify({
+        title: msg.title,
+        message: msg.body,
+        event: msg.event,
+        agent: msg.agent,
+      })
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers,
+      },
+      body: method === "POST" ? body : undefined,
+    })
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => "")
+      throw new Error(
+        `custom_webhook returned ${response.status}${text ? `: ${text.slice(0, 500)}` : ""}`,
+      )
+    }
+  }
+
+  /** 模板插值 */
+  private interpolate(tpl: string, msg: Message): string {
+    return tpl
+      .replace(/\{\{title\}\}/g, this.escapeJson(msg.title))
+      .replace(/\{\{body\}\}/g, this.escapeJson(msg.body))
+      .replace(/\{\{event\}\}/g, this.escapeJson(msg.event))
+      .replace(/\{\{agent\}\}/g, this.escapeJson(msg.agent))
+      .replace(/\{\{sessionID\}\}/g, this.escapeJson(msg.sessionID))
+  }
+
+  /** 转义模板值中的特殊字符（防止破坏 JSON） */
+  private escapeJson(s: string): string {
+    return s
+      .replace(/\\/g, "\\\\")
+      .replace(/"/g, '\\"')
+      .replace(/\n/g, "\\n")
+      .replace(/\r/g, "\\r")
+      .replace(/\t/g, "\\t")
+  }
+}

package/senders/feishu.ts

@@ -0,0 +1,79 @@
+import type { Sender } from "./types.js"
+import type { Message } from "../message.js"
+import type { FeishuChannelConfig } from "../config.js"
+
+/**
+ * 飞书 自定义机器人 Webhook 发送器
+ *
+ * 文档: https://open.feishu.cn/document/client-docs/bot-v3/add-custom-bot
+ *
+ * 配置示例:
+ * ```json
+ * {
+ *   "enabled": true,
+ *   "webhook_url": "https://open.feishu.cn/open-apis/bot/v2/hook/xxx"
+ * }
+ * ```
+ *
+ * 消息格式: 卡片消息 (interactive)
+ * 包含标题、正文、分割线、脚注
+ */
+export class FeishuSender implements Sender {
+  readonly name = "feishu"
+  private config: FeishuChannelConfig
+
+  constructor(config: FeishuChannelConfig) {
+    this.config = config
+  }
+
+  async send(msg: Message): Promise<void> {
+    const { webhook_url } = this.config
+
+    if (!webhook_url) {
+      throw new Error("feishu: webhook_url not configured")
+    }
+
+    const body = JSON.stringify({
+      msg_type: "interactive",
+      card: {
+        header: {
+          title: {
+            tag: "plain_text",
+            content: msg.title,
+          },
+        },
+        elements: [
+          {
+            tag: "markdown",
+            content: msg.body,
+          },
+          {
+            tag: "hr",
+          },
+          {
+            tag: "note",
+            elements: [
+              {
+                tag: "plain_text",
+                content: `会话: ${msg.sessionID}`,
+              },
+            ],
+          },
+        ],
+      },
+    })
+
+    const response = await fetch(webhook_url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+    })
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => "")
+      throw new Error(
+        `feishu returned ${response.status}${text ? `: ${text.slice(0, 500)}` : ""}`,
+      )
+    }
+  }
+}