@naplink/naplink 0.0.1 → 0.0.3

package/dist/index.js

@@ -328,11 +328,14 @@ function startHeartbeat(deps) {
 
 // src/core/connection/retry-handler.ts
 function handleReconnect(deps) {
-  const { config, logger, reconnectService, setState, connect } = deps;
+  const { config, logger, reconnectService, setState, connect, onMaxAttemptsReached } = deps;
   if (!reconnectService.hasRemainingAttempts()) {
     setState("disconnected" /* DISCONNECTED */);
     const err = new MaxReconnectAttemptsError(reconnectService.getMaxAttempts());
     logger.error("\u81EA\u52A8\u91CD\u8FDE\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u505C\u6B62\u91CD\u8FDE", err);
+    if (onMaxAttemptsReached) {
+      onMaxAttemptsReached();
+    }
     return false;
   }
   setState("reconnecting" /* RECONNECTING */);
@@ -341,6 +344,9 @@ function handleReconnect(deps) {
     setState("disconnected" /* DISCONNECTED */);
     const err = new MaxReconnectAttemptsError(config.reconnect.maxAttempts);
     logger.error("\u81EA\u52A8\u91CD\u8FDE\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u505C\u6B62\u91CD\u8FDE", err);
+    if (onMaxAttemptsReached) {
+      onMaxAttemptsReached();
+    }
     return false;
   }
   return true;
@@ -348,7 +354,7 @@ function handleReconnect(deps) {
 
 // src/core/connection/close-handler.ts
 function handleCloseEvent(deps, event) {
-  const { getState, setState, stopHeartbeat, logger, config, reconnectService, reconnect } = deps;
+  const { getState, setState, stopHeartbeat, logger, config, reconnectService, reconnect, onMaxAttemptsReached } = deps;
   stopHeartbeat();
   logger.info(`\u8FDE\u63A5\u5173\u95ED (code: ${event.code}, reason: ${event.reason})`);
   if (event.code === 1e3) {
@@ -362,7 +368,9 @@ function handleCloseEvent(deps, event) {
       logger,
       reconnectService,
       setState,
-      connect: reconnect
+      connect: reconnect,
+      onMaxAttemptsReached
+      // 传递回调
     });
   } else {
     setState("disconnected" /* DISCONNECTED */);
@@ -412,11 +420,13 @@ function attachWebSocketHandlers(ws, deps, resolve, reject) {
 
 // src/core/connection/manager.ts
 var ConnectionManager = class {
-  constructor(config, logger, onMessage, onStateChange) {
+  // 跟踪是否处于重连状态
+  constructor(config, logger, onMessage, onStateChange, emitter) {
     this.config = config;
     this.logger = logger;
     this.onMessage = onMessage;
     this.onStateChange = onStateChange;
+    this.emitter = emitter;
     this.reconnectService = new ReconnectService(config.reconnect, logger);
   }
   ws;
@@ -425,6 +435,7 @@ var ConnectionManager = class {
   heartbeatService;
   connectPromise;
   connectTimeout;
+  wasReconnecting = false;
   /**
    * 连接到WebSocket服务器
    */
@@ -480,7 +491,15 @@ var ConnectionManager = class {
             logger: this.logger,
             config: this.config,
             reconnectService: this.reconnectService,
-            reconnect: () => this.connect()
+            reconnect: () => this.connect(),
+            onMaxAttemptsReached: () => {
+              if (this.emitter) {
+                this.emitter.emit("connection:lost", {
+                  timestamp: Date.now(),
+                  attempts: this.reconnectService.getMaxAttempts()
+                });
+              }
+            }
           }, event),
           clearConnectTimeout: () => this.clearConnectTimeout()
         },
@@ -540,7 +559,14 @@ var ConnectionManager = class {
     if (this.state !== state) {
       this.state = state;
       this.logger.debug(`\u72B6\u6001\u53D8\u66F4: ${state}`);
-      this.onStateChange(state);
+      if (state === "reconnecting" /* RECONNECTING */) {
+        this.wasReconnecting = true;
+      } else if (state === "connected" /* CONNECTED */) {
+        this.onStateChange(state, this.wasReconnecting);
+        this.wasReconnecting = false;
+        return;
+      }
+      this.onStateChange(state, false);
     }
   }
   /**
@@ -594,6 +620,20 @@ var ResponseRegistry = class {
     this.pending.set(echo, entry);
     return entry;
   }
+  get(echo) {
+    return this.pending.get(echo);
+  }
+  refresh(echo) {
+    const req = this.pending.get(echo);
+    if (!req) return false;
+    clearTimeout(req.timer);
+    req.createdAt = Date.now();
+    req.timer = setTimeout(() => {
+      this.pending.delete(echo);
+      req.reject(new ApiTimeoutError(req.method, req.timeoutMs));
+    }, req.timeoutMs);
+    return true;
+  }
   resolve(echo, data) {
     const req = this.pending.get(echo);
     if (!req) return false;
@@ -661,6 +701,52 @@ async function withRetry(fn, retries, method, logger, delayFn) {
 }
 
 // src/core/api-client.ts
+var AsyncQueue = class {
+  values = [];
+  waiters = [];
+  closed = false;
+  push(value) {
+    if (this.closed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve({ value, done: false });
+    } else {
+      this.values.push(value);
+    }
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length) {
+      this.waiters.shift().resolve({ value: void 0, done: true });
+    }
+  }
+  fail(error) {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length) {
+      this.waiters.shift().reject(error);
+    }
+    this.values = [];
+  }
+  async next() {
+    if (this.values.length) {
+      return { value: this.values.shift(), done: false };
+    }
+    if (this.closed) {
+      return { value: void 0, done: true };
+    }
+    return await new Promise((resolve, reject) => {
+      this.waiters.push({
+        resolve,
+        reject: (err) => reject(err)
+      });
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
 var ApiClient = class {
   constructor(connection, config, logger) {
     this.connection = connection;
@@ -688,32 +774,68 @@ var ApiClient = class {
       this.delay.bind(this)
     );
   }
+  /**
+   * 调用流式 API（NapCat stream-action）
+   * 会持续产出 data.type=stream 的分片包，并在 data.type=response 时结束。
+   */
+  callStream(method, params = {}, options) {
+    const timeout = options?.timeout ?? this.config.api.timeout;
+    const queue = new AsyncQueue();
+    const result = this.sendRequest(method, params, timeout, {
+      onPacket: (packet) => queue.push(packet),
+      onEnd: () => queue.close(),
+      onError: (error) => queue.fail(error)
+    });
+    return { packets: queue, result };
+  }
   /**
    * 处理API响应
    * 由连接管理器调用
    */
   handleResponse(echo, response) {
-    const request = this.registry.take(echo);
+    const request = this.registry.get(echo);
     if (!request) {
-      this.logger.warn(`\u6536\u5230\u672A\u77E5\u8BF7\u6C42\u7684\u54CD\u5E94: ${echo}`);
+      if (response?.stream === "stream-action") {
+        this.logger.debug(`\u6536\u5230\u672A\u77E5\u6D41\u5F0F\u54CD\u5E94: ${echo}`);
+      } else {
+        this.logger.warn(`\u6536\u5230\u672A\u77E5\u8BF7\u6C42\u7684\u54CD\u5E94: ${echo}`);
+      }
       return;
     }
+    const isStreamAction = response?.stream === "stream-action" || typeof response?.data?.type === "string" && ["stream", "response", "reset", "error"].includes(response.data.type);
     if (response.status === "ok" || response.retcode === 0) {
+      if (isStreamAction) {
+        const packet = response.data;
+        const packetType = packet?.type;
+        if (request.onPacket) {
+          this.registry.refresh(echo);
+          request.onPacket(packet);
+          if (packetType === "response") {
+            this.logger.debug(`API\u6D41\u5F0F\u5B8C\u6210: ${request.method}`);
+            this.registry.resolve(echo, packet);
+            request.onEnd?.();
+          }
+          return;
+        }
+        this.logger.debug(`API\u6210\u529F(stream): ${request.method}`);
+        this.registry.resolve(echo, packet);
+        return;
+      }
       this.logger.debug(`API\u6210\u529F: ${request.method}`);
-      request.resolve(response.data);
+      this.registry.resolve(echo, response.data);
     } else {
       this.logger.warn(`API\u5931\u8D25: ${request.method}`, {
         retcode: response.retcode,
         message: response.message
       });
-      request.reject(
-        new ApiError(
-          request.method,
-          response.retcode,
-          response.message,
-          response.wording
-        )
+      const error = new ApiError(
+        request.method,
+        response.retcode,
+        response.message,
+        response.wording
       );
+      request.onError?.(error);
+      this.registry.reject(echo, error);
     }
   }
   /**
@@ -729,17 +851,19 @@ var ApiClient = class {
   /**
    * 发送API请求
    */
-  sendRequest(method, params, timeout) {
+  sendRequest(method, params, timeout, hooks) {
     return new Promise((resolve, reject) => {
       const echo = this.generateRequestId();
       this.logger.debug(`\u53D1\u9001API\u8BF7\u6C42: ${method}`, { echo, params });
       this.registry.add(
         echo,
         {
-          resolve,
-          reject,
+          resolve: (data) => resolve(data),
+          reject: (error) => reject(error),
           createdAt: Date.now(),
-          method
+          method,
+          timeoutMs: timeout,
+          ...hooks ?? {}
         },
         timeout
       );
@@ -751,6 +875,7 @@ var ApiClient = class {
         this.connection.send(payload);
       } catch (error) {
         this.registry.reject(echo, error);
+        hooks?.onError?.(error);
         reject(error);
       }
     });
@@ -951,11 +1076,14 @@ var MessageDispatcher = class {
 };
 
 // src/core/connection/state-handler.ts
-function handleConnectionStateChange(emitter, state) {
+function handleConnectionStateChange(emitter, state, wasReconnecting = false) {
   emitter.emit("state_change", state);
   switch (state) {
     case "connected" /* CONNECTED */:
       emitter.emit("connect");
+      if (wasReconnecting) {
+        emitter.emit("connection:restored", { timestamp: Date.now() });
+      }
       break;
     case "disconnected" /* DISCONNECTED */:
       emitter.emit("disconnect");
@@ -1002,6 +1130,15 @@ function createMessageApi(client) {
     markMessageAsRead(messageId) {
       return client.call("mark_msg_as_read", { message_id: messageId });
     },
+    markGroupMsgAsRead(groupId) {
+      return client.call("mark_group_msg_as_read", { group_id: groupId });
+    },
+    markPrivateMsgAsRead(userId) {
+      return client.call("mark_private_msg_as_read", { user_id: userId });
+    },
+    markAllMsgAsRead() {
+      return client.call("_mark_all_as_read");
+    },
     getGroupAtAllRemain(groupId) {
       return client.call("get_group_at_all_remain", { group_id: groupId });
     },
@@ -1010,6 +1147,30 @@ function createMessageApi(client) {
     },
     getGroupHonorInfo(groupId, type) {
       return client.call("get_group_honor_info", { group_id: groupId, type });
+    },
+    getGroupMsgHistory(params) {
+      return client.call("get_group_msg_history", params);
+    },
+    getFriendMsgHistory(params) {
+      return client.call("get_friend_msg_history", params);
+    },
+    getRecentContact(count) {
+      return client.call("get_recent_contact", { count });
+    },
+    setMsgEmojiLike(messageId, emojiId, set) {
+      return client.call("set_msg_emoji_like", { message_id: messageId, emoji_id: emojiId, set });
+    },
+    fetchEmojiLike(params) {
+      return client.call("fetch_emoji_like", params);
+    },
+    sendGroupPoke(groupId, userId) {
+      return client.call("group_poke", { group_id: groupId, user_id: userId });
+    },
+    sendFriendPoke(userId) {
+      return client.call("friend_poke", { user_id: userId });
+    },
+    sendPoke(targetId, groupId) {
+      return client.call("send_poke", groupId ? { group_id: groupId, target_id: targetId } : { user_id: targetId });
     }
   };
 }
@@ -1033,26 +1194,29 @@ function createMediaApi(client, logger) {
         const data = segment?.data;
         if (!type || !data) return;
         if (["image", "video", "record", "audio", "file"].includes(type)) {
-          const fileId = data.file;
+          const fileId = data.file ?? data.file_id;
           if (typeof fileId === "string" && !/^https?:\/\//.test(fileId) && !fileId.startsWith("file://")) {
             try {
               const res = await api.getFile(fileId);
-              if (res?.file) {
-                data.url = res.file;
-                data.file = res.file;
+              const hydratedUrl = res?.file ?? res?.url;
+              if (hydratedUrl) {
+                data.url = hydratedUrl;
+                data.file = hydratedUrl;
                 return;
               }
               if (type === "record" || type === "audio") {
                 const rec = await api.getRecord(fileId, "mp3");
-                if (rec?.file) {
-                  data.url = rec.file;
-                  data.file = rec.file;
+                const recUrl = rec?.file ?? rec?.url;
+                if (recUrl) {
+                  data.url = recUrl;
+                  data.file = recUrl;
                 }
               } else if (type === "image") {
                 const img = await api.getImage(fileId);
-                if (img?.file) {
-                  data.url = img.file;
-                  data.file = img.file;
+                const imgUrl = img?.file ?? img?.url;
+                if (imgUrl) {
+                  data.url = imgUrl;
+                  data.file = imgUrl;
                 }
               }
             } catch (e) {
@@ -1272,7 +1436,39 @@ async function computeSha256(source) {
 }
 
 // src/api/onebot/stream.ts
+import { createWriteStream as createWriteStream3 } from "fs";
+import { promises as fs3 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join3 } from "path";
 function createStreamApi(client) {
+  const downloadToFile = async (action, params, filenameHint) => {
+    const { packets } = client.callStream(action, params);
+    let fileInfo;
+    const tempPath = join3(tmpdir3(), `${randomUUID3()}-${filenameHint || "naplink.download"}`);
+    const writeStream = createWriteStream3(tempPath);
+    try {
+      for await (const packet of packets) {
+        if (packet?.data_type === "file_info") {
+          fileInfo = packet;
+        }
+        if (packet?.data_type === "file_chunk" && typeof packet.data === "string") {
+          writeStream.write(Buffer.from(packet.data, "base64"));
+        }
+      }
+      await new Promise((resolve, reject) => {
+        writeStream.once("error", reject);
+        writeStream.end(() => resolve());
+      });
+      return { path: tempPath, info: fileInfo };
+    } catch (error) {
+      try {
+        writeStream.destroy();
+      } catch {
+      }
+      await fs3.unlink(tempPath).catch(() => void 0);
+      throw error;
+    }
+  };
   return {
     async uploadFileStream(file, options) {
       const chunkSize = options?.chunkSize ?? 256 * 1024;
@@ -1311,7 +1507,48 @@ function createStreamApi(client) {
       return completion;
     },
     getUploadStreamStatus(streamId) {
-      return client.call("upload_file_stream", { stream_id: streamId });
+      return client.call("upload_file_stream", { stream_id: streamId, verify_only: true });
+    },
+    downloadFileStream(fileId, options) {
+      const chunkSize = options?.chunkSize ?? 64 * 1024;
+      return client.callStream("download_file_stream", {
+        file: fileId,
+        chunk_size: chunkSize
+      });
+    },
+    async downloadFileStreamToFile(fileId, options) {
+      const chunkSize = options?.chunkSize ?? 64 * 1024;
+      return downloadToFile("download_file_stream", { file: fileId, chunk_size: chunkSize }, options?.filename);
+    },
+    downloadFileImageStream(fileId, options) {
+      const chunkSize = options?.chunkSize ?? 64 * 1024;
+      return client.callStream("download_file_image_stream", {
+        file: fileId,
+        chunk_size: chunkSize
+      });
+    },
+    async downloadFileImageStreamToFile(fileId, options) {
+      const chunkSize = options?.chunkSize ?? 64 * 1024;
+      return downloadToFile("download_file_image_stream", { file: fileId, chunk_size: chunkSize }, options?.filename);
+    },
+    downloadFileRecordStream(fileId, outFormat, options) {
+      const chunkSize = options?.chunkSize ?? 64 * 1024;
+      return client.callStream("download_file_record_stream", {
+        file: fileId,
+        chunk_size: chunkSize,
+        out_format: outFormat
+      });
+    },
+    async downloadFileRecordStreamToFile(fileId, outFormat, options) {
+      const chunkSize = options?.chunkSize ?? 64 * 1024;
+      return downloadToFile(
+        "download_file_record_stream",
+        { file: fileId, chunk_size: chunkSize, out_format: outFormat },
+        options?.filename
+      );
+    },
+    cleanStreamTempFile() {
+      return client.call("clean_stream_temp_file");
     }
   };
 }
@@ -1328,6 +1565,328 @@ function createRequestApi(client) {
   };
 }
 
+// src/api/onebot/system.ts
+function createSystemApi(client) {
+  return {
+    getOnlineClients(noCache = false) {
+      return client.call("get_online_clients", { no_cache: noCache });
+    },
+    getRobotUinRange() {
+      return client.call("get_robot_uin_range");
+    },
+    canSendImage() {
+      return client.call("can_send_image");
+    },
+    canSendRecord() {
+      return client.call("can_send_record");
+    },
+    getCookies(domain) {
+      return client.call("get_cookies", { domain });
+    },
+    getCsrfToken() {
+      return client.call("get_csrf_token");
+    },
+    getCredentials(domain) {
+      return client.call("get_credentials", { domain });
+    },
+    setInputStatus(userId, eventType) {
+      return client.call("set_input_status", { user_id: userId, event_type: eventType, eventType });
+    },
+    ocrImage(image, dot = false) {
+      return client.call(dot ? ".ocr_image" : "ocr_image", { image });
+    },
+    translateEn2zh(words) {
+      return client.call("translate_en2zh", { words });
+    },
+    checkUrlSafely(url) {
+      return client.call("check_url_safely", { url });
+    },
+    handleQuickOperation(context, operation) {
+      return client.call(".handle_quick_operation", { context, operation });
+    },
+    getModelShow(model) {
+      return client.call("_get_model_show", { model });
+    },
+    setModelShow(model, modelShow) {
+      return client.call("_set_model_show", { model, model_show: modelShow });
+    },
+    getPacketStatus() {
+      return client.call("nc_get_packet_status");
+    }
+  };
+}
+
+// src/api/onebot/napcat.ts
+function createNapCatApi(client) {
+  return {
+    getRkeyEx() {
+      return client.call("get_rkey");
+    },
+    getRkeyServer() {
+      return client.call("get_rkey_server");
+    },
+    getRkey() {
+      return client.call("nc_get_rkey");
+    },
+    setFriendRemark(userId, remark) {
+      return client.call("set_friend_remark", { user_id: userId, remark });
+    },
+    deleteFriend(userId) {
+      return client.call("delete_friend", { user_id: userId });
+    },
+    getUnidirectionalFriendList() {
+      return client.call("get_unidirectional_friend_list");
+    },
+    setGroupRemark(groupId, remark) {
+      return client.call("set_group_remark", { group_id: String(groupId), remark });
+    },
+    getGroupInfoEx(groupId) {
+      return client.call("get_group_info_ex", { group_id: groupId });
+    },
+    getGroupDetailInfo(groupId) {
+      return client.call("get_group_detail_info", { group_id: groupId });
+    },
+    getGroupIgnoredNotifies() {
+      return client.call("get_group_ignored_notifies");
+    },
+    getGroupShutList(groupId) {
+      return client.call("get_group_shut_list", { group_id: groupId });
+    },
+    sendPrivateForwardMessage(params) {
+      return client.call("send_private_forward_msg", params);
+    },
+    forwardFriendSingleMsg(userId, messageId) {
+      return client.call("forward_friend_single_msg", { user_id: userId, message_id: messageId });
+    },
+    forwardGroupSingleMsg(groupId, messageId) {
+      return client.call("forward_group_single_msg", { group_id: groupId, message_id: messageId });
+    },
+    sendForwardMsg(params) {
+      return client.call("send_forward_msg", params);
+    },
+    sendGroupNotice(params) {
+      return client.call("_send_group_notice", params);
+    },
+    getGroupNotice(groupId) {
+      return client.call("_get_group_notice", { group_id: groupId });
+    },
+    delGroupNotice(groupId, noticeId) {
+      return client.call("_del_group_notice", { group_id: groupId, notice_id: +noticeId });
+    },
+    setOnlineStatus(status, extStatus, batteryStatus) {
+      return client.call("set_online_status", { status, ext_status: extStatus, battery_status: batteryStatus });
+    },
+    setDiyOnlineStatus(faceId, wording = " ", faceType = 1) {
+      return client.call("set_diy_online_status", { face_id: faceId, wording, face_type: faceType });
+    },
+    sendArkShare(params) {
+      return client.call("send_ark_share", params);
+    },
+    sendGroupArkShare(groupId) {
+      return client.call("send_group_ark_share", { group_id: groupId });
+    },
+    getMiniAppArk(payload) {
+      return client.call("get_mini_app_ark", payload);
+    },
+    getAiCharacters(groupId, chatType = 1) {
+      return client.call("get_ai_characters", { group_id: groupId, chat_type: chatType });
+    },
+    getAiRecord(groupId, character, text) {
+      return client.call("get_ai_record", { group_id: groupId, character, text });
+    },
+    sendGroupAiRecord(groupId, character, text) {
+      return client.call("send_group_ai_record", { group_id: groupId, character, text });
+    },
+    setGroupSign(groupId) {
+      return client.call("set_group_sign", { group_id: groupId });
+    },
+    sendGroupSign(groupId) {
+      return client.call("send_group_sign", { group_id: groupId });
+    },
+    fetchCustomFace(params) {
+      return client.call("fetch_custom_face", params ?? {});
+    },
+    getClientkey() {
+      return client.call("get_clientkey");
+    },
+    clickInlineKeyboardButton(params) {
+      return client.call("click_inline_keyboard_button", {
+        ...params,
+        button_id: params.button_id ?? "",
+        callback_data: params.callback_data ?? "",
+        msg_seq: params.msg_seq ?? "10086"
+      });
+    }
+  };
+}
+
+// src/api/onebot/raw.ts
+var NAPCAT_ACTIONS = [
+  ".get_word_slices",
+  ".handle_quick_operation",
+  ".ocr_image",
+  "ArkShareGroup",
+  "ArkSharePeer",
+  "_del_group_notice",
+  "_get_group_notice",
+  "_get_model_show",
+  "_mark_all_as_read",
+  "_send_group_notice",
+  "_set_model_show",
+  "bot_exit",
+  "can_send_image",
+  "can_send_record",
+  "check_url_safely",
+  "clean_cache",
+  "clean_stream_temp_file",
+  "click_inline_keyboard_button",
+  "create_collection",
+  "create_group_file_folder",
+  "del_group_album_media",
+  "delete_essence_msg",
+  "delete_friend",
+  "delete_group_file",
+  "delete_group_folder",
+  "delete_msg",
+  "delete_unidirectional_friend",
+  "do_group_album_comment",
+  "download_file",
+  "download_file_image_stream",
+  "download_file_record_stream",
+  "download_file_stream",
+  "fetch_custom_face",
+  "fetch_emoji_like",
+  "forward_friend_single_msg",
+  "forward_group_single_msg",
+  "friend_poke",
+  "get_ai_characters",
+  "get_ai_record",
+  "get_clientkey",
+  "get_collection_list",
+  "get_cookies",
+  "get_credentials",
+  "get_csrf_token",
+  "get_doubt_friends_add_request",
+  "get_essence_msg_list",
+  "get_file",
+  "get_forward_msg",
+  "get_friend_list",
+  "get_friend_msg_history",
+  "get_friends_with_category",
+  "get_group_album_media_list",
+  "get_group_at_all_remain",
+  "get_group_detail_info",
+  "get_group_file_system_info",
+  "get_group_file_url",
+  "get_group_files_by_folder",
+  "get_group_honor_info",
+  "get_group_ignore_add_request",
+  "get_group_ignored_notifies",
+  "get_group_info",
+  "get_group_info_ex",
+  "get_group_list",
+  "get_group_member_info",
+  "get_group_member_list",
+  "get_group_msg_history",
+  "get_group_root_files",
+  "get_group_shut_list",
+  "get_group_system_msg",
+  "get_guild_list",
+  "get_guild_service_profile",
+  "get_image",
+  "get_login_info",
+  "get_mini_app_ark",
+  "get_msg",
+  "get_online_clients",
+  "get_private_file_url",
+  "get_profile_like",
+  "get_qun_album_list",
+  "get_recent_contact",
+  "get_record",
+  "get_rkey",
+  "get_rkey_server",
+  "get_robot_uin_range",
+  "get_status",
+  "get_stranger_info",
+  "get_unidirectional_friend_list",
+  "get_version_info",
+  "group_poke",
+  "mark_group_msg_as_read",
+  "mark_msg_as_read",
+  "mark_private_msg_as_read",
+  "move_group_file",
+  "nc_get_packet_status",
+  "nc_get_rkey",
+  "nc_get_user_status",
+  "ocr_image",
+  "qidian_get_account_info",
+  "reboot_normal",
+  "reload_event_filter",
+  "rename_group_file",
+  "send_ark_share",
+  "send_forward_msg",
+  "send_group_ai_record",
+  "send_group_ark_share",
+  "send_group_forward_msg",
+  "send_group_msg",
+  "send_group_sign",
+  "send_like",
+  "send_msg",
+  "send_packet",
+  "send_poke",
+  "send_private_forward_msg",
+  "send_private_msg",
+  "set_diy_online_status",
+  "set_doubt_friends_add_request",
+  "set_essence_msg",
+  "set_friend_add_request",
+  "set_friend_remark",
+  "set_group_add_option",
+  "set_group_add_request",
+  "set_group_admin",
+  "set_group_album_media_like",
+  "set_group_anonymous",
+  "set_group_anonymous_ban",
+  "set_group_ban",
+  "set_group_card",
+  "set_group_kick",
+  "set_group_kick_members",
+  "set_group_leave",
+  "set_group_name",
+  "set_group_portrait",
+  "set_group_remark",
+  "set_group_robot_add_option",
+  "set_group_search",
+  "set_group_sign",
+  "set_group_special_title",
+  "set_group_todo",
+  "set_group_whole_ban",
+  "set_input_status",
+  "set_msg_emoji_like",
+  "set_online_status",
+  "set_qq_avatar",
+  "set_qq_profile",
+  "set_restart",
+  "set_self_longnick",
+  "test_auto_register_01",
+  "test_auto_register_02",
+  "test_download_stream",
+  "trans_group_file",
+  "translate_en2zh",
+  "unknown",
+  "upload_file_stream",
+  "upload_group_file",
+  "upload_image_to_qun_album",
+  "upload_private_file"
+];
+function createRawActionApi(client) {
+  const entries = NAPCAT_ACTIONS.map((action) => [
+    action,
+    (params) => client.call(action, params ?? {})
+  ]);
+  return Object.fromEntries(entries);
+}
+
 // src/api/onebot/index.ts
 var OneBotApi = class {
   messageApi;
@@ -1337,6 +1896,9 @@ var OneBotApi = class {
   fileApi;
   streamApi;
   requestApi;
+  systemApi;
+  napcatApi;
+  raw;
   constructor(client, logger) {
     this.messageApi = createMessageApi(client);
     this.mediaApi = createMediaApi(client, logger);
@@ -1345,6 +1907,9 @@ var OneBotApi = class {
     this.fileApi = createFileApi(client);
     this.streamApi = createStreamApi(client);
     this.requestApi = createRequestApi(client);
+    this.systemApi = createSystemApi(client);
+    this.napcatApi = createNapCatApi(client);
+    this.raw = createRawActionApi(client);
     Object.assign(
       this,
       this.messageApi,
@@ -1353,7 +1918,9 @@ var OneBotApi = class {
       this.groupApi,
       this.fileApi,
       this.streamApi,
-      this.requestApi
+      this.requestApi,
+      this.systemApi,
+      this.napcatApi
     );
   }
 };
@@ -1371,6 +1938,9 @@ function bindOneBotApiMethods(api, target) {
     getForwardMessage: (id) => api.getForwardMessage(id),
     getEssenceMessageList: (groupId) => api.getEssenceMessageList(groupId),
     markMessageAsRead: (messageId) => api.markMessageAsRead(messageId),
+    markGroupMsgAsRead: (groupId) => api.markGroupMsgAsRead(groupId),
+    markPrivateMsgAsRead: (userId) => api.markPrivateMsgAsRead(userId),
+    markAllMsgAsRead: () => api.markAllMsgAsRead(),
     getGroupAtAllRemain: (groupId) => api.getGroupAtAllRemain(groupId),
     getGroupSystemMsg: () => api.getGroupSystemMsg(),
     getGroupHonorInfo: (groupId, type) => api.getGroupHonorInfo(groupId, type),
@@ -1384,7 +1954,22 @@ function bindOneBotApiMethods(api, target) {
     downloadFile: (url, threadCount, headers) => api.downloadFile(url, threadCount, headers),
     uploadFileStream: (file, options) => api.uploadFileStream(file, options),
     getUploadStreamStatus: (streamId) => api.getUploadStreamStatus(streamId),
+    downloadFileStream: (fileId, options) => api.downloadFileStream(fileId, options),
+    downloadFileStreamToFile: (fileId, options) => api.downloadFileStreamToFile(fileId, options),
+    downloadFileImageStream: (fileId, options) => api.downloadFileImageStream(fileId, options),
+    downloadFileImageStreamToFile: (fileId, options) => api.downloadFileImageStreamToFile(fileId, options),
+    downloadFileRecordStream: (fileId, outFormat, options) => api.downloadFileRecordStream(fileId, outFormat, options),
+    downloadFileRecordStreamToFile: (fileId, outFormat, options) => api.downloadFileRecordStreamToFile(fileId, outFormat, options),
+    cleanStreamTempFile: () => api.cleanStreamTempFile(),
     sendGroupForwardMessage: (groupId, messages) => api.sendGroupForwardMessage(groupId, messages),
+    getGroupMsgHistory: (params) => api.getGroupMsgHistory(params),
+    getFriendMsgHistory: (params) => api.getFriendMsgHistory(params),
+    getRecentContact: (count) => api.getRecentContact(count),
+    setMsgEmojiLike: (messageId, emojiId, set) => api.setMsgEmojiLike(messageId, emojiId, set),
+    fetchEmojiLike: (params) => api.fetchEmojiLike(params),
+    sendGroupPoke: (groupId, userId) => api.sendGroupPoke(groupId, userId),
+    sendFriendPoke: (userId) => api.sendFriendPoke(userId),
+    sendPoke: (targetId, groupId) => api.sendPoke(targetId, groupId),
     getImage: (file) => api.getImage(file),
     getRecord: (file, outFormat) => api.getRecord(file, outFormat),
     getFile: (file) => api.getFile(file),
@@ -1412,7 +1997,56 @@ function bindOneBotApiMethods(api, target) {
     getStrangerInfo: (userId, noCache = false) => api.getStrangerInfo(userId, noCache),
     getVersionInfo: () => api.getVersionInfo(),
     handleFriendRequest: (flag, approve = true, remark) => api.handleFriendRequest(flag, approve, remark),
-    handleGroupRequest: (flag, subType, approve = true, reason) => api.handleGroupRequest(flag, subType, approve, reason)
+    handleGroupRequest: (flag, subType, approve = true, reason) => api.handleGroupRequest(flag, subType, approve, reason),
+    // SystemApi
+    getOnlineClients: (noCache = false) => api.getOnlineClients(noCache),
+    getRobotUinRange: () => api.getRobotUinRange(),
+    canSendImage: () => api.canSendImage(),
+    canSendRecord: () => api.canSendRecord(),
+    getCookies: (domain) => api.getCookies(domain),
+    getCsrfToken: () => api.getCsrfToken(),
+    getCredentials: (domain) => api.getCredentials(domain),
+    setInputStatus: (userId, eventType) => api.setInputStatus(userId, eventType),
+    ocrImage: (image, dot) => api.ocrImage(image, dot),
+    translateEn2zh: (words) => api.translateEn2zh(words),
+    checkUrlSafely: (url) => api.checkUrlSafely(url),
+    handleQuickOperation: (context, operation) => api.handleQuickOperation(context, operation),
+    getModelShow: (model) => api.getModelShow(model),
+    setModelShow: (model, modelShow) => api.setModelShow(model, modelShow),
+    getPacketStatus: () => api.getPacketStatus(),
+    // NapCatApi
+    getRkeyEx: () => api.getRkeyEx(),
+    getRkeyServer: () => api.getRkeyServer(),
+    getRkey: () => api.getRkey(),
+    setFriendRemark: (userId, remark) => api.setFriendRemark(userId, remark),
+    deleteFriend: (userId) => api.deleteFriend(userId),
+    getUnidirectionalFriendList: () => api.getUnidirectionalFriendList(),
+    setGroupRemark: (groupId, remark) => api.setGroupRemark(groupId, remark),
+    getGroupInfoEx: (groupId) => api.getGroupInfoEx(groupId),
+    getGroupDetailInfo: (groupId) => api.getGroupDetailInfo(groupId),
+    getGroupIgnoredNotifies: () => api.getGroupIgnoredNotifies(),
+    getGroupShutList: (groupId) => api.getGroupShutList(groupId),
+    sendPrivateForwardMessage: (params) => api.sendPrivateForwardMessage(params),
+    forwardFriendSingleMsg: (userId, messageId) => api.forwardFriendSingleMsg(userId, messageId),
+    forwardGroupSingleMsg: (groupId, messageId) => api.forwardGroupSingleMsg(groupId, messageId),
+    sendForwardMsg: (params) => api.sendForwardMsg(params),
+    sendGroupNotice: (params) => api.sendGroupNotice(params),
+    getGroupNotice: (groupId) => api.getGroupNotice(groupId),
+    delGroupNotice: (groupId, noticeId) => api.delGroupNotice(groupId, noticeId),
+    setOnlineStatus: (status, extStatus, batteryStatus) => api.setOnlineStatus(status, extStatus, batteryStatus),
+    setDiyOnlineStatus: (faceId, wording, faceType) => api.setDiyOnlineStatus(faceId, wording, faceType),
+    sendArkShare: (params) => api.sendArkShare(params),
+    sendGroupArkShare: (groupId) => api.sendGroupArkShare(groupId),
+    getMiniAppArk: (payload) => api.getMiniAppArk(payload),
+    getAiCharacters: (groupId, chatType) => api.getAiCharacters(groupId, chatType),
+    getAiRecord: (groupId, character, text) => api.getAiRecord(groupId, character, text),
+    sendGroupAiRecord: (groupId, character, text) => api.sendGroupAiRecord(groupId, character, text),
+    setGroupSign: (groupId) => api.setGroupSign(groupId),
+    sendGroupSign: (groupId) => api.sendGroupSign(groupId),
+    fetchCustomFace: (params) => api.fetchCustomFace(params),
+    getClientkey: () => api.getClientkey(),
+    clickInlineKeyboardButton: (params) => api.clickInlineKeyboardButton(params),
+    raw: api.raw
   };
   Object.assign(target, bindings);
 }
@@ -1492,7 +2126,9 @@ var NapLink = class extends EventEmitter2 {
       this.config,
       this.logger,
       (message) => this.dispatcher.dispatch(message),
-      (state) => handleConnectionStateChange(this, state)
+      (state, wasReconnecting) => handleConnectionStateChange(this, state, wasReconnecting || false),
+      this
+      // 传递 emitter 用于发送 connection:lost 事件
     );
     this.apiClient = new ApiClient(this.connection, this.config, this.logger);
     this.dispatcher = new MessageDispatcher(this.apiClient, this.eventRouter, this.logger);