@mrlingxd/koishi-plugin-adapter-onebot 0.1.0 → 0.2.2

package/lib/bot/cqcode.d.ts

@@ -1,13 +1,212 @@
 import { Dict, h } from "koishi";
 export declare function CQCode(type: string, attrs: Dict<string>): string;
-export interface CQCode {
-    type: string;
-    data: Dict<string>;
-    capture?: RegExpExecArray;
+export interface CQCode<T extends string = string, D = Dict<string>> {
+    type: T;
+    data: D;
 }
 export declare namespace CQCode {
+    /** 文字 */
+    interface Text extends CQCode<"text", {
+        /** 文字内容 */
+        text: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /** 图片 */
+    interface Image extends CQCode<"image", {
+        /** 图片链接/名字 */
+        file: string;
+        /** 图片链接 */
+        url?: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /** 表情 */
+    interface Face extends CQCode<"face", {
+        /** 表情 ID */
+        id: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /** 音乐 */
+    interface Music extends CQCode<"music", {
+        /** 音乐类型 */
+        type: "qq" | "163" | "xm" | string;
+        /** 音乐 ID */
+        id: string | number;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /** 自定义音乐 */
+    interface CustomMusic extends CQCode<"music", {
+        /** 音乐类型 */
+        type: "custom";
+        /** 音乐 URL */
+        url: string;
+        /** 音乐音频 URL */
+        audio: string;
+        /** 音乐标题 */
+        title: string;
+        /** 音乐描述 */
+        content?: string;
+        /** 音乐图片 URL */
+        image?: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /** 视频 */
+    interface Video extends CQCode<"video", {
+        /** 视频文件名 */
+        file: string;
+        /** 视频链接 */
+        url?: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * 语音
+     */
+    interface Record extends CQCode<"record", {
+        /** 语音文件名 */
+        file: string;
+        /** 语音链接 */
+        url?: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * 艾特
+     */
+    interface At extends CQCode<"at", {
+        /** 被艾特的 QQ 号 */
+        qq: string;
+        /** 被艾特的昵称 */
+        name?: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * 文件（未完全定义）
+     *
+     * 请根据实现端补全字段
+     */
+    interface File extends CQCode<"file", {
+        /** 图片链接 */
+        file: string;
+        /** 文件链接 */
+        url?: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * 回复
+     */
+    interface Reply extends CQCode<"reply", {
+        /** 消息 ID */
+        id: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * 转发消息
+     */
+    interface Forward extends CQCode<"forward", {
+        /** 转发 ID */
+        id: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * 回复
+     */
+    interface Reply extends CQCode<"reply", {
+        /** 消息 ID */
+        id: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * 戳一戳
+     */
+    interface Poke extends CQCode<"poke", {
+        /** 戳一戳类型 */
+        type: string;
+        /** 戳一戳 ID */
+        id: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * 商城表情
+     */
+    interface Mface extends CQCode<"mface", {
+        /** 表情 Url */
+        url?: string;
+        /** 表情包/组 ID */
+        emoji_package_id: string;
+        /** 表情 ID */
+        emoji_id: string;
+        /** 表情 key */
+        key: string;
+        /** 表情说明 */
+        summary: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * 合并消息
+     */
+    interface MergeForward extends CQCode<"node", {
+        /** 用户 ID */
+        user_id: string;
+        /** 昵称 */
+        nickname: string;
+        /** 消息内容 */
+        content: CQCodeUnion[];
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * Json 消息
+     */
+    interface Json extends CQCode<"json", {
+        /** Json 内容 */
+        data: string | object;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /**
+     * XML 消息
+     */
+    interface Xml extends CQCode<"xml", {
+        /** XML 内容 */
+        data: string;
+        /** 更多字段 */
+        [property: string]: unknown;
+    }> {
+    }
+    /** 联合类型 */
+    type CQCodeUnion = Text | Image | Face | Music | CustomMusic | Video | Record | At | File | Reply | Forward | Poke | Mface | MergeForward | Json;
     function escape(source: any, inline?: boolean): string;
     function unescape(source: string): string;
-    function from(source: string): CQCode;
+    function from(source: string): CQCode & {
+        capture: RegExpExecArray;
+    };
     function parse(source: string | CQCode[]): h[];
 }

package/lib/bot/cqcode.js

@@ -40,7 +40,7 @@ export function CQCode(type, attrs) {
     CQCode.from = from;
     function parse(source) {
         if (typeof source !== "string") {
-            return source.map(({ type, data }) => h(type === "text" ? "text" : type, type === "text" ? { content: data.text } : data));
+            return source.map(({ type, data }) => h(type, data));
         }
         const elements = [];
         let result;

package/lib/bot/index.d.ts

@@ -1,37 +1,53 @@
-import { Context, Schema, Session } from "koishi";
+import { Bot, Context, Schema, Session, Universal } from "koishi";
 import { HttpServer } from "../http";
+import { Internal } from "../internal";
 import { WsClient, WsServer } from "../ws";
-import { BaseBot } from "./base";
-import { QQGuildBot } from "./qqguild";
-export * from "./base";
-export * from "./cqcode";
-export * from "./message";
-export * from "./qqguild";
-export declare class OneBotBot<C extends Context, T extends OneBotBot.Config = OneBotBot.Config> extends BaseBot<C, T> {
-    guildBot: QQGuildBot<C>;
-    constructor(ctx: C, config: T);
+import { OneBotMessageEncoder } from "./message";
+export declare class OneBot<C extends Context = Context> extends Bot<C> {
+    static MessageEncoder: typeof OneBotMessageEncoder;
+    static inject: string[];
+    parent?: OneBot;
+    internal: Internal;
+    constructor(ctx: C, config: OneBot.Config);
     stop(): Promise<void>;
     initialize(): Promise<void>;
-    setupGuildService(): Promise<void>;
-    getChannel(channelId: string): Promise<import("@satorijs/protocol").Channel>;
-    getGuild(guildId: string): Promise<import("@satorijs/protocol").Guild>;
+    createDirectChannel(userId: string): Promise<{
+        id: string;
+        type: Universal.Channel.Type;
+    }>;
+    getMessage(channelId: string, messageId: string): Promise<Universal.Message>;
+    deleteMessage(channelId: string, messageId: string): Promise<void>;
+    getLogin(): Promise<Universal.Login>;
+    getUser(userId: string): Promise<Universal.User>;
+    getFriendList(): Promise<{
+        data: Universal.User[];
+    }>;
+    handleFriendRequest(messageId: string, approve: boolean, comment?: string): Promise<void>;
+    handleGuildRequest(messageId: string, approve: boolean, comment?: string): Promise<void>;
+    handleGuildMemberRequest(messageId: string, approve: boolean, comment?: string): Promise<void>;
+    deleteFriend(userId: string): Promise<void>;
+    getMessageList(channelId: string, next?: string, direction?: Universal.Direction): Promise<{
+        data: Universal.Message[];
+    }>;
+    getChannel(channelId: string): Promise<Universal.Channel>;
+    getGuild(guildId: string): Promise<Universal.Guild>;
     getGuildList(): Promise<{
-        data: import("@satorijs/protocol").Guild[];
+        data: Universal.Guild[];
     }>;
     getChannelList(guildId: string): Promise<{
-        data: import("@satorijs/protocol").Channel[];
+        data: Universal.Channel[];
     }>;
-    getGuildMember(guildId: string, userId: string): Promise<import("@satorijs/protocol").GuildMember>;
+    getGuildMember(guildId: string, userId: string): Promise<Universal.GuildMember>;
     getGuildMemberList(guildId: string): Promise<{
-        data: import("@satorijs/protocol").GuildMember[];
+        data: Universal.GuildMember[];
     }>;
     kickGuildMember(guildId: string, userId: string, permanent?: boolean): Promise<void>;
     muteGuildMember(guildId: string, userId: string, duration: number): Promise<void>;
     muteChannel(channelId: string, guildId?: string, enable?: boolean): Promise<void>;
     checkPermission(name: string, session: Partial<Session>): Promise<boolean>;
 }
-export declare namespace OneBotBot {
-    interface BaseConfig extends BaseBot.Config {
+export declare namespace OneBot {
+    interface BaseConfig {
         selfId: string;
         password?: string;
         token?: string;

package/lib/bot/index.js

@@ -1,82 +1,123 @@
-import { noop, Schema } from "koishi";
+import { Bot, Schema } from "koishi";
 import { HttpServer } from "../http";
-import * as OneBot from "../utils";
+import { Internal } from "../internal";
+import { adaptChannel, adaptGuild, convertUser, decodeGuildMember, decodeMessage } from "../utils";
 import { WsClient, WsServer } from "../ws";
-import { BaseBot } from "./base";
-import { QQGuildBot } from "./qqguild";
-export * from "./base";
-export * from "./cqcode";
-export * from "./message";
-export * from "./qqguild";
-export class OneBotBot extends BaseBot {
-    guildBot;
+import { OneBotMessageEncoder, PRIVATE_PFX } from "./message";
+export class OneBot extends Bot {
+    static MessageEncoder = OneBotMessageEncoder;
+    static inject = ["http"];
+    parent;
+    internal;
     constructor(ctx, config) {
         super(ctx, config, "onebot");
         this.selfId = config.selfId;
-        this.internal = new OneBot.Internal(this);
         this.user.avatar = `http://q.qlogo.cn/headimg_dl?dst_uin=${config.selfId}&spec=640`;
+        this.internal = new Internal(this);
         if (config.protocol === "http") {
             ctx.plugin(HttpServer, this);
         }
-        else if (config.protocol === "ws") {
+        else if (config.protocol === "ws" && config.responseTimeout) {
             ctx.plugin(WsClient, this);
         }
-        else if (config.protocol === "ws-reverse") {
+        else if (config.protocol === "ws-reverse" && config.responseTimeout && config.path) {
             ctx.plugin(WsServer, this);
         }
     }
     async stop() {
-        if (this.guildBot) {
-            // QQGuild stub bot should also be removed
-            delete this.ctx.bots[this.guildBot.sid];
-        }
         await super.stop();
     }
     async initialize() {
-        await Promise.all([this.getLogin(), this.setupGuildService().catch(noop)]).then(() => this.online(), (error) => this.offline(error));
-    }
-    async setupGuildService() {
-        const profile = await this.internal.getGuildServiceProfile();
-        // guild service is not supported in this account
-        if (!profile?.tiny_id || profile.tiny_id === "0")
-            return;
-        this.ctx.plugin(QQGuildBot, {
-            profile,
-            parent: this,
-            advanced: this.config.advanced
-        });
+        await Promise.all([this.getLogin()]).then(() => this.online(), (error) => this.offline(error));
+    }
+    async createDirectChannel(userId) {
+        return { id: `${PRIVATE_PFX}${userId}`, type: 1 /* Universal.Channel.Type.DIRECT */ };
+    }
+    async getMessage(channelId, messageId) {
+        const data = await this.internal.getMsg(Number(messageId));
+        return await decodeMessage(this, data);
+    }
+    async deleteMessage(channelId, messageId) {
+        await this.internal.deleteMsg(Number(messageId));
+    }
+    async getLogin() {
+        const data = await this.internal.getLoginInfo();
+        this.user = {
+            id: data.user_id.toString(),
+            username: data.nickname,
+            avatar: `http://q.qlogo.cn/headimg_dl?dst_uin=${data.user_id}&spec=640`,
+            isBot: true
+        };
+        return this.toJSON();
+    }
+    async getUser(userId) {
+        const data = await this.internal.getStrangerInfo(Number(userId));
+        return convertUser(data, this.selfId === data.user_id.toString());
+    }
+    async getFriendList() {
+        const data = await this.internal.getFriendList();
+        return { data: data.map((item) => convertUser(item, this.selfId === item.user_id.toString())) };
+    }
+    async handleFriendRequest(messageId, approve, comment) {
+        await this.internal.setFriendAddRequest(messageId, approve, comment);
+    }
+    async handleGuildRequest(messageId, approve, comment) {
+        await this.internal.setGroupAddRequest(messageId, "invite", approve, comment);
+    }
+    async handleGuildMemberRequest(messageId, approve, comment) {
+        await this.internal.setGroupAddRequest(messageId, "add", approve, comment);
+    }
+    async deleteFriend(userId) {
+        await this.internal.deleteFriend(Number(userId));
+    }
+    async getMessageList(channelId, next, direction = "before") {
+        if (direction !== "before")
+            throw new Error("Unsupported direction.");
+        // include `before` message
+        let list;
+        if (next) {
+            const msg = await this.internal.getMsg(Number(next));
+            if (msg?.message_seq) {
+                list = (await this.internal.getGroupMsgHistory(Number(channelId), msg.message_id)).messages;
+            }
+        }
+        else {
+            list = (await this.internal.getGroupMsgHistory(Number(channelId))).messages;
+        }
+        // 从旧到新
+        return { data: await Promise.all(list.map((item) => decodeMessage(this, item))) };
     }
     async getChannel(channelId) {
-        const data = await this.internal.getGroupInfo(channelId);
-        return OneBot.adaptChannel(data);
+        const data = await this.internal.getGroupInfo(Number(channelId));
+        return adaptChannel(data);
     }
     async getGuild(guildId) {
-        const data = await this.internal.getGroupInfo(guildId);
-        return OneBot.adaptGuild(data);
+        const data = await this.internal.getGroupInfo(Number(guildId));
+        return adaptGuild(data);
     }
     async getGuildList() {
         const data = await this.internal.getGroupList();
-        return { data: data.map(OneBot.adaptGuild) };
+        return { data: data.map(adaptGuild) };
     }
     async getChannelList(guildId) {
         return { data: [await this.getChannel(guildId)] };
     }
     async getGuildMember(guildId, userId) {
-        const data = await this.internal.getGroupMemberInfo(guildId, userId);
-        return OneBot.decodeGuildMember(data);
+        const data = await this.internal.getGroupMemberInfo(Number(guildId), Number(userId));
+        return decodeGuildMember(data);
     }
     async getGuildMemberList(guildId) {
-        const data = await this.internal.getGroupMemberList(guildId);
-        return { data: data.map(OneBot.decodeGuildMember) };
+        const data = await this.internal.getGroupMemberList(Number(guildId));
+        return { data: data.map((item) => decodeGuildMember(item)) };
     }
     async kickGuildMember(guildId, userId, permanent) {
-        return this.internal.setGroupKick(guildId, userId, permanent);
+        return this.internal.setGroupKick(Number(guildId), Number(userId), permanent);
     }
     async muteGuildMember(guildId, userId, duration) {
-        return this.internal.setGroupBan(guildId, userId, Math.round(duration / 1000));
+        return this.internal.setGroupBan(Number(guildId), Number(userId), Math.round(duration / 1000));
     }
     async muteChannel(channelId, guildId, enable) {
-        return this.internal.setGroupWholeBan(channelId, enable);
+        return this.internal.setGroupWholeBan(Number(channelId), enable);
     }
     async checkPermission(name, session) {
         if (name === "onebot.group.admin") {
@@ -88,21 +129,16 @@ export class OneBotBot extends BaseBot {
         return super.checkPermission(name, session);
     }
 }
-(function (OneBotBot) {
-    OneBotBot.BaseConfig = Schema.object({
+(function (OneBot) {
+    OneBot.BaseConfig = Schema.object({
         selfId: Schema.string().description("机器人的账号。").required(),
         token: Schema.string()
             .role("secret")
             .description("发送信息时用于验证的字段，应与 OneBot 配置文件中的 `access_token` 保持一致。"),
-        protocol: process.env.KOISHI_ENV === "browser"
-            ? Schema.const("ws").default("ws")
-            : Schema.union(["http", "ws", "ws-reverse"]).description("选择要使用的协议。").default("ws-reverse")
+        protocol: Schema.union(["http", "ws", "ws-reverse"]).description("选择要使用的协议。").default("ws-reverse")
     });
-    OneBotBot.Config = Schema.intersect([
-        OneBotBot.BaseConfig,
-        Schema.union([HttpServer.Options, WsClient.Options, WsServer.Options]),
-        Schema.object({
-            advanced: BaseBot.AdvancedConfig
-        })
+    OneBot.Config = Schema.intersect([
+        OneBot.BaseConfig,
+        Schema.union([HttpServer.Options, WsClient.Options, WsServer.Options])
     ]);
-})(OneBotBot || (OneBotBot = {}));
+})(OneBot || (OneBot = {}));

package/lib/bot/message.d.ts

@@ -1,5 +1,5 @@
 import { Context, h, MessageEncoder, Universal } from "koishi";
-import { BaseBot } from "./base";
+import { OneBot } from ".";
 import { CQCode } from "./cqcode";
 export interface Author extends Universal.User {
     time?: string | number;
@@ -8,13 +8,13 @@ export interface Author extends Universal.User {
 declare class State {
     type: "message" | "forward" | "reply";
     author: Partial<Author>;
-    children: CQCode[];
+    children: CQCode.CQCodeUnion[];
     constructor(type: "message" | "forward" | "reply");
 }
 export declare const PRIVATE_PFX = "private:";
-export declare class OneBotMessageEncoder<C extends Context = Context> extends MessageEncoder<C, BaseBot<C>> {
+export declare class OneBotMessageEncoder<C extends Context = Context> extends MessageEncoder<C, OneBot<C>> {
     stack: State[];
-    children: CQCode[];
+    children: CQCode.CQCodeUnion[];
     prepare(): Promise<void>;
     forward(): Promise<void>;
     flush(): Promise<void>;