koishi-plugin-chatluna 1.0.0-beta.20

package/lib/chains/chain.js

@@ -0,0 +1,465 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainMiddlewareRunStatus = exports.ChainMiddleware = exports.ChatChain = void 0;
+const koishi_1 = require("koishi");
+const logger_1 = require("../utils/logger");
+const lifecycle_1 = require("../middlewares/lifecycle");
+const events_1 = require("events");
+const error_1 = require("../utils/error");
+let logger;
+/**
+ * ChatChain为消息的发送和接收提供了一个统一的中间提供交互
+ */
+class ChatChain {
+    ctx;
+    config;
+    _graph;
+    _senders;
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        logger = (0, logger_1.createLogger)(ctx);
+        this._graph = new ChatChainDependencyGraph();
+        this._senders = [];
+        console.log(ctx.runtime.inject);
+        const defaultChatChainSender = new DefaultChatChainSender(config);
+        this._senders.push((session, messages) => defaultChatChainSender.send(session, messages));
+    }
+    async receiveMessage(session, ctx) {
+        const context = {
+            config: this.config,
+            message: session.content,
+            ctx: ctx ?? this.ctx,
+            session,
+            options: {},
+            send: (message) => this.sendMessage(session, message),
+            recallThinkingMessage: async () => { }
+        };
+        context.recallThinkingMessage = async () => {
+            if (context.options?.thinkingTimeoutObject) {
+                clearTimeout(context.options.thinkingTimeoutObject.timeout);
+                if (context.options.thinkingTimeoutObject.autoRecallTimeout) {
+                    clearTimeout(context.options.thinkingTimeoutObject.autoRecallTimeout);
+                }
+                if (context.options.thinkingTimeoutObject.recallFunc) {
+                    await context.options.thinkingTimeoutObject.recallFunc();
+                }
+                if (context.options?.thinkingTimeoutObject?.timeout) {
+                    context.options.thinkingTimeoutObject.timeout = null;
+                }
+                context.options.thinkingTimeoutObject = undefined;
+            }
+        };
+        const result = await this._runMiddleware(session, context);
+        await context.recallThinkingMessage();
+        return result;
+    }
+    async receiveCommand(session, command, options = {}) {
+        const context = {
+            config: this.config,
+            message: options?.message ?? session.content,
+            ctx: this.ctx,
+            session,
+            command,
+            send: (message) => this.sendMessage(session, message),
+            recallThinkingMessage: async () => { },
+            options
+        };
+        context.recallThinkingMessage = async () => {
+            if (context.options.thinkingTimeoutObject) {
+                clearTimeout(context.options.thinkingTimeoutObject.timeout);
+                if (context.options.thinkingTimeoutObject.recallFunc) {
+                    await context.options.thinkingTimeoutObject.recallFunc();
+                }
+                if (context.options?.thinkingTimeoutObject?.timeout) {
+                    context.options.thinkingTimeoutObject.timeout = null;
+                }
+                context.options.thinkingTimeoutObject = undefined;
+            }
+        };
+        const result = await this._runMiddleware(session, context);
+        await context.recallThinkingMessage();
+        return result;
+    }
+    middleware(name, middleware, ctx = this.ctx) {
+        const result = new ChainMiddleware(name, middleware, this._graph);
+        this._graph.addNode(result);
+        ctx.on('dispose', () => {
+            this._graph.removeNode(name);
+        });
+        return result;
+    }
+    sender(sender) {
+        this._senders.push(sender);
+    }
+    async _runMiddleware(session, context) {
+        // 手动 polyfill，呃呃呃呃呃
+        if (session.isDirect == null) {
+            session.isDirect = session.subtype === 'private';
+        }
+        const originMessage = context.message;
+        const runList = this._graph.build();
+        if (runList.length === 0) {
+            return false;
+        }
+        let isOutputLog = false;
+        for (const middleware of runList) {
+            let result;
+            let executedTime = Date.now();
+            try {
+                result = await middleware.run(session, context);
+                executedTime = Date.now() - executedTime;
+            }
+            catch (error) {
+                if (error instanceof error_1.ChatLunaError) {
+                    await this.sendMessage(session, error.message);
+                    return false;
+                }
+                logger.error(`chat-chain: ${middleware.name} error ${error}`);
+                logger.error(error);
+                if (error.cause) {
+                    logger.error(error.cause);
+                }
+                logger.debug('-'.repeat(20) + '\n');
+                await this.sendMessage(session, `执行 ${middleware.name} 时出现错误: ${error.message}`);
+                return false;
+            }
+            if (!middleware.name.startsWith('lifecycle-') &&
+                ChainMiddlewareRunStatus.SKIPPED !== result &&
+                middleware.name !== 'allow_reply' &&
+                executedTime > 10) {
+                logger.debug(`middleware %c executed in %d ms`, middleware.name, executedTime);
+                isOutputLog = true;
+            }
+            if (result === ChainMiddlewareRunStatus.STOP) {
+                // 中间件说这里不要继续执行了
+                if (context.message != null &&
+                    context.message !== originMessage) {
+                    // 消息被修改了
+                    await this.sendMessage(session, context.message);
+                }
+                if (isOutputLog) {
+                    logger.debug('-'.repeat(20) + '\n');
+                }
+                return false;
+            }
+            else if (result instanceof Array || typeof result === 'string') {
+                context.message = result;
+            }
+        }
+        if (isOutputLog) {
+            logger.debug('-'.repeat(20) + '\n');
+        }
+        if (context.message != null && context.message !== originMessage) {
+            // 消息被修改了
+            await this.sendMessage(session, context.message);
+        }
+        return true;
+    }
+    async sendMessage(session, message) {
+        // check if message is a two-dimensional array
+        const messages = message instanceof Array ? message : [message];
+        for (const sender of this._senders) {
+            await sender(session, messages);
+        }
+    }
+}
+exports.ChatChain = ChatChain;
+// 定义一个有向无环图类，包含节点集合和邻接表
+class ChatChainDependencyGraph {
+    _tasks = [];
+    _dependencies = new Map();
+    _eventEmitter = new events_1.EventEmitter();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _listeners = new Map();
+    constructor() {
+        this._eventEmitter.on('build_node', () => {
+            for (const [name, listeners] of this._listeners.entries()) {
+                for (const listener of listeners) {
+                    listener(name);
+                }
+                listeners.length = 0;
+            }
+        });
+    }
+    // Add a task to the DAG.
+    addNode(middleware) {
+        this._tasks.push({
+            name: middleware.name,
+            middleware
+        });
+    }
+    removeNode(name) {
+        const index = this._tasks.findIndex((task) => task.name === name);
+        if (index !== -1) {
+            this._tasks.splice(index, 1);
+        }
+        // remove dependencies
+        for (const [, dependencies] of this._dependencies.entries()) {
+            if (dependencies.has(name)) {
+                dependencies.delete(name);
+            }
+        }
+        if (this._dependencies[name]) {
+            delete this._dependencies[name];
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    once(name, listener) {
+        if (this._listeners.has(name)) {
+            this._listeners.get(name).push(listener);
+        }
+        else {
+            this._listeners.set(name, [listener]);
+        }
+    }
+    // Set a dependency between two tasks
+    before(taskA, taskB) {
+        if (taskA instanceof ChainMiddleware) {
+            taskA = taskA.name;
+        }
+        if (taskB instanceof ChainMiddleware) {
+            taskB = taskB.name;
+        }
+        if (taskA && taskB) {
+            // Add taskB to the dependencies of taskA
+            const dependencies = this._dependencies.get(taskA) ?? new Set();
+            dependencies.add(taskB);
+            this._dependencies.set(taskA, dependencies);
+        }
+        else {
+            throw new Error('Invalid tasks');
+        }
+    }
+    // Set a reverse dependency between two tasks
+    after(taskA, taskB) {
+        if (taskA instanceof ChainMiddleware) {
+            taskA = taskA.name;
+        }
+        if (taskB instanceof ChainMiddleware) {
+            taskB = taskB.name;
+        }
+        if (taskA && taskB) {
+            // Add taskB to the dependencies of taskA
+            const dependencies = this._dependencies.get(taskB) ?? new Set();
+            dependencies.add(taskA);
+            this._dependencies.set(taskB, dependencies);
+        }
+        else {
+            throw new Error('Invalid tasks');
+        }
+    }
+    // Get dependencies of a task
+    getDependencies(task) {
+        return this._dependencies.get(task);
+    }
+    // Get dependents of a task
+    getDependents(task) {
+        const dependents = [];
+        for (const [key, value] of this._dependencies.entries()) {
+            if ([...value].includes(task)) {
+                dependents.push(key);
+            }
+        }
+        return dependents;
+    }
+    // Build a two-dimensional array of tasks based on their dependencies
+    build() {
+        this._eventEmitter.emit('build_node');
+        // Create an array to store the result
+        const result = [];
+        // Create a map to store the indegree of each task
+        const indegree = new Map();
+        // Initialize the indegree map with zero for each task
+        for (const task of this._tasks) {
+            indegree.set(task.name, 0);
+        }
+        // Iterate over the tasks and increment the indegree of their dependencies
+        for (const [, dependencies] of this._dependencies.entries()) {
+            for (const dependency of dependencies) {
+                indegree.set(dependency, indegree.get(dependency) + 1);
+            }
+        }
+        // Create a queue to store the tasks with zero indegree
+        const queue = [];
+        // Enqueue the tasks with zero indegree
+        for (const [task, degree] of indegree.entries()) {
+            if (degree === 0) {
+                queue.push(task);
+            }
+        }
+        // While the queue is not empty
+        while (queue.length > 0) {
+            // Create an array to store the current level of tasks
+            // Dequeue all the tasks in the queue and add them to the level
+            while (queue.length > 0) {
+                const task = queue.shift();
+                result.push(this._tasks.find((t) => t.name === task).middleware);
+                // For each dependency of the dequeued task
+                for (const dep of this._dependencies.get(task) ?? []) {
+                    // Decrement its indegree by one
+                    indegree.set(dep, indegree.get(dep) - 1);
+                    // If its indegree becomes zero, enqueue it to the queue
+                    if (indegree.get(dep) === 0) {
+                        queue.push(dep);
+                    }
+                }
+            }
+        }
+        // Return the result
+        return result;
+    }
+}
+class ChainMiddleware {
+    name;
+    execute;
+    graph;
+    constructor(name, execute, graph) {
+        this.name = name;
+        this.execute = execute;
+        this.graph = graph;
+    }
+    before(name) {
+        this.graph.before(this.name, name);
+        if (this.name.startsWith('lifecycle-')) {
+            return this;
+        }
+        const lifecycleName = lifecycle_1.lifecycleNames;
+        // 现在我们需要基于当前添加的依赖，去寻找这个依赖锚定的生命周期
+        // 如果当前添加的依赖是生命周期，那么我们需要找到这个生命周期的下一个生命周期
+        if (lifecycleName.includes(name)) {
+            const lastLifecycleName = lifecycleName[lifecycleName.indexOf(name) - 1];
+            if (lastLifecycleName) {
+                this.graph.after(this.name, lastLifecycleName);
+            }
+            return this;
+        }
+        // 如果不是的话，我们就需要寻找依赖锚定的生命周期
+        this.graph.once('build_node', () => {
+            const beforeMiddlewares = [
+                ...this.graph.getDependencies(name)
+            ].filter((name) => name.startsWith('lifecycle-'));
+            const afterMiddlewares = this.graph
+                .getDependents(name)
+                .filter((name) => name.startsWith('lifecycle-'));
+            for (const before of beforeMiddlewares) {
+                this.graph.before(this.name, before);
+            }
+            for (const after of afterMiddlewares) {
+                this.graph.after(this.name, after);
+            }
+        });
+        return this;
+    }
+    after(name) {
+        this.graph.after(this.name, name);
+        if (this.name.startsWith('lifecycle-')) {
+            return this;
+        }
+        const lifecycleName = lifecycle_1.lifecycleNames;
+        // 现在我们需要基于当前添加的依赖，去寻找这个依赖锚定的生命周期
+        // 如果当前添加的依赖是生命周期，那么我们需要找到这个生命周期的下一个生命周期
+        if (lifecycleName.includes(name)) {
+            const nextLifecycleName = lifecycleName[lifecycleName.indexOf(name) + 1];
+            if (nextLifecycleName) {
+                this.graph.before(this.name, nextLifecycleName);
+            }
+            return this;
+        }
+        // 如果不是的话，我们就需要寻找依赖锚定的生命周期
+        this.graph.once('build_node', () => {
+            const beforeMiddlewares = [
+                ...this.graph.getDependencies(name)
+            ].filter((name) => name.startsWith('lifecycle-'));
+            const afterMiddlewares = this.graph
+                .getDependents(name)
+                .filter((name) => name.startsWith('lifecycle-'));
+            for (const before of beforeMiddlewares) {
+                this.graph.before(this.name, before);
+            }
+            for (const after of afterMiddlewares) {
+                this.graph.after(this.name, after);
+            }
+        });
+        return this;
+    }
+    run(session, options) {
+        return this.execute(session, options);
+    }
+}
+exports.ChainMiddleware = ChainMiddleware;
+class DefaultChatChainSender {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async send(session, messages) {
+        if (this.config.isForwardMsg) {
+            const sendMessages = [];
+            if (messages[0] instanceof Array) {
+                // h[][]
+                for (const message of messages) {
+                    sendMessages.push((0, koishi_1.h)('message', ...message));
+                }
+            }
+            else if (messages[0] instanceof Object) {
+                // h | h[]
+                sendMessages.push((0, koishi_1.h)('message', ...messages));
+            }
+            else if (typeof messages[0] === 'string') {
+                // string
+                sendMessages.push(koishi_1.h.text(messages[0]));
+            }
+            else {
+                throw new Error(`unknown message type: ${typeof messages[0]}`);
+            }
+            await session.sendQueued((0, koishi_1.h)('message', {
+                forward: true
+            }, ...sendMessages));
+        }
+        else {
+            for (const message of messages) {
+                let messageFragment;
+                if (this.config.isReplyWithAt && session.isDirect === false) {
+                    messageFragment = [(0, koishi_1.h)('quote', { id: session.messageId })];
+                    if (message instanceof Array) {
+                        messageFragment = messageFragment.concat(message);
+                    }
+                    else if (typeof message === 'string') {
+                        messageFragment.push(koishi_1.h.text(message));
+                    }
+                    else {
+                        messageFragment.push(message);
+                    }
+                    for (const element of messageFragment) {
+                        // 语音,消息 不能引用
+                        if (element.type === 'audio' ||
+                            element.type === 'message') {
+                            messageFragment.shift();
+                            break;
+                        }
+                    }
+                }
+                else {
+                    if (message instanceof Array) {
+                        messageFragment = message;
+                    }
+                    else if (typeof message === 'string') {
+                        messageFragment = [koishi_1.h.text(message)];
+                    }
+                    else {
+                        // 你就说是不是 element 吧
+                        messageFragment = [message];
+                    }
+                }
+                await session.sendQueued(messageFragment);
+            }
+        }
+    }
+}
+var ChainMiddlewareRunStatus;
+(function (ChainMiddlewareRunStatus) {
+    ChainMiddlewareRunStatus[ChainMiddlewareRunStatus["SKIPPED"] = 0] = "SKIPPED";
+    ChainMiddlewareRunStatus[ChainMiddlewareRunStatus["STOP"] = 1] = "STOP";
+    ChainMiddlewareRunStatus[ChainMiddlewareRunStatus["CONTINUE"] = 2] = "CONTINUE";
+})(ChainMiddlewareRunStatus || (exports.ChainMiddlewareRunStatus = ChainMiddlewareRunStatus = {}));

package/lib/chains/rooms.d.ts

@@ -0,0 +1,24 @@
+import { Context, Session } from 'koishi';
+import { ConversationRoom } from '../types';
+import { Config } from '../config';
+export declare function queryJoinedConversationRoom(ctx: Context, session: Session, name?: string): Promise<ConversationRoom>;
+export declare function queryPublicConversationRoom(ctx: Context, session: Session): Promise<ConversationRoom>;
+export declare function checkConversationRoomAvailability(ctx: Context, room: ConversationRoom): Promise<boolean>;
+export declare function fixConversationRoomAvailability(ctx: Context, config: Config, room: ConversationRoom): Promise<void>;
+export declare function getTemplateConversationRoom(ctx: Context, config: Config): Promise<ConversationRoom>;
+export declare function getConversationRoomCount(ctx: Context): Promise<number>;
+export declare function transferConversationRoom(ctx: Context, session: Session, room: ConversationRoom, userId: string): Promise<void>;
+export declare function switchConversationRoom(ctx: Context, session: Session, id: string | number): Promise<ConversationRoom>;
+export declare function getAllJoinedConversationRoom(ctx: Context, session: Session, queryAll?: boolean): Promise<ConversationRoom[]>;
+export declare function leaveConversationRoom(ctx: Context, session: Session, room: ConversationRoom): Promise<void>;
+export declare function queryConversationRoom(ctx: Context, session: Session, name: string): Promise<ConversationRoom>;
+export declare function resolveConversationRoom(ctx: Context, roomId: number): Promise<ConversationRoom>;
+export declare function deleteConversationRoom(ctx: Context, session: Session, room: ConversationRoom): Promise<void>;
+export declare function joinConversationRoom(ctx: Context, session: Session, roomId: number | ConversationRoom, isDirect?: boolean, userId?: string): Promise<void>;
+export declare function getConversationRoomUser(ctx: Context, session: Session, roomId: number | ConversationRoom, userId?: string): Promise<Pick<import("../types").ConversationRoomMemberInfo, import("koishi").Keys<import("../types").ConversationRoomMemberInfo, any>>>;
+export declare function setUserPermission(ctx: Context, session: Session, roomId: number | ConversationRoom, permission: 'member' | 'admin', userId?: string): Promise<void>;
+export declare function addConversationRoomToGroup(ctx: Context, session: Session, roomId: number | ConversationRoom, groupId?: string): Promise<void>;
+export declare function muteUserFromConversationRoom(ctx: Context, session: Session, roomId: number | ConversationRoom, userId: string): Promise<void>;
+export declare function kickUserFromConversationRoom(ctx: Context, session: Session, roomId: number | ConversationRoom, userId: string): Promise<void>;
+export declare function checkAdmin(session: Session): Promise<number>;
+export declare function createConversationRoom(ctx: Context, session: Session, room: ConversationRoom): Promise<void>;