@alemonjs/bubble 2.1.0-alpha.1

package/lib/sdk/types.d.ts

@@ -0,0 +1,127 @@
+export declare const AvailableIntentsEventsEnum: readonly ["MESSAGE_CREATE", "MESSAGE_UPDATE", "MESSAGE_DELETE", "MESSAGE_UNPIN", "DM_MESSAGE_CREATE", "DM_MESSAGE_UPDATE", "DM_MESSAGE_DELETE", "DM_MESSAGE_UNPIN", "GUILD_MEMBER_ADD", "GUILD_MEMBER_UPDATE", "GUILD_MEMBER_REMOVE", "EVENTS_SUBSCRIBED", "EVENTS_UNSUBSCRIBED", "SUBSCRIBE_DENIED", "BOT_READY"];
+export type IntentsEnum = (typeof AvailableIntentsEventsEnum)[number];
+export declare const AIntentsEventsEnum: IntentsEnum[];
+export interface User {
+    id: string | number;
+    username: string;
+    avatar?: string | null;
+    bot?: boolean;
+    nickname?: string;
+}
+export interface Channel {
+    id: string | number;
+    name: string;
+    type?: number;
+    guild_id?: string | number;
+}
+export interface Guild {
+    id: string | number;
+    name: string;
+}
+export interface Attachment {
+    path: string;
+    url: string;
+    contentType: string;
+    size: number;
+    filename: string;
+    category?: string;
+}
+export interface BaseMessage {
+    id: string | number;
+    content: string;
+    type?: string | number;
+    channel_id?: string | number;
+    guild_id?: string | number;
+    author_id?: string | number;
+    author?: User;
+    mentions?: User[];
+    attachments?: Attachment[];
+    created_at?: string;
+    timestamp?: string;
+}
+export interface MessageCreateEvent extends BaseMessage {
+    member?: {
+        nickname?: string;
+        roles?: number[];
+    };
+}
+export interface DmMessageCreateEvent extends BaseMessage {
+    thread_id?: string | number;
+}
+export type MessageUpdateEvent = BaseMessage;
+export interface MessageDeleteEvent {
+    id: string | number;
+    channel_id?: string | number;
+    guild_id?: string | number;
+}
+export interface GuildMemberEvent {
+    user?: User;
+    user_id?: string | number;
+    guild_id?: string | number;
+    nickname?: string;
+    roles?: number[];
+}
+export interface BotReadyEvent {
+    session_id?: string;
+    resume_gateway_url?: string;
+    guilds?: Guild[];
+    dm_threads?: Array<{
+        id: string | number;
+        user_id?: string | number;
+    }>;
+    available_events?: string[];
+}
+export interface EventsSubscribedEvent {
+    subscribedEvents: string[];
+}
+export interface EventsUnsubscribedEvent {
+    unsubscribedEvents: string[];
+}
+export interface SubscribeDeniedEvent {
+    reason?: string;
+    events?: string[];
+}
+export interface BotInfo {
+    id: number;
+    name: string;
+    botUser?: {
+        id: number;
+        name: string;
+    };
+}
+export interface SendMessagePayload {
+    content?: string;
+    type?: string;
+    attachments?: Attachment[];
+    components?: any[];
+}
+export interface FileUploadResponse {
+    file: Attachment;
+}
+export interface FileQuota {
+    usage: {
+        dailyUsedBytes: number;
+        monthlyUsedBytes: number;
+    };
+    limits: {
+        withMessage: Record<string, any>;
+        noMessage: Record<string, any>;
+    };
+}
+export interface BubbleEventMap {
+    MESSAGE_CREATE: MessageCreateEvent;
+    MESSAGE_UPDATE: MessageUpdateEvent;
+    MESSAGE_DELETE: MessageDeleteEvent;
+    MESSAGE_UNPIN: MessageDeleteEvent;
+    DM_MESSAGE_CREATE: DmMessageCreateEvent;
+    DM_MESSAGE_UPDATE: DmMessageCreateEvent;
+    DM_MESSAGE_DELETE: MessageDeleteEvent;
+    DM_MESSAGE_UNPIN: MessageDeleteEvent;
+    GUILD_MEMBER_ADD: GuildMemberEvent;
+    GUILD_MEMBER_UPDATE: GuildMemberEvent;
+    GUILD_MEMBER_REMOVE: GuildMemberEvent;
+    BOT_READY: BotReadyEvent;
+    EVENTS_SUBSCRIBED: EventsSubscribedEvent;
+    EVENTS_UNSUBSCRIBED: EventsUnsubscribedEvent;
+    SUBSCRIBE_DENIED: SubscribeDeniedEvent;
+}

package/lib/sdk/types.js

@@ -0,0 +1,20 @@
+const AvailableIntentsEventsEnum = [
+    'MESSAGE_CREATE',
+    'MESSAGE_UPDATE',
+    'MESSAGE_DELETE',
+    'MESSAGE_UNPIN',
+    'DM_MESSAGE_CREATE',
+    'DM_MESSAGE_UPDATE',
+    'DM_MESSAGE_DELETE',
+    'DM_MESSAGE_UNPIN',
+    'GUILD_MEMBER_ADD',
+    'GUILD_MEMBER_UPDATE',
+    'GUILD_MEMBER_REMOVE',
+    'EVENTS_SUBSCRIBED',
+    'EVENTS_UNSUBSCRIBED',
+    'SUBSCRIBE_DENIED',
+    'BOT_READY'
+];
+const AIntentsEventsEnum = Array.from(AvailableIntentsEventsEnum);
+
+export { AIntentsEventsEnum, AvailableIntentsEventsEnum };

package/lib/sdk/wss.d.ts

@@ -0,0 +1,11 @@
+import { BubbleAPI } from './api.js';
+import { type IntentsEnum, type BubbleEventMap } from './types.js';
+export declare class BubbleClient extends BubbleAPI {
+    #private;
+    constructor();
+    on<K extends keyof BubbleEventMap>(event: K, handler: (payload: BubbleEventMap[K]) => void | Promise<void>): this;
+    on(event: string, handler: (payload: any) => void | Promise<void>): this;
+    sendSubscribe(events: IntentsEnum[]): void;
+    sendUnsubscribe(events: IntentsEnum[]): void;
+    connect(): void;
+}

package/lib/sdk/wss.js

@@ -0,0 +1,149 @@
+import WebSocket from 'ws';
+import { BubbleAPI } from './api.js';
+import { getBubbleConfig } from '../config.js';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import { AIntentsEventsEnum } from './types.js';
+import dayjs from 'dayjs';
+import { OpCode } from './wss.types.js';
+
+class BubbleClient extends BubbleAPI {
+    #heartbeat_interval = 0;
+    #session_id = '';
+    #gateway_url = '';
+    #timeout_id = null;
+    #seq = null;
+    #ws = null;
+    #count = 0;
+    #events = {};
+    constructor() {
+        super();
+        return this;
+    }
+    #getReConnectTime() {
+        const time = this.#count > 3 ? 1000 * 6 : 1000 * 1;
+        const curTime = this.#count > 6 ? 1000 * this.#count * 2 : time;
+        logger?.info?.(`[ws-bubble] 等待 ${dayjs(curTime).format('mm:ss')} 后重新连接`);
+        return curTime;
+    }
+    on(event, handler) {
+        this.#events[event] = handler;
+        return this;
+    }
+    sendSubscribe(events) {
+        if (!this.#ws) {
+            return;
+        }
+        const payload = { events };
+        this.#ws.send(JSON.stringify({ op: OpCode.Subscribe, d: payload }));
+    }
+    sendUnsubscribe(events) {
+        if (!this.#ws) {
+            return;
+        }
+        const payload = { events };
+        this.#ws.send(JSON.stringify({ op: OpCode.Unsubscribe, d: payload }));
+    }
+    connect() {
+        this.#count++;
+        const value = getBubbleConfig();
+        const url = value.URL;
+        this.#seq = null;
+        clearTimeout(this.#timeout_id);
+        try {
+            if (!url) {
+                logger?.error?.('[ws-bubble] 未在配置中找到 WebSocket `URL`，请在配置中设置 `URL` 字段以连接网关');
+                const curTime = this.#getReConnectTime();
+                setTimeout(() => {
+                    void this.connect();
+                }, curTime);
+                return;
+            }
+            const callHeartbeat = () => {
+                if (!this.#ws) {
+                    return;
+                }
+                this.#ws.send(JSON.stringify({ op: OpCode.Heartbeat, d: this.#seq }));
+                clearTimeout(this.#timeout_id);
+                this.#timeout_id = setTimeout(callHeartbeat, this.#heartbeat_interval);
+            };
+            const handlers = {
+                [OpCode.Dispatch]: ({ d, t, s }) => {
+                    if (s !== null) {
+                        this.#seq = s;
+                    }
+                    if (t === 'BOT_READY') {
+                        if (d?.resume_gateway_url) {
+                            this.#gateway_url = d.resume_gateway_url;
+                            logger?.info?.('[ws-bubble] gateway_url', this.#gateway_url);
+                        }
+                        if (d?.session_id) {
+                            this.#session_id = d.session_id;
+                            logger?.info?.('[ws-bubble] session_id', this.#session_id);
+                        }
+                        const events = value.intent || AIntentsEventsEnum;
+                        this.sendSubscribe(events);
+                    }
+                    if (t && this.#events[t]) {
+                        try {
+                            this.#events[t](d);
+                        }
+                        catch (err) {
+                            logger?.error?.('[ws-bubble] 事件处理错误', err);
+                        }
+                    }
+                },
+                [OpCode.Hello]: ({ d }) => {
+                    this.#heartbeat_interval = d.heartbeat_interval || 30000;
+                    callHeartbeat();
+                },
+                [OpCode.HeartbeatAck]: () => {
+                    logger?.debug?.('[ws-bubble] 心跳确认');
+                }
+            };
+            const ClientOptions = value.websocket_options || {};
+            const token = value.token;
+            const clientName = value.clientName || 'alemonjs-bot';
+            ClientOptions.headers = Object.assign({}, ClientOptions.headers || {}, {
+                Authorization: `Bearer ${token}`,
+                'X-Client': clientName
+            });
+            if (value.websocket_proxy) {
+                ClientOptions.agent = new HttpsProxyAgent(value.websocket_proxy);
+            }
+            this.#ws = new WebSocket(url, ClientOptions);
+            this.#ws.on('open', () => {
+                logger?.info?.('[ws-bubble] 打开连接');
+                this.#count = 0;
+            });
+            this.#ws.on('message', data => {
+                let message;
+                try {
+                    message = JSON.parse(data.toString());
+                }
+                catch (err) {
+                    logger?.error?.('[ws-bubble] 解析消息错误', err);
+                    return;
+                }
+                const op = message.op;
+                if (handlers[op]) {
+                    handlers[op](message);
+                }
+            });
+            this.#ws.on('close', err => {
+                logger?.info?.('[ws-bubble] 连接关闭', err);
+                const curTime = this.#getReConnectTime();
+                setTimeout(() => {
+                    void this.connect();
+                }, curTime);
+            });
+            this.#ws.on('error', err => {
+                logger?.error?.('[ws-bubble] 出错', err?.message || err);
+            });
+        }
+        catch (err) {
+            logger?.error?.('[ws-bubble] 内部错误', err);
+        }
+    }
+}
+
+export { BubbleClient };

package/lib/sdk/wss.types.d.ts

@@ -0,0 +1,24 @@
+import { IntentsEnum } from './types.js';
+export declare enum OpCode {
+    Dispatch = 0,
+    Heartbeat = 1,
+    Hello = 10,
+    HeartbeatAck = 11,
+    Subscribe = 30,
+    Unsubscribe = 31
+}
+export interface BUBBLEOptions {
+    API_URL: string;
+    CDN_URL: string;
+    GATEWAY_URL: string;
+    token: string;
+    intent?: IntentsEnum[];
+    clientName?: string;
+}
+export type BubbleEventMap = Record<string, any>;
+export interface HelloPayload {
+    heartbeat_interval: number;
+}
+export interface SubscribePayload {
+    events: string[];
+}

package/lib/sdk/wss.types.js

@@ -0,0 +1,11 @@
+var OpCode;
+(function (OpCode) {
+    OpCode[OpCode["Dispatch"] = 0] = "Dispatch";
+    OpCode[OpCode["Heartbeat"] = 1] = "Heartbeat";
+    OpCode[OpCode["Hello"] = 10] = "Hello";
+    OpCode[OpCode["HeartbeatAck"] = 11] = "HeartbeatAck";
+    OpCode[OpCode["Subscribe"] = 30] = "Subscribe";
+    OpCode[OpCode["Unsubscribe"] = 31] = "Unsubscribe";
+})(OpCode || (OpCode = {}));
+
+export { OpCode };

package/lib/send.d.ts

@@ -0,0 +1,12 @@
+import { DataEnums } from 'alemonjs';
+import { BubbleClient } from './sdk/wss';
+type Client = typeof BubbleClient.prototype;
+export declare const sendchannel: (client: Client, param: {
+    channel_id: string | number;
+}, val: DataEnums[]) => Promise<import("alemonjs").Result<any>[]>;
+export declare const senduser: (client: Client, param: {
+    author_id?: string | number;
+    channel_id?: string | number;
+}, val: DataEnums[]) => Promise<import("alemonjs").Result<any>[]>;
+declare const _default: {};
+export default _default;

package/lib/send.js

@@ -0,0 +1,201 @@
+import { createResult, ResultCode } from 'alemonjs';
+import { readFileSync } from 'fs';
+
+const ImageURLToBuffer = async (url) => {
+    const arrayBuffer = await fetch(url).then(res => res.arrayBuffer());
+    return Buffer.from(arrayBuffer);
+};
+const createButtonsData = (rows) => {
+    return rows.map(row => {
+        const val = row.value;
+        return {
+            type: 1,
+            components: val.map(button => {
+                const value = button.value;
+                let text = '';
+                if (typeof button.options?.data === 'object') {
+                    text = button.options?.data.click;
+                }
+                else {
+                    text = button.options.data;
+                }
+                return {
+                    type: 2,
+                    custom_id: text,
+                    style: 1,
+                    label: typeof value === 'object' ? value.title : value
+                };
+            })
+        };
+    });
+};
+const sendchannel = async (client, param, val) => {
+    try {
+        if (!val || val.length <= 0) {
+            return [];
+        }
+        const channelId = String(param?.channel_id ?? '');
+        const images = val.filter(item => item.type === 'Image' || item.type === 'ImageURL' || item.type === 'ImageFile');
+        const buttons = val.filter(item => item.type === 'BT.group');
+        const mds = val.filter(item => item.type === 'Markdown');
+        const content = val
+            .filter(item => item.type === 'Mention' || item.type === 'Text' || item.type === 'Link')
+            .map(item => {
+            if (item.type === 'Link') {
+                return `[${item.value}](${item?.options?.link ?? item.value})`;
+            }
+            else if (item.type === 'Mention') {
+                if (item.value === 'everyone' || item.value === 'all' || item.value === '' || typeof item.value !== 'string') {
+                    return '<@everyone>';
+                }
+                if (item.options?.belong === 'user') {
+                    return `<@${item.value}>`;
+                }
+                else if (item.options?.belong === 'channel') {
+                    return `<#${item.value}>`;
+                }
+                return '';
+            }
+            else if (item.type === 'Text') {
+                if (item.options?.style === 'block') {
+                    return `\`${item.value}\``;
+                }
+                else if (item.options?.style === 'italic') {
+                    return `*${item.value}*`;
+                }
+                else if (item.options?.style === 'bold') {
+                    return `**${item.value}**`;
+                }
+                else if (item.options?.style === 'strikethrough') {
+                    return `~~${item.value}~~`;
+                }
+                return item.value ?? '';
+            }
+            return '';
+        })
+            .join('');
+        if (images.length > 0) {
+            let bufferData = null;
+            for (let i = 0; i < images.length; i++) {
+                if (bufferData) {
+                    break;
+                }
+                const item = images[i];
+                if (item.type === 'Image') {
+                    bufferData = Buffer.from(item.value, 'base64');
+                }
+                else if (item.type === 'ImageURL') {
+                    const res = await ImageURLToBuffer(item.value);
+                    bufferData = res;
+                }
+                else if (item.type === 'ImageFile') {
+                    bufferData = readFileSync(item.value);
+                }
+            }
+            const uploadRes = await client.uploadFile(bufferData, undefined, { channelId });
+            const fileAttachment = uploadRes?.file;
+            if (!fileAttachment) {
+                throw new Error('文件上传失败：未返回文件信息');
+            }
+            const attachments = [fileAttachment];
+            const payload = {
+                content: content,
+                type: 'text',
+                attachments
+            };
+            const res = await client.sendMessage(channelId, payload);
+            return [createResult(ResultCode.Ok, '完成', res)];
+        }
+        let contentMd = '';
+        if (mds && mds.length > 0) {
+            mds.forEach(item => {
+                if (item.type === 'Markdown') {
+                    const md = item.value;
+                    md.forEach(line => {
+                        if (line.type === 'MD.text') {
+                            contentMd += line.value;
+                        }
+                        else if (line.type === 'MD.blockquote') {
+                            contentMd += `> ${line.value}\n`;
+                        }
+                        else if (line.type === 'MD.bold') {
+                            contentMd += `**${line.value}**`;
+                        }
+                        else if (line.type === 'MD.italic') {
+                            contentMd += `*${line.value}*`;
+                        }
+                        else if (line.type === 'MD.divider') {
+                            contentMd += '---\n';
+                        }
+                        else if (line.type === 'MD.image') {
+                            contentMd += `![${line.value}](${line.value})`;
+                        }
+                        else if (line.type === 'MD.link') {
+                            contentMd += `[${line.value}](${line.value})`;
+                        }
+                        else if (line.type === 'MD.list') {
+                            const listStr = line.value.map(listItem => {
+                                if (typeof listItem.value === 'object') {
+                                    return `\n${listItem.value.index}. ${listItem.value.text}`;
+                                }
+                                return `\n- ${listItem.value}`;
+                            });
+                            contentMd += `${listStr}\n`;
+                        }
+                        else if (line.type === 'MD.newline') {
+                            contentMd += '\n';
+                        }
+                        else if (line.type === 'MD.code') {
+                            const language = line?.options?.language || '';
+                            contentMd += `\`\`\`${language}\n${line.value}\n\`\`\`\n`;
+                        }
+                        else {
+                            const value = line['value'] || '';
+                            contentMd += String(value);
+                        }
+                    });
+                }
+            });
+        }
+        if (buttons && buttons.length > 0) {
+            let components = null;
+            buttons.forEach(item => {
+                if (components) {
+                    return;
+                }
+                const rows = item.value;
+                components = createButtonsData(rows);
+            });
+            const res = await client.sendMessage(channelId, {
+                content: contentMd || content,
+                components
+            });
+            return [createResult(ResultCode.Ok, '完成', res)];
+        }
+        if (content && content.length > 0) {
+            const res = await client.sendMessage(channelId, { content: contentMd || content });
+            return [createResult(ResultCode.Ok, '完成', res)];
+        }
+        return [];
+    }
+    catch (err) {
+        return [createResult(ResultCode.Fail, err?.response?.data ?? err?.message ?? err, null)];
+    }
+};
+const senduser = async (client, param, val) => {
+    if (!val || val.length <= 0) {
+        return [];
+    }
+    let channelId = param?.channel_id;
+    if (!channelId && param.author_id) {
+        const dm = await client.getOrCreateDm(param.author_id);
+        channelId = dm?.id;
+    }
+    if (!channelId) {
+        return [];
+    }
+    return sendchannel(client, { channel_id: channelId }, val);
+};
+var send = {};
+
+export { send as default, sendchannel, senduser };

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@alemonjs/bubble",
+  "version": "2.1.0-alpha.1",
+  "description": "bubble platform",
+  "author": "lemonade",
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib",
+  "scripts": {
+    "build": "lvy build"
+  },
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.js"
+    },
+    "./package": "./package.json",
+    "./desktop": "./lib/desktop.js"
+  },
+  "dependencies": {
+    "http-proxy-agent": "^7.0.2",
+    "https-proxy-agent": "^7"
+  },
+  "devDependencies": {
+    "@types/qrcode": "^1.5.5"
+  },
+  "peerDependencies": {
+    "alemonjs": "^2.1.0-alpha.15"
+  },
+  "alemonjs": {
+    "desktop": {
+      "platform": [
+        {
+          "name": "bubble"
+        }
+      ],
+      "logo": "antd.bubbleOutlined",
+      "command": [
+        {
+          "name": "打开bubble",
+          "icon": "antd.bubbleOutlined",
+          "command": "open.bubble"
+        }
+      ],
+      "sidebars": [
+        {
+          "name": "dc",
+          "icon": "antd.bubbleOutlined",
+          "command": "open.bubble"
+        }
+      ]
+    }
+  },
+  "keywords": [
+    "alemonjs"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "bugs": "https://github.com/lemonade-lab/alemonjs/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lemonade-lab/alemonjs.git"
+  }
+}