koishi-plugin-dynamic-bot 0.0.0-dev → 0.0.3

package/lib/index.js

@@ -0,0 +1,1942 @@
+// src/index.ts
+import { Schema } from "koishi";
+
+// src/dbk/gateway.ts
+import { create as create4 } from "@bufbuild/protobuf";
+
+// src/gen/dbk/v1/common_pb.ts
+import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+var file_dbk_v1_common = /* @__PURE__ */ fileDesc("ChNkYmsvdjEvY29tbW9uLnByb3RvEgZkYmsudjEiSAoGVGFyZ2V0EiAKBGtpbmQYASABKA4yEi5kYmsudjEuVGFyZ2V0S2luZBIKCgJpZBgCIAEoCRIQCghndWlsZF9pZBgDIAEoCSI7CghScGNFcnJvchIfCgRjb2RlGAEgASgOMhEuZGJrLnYxLkVycm9yQ29kZRIOCgZkZXRhaWwYAiABKAkqhwEKClRhcmdldEtpbmQSGwoXVEFSR0VUX0tJTkRfVU5TUEVDSUZJRUQQABIUChBUQVJHRVRfS0lORF9VU0VSEAESFQoRVEFSR0VUX0tJTkRfR1JPVVAQAhIXChNUQVJHRVRfS0lORF9DSEFOTkVMEAMSFgoSVEFSR0VUX0tJTkRfVEhSRUFEEAQqdAoJQm90U3RhdHVzEhoKFkJPVF9TVEFUVVNfVU5TUEVDSUZJRUQQABIUChBCT1RfU1RBVFVTX1JFQURZEAESGgoWQk9UX1NUQVRVU19VTkFWQUlMQUJMRRACEhkKFUJPVF9TVEFUVVNfQ09OTkVDVElORxADKocBCgpTZW5kU3RhdHVzEhsKF1NFTkRfU1RBVFVTX1VOU1BFQ0lGSUVEEAASEgoOU0VORF9TVEFUVVNfT0sQARIXChNTRU5EX1NUQVRVU19QQVJUSUFMEAISFwoTU0VORF9TVEFUVVNfVU5LTk9XThADEhYKElNFTkRfU1RBVFVTX0ZBSUxFRBAEKqwBCglFcnJvckNvZGUSGgoWRVJST1JfQ09ERV9VTlNQRUNJRklFRBAAEhsKF0VSUk9SX0NPREVfVU5BVVRIT1JJWkVEEAESFwoTRVJST1JfQ09ERV9QUk9UT0NPTBACEhgKFEVSUk9SX0NPREVfTk9UX0ZPVU5EEAMSGgoWRVJST1JfQ09ERV9VTlNVUFBPUlRFRBAEEhcKE0VSUk9SX0NPREVfSU5URVJOQUwQBSqFAQoNQm90Q2hhbmdlVHlwZRIfChtCT1RfQ0hBTkdFX1RZUEVfVU5TUEVDSUZJRUQQABIZChVCT1RfQ0hBTkdFX1RZUEVfQURERUQQARIbChdCT1RfQ0hBTkdFX1RZUEVfVVBEQVRFRBACEhsKF0JPVF9DSEFOR0VfVFlQRV9SRU1PVkVEEANiBnByb3RvMw");
+var TargetSchema = /* @__PURE__ */ messageDesc(file_dbk_v1_common, 0);
+var RpcErrorSchema = /* @__PURE__ */ messageDesc(file_dbk_v1_common, 1);
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  ErrorCode2[ErrorCode2["UNAUTHORIZED"] = 1] = "UNAUTHORIZED";
+  ErrorCode2[ErrorCode2["PROTOCOL"] = 2] = "PROTOCOL";
+  ErrorCode2[ErrorCode2["NOT_FOUND"] = 3] = "NOT_FOUND";
+  ErrorCode2[ErrorCode2["UNSUPPORTED"] = 4] = "UNSUPPORTED";
+  ErrorCode2[ErrorCode2["INTERNAL"] = 5] = "INTERNAL";
+  return ErrorCode2;
+})(ErrorCode || {});
+
+// src/gen/dbk/v1/rpc_pb.ts
+import { fileDesc as fileDesc2, messageDesc as messageDesc2 } from "@bufbuild/protobuf/codegenv2";
+var file_dbk_v1_rpc = /* @__PURE__ */ fileDesc2("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", [file_dbk_v1_common]);
+var HelloRequestSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 0);
+var HelloResponseSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 1);
+var ListBotsRequestSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 2);
+var ListBotsResponseSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 3);
+var BotSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 4);
+var BotChangedEventSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 5);
+var ListTargetsRequestSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 6);
+var ListTargetsResponseSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 7);
+var GetTargetRequestSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 8);
+var GetTargetResponseSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 9);
+var TargetInfoSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 10);
+var SendParamsSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 11);
+var SendResultSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 26);
+var SendReceiptSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 27);
+var RecallParamsSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 28);
+var RecallResultSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 29);
+var IncomingMessageSchema = /* @__PURE__ */ messageDesc2(file_dbk_v1_rpc, 30);
+
+// src/dbk/bots.ts
+import { create } from "@bufbuild/protobuf";
+var KOISHI_STATUS_ONLINE = 1;
+var KOISHI_STATUS_CONNECT = 2;
+var KOISHI_STATUS_RECONNECT = 4;
+var SATORI_MESSAGE_DELETE = "message.delete";
+var SATORI_GUILD_LIST = "guild.list";
+var SATORI_CHANNEL_LIST = "channel.list";
+var SATORI_GUILD_GET = "guild.get";
+var SATORI_CHANNEL_GET = "channel.get";
+var SATORI_FRIEND_LIST = "friend.list";
+var SATORI_USER_GET = "user.get";
+var SATORI_USER_CHANNEL_CREATE = "user.channel.create";
+var BotFeature = {
+  MESSAGE_RECALL: "message.recall",
+  MESSAGE_FORWARD: "message.forward",
+  MENTION_ALL: "mention.all",
+  TARGETS_LIST: "targets.list",
+  TARGET_USER: "target.user",
+  TARGET_GROUP: "target.group",
+  TARGET_CHANNEL: "target.channel",
+  TARGET_THREAD: "target.thread"
+};
+var TARGET_KIND_FEATURES = [
+  [1 /* USER */, BotFeature.TARGET_USER],
+  [2 /* GROUP */, BotFeature.TARGET_GROUP],
+  [3 /* CHANNEL */, BotFeature.TARGET_CHANNEL],
+  [4 /* THREAD */, BotFeature.TARGET_THREAD]
+];
+var THREAD_METHODS = [
+  "getThreadList",
+  "listActiveThreads",
+  "listPublicArchivedThreads",
+  "listPrivateArchivedThreads",
+  "startThread",
+  "startThreadFromMessage",
+  "startThreadWithoutMessage",
+  "createThread"
+];
+var MERGED_FORWARD_METHODS = [
+  "send_group_forward_msg",
+  "send_private_forward_msg",
+  "send_forward_msg",
+  "upload_forward_msg",
+  "sendGroupForwardMsg",
+  "sendPrivateForwardMsg",
+  "sendForwardMsg",
+  "uploadForwardMsg",
+  "sendGroupForwardMessage",
+  "sendPrivateForwardMessage",
+  "sendForwardMessage",
+  "sendMergeForward",
+  "send_merge_forward"
+];
+function listBots(ctx) {
+  return ctx.bots.filter((bot) => !bot.hidden).map(toDbkBot);
+}
+function toDbkBot(bot) {
+  const platform = bot.platform ?? "";
+  const selfId = bot.selfId ?? "";
+  return create(BotSchema, {
+    botKey: platform && selfId ? `${platform}:${selfId}` : "",
+    platform,
+    selfId,
+    name: bot.user?.name || bot.user?.nick || "",
+    avatar: bot.user?.avatar || "",
+    status: toDbkBotStatus(bot.status),
+    features: botFeatures(bot)
+  });
+}
+function toDbkBotStatus(status) {
+  switch (status) {
+    case KOISHI_STATUS_ONLINE:
+      return 1 /* READY */;
+    case KOISHI_STATUS_CONNECT:
+    case KOISHI_STATUS_RECONNECT:
+      return 3 /* CONNECTING */;
+    default:
+      return 2 /* UNAVAILABLE */;
+  }
+}
+function botFeatures(bot) {
+  const features = [];
+  if (canRecall(bot)) features.push(BotFeature.MESSAGE_RECALL);
+  if (canMergedForward(bot)) features.push(BotFeature.MESSAGE_FORWARD);
+  if (canMentionAll(bot)) features.push(BotFeature.MENTION_ALL);
+  if (canListTargets(bot)) features.push(BotFeature.TARGETS_LIST);
+  for (const kind of botTargetKinds(bot)) {
+    const feature = targetKindFeature(kind);
+    if (feature) features.push(feature);
+  }
+  return features;
+}
+function botTargetKinds(bot) {
+  const kinds = [];
+  const nested = hasNestedChannels(bot);
+  const guilds = hasGuildSurface(bot);
+  if (canDirectMessage(bot)) kinds.push(1 /* USER */);
+  if (nested) {
+    kinds.push(3 /* CHANNEL */);
+    kinds.push(4 /* THREAD */);
+  } else if (guilds) {
+    kinds.push(2 /* GROUP */);
+    kinds.push(3 /* CHANNEL */);
+  }
+  if (hasThreadSurface(bot) && !kinds.includes(4 /* THREAD */)) {
+    kinds.push(4 /* THREAD */);
+  }
+  return kinds;
+}
+function targetKindFeature(kind) {
+  return TARGET_KIND_FEATURES.find(([value]) => value === kind)?.[1];
+}
+function hasNestedChannels(bot) {
+  return hasBotMethod(bot, "getChannelList") || satoriFeatures(bot).includes(SATORI_CHANNEL_LIST);
+}
+function hasGuildSurface(bot) {
+  return hasBotMethod(bot, "getGuildList") || hasBotMethod(bot, "getGuild") || satoriFeatures(bot).includes(SATORI_GUILD_LIST) || satoriFeatures(bot).includes(SATORI_GUILD_GET);
+}
+function canListDirectUsers(bot) {
+  return hasBotMethod(bot, "getFriendList") || hasBotMethod(bot, "getUserList") || satoriFeatures(bot).includes(SATORI_FRIEND_LIST);
+}
+function canDirectMessage(bot) {
+  return canListDirectUsers(bot) || hasBotMethod(bot, "getUser") || hasBotMethod(bot, "createDirectChannel") || satoriFeatures(bot).includes(SATORI_USER_GET) || satoriFeatures(bot).includes(SATORI_USER_CHANNEL_CREATE) || looksDirectMessageOnly(bot);
+}
+function hasThreadSurface(bot) {
+  if (THREAD_METHODS.some((name2) => hasBotMethod(bot, name2) || hasInternalMethod(bot, name2))) {
+    return true;
+  }
+  return satoriFeatures(bot).some((feature) => feature.includes("thread"));
+}
+function canRecall(bot) {
+  return hasBotMethod(bot, "deleteMessage") || satoriFeatures(bot).includes(SATORI_MESSAGE_DELETE);
+}
+function canListTargets(bot) {
+  return hasBotMethod(bot, "getGuildList") || hasBotMethod(bot, "getChannelList") || hasBotMethod(bot, "getGuild") || hasBotMethod(bot, "getChannel") || satoriFeatures(bot).some((feature) => feature === SATORI_GUILD_LIST || feature === SATORI_CHANNEL_LIST || feature === SATORI_GUILD_GET || feature === SATORI_CHANNEL_GET);
+}
+function canMentionAll(bot) {
+  if (encoderHandlesMentionAll(bot)) return true;
+  if (hasGuildOrChannelSurface(bot)) return true;
+  return !looksDirectMessageOnly(bot);
+}
+function canMergedForward(bot) {
+  return MERGED_FORWARD_METHODS.some((name2) => hasBotMethod(bot, name2) || hasInternalMethod(bot, name2));
+}
+function hasGuildOrChannelSurface(bot) {
+  return canListTargets(bot) || hasBotMethod(bot, "getGuildMember") || hasBotMethod(bot, "getGuildMemberList");
+}
+function looksDirectMessageOnly(bot) {
+  if (hasGuildOrChannelSurface(bot)) return false;
+  const Encoder = messageEncoder(bot);
+  if (Encoder && !encoderHandlesMentionAll(bot)) {
+    return true;
+  }
+  return false;
+}
+function encoderHandlesMentionAll(bot) {
+  const visit = messageEncoder(bot)?.prototype?.visit;
+  if (typeof visit !== "function") return false;
+  try {
+    const src = Function.prototype.toString.call(visit);
+    return /type\s*===\s*['"]all['"]/.test(src) || /['"]all['"]\s*===\s*(?:attrs\.)?type/.test(src) || /id\s*===\s*['"]all['"]/.test(src) || /['"]all['"]\s*===\s*(?:attrs\.)?id/.test(src) || /@everyone/.test(src) || /atall/i.test(src);
+  } catch {
+    return false;
+  }
+}
+function messageEncoder(bot) {
+  return bot.constructor.MessageEncoder;
+}
+function satoriFeatures(bot) {
+  const features = bot.features;
+  if (!Array.isArray(features)) return [];
+  return features.filter((item) => typeof item === "string");
+}
+function hasInternalMethod(bot, name2) {
+  return hasBotMethod(bot.internal, name2);
+}
+function hasBotMethod(target, name2) {
+  if (!target) return false;
+  const value = target[name2];
+  return typeof value === "function" && !looksUnimplemented(value);
+}
+function looksUnimplemented(fn) {
+  try {
+    const src = Function.prototype.toString.call(fn);
+    return /not implemented|NotImplementedError/i.test(src);
+  } catch {
+    return false;
+  }
+}
+
+// src/gen/dbk/v1/frame_pb.ts
+import { enumDesc as enumDesc2, fileDesc as fileDesc3, messageDesc as messageDesc3 } from "@bufbuild/protobuf/codegenv2";
+var file_dbk_v1_frame = /* @__PURE__ */ fileDesc3("ChJkYmsvdjEvZnJhbWUucHJvdG8SBmRiay52MSJ/CgVGcmFtZRIbCgJvcBgBIAEoDjIPLmRiay52MS5GcmFtZU9wEgoKAmlkGAIgASgJEgsKA3NlcRgDIAEoBBIOCgZtZXRob2QYBCABKAkSDwoHcGF5bG9hZBgFIAEoDBIfCgVlcnJvchgGIAEoCzIQLmRiay52MS5ScGNFcnJvciqVAQoHRnJhbWVPcBIYChRGUkFNRV9PUF9VTlNQRUNJRklFRBAAEhEKDUZSQU1FX09QX0NBTEwQARIPCgtGUkFNRV9PUF9PSxACEhIKDkZSQU1FX09QX0VSUk9SEAMSEgoORlJBTUVfT1BfRVZFTlQQBBIRCg1GUkFNRV9PUF9QSU5HEAUSEQoNRlJBTUVfT1BfUE9ORxAGYgZwcm90bzM", [file_dbk_v1_common]);
+var FrameSchema = /* @__PURE__ */ messageDesc3(file_dbk_v1_frame, 0);
+var FrameOp = /* @__PURE__ */ ((FrameOp2) => {
+  FrameOp2[FrameOp2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+  FrameOp2[FrameOp2["CALL"] = 1] = "CALL";
+  FrameOp2[FrameOp2["OK"] = 2] = "OK";
+  FrameOp2[FrameOp2["ERROR"] = 3] = "ERROR";
+  FrameOp2[FrameOp2["EVENT"] = 4] = "EVENT";
+  FrameOp2[FrameOp2["PING"] = 5] = "PING";
+  FrameOp2[FrameOp2["PONG"] = 6] = "PONG";
+  return FrameOp2;
+})(FrameOp || {});
+
+// src/dbk/version.ts
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var FALLBACK = "0.0.0-dev";
+var PACKAGE_NAME = "koishi-plugin-dynamic-bot";
+function hereDir() {
+  try {
+    return dirname(fileURLToPath(import.meta.url));
+  } catch {
+    return process.cwd();
+  }
+}
+function readName(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    return pkg.name;
+  } catch {
+    return void 0;
+  }
+}
+function findPackageDir(start) {
+  let dir = start;
+  for (let i = 0; i < 8; i++) {
+    if (existsSync(join(dir, "package.json")) && readName(dir) === PACKAGE_NAME) {
+      return dir;
+    }
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function packageDir() {
+  const found = findPackageDir(hereDir());
+  if (found) return found;
+  const fromCwd = join(process.cwd(), "koishi");
+  if (existsSync(join(fromCwd, "package.json"))) return fromCwd;
+  return process.cwd();
+}
+function isProductRepo(root) {
+  return existsSync(join(root, "pnpm-workspace.yaml")) && existsSync(join(root, "jvm", "build.gradle.kts")) && existsSync(join(root, "koishi", "package.json"));
+}
+function gitDescribe(cwd) {
+  try {
+    const described = execFileSync(
+      "git",
+      ["describe", "--tags", "--always", "--abbrev=7", "--dirty"],
+      { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    return described || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function packageVersion(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    return pkg.version?.trim() || FALLBACK;
+  } catch {
+    return FALLBACK;
+  }
+}
+function resolveGatewayVersion() {
+  const pkg = packageDir();
+  const repoRoot = join(pkg, "..");
+  if (isProductRepo(repoRoot)) {
+    return gitDescribe(repoRoot) ?? packageVersion(pkg);
+  }
+  return packageVersion(pkg);
+}
+var GATEWAY_VERSION = resolveGatewayVersion();
+
+// src/dbk/protocol.ts
+var PROTOCOL_VERSION = "1";
+var PING_INTERVAL_MS = 1e4;
+var PONG_TIMEOUT_MS = 2e4;
+var DbkMethod = {
+  SESSION_HELLO: "session.hello",
+  BOTS_LIST: "bots.list",
+  TARGETS_LIST: "targets.list",
+  TARGETS_GET: "targets.get",
+  MESSAGE_SEND: "message.send",
+  MESSAGE_RECALL: "message.recall"
+};
+var DbkEvent = {
+  BOT_CHANGED: "bot.changed",
+  MESSAGE_CREATED: "message.created"
+};
+var DbkRpcCodecs = {
+  [DbkMethod.SESSION_HELLO]: { request: HelloRequestSchema, response: HelloResponseSchema },
+  [DbkMethod.BOTS_LIST]: { request: ListBotsRequestSchema, response: ListBotsResponseSchema },
+  [DbkMethod.TARGETS_LIST]: { request: ListTargetsRequestSchema, response: ListTargetsResponseSchema },
+  [DbkMethod.TARGETS_GET]: { request: GetTargetRequestSchema, response: GetTargetResponseSchema },
+  [DbkMethod.MESSAGE_SEND]: { request: SendParamsSchema, response: SendResultSchema },
+  [DbkMethod.MESSAGE_RECALL]: { request: RecallParamsSchema, response: RecallResultSchema }
+};
+var DbkEventCodecs = {
+  [DbkEvent.BOT_CHANGED]: BotChangedEventSchema,
+  [DbkEvent.MESSAGE_CREATED]: IncomingMessageSchema
+};
+
+// src/dbk/session.ts
+import { create as create3 } from "@bufbuild/protobuf";
+
+// src/dbk/codec.ts
+import { create as create2, fromBinary, fromJsonString, toBinary, toJsonString } from "@bufbuild/protobuf";
+
+// src/dbk/error.ts
+var DbkRpcError = class extends Error {
+  code;
+  constructor(code, detail) {
+    super(detail);
+    this.name = "DbkRpcError";
+    this.code = code;
+  }
+};
+
+// src/dbk/codec.ts
+function encodeFrame(frame, encoding) {
+  if (encoding === "json") {
+    return toJsonString(FrameSchema, frame);
+  }
+  return toBinary(FrameSchema, frame);
+}
+function decodeFrame(data, encoding) {
+  if (encoding === "json") {
+    const text = typeof data === "string" ? data : new TextDecoder().decode(data);
+    return fromJsonString(FrameSchema, text);
+  }
+  if (typeof data === "string") {
+    throw new DbkRpcError(2 /* PROTOCOL */, "DBK only accepts protobuf binary frames");
+  }
+  return fromBinary(FrameSchema, data);
+}
+function encodePayload(schema, message) {
+  return toBinary(schema, message);
+}
+function decodePayload(schema, bytes) {
+  return fromBinary(schema, bytes);
+}
+function createFrame(init) {
+  return create2(FrameSchema, init);
+}
+function toBytes(data) {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (Array.isArray(data)) {
+    const chunks = data.map((part) => toBytes(part));
+    const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return out;
+  }
+  throw new DbkRpcError(2 /* PROTOCOL */, "DBK frame is not binary");
+}
+
+// src/dbk/session.ts
+var DbkGatewaySession = class {
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.lastInboundAt = this.now();
+  }
+  closed = false;
+  handshook = false;
+  seq = 0n;
+  sendQueue = Promise.resolve();
+  lastInboundAt;
+  heartbeat;
+  now;
+  get isHandshook() {
+    return this.handshook && !this.closed;
+  }
+  onFrame(frame) {
+    if (this.closed) return;
+    this.lastInboundAt = this.now();
+    void this.handle(frame);
+  }
+  rejectText() {
+    this.fail("DBK only accepts protobuf binary frames");
+  }
+  rejectDecode(error) {
+    this.options.logger.warn("DBK frame decode failed: %s", error);
+    this.fail("DBK frame could not be decoded");
+  }
+  emit(method, event) {
+    if (!this.isHandshook) return;
+    this.seq += 1n;
+    this.enqueueFrame(
+      createFrame({
+        op: 4 /* EVENT */,
+        seq: this.seq,
+        method,
+        payload: encodePayload(DbkEventCodecs[method], event)
+      })
+    );
+  }
+  close(reason = "closed") {
+    if (this.closed) return;
+    this.closed = true;
+    this.handshook = false;
+    if (this.heartbeat) {
+      clearInterval(this.heartbeat);
+      this.heartbeat = void 0;
+    }
+    this.options.logger.debug("DBK session closed: %s", reason);
+  }
+  async handle(frame) {
+    switch (frame.op) {
+      case 5 /* PING */:
+        if (!this.handshook) return;
+        this.enqueueFrame(createFrame({ op: 6 /* PONG */, id: frame.id }));
+        return;
+      case 6 /* PONG */:
+        return;
+      case 1 /* CALL */:
+        await this.handleCall(frame);
+        return;
+      case 4 /* EVENT */:
+      case 2 /* OK */:
+      case 3 /* ERROR */:
+        this.options.logger.debug("gateway ignored peer %s: method=%s", FrameOp[frame.op], frame.method);
+        return;
+      default:
+        this.options.logger.warn("ignored DBK frame with unspecified op");
+    }
+  }
+  async handleCall(frame) {
+    if (!frame.id) {
+      this.replyError("", 2 /* PROTOCOL */, "CALL is missing id");
+      return;
+    }
+    if (!this.handshook && frame.method !== DbkMethod.SESSION_HELLO) {
+      this.options.logger.debug("drop CALL before handshake: method=%s", frame.method);
+      this.replyError(frame.id, 2 /* PROTOCOL */, "DBK handshake is not complete");
+      return;
+    }
+    if (!(frame.method in DbkRpcCodecs)) {
+      this.replyError(frame.id, 4 /* UNSUPPORTED */, `unknown method: ${frame.method}`);
+      return;
+    }
+    try {
+      const payload = await this.dispatchCall(frame.method, frame.payload);
+      this.enqueueFrame(
+        createFrame({
+          op: 2 /* OK */,
+          id: frame.id,
+          method: frame.method,
+          payload
+        })
+      );
+    } catch (error) {
+      const rpcError = error instanceof DbkRpcError ? error : new DbkRpcError(5 /* INTERNAL */, error instanceof Error ? error.message : String(error));
+      this.options.logger.warn("DBK RPC failed: method=%s code=%s %s", frame.method, ErrorCode[rpcError.code], rpcError.message);
+      this.replyError(frame.id, rpcError.code, rpcError.message);
+      if (frame.method === DbkMethod.SESSION_HELLO && rpcError.code === 1 /* UNAUTHORIZED */) {
+        this.options.onUnauthorized?.();
+        await this.sendQueue;
+        this.fail(rpcError.message);
+      }
+    }
+  }
+  dispatchCall(method, payload) {
+    switch (method) {
+      case DbkMethod.SESSION_HELLO:
+        return this.runRpc(method, payload, (request) => this.hello(request));
+      case DbkMethod.BOTS_LIST:
+      case DbkMethod.TARGETS_LIST:
+      case DbkMethod.TARGETS_GET:
+      case DbkMethod.MESSAGE_SEND:
+      case DbkMethod.MESSAGE_RECALL:
+        return this.runRpc(method, payload, this.options.handlers[method]);
+      default:
+        return Promise.reject(new DbkRpcError(4 /* UNSUPPORTED */, `unknown method: ${method}`));
+    }
+  }
+  async runRpc(method, payload, handler) {
+    const codec = DbkRpcCodecs[method];
+    const request = decodePayload(codec.request, payload);
+    const response = await handler(request);
+    return encodePayload(codec.response, response);
+  }
+  async hello(request) {
+    if (request.token !== this.options.accessToken) {
+      throw new DbkRpcError(1 /* UNAUTHORIZED */, "invalid access token");
+    }
+    const remote = request.protocolVersion.trim();
+    if (remote && remote !== PROTOCOL_VERSION) {
+      throw new DbkRpcError(
+        2 /* PROTOCOL */,
+        `protocol version mismatch: local=${PROTOCOL_VERSION} remote=${remote}`
+      );
+    }
+    const response = await this.options.handlers[DbkMethod.SESSION_HELLO](request);
+    this.handshook = true;
+    this.startHeartbeat();
+    this.options.logger.info(
+      "DBK handshake complete: bots=%d app=%s",
+      response.bots.length,
+      request.appVersion || "-"
+    );
+    return response;
+  }
+  replyError(id, code, detail) {
+    this.enqueueFrame(
+      createFrame({
+        op: 3 /* ERROR */,
+        id,
+        error: create3(RpcErrorSchema, { code, detail })
+      })
+    );
+  }
+  startHeartbeat() {
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    this.lastInboundAt = this.now();
+    this.heartbeat = setInterval(() => {
+      if (this.closed) return;
+      if (this.now() - this.lastInboundAt >= PONG_TIMEOUT_MS) {
+        this.fail("DBK heartbeat timed out");
+        return;
+      }
+      this.enqueueFrame(createFrame({ op: 5 /* PING */ }));
+    }, PING_INTERVAL_MS);
+  }
+  enqueueFrame(frame) {
+    this.sendQueue = this.sendQueue.then(() => {
+      if (this.closed) return;
+      this.options.send(encodeFrame(frame, this.options.encoding));
+    }).catch((error) => {
+      this.options.logger.warn("DBK send failed: %s", error);
+      this.fail("DBK send failed");
+    });
+  }
+  fail(reason) {
+    if (this.closed) return;
+    this.options.onDead(reason);
+    this.close(reason);
+  }
+};
+
+// src/dbk/socket.ts
+var WS_OPEN = 1;
+function sendSocket(socket, data) {
+  if (socket.readyState !== WS_OPEN) {
+    throw new Error("WebSocket is not open");
+  }
+  socket.send(data);
+}
+function attachSocket(socket, session, encoding) {
+  if (socket.binaryType !== void 0) {
+    socket.binaryType = "arraybuffer";
+  }
+  const onMessage = (data, isBinary) => {
+    const binary = isBinary ?? typeof data !== "string";
+    if (encoding === "binary" && !binary) {
+      session.rejectText();
+      return;
+    }
+    try {
+      const raw = typeof data === "string" ? data : toBytes(data);
+      session.onFrame(decodeFrame(raw, encoding));
+    } catch (error) {
+      session.rejectDecode(error);
+    }
+  };
+  const onClose = () => session.close("ws close");
+  if (typeof socket.on === "function") {
+    socket.on("message", (data, isBinary) => onMessage(data, isBinary));
+    socket.on("close", onClose);
+    return;
+  }
+  socket.addEventListener?.("message", (event) => onMessage(event.data));
+  socket.addEventListener?.("close", onClose);
+}
+
+// src/dbk/gateway.ts
+var RECONNECT_BACKOFF_MS = [
+  5e3,
+  1e4,
+  3e4,
+  6e4,
+  5 * 6e4,
+  10 * 6e4,
+  30 * 6e4,
+  60 * 6e4
+];
+var DbkGateway = class {
+  constructor(ctx, config, handlers) {
+    this.ctx = ctx;
+    this.config = config;
+    this.handlers = handlers;
+  }
+  session;
+  socket;
+  closing = false;
+  reconnectAttempts = 0;
+  reconnectTimer;
+  reconnectSuspended = false;
+  get isHandshook() {
+    return this.session?.isHandshook ?? false;
+  }
+  emit(method, event) {
+    this.session?.emit(method, event);
+  }
+  startForward() {
+    const path = normalizePath(this.config.path);
+    this.ctx.logger.info("DBK forward WebSocket mounted on Koishi HTTP at %s", path);
+    this.ctx.server.ws(path, (socket) => {
+      this.attach("replaced", socket);
+    });
+  }
+  startReverse() {
+    this.connectReverse();
+  }
+  stop() {
+    this.closing = true;
+    this.reconnectTimer?.();
+    this.reconnectTimer = void 0;
+    this.session?.close("plugin stop");
+    this.session = void 0;
+    this.socket?.close(1e3, "plugin stop");
+    this.socket = void 0;
+  }
+  connectReverse() {
+    if (this.closing) return;
+    const url = `ws://${this.config.host}:${this.config.port}`;
+    this.ctx.logger.info("DBK reverse WebSocket connecting to %s", url);
+    const socket = this.ctx.http.ws(url);
+    const onOpen = () => {
+      this.reconnectAttempts = 0;
+      this.attach("ws close", socket);
+    };
+    if (typeof socket.on === "function") {
+      socket.on("open", onOpen);
+      socket.on("error", (error) => this.ctx.logger.warn("DBK reverse WebSocket error: %s", error));
+      socket.on("close", () => this.onReverseClosed());
+    } else {
+      socket.addEventListener?.("open", onOpen);
+      socket.addEventListener?.("close", () => this.onReverseClosed());
+    }
+  }
+  attach(replaceReason, socket) {
+    if (this.socket && this.socket !== socket) {
+      this.ctx.logger.warn("replacing existing DBK connection");
+      this.session?.close(replaceReason);
+      this.socket.close(1e3, replaceReason);
+    }
+    this.socket = socket;
+    const session = new DbkGatewaySession({
+      encoding: this.config.encoding,
+      accessToken: this.config.accessToken,
+      handlers: this.handlers,
+      logger: this.ctx.logger,
+      send: (data) => sendSocket(socket, data),
+      onDead: (reason) => {
+        socket.close(1e3, reason.slice(0, 123));
+      },
+      onUnauthorized: () => {
+        this.reconnectSuspended = true;
+        this.ctx.logger.warn("DBK unauthorized, automatic reconnect paused");
+      }
+    });
+    this.session = session;
+    attachSocket(socket, session, this.config.encoding);
+  }
+  onReverseClosed() {
+    this.session?.close("ws close");
+    if (this.socket) this.socket = void 0;
+    this.session = void 0;
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    if (this.closing || !this.config.reconnect || this.reconnectSuspended) return;
+    this.reconnectTimer?.();
+    const attempt = this.reconnectAttempts + 1;
+    this.reconnectAttempts = attempt;
+    const delay = RECONNECT_BACKOFF_MS[Math.min(attempt, RECONNECT_BACKOFF_MS.length) - 1];
+    this.ctx.logger.warn("DBK reverse disconnected, reconnecting in %dms (attempt=%d)", delay, attempt);
+    this.reconnectTimer = this.ctx.setTimeout(() => {
+      this.reconnectTimer = void 0;
+      this.connectReverse();
+    }, delay);
+  }
+};
+function watchBots(ctx, gateway) {
+  const emit = (type, bot) => {
+    if (bot.hidden && type !== 3 /* REMOVED */) return;
+    gateway.emit(DbkEvent.BOT_CHANGED, create4(BotChangedEventSchema, {
+      type,
+      bot: toDbkBot(bot)
+    }));
+  };
+  ctx.on("bot-added", (bot) => emit(1 /* ADDED */, bot));
+  ctx.on("bot-removed", (bot) => emit(3 /* REMOVED */, bot));
+  ctx.on("bot-status-updated", (bot) => emit(2 /* UPDATED */, bot));
+}
+function normalizePath(path) {
+  const trimmed = path.trim() || "/dbk";
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+// src/dbk/handlers.ts
+import { create as create9 } from "@bufbuild/protobuf";
+
+// src/dbk/get-target.ts
+import { create as create5 } from "@bufbuild/protobuf";
+
+// src/dbk/avatar.ts
+var AVATAR_KEYS = [
+  "avatar",
+  "avatarUrl",
+  "avatar_url",
+  "icon",
+  "iconUrl",
+  "icon_url",
+  "photoUrl",
+  "photo_url"
+];
+function pickAvatar(...sources) {
+  for (const source of sources) {
+    const value = avatarFrom(source);
+    if (value) return value;
+  }
+  return "";
+}
+function avatarFrom(source) {
+  if (typeof source === "string") return sanitize(source);
+  if (!source || typeof source !== "object") return "";
+  const rec = source;
+  const nested = rec.user && typeof rec.user === "object" ? rec.user : void 0;
+  for (const obj of [nested, rec]) {
+    if (!obj) continue;
+    for (const key of AVATAR_KEYS) {
+      const value = sanitize(obj[key]);
+      if (value) return value;
+    }
+  }
+  return photoUri(rec.photo);
+}
+function photoUri(photo) {
+  if (typeof photo === "string") return sanitize(photo);
+  if (!photo || typeof photo !== "object") return "";
+  const rec = photo;
+  for (const key of ["url", "big", "small", "src"]) {
+    const value = sanitize(rec[key]);
+    if (value) return value;
+  }
+  return "";
+}
+function sanitize(value) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  if (!/^(https?:|data:|file:|\/\/)/i.test(trimmed) && !trimmed.includes("/")) {
+    return "";
+  }
+  return trimmed;
+}
+
+// src/dbk/get-target.ts
+var CHANNEL_TEXT = 0;
+var CHANNEL_DIRECT = 1;
+var CHANNEL_CATEGORY = 2;
+var CHANNEL_VOICE = 3;
+var DISCORD_THREAD_TYPES = /* @__PURE__ */ new Set([10, 11, 12]);
+async function getTarget(ctx, request) {
+  const botKey = request.botKey.trim();
+  const target = request.target;
+  if (botKey) {
+    const bot = findBot(ctx, botKey);
+    if (!bot) {
+      throw new DbkRpcError(3 /* NOT_FOUND */, `bot not found: ${botKey}`);
+    }
+    const info = await resolveOnBot(bot, target);
+    return info ? resolved(info) : unresolved(target);
+  }
+  for (const bot of listSearchableBots(ctx)) {
+    const info = await resolveOnBot(bot, target);
+    if (info) return resolved(info);
+  }
+  return unresolved(target);
+}
+function findBot(ctx, botKey) {
+  return ctx.bots.find((bot) => !bot.hidden && botKeyOf(bot) === botKey);
+}
+function listSearchableBots(ctx) {
+  return ctx.bots.filter((bot) => !bot.hidden && (bot.platform ?? "").toLowerCase() !== "qq");
+}
+function botKeyOf(bot) {
+  const platform = bot.platform ?? "";
+  const selfId = bot.selfId ?? "";
+  return platform && selfId ? `${platform}:${selfId}` : "";
+}
+async function resolveOnBot(bot, target) {
+  const id = target?.id.trim() ?? "";
+  if (!id) return void 0;
+  const guildId = target?.guildId.trim() ?? "";
+  const kind = target?.kind ?? 0 /* UNSPECIFIED */;
+  try {
+    switch (kind) {
+      case 1 /* USER */:
+        return await resolveUser(bot, id, guildId);
+      case 2 /* GROUP */:
+        return await resolveGroup(bot, id, guildId);
+      case 3 /* CHANNEL */:
+        return await resolveChannelKind(bot, id, guildId, 3 /* CHANNEL */);
+      case 4 /* THREAD */:
+        return await resolveChannelKind(bot, id, guildId, 4 /* THREAD */);
+      default:
+        return await resolveChannelKind(bot, id, guildId, 0 /* UNSPECIFIED */) ?? await resolveGroup(bot, id, guildId) ?? await resolveUser(bot, id, guildId);
+    }
+  } catch {
+    return void 0;
+  }
+}
+async function resolveUser(bot, id, guildId) {
+  const user = await callBot(bot, "getUser", () => bot.getUser(id, guildId || void 0));
+  if (user) return toUserInfo(bot, user, guildId);
+  const friend = await callFriend(bot, id);
+  if (friend) return toUserInfo(bot, friend, guildId);
+  const channel = await callBot(bot, "getChannel", () => bot.getChannel(id, guildId || void 0));
+  if (channel && channelKind(bot, channel, 1 /* USER */) === 1 /* USER */) {
+    return toChannelInfo(bot, channel, 1 /* USER */, guildId);
+  }
+  return void 0;
+}
+async function resolveGroup(bot, id, guildId) {
+  if (!hasNestedChannels(bot)) {
+    const guild = await callBot(bot, "getGuild", () => bot.getGuild(id));
+    if (guild) {
+      const kind = kindFromGuild(bot, guild);
+      if (kind) return toGuildInfo(bot, guild, kind);
+    }
+  }
+  return resolveChannelKind(bot, id, guildId, 2 /* GROUP */);
+}
+async function resolveChannelKind(bot, id, guildId, requested) {
+  const channel = await callBot(bot, "getChannel", () => bot.getChannel(id, guildId || void 0));
+  if (!channel) return void 0;
+  const kind = channelKind(bot, channel, requested);
+  if (!kind) return void 0;
+  return toChannelInfo(bot, channel, kind, guildId);
+}
+function channelKind(bot, channel, requested) {
+  const nested = hasNestedChannels(bot);
+  const type = channel.type ?? CHANNEL_TEXT;
+  if (type === CHANNEL_DIRECT) return 1 /* USER */;
+  if (type === CHANNEL_CATEGORY || type === CHANNEL_VOICE) return void 0;
+  if (DISCORD_THREAD_TYPES.has(type) || requested === 4 /* THREAD */) {
+    if (requested === 1 /* USER */) return void 0;
+    if (requested === 2 /* GROUP */ && nested) return void 0;
+    return 4 /* THREAD */;
+  }
+  if (requested === 1 /* USER */) return void 0;
+  if (!nested) {
+    if (requested === 3 /* CHANNEL */) return 3 /* CHANNEL */;
+    return 2 /* GROUP */;
+  }
+  if (requested === 2 /* GROUP */) return void 0;
+  return 3 /* CHANNEL */;
+}
+function kindFromGuild(bot, guild) {
+  const chatType = guild.type;
+  if (chatType === "private") return 1 /* USER */;
+  if (chatType === "channel") return 3 /* CHANNEL */;
+  if (chatType === "group" || chatType === "supergroup") return 2 /* GROUP */;
+  if (hasNestedChannels(bot)) return void 0;
+  return 2 /* GROUP */;
+}
+async function toChannelInfo(bot, channel, kind, requestGuildId) {
+  const id = stringifyId(channel.id);
+  const guildId = requestGuildId || stringifyId(channel.guildId);
+  const guild = guildId ? await lookupGuild(bot, guildId) : void 0;
+  return create5(TargetInfoSchema, {
+    target: create5(TargetSchema, { kind, id, guildId }),
+    name: channel.name?.trim() || id,
+    guildId: stringifyId(guild?.id) || guildId,
+    guildName: guildDisplayName(guild),
+    avatar: pickAvatar(channel, guild),
+    botKeys: [botKeyOf(bot)]
+  });
+}
+function toGuildInfo(bot, guild, kind) {
+  const id = stringifyId(guild.id) || stringifyId(guild.guildId);
+  const guildId = kind === 1 /* USER */ ? "" : id;
+  return create5(TargetInfoSchema, {
+    target: create5(TargetSchema, { kind, id, guildId }),
+    name: guildDisplayName(guild) || id,
+    guildId,
+    guildName: kind === 1 /* USER */ ? "" : guildDisplayName(guild),
+    avatar: pickAvatar(guild),
+    botKeys: [botKeyOf(bot)]
+  });
+}
+function toUserInfo(bot, user, guildId) {
+  const id = stringifyId(user.id);
+  return create5(TargetInfoSchema, {
+    target: create5(TargetSchema, { kind: 1 /* USER */, id, guildId }),
+    name: user.nick?.trim() || user.name?.trim() || user.username?.trim() || id,
+    guildId,
+    guildName: "",
+    avatar: pickAvatar(user),
+    botKeys: [botKeyOf(bot)]
+  });
+}
+async function lookupGuild(bot, guildId) {
+  return callBot(bot, "getGuild", () => bot.getGuild(guildId));
+}
+function guildDisplayName(guild) {
+  if (!guild) return "";
+  return guild.name?.trim() || guild.guildName?.trim() || guild.title?.trim() || guild.first_name?.trim() || "";
+}
+function stringifyId(value) {
+  if (value === void 0 || value === null) return "";
+  return String(value).trim();
+}
+function resolved(target) {
+  return create5(GetTargetResponseSchema, { target, unresolved: false });
+}
+function unresolved(requestTarget) {
+  return create5(GetTargetResponseSchema, {
+    unresolved: true,
+    target: requestTarget ? create5(TargetInfoSchema, {
+      target: requestTarget
+    }) : void 0
+  });
+}
+async function callBot(bot, method, fn) {
+  if (typeof bot[method] !== "function") return void 0;
+  try {
+    return await fn();
+  } catch {
+    return void 0;
+  }
+}
+async function callFriend(bot, id) {
+  const getFriend = bot.getFriend;
+  if (typeof getFriend !== "function") return void 0;
+  try {
+    return await getFriend.call(bot, id);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/dbk/list-targets.ts
+import { create as create6 } from "@bufbuild/protobuf";
+var CHANNEL_TEXT2 = 0;
+var CHANNEL_CATEGORY2 = 2;
+var CHANNEL_DIRECT_OR_VOICE = /* @__PURE__ */ new Set([1, 3]);
+var DISCORD_THREAD_TYPES2 = /* @__PURE__ */ new Set([10, 11, 12]);
+var MAX_LIST_PAGES = 64;
+var MAX_LIST_ITEMS = 1e4;
+async function listTargets(ctx, request) {
+  const bots = resolveBots(ctx, request.botKey);
+  const kindFilter = request.kind ?? 0 /* UNSPECIFIED */;
+  const merged = /* @__PURE__ */ new Map();
+  let incomplete = false;
+  for (const bot of bots) {
+    if (isQq(bot)) continue;
+    const listed = await listTargetsForBot(ctx, bot, kindFilter);
+    incomplete = incomplete || listed.incomplete;
+    for (const target of listed.targets) {
+      mergeTarget(merged, target);
+    }
+  }
+  return create6(ListTargetsResponseSchema, {
+    targets: [...merged.values()].map((target) => ({
+      target: { kind: target.kind, id: target.id, guildId: target.guildId },
+      name: target.name,
+      guildId: target.guildId,
+      guildName: target.guildName,
+      avatar: target.avatar,
+      botKeys: target.botKeys
+    })),
+    incomplete
+  });
+}
+function resolveBots(ctx, botKey) {
+  const key = botKey?.trim() ?? "";
+  const visible = ctx.bots.filter((bot) => !bot.hidden);
+  if (!key) return visible;
+  const found = findBot2(ctx, key);
+  if (!found) {
+    throw new DbkRpcError(3 /* NOT_FOUND */, `bot not found: ${key}`);
+  }
+  return [found];
+}
+function findBot2(ctx, botKey) {
+  return ctx.bots.find((bot) => !bot.hidden && botKeyOf2(bot) === botKey);
+}
+function botKeyOf2(bot) {
+  const platform = bot.platform ?? "";
+  const selfId = bot.selfId ?? "";
+  return platform && selfId ? `${platform}:${selfId}` : "";
+}
+function isQq(bot) {
+  return (bot.platform ?? "").toLowerCase() === "qq";
+}
+function wantsKind(filter, kind) {
+  return filter === 0 /* UNSPECIFIED */ || filter === kind;
+}
+async function listTargetsForBot(ctx, bot, kindFilter) {
+  const botKey = botKeyOf2(bot);
+  const targets = [];
+  const nested = hasNestedChannels(bot);
+  const supported = botTargetKinds(bot);
+  if (kindFilter !== 0 /* UNSPECIFIED */ && supported.length > 0 && !supported.includes(kindFilter)) {
+    return { targets, incomplete: false };
+  }
+  let incomplete = hasGuildSurface(bot) && !nested;
+  const wantGuilds = wantsKind(kindFilter, 2 /* GROUP */) || wantsKind(kindFilter, 3 /* CHANNEL */) || wantsKind(kindFilter, 4 /* THREAD */);
+  const wantUsers = wantsKind(kindFilter, 1 /* USER */);
+  if (wantGuilds) {
+    const guilds = await paginate((next) => callBotList(bot, "getGuildList", next));
+    if (guilds.unsupported || guilds.failed || guilds.truncated) incomplete = true;
+    if (guilds.failed && !guilds.unsupported) {
+      ctx.logger?.debug("targets.list: %s getGuildList failed", botKey);
+    }
+    let channelMode = nested ? "unknown" : "flat";
+    for (const guild of guilds.items) {
+      const guildId = String(guild.id ?? "").trim();
+      if (!guildId) continue;
+      const guildName = String(guild.name ?? "").trim();
+      if (channelMode === "flat") {
+        pushTarget(targets, kindFilter, {
+          kind: kindFromListedGuild(guild),
+          id: guildId,
+          guildId: "",
+          name: guildName || guildId,
+          guildName: "",
+          avatar: pickAvatar(guild),
+          botKeys: [botKey]
+        });
+        continue;
+      }
+      const channels = await paginate((next) => callBotList(bot, "getChannelList", next, guildId));
+      if (channels.truncated) incomplete = true;
+      if (channels.unsupported) {
+        channelMode = "flat";
+        pushTarget(targets, kindFilter, {
+          kind: kindFromListedGuild(guild),
+          id: guildId,
+          guildId: "",
+          name: guildName || guildId,
+          guildName: "",
+          avatar: pickAvatar(guild),
+          botKeys: [botKey]
+        });
+        continue;
+      }
+      if (channels.failed) {
+        incomplete = true;
+        ctx.logger?.debug("targets.list: %s getChannelList failed guild=%s", botKey, guildId);
+        continue;
+      }
+      channelMode = "nested";
+      const classified = classifyGuildChannels(channels.items, guildId, guildName, pickAvatar(guild), botKey);
+      for (const target of classified) {
+        pushTarget(targets, kindFilter, target);
+      }
+    }
+  }
+  if (wantUsers) {
+    if (canListDirectUsers(bot)) {
+      const friends = await listDirectUsers(bot);
+      if (friends.truncated) incomplete = true;
+      if (friends.failed && !friends.unsupported) {
+        incomplete = true;
+        ctx.logger?.debug("targets.list: %s friend/user list failed", botKey);
+      }
+      for (const user of friends.items) {
+        pushTarget(targets, kindFilter, {
+          kind: 1 /* USER */,
+          id: user.id,
+          guildId: "",
+          name: user.name,
+          guildName: "",
+          avatar: user.avatar,
+          botKeys: [botKey]
+        });
+      }
+    } else if (supported.includes(1 /* USER */) || supported.length === 0) {
+      incomplete = true;
+    }
+  }
+  return { targets, incomplete };
+}
+function classifyGuildChannels(channels, guildId, guildName, guildAvatar, botKey) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const channel of channels) {
+    const id = String(channel.id ?? "").trim();
+    if (id) byId.set(id, channel);
+  }
+  const out = [];
+  for (const channel of channels) {
+    const id = String(channel.id ?? "").trim();
+    if (!id) continue;
+    const kind = classifyChannel(channel, byId);
+    if (kind == null) continue;
+    const name2 = String(channel.name ?? "").trim() || id;
+    out.push({
+      kind,
+      id,
+      guildId,
+      name: name2,
+      guildName,
+      avatar: pickAvatar(channel) || guildAvatar,
+      botKeys: [botKey]
+    });
+  }
+  return out;
+}
+function classifyChannel(channel, byId) {
+  const type = channel.type;
+  if (type === CHANNEL_CATEGORY2 || type != null && CHANNEL_DIRECT_OR_VOICE.has(type)) {
+    return null;
+  }
+  if (type != null && DISCORD_THREAD_TYPES2.has(type)) {
+    return 4 /* THREAD */;
+  }
+  if (type != null && type !== CHANNEL_TEXT2) {
+    return null;
+  }
+  const parentId = String(channel.parentId ?? channel.parent_id ?? "").trim();
+  if (parentId) {
+    const parent = byId.get(parentId);
+    if (parent && isTextLikeChannel(parent)) {
+      return 4 /* THREAD */;
+    }
+  }
+  return 3 /* CHANNEL */;
+}
+function kindFromListedGuild(guild) {
+  const chatType = guild.type;
+  if (chatType === "private") return 1 /* USER */;
+  if (chatType === "channel") return 3 /* CHANNEL */;
+  if (chatType === "group" || chatType === "supergroup") return 2 /* GROUP */;
+  return 2 /* GROUP */;
+}
+function isTextLikeChannel(channel) {
+  const type = channel.type;
+  if (type === CHANNEL_CATEGORY2 || type != null && CHANNEL_DIRECT_OR_VOICE.has(type)) {
+    return false;
+  }
+  return type == null || type === CHANNEL_TEXT2 || DISCORD_THREAD_TYPES2.has(type);
+}
+async function listDirectUsers(bot) {
+  const collected = [];
+  let truncated = false;
+  let sawSupported = false;
+  let sawFailure = false;
+  let sawSuccess = false;
+  for (const method of ["getFriendList", "getUserList"]) {
+    const page = await paginate((next) => callBotList(bot, method, next));
+    if (page.unsupported) continue;
+    sawSupported = true;
+    truncated = truncated || page.truncated;
+    if (page.failed) sawFailure = true;
+    else sawSuccess = true;
+    for (const item of page.items) {
+      const user = userFromListItem(item);
+      if (user) collected.push(user);
+    }
+  }
+  return {
+    items: collected,
+    truncated,
+    unsupported: !sawSupported,
+    failed: sawSupported && sawFailure && !sawSuccess
+  };
+}
+function userFromListItem(item) {
+  if (!item || typeof item !== "object") return void 0;
+  const rec = item;
+  const nested = rec.user && typeof rec.user === "object" ? rec.user : rec;
+  const id = String(nested.id ?? rec.id ?? rec.userId ?? rec.user_id ?? "").trim();
+  if (!id) return void 0;
+  const name2 = String(nested.name ?? nested.nick ?? rec.nick ?? rec.name ?? "").trim();
+  return { id, name: name2 || id, avatar: pickAvatar(nested, rec) };
+}
+function pushTarget(targets, kindFilter, target) {
+  if (!wantsKind(kindFilter, target.kind)) return;
+  if (!target.botKeys[0]) return;
+  targets.push(target);
+}
+function mergeTarget(merged, incoming) {
+  const key = `${incoming.kind}\0${incoming.id}\0${incoming.guildId}`;
+  const existing = merged.get(key);
+  if (!existing) {
+    merged.set(key, { ...incoming, botKeys: [...incoming.botKeys] });
+    return;
+  }
+  existing.botKeys = unionKeys(existing.botKeys, incoming.botKeys);
+  if (!existing.name || existing.name === existing.id) {
+    existing.name = incoming.name || existing.name;
+  }
+  if (!existing.guildName) existing.guildName = incoming.guildName;
+  if (!existing.avatar) existing.avatar = incoming.avatar;
+}
+function unionKeys(left, right) {
+  const seen = new Set(left);
+  const out = [...left];
+  for (const key of right) {
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(key);
+  }
+  return out;
+}
+async function paginate(fetch) {
+  const items = [];
+  const seenTokens = /* @__PURE__ */ new Set();
+  let next;
+  let pages = 0;
+  while (true) {
+    pages += 1;
+    if (pages > MAX_LIST_PAGES || items.length >= MAX_LIST_ITEMS) {
+      return { items, truncated: true, unsupported: false, failed: false };
+    }
+    let raw;
+    try {
+      raw = await fetch(next);
+    } catch (error) {
+      if (isUnsupported(error)) {
+        if (items.length > 0) {
+          return { items, truncated: true, unsupported: false, failed: false };
+        }
+        return { items, truncated: false, unsupported: true, failed: false };
+      }
+      return { items, truncated: items.length > 0, unsupported: false, failed: true };
+    }
+    if (raw == null) break;
+    if (typeof raw.then === "function") {
+      raw = await raw;
+    }
+    if (isAsyncIterableObject(raw) && !hasListData(raw)) {
+      try {
+        const collected = await collectFromIterable(raw);
+        items.push(...collected.items);
+        return {
+          items,
+          truncated: collected.truncated,
+          unsupported: false,
+          failed: false
+        };
+      } catch (error) {
+        if (isUnsupported(error) && items.length === 0) {
+          return { items, truncated: false, unsupported: true, failed: false };
+        }
+        return { items, truncated: items.length > 0, unsupported: false, failed: true };
+      }
+    }
+    const page = normalizePage(raw);
+    items.push(...page.data);
+    const token = page.next;
+    if (!token || seenTokens.has(token) || page.data.length === 0) break;
+    seenTokens.add(token);
+    next = token;
+  }
+  return { items, truncated: false, unsupported: false, failed: false };
+}
+function normalizePage(raw) {
+  if (Array.isArray(raw)) {
+    return { data: raw };
+  }
+  if (!raw || typeof raw !== "object") {
+    return { data: [] };
+  }
+  const rec = raw;
+  const data = Array.isArray(rec.data) ? rec.data : [];
+  const next = rec.next == null || rec.next === "" ? void 0 : String(rec.next);
+  return { data, next };
+}
+function callBotList(bot, method, next, guildId) {
+  const fn = bot[method];
+  if (typeof fn !== "function") {
+    return Promise.reject(new Error(`${method} is not supported`));
+  }
+  if (method === "getChannelList") {
+    return Promise.resolve(fn.call(bot, guildId ?? "", next));
+  }
+  return Promise.resolve(fn.call(bot, next));
+}
+function hasListData(value) {
+  return Array.isArray(value.data);
+}
+function isAsyncIterableObject(value) {
+  return typeof value === "object" && value != null && Symbol.asyncIterator in value && !Array.isArray(value);
+}
+async function collectFromIterable(iterable) {
+  const items = [];
+  for await (const item of iterable) {
+    items.push(item);
+    if (items.length >= MAX_LIST_ITEMS) return { items, truncated: true };
+  }
+  return { items, truncated: false };
+}
+function isUnsupported(error) {
+  if (error && typeof error === "object" && "name" in error) {
+    const name2 = String(error.name);
+    if (/unsupported/i.test(name2)) return true;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return /not (implemented|supported)|unsupported|is not a function/i.test(message);
+}
+
+// src/dbk/recall.ts
+import { create as create7 } from "@bufbuild/protobuf";
+var KOISHI_STATUS_ONLINE2 = 1;
+var KOISHI_STATUS_CONNECT2 = 2;
+var KOISHI_STATUS_RECONNECT2 = 4;
+var RECALL_TIMEOUT_MS = 25e3;
+async function recallMessage(ctx, params) {
+  const bot = findBot3(ctx, params.botKey);
+  if (!bot) {
+    throw new DbkRpcError(3 /* NOT_FOUND */, `bot not found: ${params.botKey.trim() || "(empty)"}`);
+  }
+  if (!botCanRecall(bot)) {
+    return failed("bot has no message.recall capability", false);
+  }
+  const notReady = notReadyResult(bot);
+  if (notReady) return notReady;
+  const messageId = params.messageId.trim();
+  if (!messageId) {
+    return failed("message_id is empty", false);
+  }
+  const channelId = params.target?.id.trim() ?? "";
+  if (!channelId) {
+    return failed("target id is empty", false);
+  }
+  try {
+    await withTimeout(Promise.resolve(bot.deleteMessage(channelId, messageId)), RECALL_TIMEOUT_MS);
+    return create7(RecallResultSchema, {
+      status: 1 /* OK */,
+      reason: "",
+      retryable: false
+    });
+  } catch (error) {
+    return classifyRecallError(error);
+  }
+}
+function findBot3(ctx, botKey) {
+  const key = botKey.trim();
+  if (!key) return void 0;
+  return ctx.bots.find((bot) => botKeyOf3(bot) === key);
+}
+function botKeyOf3(bot) {
+  const platform = bot.platform ?? "";
+  const selfId = bot.selfId ?? "";
+  return platform && selfId ? `${platform}:${selfId}` : "";
+}
+function botCanRecall(bot) {
+  if (typeof bot.deleteMessage !== "function") return false;
+  try {
+    const src = Function.prototype.toString.call(bot.deleteMessage);
+    if (/not implemented|NotImplementedError/i.test(src)) return false;
+  } catch {
+  }
+  return true;
+}
+function notReadyResult(bot) {
+  switch (bot.status) {
+    case KOISHI_STATUS_ONLINE2:
+      return void 0;
+    case KOISHI_STATUS_CONNECT2:
+    case KOISHI_STATUS_RECONNECT2:
+      return failed("bot is connecting", true);
+    default:
+      return failed("bot is unavailable", false);
+  }
+}
+function failed(reason, retryable) {
+  return create7(RecallResultSchema, {
+    status: 4 /* FAILED */,
+    reason,
+    retryable
+  });
+}
+function unknown(reason) {
+  return create7(RecallResultSchema, {
+    status: 3 /* UNKNOWN */,
+    reason,
+    retryable: false
+  });
+}
+function classifyRecallError(error) {
+  if (error instanceof RecallTimeoutError) {
+    return unknown(error.message);
+  }
+  const text = errorMessage(error);
+  const lower = text.toLowerCase();
+  const status = httpStatusOf(error);
+  if (isTimeout(error, lower, status)) {
+    return unknown(text || "message.recall timed out");
+  }
+  if (isNotImplemented(lower)) {
+    return failed("bot has no message.recall capability", false);
+  }
+  if (status === 401 || status === 403 || isForbidden(lower)) {
+    return failed(text || "not permitted to recall message", false);
+  }
+  if (status === 400 || status === 404) {
+    return failed(text || "recall rejected", false);
+  }
+  if (status === 429 || status !== void 0 && status >= 500 || isRetryableNetwork(error, lower)) {
+    return failed(text || "recall failed", true);
+  }
+  return failed(text || "message.recall failed", false);
+}
+function httpStatusOf(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const record = error;
+  if (typeof record.status === "number") return record.status;
+  if (typeof record.statusCode === "number") return record.statusCode;
+  const response = record.response;
+  if (response && typeof response === "object") {
+    const nested = response.status;
+    if (typeof nested === "number") return nested;
+  }
+  if (typeof record.code === "number" && record.code >= 400 && record.code < 600) return record.code;
+  return void 0;
+}
+function errorMessage(error) {
+  if (error instanceof Error) return error.message.trim();
+  if (typeof error === "string") return error.trim();
+  return String(error);
+}
+function isTimeout(error, lower, status) {
+  if (status === 408 || status === 504) return true;
+  if (error && typeof error === "object") {
+    const name2 = error.name;
+    if (name2 === "TimeoutError" || name2 === "AbortError") return true;
+    const code = error.code;
+    if (code === "ETIMEDOUT" || code === "UND_ERR_CONNECT_TIMEOUT" || code === "ABORT_ERR") return true;
+  }
+  return lower.includes("timed out") || lower.includes("timeout");
+}
+function isNotImplemented(lower) {
+  return lower.includes("not implemented") || lower.includes("unsupported");
+}
+function isForbidden(lower) {
+  return lower.includes("forbidden") || lower.includes("not permitted") || lower.includes("missing permission") || lower.includes("missing access") || lower.includes("can't delete") || lower.includes("cannot delete") || lower.includes("message can't be deleted") || lower.includes("not enough rights");
+}
+function isRetryableNetwork(error, lower) {
+  if (error && typeof error === "object") {
+    const code = error.code;
+    if (code === "ECONNRESET" || code === "ECONNREFUSED" || code === "ECONNABORTED" || code === "ENOTFOUND" || code === "EAI_AGAIN" || code === "EPIPE" || code === "UND_ERR_SOCKET" || code === "UND_ERR_CONNECT_TIMEOUT") {
+      return true;
+    }
+  }
+  return lower.includes("network") || lower.includes("fetch failed") || lower.includes("socket hang up") || lower.includes("econnreset") || lower.includes("econnrefused");
+}
+var RecallTimeoutError = class extends Error {
+  constructor() {
+    super("message.recall timed out");
+    this.name = "RecallTimeoutError";
+  }
+};
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new RecallTimeoutError()), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+
+// src/dbk/send.ts
+import { create as create8 } from "@bufbuild/protobuf";
+import { h } from "koishi";
+var SEND_TIMEOUT_MS = 25e3;
+var MENTION_ALL_FALLBACK = "@\u5168\u4F53\u6210\u5458";
+async function sendMessage(ctx, request) {
+  const bot = findBot4(ctx, request.botKey);
+  if (!bot) {
+    throw new DbkRpcError(3 /* NOT_FOUND */, `bot not found: ${request.botKey.trim() || "(empty)"}`);
+  }
+  const status = toDbkBotStatus(bot.status);
+  if (status === 3 /* CONNECTING */) {
+    return failed2("bot is connecting", true);
+  }
+  if (status !== 1 /* READY */) {
+    return failed2("bot is unavailable", false);
+  }
+  const channelId = request.target?.id.trim() ?? "";
+  if (!channelId) {
+    return failed2("target id is empty", false);
+  }
+  if (request.units.length === 0) {
+    return failed2("units is empty", false);
+  }
+  const guildId = request.target?.guildId.trim() || void 0;
+  const features = botFeatures(bot);
+  const recallable = features.includes("message.recall") || typeof bot.deleteMessage === "function";
+  const mentionAll = features.includes("mention.all");
+  const receipts = [];
+  const failures = [];
+  const unknownReasons = [];
+  let failuresRetryable = true;
+  let quoteUsed = false;
+  let aborted = false;
+  const nextQuoteId = () => {
+    if (quoteUsed) return void 0;
+    const id = request.replyToMessageId.trim();
+    return id || void 0;
+  };
+  const sendElements = async (elements) => {
+    if (aborted) return;
+    if (elements.length === 0) {
+      failuresRetryable = false;
+      failures.push("no sendable segments");
+      return;
+    }
+    const outgoing = withQuote(elements, nextQuoteId());
+    try {
+      const ids = await bot.sendMessage(channelId, outgoing, guildId);
+      if (aborted) return;
+      quoteUsed = true;
+      const kept = normalizeMessageIds(ids);
+      if (kept.length === 0) {
+        unknownReasons.push("send returned no message id");
+        return;
+      }
+      for (const messageId of kept) {
+        receipts.push(create8(SendReceiptSchema, { messageId, recallable }));
+      }
+    } catch (error) {
+      if (aborted) return;
+      if (isTimeoutError(error)) {
+        quoteUsed = true;
+        unknownReasons.push(errorMessage2(error) || "send timed out");
+        return;
+      }
+      const retryable = isRetryableSendError(error);
+      failuresRetryable = failuresRetryable && retryable;
+      failures.push(errorMessage2(error) || "send failed");
+    }
+  };
+  const work = (async () => {
+    for (const unit of request.units) {
+      if (aborted) break;
+      if (unit.body.case === "normal") {
+        await sendElements(segmentsToElements(unit.body.value.segments, { mentionAll }));
+      } else if (unit.body.case === "forward") {
+        const nodes = unit.body.value.nodes;
+        if (nodes.length === 0) {
+          failuresRetryable = false;
+          failures.push("forward has no nodes");
+          continue;
+        }
+        for (const node of nodes) {
+          if (aborted) break;
+          await sendElements(forwardNodeElements(node, { mentionAll }));
+        }
+      } else {
+        failuresRetryable = false;
+        failures.push("empty send unit");
+      }
+    }
+    return finalize(receipts, failures, unknownReasons, failuresRetryable);
+  })();
+  try {
+    return await withTimeout2(work, SEND_TIMEOUT_MS);
+  } catch (error) {
+    aborted = true;
+    void work.catch(() => void 0);
+    if (error instanceof SendTimeoutError || isTimeoutError(error)) {
+      return create8(SendResultSchema, {
+        status: 3 /* UNKNOWN */,
+        reason: error instanceof Error ? error.message : "send timed out",
+        retryable: false,
+        receipts
+      });
+    }
+    return create8(SendResultSchema, {
+      status: 4 /* FAILED */,
+      reason: errorMessage2(error) || "message.send failed",
+      retryable: isRetryableSendError(error),
+      receipts
+    });
+  }
+}
+function segmentsToElements(segments, options) {
+  const elements = [];
+  const quoted = /* @__PURE__ */ new Set();
+  const addQuote = (id) => {
+    const trimmed = id.trim();
+    if (!trimmed || quoted.has(trimmed)) return;
+    quoted.add(trimmed);
+    elements.push(h.quote(trimmed));
+  };
+  if (options?.quoteMessageId) addQuote(options.quoteMessageId);
+  for (const segment of segments) {
+    switch (segment.body.case) {
+      case "text": {
+        elements.push(h.text(segment.body.value.text));
+        break;
+      }
+      case "image": {
+        const uri = segment.body.value.uri.trim();
+        if (uri) elements.push(h.image(uri));
+        break;
+      }
+      case "video": {
+        const uri = segment.body.value.uri.trim();
+        if (uri) elements.push(h.video(uri));
+        break;
+      }
+      case "audio": {
+        const uri = segment.body.value.uri.trim();
+        if (uri) elements.push(h.audio(uri));
+        break;
+      }
+      case "mention": {
+        const id = segment.body.value.id.trim();
+        if (id) elements.push(h.at(id));
+        break;
+      }
+      case "mentionAll": {
+        if (options?.mentionAll === false) {
+          elements.push(h.text(MENTION_ALL_FALLBACK));
+        } else {
+          elements.push(h("at", { type: "all" }));
+        }
+        break;
+      }
+      case "reply": {
+        addQuote(segment.body.value.messageId);
+        break;
+      }
+      case "link": {
+        const url = segment.body.value.url.trim();
+        if (!url) break;
+        const title = segment.body.value.title.trim();
+        elements.push(h("a", { href: url }, title || url));
+        break;
+      }
+      case "unknown":
+      case void 0:
+        break;
+    }
+  }
+  return elements;
+}
+function forwardNodeElements(node, options) {
+  const body = segmentsToElements(node.segments, options);
+  const name2 = node.senderName.trim();
+  if (!name2) return body;
+  return [h.text(`${name2}
+`), ...body];
+}
+function withQuote(elements, quoteId) {
+  if (!quoteId) return elements;
+  if (hasQuote(elements, quoteId)) return elements;
+  return [h.quote(quoteId), ...elements];
+}
+function hasQuote(elements, messageId) {
+  return elements.some((el) => el.type === "quote" && String(el.attrs?.id ?? "") === messageId);
+}
+function normalizeMessageIds(raw) {
+  if (raw == null) return [];
+  const list = Array.isArray(raw) ? raw : [raw];
+  return list.map((id) => String(id).trim()).filter(Boolean);
+}
+function findBot4(ctx, botKey) {
+  const key = botKey.trim();
+  if (!key) return void 0;
+  return ctx.bots.find((bot) => !bot.hidden && botKeyOf4(bot) === key);
+}
+function botKeyOf4(bot) {
+  const platform = bot.platform ?? "";
+  const selfId = bot.selfId ?? "";
+  return platform && selfId ? `${platform}:${selfId}` : "";
+}
+function finalize(receipts, failures, unknownReasons, failuresRetryable) {
+  if (unknownReasons.length > 0) {
+    return create8(SendResultSchema, {
+      status: 3 /* UNKNOWN */,
+      reason: unknownReasons[0] ?? "send outcome unknown",
+      retryable: false,
+      receipts
+    });
+  }
+  if (failures.length === 0) {
+    return create8(SendResultSchema, {
+      status: 1 /* OK */,
+      reason: "",
+      retryable: false,
+      receipts
+    });
+  }
+  if (receipts.length > 0) {
+    return create8(SendResultSchema, {
+      status: 2 /* PARTIAL */,
+      reason: failures.join("; "),
+      retryable: false,
+      receipts
+    });
+  }
+  return create8(SendResultSchema, {
+    status: 4 /* FAILED */,
+    reason: failures.join("; "),
+    retryable: failuresRetryable,
+    receipts: []
+  });
+}
+function failed2(reason, retryable) {
+  return create8(SendResultSchema, {
+    status: 4 /* FAILED */,
+    reason,
+    retryable
+  });
+}
+function isRetryableSendError(error) {
+  const text = errorMessage2(error);
+  const lower = text.toLowerCase();
+  const status = httpStatusOf2(error);
+  if (status === 401 || status === 403 || isForbidden2(lower)) return false;
+  if (status === 400 || status === 404) return false;
+  if (status === 429 || status !== void 0 && status >= 500) return true;
+  if (isRetryableNetwork2(error, lower)) return true;
+  if (/\brate.?limit\b|too many requests/.test(lower)) return true;
+  return false;
+}
+function isTimeoutError(error) {
+  const text = errorMessage2(error).toLowerCase();
+  const status = httpStatusOf2(error);
+  if (error instanceof SendTimeoutError) return true;
+  if (status === 408 || status === 504) return true;
+  if (error && typeof error === "object") {
+    const name2 = error.name;
+    if (name2 === "TimeoutError" || name2 === "AbortError") return true;
+    const code = error.code;
+    if (code === "ETIMEDOUT" || code === "UND_ERR_CONNECT_TIMEOUT" || code === "ABORT_ERR") return true;
+  }
+  return text.includes("timed out") || text.includes("timeout");
+}
+function httpStatusOf2(error) {
+  if (!error || typeof error !== "object") return void 0;
+  const record = error;
+  if (typeof record.status === "number") return record.status;
+  if (typeof record.statusCode === "number") return record.statusCode;
+  const response = record.response;
+  if (response && typeof response === "object") {
+    const nested = response.status;
+    if (typeof nested === "number") return nested;
+  }
+  if (typeof record.code === "number" && record.code >= 400 && record.code < 600) return record.code;
+  return void 0;
+}
+function errorMessage2(error) {
+  if (error instanceof Error) return error.message.trim();
+  if (typeof error === "string") return error.trim();
+  return String(error);
+}
+function isForbidden2(lower) {
+  return lower.includes("forbidden") || lower.includes("missing permission") || lower.includes("missing access") || lower.includes("not permitted") || lower.includes("unauthorized");
+}
+function isRetryableNetwork2(error, lower) {
+  if (error && typeof error === "object") {
+    const code = error.code;
+    if (code === "ECONNRESET" || code === "ECONNREFUSED" || code === "ECONNABORTED" || code === "ENOTFOUND" || code === "EAI_AGAIN" || code === "EPIPE" || code === "UND_ERR_SOCKET" || code === "UND_ERR_CONNECT_TIMEOUT") {
+      return true;
+    }
+  }
+  return lower.includes("network") || lower.includes("fetch failed") || lower.includes("socket hang up") || lower.includes("econnreset") || lower.includes("econnrefused");
+}
+var SendTimeoutError = class extends Error {
+  constructor() {
+    super("send timed out");
+    this.name = "SendTimeoutError";
+  }
+};
+function withTimeout2(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new SendTimeoutError()), ms);
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+
+// src/dbk/handlers.ts
+function createGatewayHandlers(ctx) {
+  const snapshot = () => create9(ListBotsResponseSchema, { bots: listBots(ctx) });
+  return {
+    [DbkMethod.SESSION_HELLO]: () => create9(HelloResponseSchema, {
+      protocolVersion: PROTOCOL_VERSION,
+      gatewayVersion: GATEWAY_VERSION,
+      bots: snapshot().bots
+    }),
+    [DbkMethod.BOTS_LIST]: snapshot,
+    [DbkMethod.TARGETS_LIST]: (request) => listTargets(ctx, request),
+    [DbkMethod.TARGETS_GET]: (request) => getTarget(ctx, request),
+    [DbkMethod.MESSAGE_SEND]: (request) => sendMessage(ctx, request),
+    [DbkMethod.MESSAGE_RECALL]: (request) => recallMessage(ctx, request)
+  };
+}
+
+// src/index.ts
+var name = "dynamic-bot";
+var reusable = true;
+var inject = ["server", "http"];
+var WebsocketType = /* @__PURE__ */ ((WebsocketType2) => {
+  WebsocketType2["SERVER"] = "server";
+  WebsocketType2["CLIENT"] = "client";
+  return WebsocketType2;
+})(WebsocketType || {});
+var Config = Schema.intersect([
+  Schema.object({
+    websocketType: Schema.union([
+      Schema.const("server" /* SERVER */).description(
+        "\u6B63\u5411\u8FDE\u63A5\uFF08dynamic-bot \u8FDE\u63A5\u672C\u63D2\u4EF6\uFF0C\u590D\u7528 Koishi HTTP \u670D\u52A1\uFF09"
+      ),
+      Schema.const("client" /* CLIENT */).description(
+        "\u53CD\u5411\u8FDE\u63A5\uFF08\u672C\u63D2\u4EF6\u8FDE\u63A5 dynamic-bot\uFF09"
+      )
+    ]).description("\u8FDE\u63A5\u6A21\u5F0F").required(),
+    accessToken: Schema.string().role("secret").required().description("\u4E0E dynamic-bot \u63D2\u4EF6\u5171\u4EAB\u7684\u8BBF\u95EE\u4EE4\u724C"),
+    dev: Schema.boolean().default(false).description("\u4F7F\u7528 protojson \u6587\u672C\u5E27\uFF08\u4EC5\u672C\u5730\u8C03\u8BD5\uFF09")
+  }).description("\u52A8\u6001\u673A\u5668\u4EBA\u8FDE\u63A5\u914D\u7F6E"),
+  Schema.union([
+    Schema.object({
+      websocketType: Schema.const("server" /* SERVER */).required(),
+      path: Schema.string().default("/dbk").description(
+        "\u6302\u8F7D\u5728 Koishi HTTP \u670D\u52A1\u4E0A\u7684 WebSocket \u8DEF\u5F84\uFF0C\u65E0\u9700\u5355\u72EC\u5F00\u7AEF\u53E3"
+      )
+    }).description("\u6B63\u5411\u8FDE\u63A5\u914D\u7F6E"),
+    Schema.object({
+      websocketType: Schema.const("client" /* CLIENT */).required(),
+      host: Schema.string().default("127.0.0.1").description("dynamic-bot \u53CD\u5411 WebSocket \u76D1\u542C\u5730\u5740"),
+      port: Schema.number().min(1).max(65535).default(9800).description("dynamic-bot \u53CD\u5411 WebSocket \u7AEF\u53E3"),
+      reconnect: Schema.boolean().default(true).description("\u65AD\u5F00\u540E\u81EA\u52A8\u91CD\u8FDE")
+    }).description("\u53CD\u5411\u8FDE\u63A5\u914D\u7F6E")
+  ])
+]);
+function apply(ctx, config) {
+  const gateway = new DbkGateway(
+    ctx,
+    {
+      encoding: config.dev ? "json" : "binary",
+      accessToken: config.accessToken ?? "",
+      path: config.path ?? "/dbk",
+      host: config.host ?? "127.0.0.1",
+      port: config.port ?? 9800,
+      reconnect: config.reconnect ?? true
+    },
+    createGatewayHandlers(ctx)
+  );
+  if (config.websocketType === "client" /* CLIENT */) {
+    gateway.startReverse();
+  } else {
+    gateway.startForward();
+  }
+  watchBots(ctx, gateway);
+  ctx.on("dispose", () => gateway.stop());
+}
+export {
+  Config,
+  DbkEvent,
+  DbkGateway,
+  DbkMethod,
+  DbkRpcError,
+  PROTOCOL_VERSION,
+  WebsocketType,
+  apply,
+  inject,
+  name,
+  reusable
+};