@meet-im/meet-bot-jssdk 0.0.5 → 0.0.7

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,56 @@ 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 片
+];
+function getChunkNum(size) {
+  for (const rule of CHUNK_RULES) {
+    if (size < rule.maxSize) {
+      return rule.chunks;
+    }
+  }
+  return 50;
+}
+
+// src/utils/logger.ts
+var Logger = class {
+  level = "silent";
+  setLevel(level) {
+    this.level = level;
+  }
+  getLevel() {
+    return this.level;
+  }
+  info(...args) {
+    if (this.level === "info") {
+      console.log("[meetBotSDK]", ...args);
+    }
+  }
+  error(...args) {
+    if (this.level === "info") {
+      console.error("[meetBotSDK]", ...args);
+    }
+  }
+};
+var logger = new Logger();
 
 // src/http/request.ts
 function validateToken(token) {
@@ -136,9 +194,9 @@ async function request(options) {
     Accept: "application/json",
     Authorization: `Bot ${extractBotToken(token)}`
   };
-  console.log("[meetBotSDK] [Request]", method, url);
+  logger.info("[Request]", method, url);
   if (body) {
-    console.log("[meetBotSDK] [Body]", JSON.stringify(body));
+    logger.info("[Body]", JSON.stringify(body));
   }
   try {
     const response = await fetch(url, {
@@ -152,9 +210,21 @@ async function request(options) {
     response.headers.forEach((value, key) => {
       responseHeaders[key] = value;
     });
-    console.log("[meetBotSDK] [Response Status]", response.status);
-    const data = await response.json();
-    console.log("[meetBotSDK] [Response Body]", JSON.stringify(data));
+    logger.info("[Response Status]", response.status);
+    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;
       throw new exports.ApiError(
@@ -198,6 +268,256 @@ 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,
+      "x-oss-process": queryParams["x-oss-process"],
+      origin: queryParams.origin,
+      bestDomain: queryParams.bestDomain,
+      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;
@@ -216,9 +536,11 @@ async function getUpdates(params) {
 }
 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,
@@ -257,6 +579,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;
+    logger.setLevel(config.logLevel ?? "silent");
   }
   on(event, handler) {
     if (!this.eventHandlers.has(event)) {
@@ -279,7 +602,7 @@ var MeetBot = class {
         try {
           handler(data);
         } catch (e) {
-          console.error("[meetBotSDK]", `Error in ${event} handler:`, e);
+          logger.error(`Error in ${event} handler:`, e);
         }
       }
     }
@@ -295,7 +618,7 @@ var MeetBot = class {
     this.abortController = new AbortController();
     const limit = options?.limit ?? this.pollingLimit;
     const timeout = options?.timeout ?? this.longPollingTimeout;
-    console.log("[meetBotSDK]", `\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)`);
     this.emit("polling_start", void 0);
     const retryDelay = options?.retryDelay ?? POLLING.DEFAULT_RETRY_DELAY;
     const maxRetries = options?.maxRetries ?? POLLING.DEFAULT_MAX_RETRIES;
@@ -355,6 +678,58 @@ 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) {
+    return getAccessURL({
+      token: this.token,
+      baseUrl: this.baseUrl,
+      ...params
+    });
+  }
+  /**
+   * 上传文件（自动选择单文件或分片上传）
+   */
+  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));
   }
@@ -364,11 +739,21 @@ 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.UPLOAD = UPLOAD;
+exports.completeMultipartUpload = completeMultipartUpload;
+exports.computeMD5 = computeMD5;
+exports.getAccessURL = getAccessURL;
+exports.getChunkNum = getChunkNum;
+exports.getMultiPartUploadURL = getMultiPartUploadURL;
 exports.getUpdates = getUpdates;
+exports.getUploadURL = getUploadURL;
+exports.sendMediaMessage = sendMediaMessage;
 exports.sendMessage = sendMessage;
+exports.uploadFile = uploadFile;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map