koishi-plugin-dynamic-bot 0.0.2 → 0.0.3

package/lib/dbk/avatar.d.ts

@@ -0,0 +1,2 @@
+/** First non-empty avatar URI among Satori/Koishi-shaped objects. */
+export declare function pickAvatar(...sources: unknown[]): string;

package/lib/dbk/bots.d.ts

@@ -0,0 +1,24 @@
+import type { Bot, Context } from "koishi";
+import { BotStatus, TargetKind } from "../gen/dbk/v1/common_pb";
+import { type Bot as DbkBot } from "../gen/dbk/v1/rpc_pb";
+export declare const BotFeature: {
+    readonly MESSAGE_RECALL: "message.recall";
+    readonly MESSAGE_FORWARD: "message.forward";
+    readonly MENTION_ALL: "mention.all";
+    readonly TARGETS_LIST: "targets.list";
+    readonly TARGET_USER: "target.user";
+    readonly TARGET_GROUP: "target.group";
+    readonly TARGET_CHANNEL: "target.channel";
+    readonly TARGET_THREAD: "target.thread";
+};
+export declare function listBots(ctx: Pick<Context, "bots">): DbkBot[];
+export declare function toDbkBot(bot: Bot): DbkBot;
+export declare function toDbkBotStatus(status: number): BotStatus;
+export declare function botFeatures(bot: Bot): string[];
+export declare function botTargetKinds(bot: Bot): TargetKind[];
+export declare function targetKindFeature(kind: TargetKind): string | undefined;
+/** Nested `channel.list` under a guild: Discord/KOOK-style servers, not sendable GROUP. */
+export declare function hasNestedChannels(bot: Bot): boolean;
+/** Guild/chat list or get, including flat adapters where the guild is the sendable target. */
+export declare function hasGuildSurface(bot: Bot): boolean;
+export declare function canListDirectUsers(bot: Bot): boolean;

package/lib/dbk/codec.d.ts

@@ -0,0 +1,9 @@
+import { create, type DescMessage, type MessageShape } from "@bufbuild/protobuf";
+import { FrameSchema, type Frame } from "../gen/dbk/v1/frame_pb";
+import type { DbkEncoding } from "./protocol";
+export declare function encodeFrame(frame: Frame, encoding: DbkEncoding): Uint8Array | string;
+export declare function decodeFrame(data: Uint8Array | string, encoding: DbkEncoding): Frame;
+export declare function encodePayload<Desc extends DescMessage>(schema: Desc, message: MessageShape<Desc>): Uint8Array;
+export declare function decodePayload<Desc extends DescMessage>(schema: Desc, bytes: Uint8Array): MessageShape<Desc>;
+export declare function createFrame(init: Parameters<typeof create<typeof FrameSchema>>[1]): Frame;
+export declare function toBytes(data: unknown): Uint8Array;

package/lib/dbk/error.d.ts

@@ -0,0 +1,5 @@
+import { ErrorCode } from "../gen/dbk/v1/common_pb";
+export declare class DbkRpcError extends Error {
+    readonly code: ErrorCode;
+    constructor(code: ErrorCode, detail: string);
+}

package/lib/dbk/gateway.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from "koishi";
+import { type DbkEncoding, type DbkEventMap, type DbkGatewayHandlers } from "./protocol";
+export interface DbkGatewayConfig {
+    encoding: DbkEncoding;
+    accessToken: string;
+    path: string;
+    host: string;
+    port: number;
+    reconnect: boolean;
+}
+export declare class DbkGateway {
+    private readonly ctx;
+    private readonly config;
+    private readonly handlers;
+    private session;
+    private socket;
+    private closing;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private reconnectSuspended;
+    constructor(ctx: Context, config: DbkGatewayConfig, handlers: DbkGatewayHandlers);
+    get isHandshook(): boolean;
+    emit<K extends keyof DbkEventMap>(method: K, event: DbkEventMap[K]): void;
+    startForward(): void;
+    startReverse(): void;
+    stop(): void;
+    private connectReverse;
+    private attach;
+    private onReverseClosed;
+    private scheduleReconnect;
+}
+export declare function watchBots(ctx: Context, gateway: DbkGateway): void;

package/lib/dbk/get-target.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "koishi";
+import { type GetTargetRequest, type GetTargetResponse } from "../gen/dbk/v1/rpc_pb";
+export declare function getTarget(ctx: Context, request: GetTargetRequest): Promise<GetTargetResponse>;

package/lib/dbk/handlers.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "koishi";
+import { type DbkGatewayHandlers } from "./protocol";
+export declare function createGatewayHandlers(ctx: Context): DbkGatewayHandlers;

package/lib/dbk/list-targets.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "koishi";
+import { type ListTargetsRequest, type ListTargetsResponse } from "../gen/dbk/v1/rpc_pb";
+export declare function listTargets(ctx: Context, request: ListTargetsRequest): Promise<ListTargetsResponse>;

package/lib/dbk/protocol.d.ts

@@ -0,0 +1,71 @@
+import type { GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { Message } from "@bufbuild/protobuf";
+import { FrameSchema } from "../gen/dbk/v1/frame_pb";
+import { type BotChangedEvent, type GetTargetRequest, type GetTargetResponse, type HelloRequest, type HelloResponse, type IncomingMessage, type ListBotsRequest, type ListBotsResponse, type ListTargetsRequest, type ListTargetsResponse, type RecallParams, type RecallResult, type SendParams, type SendResult } from "../gen/dbk/v1/rpc_pb";
+export declare const PROTOCOL_VERSION = "1";
+export { GATEWAY_VERSION } from "./version";
+export declare const PING_INTERVAL_MS = 10000;
+export declare const PONG_TIMEOUT_MS = 20000;
+export declare const DbkMethod: {
+    readonly SESSION_HELLO: "session.hello";
+    readonly BOTS_LIST: "bots.list";
+    readonly TARGETS_LIST: "targets.list";
+    readonly TARGETS_GET: "targets.get";
+    readonly MESSAGE_SEND: "message.send";
+    readonly MESSAGE_RECALL: "message.recall";
+};
+export declare const DbkEvent: {
+    readonly BOT_CHANGED: "bot.changed";
+    readonly MESSAGE_CREATED: "message.created";
+};
+export type DbkMethodName = (typeof DbkMethod)[keyof typeof DbkMethod];
+export type DbkEventName = (typeof DbkEvent)[keyof typeof DbkEvent];
+export type DbkEncoding = "binary" | "json";
+export interface DbkRpcMap {
+    [DbkMethod.SESSION_HELLO]: {
+        request: HelloRequest;
+        response: HelloResponse;
+    };
+    [DbkMethod.BOTS_LIST]: {
+        request: ListBotsRequest;
+        response: ListBotsResponse;
+    };
+    [DbkMethod.TARGETS_LIST]: {
+        request: ListTargetsRequest;
+        response: ListTargetsResponse;
+    };
+    [DbkMethod.TARGETS_GET]: {
+        request: GetTargetRequest;
+        response: GetTargetResponse;
+    };
+    [DbkMethod.MESSAGE_SEND]: {
+        request: SendParams;
+        response: SendResult;
+    };
+    [DbkMethod.MESSAGE_RECALL]: {
+        request: RecallParams;
+        response: RecallResult;
+    };
+}
+export interface DbkEventMap {
+    [DbkEvent.BOT_CHANGED]: BotChangedEvent;
+    [DbkEvent.MESSAGE_CREATED]: IncomingMessage;
+}
+export type DbkGatewayHandlers = {
+    [K in keyof DbkRpcMap]: (request: DbkRpcMap[K]["request"]) => Promise<DbkRpcMap[K]["response"]> | DbkRpcMap[K]["response"];
+};
+interface RpcCodec<Req extends Message, Res extends Message> {
+    request: GenMessage<Req>;
+    response: GenMessage<Res>;
+}
+export declare const DbkRpcCodecs: {
+    [K in keyof DbkRpcMap]: RpcCodec<DbkRpcMap[K]["request"], DbkRpcMap[K]["response"]>;
+};
+export declare const DbkEventCodecs: {
+    [K in keyof DbkEventMap]: GenMessage<DbkEventMap[K]>;
+};
+export { FrameSchema };
+export type { Frame } from "../gen/dbk/v1/frame_pb";
+export { FrameOp } from "../gen/dbk/v1/frame_pb";
+export { ErrorCode, RpcErrorSchema } from "../gen/dbk/v1/common_pb";
+export type { RpcError } from "../gen/dbk/v1/common_pb";

package/lib/dbk/recall.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "koishi";
+import { type RecallParams, type RecallResult } from "../gen/dbk/v1/rpc_pb";
+export declare function recallMessage(ctx: Context, params: RecallParams): Promise<RecallResult>;

package/lib/dbk/send.d.ts

@@ -0,0 +1,16 @@
+import { h, type Context } from "koishi";
+import { type Segment, type SendParams, type SendResult } from "../gen/dbk/v1/rpc_pb";
+type El = ReturnType<typeof h>;
+export interface SegmentRenderOptions {
+    /** Prepend `h.quote` unless a reply segment already uses this id. */
+    quoteMessageId?: string;
+    /**
+     * `mention_all` mapping:
+     * - true → Satori `<at type="all"/>` (`h("at", { type: "all" })`)
+     * - false → degrade to text `@全体成员` (not PARTIAL)
+     */
+    mentionAll?: boolean;
+}
+export declare function sendMessage(ctx: Context, request: SendParams): Promise<SendResult>;
+export declare function segmentsToElements(segments: Segment[], options?: SegmentRenderOptions): El[];
+export {};

package/lib/dbk/session.d.ts

@@ -0,0 +1,44 @@
+import { type Frame } from "../gen/dbk/v1/frame_pb";
+import { type DbkEncoding, type DbkEventMap, type DbkGatewayHandlers } from "./protocol";
+export interface DbkLogger {
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+export interface DbkSessionOptions {
+    encoding: DbkEncoding;
+    accessToken: string;
+    handlers: DbkGatewayHandlers;
+    logger: DbkLogger;
+    send: (data: Uint8Array | string) => void;
+    onDead: (reason: string) => void;
+    onUnauthorized?: () => void;
+    now?: () => number;
+}
+export declare class DbkGatewaySession {
+    private readonly options;
+    private closed;
+    private handshook;
+    private seq;
+    private sendQueue;
+    private lastInboundAt;
+    private heartbeat;
+    private readonly now;
+    constructor(options: DbkSessionOptions);
+    get isHandshook(): boolean;
+    onFrame(frame: Frame): void;
+    rejectText(): void;
+    rejectDecode(error: unknown): void;
+    emit<K extends keyof DbkEventMap>(method: K, event: DbkEventMap[K]): void;
+    close(reason?: string): void;
+    private handle;
+    private handleCall;
+    private dispatchCall;
+    private runRpc;
+    private hello;
+    private replyError;
+    private startHeartbeat;
+    private enqueueFrame;
+    private fail;
+}

package/lib/dbk/socket.d.ts

@@ -0,0 +1,17 @@
+import type { DbkEncoding } from "./protocol";
+import type { DbkGatewaySession } from "./session";
+export interface DbkSocket {
+    readyState: number;
+    binaryType?: string;
+    send(data: Uint8Array | string): void;
+    close(code?: number, reason?: string): void;
+    on?(event: string, listener: (...args: unknown[]) => void): void;
+    addEventListener?(type: string, listener: (event: {
+        data?: unknown;
+        code?: number;
+        reason?: string;
+    }) => void): void;
+}
+export declare const WS_OPEN = 1;
+export declare function sendSocket(socket: DbkSocket, data: Uint8Array | string): void;
+export declare function attachSocket(socket: DbkSocket, session: DbkGatewaySession, encoding: DbkEncoding): void;

package/lib/dbk/version.d.ts

@@ -0,0 +1 @@
+export declare const GATEWAY_VERSION: string;

package/lib/gen/dbk/v1/common_pb.d.ts

@@ -0,0 +1,187 @@
+import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file dbk/v1/common.proto.
+ */
+export declare const file_dbk_v1_common: GenFile;
+/**
+ * @generated from message dbk.v1.Target
+ */
+export type Target = Message<"dbk.v1.Target"> & {
+    /**
+     * @generated from field: dbk.v1.TargetKind kind = 1;
+     */
+    kind: TargetKind;
+    /**
+     * @generated from field: string id = 2;
+     */
+    id: string;
+    /**
+     * @generated from field: string guild_id = 3;
+     */
+    guildId: string;
+};
+/**
+ * Describes the message dbk.v1.Target.
+ * Use `create(TargetSchema)` to create a new message.
+ */
+export declare const TargetSchema: GenMessage<Target>;
+/**
+ * @generated from message dbk.v1.RpcError
+ */
+export type RpcError = Message<"dbk.v1.RpcError"> & {
+    /**
+     * @generated from field: dbk.v1.ErrorCode code = 1;
+     */
+    code: ErrorCode;
+    /**
+     * @generated from field: string detail = 2;
+     */
+    detail: string;
+};
+/**
+ * Describes the message dbk.v1.RpcError.
+ * Use `create(RpcErrorSchema)` to create a new message.
+ */
+export declare const RpcErrorSchema: GenMessage<RpcError>;
+/**
+ * @generated from enum dbk.v1.TargetKind
+ */
+export declare enum TargetKind {
+    /**
+     * @generated from enum value: TARGET_KIND_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: TARGET_KIND_USER = 1;
+     */
+    USER = 1,
+    /**
+     * @generated from enum value: TARGET_KIND_GROUP = 2;
+     */
+    GROUP = 2,
+    /**
+     * @generated from enum value: TARGET_KIND_CHANNEL = 3;
+     */
+    CHANNEL = 3,
+    /**
+     * @generated from enum value: TARGET_KIND_THREAD = 4;
+     */
+    THREAD = 4
+}
+/**
+ * Describes the enum dbk.v1.TargetKind.
+ */
+export declare const TargetKindSchema: GenEnum<TargetKind>;
+/**
+ * @generated from enum dbk.v1.BotStatus
+ */
+export declare enum BotStatus {
+    /**
+     * @generated from enum value: BOT_STATUS_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: BOT_STATUS_READY = 1;
+     */
+    READY = 1,
+    /**
+     * @generated from enum value: BOT_STATUS_UNAVAILABLE = 2;
+     */
+    UNAVAILABLE = 2,
+    /**
+     * @generated from enum value: BOT_STATUS_CONNECTING = 3;
+     */
+    CONNECTING = 3
+}
+/**
+ * Describes the enum dbk.v1.BotStatus.
+ */
+export declare const BotStatusSchema: GenEnum<BotStatus>;
+/**
+ * @generated from enum dbk.v1.SendStatus
+ */
+export declare enum SendStatus {
+    /**
+     * @generated from enum value: SEND_STATUS_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: SEND_STATUS_OK = 1;
+     */
+    OK = 1,
+    /**
+     * @generated from enum value: SEND_STATUS_PARTIAL = 2;
+     */
+    PARTIAL = 2,
+    /**
+     * @generated from enum value: SEND_STATUS_UNKNOWN = 3;
+     */
+    UNKNOWN = 3,
+    /**
+     * @generated from enum value: SEND_STATUS_FAILED = 4;
+     */
+    FAILED = 4
+}
+/**
+ * Describes the enum dbk.v1.SendStatus.
+ */
+export declare const SendStatusSchema: GenEnum<SendStatus>;
+/**
+ * @generated from enum dbk.v1.ErrorCode
+ */
+export declare enum ErrorCode {
+    /**
+     * @generated from enum value: ERROR_CODE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: ERROR_CODE_UNAUTHORIZED = 1;
+     */
+    UNAUTHORIZED = 1,
+    /**
+     * @generated from enum value: ERROR_CODE_PROTOCOL = 2;
+     */
+    PROTOCOL = 2,
+    /**
+     * @generated from enum value: ERROR_CODE_NOT_FOUND = 3;
+     */
+    NOT_FOUND = 3,
+    /**
+     * @generated from enum value: ERROR_CODE_UNSUPPORTED = 4;
+     */
+    UNSUPPORTED = 4,
+    /**
+     * @generated from enum value: ERROR_CODE_INTERNAL = 5;
+     */
+    INTERNAL = 5
+}
+/**
+ * Describes the enum dbk.v1.ErrorCode.
+ */
+export declare const ErrorCodeSchema: GenEnum<ErrorCode>;
+/**
+ * @generated from enum dbk.v1.BotChangeType
+ */
+export declare enum BotChangeType {
+    /**
+     * @generated from enum value: BOT_CHANGE_TYPE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: BOT_CHANGE_TYPE_ADDED = 1;
+     */
+    ADDED = 1,
+    /**
+     * @generated from enum value: BOT_CHANGE_TYPE_UPDATED = 2;
+     */
+    UPDATED = 2,
+    /**
+     * @generated from enum value: BOT_CHANGE_TYPE_REMOVED = 3;
+     */
+    REMOVED = 3
+}
+/**
+ * Describes the enum dbk.v1.BotChangeType.
+ */
+export declare const BotChangeTypeSchema: GenEnum<BotChangeType>;

package/lib/gen/dbk/v1/frame_pb.d.ts

@@ -0,0 +1,88 @@
+import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2";
+import type { RpcError } from "./common_pb";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file dbk/v1/frame.proto.
+ */
+export declare const file_dbk_v1_frame: GenFile;
+/**
+ * @generated from message dbk.v1.Frame
+ */
+export type Frame = Message<"dbk.v1.Frame"> & {
+    /**
+     * @generated from field: dbk.v1.FrameOp op = 1;
+     */
+    op: FrameOp;
+    /**
+     * CALL / OK / ERROR. Generated by the caller.
+     *
+     * @generated from field: string id = 2;
+     */
+    id: string;
+    /**
+     * EVENT only. Monotonic per connection; v1 does not resume by seq.
+     *
+     * @generated from field: uint64 seq = 3;
+     */
+    seq: bigint;
+    /**
+     * CALL / EVENT method name, e.g. `session.hello`, `message.created`.
+     *
+     * @generated from field: string method = 4;
+     */
+    method: string;
+    /**
+     * Encoded request, response, or event body for `method`.
+     *
+     * @generated from field: bytes payload = 5;
+     */
+    payload: Uint8Array;
+    /**
+     * ERROR only. Business send failures use OK + SendStatus, not this.
+     *
+     * @generated from field: dbk.v1.RpcError error = 6;
+     */
+    error?: RpcError | undefined;
+};
+/**
+ * Describes the message dbk.v1.Frame.
+ * Use `create(FrameSchema)` to create a new message.
+ */
+export declare const FrameSchema: GenMessage<Frame>;
+/**
+ * @generated from enum dbk.v1.FrameOp
+ */
+export declare enum FrameOp {
+    /**
+     * @generated from enum value: FRAME_OP_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: FRAME_OP_CALL = 1;
+     */
+    CALL = 1,
+    /**
+     * @generated from enum value: FRAME_OP_OK = 2;
+     */
+    OK = 2,
+    /**
+     * @generated from enum value: FRAME_OP_ERROR = 3;
+     */
+    ERROR = 3,
+    /**
+     * @generated from enum value: FRAME_OP_EVENT = 4;
+     */
+    EVENT = 4,
+    /**
+     * @generated from enum value: FRAME_OP_PING = 5;
+     */
+    PING = 5,
+    /**
+     * @generated from enum value: FRAME_OP_PONG = 6;
+     */
+    PONG = 6
+}
+/**
+ * Describes the enum dbk.v1.FrameOp.
+ */
+export declare const FrameOpSchema: GenEnum<FrameOp>;