@nextclaw/channel-runtime 0.4.0 → 0.4.1

package/dist/index.d.ts

@@ -102,6 +102,7 @@ declare class FeishuChannel extends BaseChannel<Config["channels"]["feishu"]> {
     private clients;
     private processedMessageIds;
     private processedSet;
+    private readonly inboundMediaResolver;
     constructor(config: Config["channels"]["feishu"], bus: MessageBus);
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/index.js

@@ -1384,6 +1384,115 @@ import {
   getEnabledFeishuAccounts,
   LarkClient
 } from "@nextclaw/feishu-core";
+
+// src/channels/feishu-inbound-media.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var DEFAULT_FEISHU_MEDIA_MAX_MB = 20;
+function sanitizeAttachmentName2(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "") || "attachment";
+}
+function inferAttachmentExtension(resourceType, mimeType) {
+  const normalizedMime = mimeType?.toLowerCase();
+  if (normalizedMime === "image/jpeg") {
+    return ".jpg";
+  }
+  if (normalizedMime === "image/png") {
+    return ".png";
+  }
+  if (normalizedMime === "image/webp") {
+    return ".webp";
+  }
+  if (normalizedMime === "image/gif") {
+    return ".gif";
+  }
+  if (normalizedMime === "audio/ogg") {
+    return ".ogg";
+  }
+  if (normalizedMime === "audio/mpeg") {
+    return ".mp3";
+  }
+  if (normalizedMime === "application/pdf") {
+    return ".pdf";
+  }
+  if (resourceType === "image") {
+    return ".jpg";
+  }
+  if (resourceType === "audio") {
+    return ".ogg";
+  }
+  if (resourceType === "sticker") {
+    return ".webp";
+  }
+  return ".bin";
+}
+function buildAttachmentFileName(params) {
+  const extension = inferAttachmentExtension(params.resource.type, params.mimeType);
+  const resourceId = sanitizeAttachmentName2(params.resource.fileKey).slice(0, 64);
+  const messageId = sanitizeAttachmentName2(params.messageId).slice(0, 48);
+  const preferredName = params.resource.fileName?.trim() ? sanitizeAttachmentName2(params.resource.fileName.trim()) : `${params.resource.type}${extension}`;
+  const baseName = preferredName.includes(".") ? preferredName : `${preferredName}${extension}`;
+  return `feishu_${messageId}_${resourceId}_${baseName}`;
+}
+function resolveMessageResourceType(resourceType) {
+  return resourceType === "image" ? "image" : "file";
+}
+var FeishuInboundMediaResolver = class {
+  maxBytes;
+  constructor(maxMb) {
+    this.maxBytes = Math.max(1, maxMb ?? DEFAULT_FEISHU_MEDIA_MAX_MB) * 1024 * 1024;
+  }
+  async resolve(params) {
+    const { client, messageId, resource } = params;
+    const mimeType = inferFeishuResourceMimeType(resource.type);
+    const baseAttachment = {
+      id: resource.fileKey,
+      name: resource.fileName,
+      source: "feishu",
+      status: "remote-only",
+      mimeType
+    };
+    if (!messageId?.trim()) {
+      return {
+        ...baseAttachment,
+        errorCode: "invalid_payload"
+      };
+    }
+    try {
+      const downloaded = await client.downloadMessageResource({
+        messageId,
+        fileKey: resource.fileKey,
+        type: resolveMessageResourceType(resource.type)
+      });
+      if (downloaded.buffer.length > this.maxBytes) {
+        return {
+          ...baseAttachment,
+          size: downloaded.buffer.length,
+          errorCode: "too_large"
+        };
+      }
+      const mediaDir = join2(getDataPath(), "media");
+      mkdirSync2(mediaDir, { recursive: true });
+      const fileName = buildAttachmentFileName({ messageId, resource, mimeType });
+      const filePath = join2(mediaDir, fileName);
+      writeFileSync2(filePath, downloaded.buffer);
+      return {
+        ...baseAttachment,
+        name: fileName,
+        path: filePath,
+        size: downloaded.buffer.length,
+        status: "ready"
+      };
+    } catch {
+      return {
+        ...baseAttachment,
+        errorCode: "download_failed"
+      };
+    }
+  }
+};
+
+// src/channels/feishu.ts
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -1392,8 +1501,10 @@ var FeishuChannel = class extends BaseChannel {
   clients = /* @__PURE__ */ new Map();
   processedMessageIds = [];
   processedSet = /* @__PURE__ */ new Set();
+  inboundMediaResolver;
   constructor(config, bus) {
     super(config, bus);
+    this.inboundMediaResolver = new FeishuInboundMediaResolver(this.config.mediaMaxMb);
   }
   async start() {
     const accounts = getEnabledFeishuAccounts(this.config);
@@ -1479,7 +1590,7 @@ var FeishuChannel = class extends BaseChannel {
     if (mentionState.requireMention && !mentionState.wasMentioned) {
       return;
     }
-    const payload = this.buildInboundPayload(account, messageInfo, mentions);
+    const payload = await this.buildInboundPayload(account, messageInfo, mentions);
     if (!payload) {
       return;
     }
@@ -1573,17 +1684,14 @@ var FeishuChannel = class extends BaseChannel {
       requireMention
     };
   }
-  convertResource(resource) {
-    return {
-      id: resource.fileKey,
-      name: resource.fileName,
-      source: "feishu",
-      status: "remote-only",
-      mimeType: inferFeishuResourceMimeType(resource.type),
-      url: resource.fileKey
-    };
+  async convertResource(params) {
+    return this.inboundMediaResolver.resolve({
+      client: params.account.client,
+      messageId: params.messageId,
+      resource: params.resource
+    });
   }
-  buildInboundPayload(account, messageInfo, mentions) {
+  async buildInboundPayload(account, messageInfo, mentions) {
     const converted = convertFeishuMessageContent(
       messageInfo.rawContent,
       messageInfo.msgType,
@@ -1594,13 +1702,22 @@ var FeishuChannel = class extends BaseChannel {
         botName: account.botName
       })
     );
-    const content = converted.content.trim();
-    if (!content) {
+    const content = converted.content.trim() || `[${messageInfo.msgType || "message"}]`;
+    const attachments = await Promise.all(
+      converted.resources.map(
+        (resource) => this.convertResource({
+          account,
+          messageId: messageInfo.messageId,
+          resource
+        })
+      )
+    );
+    if (!content && attachments.length === 0) {
       return null;
     }
     return {
       content,
-      attachments: converted.resources.map((resource) => this.convertResource(resource))
+      attachments
     };
   }
 };
@@ -1608,8 +1725,8 @@ var FeishuChannel = class extends BaseChannel {
 // src/channels/mochat.ts
 import { io } from "socket.io-client";
 import { fetch as fetch3 } from "undici";
-import { join as join2 } from "path";
-import { mkdirSync as mkdirSync2, existsSync, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+import { mkdirSync as mkdirSync3, existsSync, readFileSync, writeFileSync as writeFileSync3 } from "fs";
 var MAX_SEEN_MESSAGE_IDS = 2e3;
 var CURSOR_SAVE_DEBOUNCE_MS = 500;
 var AsyncLock = class {
@@ -1628,8 +1745,8 @@ var MochatChannel = class extends BaseChannel {
   socket = null;
   wsConnected = false;
   wsReady = false;
-  stateDir = join2(getDataPath(), "mochat");
-  cursorPath = join2(this.stateDir, "session_cursors.json");
+  stateDir = join3(getDataPath(), "mochat");
+  cursorPath = join3(this.stateDir, "session_cursors.json");
   sessionCursor = {};
   cursorSaveTimer = null;
   sessionSet = /* @__PURE__ */ new Set();
@@ -1655,7 +1772,7 @@ var MochatChannel = class extends BaseChannel {
     if (!this.config.clawToken) {
       throw new Error("Mochat clawToken not configured");
     }
-    mkdirSync2(this.stateDir, { recursive: true });
+    mkdirSync3(this.stateDir, { recursive: true });
     await this.loadSessionCursors();
     this.seedTargetsFromConfig();
     await this.refreshTargets(false);
@@ -2338,13 +2455,13 @@ var MochatChannel = class extends BaseChannel {
   }
   async saveSessionCursors() {
     try {
-      mkdirSync2(this.stateDir, { recursive: true });
+      mkdirSync3(this.stateDir, { recursive: true });
       const payload = {
         schemaVersion: 1,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         cursors: this.sessionCursor
       };
-      writeFileSync2(this.cursorPath, JSON.stringify(payload, null, 2) + "\n");
+      writeFileSync3(this.cursorPath, JSON.stringify(payload, null, 2) + "\n");
     } catch {
       return;
     }
@@ -3137,8 +3254,8 @@ var GroqTranscriptionProvider = class {
 };
 
 // src/channels/telegram.ts
-import { join as join3 } from "path";
-import { mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+import { mkdirSync as mkdirSync4 } from "fs";
 import {
   isAssistantStreamResetControlMessage,
   isTypingStopControlMessage as isTypingStopControlMessage2,
@@ -3561,8 +3678,8 @@ Just send me a text message to chat!`;
     }
     const { fileId, mediaType, mimeType } = resolveMedia(message);
     if (fileId && mediaType) {
-      const mediaDir = join3(getDataPath(), "media");
-      mkdirSync3(mediaDir, { recursive: true });
+      const mediaDir = join4(getDataPath(), "media");
+      mkdirSync4(mediaDir, { recursive: true });
       const extension = getExtension(mediaType, mimeType);
       const downloaded = await this.bot.downloadFile(fileId, mediaDir);
       const finalPath = extension && !downloaded.endsWith(extension) ? `${downloaded}${extension}` : downloaded;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-runtime",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "private": false,
   "description": "Runtime implementations for NextClaw builtin channel plugins.",
   "type": "module",
@@ -28,7 +28,7 @@
     "undici": "^6.21.0",
     "ws": "^8.18.0",
     "socket.io-msgpack-parser": "^3.0.2",
-    "@nextclaw/core": "0.11.0",
+    "@nextclaw/core": "0.11.1",
     "@nextclaw/feishu-core": "0.2.0"
   },
   "devDependencies": {