@milerliu/feishu 0.1.5

package/src/media.ts

@@ -0,0 +1,515 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { FeishuConfig } from "./types.js";
+import { createFeishuClient } from "./client.js";
+import { resolveReceiveIdType, normalizeFeishuTarget } from "./targets.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { Readable } from "stream";
+
+export type DownloadImageResult = {
+  buffer: Buffer;
+  contentType?: string;
+};
+
+export type DownloadMessageResourceResult = {
+  buffer: Buffer;
+  contentType?: string;
+  fileName?: string;
+};
+
+/**
+ * Download an image from Feishu using image_key.
+ * Used for downloading images sent in messages.
+ */
+export async function downloadImageFeishu(params: {
+  cfg: ClawdbotConfig;
+  imageKey: string;
+}): Promise<DownloadImageResult> {
+  const { cfg, imageKey } = params;
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  if (!feishuCfg) {
+    throw new Error("Feishu channel not configured");
+  }
+
+  const client = createFeishuClient(feishuCfg);
+
+  const response = await client.im.image.get({
+    path: { image_key: imageKey },
+  });
+
+  const responseAny = response as any;
+  if (responseAny.code !== undefined && responseAny.code !== 0) {
+    throw new Error(`Feishu image download failed: ${responseAny.msg || `code ${responseAny.code}`}`);
+  }
+
+  // Handle various response formats from Feishu SDK
+  let buffer: Buffer;
+
+  if (Buffer.isBuffer(response)) {
+    buffer = response;
+  } else if (response instanceof ArrayBuffer) {
+    buffer = Buffer.from(response);
+  } else if (responseAny.data && Buffer.isBuffer(responseAny.data)) {
+    buffer = responseAny.data;
+  } else if (responseAny.data instanceof ArrayBuffer) {
+    buffer = Buffer.from(responseAny.data);
+  } else if (typeof responseAny.getReadableStream === "function") {
+    // SDK provides getReadableStream method
+    const stream = responseAny.getReadableStream();
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    buffer = Buffer.concat(chunks);
+  } else if (typeof responseAny.writeFile === "function") {
+    // SDK provides writeFile method - use a temp file
+    const tmpPath = path.join(os.tmpdir(), `feishu_img_${Date.now()}_${imageKey}`);
+    await responseAny.writeFile(tmpPath);
+    buffer = await fs.promises.readFile(tmpPath);
+    await fs.promises.unlink(tmpPath).catch(() => {}); // cleanup
+  } else if (typeof responseAny[Symbol.asyncIterator] === "function") {
+    // Response is an async iterable
+    const chunks: Buffer[] = [];
+    for await (const chunk of responseAny) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    buffer = Buffer.concat(chunks);
+  } else if (typeof responseAny.read === "function") {
+    // Response is a Readable stream
+    const chunks: Buffer[] = [];
+    for await (const chunk of responseAny as Readable) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    buffer = Buffer.concat(chunks);
+  } else {
+    // Debug: log what we actually received
+    const keys = Object.keys(responseAny);
+    const types = keys.map(k => `${k}: ${typeof responseAny[k]}`).join(", ");
+    throw new Error(
+      `Feishu image download failed: unexpected response format. Keys: [${types}]`,
+    );
+  }
+
+  return { buffer };
+}
+
+/**
+ * Download a message resource (file/image/audio/video) from Feishu.
+ * Used for downloading files, audio, and video from messages.
+ */
+export async function downloadMessageResourceFeishu(params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  fileKey: string;
+  type: "image" | "file";
+}): Promise<DownloadMessageResourceResult> {
+  const { cfg, messageId, fileKey, type } = params;
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  if (!feishuCfg) {
+    throw new Error("Feishu channel not configured");
+  }
+
+  const client = createFeishuClient(feishuCfg);
+
+  const response = await client.im.messageResource.get({
+    path: { message_id: messageId, file_key: fileKey },
+    params: { type },
+  });
+
+  const responseAny = response as any;
+  if (responseAny.code !== undefined && responseAny.code !== 0) {
+    throw new Error(
+      `Feishu message resource download failed: ${responseAny.msg || `code ${responseAny.code}`}`,
+    );
+  }
+
+  // Handle various response formats from Feishu SDK
+  let buffer: Buffer;
+
+  if (Buffer.isBuffer(response)) {
+    buffer = response;
+  } else if (response instanceof ArrayBuffer) {
+    buffer = Buffer.from(response);
+  } else if (responseAny.data && Buffer.isBuffer(responseAny.data)) {
+    buffer = responseAny.data;
+  } else if (responseAny.data instanceof ArrayBuffer) {
+    buffer = Buffer.from(responseAny.data);
+  } else if (typeof responseAny.getReadableStream === "function") {
+    // SDK provides getReadableStream method
+    const stream = responseAny.getReadableStream();
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    buffer = Buffer.concat(chunks);
+  } else if (typeof responseAny.writeFile === "function") {
+    // SDK provides writeFile method - use a temp file
+    const tmpPath = path.join(os.tmpdir(), `feishu_${Date.now()}_${fileKey}`);
+    await responseAny.writeFile(tmpPath);
+    buffer = await fs.promises.readFile(tmpPath);
+    await fs.promises.unlink(tmpPath).catch(() => {}); // cleanup
+  } else if (typeof responseAny[Symbol.asyncIterator] === "function") {
+    // Response is an async iterable
+    const chunks: Buffer[] = [];
+    for await (const chunk of responseAny) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    buffer = Buffer.concat(chunks);
+  } else if (typeof responseAny.read === "function") {
+    // Response is a Readable stream
+    const chunks: Buffer[] = [];
+    for await (const chunk of responseAny as Readable) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    buffer = Buffer.concat(chunks);
+  } else {
+    // Debug: log what we actually received
+    const keys = Object.keys(responseAny);
+    const types = keys.map(k => `${k}: ${typeof responseAny[k]}`).join(", ");
+    throw new Error(
+      `Feishu message resource download failed: unexpected response format. Keys: [${types}]`,
+    );
+  }
+
+  return { buffer };
+}
+
+export type UploadImageResult = {
+  imageKey: string;
+};
+
+export type UploadFileResult = {
+  fileKey: string;
+};
+
+export type SendMediaResult = {
+  messageId: string;
+  chatId: string;
+};
+
+/**
+ * Upload an image to Feishu and get an image_key for sending.
+ * Supports: JPEG, PNG, WEBP, GIF, TIFF, BMP, ICO
+ */
+export async function uploadImageFeishu(params: {
+  cfg: ClawdbotConfig;
+  image: Buffer | string; // Buffer or file path
+  imageType?: "message" | "avatar";
+}): Promise<UploadImageResult> {
+  const { cfg, image, imageType = "message" } = params;
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  if (!feishuCfg) {
+    throw new Error("Feishu channel not configured");
+  }
+
+  const client = createFeishuClient(feishuCfg);
+
+  // SDK expects a Readable stream, not a Buffer
+  // Use type assertion since SDK actually accepts any Readable at runtime
+  const imageStream =
+    typeof image === "string" ? fs.createReadStream(image) : Readable.from(image);
+
+  const response = await client.im.image.create({
+    data: {
+      image_type: imageType,
+      image: imageStream as any,
+    },
+  });
+
+  // SDK v1.30+ returns data directly without code wrapper on success
+  // On error, it throws or returns { code, msg }
+  const responseAny = response as any;
+  if (responseAny.code !== undefined && responseAny.code !== 0) {
+    throw new Error(`Feishu image upload failed: ${responseAny.msg || `code ${responseAny.code}`}`);
+  }
+
+  const imageKey = responseAny.image_key ?? responseAny.data?.image_key;
+  if (!imageKey) {
+    throw new Error("Feishu image upload failed: no image_key returned");
+  }
+
+  return { imageKey };
+}
+
+/**
+ * Upload a file to Feishu and get a file_key for sending.
+ * Max file size: 30MB
+ */
+export async function uploadFileFeishu(params: {
+  cfg: ClawdbotConfig;
+  file: Buffer | string; // Buffer or file path
+  fileName: string;
+  fileType: "opus" | "mp4" | "pdf" | "doc" | "xls" | "ppt" | "stream";
+  duration?: number; // Required for audio/video files, in milliseconds
+}): Promise<UploadFileResult> {
+  const { cfg, file, fileName, fileType, duration } = params;
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  if (!feishuCfg) {
+    throw new Error("Feishu channel not configured");
+  }
+
+  const client = createFeishuClient(feishuCfg);
+
+  // SDK expects a Readable stream, not a Buffer
+  // Use type assertion since SDK actually accepts any Readable at runtime
+  const fileStream =
+    typeof file === "string" ? fs.createReadStream(file) : Readable.from(file);
+
+  const response = await client.im.file.create({
+    data: {
+      file_type: fileType,
+      file_name: fileName,
+      file: fileStream as any,
+      ...(duration !== undefined && { duration }),
+    },
+  });
+
+  // SDK v1.30+ returns data directly without code wrapper on success
+  const responseAny = response as any;
+  if (responseAny.code !== undefined && responseAny.code !== 0) {
+    throw new Error(`Feishu file upload failed: ${responseAny.msg || `code ${responseAny.code}`}`);
+  }
+
+  const fileKey = responseAny.file_key ?? responseAny.data?.file_key;
+  if (!fileKey) {
+    throw new Error("Feishu file upload failed: no file_key returned");
+  }
+
+  return { fileKey };
+}
+
+/**
+ * Send an image message using an image_key
+ */
+export async function sendImageFeishu(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  imageKey: string;
+  replyToMessageId?: string;
+}): Promise<SendMediaResult> {
+  const { cfg, to, imageKey, replyToMessageId } = params;
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  if (!feishuCfg) {
+    throw new Error("Feishu channel not configured");
+  }
+
+  const client = createFeishuClient(feishuCfg);
+  const receiveId = normalizeFeishuTarget(to);
+  if (!receiveId) {
+    throw new Error(`Invalid Feishu target: ${to}`);
+  }
+
+  const receiveIdType = resolveReceiveIdType(receiveId);
+  const content = JSON.stringify({ image_key: imageKey });
+
+  if (replyToMessageId) {
+    const response = await client.im.message.reply({
+      path: { message_id: replyToMessageId },
+      data: {
+        content,
+        msg_type: "image",
+      },
+    });
+
+    if (response.code !== 0) {
+      throw new Error(`Feishu image reply failed: ${response.msg || `code ${response.code}`}`);
+    }
+
+    return {
+      messageId: response.data?.message_id ?? "unknown",
+      chatId: receiveId,
+    };
+  }
+
+  const response = await client.im.message.create({
+    params: { receive_id_type: receiveIdType },
+    data: {
+      receive_id: receiveId,
+      content,
+      msg_type: "image",
+    },
+  });
+
+  if (response.code !== 0) {
+    throw new Error(`Feishu image send failed: ${response.msg || `code ${response.code}`}`);
+  }
+
+  return {
+    messageId: response.data?.message_id ?? "unknown",
+    chatId: receiveId,
+  };
+}
+
+/**
+ * Send a file message using a file_key
+ */
+export async function sendFileFeishu(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  fileKey: string;
+  replyToMessageId?: string;
+}): Promise<SendMediaResult> {
+  const { cfg, to, fileKey, replyToMessageId } = params;
+  const feishuCfg = cfg.channels?.feishu as FeishuConfig | undefined;
+  if (!feishuCfg) {
+    throw new Error("Feishu channel not configured");
+  }
+
+  const client = createFeishuClient(feishuCfg);
+  const receiveId = normalizeFeishuTarget(to);
+  if (!receiveId) {
+    throw new Error(`Invalid Feishu target: ${to}`);
+  }
+
+  const receiveIdType = resolveReceiveIdType(receiveId);
+  const content = JSON.stringify({ file_key: fileKey });
+
+  if (replyToMessageId) {
+    const response = await client.im.message.reply({
+      path: { message_id: replyToMessageId },
+      data: {
+        content,
+        msg_type: "file",
+      },
+    });
+
+    if (response.code !== 0) {
+      throw new Error(`Feishu file reply failed: ${response.msg || `code ${response.code}`}`);
+    }
+
+    return {
+      messageId: response.data?.message_id ?? "unknown",
+      chatId: receiveId,
+    };
+  }
+
+  const response = await client.im.message.create({
+    params: { receive_id_type: receiveIdType },
+    data: {
+      receive_id: receiveId,
+      content,
+      msg_type: "file",
+    },
+  });
+
+  if (response.code !== 0) {
+    throw new Error(`Feishu file send failed: ${response.msg || `code ${response.code}`}`);
+  }
+
+  return {
+    messageId: response.data?.message_id ?? "unknown",
+    chatId: receiveId,
+  };
+}
+
+/**
+ * Helper to detect file type from extension
+ */
+export function detectFileType(
+  fileName: string,
+): "opus" | "mp4" | "pdf" | "doc" | "xls" | "ppt" | "stream" {
+  const ext = path.extname(fileName).toLowerCase();
+  switch (ext) {
+    case ".opus":
+    case ".ogg":
+      return "opus";
+    case ".mp4":
+    case ".mov":
+    case ".avi":
+      return "mp4";
+    case ".pdf":
+      return "pdf";
+    case ".doc":
+    case ".docx":
+      return "doc";
+    case ".xls":
+    case ".xlsx":
+      return "xls";
+    case ".ppt":
+    case ".pptx":
+      return "ppt";
+    default:
+      return "stream";
+  }
+}
+
+/**
+ * Check if a string is a local file path (not a URL)
+ */
+function isLocalPath(urlOrPath: string): boolean {
+  // Starts with / or ~ or drive letter (Windows)
+  if (urlOrPath.startsWith("/") || urlOrPath.startsWith("~") || /^[a-zA-Z]:/.test(urlOrPath)) {
+    return true;
+  }
+  // Try to parse as URL - if it fails or has no protocol, it's likely a local path
+  try {
+    const url = new URL(urlOrPath);
+    return url.protocol === "file:";
+  } catch {
+    return true; // Not a valid URL, treat as local path
+  }
+}
+
+/**
+ * Upload and send media (image or file) from URL, local path, or buffer
+ */
+export async function sendMediaFeishu(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  mediaUrl?: string;
+  mediaBuffer?: Buffer;
+  fileName?: string;
+  replyToMessageId?: string;
+}): Promise<SendMediaResult> {
+  const { cfg, to, mediaUrl, mediaBuffer, fileName, replyToMessageId } = params;
+
+  let buffer: Buffer;
+  let name: string;
+
+  if (mediaBuffer) {
+    buffer = mediaBuffer;
+    name = fileName ?? "file";
+  } else if (mediaUrl) {
+    if (isLocalPath(mediaUrl)) {
+      // Local file path - read directly
+      const filePath = mediaUrl.startsWith("~")
+        ? mediaUrl.replace("~", process.env.HOME ?? "")
+        : mediaUrl.replace("file://", "");
+
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Local file not found: ${filePath}`);
+      }
+      buffer = fs.readFileSync(filePath);
+      name = fileName ?? path.basename(filePath);
+    } else {
+      // Remote URL - fetch
+      const response = await fetch(mediaUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch media from URL: ${response.status}`);
+      }
+      buffer = Buffer.from(await response.arrayBuffer());
+      name = fileName ?? (path.basename(new URL(mediaUrl).pathname) || "file");
+    }
+  } else {
+    throw new Error("Either mediaUrl or mediaBuffer must be provided");
+  }
+
+  // Determine if it's an image based on extension
+  const ext = path.extname(name).toLowerCase();
+  const isImage = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".ico", ".tiff"].includes(ext);
+
+  if (isImage) {
+    const { imageKey } = await uploadImageFeishu({ cfg, image: buffer });
+    return sendImageFeishu({ cfg, to, imageKey, replyToMessageId });
+  } else {
+    const fileType = detectFileType(name);
+    const { fileKey } = await uploadFileFeishu({
+      cfg,
+      file: buffer,
+      fileName: name,
+      fileType,
+    });
+    return sendFileFeishu({ cfg, to, fileKey, replyToMessageId });
+  }
+}

package/src/mention.ts

@@ -0,0 +1,121 @@
+import type { FeishuMessageEvent } from "./bot.js";
+
+/**
+ * Mention target user info
+ */
+export type MentionTarget = {
+  openId: string;
+  name: string;
+  key: string; // Placeholder in original message, e.g. @_user_1
+};
+
+/**
+ * Extract mention targets from message event (excluding the bot itself)
+ */
+export function extractMentionTargets(
+  event: FeishuMessageEvent,
+  botOpenId?: string,
+): MentionTarget[] {
+  const mentions = event.message.mentions ?? [];
+
+  return mentions
+    .filter((m) => {
+      // Exclude the bot itself
+      if (botOpenId && m.id.open_id === botOpenId) return false;
+      // Must have open_id
+      return !!m.id.open_id;
+    })
+    .map((m) => ({
+      openId: m.id.open_id!,
+      name: m.name,
+      key: m.key,
+    }));
+}
+
+/**
+ * Check if message is a mention forward request
+ * Rules:
+ * - Group: message mentions bot + at least one other user
+ * - DM: message mentions any user (no need to mention bot)
+ */
+export function isMentionForwardRequest(
+  event: FeishuMessageEvent,
+  botOpenId?: string,
+): boolean {
+  const mentions = event.message.mentions ?? [];
+  if (mentions.length === 0) return false;
+
+  const isDirectMessage = event.message.chat_type === "p2p";
+  const hasOtherMention = mentions.some((m) => m.id.open_id !== botOpenId);
+
+  if (isDirectMessage) {
+    // DM: trigger if any non-bot user is mentioned
+    return hasOtherMention;
+  } else {
+    // Group: need to mention both bot and other users
+    const hasBotMention = mentions.some((m) => m.id.open_id === botOpenId);
+    return hasBotMention && hasOtherMention;
+  }
+}
+
+/**
+ * Extract message body from text (remove @ placeholders)
+ */
+export function extractMessageBody(text: string, allMentionKeys: string[]): string {
+  let result = text;
+
+  // Remove all @ placeholders
+  for (const key of allMentionKeys) {
+    result = result.replace(new RegExp(key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), "");
+  }
+
+  return result.replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Format @mention for text message
+ */
+export function formatMentionForText(target: MentionTarget): string {
+  return `<at user_id="${target.openId}">${target.name}</at>`;
+}
+
+/**
+ * Format @everyone for text message
+ */
+export function formatMentionAllForText(): string {
+  return `<at user_id="all">Everyone</at>`;
+}
+
+/**
+ * Format @mention for card message (lark_md)
+ */
+export function formatMentionForCard(target: MentionTarget): string {
+  return `<at id=${target.openId}></at>`;
+}
+
+/**
+ * Format @everyone for card message
+ */
+export function formatMentionAllForCard(): string {
+  return `<at id=all></at>`;
+}
+
+/**
+ * Build complete message with @mentions (text format)
+ */
+export function buildMentionedMessage(targets: MentionTarget[], message: string): string {
+  if (targets.length === 0) return message;
+
+  const mentionParts = targets.map((t) => formatMentionForText(t));
+  return `${mentionParts.join(" ")} ${message}`;
+}
+
+/**
+ * Build card content with @mentions (Markdown format)
+ */
+export function buildMentionedCardContent(targets: MentionTarget[], message: string): string {
+  if (targets.length === 0) return message;
+
+  const mentionParts = targets.map((t) => formatMentionForCard(t));
+  return `${mentionParts.join(" ")} ${message}`;
+}