koishi-plugin-adapter-onebot-multi 0.0.1

package/lib/admin.d.ts

@@ -0,0 +1,52 @@
+import { Context } from 'koishi';
+import { ConfigManager, BotConfigRecord } from './config-manager';
+import { StatusManager, BotStatus } from './status';
+export interface BotFullInfo extends BotStatus {
+    config: Omit<BotConfigRecord, 'token'>;
+}
+export interface AdminPanelData {
+    bots: BotFullInfo[];
+    updatedAt: number;
+}
+/**
+ * Console 管理面板服务
+ * 提供 Bot 配置的增删改查 API
+ */
+export declare function setupAdminPanel(ctx: Context, configManager: ConfigManager, statusManager: StatusManager): void;
+declare module '@koishijs/console' {
+    interface Events {
+        'onebot-multi/admin/list'(): Promise<AdminPanelData>;
+        'onebot-multi/admin/create'(data: {
+            selfId: string;
+            token?: string;
+            protocol: 'ws' | 'ws-reverse';
+            endpoint?: string;
+            path?: string;
+        }): Promise<{
+            success: boolean;
+            record: BotConfigRecord;
+        }>;
+        'onebot-multi/admin/update'(data: {
+            selfId: string;
+            updates: {
+                token?: string;
+                protocol?: 'ws' | 'ws-reverse';
+                endpoint?: string;
+                path?: string;
+            };
+        }): Promise<{
+            success: boolean;
+            needRestart: boolean;
+        }>;
+        'onebot-multi/admin/delete'(selfId: string): Promise<{
+            success: boolean;
+        }>;
+        'onebot-multi/admin/toggle'(selfId: string): Promise<{
+            success: boolean;
+            enabled: boolean;
+        }>;
+        'onebot-multi/admin/restart'(selfId: string): Promise<{
+            success: boolean;
+        }>;
+    }
+}

package/lib/bot/base.d.ts

@@ -0,0 +1,36 @@
+import { Bot, Context, Schema, Universal } from 'koishi';
+import * as OneBot from '../utils';
+import { OneBotMessageEncoder } from './message';
+export declare class BaseBot<C extends Context = Context, T extends BaseBot.Config = BaseBot.Config> extends Bot<C, T> {
+    static MessageEncoder: typeof OneBotMessageEncoder;
+    static inject: string[];
+    parent?: BaseBot;
+    internal: OneBot.Internal;
+    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, before?: string, direction?: Universal.Direction): Promise<{
+        data: Universal.Message[];
+    }>;
+}
+export declare namespace BaseBot {
+    interface Config {
+        advanced?: AdvancedConfig;
+    }
+    interface AdvancedConfig {
+        splitMixedContent?: boolean;
+    }
+    const AdvancedConfig: Schema<AdvancedConfig>;
+}

package/lib/bot/cqcode.d.ts

@@ -0,0 +1,13 @@
+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 declare namespace CQCode {
+    function escape(source: any, inline?: boolean): string;
+    function unescape(source: string): string;
+    function from(source: string): CQCode;
+    function parse(source: string | CQCode[]): h[];
+}

package/lib/bot/index.d.ts

@@ -0,0 +1,43 @@
+import { Context, Schema, Session } from 'koishi';
+import { QQGuildBot } from './qqguild';
+import { BaseBot } from './base';
+import { WsClient, WsServer } from '../ws';
+import { HeartbeatMonitor } from '../heartbeat';
+export * from './base';
+export * from './cqcode';
+export * from './message';
+export * from './qqguild';
+export declare class OneBotBot<C extends Context = Context, T extends OneBotBot.Config = OneBotBot.Config> extends BaseBot<C, T> {
+    guildBot: QQGuildBot<C>;
+    heartbeat: HeartbeatMonitor;
+    constructor(ctx: C, config: T);
+    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>;
+    getGuildList(): Promise<{
+        data: import("@satorijs/protocol").Guild[];
+    }>;
+    getChannelList(guildId: string): Promise<{
+        data: import("@satorijs/protocol").Channel[];
+    }>;
+    getGuildMember(guildId: string, userId: string): Promise<import("@satorijs/protocol").GuildMember>;
+    getGuildMemberList(guildId: string): Promise<{
+        data: import("@satorijs/protocol").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 {
+        selfId: string;
+        token?: string;
+        heartbeatInterval?: number;
+    }
+    const BaseConfig: Schema<BaseConfig>;
+    type Config = BaseConfig & (WsServer.Options | WsClient.Options);
+    const Config: Schema<Config>;
+}

package/lib/bot/message.d.ts

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

package/lib/bot/qqguild.d.ts

@@ -0,0 +1,31 @@
+import { Context, Universal } from 'koishi';
+import { BaseBot } from './base';
+import { OneBotBot } from './index';
+import * as OneBot from '../utils';
+export declare namespace QQGuildBot {
+    interface Config extends BaseBot.Config {
+        parent: OneBotBot<Context>;
+        profile: OneBot.GuildServiceProfile;
+    }
+}
+export declare class QQGuildBot<C extends Context> extends BaseBot<C> {
+    parent: OneBotBot<Context>;
+    hidden: boolean;
+    constructor(ctx: C, config: QQGuildBot.Config);
+    get status(): Universal.Status;
+    set status(status: Universal.Status);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getChannel(channelId: string, guildId?: string): Promise<Universal.Channel>;
+    getChannelList(guildId: string): Promise<{
+        data: Universal.Channel[];
+    }>;
+    getGuild(guildId: string): Promise<Universal.Guild>;
+    getGuildList(): Promise<{
+        data: Universal.Guild[];
+    }>;
+    getGuildMember(guildId: string, userId: string): Promise<Universal.GuildMember>;
+    getGuildMemberList(guildId: string): Promise<{
+        data: Universal.GuildMember[];
+    }>;
+}

package/lib/config-manager.d.ts

@@ -0,0 +1,70 @@
+import { Context } from 'koishi';
+import type { BotConfig } from './index';
+declare module 'koishi' {
+    interface Tables {
+        'onebot_multi_bots': BotConfigRecord;
+    }
+}
+export interface BotConfigRecord {
+    id: number;
+    selfId: string;
+    token?: string;
+    protocol: 'ws' | 'ws-reverse';
+    endpoint?: string;
+    path?: string;
+    enabled: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare class ConfigManager {
+    private ctx;
+    constructor(ctx: Context);
+    /**
+     * 获取存储的密码哈希
+     */
+    private getStoredPasswordHash;
+    /**
+     * 设置管理密码（哈希存储）
+     */
+    setAdminPassword(password: string): Promise<void>;
+    /**
+     * 检查是否已设置密码
+     */
+    hasAdminPassword(): Promise<boolean>;
+    /**
+     * 验证管理密码
+     */
+    verifyAdminPassword(password: string): Promise<boolean>;
+    /**
+     * 获取所有 Bot 配置（排除系统配置）
+     */
+    getAllConfigs(): Promise<BotConfigRecord[]>;
+    /**
+     * 获取启用的 Bot 配置（排除系统配置）
+     */
+    getEnabledConfigs(): Promise<BotConfigRecord[]>;
+    /**
+     * 获取单个 Bot 配置
+     */
+    getConfig(selfId: string): Promise<BotConfigRecord | undefined>;
+    /**
+     * 创建 Bot 配置
+     */
+    createConfig(config: Omit<BotConfigRecord, 'id' | 'createdAt' | 'updatedAt'>): Promise<BotConfigRecord>;
+    /**
+     * 更新 Bot 配置
+     */
+    updateConfig(selfId: string, updates: Partial<Omit<BotConfigRecord, 'id' | 'selfId' | 'createdAt'>>): Promise<boolean>;
+    /**
+     * 删除 Bot 配置
+     */
+    deleteConfig(selfId: string): Promise<boolean>;
+    /**
+     * 切换 Bot 启用状态
+     */
+    toggleEnabled(selfId: string): Promise<boolean>;
+    /**
+     * 将数据库配置转换为 BotConfig 格式
+     */
+    toBotConfig(record: BotConfigRecord): BotConfig;
+}

package/lib/heartbeat.d.ts

@@ -0,0 +1,18 @@
+import { Context } from 'koishi';
+import type { OneBotBot } from './bot';
+export interface HeartbeatConfig {
+    /** 心跳检测间隔（毫秒） */
+    heartbeatInterval?: number;
+}
+export declare class HeartbeatMonitor {
+    private ctx;
+    private bot;
+    private interval;
+    private timer;
+    private logger;
+    private lastOnlineState;
+    constructor(ctx: Context, bot: OneBotBot, interval: number);
+    start(): void;
+    stop(): void;
+    private check;
+}

package/lib/index.d.ts

@@ -0,0 +1,49 @@
+import { Context, Schema } from 'koishi';
+import { OneBotBot } from './bot';
+import { BaseBot } from './bot/base';
+import { PanelConfig } from './panel';
+import * as OneBot from './utils';
+export { OneBot };
+export * from './bot';
+export * from './ws';
+export * from './heartbeat';
+export * from './status';
+export * from './panel';
+export * from './config-manager';
+export interface BotConfig {
+    selfId: string;
+    token?: string;
+    protocol?: 'ws' | 'ws-reverse';
+    endpoint?: string;
+    path?: string;
+}
+export interface Config {
+    responseTimeout?: number;
+    heartbeatInterval?: number;
+    retryTimes?: number;
+    retryInterval?: number;
+    retryLazy?: number;
+    advanced?: BaseBot.AdvancedConfig;
+    panel?: PanelConfig;
+}
+export declare const Config: Schema<Config>;
+export declare const name = "adapter-onebot-multi";
+export declare const inject: {
+    required: string[];
+};
+export declare function apply(ctx: Context, config: Config): void;
+declare module 'koishi' {
+    interface Events {
+        'onebot/message-reactions-updated'(session: import('koishi').Session): void;
+        'onebot/channel-updated'(session: import('koishi').Session): void;
+        'onebot/channel-created'(session: import('koishi').Session): void;
+        'onebot/channel-destroyed'(session: import('koishi').Session): void;
+        'onebot-multi/bot-online'(bot: OneBotBot): void;
+        'onebot-multi/bot-offline'(bot: OneBotBot): void;
+    }
+}
+declare module '@satorijs/core' {
+    interface Session {
+        onebot?: OneBot.Payload & OneBot.Internal;
+    }
+}