@meet-im/meet-bot-jssdk 0.0.6 → 1.0.0

package/dist/index.cjs

@@ -1,5 +1,11 @@
 'use strict';
 
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
 // @meet/meet-bot-jssdk - MeetIM Chatbot JavaScript SDK
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -92,7 +98,9 @@ var HTTP = {
   /** 请求超时时间（毫秒），默认 60000ms */
   DEFAULT_TIMEOUT: 6e4,
   /** 长轮询额外超时缓冲时间（毫秒），默认 10000ms */
-  POLLING_TIMEOUT_BUFFER: 1e4
+  POLLING_TIMEOUT_BUFFER: 1e4,
+  /** 上传超时时间（毫秒），默认 1 小时 */
+  UPLOAD_TIMEOUT: 3600 * 1e3
 };
 var API = {
   /** getUpdates 默认超时时间（秒），默认 30（long polling） */
@@ -100,6 +108,64 @@ var API = {
   /** getUpdates 默认拉取条数，默认 100 条 */
   DEFAULT_LIMIT: 100
 };
+var UPLOAD = {
+  /** 分片上传阈值，>= 5MB 使用分片上传 */
+  MULTIPART_THRESHOLD: 5 * 1024 * 1024,
+  /** 分片上传最大重试次数 */
+  MAX_RETRY_COUNT: 3,
+  /** 分片上传重试间隔（毫秒） */
+  RETRY_DELAY: 1e3,
+  /** 最大并发上传数 */
+  MAX_CONCURRENCY: 4
+};
+var CHUNK_RULES = [
+  { maxSize: 1 * 1024 * 1024, chunks: 1 },
+  // < 1MB: 1 片
+  { maxSize: 20 * 1024 * 1024, chunks: 5 },
+  // 1-20MB: 5 片
+  { maxSize: 100 * 1024 * 1024, chunks: 20 },
+  // 20-100MB: 20 片
+  { maxSize: Infinity, chunks: 50 }
+  // > 100MB: 50 片
+];
+var SESSION_TYPE = {
+  PRIVATE: 1,
+  GROUP: 3,
+  CHANNEL: 4
+};
+function getChunkNum(size) {
+  for (const rule of CHUNK_RULES) {
+    if (size < rule.maxSize) {
+      return rule.chunks;
+    }
+  }
+  return 50;
+}
+function getConvID(firstID, secondID, sessionType, companyID = 1) {
+  let convID;
+  if (sessionType === SESSION_TYPE.PRIVATE) {
+    const min = Math.min(firstID, secondID);
+    const max = Math.max(firstID, secondID);
+    convID = `${min}:${max}`;
+    if (companyID > 1) {
+      convID += `:${companyID}`;
+    }
+  } else if (sessionType === SESSION_TYPE.GROUP) {
+    convID = `${firstID}+${secondID}`;
+    if (companyID > 1) {
+      convID += `+${companyID}`;
+    }
+  } else {
+    convID = `${firstID}_${secondID}`;
+    if (companyID > 1) {
+      convID += `_${companyID}`;
+    }
+  }
+  return convID;
+}
+function getQuoteMsgKey(convID, seqID) {
+  return `${convID}:${seqID}`;
+}
 
 // src/utils/logger.ts
 var Logger = class {
@@ -175,7 +241,19 @@ async function request(options) {
       responseHeaders[key] = value;
     });
     logger.info("[Response Status]", response.status);
-    const data = await response.json();
+    const contentType = response.headers.get("content-type") || "";
+    const responseText = await response.text();
+    if (!contentType.includes("application/json")) {
+      logger.error("[Response] Non-JSON response:", responseText.substring(0, 500));
+      throw new exports.NetworkError(`Server returned non-JSON response (status ${response.status})`, void 0);
+    }
+    let data;
+    try {
+      data = JSON.parse(responseText);
+    } catch {
+      logger.error("[Response] Failed to parse JSON:", responseText.substring(0, 500));
+      throw new exports.NetworkError("Failed to parse server response", void 0);
+    }
     logger.info("[Response Body]", JSON.stringify(data));
     if (!response.ok || !data.ok) {
       const errorData = data;
@@ -220,6 +298,255 @@ function mapStatusCodeToErrorCode(status) {
   }
 }
 
+// src/api/file.ts
+async function getUploadURL(params) {
+  const { token, baseUrl, ...body } = params;
+  return request({
+    token,
+    baseUrl,
+    method: "POST",
+    path: "getUploadURL",
+    body: {
+      originFileName: body.originFileName,
+      contentType: body.contentType,
+      md5: body.md5,
+      size: body.size,
+      fullImage: body.fullImage,
+      videoLength: body.videoLength,
+      bestDomain: body.bestDomain,
+      uploadId: body.uploadId,
+      chunkNum: body.chunkNum
+    },
+    timeout: HTTP.UPLOAD_TIMEOUT
+  });
+}
+async function getMultiPartUploadURL(params) {
+  const { token, baseUrl, ...body } = params;
+  return request({
+    token,
+    baseUrl,
+    method: "POST",
+    path: "getMultiPartUploadURL",
+    body: {
+      originFileName: body.originFileName,
+      contentType: body.contentType,
+      md5: body.md5,
+      size: body.size,
+      fullImage: body.fullImage,
+      videoLength: body.videoLength,
+      bestDomain: body.bestDomain
+    },
+    timeout: HTTP.UPLOAD_TIMEOUT
+  });
+}
+async function completeMultipartUpload(params) {
+  const { token, baseUrl, ...body } = params;
+  return request({
+    token,
+    baseUrl,
+    method: "POST",
+    path: "completeMultipartUpload",
+    body: {
+      originFileName: body.originFileName,
+      md5: body.md5,
+      UploadParts: body.UploadParts
+    },
+    timeout: HTTP.UPLOAD_TIMEOUT
+  });
+}
+async function getAccessURL(params) {
+  const { token, baseUrl, ...queryParams } = params;
+  return request({
+    token,
+    baseUrl,
+    method: "GET",
+    path: "getAccessURL",
+    params: {
+      firstId: queryParams.firstId,
+      secondId: queryParams.secondId,
+      sessionType: queryParams.sessionType,
+      seqId: queryParams.seqId,
+      fileId: queryParams.fileId,
+      companyId: queryParams.companyId,
+      "x-oss-process": queryParams["x-oss-process"],
+      printResult: queryParams.printResult ?? "1"
+    }
+  });
+}
+async function computeMD5(buffer) {
+  return crypto__default.default.createHash("md5").update(buffer).digest("hex");
+}
+async function uploadToOSS(signedUrl, buffer, contentType, callback, onProgress) {
+  const startTime = Date.now();
+  const total = buffer.length;
+  const response = await fetch(signedUrl, {
+    method: "PUT",
+    headers: {
+      "Content-Type": contentType,
+      "X-Oss-Callback": callback
+    },
+    body: buffer
+  });
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    logger.error(`OSS upload failed: ${response.status} ${response.statusText}`);
+    logger.error(`OSS error body: ${errorBody}`);
+    throw new Error(`OSS upload failed: ${response.status} - ${errorBody}`);
+  }
+  const responseText = await response.text();
+  logger.info(`[uploadToOSS] OSS response status: ${response.status}`);
+  logger.info(`[uploadToOSS] OSS response: ${responseText}`);
+  let result;
+  try {
+    const parsed = JSON.parse(responseText);
+    result = {
+      id: parsed.id || parsed.ID || 0,
+      path: parsed.path || "",
+      size: parsed.size || 0
+    };
+  } catch {
+    const idMatch = responseText.match(/<id>(\d+)<\/id>/i);
+    const pathMatch = responseText.match(/<path>([^<]*)<\/path>/i);
+    const sizeMatch = responseText.match(/<size>(\d+)<\/size>/i);
+    result = {
+      id: idMatch?.[1] ? parseInt(idMatch[1], 10) : 0,
+      path: pathMatch?.[1] || "",
+      size: sizeMatch?.[1] ? parseInt(sizeMatch[1], 10) : 0
+    };
+  }
+  if (onProgress) {
+    const seconds = Math.round((Date.now() - startTime) / 1e3) || 1;
+    const speedPerSecond = formatSpeed(total / seconds);
+    onProgress({
+      percent: "100%",
+      loaded: total,
+      total,
+      speedPerSecond,
+      percentRate: 1
+    });
+  }
+  return result;
+}
+function formatSpeed(bytesPerSecond) {
+  if (bytesPerSecond < 1024) {
+    return `${bytesPerSecond.toFixed(0)}B/s`;
+  } else if (bytesPerSecond < 1024 * 1024) {
+    return `${(bytesPerSecond / 1024).toFixed(2)}KB/s`;
+  } else {
+    return `${(bytesPerSecond / 1024 / 1024).toFixed(2)}MB/s`;
+  }
+}
+async function uploadFile(token, buffer, options, baseUrl) {
+  const { fileName, contentType, onProgress } = options;
+  const size = buffer.length;
+  const md5 = await computeMD5(buffer);
+  logger.info(`[uploadFile] Starting upload: ${fileName}, size: ${size}, md5: ${md5}`);
+  if (size < UPLOAD.MULTIPART_THRESHOLD) {
+    return uploadSingleFile(token, buffer, fileName, contentType, md5, baseUrl, onProgress);
+  } else {
+    return uploadMultipartFile(token, buffer, fileName, contentType, md5, baseUrl, onProgress);
+  }
+}
+async function uploadSingleFile(token, buffer, fileName, contentType, md5, baseUrl, onProgress) {
+  const result = await getUploadURL({
+    token,
+    baseUrl,
+    originFileName: fileName,
+    contentType,
+    md5,
+    size: buffer.length
+  });
+  if (result.id > 0 && !result.signedUrl) {
+    logger.info(`[uploadFile] Instant upload (MD5 match): ${result.id}`);
+    return { fileID: result.id, path: result.path, size: result.size };
+  }
+  const ossResult = await uploadToOSS(result.signedUrl, buffer, contentType, result.callback || "", onProgress);
+  return { fileID: ossResult.id, path: ossResult.path, size: ossResult.size };
+}
+async function uploadMultipartFile(token, buffer, fileName, contentType, md5, baseUrl, onProgress) {
+  const size = buffer.length;
+  const chunkNum = getChunkNum(size);
+  logger.info(`[uploadMultipartFile] Starting multipart upload: ${chunkNum} chunks`);
+  const result = await getMultiPartUploadURL({
+    token,
+    baseUrl,
+    originFileName: fileName,
+    contentType,
+    md5,
+    size
+  });
+  if (result.ID && result.ID > 0) {
+    logger.info(`[uploadMultipartFile] Instant upload (MD5 match): ${result.ID}`);
+    return { fileID: result.ID, path: result.path, size: result.size };
+  }
+  const uploadParts = [];
+  const chunkSize = Math.ceil(size / chunkNum);
+  const startTime = Date.now();
+  let totalUploaded = 0;
+  for (let i = 1; i <= chunkNum; i++) {
+    const start = (i - 1) * chunkSize;
+    const end = Math.min(start + chunkSize, size);
+    const chunk = buffer.subarray(start, end);
+    const signedUrl = result.mapSignURLs[String(i)];
+    if (!signedUrl) {
+      throw new Error(`Missing signed URL for chunk ${i}`);
+    }
+    const resp = await fetch(signedUrl, {
+      method: "PUT",
+      headers: { "Content-Type": contentType },
+      body: chunk
+    });
+    if (!resp.ok) {
+      throw new Error(`Chunk ${i} upload failed: ${resp.status}`);
+    }
+    const eTag = resp.headers.get("ETag") || "";
+    uploadParts.push({ partNumber: i, eTag: JSON.parse(eTag) });
+    totalUploaded += chunk.length;
+    if (onProgress) {
+      const seconds = Math.round((Date.now() - startTime) / 1e3) || 1;
+      const speedPerSecond = formatSpeed(totalUploaded / seconds);
+      onProgress({
+        percent: `${Math.round(totalUploaded / size * 100)}%`,
+        loaded: totalUploaded,
+        total: size,
+        speedPerSecond,
+        percentRate: totalUploaded / size
+      });
+    }
+  }
+  const complete = await completeMultipartUpload({
+    token,
+    baseUrl,
+    originFileName: fileName,
+    md5,
+    UploadParts: uploadParts
+  });
+  logger.info(`[uploadMultipartFile] Upload complete: ${complete.ID}`);
+  return { fileID: complete.ID, path: complete.path, size };
+}
+async function sendMediaMessage(token, sessionInfo, options, baseUrl) {
+  const { buffer, fileName, contentType, content, onProgress } = options;
+  const { fileID, path } = await uploadFile(token, buffer, { fileName, contentType, onProgress }, baseUrl);
+  logger.info(`[sendMediaMessage] fileID=${fileID}, path=${path}`);
+  return sendMessage({
+    token,
+    baseUrl,
+    sessionInfo,
+    msgContent: {
+      content: content || "",
+      extraInfo: {
+        attechmentInfo: {
+          fileID: String(fileID),
+          fileName,
+          filePath: path,
+          fileSize: buffer.length,
+          mimeType: contentType
+        }
+      }
+    }
+  });
+}
+
 // src/api/index.ts
 async function getUpdates(params) {
   const { token, baseUrl, timeout = API.DEFAULT_TIMEOUT, offset, limit = API.DEFAULT_LIMIT } = params;
@@ -236,11 +563,27 @@ async function getUpdates(params) {
     timeout: (timeout || 0) * 1e3 + HTTP.POLLING_TIMEOUT_BUFFER
   });
 }
+async function getUpdatesV2(params) {
+  const { token, baseUrl, timeout = API.DEFAULT_TIMEOUT, limit = API.DEFAULT_LIMIT } = params;
+  return request({
+    token,
+    baseUrl,
+    method: "POST",
+    path: "getUpdatesV2",
+    body: {
+      timeout,
+      limit
+    },
+    timeout: (timeout || 0) * 1e3 + HTTP.POLLING_TIMEOUT_BUFFER
+  });
+}
 async function sendMessage(params) {
   const { token, baseUrl, sessionInfo, msgContent } = params;
-  if (!msgContent.content || msgContent.content.trim() === "") {
+  const hasContent = msgContent.content && msgContent.content.trim() !== "";
+  const hasAttachment = msgContent.extraInfo?.attechmentInfo || msgContent.extraInfo?.attechmentInfos && msgContent.extraInfo.attechmentInfos.length > 0;
+  if (!hasContent && !hasAttachment) {
     const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_error(), error_exports));
-    throw new ValidationError2("Message text cannot be empty", "content", msgContent.content);
+    throw new ValidationError2("Message content or attachment is required", "msgContent", msgContent);
   }
   return request({
     token,
@@ -261,6 +604,7 @@ var MeetBot = class {
   baseUrl;
   pollingLimit;
   longPollingTimeout;
+  useV2;
   eventHandlers = /* @__PURE__ */ new Map();
   polling = false;
   offset = 0;
@@ -279,6 +623,7 @@ var MeetBot = class {
     this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
     this.pollingLimit = config.pollingLimit ?? POLLING.DEFAULT_LIMIT;
     this.longPollingTimeout = config.longPollingTimeout ?? POLLING.DEFAULT_TIMEOUT;
+    this.useV2 = config.useV2 ?? false;
     logger.setLevel(config.logLevel ?? "silent");
   }
   on(event, handler) {
@@ -318,7 +663,7 @@ var MeetBot = class {
     this.abortController = new AbortController();
     const limit = options?.limit ?? this.pollingLimit;
     const timeout = options?.timeout ?? this.longPollingTimeout;
-    logger.info(`\u5F00\u59CB\u957F\u8F6E\u8BE2\u6D88\u606F... (\u6761\u6570: ${limit}, \u8D85\u65F6: ${timeout}s)`);
+    logger.info(`\u5F00\u59CB\u957F\u8F6E\u8BE2\u6D88\u606F... (\u6761\u6570: ${limit}, \u8D85\u65F6: ${timeout}s, V2: ${this.useV2})`);
     this.emit("polling_start", void 0);
     const retryDelay = options?.retryDelay ?? POLLING.DEFAULT_RETRY_DELAY;
     const maxRetries = options?.maxRetries ?? POLLING.DEFAULT_MAX_RETRIES;
@@ -326,20 +671,35 @@ var MeetBot = class {
     let retryCount = 0;
     while (this.polling) {
       try {
-        const updates = await getUpdates({
-          token: this.token,
-          baseUrl: this.baseUrl,
-          timeout,
-          offset: this.offset,
-          limit
-        });
-        retryCount = 0;
-        for (const update of updates) {
-          if (update.message) {
-            this.emit("message", update.message);
-            this.offset = (update.message.seqId || 0) + 1;
+        if (this.useV2) {
+          const result = await getUpdatesV2({
+            token: this.token,
+            baseUrl: this.baseUrl,
+            timeout,
+            limit
+          });
+          retryCount = 0;
+          for (const msgUpdate of result.msgs) {
+            this.emit("message", { message: msgUpdate.message, quoteMsgMap: result.quoteMsgMap });
+            this.offset = (msgUpdate.message.seqId || 0) + 1;
             onOffsetUpdate?.(this.offset);
           }
+        } else {
+          const updates = await getUpdates({
+            token: this.token,
+            baseUrl: this.baseUrl,
+            timeout,
+            offset: this.offset,
+            limit
+          });
+          retryCount = 0;
+          for (const update of updates) {
+            if (update.message) {
+              this.emit("message", { message: update.message, quoteMsgMap: {} });
+              this.offset = (update.message.seqId || 0) + 1;
+              onOffsetUpdate?.(this.offset);
+            }
+          }
         }
         await this.sleep(POLLING.SUCCESS_DELAY);
       } catch (error) {
@@ -370,6 +730,13 @@ var MeetBot = class {
       ...options
     });
   }
+  async getUpdatesV2(options) {
+    return getUpdatesV2({
+      token: this.token,
+      baseUrl: this.baseUrl,
+      ...options
+    });
+  }
   async sendMessage(sessionInfo, msgContent) {
     return sendMessage({
       token: this.token,
@@ -378,6 +745,66 @@ var MeetBot = class {
       msgContent
     });
   }
+  /**
+   * 获取单文件上传签名地址
+   */
+  async getUploadURL(params) {
+    return getUploadURL({
+      token: this.token,
+      baseUrl: this.baseUrl,
+      ...params
+    });
+  }
+  /**
+   * 获取分片上传签名地址
+   */
+  async getMultiPartUploadURL(params) {
+    return getMultiPartUploadURL({
+      token: this.token,
+      baseUrl: this.baseUrl,
+      ...params
+    });
+  }
+  /**
+   * 完成分片上传
+   */
+  async completeMultipartUpload(params) {
+    return completeMultipartUpload({
+      token: this.token,
+      baseUrl: this.baseUrl,
+      ...params
+    });
+  }
+  /**
+   * 获取文件下载地址
+   */
+  async getAccessURL(params) {
+    const apiParams = "sessionInfo" in params ? {
+      firstId: params.sessionInfo.firstID,
+      secondId: params.sessionInfo.secondID,
+      sessionType: params.sessionInfo.sessionType,
+      seqId: params.seqId,
+      fileId: params.fileId,
+      printResult: params.printResult
+    } : params;
+    return getAccessURL({
+      token: this.token,
+      baseUrl: this.baseUrl,
+      ...apiParams
+    });
+  }
+  /**
+   * 上传文件（自动选择单文件或分片上传）
+   */
+  async uploadFile(buffer, options) {
+    return uploadFile(this.token, buffer, options, this.baseUrl);
+  }
+  /**
+   * 发送媒体消息（上传并发送）
+   */
+  async sendMedia(sessionInfo, options) {
+    return sendMediaMessage(this.token, sessionInfo, options, this.baseUrl);
+  }
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
@@ -387,11 +814,25 @@ var MeetBot = class {
 init_error();
 
 exports.API = API;
+exports.CHUNK_RULES = CHUNK_RULES;
 exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
 exports.HTTP = HTTP;
 exports.MeetBot = MeetBot;
 exports.POLLING = POLLING;
+exports.SESSION_TYPE = SESSION_TYPE;
+exports.UPLOAD = UPLOAD;
+exports.completeMultipartUpload = completeMultipartUpload;
+exports.computeMD5 = computeMD5;
+exports.getAccessURL = getAccessURL;
+exports.getChunkNum = getChunkNum;
+exports.getConvID = getConvID;
+exports.getMultiPartUploadURL = getMultiPartUploadURL;
+exports.getQuoteMsgKey = getQuoteMsgKey;
 exports.getUpdates = getUpdates;
+exports.getUpdatesV2 = getUpdatesV2;
+exports.getUploadURL = getUploadURL;
+exports.sendMediaMessage = sendMediaMessage;
 exports.sendMessage = sendMessage;
+exports.uploadFile = uploadFile;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map