@trydying/opencode-feishu-notifier 0.3.1 → 0.3.2

package/src/feishu/client.ts

@@ -0,0 +1,202 @@
+import type { FeishuConfig } from "../config"
+
+type TenantTokenResponse = {
+  code: number
+  msg: string
+  tenant_access_token?: string
+  expire?: number
+}
+
+interface TokenCacheEntry {
+  token: string
+  expiresAt: number // timestamp in milliseconds
+}
+
+const tokenCache = new Map<string, TokenCacheEntry>()
+
+function clearTokenCache(config: FeishuConfig) {
+  const cacheKey = `${config.appId}:${config.appSecret}`
+  tokenCache.delete(cacheKey)
+}
+
+function isTokenExpiredError(code: number): boolean {
+  // Common Feishu token expiration error codes
+  return code === 99991663 || code === 99991664 || code === 99991668
+}
+
+type MessageResponse = {
+  code: number
+  msg: string
+  data?: {
+    message_id?: string
+  }
+}
+
+type FeishuPostContent = {
+  post: {
+    zh_cn: {
+      title: string
+      content: Array<Array<{
+        tag: string
+        text?: string
+        href?: string
+        un_escape?: boolean
+      }>>
+    }
+  }
+}
+
+function ensureFetch(): typeof fetch {
+  if (typeof fetch === "undefined") {
+    throw new Error("Global fetch is not available. Use Node.js 18+.")
+  }
+
+  return fetch
+}
+
+async function readJson<T>(response: Response): Promise<T> {
+  const text = await response.text()
+  if (!text) {
+    throw new Error(`Empty response from Feishu API (${response.status}).`)
+  }
+
+  return JSON.parse(text) as T
+}
+
+export async function getTenantAccessToken(config: FeishuConfig): Promise<string> {
+  const cacheKey = `${config.appId}:${config.appSecret}`
+  const now = Date.now()
+  
+  // Check cache
+  const cached = tokenCache.get(cacheKey)
+  if (cached && cached.expiresAt > now + 60000) { // 60 second buffer
+    return cached.token
+  }
+  
+  const fetchImpl = ensureFetch()
+  const response = await fetchImpl(
+    "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal",
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        app_id: config.appId,
+        app_secret: config.appSecret
+      })
+    }
+  )
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => `Failed to read error response`)
+    throw new Error(`Feishu auth request failed: ${response.status} - ${errorText}`)
+  }
+
+  const payload = await readJson<TenantTokenResponse>(response)
+  if (payload.code !== 0 || !payload.tenant_access_token) {
+    throw new Error(`Feishu auth failed: ${payload.msg} (${payload.code})`)
+  }
+
+  // Cache token with expiration (default 2 hours if not provided)
+  const expiresIn = payload.expire ? payload.expire * 1000 : 2 * 60 * 60 * 1000
+  const expiresAt = now + expiresIn - 60000 // 60 second buffer
+  
+  tokenCache.set(cacheKey, {
+    token: payload.tenant_access_token,
+    expiresAt
+  })
+  
+  return payload.tenant_access_token
+}
+
+async function sendMessage(
+  config: FeishuConfig,
+  msgType: "text" | "post",
+  content: unknown
+): Promise<MessageResponse> {
+  const fetchImpl = ensureFetch()
+  
+  const sendWithToken = async (retryOnTokenExpired = true): Promise<MessageResponse> => {
+    const token = await getTenantAccessToken(config)
+    const response = await fetchImpl(
+      `https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=${config.receiverType}`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          receive_id: config.receiverId,
+          msg_type: msgType,
+          content: JSON.stringify(content)
+        })
+      }
+    )
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => `Failed to read error response`)
+      throw new Error(`Feishu message request failed: ${response.status} - ${errorText}`)
+    }
+
+    const payload = await readJson<MessageResponse>(response)
+    if (payload.code !== 0) {
+      // Check if token expired
+      if (retryOnTokenExpired && isTokenExpiredError(payload.code)) {
+        clearTokenCache(config)
+        return sendWithToken(false) // Retry once
+      }
+      throw new Error(`Feishu message failed: ${payload.msg} (${payload.code}) - Response: ${JSON.stringify(payload)}`)
+    }
+
+    return payload
+  }
+  
+  return sendWithToken()
+}
+
+export async function sendTextMessage(
+  config: FeishuConfig,
+  text: string
+): Promise<MessageResponse> {
+  return sendMessage(config, "text", { text })
+}
+
+/**
+ * 将纯文本转换为飞书富文本（post）格式
+ * 简化实现：所有文本作为一个段落
+ */
+function textToPostContent(text: string, title: string = "OpenCode 通知"): FeishuPostContent {
+  // 移除空行，但保留换行符
+  const cleanedText = text.split('\n').filter(line => line.trim().length > 0).join('\n')
+  
+  const content = [
+    [
+      {
+        tag: 'text',
+        text: cleanedText,
+        un_escape: true
+      }
+    ]
+  ]
+  
+  return {
+    post: {
+      zh_cn: {
+        title,
+        content
+      }
+    }
+  }
+}
+
+export async function sendRichTextMessage(
+  config: FeishuConfig,
+  text: string,
+  title?: string,
+  richContent?: FeishuPostContent
+): Promise<MessageResponse> {
+  const postContent = richContent || textToPostContent(text, title)
+  return sendMessage(config, "post", postContent)
+}

package/src/feishu/messages.ts

@@ -0,0 +1,322 @@
+import os from "os";
+
+export type FeishuPostContent = {
+  post: {
+    zh_cn: {
+      title: string
+      content: Array<Array<{
+        tag: string
+        text?: string
+        href?: string
+        un_escape?: boolean
+      }>>
+    }
+  }
+}
+
+export type NotificationResult = {
+  title: string
+  text: string
+  richContent?: FeishuPostContent
+}
+
+export type NotificationType =
+  | "interaction_required"
+  | "permission_required"
+  | "command_args_required"
+  | "confirmation_required"
+  | "session_idle"
+  | "question_asked"
+  | "setup_test"
+
+type EventPayload = {
+  type?: string;
+  payload?: unknown;
+  properties?: Record<string, unknown>;
+}
+
+type SessionContext = {
+  sessionID?: string;
+  sessionTitle?: string;
+  agentName?: string;
+};
+
+type SessionClient = {
+  session?: {
+    get?: (options: { path: { id: string } }) => Promise<{
+      data?: {
+        title?: string;
+      };
+    }>;
+  };
+};
+
+const sessionTitleCache = new Map<string, string>();
+const sessionAgentCache = new Map<string, string>();
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  if (value && typeof value === "object") {
+    return value as Record<string, unknown>;
+  }
+  return undefined;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function extractEventPayload(event?: EventPayload): unknown {
+  if (!event) {
+    return undefined;
+  }
+  if (event.payload !== undefined) {
+    return event.payload;
+  }
+  if (event.properties !== undefined) {
+    return event.properties;
+  }
+  return undefined;
+}
+
+function extractEventProperties(event?: EventPayload): Record<string, unknown> | undefined {
+  if (!event) {
+    return undefined;
+  }
+  if (event.properties) {
+    return asRecord(event.properties);
+  }
+  if (event.payload) {
+    return asRecord(event.payload);
+  }
+  return undefined;
+}
+
+function extractSessionContext(event?: EventPayload): SessionContext {
+  const properties = extractEventProperties(event);
+  const info = asRecord(properties?.info);
+  const part = asRecord(properties?.part);
+
+  const sessionID =
+    readString(properties?.sessionID) ??
+    readString(info?.sessionID) ??
+    readString(info?.id) ??
+    readString(part?.sessionID);
+
+  const sessionTitle = readString(info?.title);
+
+  const agentName =
+    readString(properties?.agent) ??
+    readString(info?.agent) ??
+    readString(part?.agent) ??
+    readString(part?.name);
+
+  return {
+    sessionID,
+    sessionTitle,
+    agentName,
+  };
+}
+
+async function resolveSessionContext(
+  event?: EventPayload,
+  client?: SessionClient
+): Promise<SessionContext> {
+  const baseContext = extractSessionContext(event);
+  if (!baseContext.sessionID) {
+    return baseContext;
+  }
+
+  const cachedTitle = sessionTitleCache.get(baseContext.sessionID);
+  const cachedAgent = sessionAgentCache.get(baseContext.sessionID);
+  const mergedContext = {
+    ...baseContext,
+    sessionTitle: baseContext.sessionTitle ?? cachedTitle,
+    agentName: baseContext.agentName ?? cachedAgent,
+  };
+
+  if (mergedContext.sessionTitle) {
+    return mergedContext;
+  }
+
+  if (client?.session?.get) {
+    try {
+      const response = await client.session.get({
+        path: { id: baseContext.sessionID },
+      });
+      const title = response?.data?.title;
+      if (title) {
+        sessionTitleCache.set(baseContext.sessionID, title);
+        return {
+          ...mergedContext,
+          sessionTitle: title,
+        };
+      }
+    } catch {
+      // 忽略会话信息获取失败
+    }
+  }
+
+  return mergedContext;
+}
+
+export function recordEventContext(event?: EventPayload): void {
+  const context = extractSessionContext(event);
+  if (!context.sessionID) {
+    return;
+  }
+
+  if (context.sessionTitle) {
+    sessionTitleCache.set(context.sessionID, context.sessionTitle);
+  }
+
+  if (context.agentName) {
+    sessionAgentCache.set(context.sessionID, context.agentName);
+  }
+}
+
+// 保持向后兼容的标题映射
+const titles: Record<NotificationType, string> = {
+  interaction_required: "需要交互",
+  permission_required: "需要权限确认",
+  command_args_required: "需要补充参数",
+  confirmation_required: "需要确认",
+  session_idle: "OpenCode 闲暇",
+  question_asked: "需要选择方案",
+  setup_test: "Feishu 通知测试"
+}
+
+/**
+ * 构建结构化通知消息（新版本）
+ * @param type 通知类型
+ * @param event 事件数据
+ * @param directory 工作目录（可选，默认当前目录）
+ * @returns 包含标题和文本的消息对象
+ */
+export async function buildStructuredNotification(
+  type: NotificationType,
+  event?: EventPayload,
+  directory?: string,
+  client?: SessionClient
+): Promise<NotificationResult> {
+  // 导入模板系统
+  const { buildStructuredMessage } = await import("./templates")
+
+  const eventPayload = extractEventPayload(event);
+  const sessionContext = await resolveSessionContext(event, client);
+  
+  try {
+    const text = await buildStructuredMessage(
+      type,
+      eventPayload,
+      event?.type,
+      directory,
+      sessionContext
+    )
+    
+    // 返回标题（保持向后兼容）
+    return {
+      title: titles[type],
+      text,
+      richContent: textToPostContent(text, titles[type])
+    }
+  } catch (error) {
+    // 如果模板系统失败，回退到原始实现
+    return buildLegacyNotification(type, event)
+  }
+}
+
+/**
+ * 构建传统格式的通知消息（向后兼容）
+ */
+export function buildLegacyNotification(
+  type: NotificationType,
+  event?: EventPayload
+): NotificationResult {
+  const title = titles[type]
+  if (type === "setup_test") {
+    const text = `${title}\nFeishu 通知已启用。`
+    return {
+      title,
+      text,
+      richContent: textToPostContent(text, title)
+    }
+  }
+
+  const payloadText = formatPayload(extractEventPayload(event))
+  const sessionContext = extractSessionContext(event)
+  const lines = [
+    `[OpenCode] ${title}`,
+    event?.type ? `事件类型: ${event.type}` : "",
+    sessionContext.sessionTitle || sessionContext.sessionID
+      ? `会话: ${sessionContext.sessionTitle ?? sessionContext.sessionID}`
+      : "",
+    sessionContext.agentName ? `Agent: ${sessionContext.agentName}` : "",
+    `主机: ${os.hostname()}`,
+    payloadText ? `详情: ${payloadText}` : ""
+  ].filter(Boolean)
+
+  const text = lines.join("\n")
+  return {
+    title,
+    text,
+    richContent: textToPostContent(text, title)
+  }
+}
+
+/**
+ * 格式化负载文本
+ */
+function formatPayload(payload: unknown): string {
+  if (!payload) {
+    return ""
+  }
+
+  const text = JSON.stringify(payload, null, 2)
+  if (text.length > 1200) {
+    return `${text.slice(0, 1200)}…`
+  }
+
+  return text
+}
+
+/**
+ * 将纯文本转换为飞书富文本（post）格式
+ * 简化实现：所有文本作为一个段落
+ */
+function textToPostContent(text: string, title: string = "OpenCode 通知"): FeishuPostContent {
+  // 移除空行，但保留换行符
+  const cleanedText = text.split('\n').filter(line => line.trim().length > 0).join('\n')
+  
+  const content = [
+    [
+      {
+        tag: 'text',
+        text: cleanedText,
+        un_escape: true
+      }
+    ]
+  ]
+  
+  return {
+    post: {
+      zh_cn: {
+        title,
+        content
+      }
+    }
+  }
+}
+
+/**
+ * 构建通知消息（主入口，保持向后兼容）
+ * 默认使用结构化消息，失败时回退
+ */
+export async function buildNotification(
+  type: NotificationType,
+  event?: EventPayload,
+  directory?: string,
+  client?: SessionClient
+): Promise<NotificationResult> {
+  // 默认使用结构化消息
+  return buildStructuredNotification(type, event, directory, client)
+}