alemonjs-aichat 1.0.31-beta.3 → 1.0.32

package/lib/api/aitools.js

@@ -10,6 +10,8 @@ import { isPrivateIP, validateURL } from './security.js';
 import { spawn } from 'child_process';
 import * as dns from 'node:dns/promises';
 import { getWorkspace } from './workspace.js';
+import { getExecCommandEnv } from '../userEnv.js';
+import { remoteNodeManager } from '../remoteNodes.js';
 
 const value = getConfigValue().aiChat || {};
 const getPrompt = async (text) => {
@@ -168,7 +170,7 @@ const tools = [
         type: "function",
         function: {
             name: "exec",
-            description: "执行终端命令, 请勿执行高危险性指令, 例如rm -rf /等, 否则可能会导致服务器数据丢失或系统崩溃. 你可以使用这个工具来执行一些简单的命令, 例如查看当前目录下的文件ls, 查看系统状态top等. 当你想要执行一个命令时, 请提供具体的命令文本, 例如'ls -la'或'top -n 1'. 执行结果将会返回给你, 但请注意, 由于安全限制, 某些命令可能无法执行或返回受限的结果",
+            description: "执行终端命令. 你可以使用这个工具来执行一些简单的命令, 例如查看当前目录下的文件ls, 查看系统状态top等. 当你想要执行一个命令时, 请提供具体的命令文本, 例如'ls -la'或'top -n 1'. 执行结果将会返回给你, 但请注意, 由于安全限制, 某些命令可能无法执行或返回受限的结果",
             parameters: {
                 type: "object",
                 properties: {
@@ -176,12 +178,16 @@ const tools = [
                         type: "string",
                         description: "执行命令的用户ID",
                     },
+                    groupId: {
+                        type: "string",
+                        description: "当前群聊ID，私聊时传'private'",
+                    },
                     command: {
                         type: "string",
                         description: "要执行的终端命令",
                     },
                 },
-                required: ["userId", "command"],
+                required: ["userId", "groupId", "command"],
             },
         },
     },
@@ -234,7 +240,7 @@ const tools = [
         type: "function",
         function: {
             name: "MemoryOperation",
-            description: "这个工具用于获取或修改对于用户的记忆数据, 包括用户形象, 用户偏好, 历史对话等. 你可以使用这个工具来存储一些需要长期记忆的信息, 例如用户的兴趣爱好, 重要事件等. 当你想要获取或修改这些信息时, 可以调用这个工具并提供具体的操作指令和数据. 例如, 在聊天过程中他对你的态度,以及他喜欢的东西等,可以通过这个工具及时记录下来, 也可以通过这个工具获取之前的对话记录,便于继续之前的话题",
+            description: "这个工具用于获取或修改对于用户的记忆数据, 包括用户形象, 用户偏好, 历史对话等. 你可以使用这个工具来存储一些需要长期记忆的信息, 例如用户的兴趣爱好, 重要事件等, 在不认识对方时可以尝试一下获取. 当你想要获取或修改这些信息时, 可以调用这个工具并提供具体的操作指令和数据. 例如, 在聊天过程中他对你的态度,以及他喜欢的东西等,可以通过这个工具及时记录下来, 也可以通过这个工具获取之前的对话记录,便于继续之前的话题",
             parameters: {
                 type: "object",
                 properties: {
@@ -335,6 +341,51 @@ const tools = [
         },
     },
 ];
+/**
+ * 确保 Docker 容器已创建并运行
+ */
+async function ensureContainerRunning(config) {
+    const { containerName, image, memory, cpus, pidsLimit, networkMode, workspacePath } = config;
+    if (!containerName)
+        return;
+    return new Promise((resolve) => {
+        const check = spawn("docker", ["inspect", "-f", "{{.State.Running}}", containerName]);
+        let stdout = "";
+        check.stdout.on("data", (d) => (stdout += d.toString()));
+        check.on("close", (code) => {
+            if (code === 0 && stdout.trim() === "true") {
+                resolve();
+                return;
+            }
+            if (code === 0 && stdout.trim() === "false") {
+                const start = spawn("docker", ["start", containerName]);
+                start.on("close", () => resolve());
+                return;
+            }
+            const args = [
+                "run", "-d",
+                "--name", containerName,
+                "--memory", memory || "256m",
+                "--cpus", cpus || "0.5",
+                "--pids-limit", String(pidsLimit || 64),
+                "--network", networkMode || "none",
+            ];
+            if (workspacePath && fs.existsSync(workspacePath)) {
+                args.push("-v", `${workspacePath}:/workspace`, "-w", "/workspace");
+            }
+            args.push(image || "ubuntu:latest", "sleep", "infinity");
+            const create = spawn("docker", args);
+            let createStderr = "";
+            create.stderr.on("data", (d) => (createStderr += d.toString()));
+            create.on("close", (code) => {
+                if (code !== 0) {
+                    console.error(`[Docker] 容器创建失败: ${containerName}`, createStderr);
+                }
+                resolve();
+            });
+        });
+    });
+}
 const availableTools = {
     getAlemonjsConfig: async ({ key, value }) => {
         if (key == "ailist") {
@@ -726,30 +777,70 @@ const availableTools = {
     },
     /**
      * 运行cmd命令
-     * @param exec 命令字符串
+     * @param userId 用户ID
+     * @param groupId 群聊ID，私聊时为"private"
+     * @param command 命令字符串
      * @returns 命令执行结果
      */
-    exec: async ({ userId, command }) => {
+    exec: async ({ userId, groupId, command }) => {
         const workspace = getWorkspace(userId);
+        // 使用新的环境管理获取执行环境
+        const envInfo = await getExecCommandEnv(groupId || "private", userId);
+        // 远程节点环境：通过 SSH 执行
+        if (envInfo.type === "remote" && envInfo.nodeName) {
+            try {
+                const result = await remoteNodeManager.execute(envInfo.nodeName, command);
+                return result || "命令执行完成，无输出";
+            }
+            catch (err) {
+                return `远程执行失败: ${err.message}`;
+            }
+        }
+        // Singularity 容器环境：通过远程节点的 Singularity 执行
+        if (envInfo.type === "singularity" && envInfo.nodeName) {
+            try {
+                const node = remoteNodeManager.getNode(envInfo.nodeName);
+                if (!node) {
+                    return `未找到远程节点: ${envInfo.nodeName}`;
+                }
+                const image = envInfo.singularityImage || node.defaultImage;
+                if (!image) {
+                    return "未指定 Singularity 镜像，请在切换环境时指定或配置 defaultImage";
+                }
+                // 构建 singularity exec 命令
+                const singularityCmd = `singularity exec ${image} sh -c '${command.replace(/'/g, "'\''")}'`;
+                const result = await remoteNodeManager.execute(envInfo.nodeName, singularityCmd);
+                return result || "命令执行完成，无输出";
+            }
+            catch (err) {
+                return `Singularity 执行失败: ${err.message}`;
+            }
+        }
+        // 系统环境：直接在宿主机执行
+        if (envInfo.type === "system") {
+            return new Promise((resolve) => {
+                let output = "";
+                const child = spawn("sh", ["-c", command], { cwd: workspace });
+                child.stdout.on("data", (d) => (output += d.toString()));
+                child.stderr.on("data", (d) => (output += d.toString()));
+                child.on("close", () => resolve(output));
+            });
+        }
+        // 容器环境（group/user）：确保容器存在并启动，然后 docker exec
+        const envConfig = await redisClient.getExecEnv(groupId || "private", userId);
+        const containerName = envConfig?.containerName;
+        if (!containerName) {
+            return "错误：未找到执行环境配置，请先切换执行环境";
+        }
+        await ensureContainerRunning(envConfig);
         return new Promise((resolve) => {
-            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 = "";
+            const args = ["exec"];
+            if (envConfig.workspacePath) {
+                args.push("-w", "/workspace");
+            }
+            args.push(containerName, "sh", "-c", command);
+            const child = spawn("docker", args);
             child.stdout.on("data", (d) => (output += d.toString()));
             child.stderr.on("data", (d) => (output += d.toString()));
             child.on("close", () => resolve(output));

package/lib/api/format.js

@@ -2,12 +2,22 @@ import { getConfigValue } from 'alemonjs';
 
 getConfigValue().aiChat || {};
 const getTimeString = () => {
+    return getMessageTimeString();
+};
+const getGroupTimeString = () => {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    return `${year}/${month}`;
+};
+const getMessageTimeString = () => {
     const now = new Date();
+    const year = now.getFullYear();
     const month = String(now.getMonth() + 1).padStart(2, "0");
     const day = String(now.getDate()).padStart(2, "0");
     const hours = String(now.getHours()).padStart(2, "0");
     const minutes = String(now.getMinutes()).padStart(2, "0");
-    return `${month}-${day} ${hours}:${minutes}`;
+    return `${year}/${month}/${day} ${hours}:${minutes}`;
 };
 
-export { getTimeString };
+export { getGroupTimeString, getMessageTimeString, getTimeString };

package/lib/config.js

@@ -1,10 +1,15 @@
-import Redis from 'ioredis';
 import { getConfigValue } from 'alemonjs';
-import { tools } from './api/aitools.js';
+import fs from 'fs';
+import path from 'path';
+import { redis } from './redis.js';
 
 class db {
     redis;
     systemPrompt = "";
+    async getToolDefinitions() {
+        const { tools } = await import('./api/aitools.js');
+        return tools;
+    }
     static defaultAIConfig = {
         host: "",
         key: "",
@@ -14,11 +19,8 @@ class db {
         systemPrompt: "",
         rapi: false,
     };
-    constructor(redisConfig) {
-        this.redis =
-            redisConfig && Object.keys(redisConfig).length > 0
-                ? new Redis(redisConfig)
-                : new Redis(); // 默认配置
+    constructor(redisInstance) {
+        this.redis = redisInstance || redis;
     }
     /** 获取提示词优化内容 */
     async getPromptOptimization(guid) {
@@ -408,6 +410,218 @@ class db {
     async setAtTriggerSwitch(guid, enable) {
         await this.redis.set(`ai:at_trigger:switch:${guid}`, enable ? "1" : "0");
     }
+    /** --------------------------------------------------------- */
+    /** 正则触发规则 */
+    /** 获取正则触发规则列表 */
+    async getRegexRules(guid) {
+        const rulesStr = await this.redis.get(`ai:regex_rules:${guid}`);
+        if (rulesStr) {
+            return JSON.parse(rulesStr);
+        }
+        return [];
+    }
+    /** 设置正则触发规则列表 */
+    async setRegexRules(guid, rules) {
+        await this.redis.set(`ai:regex_rules:${guid}`, JSON.stringify(rules));
+    }
+    /** 添加正则触发规则 */
+    async addRegexRule(guid, rule) {
+        // 验证正则表达式是否合法
+        try {
+            new RegExp(rule);
+        }
+        catch {
+            return false;
+        }
+        const rules = await this.getRegexRules(guid);
+        if (rules.includes(rule)) {
+            return false; // 规则已存在
+        }
+        rules.push(rule);
+        await this.setRegexRules(guid, rules);
+        return true;
+    }
+    /** 删除正则触发规则 */
+    async removeRegexRule(guid, ruleOrIndex) {
+        const rules = await this.getRegexRules(guid);
+        // 尝试按索引删除
+        const index = parseInt(ruleOrIndex, 10);
+        if (!isNaN(index) && index >= 0 && index < rules.length) {
+            rules.splice(index, 1);
+            await this.setRegexRules(guid, rules);
+            return true;
+        }
+        // 按规则内容删除
+        const ruleIndex = rules.indexOf(ruleOrIndex);
+        if (ruleIndex === -1) {
+            return false;
+        }
+        rules.splice(ruleIndex, 1);
+        await this.setRegexRules(guid, rules);
+        return true;
+    }
+    /** 检查消息是否匹配正则触发规则 */
+    async matchRegexRule(guid, message) {
+        const rules = await this.getRegexRules(guid);
+        for (const rule of rules) {
+            try {
+                const regex = new RegExp(rule);
+                if (regex.test(message)) {
+                    return true;
+                }
+            }
+            catch {
+                // 跳过无效的正则
+            }
+        }
+        return false;
+    }
+    /** 清空正则触发规则 */
+    async clearRegexRules(guid) {
+        await this.redis.del(`ai:regex_rules:${guid}`);
+    }
+    /** --------------------------------------------------------- */
+    /** 容器管理 */
+    /** 获取群容器配置 */
+    async getGroupContainer(groupId) {
+        const str = await this.redis.get(`ai:container:group:${groupId}`);
+        return str ? JSON.parse(str) : null;
+    }
+    /** 设置群容器配置 */
+    async setGroupContainer(groupId, config) {
+        await this.redis.set(`ai:container:group:${groupId}`, JSON.stringify(config));
+    }
+    /** 获取用户容器配置 */
+    async getUserContainer(userId) {
+        const str = await this.redis.get(`ai:container:user:${userId}`);
+        return str ? JSON.parse(str) : null;
+    }
+    /** 设置用户容器配置 */
+    async setUserContainer(userId, config) {
+        await this.redis.set(`ai:container:user:${userId}`, JSON.stringify(config));
+    }
+    /** 获取用户当前 exec 环境配置（按群隔离） */
+    async getExecEnv(groupId, userId) {
+        const key = groupId === "private"
+            ? `ai:container:env:private:${userId}`
+            : `ai:container:env:${groupId}:${userId}`;
+        const str = await this.redis.get(key);
+        return str ? JSON.parse(str) : null;
+    }
+    /** 设置用户当前 exec 环境配置（按群隔离） */
+    async setExecEnv(groupId, userId, config) {
+        const key = groupId === "private"
+            ? `ai:container:env:private:${userId}`
+            : `ai:container:env:${groupId}:${userId}`;
+        await this.redis.set(key, JSON.stringify(config));
+    }
+    /** 创建群容器（首次触发时自动创建） */
+    async ensureGroupContainer(groupId) {
+        const existing = await this.getGroupContainer(groupId);
+        if (existing)
+            return existing;
+        const configValue = getConfigValue();
+        const containerConf = configValue.aiChat?.groupContainer || {};
+        const image = containerConf.image || "ubuntu:latest";
+        const containerName = `aichat_grp_${groupId}`;
+        const workspacePath = path.resolve(process.cwd(), `public/sandbox/workspaces/groups/${groupId}`);
+        if (!fs.existsSync(workspacePath)) {
+            fs.mkdirSync(workspacePath, { recursive: true });
+        }
+        const config = {
+            containerName,
+            image,
+            memory: containerConf.memory || "256m",
+            cpus: containerConf.cpus || "0.5",
+            pidsLimit: containerConf.pidsLimit || 64,
+            networkMode: containerConf.networkMode || "none",
+            workspacePath,
+        };
+        await this.setGroupContainer(groupId, config);
+        return config;
+    }
+    /** 创建用户容器（手动切换或私聊首次触发时创建） */
+    async ensureUserContainer(userId) {
+        const existing = await this.getUserContainer(userId);
+        if (existing)
+            return existing;
+        const configValue = getConfigValue();
+        const containerConf = configValue.aiChat?.userContainer || {};
+        const image = containerConf.image || "ubuntu:latest";
+        const containerName = `aichat_usr_${userId}`;
+        const workspacePath = path.resolve(process.cwd(), `public/sandbox/workspaces/${userId}`);
+        if (!fs.existsSync(workspacePath)) {
+            fs.mkdirSync(workspacePath, { recursive: true });
+        }
+        const config = {
+            containerName,
+            image,
+            memory: containerConf.memory || "128m",
+            cpus: containerConf.cpus || "0.25",
+            pidsLimit: containerConf.pidsLimit || 32,
+            networkMode: containerConf.networkMode || "none",
+            workspacePath,
+        };
+        await this.setUserContainer(userId, config);
+        return config;
+    }
+    /** 初始化用户 exec 环境（群聊默认群容器，私聊默认用户容器） */
+    async initExecEnv(groupId, userId) {
+        const existing = await this.getExecEnv(groupId, userId);
+        if (existing)
+            return existing;
+        if (groupId === "private") {
+            const userConfig = await this.ensureUserContainer(userId);
+            await this.setExecEnv("private", userId, { ...userConfig, type: "user" });
+            return userConfig;
+        }
+        else {
+            const groupConfig = await this.ensureGroupContainer(groupId);
+            await this.setExecEnv(groupId, userId, { ...groupConfig, type: "group" });
+            return groupConfig;
+        }
+    }
+    /** 切换到群容器 */
+    async switchToGroupContainer(groupId, userId) {
+        const groupConfig = await this.ensureGroupContainer(groupId);
+        await this.setExecEnv(groupId, userId, { ...groupConfig, type: "group" });
+        return groupConfig;
+    }
+    /** 切换到用户容器 */
+    async switchToUserContainer(groupId, userId) {
+        const userConfig = await this.ensureUserContainer(userId);
+        await this.setExecEnv(groupId, userId, { ...userConfig, type: "user" });
+        return userConfig;
+    }
+    /** 切换到系统环境 */
+    async switchToSystemEnv(groupId, userId) {
+        await this.setExecEnv(groupId, userId, { type: "system" });
+    }
+    /** 切换到远程节点环境 */
+    async switchToRemoteEnv(groupId, userId, nodeName) {
+        await this.setExecEnv(groupId, userId, { type: "remote", nodeName });
+    }
+    /** 切换到 Singularity 环境 */
+    async switchToSingularityEnv(groupId, userId, nodeName, image) {
+        await this.setExecEnv(groupId, userId, { type: "singularity", nodeName, singularityImage: image });
+    }
+    /** 判断是否为超级管理员 */
+    isSuperAdmin(userId) {
+        const configValue = getConfigValue();
+        const superAdmins = configValue.aiChat?.superAdmin || [];
+        return superAdmins.includes(userId);
+    }
+    /** 获取所有容器配置 key */
+    async getAllContainerKeys() {
+        const groupKeys = await this.redis.keys("ai:container:group:*");
+        const userKeys = await this.redis.keys("ai:container:user:*");
+        return [...groupKeys, ...userKeys];
+    }
+    /** 删除指定容器配置 */
+    async deleteContainer(key) {
+        await this.redis.del(key);
+    }
+    /** --------------------------------------------------------- */
     /** 禁用工具 */
     async disableTool(guid, toolName) {
         await this.redis.set(`ai:tool:disable:${guid}:${toolName}`, "1");
@@ -423,6 +637,7 @@ class db {
     }
     /** 获取所有工具状态 */
     async getAllToolStatus(guid) {
+        const tools = await this.getToolDefinitions();
         const status = {};
         for (const tool of tools) {
             const toolName = tool.type === "function" ? tool.function.name : "";
@@ -432,6 +647,7 @@ class db {
     }
     // 获取所有可用工具,返回完整工具
     async getAvailableTools(guid) {
+        const tools = await this.getToolDefinitions();
         const toolStatus = await this.getAllToolStatus(guid);
         const availableTools = tools.filter((tool) => {
             const toolName = tool.type === "function" ? tool.function.name : "";
@@ -439,8 +655,22 @@ class db {
         });
         return availableTools;
     }
+    /** 获取渲染精度 (中:80%, 高:100%, 超高:120%) */
+    async getRenderPrecision(guid) {
+        const val = await this.redis.get(`ai:render_precision:${guid}`);
+        if (val === "中")
+            return 0.8;
+        if (val === "超高")
+            return 1.2;
+        return 1.0;
+    }
+    /** 设置渲染精度 */
+    async setRenderPrecision(guid, level) {
+        await this.redis.set(`ai:render_precision:${guid}`, level);
+    }
     /** 装载工具 */
     async loadTools(guid) {
+        const tools = await this.getToolDefinitions();
         const toolStatus = await this.getAllToolStatus(guid);
         const allTools = tools.map((tool) => tool.type === "function" ? tool.function.name : "");
         // 默认禁用的危险工具
@@ -463,12 +693,6 @@ class db {
         return toolsWithStatus.map((tool) => tool.name);
     }
 }
-const configValue = getConfigValue();
-const aiChatConfig = configValue.aiChat || {};
-const redisClient = new db({
-    host: aiChatConfig.redis?.host ?? "localhost",
-    port: aiChatConfig.redis?.port ?? 6379,
-    password: aiChatConfig.redis?.password ?? "",
-});
+const redisClient = new db(redis);
 
 export { redisClient as default };

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.31-beta";
+var version = "v1.0.32";
 var by = "AlemonJS";
 var list = [
 	{
@@ -85,6 +85,34 @@ var list = [
 					cmd: "/[开启|关闭]仅艾特触发",
 					desc: "开启或关闭仅艾特触发功能, 避免群内有多个AI时互相干扰。"
 				},
+				{
+					cmd: "/添加正则规则 [表达式]",
+					desc: "添加正则触发规则，匹配的消息将自动触发AI回复，无需艾特。"
+				},
+				{
+					cmd: "/删除正则规则 [序号或内容]",
+					desc: "删除指定的正则触发规则。"
+				},
+				{
+					cmd: "/正则规则列表",
+					desc: "查看当前所有正则触发规则。"
+				},
+				{
+					cmd: "/清空正则规则",
+					desc: "清空所有正则触发规则。"
+				},
+				{
+					cmd: "/切换群容器",
+					desc: "切换 exec 指令指向当前群的 Docker 容器。"
+				},
+				{
+					cmd: "/切换用户容器",
+					desc: "切换 exec 指令指向自己的 Docker 容器。"
+				},
+				{
+					cmd: "/切换系统环境",
+					desc: "[仅超级管理员私聊]切换 exec 指令指向宿主机。"
+				},
 				{
 					cmd: "/[开启|关闭]好感度",
 					desc: "开启或关闭好感度功能。"

package/lib/image/conponent/AiConfig.js

@@ -35,7 +35,7 @@ function App(data) {
     return (React.createElement("html", null,
         React.createElement("head", null,
             React.createElement(LinkStyleSheet, { src: fileUrl })),
-        React.createElement("body", { className: "bg-cover p-4", style: { backgroundImage: `url(${fileUrl$1})` } },
+        React.createElement("body", { className: "bg-cover p-4", style: { backgroundImage: `url(${fileUrl$1})`, width: "800px" } },
             React.createElement("div", { className: "relative mb-6" },
                 React.createElement("div", { className: "absolute -left-4 -top-4 w-24 h-24 bg-purple-400/20 rounded-full blur-2xl -z-0" }),
                 React.createElement("h2", { className: "relative text-3xl font-bold bg-gradient-to-r from-amber-300 via-yellow-200 to-amber-300 bg-clip-text text-transparent drop-shadow-lg tracking-wide" }, "AI\u914D\u7F6E\u8BE6\u60C5"),

package/lib/middleware/mw.js

@@ -16,6 +16,13 @@ var mw = onMiddleware(selects, async (event, next) => {
     event["uidkey"] = `${event["guid"]}:${event.UserName}(${event.UserId})`; // 唯一标识
     event["nickname"] =
         `${event.name === "private.message.create" ? "[私信]" : ""}${event.UserName}(${event.UserId})`; // 昵称(用户名+QQ号)
+    // 初始化 exec 环境（群容器为默认）
+    if (event.name === "private.message.create") {
+        await redisClient.initExecEnv("private", event.UserId);
+    }
+    else {
+        await redisClient.initExecEnv(event.guid, event.UserId);
+    }
     if (event.Platform == "testone") {
         // 处理图片消息
         event["img"] = event.value
@@ -261,7 +268,14 @@ var mw = onMiddleware(selects, async (event, next) => {
     const atTriggerSwitch = await redisClient.getAtTriggerSwitch(event.ChannelId ?? event.UserId);
     if (atTriggerSwitch === "1" && event.Platform !== "testone") {
         if (!event["atBot"] && event.name !== "private.message.create") {
-            event["Xianyu"] = false; // 跳过所有指令,继续执行后续的处理函数
+            // 检查是否匹配正则触发规则
+            const regexMatched = await redisClient.matchRegexRule(event.ChannelId ?? event.UserId, event.msg || "");
+            if (regexMatched) {
+                event["regexTriggered"] = true; // 标记为正则触发
+            }
+            else {
+                event["Xianyu"] = false; // 跳过所有指令,继续执行后续的处理函数
+            }
         }
     }
     if (event["Xianyu"]) {