koishi-plugin-dynamic-bot 0.0.0-dev

package/src/dbk/gateway.ts

@@ -0,0 +1,155 @@
+import { create } from "@bufbuild/protobuf";
+import type { Context } from "koishi";
+import { BotChangeType } from "../gen/dbk/v1/common_pb";
+import { BotChangedEventSchema } from "../gen/dbk/v1/rpc_pb";
+import { toDbkBot } from "./bots";
+import { DbkEvent, type DbkEncoding, type DbkEventMap, type DbkGatewayHandlers } from "./protocol";
+import { DbkGatewaySession } from "./session";
+import { attachSocket, sendSocket, type DbkSocket } from "./socket";
+
+const RECONNECT_BACKOFF_MS = [
+  5_000,
+  10_000,
+  30_000,
+  60_000,
+  5 * 60_000,
+  10 * 60_000,
+  30 * 60_000,
+  60 * 60_000,
+];
+
+export interface DbkGatewayConfig {
+  encoding: DbkEncoding;
+  accessToken: string;
+  path: string;
+  host: string;
+  port: number;
+  reconnect: boolean;
+}
+
+export class DbkGateway {
+  private session: DbkGatewaySession | undefined;
+  private socket: DbkSocket | undefined;
+  private closing = false;
+  private reconnectAttempts = 0;
+  private reconnectTimer: (() => void) | undefined;
+  private reconnectSuspended = false;
+
+  constructor(
+    private readonly ctx: Context,
+    private readonly config: DbkGatewayConfig,
+    private readonly handlers: DbkGatewayHandlers,
+  ) {}
+
+  get isHandshook(): boolean {
+    return this.session?.isHandshook ?? false;
+  }
+
+  emit<K extends keyof DbkEventMap>(method: K, event: DbkEventMap[K]): void {
+    this.session?.emit(method, event);
+  }
+
+  startForward(): void {
+    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 as DbkSocket);
+    });
+  }
+
+  startReverse(): void {
+    this.connectReverse();
+  }
+
+  stop(): void {
+    this.closing = true;
+    this.reconnectTimer?.();
+    this.reconnectTimer = undefined;
+    this.session?.close("plugin stop");
+    this.session = undefined;
+    this.socket?.close(1000, "plugin stop");
+    this.socket = undefined;
+  }
+
+  private connectReverse(): void {
+    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) as DbkSocket;
+    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());
+    }
+  }
+
+  private attach(replaceReason: string, socket: DbkSocket): void {
+    if (this.socket && this.socket !== socket) {
+      this.ctx.logger.warn("replacing existing DBK connection");
+      this.session?.close(replaceReason);
+      this.socket.close(1000, 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(1000, 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);
+  }
+
+  private onReverseClosed(): void {
+    this.session?.close("ws close");
+    if (this.socket) this.socket = undefined;
+    this.session = undefined;
+    this.scheduleReconnect();
+  }
+
+  private scheduleReconnect(): void {
+    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 = undefined;
+      this.connectReverse();
+    }, delay);
+  }
+}
+
+export function watchBots(ctx: Context, gateway: DbkGateway): void {
+  const emit = (type: BotChangeType, bot: Parameters<typeof toDbkBot>[0]) => {
+    if (bot.hidden && type !== BotChangeType.REMOVED) return;
+    gateway.emit(DbkEvent.BOT_CHANGED, create(BotChangedEventSchema, {
+      type,
+      bot: toDbkBot(bot),
+    }));
+  };
+  ctx.on("bot-added", (bot) => emit(BotChangeType.ADDED, bot));
+  ctx.on("bot-removed", (bot) => emit(BotChangeType.REMOVED, bot));
+  ctx.on("bot-status-updated", (bot) => emit(BotChangeType.UPDATED, bot));
+}
+
+function normalizePath(path: string): string {
+  const trimmed = path.trim() || "/dbk";
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}

package/src/dbk/get-target.ts

@@ -0,0 +1,275 @@
+import { create } from "@bufbuild/protobuf";
+import type { Bot, Context } from "koishi";
+import { ErrorCode, TargetKind, TargetSchema, type Target } from "../gen/dbk/v1/common_pb";
+import {
+  GetTargetResponseSchema,
+  TargetInfoSchema,
+  type GetTargetRequest,
+  type GetTargetResponse,
+  type TargetInfo,
+} from "../gen/dbk/v1/rpc_pb";
+import { pickAvatar } from "./avatar";
+import { hasNestedChannels } from "./bots";
+import { DbkRpcError } from "./error";
+
+/** Satori `Universal.Channel.Type` (Koishi 4.18). TEXT=0 DIRECT=1 CATEGORY=2 VOICE=3. */
+const CHANNEL_TEXT = 0;
+const CHANNEL_DIRECT = 1;
+const CHANNEL_CATEGORY = 2;
+const CHANNEL_VOICE = 3;
+/** Discord native thread types if an adapter leaks them instead of Satori TEXT. */
+const DISCORD_THREAD_TYPES = new Set([10, 11, 12]);
+
+interface ChannelLike {
+  id?: string | number;
+  type?: number;
+  name?: string;
+  parentId?: string;
+  parent_id?: string;
+  guildId?: string;
+  avatar?: string;
+}
+
+interface GuildLike {
+  id?: string | number;
+  name?: string;
+  title?: string;
+  first_name?: string;
+  type?: string;
+  guildId?: string;
+  guildName?: string;
+  avatar?: string;
+}
+
+interface UserLike {
+  id?: string | number;
+  name?: string;
+  nick?: string;
+  username?: string;
+  avatar?: string;
+}
+
+export async function getTarget(ctx: Context, request: GetTargetRequest): Promise<GetTargetResponse> {
+  const botKey = request.botKey.trim();
+  const target = request.target;
+
+  if (botKey) {
+    const bot = findBot(ctx, botKey);
+    if (!bot) {
+      throw new DbkRpcError(ErrorCode.NOT_FOUND, `bot not found: ${botKey}`);
+    }
+    const info = await resolveOnBot(bot, target);
+    return info ? resolved(info) : unresolved(target);
+  }
+
+  // Empty bot_key: search non-hidden, non-qq bots in ctx.bots order; first successful resolve wins.
+  for (const bot of listSearchableBots(ctx)) {
+    const info = await resolveOnBot(bot, target);
+    if (info) return resolved(info);
+  }
+  return unresolved(target);
+}
+
+function findBot(ctx: Context, botKey: string): Bot | undefined {
+  return ctx.bots.find((bot) => !bot.hidden && botKeyOf(bot) === botKey);
+}
+
+function listSearchableBots(ctx: Context): Bot[] {
+  return ctx.bots.filter((bot) => !bot.hidden && (bot.platform ?? "").toLowerCase() !== "qq");
+}
+
+function botKeyOf(bot: Bot): string {
+  const platform = bot.platform ?? "";
+  const selfId = bot.selfId ?? "";
+  return platform && selfId ? `${platform}:${selfId}` : "";
+}
+
+async function resolveOnBot(bot: Bot, target: Target | undefined): Promise<TargetInfo | undefined> {
+  const id = target?.id.trim() ?? "";
+  if (!id) return undefined;
+  const guildId = target?.guildId.trim() ?? "";
+  const kind = target?.kind ?? TargetKind.UNSPECIFIED;
+
+  try {
+    switch (kind) {
+      case TargetKind.USER:
+        return await resolveUser(bot, id, guildId);
+      case TargetKind.GROUP:
+        return await resolveGroup(bot, id, guildId);
+      case TargetKind.CHANNEL:
+        return await resolveChannelKind(bot, id, guildId, TargetKind.CHANNEL);
+      case TargetKind.THREAD:
+        return await resolveChannelKind(bot, id, guildId, TargetKind.THREAD);
+      default:
+        return (
+          (await resolveChannelKind(bot, id, guildId, TargetKind.UNSPECIFIED)) ??
+          (await resolveGroup(bot, id, guildId)) ??
+          (await resolveUser(bot, id, guildId))
+        );
+    }
+  } catch {
+    return undefined;
+  }
+}
+
+async function resolveUser(bot: Bot, id: string, guildId: string): Promise<TargetInfo | undefined> {
+  const user = await callBot(bot, "getUser", () => bot.getUser(id, guildId || undefined));
+  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 || undefined));
+  if (channel && channelKind(bot, channel, TargetKind.USER) === TargetKind.USER) {
+    return toChannelInfo(bot, channel, TargetKind.USER, guildId);
+  }
+  return undefined;
+}
+
+async function resolveGroup(bot: Bot, id: string, guildId: string): Promise<TargetInfo | undefined> {
+  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, TargetKind.GROUP);
+}
+
+async function resolveChannelKind(
+  bot: Bot,
+  id: string,
+  guildId: string,
+  requested: TargetKind,
+): Promise<TargetInfo | undefined> {
+  const channel = await callBot(bot, "getChannel", () => bot.getChannel(id, guildId || undefined));
+  if (!channel) return undefined;
+  const kind = channelKind(bot, channel, requested);
+  if (!kind) return undefined;
+  return toChannelInfo(bot, channel, kind, guildId);
+}
+
+function channelKind(bot: Bot, channel: ChannelLike, requested: TargetKind): TargetKind | undefined {
+  const nested = hasNestedChannels(bot);
+  const type = channel.type ?? CHANNEL_TEXT;
+  if (type === CHANNEL_DIRECT) return TargetKind.USER;
+  if (type === CHANNEL_CATEGORY || type === CHANNEL_VOICE) return undefined;
+  if (DISCORD_THREAD_TYPES.has(type) || requested === TargetKind.THREAD) {
+    if (requested === TargetKind.USER) return undefined;
+    if (requested === TargetKind.GROUP && nested) return undefined;
+    return TargetKind.THREAD;
+  }
+  if (requested === TargetKind.USER) return undefined;
+  if (!nested) {
+    if (requested === TargetKind.CHANNEL) return TargetKind.CHANNEL;
+    return TargetKind.GROUP;
+  }
+  if (requested === TargetKind.GROUP) return undefined;
+  return TargetKind.CHANNEL;
+}
+
+function kindFromGuild(bot: Bot, guild: GuildLike): TargetKind | undefined {
+  const chatType = guild.type;
+  if (chatType === "private") return TargetKind.USER;
+  if (chatType === "channel") return TargetKind.CHANNEL;
+  if (chatType === "group" || chatType === "supergroup") return TargetKind.GROUP;
+  if (hasNestedChannels(bot)) return undefined;
+  return TargetKind.GROUP;
+}
+
+async function toChannelInfo(
+  bot: Bot,
+  channel: ChannelLike,
+  kind: TargetKind,
+  requestGuildId: string,
+): Promise<TargetInfo> {
+  const id = stringifyId(channel.id);
+  const guildId = requestGuildId || stringifyId(channel.guildId);
+  const guild = guildId ? await lookupGuild(bot, guildId) : undefined;
+  return create(TargetInfoSchema, {
+    target: create(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: Bot, guild: GuildLike, kind: TargetKind): TargetInfo {
+  const id = stringifyId(guild.id) || stringifyId(guild.guildId);
+  const guildId = kind === TargetKind.USER ? "" : id;
+  return create(TargetInfoSchema, {
+    target: create(TargetSchema, { kind, id, guildId }),
+    name: guildDisplayName(guild) || id,
+    guildId,
+    guildName: kind === TargetKind.USER ? "" : guildDisplayName(guild),
+    avatar: pickAvatar(guild),
+    botKeys: [botKeyOf(bot)],
+  });
+}
+
+function toUserInfo(bot: Bot, user: UserLike, guildId: string): TargetInfo {
+  const id = stringifyId(user.id);
+  return create(TargetInfoSchema, {
+    target: create(TargetSchema, { kind: TargetKind.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: Bot, guildId: string): Promise<GuildLike | undefined> {
+  return callBot(bot, "getGuild", () => bot.getGuild(guildId));
+}
+
+function guildDisplayName(guild: GuildLike | undefined): string {
+  if (!guild) return "";
+  return guild.name?.trim() || guild.guildName?.trim() || guild.title?.trim() || guild.first_name?.trim() || "";
+}
+
+function stringifyId(value: string | number | undefined): string {
+  if (value === undefined || value === null) return "";
+  return String(value).trim();
+}
+
+function resolved(target: TargetInfo): GetTargetResponse {
+  return create(GetTargetResponseSchema, { target, unresolved: false });
+}
+
+function unresolved(requestTarget: Target | undefined): GetTargetResponse {
+  return create(GetTargetResponseSchema, {
+    unresolved: true,
+    target: requestTarget
+      ? create(TargetInfoSchema, {
+          target: requestTarget,
+        })
+      : undefined,
+  });
+}
+
+async function callBot<K extends string, T>(
+  bot: Bot,
+  method: K,
+  fn: () => Promise<T>,
+): Promise<T | undefined> {
+  if (typeof (bot as unknown as Record<string, unknown>)[method] !== "function") return undefined;
+  try {
+    return await fn();
+  } catch {
+    return undefined;
+  }
+}
+
+async function callFriend(bot: Bot, id: string): Promise<UserLike | undefined> {
+  const getFriend = (bot as Bot & { getFriend?: (userId: string) => Promise<UserLike> }).getFriend;
+  if (typeof getFriend !== "function") return undefined;
+  try {
+    return await getFriend.call(bot, id);
+  } catch {
+    return undefined;
+  }
+}

package/src/dbk/handlers.ts

@@ -0,0 +1,29 @@
+import { create } from "@bufbuild/protobuf";
+import type { Context } from "koishi";
+import {
+  HelloResponseSchema,
+  ListBotsResponseSchema,
+} from "../gen/dbk/v1/rpc_pb";
+import { listBots } from "./bots";
+import { getTarget } from "./get-target";
+import { listTargets } from "./list-targets";
+import { DbkMethod, GATEWAY_VERSION, PROTOCOL_VERSION, type DbkGatewayHandlers } from "./protocol";
+import { recallMessage } from "./recall";
+import { sendMessage } from "./send";
+
+export function createGatewayHandlers(ctx: Context): DbkGatewayHandlers {
+  const snapshot = () => create(ListBotsResponseSchema, { bots: listBots(ctx) });
+
+  return {
+    [DbkMethod.SESSION_HELLO]: () => create(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),
+  };
+}