alemonjs-aichat 1.0.28 → 1.0.30-beta.0

package/lib/api/aitools.js

@@ -5,6 +5,11 @@ import { uploadImageToR2 } from '../s3.js';
 import { TTSClient } from './tts.js';
 import { loadSkillDetail } from './loadSkill.js';
 import help from '../data/help.json.js';
+import redisClient from '../config.js';
+import { isPrivateIP, validateURL } from './security.js';
+import { spawn } from 'child_process';
+import * as dns from 'node:dns/promises';
+import { getWorkspace } from './workspace.js';
 
 const value = getConfigValue().aiChat || {};
 const getPrompt = async (text) => {
@@ -167,6 +172,10 @@ const tools = [
             parameters: {
                 type: "object",
                 properties: {
+                    userId: {
+                        type: "string",
+                        description: "执行命令的用户ID",
+                    },
                     command: {
                         type: "string",
                         description: "要执行的终端命令",
@@ -193,36 +202,151 @@ const tools = [
             },
         },
     },
+    // {
+    //   type: "function",
+    //   function: {
+    //     name: "EvalCode",
+    //     description: "执行JavaScript代码",
+    //     parameters: {
+    //       type: "object",
+    //       properties: {
+    //         code: {
+    //           type: "string",
+    //           description: "要执行的JavaScript代码",
+    //         },
+    //       },
+    //       required: ["code"],
+    //     },
+    //   },
+    // },
+    {
+        type: "function",
+        function: {
+            name: "GetCommand",
+            description: "获取当前框架可用的指令, 查看当前框架每个命令的使用方法和说明. 当用户需要获取指令列表时, 可以调用这个工具来获取当前框架可用的指令列表. 例如, 当用户输入'帮助'或'指令列表'等类似的关键词时, 你可以调用这个工具来获取指令列表并回复给用户. 指令列表会包含每个指令的文本和说明, 例如: [{ command: '帮助', description: '获取帮助信息' }, { command: '看看配置', description: '查看当前AI配置' }]",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+        },
+    },
     {
         type: "function",
         function: {
-            name: "EvalCode",
-            description: "执行JavaScript代码",
+            name: "MemoryOperation",
+            description: "这个工具用于获取或修改对于用户的记忆数据, 包括用户形象, 用户偏好, 历史对话等. 你可以使用这个工具来存储一些需要长期记忆的信息, 例如用户的兴趣爱好, 重要事件等. 当你想要获取或修改这些信息时, 可以调用这个工具并提供具体的操作指令和数据. 例如, 在聊天过程中他对你的态度,以及他喜欢的东西等,可以通过这个工具及时记录下来, 也可以通过这个工具获取之前的对话记录,便于继续之前的话题",
             parameters: {
                 type: "object",
                 properties: {
-                    code: {
+                    userID: {
+                        type: "string",
+                        description: "要获取或修改的用户数据的用户ID",
+                    },
+                    operation: {
+                        type: "string",
+                        description: "要执行的操作类型，例如'get'表示获取数据，'set'表示修改数据",
+                        enum: ["get", "set"],
+                    },
+                    dataType: {
                         type: "string",
-                        description: "要执行的JavaScript代码",
+                        description: "要获取或修改的数据类型，例如'user'表示用户相关,获取或修改用户数据，'chatHistory'表示历史对话,历史对话只能获取不能修改",
+                        enum: ["user", "chatHistory"],
+                    },
+                    data: {
+                        type: "string",
+                        description: "要获取或修改的数据内容, 例如当operation为'set'时,dataType为'user'时, data应该是要存储的数据内容, 例如用户喜欢的颜色是蓝色, 则data可以是'favoriteColor:blue', 当operation为'get'时, dataType为'user'时, data就不需要传入值, 它会返回之前存储的数据, 当operation为'get'时, dataType为'chatHistory'时, data不传入值获取摘要列表, 传入id获取对应的摘要详情",
                     },
                 },
-                required: ["code"],
             },
         },
     },
     {
         type: "function",
         function: {
-            name: "GetCommand",
-            description: "获取当前框架可用的指令, 查看当前框架每个命令的使用方法和说明. 当用户需要获取指令列表时, 可以调用这个工具来获取当前框架可用的指令列表. 例如, 当用户输入'帮助'或'指令列表'等类似的关键词时, 你可以调用这个工具来获取指令列表并回复给用户. 指令列表会包含每个指令的文本和说明, 例如: [{ command: '帮助', description: '获取帮助信息' }, { command: '看看配置', description: '查看当前AI配置' }]",
+            name: "ping",
+            description: `
+检测目标主机是否可达。
+
+【限制】
+- 仅允许公网域名
+- 禁止 IP 地址（防止内网扫描）
+- 自动限制次数（例如 3 次）
+
+`,
             parameters: {
                 type: "object",
-                properties: {},
+                properties: {
+                    host: { type: "string" },
+                },
+                required: ["host"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "http_request",
+            description: `
+发送 HTTP 请求以获取网页或 API 数据。
+
+【能力范围】
+- 支持 GET / POST 请求
+- 返回文本或 JSON 内容
+- 自动处理常见编码
+
+【限制】
+- 禁止访问云元数据地址（如 169.254.169.254）
+- 请求超时限制为 5 秒
+- 响应大小限制（例如 1MB）
+
+【使用建议】
+- 优先使用此工具获取网页内容，而不是使用 shell
+- 适合抓取网页、调用 API、获取数据
+`,
+            parameters: {
+                type: "object",
+                properties: {
+                    url: { type: "string" },
+                    method: { type: "string", enum: ["GET", "POST"] },
+                    body: { type: "string" },
+                },
+                required: ["url"],
             },
         },
     },
 ];
 const availableTools = {
+    MemoryOperation: async ({ userID, operation, dataType, data }) => {
+        if (operation === "set") {
+            if (dataType === "user") {
+                // 存储用户数据到redis, key为user:${userID}:data, value为data
+                await redisClient.setUserData(userID, data);
+                return { success: true };
+            }
+            if (dataType === "chatHistory") {
+                return "历史对话数据只能获取不能修改";
+            }
+        }
+        if (operation === "get") {
+            if (dataType === "user") {
+                // 从redis获取用户数据, key为user:${userID}:data
+                const userData = await redisClient.getUserData(userID);
+                return { success: true, data: userData };
+            }
+            if (dataType === "chatHistory") {
+                // 从redis获取聊天历史, key为chatHistory:${userID}
+                const [guid, id] = data?.split(":") || [];
+                if (guid && id) {
+                    const chatHistory = await redisClient.getSummaryDetail(guid, id);
+                    return { success: true, data: chatHistory };
+                }
+                else {
+                    const summaryList = await redisClient.getSummaryList();
+                    return { success: true, data: summaryList };
+                }
+            }
+        }
+    },
     /**
      *  使用 Stable Diffusion 生成图片
      * @param {string} prompt - 正向提示词
@@ -574,88 +698,55 @@ const availableTools = {
         const models = await ttsClient.getModels("v4");
         return models;
     },
-    /**
-     * 获取 ollama 模型列表
-     * @returns ollama 模型列表
-     */
-    OllamaListModels: async () => {
-        const res = await fetch("http://localhost:11434/v1/models");
-        if (!res.ok) {
-            return null;
-        }
-        const data = await res.json();
-        return data.data;
-    },
-    /**
-     * 安装 ollama 模型
-     * @param modelName 模型名称
-     * @returns 安装结果
-     */
-    OllamaInstallModel: async (modelName) => {
-        try {
-            const res = await fetch("http://localhost:11434/v1/models", {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    model: modelName,
-                }),
-            });
-            if (!res.ok) {
-                const err = await res.text();
-                console.log(err);
-                return { success: false, error: err };
-            }
-            const data = await res.json();
-            console.log("安装结果", data);
-            return { success: true };
-        }
-        catch (error) {
-            console.error("Error installing Ollama model:", error);
-            return { success: false, error: error };
-        }
-    },
     /**
      * 运行cmd命令
      * @param exec 命令字符串
      * @returns 命令执行结果
      */
-    exec: async ({ command }) => {
-        const { exec } = await import('child_process');
+    exec: async ({ userId, command }) => {
+        const workspace = getWorkspace(userId);
         return new Promise((resolve) => {
-            exec(command, (error, stdout, stderr) => {
-                if (error) {
-                    console.error(`Error executing command: ${error}`);
-                    resolve(`Error: ${error.message}`);
-                    return;
-                }
-                if (stderr) {
-                    console.error(`Command stderr: ${stderr}`);
-                    resolve(`Error: ${stderr}`);
-                    return;
-                }
-                console.log(`Command stdout: ${stdout}`);
-                resolve(stdout);
-            });
+            const child = spawn("docker", [
+                "run",
+                "--rm",
+                "--memory=256m",
+                "--cpus=0.5",
+                "--pids-limit=64",
+                "--network=none",
+                "--read-only",
+                "-v",
+                `${workspace}:/workspace`,
+                "-w",
+                "/workspace",
+                "alpine",
+                "sh",
+                "-c",
+                command,
+            ]);
+            let output = "";
+            child.stdout.on("data", (d) => (output += d.toString()));
+            child.stderr.on("data", (d) => (output += d.toString()));
+            child.on("close", () => resolve(output));
         });
     },
-    /**
-     * 执行eval
-     * @param code 代码字符串
-     * @returns 执行结果
-     */
-    EvalCode: async ({ code }) => {
-        try {
-            // eslint-disable-next-line no-eval
-            const result = eval(code);
-            return result;
-        }
-        catch (error) {
-            console.error(`Error executing code: ${error}`);
-            return `Error: ${error}`;
-        }
-    },
+    // /**
+    //  * 执行eval
+    //  * @param code 代码字符串
+    //  * @returns 执行结果
+    //  */
+    // EvalCode: async ({ code }) => {
+    //   try {
+    //     if (code.includes("exec") || code.includes("process")) {
+    //       return "代码中包含敏感词,无法执行";
+    //     }
+    //     // eslint-disable-next-line no-eval
+    //     const result = eval(code);
+    //     return result;
+    //   } catch (error) {
+    //     console.error(`Error executing code: ${error}`);
+    //     return `Error: ${error}`;
+    //   }
+    // },
     /**
      * 获取技能详情
      * @param skillName 技能名称
@@ -673,6 +764,51 @@ const availableTools = {
     GetCommand: async () => {
         return help;
     },
+    http_request: async ({ url, method = "GET", body, }) => {
+        await validateURL(url);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        try {
+            const res = await fetch(url, {
+                method,
+                body,
+                signal: controller.signal,
+                headers: {
+                    "User-Agent": "AI-Agent/1.0",
+                },
+            });
+            const text = await res.text();
+            if (text.length > 1024 * 1024) {
+                return "Response too large";
+            }
+            return text;
+        }
+        catch (e) {
+            return `Request failed: ${e.message}`;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    },
+    ping: async ({ host }) => {
+        // 禁止直接 IP
+        if (/^\d+\.\d+\.\d+\.\d+$/.test(host)) {
+            return "IP address not allowed";
+        }
+        const ips = await dns.lookup(host, { all: true });
+        for (const { address } of ips) {
+            if (isPrivateIP(address)) {
+                return "Target resolves to private IP";
+            }
+        }
+        return new Promise((resolve) => {
+            const child = spawn("ping", ["-c", "3", host]);
+            let output = "";
+            child.stdout.on("data", (d) => (output += d.toString()));
+            child.stderr.on("data", (d) => (output += d.toString()));
+            child.on("close", () => resolve(output));
+        });
+    },
 };
 
 export { availableTools, tools };

package/lib/api/security.js

@@ -0,0 +1,33 @@
+import dns from 'dns/promises';
+
+// security.ts
+const BLOCKED_IP_RANGES = [
+    /^127\./,
+    /^10\./,
+    /^192\.168\./,
+    /^172\.(1[6-9]|2\d|3[0-1])\./,
+    /^169\.254\./,
+];
+function isPrivateIP(ip) {
+    return BLOCKED_IP_RANGES.some((r) => r.test(ip));
+}
+async function validateURL(url) {
+    try {
+        const u = new URL(url);
+        if (!["http:", "https:"].includes(u.protocol)) {
+            throw new Error("Only http/https allowed");
+        }
+        const ips = await dns.lookup(u.hostname, { all: true });
+        for (const { address } of ips) {
+            if (isPrivateIP(address)) {
+                throw new Error("Access to private network is forbidden");
+            }
+        }
+        return true;
+    }
+    catch (e) {
+        throw new Error(`Invalid URL: ${e.message}`);
+    }
+}
+
+export { isPrivateIP, validateURL };

package/lib/api/workspace.js

@@ -0,0 +1,13 @@
+import fs from 'fs';
+import path from 'path';
+
+const BASE = "./public/sandbox/workspaces";
+function getWorkspace(userId) {
+    const dir = path.join(BASE, userId);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+
+export { getWorkspace };

package/lib/config.js

@@ -256,6 +256,67 @@ class db {
         }
         await this.setAIChatHistory(guid, history);
     }
+    /** 存储摘要,全局共享 */
+    async setSummary(guid, id, summary) {
+        await this.redis.set(`ai:summary:${guid}:${id}`, `${summary}`);
+    }
+    /** 获取摘要 */
+    async getSummary(guid, id) {
+        return await this.redis.get(`ai:summary:${guid}:${id}`);
+    }
+    /** 获取所有摘要时间列表 */
+    async getSummaryList() {
+        console.log("获取列表");
+        const keys = await this.redis.keys(`ai:summary:*`);
+        return Promise.all(keys.map(async (key) => {
+            const parts = key.split(":");
+            const summary = await this.redis.get(key);
+            return {
+                id: `${parts[2]}:${parts[3]}`,
+                summary: summary ?? "",
+            };
+        }));
+    }
+    /** 删除摘要 */
+    async deleteSummary(guid, id) {
+        return await this.redis.del(`ai:summary:${guid}:${id}`);
+    }
+    /** 存储摘要中的详细内容 */
+    async setSummaryDetail(guid, id, detail) {
+        await this.redis.set(`ai:summary_detail:${guid}:${id}`, `${detail}`);
+    }
+    /** 获取摘要中的详细内容 */
+    async getSummaryDetail(guid, id) {
+        return await this.redis.get(`ai:summary_detail:${guid}:${id}`);
+    }
+    /** 删除摘要中的详细内容 */
+    async deleteSummaryDetail(guid, id) {
+        return await this.redis.del(`ai:summary_detail:${guid}:${id}`);
+    }
+    /** 存储用户数据 */
+    async setUserData(userKey, value) {
+        await this.redis.set(`ai:user:${userKey}`, value);
+    }
+    /** 获取用户数据 */
+    async getUserData(userKey) {
+        return await this.redis.get(`ai:user:${userKey}`);
+    }
+    /** 删除用户数据 */
+    async deleteUserData(userKey) {
+        return await this.redis.del(`ai:user:${userKey}`);
+    }
+    /** 设置会话id */
+    async setSessionId(guid, sessionId) {
+        await this.redis.set(`ai:session:${guid}`, sessionId);
+    }
+    /** 获取会话id */
+    async getSessionId(guid) {
+        return await this.redis.get(`ai:session:${guid}`);
+    }
+    /** 删除会话id */
+    async deleteSessionId(guid) {
+        return await this.redis.del(`ai:session:${guid}`);
+    }
     /** 获取好感度 */
     async getAffectionLevel(guid, userKey) {
         const levelStr = await this.redis.get(`ai:affection:${guid}:${userKey}`);

package/lib/data/help.json.js

@@ -1,7 +1,7 @@
 var title = "IA聊天插件";
 var desc = "一个基于AI的聊天插件，支持多种AI模型和丰富的功能配置，适用于各种聊天场景。";
 var name = "alemonjs-aichat";
-var version = "v1.0.28";
+var version = "v1.0.29";
 var by = "AlemonJS";
 var list = [
 	{

package/lib/middleware/mw.js

@@ -2,6 +2,7 @@ import { getConfigValue, useClient } from 'alemonjs';
 import { API } from '@alemonjs/onebot';
 import redisClient from '../config.js';
 import { CApiReply } from '../response/zreply/capi.js';
+import { RApiReply } from '../response/zreply/rapi.js';
 
 const selects = onSelects(["message.create", "private.message.create"]);
 // 中间件
@@ -268,15 +269,21 @@ var mw = onMiddleware(selects, async (event, next) => {
         // 执行ai回复, 方便ai控制后续指令
         const aiconfig = await redisClient.getAIConfig(event.guid);
         if (aiconfig && aiconfig.model && aiconfig.key) {
-            const ReplyRes = await CApiReply(event);
-            console.log("res", ReplyRes);
-            if (ReplyRes) {
-                event["Xianyu"] = ReplyRes.next; // 根据AI回复决定是否继续执行后续的处理函数
-                if (ReplyRes.commands && ReplyRes.commands.length > 0) {
-                    event.MessageText = ReplyRes.commands[0];
-                    event["msg"] = ReplyRes.commands[0];
-                }
+            if (aiconfig.rapi) {
+                await RApiReply(event);
+            }
+            else {
+                await CApiReply(event);
             }
+            // const ReplyRes = await RApiReply(event);
+            // console.log("res", ReplyRes);
+            // if (ReplyRes) {
+            //   event["Xianyu"] = ReplyRes.next; // 根据AI回复决定是否继续执行后续的处理函数
+            //   // if (ReplyRes.commands && ReplyRes.commands.length > 0) {
+            //   //   event.MessageText = ReplyRes.commands[0];
+            //   //   event["msg"] = ReplyRes.commands[0];
+            //   // }
+            // }
         }
     }
     next();

package/lib/redis.js

@@ -6,6 +6,7 @@ const redisConfig = {
     host: value.redis?.host ?? "localhost",
     port: value.redis?.port ?? 6379,
     password: value.redis?.password ?? "",
+    username: value.redis?.user ?? "",
 };
 const redis = new Redis(redisConfig);
 

package/lib/response/config/res.js

@@ -2,10 +2,9 @@ import redisClient from '../../config.js';
 import App from '../../image/conponent/AiConfig.js';
 import { useMessage, Image, Text } from 'alemonjs';
 import { renderComponentIsHtmlToBuffer } from 'jsxp';
+import OpenAi from 'openai';
 
 const selects = onSelects(["message.create", "private.message.create"]);
-// inline regex used directly in condition checks
-const get = /^(\/|#)get (.+)$/i;
 var res = onResponse(selects, async (e, next) => {
     // 创建
     const [message] = useMessage(e);
@@ -67,6 +66,7 @@ var res = onResponse(selects, async (e, next) => {
     // 清空对话
     if (/^(\/|#)清空对话$/i.test(e.msg)) {
         await redisClient.clearAIChatHistory(e.guid);
+        await redisClient.deleteSessionId(e.guid);
         message.send(format(Text("对话已清空")));
     }
     // 清空所有对话
@@ -75,8 +75,8 @@ var res = onResponse(selects, async (e, next) => {
         message.send(format(Text("所有对话已清空")));
     }
     // get请求一个地址
-    if (get.test(e.msg)) {
-        const match = e.msg.match(get);
+    if (/^(\/|#)get (.+)$/i.test(e.msg)) {
+        const match = e.msg.match(/^(\/|#)get (.+)$/i);
         if (!match) {
             message.send(format(Text("格式错误，请按照 格式：/get <url> 进行请求")));
             return;
@@ -91,6 +91,72 @@ var res = onResponse(selects, async (e, next) => {
             message.send(format(Text(`请求 ${url} 失败：${error}`)));
         }
     }
+    // 新对话
+    if (/(\/|#)(开启)?(new|新对话|新会话)$/i.test(e.msg)) {
+        const match = e.msg.match(/^(\/|#)(开启)?(new|新对话|新会话)$/i);
+        if (!match) {
+            message.send(format(Text("格式错误，请按照 格式：/new 进行开启新对话")));
+            return;
+        }
+        // 压缩当前对话的上下文
+        const aiConfig = await redisClient.getAIConfig(e.guid);
+        if (aiConfig.model) {
+            // 让ai总结当前聊天内容, 将其存储到redis中作为历史对话的一部分
+            const openai = new OpenAi({
+                baseURL: aiConfig.host,
+                apiKey: aiConfig.key,
+                timeout: 300000,
+            });
+            const history = await redisClient.getAIChatHistory(e.guid);
+            const FilingID = Date.now();
+            const summaryPrompt = `system:请总结一下我们之前的聊天内容，要求总结内容能够涵盖之前聊天的主要信息和细节，字数控制在200字以内。总结内容将被用作未来对话的上下文，请确保总结内容的准确性和完整性。请务必按照特定格式总总结, 格式如下
+
+归档ID:${FilingID}
+摘要:<简单描述>
+详细信息:<详细描述>
+
+归档id为框架生成
+其中摘要部分要求简洁明了, 详细信息部分要求尽可能全面地涵盖之前聊天的内容, 包括重要的细节和信息点。请确保总结内容能够准确反映之前的聊天内容, 并且格式正确，以便我们在未来的对话中能够正确地使用这些总结内容。`;
+            const messages = [
+                ...history,
+                {
+                    role: "user",
+                    content: summaryPrompt,
+                },
+            ];
+            console.log("messages", messages);
+            try {
+                const response = await openai.chat.completions.create({
+                    model: aiConfig.model,
+                    messages,
+                    temperature: 0.8,
+                    stream: false,
+                });
+                const summary = response.choices[0].message.content;
+                if (summary) {
+                    const AbstractMatch = summary.match(/摘要:(.*)详细信息:/s);
+                    const DetailMatch = summary.match(/详细信息:(.*)/s);
+                    const Abstract = AbstractMatch ? AbstractMatch[1].trim() : "无摘要";
+                    const Detail = DetailMatch ? DetailMatch[1].trim() : "无详细信息";
+                    await redisClient.setSummary(e.guid, FilingID.toString(), Abstract);
+                    await redisClient.setSummaryDetail(e.guid, FilingID.toString(), Detail);
+                    await redisClient.clearAIChatHistory(e.guid);
+                    await redisClient.addAIChatHistory(e.guid, {
+                        role: "user",
+                        content: `system:上一轮对话小结：${Abstract}\n详细信息：${Detail}`,
+                    });
+                    message.send(format(Text("已开启新对话")));
+                }
+            }
+            catch (error) {
+                console.error("对话总结失败：", error);
+                message.send(format(Text("新对话开启失败"), Text(`\n报错内容：${error}`)));
+            }
+        }
+        else {
+            message.send(format(Text("当前无可用的AI配置，请先设置AI配置")));
+        }
+    }
     next();
 });