wechaty-web-panel 1.6.112 → 1.6.113

package/dist/botInstance/sdk/qanything.js

@@ -0,0 +1,137 @@
+import axios from 'axios';
+const BASE_URL = 'https://openapi.youdao.com';
+const routes = {
+    // 发起对话
+    creatChat: {
+        method: 'POST', url: () => '/q_anything/api/bot/chat_stream',
+    }
+};
+class QAnyClient {
+    constructor({ apiKey, baseUrl = BASE_URL, debug = false, stream = true, botId }) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl || BASE_URL;
+        this.debug = debug;
+        this.stream = stream;
+        this.botId = botId;
+        this.history = [];
+    }
+    updateApiKey(apiKey) {
+        this.apiKey = apiKey;
+    }
+    async sendRequest({ method, endpoint, data, params, stream = false, headerParams = {}, timeoutMs = 100 * 1000 }) {
+        const headers = {
+            ...{
+                Authorization: `${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            ...headerParams,
+        };
+        const url = `${this.baseUrl}${endpoint}`;
+        let response;
+        if (this.debug) {
+            console.log('request', url, { data, headers, params });
+        }
+        if (!stream) {
+            response = await axios.request({
+                method,
+                url,
+                data: data || {},
+                params: params || {},
+                headers,
+                timeout: timeoutMs,
+            });
+        }
+        else {
+            response = await axios({
+                method,
+                url,
+                data,
+                params,
+                headers,
+                responseType: 'stream',
+            });
+        }
+        return response;
+    }
+}
+class QAnyApi extends QAnyClient {
+    async sendMessage(query, { needHistory, user, timeoutMs = 100 * 1000, variables, }) {
+        if (needHistory) {
+            this.history = this.history.slice(-2);
+        }
+        else {
+            this.history = [];
+        }
+        const data = {
+            uuid: this.botId,
+            question: query,
+            history: this.history
+        };
+        const res = await this.sendRequest({
+            method: routes.creatChat.method,
+            endpoint: routes.creatChat.url(),
+            data,
+            stream: this.stream,
+            timeoutMs,
+        });
+        const asyncSSE = stream => {
+            return new Promise((resolve, reject) => {
+                const answers = [];
+                let answer = '';
+                let id = '';
+                const chunks = [];
+                try {
+                    stream.on('data', data => {
+                        chunks.push(data);
+                    });
+                    stream.on('end', async () => {
+                        const result = Buffer.concat(chunks);
+                        console.log('思考完毕，准备回复');
+                        const streams = new TextDecoder('utf-8').decode(result, { stream: true }).split('\n');
+                        for (const stream of streams) {
+                            let res = {};
+                            try {
+                                res = JSON.parse(stream.substring(5)) || {};
+                            }
+                            catch (e) {
+                                // console.log('json 解析错误，不影响输出', stream)
+                                try {
+                                    res = JSON.parse(stream) || {};
+                                }
+                                catch (e) {
+                                    // console.log('json 解析错误，不影响输出', stream)
+                                }
+                            }
+                            if (res.errorCode && res.errorCode !== '0') {
+                                console.log('QAnything 请求报错', res.msg);
+                                answer = res.msg;
+                            }
+                            else if (res.errorCode) {
+                                if (res.result.response && !res.result.singleQAId) {
+                                    answers.push(res.result.response);
+                                }
+                                if (res.result.singleQAId) {
+                                    this.history = res.result.history;
+                                    id = res.result.singleQAId;
+                                    answer = res.result.response;
+                                }
+                            }
+                        }
+                        if (!answer) {
+                            answer = answers.join('');
+                        }
+                        resolve({ text: answer, conversationId: '', id: id });
+                    });
+                }
+                catch (e) {
+                    resolve({ text: `agent 出错，${e}`, conversationId: '', files: [] });
+                }
+            });
+        };
+        console.log('进入流式输出模式，请耐心等待模型的思考');
+        const result = await asyncSSE(res.data);
+        return result;
+    }
+}
+export { QAnyApi };
+//# sourceMappingURL=qanything.js.map

package/dist/botInstance/sdk/quick-lru.js

@@ -0,0 +1,237 @@
+export default class QuickLRU extends Map {
+    constructor(options = {}) {
+        super();
+        if (!(options.maxSize && options.maxSize > 0)) {
+            throw new TypeError('`maxSize` must be a number greater than 0');
+        }
+        if (typeof options.maxAge === 'number' && options.maxAge === 0) {
+            throw new TypeError('`maxAge` must be a number greater than 0');
+        }
+        // TODO: Use private class fields when ESLint supports them.
+        this.maxSize = options.maxSize;
+        this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+        this.onEviction = options.onEviction;
+        this.cache = new Map();
+        this.oldCache = new Map();
+        this._size = 0;
+    }
+    // TODO: Use private class methods when targeting Node.js 16.
+    _emitEvictions(cache) {
+        if (typeof this.onEviction !== 'function') {
+            return;
+        }
+        for (const [key, item] of cache) {
+            this.onEviction(key, item.value);
+        }
+    }
+    _deleteIfExpired(key, item) {
+        if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
+            if (typeof this.onEviction === 'function') {
+                this.onEviction(key, item.value);
+            }
+            return this.delete(key);
+        }
+        return false;
+    }
+    _getOrDeleteIfExpired(key, item) {
+        const deleted = this._deleteIfExpired(key, item);
+        if (deleted === false) {
+            return item.value;
+        }
+    }
+    _getItemValue(key, item) {
+        return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
+    }
+    _peek(key, cache) {
+        const item = cache.get(key);
+        return this._getItemValue(key, item);
+    }
+    _set(key, value) {
+        this.cache.set(key, value);
+        this._size++;
+        if (this._size >= this.maxSize) {
+            this._size = 0;
+            this._emitEvictions(this.oldCache);
+            this.oldCache = this.cache;
+            this.cache = new Map();
+        }
+    }
+    _moveToRecent(key, item) {
+        this.oldCache.delete(key);
+        this._set(key, item);
+    }
+    *_entriesAscending() {
+        for (const item of this.oldCache) {
+            const [key, value] = item;
+            if (!this.cache.has(key)) {
+                const deleted = this._deleteIfExpired(key, value);
+                if (deleted === false) {
+                    yield item;
+                }
+            }
+        }
+        for (const item of this.cache) {
+            const [key, value] = item;
+            const deleted = this._deleteIfExpired(key, value);
+            if (deleted === false) {
+                yield item;
+            }
+        }
+    }
+    get(key) {
+        if (this.cache.has(key)) {
+            const item = this.cache.get(key);
+            return this._getItemValue(key, item);
+        }
+        if (this.oldCache.has(key)) {
+            const item = this.oldCache.get(key);
+            if (this._deleteIfExpired(key, item) === false) {
+                this._moveToRecent(key, item);
+                return item.value;
+            }
+        }
+    }
+    set(key, value, { maxAge = this.maxAge } = {}) {
+        const expiry = typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY ?
+            Date.now() + maxAge :
+            undefined;
+        if (this.cache.has(key)) {
+            this.cache.set(key, {
+                value,
+                expiry
+            });
+        }
+        else {
+            this._set(key, { value, expiry });
+        }
+    }
+    has(key) {
+        if (this.cache.has(key)) {
+            return !this._deleteIfExpired(key, this.cache.get(key));
+        }
+        if (this.oldCache.has(key)) {
+            return !this._deleteIfExpired(key, this.oldCache.get(key));
+        }
+        return false;
+    }
+    peek(key) {
+        if (this.cache.has(key)) {
+            return this._peek(key, this.cache);
+        }
+        if (this.oldCache.has(key)) {
+            return this._peek(key, this.oldCache);
+        }
+    }
+    delete(key) {
+        const deleted = this.cache.delete(key);
+        if (deleted) {
+            this._size--;
+        }
+        return this.oldCache.delete(key) || deleted;
+    }
+    clear() {
+        this.cache.clear();
+        this.oldCache.clear();
+        this._size = 0;
+    }
+    resize(newSize) {
+        if (!(newSize && newSize > 0)) {
+            throw new TypeError('`maxSize` must be a number greater than 0');
+        }
+        const items = [...this._entriesAscending()];
+        const removeCount = items.length - newSize;
+        if (removeCount < 0) {
+            this.cache = new Map(items);
+            this.oldCache = new Map();
+            this._size = items.length;
+        }
+        else {
+            if (removeCount > 0) {
+                this._emitEvictions(items.slice(0, removeCount));
+            }
+            this.oldCache = new Map(items.slice(removeCount));
+            this.cache = new Map();
+            this._size = 0;
+        }
+        this.maxSize = newSize;
+    }
+    *keys() {
+        for (const [key] of this) {
+            yield key;
+        }
+    }
+    *values() {
+        for (const [, value] of this) {
+            yield value;
+        }
+    }
+    *[Symbol.iterator]() {
+        for (const item of this.cache) {
+            const [key, value] = item;
+            const deleted = this._deleteIfExpired(key, value);
+            if (deleted === false) {
+                yield [key, value.value];
+            }
+        }
+        for (const item of this.oldCache) {
+            const [key, value] = item;
+            if (!this.cache.has(key)) {
+                const deleted = this._deleteIfExpired(key, value);
+                if (deleted === false) {
+                    yield [key, value.value];
+                }
+            }
+        }
+    }
+    *entriesDescending() {
+        let items = [...this.cache];
+        for (let i = items.length - 1; i >= 0; --i) {
+            const item = items[i];
+            const [key, value] = item;
+            const deleted = this._deleteIfExpired(key, value);
+            if (deleted === false) {
+                yield [key, value.value];
+            }
+        }
+        items = [...this.oldCache];
+        for (let i = items.length - 1; i >= 0; --i) {
+            const item = items[i];
+            const [key, value] = item;
+            if (!this.cache.has(key)) {
+                const deleted = this._deleteIfExpired(key, value);
+                if (deleted === false) {
+                    yield [key, value.value];
+                }
+            }
+        }
+    }
+    *entriesAscending() {
+        for (const [key, value] of this._entriesAscending()) {
+            yield [key, value.value];
+        }
+    }
+    get size() {
+        if (!this._size) {
+            return this.oldCache.size;
+        }
+        let oldCacheSize = 0;
+        for (const key of this.oldCache.keys()) {
+            if (!this.cache.has(key)) {
+                oldCacheSize++;
+            }
+        }
+        return Math.min(this._size + oldCacheSize, this.maxSize);
+    }
+    entries() {
+        return this.entriesAscending();
+    }
+    forEach(callbackFunction, thisArgument = this) {
+        for (const [key, value] of this.entriesAscending()) {
+            callbackFunction.call(thisArgument, value, key, this);
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return JSON.stringify([...this.entriesAscending()]);
+    }
+}
+//# sourceMappingURL=quick-lru.js.map

package/dist/common/hook.js

@@ -0,0 +1,66 @@
+import { delay } from "../lib/index.js";
+/**
+ * 指定用户消息转发到群或好友 如果被拦截成功 则不进行其他回复操作
+ * @returns {Promise<boolean>}
+ */
+export async function privateForward({ that, msg, name, config }) {
+    const { role } = config?.userInfo || {};
+    const privateForwards = config.privateForwards;
+    if (role !== 'vip' || !privateForwards || !privateForwards.length || msg.text().includes('请在手机上查看]'))
+        return false;
+    let result = false;
+    try {
+        if (privateForwards.length) {
+            for (let item of privateForwards) {
+                if (item.name === name) {
+                    result = true;
+                    for (let roomName of item.rooms) {
+                        await delay(500);
+                        const room = await that.Room.find({ topic: roomName });
+                        if (!room) {
+                            console.log(`查找不到群：${roomName}，请检查群名是否正确`);
+                        }
+                        // 只转发文字
+                        if (item.type === 1 && msg.type() === 7) {
+                            room && msg && msg.forward(room);
+                        }
+                        else {
+                            if (msg.type() === 6) {
+                                const file = await msg.toFileBox();
+                                room.say(file);
+                            }
+                            else {
+                                room && msg && msg.forward(room);
+                            }
+                        }
+                    }
+                    for (let contactName of item.contacts) {
+                        await delay(500);
+                        const contact = await that.Contact.find({ name: contactName });
+                        if (!contact) {
+                            console.log(`查找不到用户：${contactName}，请检查用户昵称是否正确`);
+                        }
+                        // 只转发文字
+                        if (item.type === 1 && msg.type() === 7) {
+                            contact && msg && msg.forward(contact);
+                        }
+                        else {
+                            if (msg.type() === 6) {
+                                const file = await msg.toFileBox();
+                                contact.say(file);
+                            }
+                            else {
+                                contact && msg && msg.forward(contact);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    catch (e) {
+        console.log("error", e);
+    }
+}
+//# sourceMappingURL=hook.js.map