moltbot-channel-feishu 0.0.8

package/src/api/media.ts

@@ -0,0 +1,335 @@
+/**
+ * Media upload and sending operations.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import type { Config } from "../config/schema.js";
+import type {
+  UploadImageParams,
+  UploadFileParams,
+  SendMediaParams,
+  SendResult,
+  ImageUploadResult,
+  FileUploadResult,
+  FileType,
+  SendImageParams,
+  SendFileParams,
+} from "../types/index.js";
+import { getApiClient } from "./client.js";
+import { normalizeTarget, resolveReceiveIdType } from "./messages.js";
+
+// ============================================================================
+// File Type Detection
+// ============================================================================
+
+/**
+ * Detect file type from extension for upload.
+ */
+export function detectFileType(fileName: string): FileType {
+  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 extension indicates an image.
+ */
+function isImageExtension(fileName: string): boolean {
+  const ext = path.extname(fileName).toLowerCase();
+  return [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".ico", ".tiff"].includes(ext);
+}
+
+/**
+ * Check if a string is a local file path (not a URL).
+ */
+function isLocalPath(urlOrPath: string): boolean {
+  if (urlOrPath.startsWith("/") || urlOrPath.startsWith("~")) {
+    return true;
+  }
+  if (/^[a-zA-Z]:/.test(urlOrPath)) {
+    return true; // Windows drive letter
+  }
+  try {
+    const url = new URL(urlOrPath);
+    return url.protocol === "file:";
+  } catch {
+    return true; // Not a valid URL, treat as local path
+  }
+}
+
+// ============================================================================
+// Upload Operations
+// ============================================================================
+
+interface UploadImageResponse {
+  code?: number;
+  msg?: string;
+  image_key?: string;
+  data?: { image_key?: string };
+}
+
+/**
+ * Upload an image to Feishu.
+ * Supports JPEG, PNG, WEBP, GIF, TIFF, BMP, ICO.
+ *
+ * @throws Error if upload fails
+ */
+export async function uploadImage(
+  config: Config,
+  params: UploadImageParams
+): Promise<ImageUploadResult> {
+  const client = getApiClient(config);
+  const imageType = params.imageType ?? "message";
+
+  // Create readable stream from input
+  const imageStream =
+    typeof params.image === "string"
+      ? fs.createReadStream(params.image)
+      : Readable.from(params.image);
+
+  const response = (await client.im.image.create({
+    data: {
+      image_type: imageType,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      image: imageStream as any,
+    },
+  })) as UploadImageResponse;
+
+  if (response.code !== undefined && response.code !== 0) {
+    throw new Error(`Image upload failed: ${response.msg ?? `code ${response.code}`}`);
+  }
+
+  const imageKey = response.image_key ?? response.data?.image_key;
+  if (!imageKey) {
+    throw new Error("Image upload failed: no image_key returned");
+  }
+
+  return { imageKey };
+}
+
+interface UploadFileResponse {
+  code?: number;
+  msg?: string;
+  file_key?: string;
+  data?: { file_key?: string };
+}
+
+/**
+ * Upload a file to Feishu.
+ * Max file size: 30MB.
+ *
+ * @throws Error if upload fails
+ */
+export async function uploadFile(
+  config: Config,
+  params: UploadFileParams
+): Promise<FileUploadResult> {
+  const client = getApiClient(config);
+
+  // Create readable stream from input
+  const fileStream =
+    typeof params.file === "string" ? fs.createReadStream(params.file) : Readable.from(params.file);
+
+  const response = (await client.im.file.create({
+    data: {
+      file_type: params.fileType,
+      file_name: params.fileName,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      file: fileStream as any,
+      ...(params.duration !== undefined ? { duration: params.duration } : {}),
+    },
+  })) as UploadFileResponse;
+
+  if (response.code !== undefined && response.code !== 0) {
+    throw new Error(`File upload failed: ${response.msg ?? `code ${response.code}`}`);
+  }
+
+  const fileKey = response.file_key ?? response.data?.file_key;
+  if (!fileKey) {
+    throw new Error("File upload failed: no file_key returned");
+  }
+
+  return { fileKey };
+}
+
+// ============================================================================
+// Media Sending
+// ============================================================================
+
+interface SendMediaResponse {
+  code?: number;
+  msg?: string;
+  data?: { message_id?: string };
+}
+
+/**
+ * Send an image message using an image_key.
+ *
+ * @throws Error if target is invalid or send fails
+ */
+export async function sendImage(config: Config, params: SendImageParams): Promise<SendResult> {
+  const client = getApiClient(config);
+  const receiveId = normalizeTarget(params.to);
+
+  if (!receiveId) {
+    throw new Error(`Invalid target: ${params.to}`);
+  }
+
+  const receiveIdType = resolveReceiveIdType(receiveId);
+  const content = JSON.stringify({ image_key: params.imageKey });
+
+  if (params.replyToMessageId) {
+    const response = (await client.im.message.reply({
+      path: { message_id: params.replyToMessageId },
+      data: { content, msg_type: "image" },
+    })) as SendMediaResponse;
+
+    if (response.code !== 0) {
+      throw new Error(`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" },
+  })) as SendMediaResponse;
+
+  if (response.code !== 0) {
+    throw new Error(`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.
+ *
+ * @throws Error if target is invalid or send fails
+ */
+export async function sendFile(config: Config, params: SendFileParams): Promise<SendResult> {
+  const client = getApiClient(config);
+  const receiveId = normalizeTarget(params.to);
+
+  if (!receiveId) {
+    throw new Error(`Invalid target: ${params.to}`);
+  }
+
+  const receiveIdType = resolveReceiveIdType(receiveId);
+  const content = JSON.stringify({ file_key: params.fileKey });
+
+  if (params.replyToMessageId) {
+    const response = (await client.im.message.reply({
+      path: { message_id: params.replyToMessageId },
+      data: { content, msg_type: "file" },
+    })) as SendMediaResponse;
+
+    if (response.code !== 0) {
+      throw new Error(`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" },
+  })) as SendMediaResponse;
+
+  if (response.code !== 0) {
+    throw new Error(`File send failed: ${response.msg ?? `code ${response.code}`}`);
+  }
+
+  return {
+    messageId: response.data?.message_id ?? "unknown",
+    chatId: receiveId,
+  };
+}
+
+/**
+ * Upload and send media (image or file) from URL, local path, or buffer.
+ *
+ * @throws Error if no media source provided or upload/send fails
+ */
+export async function sendMedia(config: Config, params: SendMediaParams): Promise<SendResult> {
+  let buffer: Buffer;
+  let name: string;
+
+  if (params.mediaBuffer) {
+    buffer = params.mediaBuffer;
+    name = params.fileName ?? "file";
+  } else if (params.mediaUrl) {
+    if (isLocalPath(params.mediaUrl)) {
+      // Local file path
+      const filePath = params.mediaUrl.startsWith("~")
+        ? params.mediaUrl.replace("~", process.env["HOME"] ?? "")
+        : params.mediaUrl.replace("file://", "");
+
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Local file not found: ${filePath}`);
+      }
+      buffer = fs.readFileSync(filePath);
+      name = params.fileName ?? path.basename(filePath);
+    } else {
+      // Remote URL
+      const response = await fetch(params.mediaUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch media from URL: ${response.status}`);
+      }
+      buffer = Buffer.from(await response.arrayBuffer());
+      name = params.fileName ?? (path.basename(new URL(params.mediaUrl).pathname) || "file");
+    }
+  } else {
+    throw new Error("Either mediaUrl or mediaBuffer must be provided");
+  }
+
+  // Determine if it's an image and upload accordingly
+  if (isImageExtension(name)) {
+    const { imageKey } = await uploadImage(config, { image: buffer });
+    return sendImage(config, {
+      to: params.to,
+      imageKey,
+      replyToMessageId: params.replyToMessageId,
+    });
+  } else {
+    const fileType = detectFileType(name);
+    const { fileKey } = await uploadFile(config, {
+      file: buffer,
+      fileName: name,
+      fileType,
+    });
+    return sendFile(config, { to: params.to, fileKey, replyToMessageId: params.replyToMessageId });
+  }
+}

package/src/api/messages.ts

@@ -0,0 +1,290 @@
+/**
+ * Message sending and retrieval operations.
+ */
+
+import type { Config } from "../config/schema.js";
+import type {
+  SendTextParams,
+  SendCardParams,
+  EditMessageParams,
+  SendResult,
+  MessageInfo,
+  ReceiveIdType,
+} from "../types/index.js";
+import { getApiClient } from "./client.js";
+
+// ============================================================================
+// Target Resolution
+// ============================================================================
+
+/**
+ * Normalize a target string to a receive_id.
+ * Handles prefixed formats like "user:xxx" or "chat:xxx".
+ */
+export function normalizeTarget(target: string): string | null {
+  const trimmed = target.trim();
+  if (!trimmed) return null;
+
+  // Handle prefixed formats
+  if (trimmed.startsWith("user:")) {
+    return trimmed.slice(5).trim() || null;
+  }
+  if (trimmed.startsWith("chat:")) {
+    return trimmed.slice(5).trim() || null;
+  }
+
+  // Return as-is if no prefix
+  return trimmed;
+}
+
+/**
+ * Determine the receive_id_type based on ID format.
+ */
+export function resolveReceiveIdType(receiveId: string): ReceiveIdType {
+  if (receiveId.startsWith("oc_")) return "chat_id";
+  if (receiveId.startsWith("ou_")) return "open_id";
+  if (receiveId.startsWith("on_")) return "union_id";
+  // Default to open_id for DMs
+  return "open_id";
+}
+
+/**
+ * Check if a string looks like a Feishu ID.
+ */
+export function isValidId(id: string): boolean {
+  const trimmed = id.trim();
+  return (
+    trimmed.startsWith("oc_") ||
+    trimmed.startsWith("ou_") ||
+    trimmed.startsWith("on_") ||
+    trimmed.startsWith("u_") ||
+    trimmed.length > 10
+  );
+}
+
+// ============================================================================
+// Message Retrieval
+// ============================================================================
+
+interface GetMessageResponse {
+  code?: number;
+  msg?: string;
+  data?: {
+    items?: {
+      message_id?: string;
+      chat_id?: string;
+      msg_type?: string;
+      body?: { content?: string };
+      sender?: {
+        id?: string;
+        id_type?: string;
+        sender_type?: string;
+      };
+      create_time?: string;
+    }[];
+  };
+}
+
+/**
+ * Get a message by ID.
+ * Returns null if message not found or access denied.
+ */
+export async function getMessage(config: Config, messageId: string): Promise<MessageInfo | null> {
+  const client = getApiClient(config);
+
+  try {
+    const response = (await client.im.message.get({
+      path: { message_id: messageId },
+    })) as GetMessageResponse;
+
+    if (response.code !== 0) {
+      return null;
+    }
+
+    const item = response.data?.items?.[0];
+    if (!item) {
+      return null;
+    }
+
+    // Parse content based on message type
+    let content = item.body?.content ?? "";
+    try {
+      const parsed: unknown = JSON.parse(content);
+      if (
+        item.msg_type === "text" &&
+        typeof parsed === "object" &&
+        parsed !== null &&
+        "text" in parsed
+      ) {
+        content = String((parsed as { text: unknown }).text);
+      }
+    } catch {
+      // Keep raw content if parsing fails
+    }
+
+    return {
+      messageId: item.message_id ?? messageId,
+      chatId: item.chat_id ?? "",
+      senderId: item.sender?.id,
+      senderOpenId: item.sender?.id_type === "open_id" ? item.sender?.id : undefined,
+      content,
+      contentType: item.msg_type ?? "text",
+      createTime: item.create_time ? parseInt(item.create_time, 10) : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ============================================================================
+// Message Sending
+// ============================================================================
+
+interface SendMessageResponse {
+  code?: number;
+  msg?: string;
+  data?: {
+    message_id?: string;
+  };
+}
+
+/**
+ * Send a text message.
+ *
+ * @throws Error if target is invalid or send fails
+ */
+export async function sendTextMessage(config: Config, params: SendTextParams): Promise<SendResult> {
+  const client = getApiClient(config);
+  const receiveId = normalizeTarget(params.to);
+
+  if (!receiveId) {
+    throw new Error(`Invalid target: ${params.to}`);
+  }
+
+  const receiveIdType = resolveReceiveIdType(receiveId);
+  const content = JSON.stringify({ text: params.text });
+
+  // Reply to existing message
+  if (params.replyToMessageId) {
+    const response = (await client.im.message.reply({
+      path: { message_id: params.replyToMessageId },
+      data: { content, msg_type: "text" },
+    })) as SendMessageResponse;
+
+    if (response.code !== 0) {
+      throw new Error(`Reply failed: ${response.msg ?? `code ${response.code}`}`);
+    }
+
+    return {
+      messageId: response.data?.message_id ?? "unknown",
+      chatId: receiveId,
+    };
+  }
+
+  // Create new message
+  const response = (await client.im.message.create({
+    params: { receive_id_type: receiveIdType },
+    data: { receive_id: receiveId, content, msg_type: "text" },
+  })) as SendMessageResponse;
+
+  if (response.code !== 0) {
+    throw new Error(`Send failed: ${response.msg ?? `code ${response.code}`}`);
+  }
+
+  return {
+    messageId: response.data?.message_id ?? "unknown",
+    chatId: receiveId,
+  };
+}
+
+/**
+ * Send an interactive card message.
+ *
+ * @throws Error if target is invalid or send fails
+ */
+export async function sendCardMessage(config: Config, params: SendCardParams): Promise<SendResult> {
+  const client = getApiClient(config);
+  const receiveId = normalizeTarget(params.to);
+
+  if (!receiveId) {
+    throw new Error(`Invalid target: ${params.to}`);
+  }
+
+  const receiveIdType = resolveReceiveIdType(receiveId);
+  const content = JSON.stringify(params.card);
+
+  // Reply with card
+  if (params.replyToMessageId) {
+    const response = (await client.im.message.reply({
+      path: { message_id: params.replyToMessageId },
+      data: { content, msg_type: "interactive" },
+    })) as SendMessageResponse;
+
+    if (response.code !== 0) {
+      throw new Error(`Card reply failed: ${response.msg ?? `code ${response.code}`}`);
+    }
+
+    return {
+      messageId: response.data?.message_id ?? "unknown",
+      chatId: receiveId,
+    };
+  }
+
+  // Create card message
+  const response = (await client.im.message.create({
+    params: { receive_id_type: receiveIdType },
+    data: { receive_id: receiveId, content, msg_type: "interactive" },
+  })) as SendMessageResponse;
+
+  if (response.code !== 0) {
+    throw new Error(`Card send failed: ${response.msg ?? `code ${response.code}`}`);
+  }
+
+  return {
+    messageId: response.data?.message_id ?? "unknown",
+    chatId: receiveId,
+  };
+}
+
+/**
+ * Update an interactive card message.
+ *
+ * @throws Error if update fails
+ */
+export async function updateCard(
+  config: Config,
+  messageId: string,
+  card: Record<string, unknown>
+): Promise<void> {
+  const client = getApiClient(config);
+  const content = JSON.stringify(card);
+
+  const response = (await client.im.message.patch({
+    path: { message_id: messageId },
+    data: { content },
+  })) as SendMessageResponse;
+
+  if (response.code !== 0) {
+    throw new Error(`Card update failed: ${response.msg ?? `code ${response.code}`}`);
+  }
+}
+
+/**
+ * Edit an existing text message.
+ * Note: Feishu only allows editing messages within 24 hours.
+ *
+ * @throws Error if edit fails
+ */
+export async function editMessage(config: Config, params: EditMessageParams): Promise<void> {
+  const client = getApiClient(config);
+  const content = JSON.stringify({ text: params.text });
+
+  const response = (await client.im.message.update({
+    path: { message_id: params.messageId },
+    data: { msg_type: "text", content },
+  })) as SendMessageResponse;
+
+  if (response.code !== 0) {
+    throw new Error(`Edit failed: ${response.msg ?? `code ${response.code}`}`);
+  }
+}