@alemonjs/bubble 2.1.0-alpha.1

package/lib/config.js

@@ -0,0 +1,34 @@
+import { useUserHashKey, getConfigValue } from 'alemonjs';
+import { GATEWAY_URL, API_URL, CDN_URL } from './sdk/api.js';
+
+const platform = 'bubble';
+const getBubbleConfig = () => {
+    const value = getConfigValue() || {};
+    const config = value[platform] || {};
+    if (!config.URL && !config.GATEWAY_URL) {
+        config.URL = GATEWAY_URL;
+    }
+    else if (config.GATEWAY_URL && !config.URL) {
+        config.URL = config.GATEWAY_URL;
+    }
+    if (!config.API_URL) {
+        config.API_URL = API_URL;
+    }
+    if (!config.CDN_URL) {
+        config.CDN_URL = CDN_URL;
+    }
+    return config;
+};
+const getMaster = (UserId) => {
+    const config = getBubbleConfig();
+    const masterKey = config.master_key || [];
+    const masterId = config.master_id || [];
+    const UserKey = useUserHashKey({
+        Platform: platform,
+        UserId: UserId
+    });
+    const is = masterKey.includes(UserKey) || masterId.includes(UserId);
+    return [is, UserKey];
+};
+
+export { getBubbleConfig, getMaster, platform };

package/lib/desktop.d.ts

@@ -0,0 +1 @@
+export declare const activate: (context: any) => void;

package/lib/desktop.js

@@ -0,0 +1,52 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { getConfig, getConfigValue } from 'alemonjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const activate = context => {
+    const webView = context.createSidebarWebView(context);
+    context.onCommand('open.bubble', () => {
+        const dir = join(__dirname, '../', 'dist', 'index.html');
+        const scriptReg = /<script.*?src="(.+?)".*?>/;
+        const styleReg = /<link.*?rel="stylesheet".*?href="(.+?)".*?>/;
+        const iconReg = /<link.*?rel="icon".*?href="(.+?)".*?>/g;
+        const styleUri = context.createExtensionDir(join(__dirname, '../', 'dist', 'assets', 'index.css'));
+        const scriptUri = context.createExtensionDir(join(__dirname, '../', 'dist', 'assets', 'index.js'));
+        const html = readFileSync(dir, 'utf-8')
+            .replace(iconReg, '')
+            .replace(scriptReg, `<script type="module" crossorigin src="${scriptUri}"></script>`)
+            .replace(styleReg, `<link rel="stylesheet" crossorigin href="${styleUri}">`);
+        webView.loadWebView(html);
+    });
+    webView.onMessage(data => {
+        try {
+            if (data.type === 'bubble.form.save') {
+                const db = data.data;
+                const config = getConfig();
+                const value = config.value ?? {};
+                value['bubble'] = {
+                    token: db.token ?? '',
+                    master_key: db.master_key?.split(',') ?? null
+                };
+                config.saveValue(value);
+                context.notification('bubble 配置保存成功～');
+            }
+            else if (data.type === 'bubble.init') {
+                let config = getConfigValue();
+                if (!config) {
+                    config = {};
+                }
+                webView.postMessage({
+                    type: 'bubble.init',
+                    data: config.bubble ?? {}
+                });
+            }
+        }
+        catch (e) {
+            logger.error(e);
+        }
+    });
+};
+
+export { activate };

package/lib/hook.d.ts

@@ -0,0 +1,25 @@
+import { EventKeys, Events } from 'alemonjs';
+import { BubbleAPI as API } from './sdk/api';
+type MAP = {
+    'message.create': object;
+    'private.message.create': object;
+    'interaction.create': object;
+    'private.interaction.create': object;
+    'message.update': undefined;
+    'message.delete': undefined;
+    'message.reaction.add': undefined;
+    'message.reaction.remove': undefined;
+    'channal.create': undefined;
+    'channal.delete': undefined;
+    'guild.join': undefined;
+    'guild.exit': undefined;
+    'member.add': undefined;
+    'member.remove': undefined;
+    'private.message.update': undefined;
+    'private.message.delete': undefined;
+    'private.friend.add': undefined;
+    'private.guild.add': undefined;
+};
+export declare const useValue: <T extends EventKeys>(event: Events[T]) => readonly [MAP[T]];
+export declare const useClient: <T extends EventKeys>(event: Events[T]) => readonly [API, MAP[T]];
+export {};

package/lib/hook.js

@@ -0,0 +1,14 @@
+import { createEventValue, useClient as useClient$1 } from 'alemonjs';
+import { BubbleAPI } from './sdk/api.js';
+
+const useValue = (event) => {
+    const value = createEventValue(event);
+    return [value];
+};
+const useClient = (event) => {
+    const [client] = useClient$1(event, BubbleAPI);
+    const value = createEventValue(event);
+    return [client, value];
+};
+
+export { useClient, useValue };

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export { platform } from './config';
+export { BubbleAPI as API } from './sdk/api';
+export { API_URL, CDN_URL, GATEWAY_URL } from './sdk/api';
+export type { IntentsEnum, User, Channel, Guild, Attachment, BaseMessage, MessageCreateEvent, DmMessageCreateEvent, MessageUpdateEvent, MessageDeleteEvent, GuildMemberEvent, BotReadyEvent, EventsSubscribedEvent, EventsUnsubscribedEvent, SubscribeDeniedEvent, BotInfo, SendMessagePayload, FileUploadResponse, FileQuota, BubbleEventMap } from './sdk/types';
+export { BubbleClient } from './sdk/wss';
+export { OpCode } from './sdk/wss.types';
+export type { BUBBLEOptions, HelloPayload, SubscribePayload } from './sdk/wss.types';
+export * from './hook';
+export { type Options } from './config';
+declare const main: () => void;
+export default main;

package/lib/index.js

@@ -0,0 +1,223 @@
+import { BubbleClient } from './sdk/wss.js';
+import { cbpPlatform, createResult, ResultCode } from 'alemonjs';
+import { getMaster, platform } from './config.js';
+import { CDN_URL } from './sdk/api.js';
+export { BubbleAPI as API, API_URL, GATEWAY_URL } from './sdk/api.js';
+import { sendchannel, senduser } from './send.js';
+export { OpCode } from './sdk/wss.types.js';
+export { useClient, useValue } from './hook.js';
+
+const main = () => {
+    const port = process.env?.port || 17117;
+    const url = `ws://127.0.0.1:${port}`;
+    const cbp = cbpPlatform(url);
+    const client = new BubbleClient();
+    void client.connect();
+    const createUserAvatar = (_UserId, avatar) => {
+        return `${CDN_URL}/${avatar}`;
+    };
+    client.on('MESSAGE_CREATE', event => {
+        if (event.author?.bot) {
+            return;
+        }
+        const atUsers = [];
+        for (const item of event.mentions || []) {
+            atUsers.push({
+                id: String(item.id)
+            });
+        }
+        let msg = event.content;
+        for (const item of atUsers) {
+            msg = msg.replace(`<@${item.id}>`, '').trim();
+        }
+        const UserId = String(event.author.id);
+        const [isMaster, UserKey] = getMaster(UserId);
+        const UserAvatar = createUserAvatar(UserId, event.author.avatar);
+        if (event.type === 0 && event.member) {
+            const e = {
+                name: 'message.create',
+                Platform: platform,
+                GuildId: String(event.guild_id || ''),
+                ChannelId: String(event.channel_id || ''),
+                SpaceId: String(event.channel_id || ''),
+                UserId: UserId,
+                UserKey,
+                UserName: event.author.username,
+                UserAvatar: UserAvatar,
+                IsMaster: isMaster,
+                IsBot: false,
+                OpenId: UserId,
+                MessageId: String(event.id),
+                MessageText: msg,
+                CreateAt: Date.now(),
+                tag: 'message.create',
+                value: event
+            };
+            cbp.send(e);
+        }
+        else if (event.type === 0 && !event.member) {
+            const e = {
+                name: 'private.message.create',
+                Platform: platform,
+                UserId: UserId,
+                UserKey,
+                UserName: event.author.username,
+                UserAvatar: UserAvatar,
+                IsMaster: isMaster,
+                IsBot: false,
+                OpenId: UserId,
+                MessageId: String(event.id),
+                MessageText: msg,
+                CreateAt: Date.now(),
+                tag: 'private.message.create',
+                value: event
+            };
+            cbp.send(e);
+        }
+        else ;
+    });
+    const api = {
+        active: {
+            send: {
+                channel: async (UserId, val) => {
+                    const res = await sendchannel(client, { channel_id: UserId }, val);
+                    return [createResult(ResultCode.Ok, '请求完成', res)];
+                },
+                user: async (OpenId, val) => {
+                    const res = await senduser(client, { author_id: OpenId }, val);
+                    return [createResult(ResultCode.Ok, '请求完成', res)];
+                }
+            }
+        },
+        use: {
+            send: async (event, val) => {
+                if (val.length < 0) {
+                    return [];
+                }
+                const tag = event.tag;
+                if (tag === 'message.create') {
+                    const ChannelId = String(event.value.channel_id || '');
+                    const res = await sendchannel(client, { channel_id: ChannelId }, val);
+                    return [createResult(ResultCode.Ok, '请求完成', res)];
+                }
+                else if (tag === 'private.message.create') {
+                    const UserId = String(event.value.author.id || '');
+                    const ChannelId = String(event.value.channel_id || '');
+                    const res = await senduser(client, {
+                        channel_id: ChannelId,
+                        author_id: UserId
+                    }, val);
+                    return [createResult(ResultCode.Ok, '请求完成', res)];
+                }
+                else if (tag === 'interaction.create') {
+                    const ChannelId = String(event.value.channel_id || '');
+                    const res = await sendchannel(client, { channel_id: ChannelId }, val);
+                    return [createResult(ResultCode.Ok, '请求完成', res)];
+                }
+                else if (tag === 'private.interaction.create') {
+                    const UserId = String(event.value.user.id || '');
+                    const ChannelId = String(event.value.channel_id || '');
+                    const res = await senduser(client, {
+                        channel_id: ChannelId,
+                        author_id: UserId
+                    }, val);
+                    return [createResult(ResultCode.Ok, '请求完成', res)];
+                }
+                return [];
+            },
+            mention: e => {
+                const event = e.value;
+                const MessageMention = event.mentions.map(item => {
+                    const UserId = item.id;
+                    const avatar = event.author.avatar;
+                    const UserAvatar = createUserAvatar(UserId, avatar);
+                    const [isMaster, UserKey] = getMaster(UserId);
+                    return {
+                        UserId: item.id,
+                        IsMaster: isMaster,
+                        IsBot: item.bot,
+                        UserAvatar,
+                        UserKey
+                    };
+                });
+                return new Promise(resolve => {
+                    resolve(MessageMention);
+                });
+            }
+        }
+    };
+    const onactions = async (data, consume) => {
+        try {
+            if (data.action === 'message.send') {
+                const event = data.payload.event;
+                const paramFormat = data.payload.params.format;
+                const res = await api.use.send(event, paramFormat);
+                consume(res);
+            }
+            else if (data.action === 'message.send.channel') {
+                const channelId = data.payload.ChannelId;
+                const val = data.payload.params.format;
+                const res = await api.active.send.channel(channelId, val);
+                consume(res);
+            }
+            else if (data.action === 'message.send.user') {
+                const userId = data.payload.UserId;
+                const val = data.payload.params.format;
+                const res = await api.active.send.user(userId, val);
+                consume(res);
+            }
+            else if (data.action === 'mention.get') {
+                const event = data.payload.event;
+                const res = await api.use.mention(event);
+                consume([createResult(ResultCode.Ok, '请求完成', res)]);
+            }
+        }
+        catch (error) {
+            consume([createResult(ResultCode.Fail, '请求失败', error)]);
+        }
+    };
+    cbp.onactions((data, consume) => void onactions(data, consume));
+    const onapis = async (data, consume) => {
+        const key = data.payload?.key;
+        if (client[key]) {
+            const params = data.payload.params;
+            try {
+                const res = await client[key](...params);
+                consume([createResult(ResultCode.Ok, '请求完成', res)]);
+            }
+            catch (error) {
+                consume([createResult(ResultCode.Fail, '请求失败', error)]);
+            }
+        }
+    };
+    cbp.onapis((data, consume) => void onapis(data, consume));
+};
+const mainProcess = () => {
+    ['SIGINT', 'SIGTERM', 'SIGQUIT', 'disconnect'].forEach(sig => {
+        process?.on?.(sig, () => {
+            logger.info?.(`[alemonjs][${sig}] 收到信号，正在关闭...`);
+            setImmediate(() => process.exit(0));
+        });
+    });
+    process?.on?.('exit', code => {
+        logger.info?.(`[alemonjs][exit] 进程退出，code=${code}`);
+    });
+    process.on('message', msg => {
+        try {
+            const data = typeof msg === 'string' ? JSON.parse(msg) : msg;
+            if (data?.type === 'start') {
+                main();
+            }
+            else if (data?.type === 'stop') {
+                process.exit(0);
+            }
+        }
+        catch { }
+    });
+    if (process.send) {
+        process.send(JSON.stringify({ type: 'ready' }));
+    }
+};
+mainProcess();
+
+export { BubbleClient, CDN_URL, main as default, platform };

package/lib/sdk/api.d.ts

@@ -0,0 +1,29 @@
+import { type AxiosRequestConfig } from 'axios';
+import type { BotInfo, SendMessagePayload, FileUploadResponse, FileQuota, BaseMessage, Channel, User } from './types.js';
+export declare const API_URL: string;
+export declare const CDN_URL: string;
+export declare const GATEWAY_URL: string;
+export declare class BubbleAPI {
+    request(options: AxiosRequestConfig): Promise<any>;
+    getMe(): Promise<BotInfo>;
+    sendMessage(channelId: string | number, data: SendMessagePayload): Promise<BaseMessage>;
+    getChannelMessages(channelId: string | number): Promise<BaseMessage[]>;
+    editMessage(channelId: string | number, messageId: string | number, data: Partial<SendMessagePayload>): Promise<BaseMessage>;
+    deleteMessage(channelId: string | number, messageId: string | number): Promise<void>;
+    listGuildChannels(guildId: string | number): Promise<Channel[]>;
+    getChannel(channelId: string | number): Promise<Channel>;
+    listGuildMembers(guildId: string | number): Promise<User[]>;
+    getGuildMember(guildId: string | number, userId: string | number): Promise<User>;
+    getOrCreateDm(userId: string | number): Promise<{
+        id: number;
+        type: string;
+    }>;
+    sendDm(threadId: string | number, data: SendMessagePayload): Promise<BaseMessage>;
+    getDmMessages(threadId: string | number): Promise<BaseMessage[]>;
+    uploadFile(file: any, filename?: string, extra?: {
+        channelId?: string | number;
+        threadId?: string | number;
+        messageId?: string | number;
+    }): Promise<FileUploadResponse>;
+    filesQuota(): Promise<FileQuota>;
+}

package/lib/sdk/api.js

@@ -0,0 +1,99 @@
+import axios from 'axios';
+import { getBubbleConfig } from '../config.js';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import { createAxiosInstance } from './instance.js';
+
+const API_URL = process.env.BUBBLE_API_BASE || 'https://bubble.alemonjs.com/api/bot/v1';
+const CDN_URL = process.env.BUBBLE_CDN_BASE || 'https://bubble-oss-files.alemonjs.com';
+const GATEWAY_URL = process.env.BUBBLE_GATEWAY_URL || 'wss://bubble.alemonjs.com/api/bot/gateway';
+class BubbleAPI {
+    request(options) {
+        const value = getBubbleConfig();
+        const token = value.token;
+        const requestConfig = value.request_config ?? {};
+        if (value.request_proxy) {
+            requestConfig.httpsAgent = new HttpsProxyAgent(value.request_proxy);
+        }
+        const service = axios.create({
+            ...requestConfig,
+            baseURL: API_URL,
+            timeout: 6000,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`
+            }
+        });
+        return createAxiosInstance(service, options);
+    }
+    getMe() {
+        return this.request({ method: 'GET', url: '/me' });
+    }
+    sendMessage(channelId, data) {
+        return this.request({ method: 'POST', url: `/channels/${channelId}/messages`, data });
+    }
+    getChannelMessages(channelId) {
+        return this.request({ method: 'GET', url: `/channels/${channelId}/messages` });
+    }
+    editMessage(channelId, messageId, data) {
+        return this.request({ method: 'PUT', url: `/channels/${channelId}/messages/${messageId}`, data });
+    }
+    deleteMessage(channelId, messageId) {
+        return this.request({ method: 'DELETE', url: `/channels/${channelId}/messages/${messageId}` });
+    }
+    listGuildChannels(guildId) {
+        return this.request({ method: 'GET', url: `/guilds/${guildId}/channels` });
+    }
+    getChannel(channelId) {
+        return this.request({ method: 'GET', url: `/channels/${channelId}` });
+    }
+    listGuildMembers(guildId) {
+        return this.request({ method: 'GET', url: `/guilds/${guildId}/members` });
+    }
+    getGuildMember(guildId, userId) {
+        return this.request({ method: 'GET', url: `/guilds/${guildId}/members/${userId}` });
+    }
+    getOrCreateDm(userId) {
+        return this.request({ method: 'GET', url: `/users/${userId}/dm` });
+    }
+    sendDm(threadId, data) {
+        return this.request({ method: 'POST', url: `/dm/threads/${threadId}/messages`, data });
+    }
+    getDmMessages(threadId) {
+        return this.request({ method: 'GET', url: `/dm/threads/${threadId}/messages` });
+    }
+    async uploadFile(file, filename, extra = {}) {
+        const FormData = (await import('form-data')).default;
+        const form = new FormData();
+        form.append('file', file, filename || 'file');
+        if (extra.channelId) {
+            form.append('channelId', String(extra.channelId));
+        }
+        if (extra.threadId) {
+            form.append('threadId', String(extra.threadId));
+        }
+        if (extra.messageId) {
+            form.append('messageId', String(extra.messageId));
+        }
+        const value = getBubbleConfig();
+        const token = value.token;
+        const requestConfig = value.request_config ?? {};
+        if (value.request_proxy) {
+            requestConfig.httpsAgent = new HttpsProxyAgent(value.request_proxy);
+        }
+        const service = axios.create({
+            ...requestConfig,
+            baseURL: API_URL,
+            timeout: 60000,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                ...form.getHeaders()
+            }
+        });
+        return createAxiosInstance(service, { method: 'POST', url: '/files/upload', data: form });
+    }
+    filesQuota() {
+        return this.request({ method: 'GET', url: '/files/quota' });
+    }
+}
+
+export { API_URL, BubbleAPI, CDN_URL, GATEWAY_URL };

package/lib/sdk/createPicFrom.d.ts

@@ -0,0 +1,6 @@
+import { Readable } from 'stream';
+export declare function createPicFrom(image: string | Buffer | Readable, name?: string): Promise<false | {
+    picData: Readable;
+    image: string | Readable | Buffer<ArrayBufferLike>;
+    name: string;
+}>;

package/lib/sdk/createPicFrom.js

@@ -0,0 +1,37 @@
+import { existsSync, createReadStream } from 'fs';
+import { Readable, isReadable } from 'stream';
+import { basename } from 'path';
+import { fileTypeFromBuffer, fileTypeFromStream } from 'file-type';
+
+async function createPicFrom(image, name = 'image.jpg') {
+    let picData;
+    if (typeof image === 'string') {
+        if (!existsSync(image)) {
+            return false;
+        }
+        if (!name) {
+            name = basename(image);
+        }
+        picData = createReadStream(image);
+    }
+    else if (Buffer.isBuffer(image)) {
+        if (!name) {
+            name = 'file.' + (await fileTypeFromBuffer(image)).ext;
+        }
+        picData = new Readable();
+        picData.push(image);
+        picData.push(null);
+    }
+    else if (isReadable(image)) {
+        if (!name) {
+            name = 'file.' + (await fileTypeFromStream(image)).ext;
+        }
+        picData = image;
+    }
+    else {
+        return false;
+    }
+    return { picData, image, name };
+}
+
+export { createPicFrom };

package/lib/sdk/instance.d.ts

@@ -0,0 +1,3 @@
+import { AxiosInstance } from 'axios';
+import { type AxiosRequestConfig } from 'axios';
+export declare const createAxiosInstance: (service: AxiosInstance, options: AxiosRequestConfig) => Promise<any>;

package/lib/sdk/instance.js

@@ -0,0 +1,93 @@
+const filterHeaders = (headers = {}) => {
+    if (!headers) {
+        return headers;
+    }
+    const filtered = {};
+    const sensitiveKeys = [/^authorization$/i, /^cookie$/i, /^set-cookie$/i, /token/i, /key/i, /jwt/i, /^session[-_]id$/i, /^uid$/i, /^user[-_]id$/i];
+    for (const key in headers) {
+        if (/^_/.test(key)) {
+            continue;
+        }
+        if (typeof key === 'symbol') {
+            continue;
+        }
+        if (typeof headers[key] === 'function') {
+            continue;
+        }
+        if (sensitiveKeys.some(re => re.test(key))) {
+            filtered[key] = '******';
+        }
+        else {
+            filtered[key] = headers[key];
+        }
+    }
+    return filtered;
+};
+const filterConfig = (config = {}) => {
+    if (!config) {
+        return config;
+    }
+    const filtered = {};
+    for (const key in config) {
+        if (/^_/.test(key)) {
+            continue;
+        }
+        if (typeof key === 'symbol') {
+            continue;
+        }
+        if (typeof config[key] === 'function') {
+            continue;
+        }
+        filtered[key] = config[key];
+    }
+    return filtered;
+};
+const filterRequest = (request = {}) => {
+    if (!request) {
+        return request;
+    }
+    const filtered = {};
+    for (const key in request) {
+        if (/^_/.test(key)) {
+            continue;
+        }
+        if (typeof key === 'symbol') {
+            continue;
+        }
+        if (typeof request[key] === 'function') {
+            continue;
+        }
+        filtered[key] = request[key];
+    }
+    return filtered;
+};
+const loggerError = err => {
+    logger.error('[axios] error', {
+        config: {
+            headers: filterHeaders(err?.config?.headers),
+            params: err?.config?.params,
+            data: err?.config?.data
+        },
+        response: {
+            status: err?.response?.status,
+            statusText: err?.response?.statusText,
+            headers: filterHeaders(err?.response?.headers),
+            config: filterConfig(err?.response?.config),
+            request: filterRequest(err?.response?.request),
+            data: err?.response?.data
+        },
+        message: err?.message
+    });
+};
+const createAxiosInstance = (service, options) => {
+    return new Promise((resolve, reject) => {
+        service(options)
+            .then(res => resolve(res?.data ?? {}))
+            .catch(err => {
+            loggerError(err);
+            reject(err?.response?.data);
+        });
+    });
+};
+
+export { createAxiosInstance };