fofstudio-aimcpztdata 1.0.0

package/build/MCPMain.js

@@ -0,0 +1,2577 @@
+#!/usr/bin/env node
+const { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
+const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+const { z } = require("zod");
+    
+
+
+/**
+ * 自定义单击事件
+ * @id 选择器
+ * @fun 点击事件
+ * */
+function baseClick(id, fun) {
+	document.querySelectorAll(id).forEach(function (v) {
+		v.addEventListener('click', fun);
+	});
+};
+
+/**
+ * 自定义双击事件
+ * @id 选择器
+ * @fun 点击事件
+ * */
+function baseDblclick(id, fun) {
+	document.querySelectorAll(id).forEach(function (v) {
+		v.addEventListener('dblclick', fun);
+	});
+};
+
+/**
+ * 自定义鼠标按键按下事件
+ * @id 选择器
+ * @fun 点击事件
+ * */
+function baseMousedown(id, fun) {
+	document.querySelectorAll(id).forEach(function (v) {
+		v.addEventListener('mousedown', fun);
+	});
+};
+
+/**
+ * 自定义鼠标按键松开事件
+ * @id 选择器
+ * @fun 点击事件
+ * */
+function baseMouseup(id, fun) {
+	document.querySelectorAll(id).forEach(function (v) {
+		v.addEventListener('mouseup', fun);
+	});
+};
+
+/**
+ * 自定义鼠标移入事件
+ * @id 选择器
+ * @fun 点击事件
+ * */
+function baseMouseenter(id, fun) {
+	document.querySelectorAll(id).forEach(function (v) {
+		v.addEventListener('mouseenter', fun);
+	});
+};
+
+/**
+ * 自定义鼠标移出事件
+ * @id 选择器
+ * @fun 点击事件
+ * */
+function baseMouseleave(id, fun) {
+	document.querySelectorAll(id).forEach(function (v) {
+		v.addEventListener('mouseleave', fun);
+	});
+};
+
+/**
+ * 自定义鼠标移动事件
+ * @id 选择器
+ * @fun 点击事件
+ * */
+function baseMousemove(id, fun) {
+	document.querySelectorAll(id).forEach(function (v) {
+		v.addEventListener('mousemove', fun);
+	});
+};
+/**
+ * Utf8Array转字符串
+ * @array Utf8Array数据
+ * */
+function Utf8ArrayToStr(array) {
+	var out, i, len, c;
+	var char2, char3;
+	out = "";
+	len = array.length;
+	i = 0;
+	while (i < len) {
+		c = array[i++];
+		switch (c >> 4) {
+			case 0:
+			case 1:
+			case 2:
+			case 3:
+			case 4:
+			case 5:
+			case 6:
+			case 7:
+				// 0xxxxxxx
+				out += String.fromCharCode(c);
+				break;
+			case 12:
+			case 13:
+				// 110x xxxx 10xx xxxx
+				char2 = array[i++];
+				out += String.fromCharCode((c & 0x1f) << 6 | char2 & 0x3f);
+				break;
+			case 14:
+				// 1110 xxxx 10xx xxxx 10xx xxxx
+				char2 = array[i++];
+				char3 = array[i++];
+				out += String.fromCharCode((c & 0x0f) << 12 | (char2 & 0x3f) << 6 | (char3 & 0x3f) << 0);
+				break;
+		}
+	}
+	return out;
+}
+
+let LetData = {
+	sqlServer: null,
+	fofsqlite3: null,
+	fofmysql: null,
+	crypto: null,
+	sharp: null,
+	email: null,
+	compress: null,
+	ftp: null,
+	fileFOF: null,
+	DecoderAPI: null,
+	SendHttp: null,
+	dnsFOF: null,
+	EXEAPI: null,
+	PlatAPI: null,
+	ReadAPI: null,
+	ProcessAPI: null,
+	HttpServer: null,
+	TcpServer: null,
+	UdpServer: null,
+	IPData: null,
+	BufferClass: null,
+	DataPackaging: null,
+	websocket: null,
+	sms: null,
+	excel: null,
+	word: null,
+	docxObj: null,
+	wordPath: null,
+	nodeRsa: null,
+	ffiNapi: null,
+	HttpProxy: null,
+	TxCdn: null,
+	SerialPortNode: null,
+	mqttServer: null,
+	modbus: null,
+	printWindows: null,
+	postgres: null,
+	BaiDuOpencv: null,
+	Alioss: null
+}
+let fofletData = LetData;
+
+let electronProcessAPI = {
+	runExec: (Path, cmdCode, SetProcessYesMsg = undefined, SetProcessNoMsg = undefined, SetProcessEndMsg = undefined, encoding_ = "GBK", env = undefined, ifArr = false) => {
+		if (LetData.ProcessAPI == null) {
+			LetData.ProcessAPI = require('./modules/ProcessAPI.js');
+		}
+		LetData.ProcessAPI.runExec({ "路径": Path, "code": cmdCode }, SetProcessYesMsg, SetProcessNoMsg, SetProcessEndMsg, encoding_, env, ifArr)
+	},
+	runExeckill: () => {
+		if (LetData.ProcessAPI == null) {
+			LetData.ProcessAPI = require('./modules/ProcessAPI.js');
+		}
+		LetData.ProcessAPI.runExeckill()
+	},
+
+}
+let electronReadAPI = {
+	readText: () => {
+		if (LetData.ReadAPI == null) {
+			LetData.ReadAPI = require('./modules/ReadAPI.js');
+		}
+		return LetData.ReadAPI.readText();
+	},
+	writeText: (text) => {
+		if (LetData.ReadAPI == null) {
+			LetData.ReadAPI = require('./modules/ReadAPI.js');
+		}
+		return LetData.ReadAPI.writeText(text);
+	},
+	readHTML: () => {
+		if (LetData.ReadAPI == null) {
+			LetData.ReadAPI = require('./modules/ReadAPI.js');
+		}
+		return LetData.ReadAPI.readHTML();
+	},
+	writeHTML: (text) => {
+		if (LetData.ReadAPI == null) {
+			LetData.ReadAPI = require('./modules/ReadAPI.js');
+		}
+		return LetData.ReadAPI.writeHTML(text);
+	},
+	readRTF: () => {
+		if (LetData.ReadAPI == null) {
+			LetData.ReadAPI = require('./modules/ReadAPI.js');
+		}
+		return LetData.ReadAPI.readRTF();
+	},
+	writeRTF: (text) => {
+		if (LetData.ReadAPI == null) {
+			LetData.ReadAPI = require('./modules/ReadAPI.js');
+		}
+		return LetData.ReadAPI.writeRTF(text);
+	},
+}
+let electronPlatAPI = {
+	getPlatform: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.getPlatform();
+	},
+	globalShortcut: (key) => {
+		//全局快捷键绑定
+		try {
+			//只在electron中生效
+			ipcRenderer.invoke('globalShortcut', key)
+		} catch (error) {
+
+		}
+	},
+	Notification: (data) => {
+		try {
+			//只在electron中生效
+			ipcRenderer.invoke('Notification', data)
+		} catch (error) {
+
+		}
+	},
+	openAtLogin: (true_) => {
+		try {
+			//只在electron中生效
+			ipcRenderer.invoke('openAtLogin', true_)
+		} catch (error) {
+
+		}
+	},
+	powerSaveBlocker: () => {
+		try {
+			//只在electron中生效
+			ipcRenderer.invoke('powerSaveBlocker')
+		} catch (error) {
+
+		}
+	},
+	processArgv: () => {
+		return process.argv;
+	},
+	getCursorScreenPoint: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.getCursorScreenPoint()
+	},
+	dipToScreenPoint: (data) => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.dipToScreenPoint(data)
+	},
+	networkInterfaces: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.networkInterfaces()
+	},
+	getLocalIP: () => {
+		if (LetData.IPData == null) {
+			LetData.IPData = require('./modules/IP.js');
+		}
+		return LetData.IPData.getLocalIP()
+	},
+	cpus: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.cpus()
+	},
+	tmpDir: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.tmpDir()
+	},
+	arch: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.arch()
+	},
+	totalmem: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.totalmem()
+	},
+	freemem: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.freemem()
+	},
+	OStype: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.OStype()
+	},
+	hostname: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.hostname()
+	},
+	release: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.release()
+	},
+	uptime: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.uptime()
+	},
+	loadavg: () => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		return LetData.PlatAPI.loadavg()
+	},
+	showItemInFolder: (fullPath) => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		LetData.PlatAPI.showItemInFolder(fullPath)
+	},
+	openPath: (fullPath) => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		LetData.PlatAPI.openPath(fullPath)
+	},
+	openExternal: (url) => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		LetData.PlatAPI.openExternal(url)
+	},
+	trashItem: (fullPath) => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		LetData.PlatAPI.trashItem(fullPath)
+	},
+	openItem: (fullPath) => {
+		if (LetData.PlatAPI == null) {
+			LetData.PlatAPI = require('./modules/PlatAPI.js');
+		}
+		LetData.PlatAPI.openItem(fullPath)
+	},
+}
+let electronEXEAPI = {
+	OpenEXE: (path) => {
+		if (LetData.EXEAPI == null) {
+			LetData.EXEAPI = require('./modules/EXEAPI.js');
+		}
+		return LetData.EXEAPI.OpenEXE(path)
+	},
+	KillEXE: (pid) => {
+		if (LetData.EXEAPI == null) {
+			LetData.EXEAPI = require('./modules/EXEAPI.js');
+		}
+		return LetData.EXEAPI.KillEXE(pid)
+	},
+	DoesTheProcessExist: (query, cb, encoding = "GBK") => {
+		if (LetData.EXEAPI == null) {
+			LetData.EXEAPI = require('./modules/EXEAPI.js');
+		}
+		return LetData.EXEAPI.DoesTheProcessExist(query, cb, encoding)
+	},
+
+}
+let electronDnsAPI = {
+	lookup: (url, funStr = undefined) => {
+		if (LetData.dnsFOF == null) {
+			LetData.dnsFOF = require('./modules/dns.js');
+		}
+		LetData.dnsFOF.lookup(url, funStr)
+	},
+	lookupService: (address, family, funStr = undefined) => {
+		if (LetData.dnsFOF == null) {
+			LetData.dnsFOF = require('./modules/dns.js');
+		}
+		LetData.dnsFOF.lookupService(address, family, funStr)
+	},
+	resolve4: (url, funStr = undefined) => {
+		if (LetData.dnsFOF == null) {
+			LetData.dnsFOF = require('./modules/dns.js');
+		}
+		LetData.dnsFOF.resolve4(url, funStr)
+	},
+	resolve6: (url, funStr) => {
+		if (LetData.dnsFOF == null) {
+			LetData.dnsFOF = require('./modules/dns.js');
+		}
+		LetData.dnsFOF.resolve6(url, funStr)
+	},
+	reverse: (ip, funStr) => {
+		if (LetData.dnsFOF == null) {
+			LetData.dnsFOF = require('./modules/dns.js');
+		}
+		LetData.dnsFOF.reverse(ip, funStr)
+	},
+}
+let electronFileAPI = {
+	getAppPath: () => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		if (__filename.indexOf("MCPMain.js") != -1) {
+			return LetData.fileFOF.getAppPath(true);
+		} else {
+			return LetData.fileFOF.getAppPath();
+		}
+	},
+	getDesktop: () => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.getDesktop();
+	},
+	getPathAll: () => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.getPathAll();
+	},
+
+	listFile: (path, funEv = undefined) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		LetData.fileFOF.listFile(path, funEv);
+	},
+	watch: (path, funEv = undefined) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		LetData.fileFOF.watch(path, funEv);
+	},
+	getExe: () => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.getExe();
+	},
+	existsSync: (path) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.existsSync(path);
+	},
+	writeFileSync: (path, data) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.writeFileSync({ "路径": path, "数据": data });
+	},
+	writeFileBase64Sync: (path, data) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.writeFileBase64Sync({ "路径": path, "数据": data });
+	},
+	writeFileHexSync: (path, data) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.writeFileHexSync({ "路径": path, "数据": data });
+	},
+	readFileSync: (path, unicode = "utf8") => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.readFileSync({ "路径": path, "编码": unicode });
+	},
+	readFileBase64Sync: (path) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.readFileBase64Sync({ "路径": path });
+	},
+	readFileHexSync: (path) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.readFileHexSync({ "路径": path });
+	},
+	mkdirSync: (path) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.mkdirSync(path);
+	},
+	cp: (path, path2, funEv = undefined) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.cp(path, path2, funEv);
+	},
+	renameSync: (path, newPath) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.renameSync({ "路径": path, "路径2": newPath });
+	},
+	unlink: (path, funEv = undefined) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.unlink(path, funEv);
+	},
+	appendFile: (path, data) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.appendFile({ "路径": path, "数据": data });
+	},
+	basename: (path) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.basename(path);
+	},
+	dirname: (path) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.dirname(path);
+	},
+	extname: (path) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.extname(path);
+	},
+	isAbsolute: (path) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.isAbsolute(path);
+	},
+	normalize: (path) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.normalize(path);
+	},
+	FileMsg: (path, EVFun) => {
+		if (LetData.fileFOF == null) {
+			LetData.fileFOF = require('./modules/File.js');
+		}
+		return LetData.fileFOF.FileMsg(path, EVFun);
+	},
+}
+
+electronFileAPI.getAppPath = function () {
+    let path = __dirname.replace("/MCPMain.js", "")
+    path = path.replaceAll("\\", "/")
+    return path;
+}
+
+let electronDecoderAPI = {
+	TextDecoder: (Decoder, Code, hexTrue = false, hexCode = "hex") => {
+		if (LetData.DecoderAPI == null) {
+			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
+		}
+		return LetData.DecoderAPI.TextDecoder(Decoder, Code, hexTrue, hexCode);
+	},
+	TextDecoderBase64: (Decoder, Code) => {
+		if (LetData.DecoderAPI == null) {
+			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
+		}
+		return LetData.DecoderAPI.TextDecoderBase64(Decoder, Code);
+	},
+	TextToBase64: (Code) => {
+		if (LetData.DecoderAPI == null) {
+			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
+		}
+		return LetData.DecoderAPI.TextToBase64(Code);
+	},
+	Base64ToText: (Code) => {
+		if (LetData.DecoderAPI == null) {
+			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
+		}
+		return LetData.DecoderAPI.Base64ToText(Code);
+	},
+	TextTo16: (Code) => {
+		if (LetData.DecoderAPI == null) {
+			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
+		}
+		return LetData.DecoderAPI.TextTo16(Code);
+	},
+	HexToText: (Code) => {
+		if (LetData.DecoderAPI == null) {
+			LetData.DecoderAPI = require('./modules/DecoderAPI.js');
+		}
+		return LetData.DecoderAPI.HexToText(Code);
+	},
+}
+let electronHTTPAPI = {
+	httpSend: (url, RetFun = undefined, method_ = "GET", POSTDATA = "", headers_ = {}) => {
+		if (LetData.SendHttp == null) {
+			LetData.SendHttp = require('./modules/SendHttp.js');
+		}
+		LetData.SendHttp.httpSend(url, RetFun, method_, POSTDATA, headers_);
+	},
+	httpsSend: (url, RetFun = undefined, method_ = "GET", POSTDATA = "", headers_ = {}) => {
+		if (LetData.SendHttp == null) {
+			LetData.SendHttp = require('./modules/SendHttp.js');
+		}
+		LetData.SendHttp.httpsSend(url, RetFun, method_, POSTDATA, headers_);
+	},
+}
+let electronSqlServer = {
+	sendsqlserver: (funStr, host, user, password, database, port = 1433, max = 20, if2000 = false, obj = undefined) => {
+		if (LetData.sqlServer == null) {
+			LetData.sqlServer = require('./modules/sqlServer.js');
+		}
+		return LetData.sqlServer.sendsqlserver(funStr, host, user, password, database, port, max, if2000, obj);
+	},
+	exec: (funStr, sqltXet, values, poolID = 0) => {
+		if (LetData.sqlServer == null) {
+			LetData.sqlServer = require('./modules/sqlServer.js');
+		}
+		LetData.sqlServer.exec(sqltXet, values, poolID, funStr)
+	},
+	exec2: async (sqltXet, values, poolID = 0) => {
+		if (LetData.sqlServer == null) {
+			LetData.sqlServer = require('./modules/sqlServer.js');
+		}
+		let RetExec = await LetData.sqlServer.exec(sqltXet, values, poolID, undefined)
+		return RetExec;
+	},
+	execTransaction: (funStr, sqltXet, poolID = 0, TransactionType = {}) => {
+		if (LetData.sqlServer == null) {
+			LetData.sqlServer = require('./modules/sqlServer.js');
+		}
+		LetData.sqlServer.execTransaction(sqltXet, poolID, funStr, TransactionType);
+	},
+	execTransaction2: async (sqltXet, poolID = 0, TransactionType = {}) => {
+		if (LetData.sqlServer == null) {
+			LetData.sqlServer = require('./modules/sqlServer.js');
+		}
+		let RetData = {};
+		await LetData.sqlServer.execTransaction(sqltXet, poolID, undefined, TransactionType)
+			.then(res => {
+				RetData = res;
+			})
+			.catch(err => RetData = { "状态": "失败", "数据": err });
+		return RetData;
+	},
+	endPool: (poolID = 0) => {
+		if (LetData.sqlServer == null) {
+			LetData.sqlServer = require('./modules/sqlServer.js');
+		}
+		LetData.sqlServer.endPool(poolID);
+	},
+}
+let electronMysql = {
+	sendmysql: (funStr, host, user, password, database, port = 3306, connectionLimit = 20, Obj = {}) => {
+		if (LetData.fofmysql == null) {
+			LetData.fofmysql = require('./modules/mysql.js');
+		}
+		return LetData.fofmysql.sendmysql(funStr, host, user, password, database, port, connectionLimit, Obj)
+	},
+	query: (funStr, sqltXet, params = [], poolID = 0) => {
+		if (LetData.fofmysql == null) {
+			LetData.fofmysql = require('./modules/mysql.js');
+		}
+		LetData.fofmysql.query(sqltXet, params, poolID, funStr)
+	},
+	query2: async (sqltXet, params = [], poolID = 0) => {
+		if (LetData.fofmysql == null) {
+			LetData.fofmysql = require('./modules/mysql.js');
+		}
+		let RetData = {};
+		await LetData.fofmysql.query(sqltXet, params, poolID).then(res => {
+			RetData = { "状态": "成功", "数据": res }
+		}).catch(err => RetData = { "状态": "失败", "数据": err })
+		try {
+			if (RetData["数据"] == false) {
+				if (Array.isArray(RetData["数据"]) == false) {
+					RetData["数据"] = [];
+					RetData["状态"] == "失败"
+				}
+			}
+		} catch (error) {
+
+		}
+		return RetData;
+	},
+	exec: (funStr, sqltXet, values = [], poolID = 0) => {
+		if (LetData.fofmysql == null) {
+			LetData.fofmysql = require('./modules/mysql.js');
+		}
+		LetData.fofmysql.exec(sqltXet, values, poolID, funStr)
+	},
+	exec2: async (sqltXet, values = [], poolID = 0) => {
+		if (LetData.fofmysql == null) {
+			LetData.fofmysql = require('./modules/mysql.js');
+		}
+		let RetData = {};
+		await LetData.fofmysql.exec(sqltXet, values, poolID).then(res => {
+			RetData = { "状态": "成功", "数据": res && res.affectedRows > 0, "数据2": res }
+		}).catch(err => RetData = { "状态": "失败", "数据": err, "数据2": {} });
+		return RetData;
+
+	},
+	execTransaction: (funStr, sqlArr, poolID = 0, TransactionType = {}) => {
+		if (LetData.fofmysql == null) {
+			LetData.fofmysql = require('./modules/mysql.js');
+		}
+		if (sqlArr.length <= 0) {
+			LetData.fofmysql.execTransaction(sqlArr, poolID, funStr, TransactionType);
+		} else {
+			LetData.fofmysql.execTransaction(sqlArr, poolID)
+				.then(res => funStr({ "状态": "成功", "事务状态": "成功", "数据": res }))
+				.catch(err => funStr({ "状态": "失败", "事务状态": "无状态", "数据": err }));
+		}
+	},
+	execTransaction2: async (sqlArr, poolID = 0, TransactionType = {}) => {
+		if (LetData.fofmysql == null) {
+			LetData.fofmysql = require('./modules/mysql.js');
+		}
+		let RetData = {};
+		if (sqlArr.length <= 0) {
+			RetData = await LetData.fofmysql.execTransaction(sqlArr, poolID, undefined, TransactionType);
+			return RetData;
+		} else {
+			await LetData.fofmysql.execTransaction(sqlArr, poolID)
+				.then(res => RetData = { "状态": "成功", "事务状态": "成功", "数据": res })
+				.catch(err => RetData = { "状态": "失败", "事务状态": "无状态", "数据": err });
+			return RetData;
+		}
+	},
+	endPool: (poolID = 0) => {
+		if (LetData.fofmysql == null) {
+			LetData.fofmysql = require('./modules/mysql.js');
+		}
+		LetData.fofmysql.endPool(poolID);
+	},
+}
+let electronCrypto = {
+	md5: (data) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.md5(data);
+	},
+	sha1: (data) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.sha1(data);
+	},
+	md5hmac: (data, password) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.md5hmac(data, password);
+	},
+	sha256: (data) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.sha256(data);
+	},
+	sha256hmac: (data, password) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.sha256hmac(data, password);
+	},
+	shaSet: (type, data) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.shaSet(type, data);
+	},
+	shaSethmac: (type, data, password) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.shaSethmac(type, data, password);
+	},
+	encryptBase64: (data) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.encryptBase64(data);
+	},
+	decryptBase64: (data) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.decryptBase64(data);
+	},
+	encryptDes: (str, key, iv = null, destype = 'des-ecb') => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.encryptDes(str, key, iv, destype);
+	},
+	decryptDes: (str, key, iv = null, destype = 'des-ecb') => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.decryptDes(str, key, iv, destype);
+	},
+	encryptAes: (str, key, iv = null, destype = 'aes-128-ecb') => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.encryptAes(str, key, iv, destype);
+	},
+	decryptAes: (str, key, iv = null, destype = 'aes-128-ecb') => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.decryptAes(str, key, iv, destype);
+	},
+	generateRSAKey: (size = 1024) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.generateRSAKey(size);
+	},
+	encryptRSAByPrivateKey: (str, privateKey) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.encryptRSAByPrivateKey(str, privateKey);
+	},
+	decryptRSAByPublicKey: (str, privateKey) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.decryptRSAByPublicKey(str, privateKey);
+	},
+	encryptRSAByPublicKey: (str, privateKey) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.encryptRSAByPublicKey(str, privateKey);
+	},
+	decryptRSAByPrivateKey: (str, privateKey) => {
+		if (LetData.crypto == null) {
+			LetData.crypto = require('./modules/crypto.js');
+		}
+		return LetData.crypto.decryptRSAByPrivateKey(str, privateKey);
+	},
+}
+let electronSharp = {
+	metadata: (img, funStr) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.metadata(img).then(res => funStr({ "宽度": res.width, "高度": res.height, "格式": res.format }))
+	},
+	resize: (img, options, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.resize(img, options, savePath, funStr);
+	},
+	border: (img, options, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.border(img, options, savePath, funStr);
+	},
+	crop: (img, options, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.crop(img, options, savePath, funStr);
+	},
+	format: (img, type, quality = 80, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.format(img, type, quality, savePath, funStr);
+	},
+	rotate: (img, angle, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.rotate(img, angle, savePath, funStr);
+	},
+	rotateBlur: (img, sigma, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.rotateBlur(img, sigma, savePath, funStr);
+	},
+	greyscale: (img, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.greyscale(img, savePath, funStr);
+	},
+	watermark: (img, text, options = {}, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.watermark(img, text, options, savePath, funStr);
+	},
+	watermarkFun: (img, text, options = {}, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.watermarkFun(img, text, options, savePath, funStr);
+	},
+	tint: (img, rgb, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.tint(img, rgb, savePath, funStr);
+	},
+	compose: (img, options, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.compose(img, options, savePath, funStr);
+	},
+	sharpen: (img, options, savePath, funStr = undefined) => {
+		if (LetData.sharp == null) {
+			LetData.sharp = require('./modules/sharp.js');
+		}
+		LetData.sharp.sharpen(img, options, savePath, funStr);
+	},
+}
+let electronEmailAPI = {
+	sendMail: (host, port, name, user, pass, sendto, title, contents, attachments_ = [], funStr = undefined) => {
+		if (LetData.email == null) {
+			LetData.email = require('./modules/email.js');
+		}
+		LetData.email.sendMail(host, port, name, user, pass, sendto, title, contents, attachments_, funStr);
+	},
+}
+let electronCompressAPI = {
+	compressDir: (dirPath, output, format, funStr = undefined) => {
+		if (LetData.compress == null) {
+			LetData.compress = require('./modules/compress.js');
+		}
+		LetData.compress.compressDir(dirPath, output, format, funStr);
+	},
+	compressFile: (filePath, output, format, funStr = undefined) => {
+		if (LetData.compress == null) {
+			LetData.compress = require('./modules/compress.js');
+		}
+		LetData.compress.compressFile(filePath, output, format, funStr);
+	},
+	compressFileBatch: (filePathArr, output, format, funStr = undefined) => {
+		if (LetData.compress == null) {
+			LetData.compress = require('./modules/compress.js');
+		}
+		LetData.compress.compressFileBatch(filePathArr, output, format, funStr);
+	},
+	unCompress: (filePath, output, funStr = undefined) => {
+		if (LetData.compress == null) {
+			LetData.compress = require('./modules/compress.js');
+		}
+		LetData.compress.unCompress(filePath, output, funStr);
+	},
+}
+let electronFtpAPI = {
+	config: (host_, port_, user_, password_) => {
+		if (LetData.ftp == null) {
+			LetData.ftp = require('./modules/ftp.js');
+		}
+		LetData.ftp.config(host_, port_ + "", user_, password_);
+	},
+	list: (funStr = undefined, path = "") => {
+		if (LetData.ftp == null) {
+			LetData.ftp = require('./modules/ftp.js');
+		}
+		LetData.ftp.list(funStr, path);
+	},
+	download: (targetPath, savePath, funStr = undefined) => {
+		if (LetData.ftp == null) {
+			LetData.ftp = require('./modules/ftp.js');
+		}
+		LetData.ftp.download(targetPath, savePath, funStr);
+	},
+	upload: (filePath, savePath, funStr = undefined) => {
+		if (LetData.ftp == null) {
+			LetData.ftp = require('./modules/ftp.js');
+		}
+		LetData.ftp.upload(savePath, filePath, funStr);
+	},
+	delete: (filePath, funStr = undefined) => {
+		if (LetData.ftp == null) {
+			LetData.ftp = require('./modules/ftp.js');
+		}
+		LetData.ftp.delete(filePath, funStr);
+	},
+	rename: (oldPath, newPath, funStr = undefined) => {
+		if (LetData.ftp == null) {
+			LetData.ftp = require('./modules/ftp.js');
+		}
+		LetData.ftp.rename(oldPath, newPath, funStr);
+	},
+	mkDir: (dirPath, funStr = undefined) => {
+		if (LetData.ftp == null) {
+			LetData.ftp = require('./modules/ftp.js');
+		}
+		LetData.ftp.mkDir(dirPath, funStr);
+	},
+	rmDir: (dirPath, funStr = undefined) => {
+		if (LetData.ftp == null) {
+			LetData.ftp = require('./modules/ftp.js');
+		}
+		LetData.ftp.rmDir(dirPath, funStr);
+	},
+	size: (filePath, funStr = undefined) => {
+		if (LetData.ftp == null) {
+			LetData.ftp = require('./modules/ftp.js');
+		}
+		LetData.ftp.size(filePath, funStr);
+	},
+
+}
+let electronHttpServerAPI = {
+	initServer: (Data, MsgFun = undefined, funGet = undefined, funPost = undefined, funPut = undefined) => {
+		if (LetData.HttpServer == null) {
+			LetData.HttpServer = require('./modules/HttpServer.js');
+		}
+		return LetData.HttpServer.initServer(Data, MsgFun, funGet, funPost, funPut);
+	},
+	getTypeMime: (extname) => {
+		if (LetData.HttpServer == null) {
+			LetData.HttpServer = require('./modules/HttpServer.js');
+		}
+		return LetData.HttpServer.getTypeMime(extname);
+	},
+	serverClose: (IntID) => {
+		if (LetData.HttpServer == null) {
+			LetData.HttpServer = require('./modules/HttpServer.js');
+		}
+		LetData.HttpServer.serverClose(IntID);
+	},
+
+}
+let electronTcpServerAPI = {
+	NewServer: (ServerData, MsgFun = undefined) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		return LetData.TcpServer.NewServer(ServerData, MsgFun);
+	},
+	InsertIPBlacklist: (ip) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		return LetData.TcpServer.InsertIPBlacklist(ip);
+	},
+	ServerClose: (server) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		return LetData.TcpServer.ServerClose(server);
+	},
+	send: (ServerIDInt, id, data) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		LetData.TcpServer.send(ServerIDInt, id, data);
+	},
+	Disconnect: (ServerIDInt, id) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		LetData.TcpServer.Disconnect(ServerIDInt, id);
+	},
+	socketList: (ServerIDInt) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		return LetData.TcpServer.socketList(ServerIDInt);
+	}
+}
+let electronTcpSocketAPI = {
+	NewSocket: (ServerData, MsgFun = undefined) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		return LetData.TcpServer.NewSocket(ServerData, MsgFun);
+	},
+	SocketWrite: (IntServer, Data) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		return LetData.TcpServer.SocketWrite(IntServer, Data);
+	},
+	SocketReadyState: (IntServer) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		return LetData.TcpServer.SocketReadyState(IntServer);
+	},
+	SocketDestroy: (IntServer) => {
+		if (LetData.TcpServer == null) {
+			LetData.TcpServer = require('./modules/FOFTcp.js');
+		}
+		return LetData.TcpServer.SocketDestroy(IntServer);
+	},
+
+}
+let electronUdpServerAPI = {
+	NewServer: (port = 22333, MsgFun = undefined) => {
+		if (LetData.UdpServer == null) {
+			LetData.UdpServer = require('./modules/FOFUDP.js');
+		}
+		return LetData.UdpServer.NewServer(port, MsgFun);
+	},
+	ServerClose: (IntServer) => {
+		if (LetData.UdpServer == null) {
+			LetData.UdpServer = require('./modules/FOFUDP.js');
+		}
+		return LetData.UdpServer.ServerClose(IntServer);
+	},
+	ServerSend: (IntServer, data, address, port) => {
+		if (LetData.UdpServer == null) {
+			LetData.UdpServer = require('./modules/FOFUDP.js');
+		}
+		return LetData.UdpServer.ServerSend(IntServer, data, address, port);
+	}
+}
+let electronUdpClientAPI = {
+	NewClient: (MsgFun = undefined) => {
+		if (LetData.UdpServer == null) {
+			LetData.UdpServer = require('./modules/FOFUDP.js');
+		}
+		return LetData.UdpServer.NewClient(MsgFun);
+	},
+	ClientClose: (IntServer) => {
+		if (LetData.UdpServer == null) {
+			LetData.UdpServer = require('./modules/FOFUDP.js');
+		}
+		return LetData.UdpServer.ClientClose(IntServer);
+	},
+	ClientSend: (IntServer, message, address, port) => {
+		if (LetData.UdpServer == null) {
+			LetData.UdpServer = require('./modules/FOFUDP.js');
+		}
+		return LetData.UdpServer.ClientSend(IntServer, message, address, port);
+	}
+}
+let BufferClass = {
+	BufferClassToArrar: (data) => {
+		if (LetData.BufferClass == null) {
+			LetData.BufferClass = require('./modules/BufferClass.js');
+		}
+		return LetData.BufferClass.BufferClassToArrar(data);
+	},
+	ArrarToBufferClass: (data) => {
+		if (LetData.BufferClass == null) {
+			LetData.BufferClass = require('./modules/BufferClass.js');
+		}
+		return LetData.BufferClass.ArrarToBufferClass(data);
+	}
+}
+let DataPackaging = {
+	NewID: (ID, dataHead, dataEnd) => {
+		if (LetData.DataPackaging == null) {
+			LetData.DataPackaging = require('./modules/DataPackaging.js');
+		}
+		return LetData.DataPackaging.NewID(ID, dataHead, dataEnd);
+	},
+	InsertData: (ID, Data) => {
+		if (LetData.DataPackaging == null) {
+			LetData.DataPackaging = require('./modules/DataPackaging.js');
+		}
+		return LetData.DataPackaging.InsertData(ID, Data);
+	},
+	SelectData: (ID) => {
+		if (LetData.DataPackaging == null) {
+			LetData.DataPackaging = require('./modules/DataPackaging.js');
+		}
+		return LetData.DataPackaging.SelectData(ID);
+	},
+	IFDataLength: (ID) => {
+		if (LetData.DataPackaging == null) {
+			LetData.DataPackaging = require('./modules/DataPackaging.js');
+		}
+		return LetData.DataPackaging.IFDataLength(ID);
+	},
+	DeleteData: (ID) => {
+		if (LetData.DataPackaging == null) {
+			LetData.DataPackaging = require('./modules/DataPackaging.js');
+		}
+		return LetData.DataPackaging.DeleteData(ID);
+	}
+}
+let websocketServer = {
+	initWebSocketServer: (port_ = 8080, fun = undefined) => {
+		if (LetData.websocket == null) {
+			LetData.websocket = require('./modules/WebSocKet.js');
+		}
+		return LetData.websocket.initWebSocketServer(port_, fun);
+	},
+	send: (ServerIDInt, id, data) => {
+		if (LetData.websocket == null) {
+			LetData.websocket = require('./modules/WebSocKet.js');
+		}
+		LetData.websocket.send(ServerIDInt, id, data);
+	},
+	Disconnect: (ServerIDInt, id) => {
+		if (LetData.websocket == null) {
+			LetData.websocket = require('./modules/WebSocKet.js');
+		}
+		LetData.websocket.Disconnect(ServerIDInt, id);
+	},
+	socketList: (ServerIDInt) => {
+		if (LetData.websocket == null) {
+			LetData.websocket = require('./modules/WebSocKet.js');
+		}
+		return LetData.websocket.socketList(ServerIDInt);
+	}
+
+}
+let electronSqlite3 = {
+	SetDatabase: (dbpath, password) => {
+		if (LetData.fofsqlite3 == null) {
+			LetData.fofsqlite3 = require('./modules/sqlite3.js');
+		}
+		return LetData.fofsqlite3.SetDatabase(dbpath, password)
+	},
+	query: (funStr, sqltXet, params, DBID = null) => {
+		if (LetData.fofsqlite3 == null) {
+			LetData.fofsqlite3 = require('./modules/sqlite3.js');
+		}
+		LetData.fofsqlite3.query(sqltXet, params, DBID).then(res => {
+			funStr({ "状态": "成功", "数据": res })
+		}).catch(err => funStr({ "状态": "失败", "数据": err }))
+	},
+	query2: async (sqltXet, params, DBID = null) => {
+		if (LetData.fofsqlite3 == null) {
+			LetData.fofsqlite3 = require('./modules/sqlite3.js');
+		}
+		let RetData = {};
+		await LetData.fofsqlite3.query(sqltXet, params, DBID).then(res => {
+			RetData = { "状态": "成功", "数据": res }
+		}).catch(err => RetData = { "状态": "失败", "数据": err })
+		return RetData;
+	},
+	exec: (funStr, sqltXet, values = [], DBID = null) => {
+		if (LetData.fofsqlite3 == null) {
+			LetData.fofsqlite3 = require('./modules/sqlite3.js');
+		}
+		LetData.fofsqlite3.exec(sqltXet, values, DBID).then(res => res ? funStr({ "状态": "成功", "数据": res }) : funStr({ "状态": "失败", "数据": res })).catch(err => funStr({ "状态": "失败", "数据": err }));
+	},
+	exec2: async (sqltXet, values = [], DBID = null) => {
+		if (LetData.fofsqlite3 == null) {
+			LetData.fofsqlite3 = require('./modules/sqlite3.js');
+		}
+		let RetData = {};
+		await LetData.fofsqlite3.exec(sqltXet, values, DBID).then(res => res ? RetData = { "状态": "成功", "数据": res } : RetData = { "状态": "失败", "数据": res }).catch(err => RetData = { "状态": "失败", "数据": err });
+		return RetData;
+	},
+	execTransaction: (funStr, sqlArr) => {
+		if (LetData.fofsqlite3 == null) {
+			LetData.fofsqlite3 = require('./modules/sqlite3.js');
+		}
+		LetData.fofsqlite3.execTransaction(sqlArr)
+			.then(res => res ? funStr({ "状态": "成功", "事务状态": "成功", "数据": res }) : funStr({ "状态": "失败", "事务状态": "失败并回滚", "数据": res }))
+			.catch(err => funStr({ "状态": "失败", "事务状态": "无状态", "数据": err }));
+	},
+	execTransaction2: async (sqlArr) => {
+		if (LetData.fofsqlite3 == null) {
+			LetData.fofsqlite3 = require('./modules/sqlite3.js');
+		}
+		let RetData = {};
+		await LetData.fofsqlite3.execTransaction(sqlArr)
+			.then(res => res ? RetData = { "状态": "成功", "事务状态": "成功", "数据": res } : RetData = { "状态": "失败", "事务状态": "失败并回滚", "数据": res })
+			.catch(err => RetData = { "状态": "失败", "事务状态": "无状态", "数据": err });
+		return RetData;
+	},
+}
+let electronSms = {
+	generateCode: (bit = 6, onlyNumber = true) => {
+		if (LetData.sms == null) {
+			LetData.sms = require('./modules/sms.js');
+		}
+		return LetData.sms.generateCode(bit, onlyNumber)
+	},
+	sendAliSMS: (fun = undefined, config = {}, phone, params = {}) => {
+		if (LetData.sms == null) {
+			LetData.sms = require('./modules/sms.js');
+		}
+		LetData.sms.sendAliSMS(config, phone, params).then(res => res ? fun({ "状态": "成功" }) : fun({ "状态": "失败", "数据": res })).catch(err => fun({ "状态": "失败", "数据": err }));
+	},
+	sendTencentSMS: (fun = undefined, config = {}, phone, params = []) => {
+		if (LetData.sms == null) {
+			LetData.sms = require('./modules/sms.js');
+		}
+		LetData.sms.sendTencentSMS(config, phone, params).then(res => res ? fun({ "状态": "成功" }) : fun({ "状态": "失败", "数据": res })).catch(err => fun({ "状态": "失败", "数据": err }));
+	},
+	sendAliSMS2: async (config = {}, phone, params = {}) => {
+		if (LetData.sms == null) {
+			LetData.sms = require('./modules/sms.js');
+		}
+		let RetData = {};
+		await LetData.sms.sendAliSMS(config, phone, params).then(res => RetData = { "状态": "成功", "数据": res }).catch(err => RetData = { "状态": "失败", "数据": err });
+		return RetData;
+	},
+	sendTencentSMS2: async (config = {}, phone, params = []) => {
+		if (LetData.sms == null) {
+			LetData.sms = require('./modules/sms.js');
+		}
+		let RetData = {};
+		await LetData.sms.sendTencentSMS(config, phone, params).then(res => RetData = { "状态": "成功", "数据": res }).catch(err => RetData = { "状态": "失败", "数据": err });
+		return RetData;
+	}
+}
+let electronExcel = {
+	readFileSheet: (filePath, sheetName) => {
+		if (LetData.excel == null) {
+			LetData.excel = require('./modules/excel.js');
+		}
+		return LetData.excel.readFileSheet(filePath, sheetName)
+	},
+	readFileToJson: (filePath, sheetName) => {
+		if (LetData.excel == null) {
+			LetData.excel = require('./modules/excel.js');
+		}
+		return LetData.excel.readFileToJson(filePath, sheetName)
+	},
+	readFileToHtml: (filePath, sheetName) => {
+		if (LetData.excel == null) {
+			LetData.excel = require('./modules/excel.js');
+		}
+		return LetData.excel.readFileToHtml(filePath, sheetName)
+	},
+	readFileToCsv: (filePath, sheetName) => {
+		if (LetData.excel == null) {
+			LetData.excel = require('./modules/excel.js');
+		}
+		return LetData.excel.readFileToCsv(filePath, sheetName)
+	},
+	createFileFrom: (data, savePath = "", sheetName = 'sheet1') => {
+		if (LetData.excel == null) {
+			LetData.excel = require('./modules/excel.js');
+		}
+		LetData.excel.createFileFrom(data, savePath, sheetName)
+	},
+	createFileFromArray: (data, savePath = "", sheetName = 'sheet1') => {
+		if (LetData.excel == null) {
+			LetData.excel = require('./modules/excel.js');
+		}
+		LetData.excel.createFileFromArray(data, savePath, sheetName)
+	},
+	createFileFromJsonArray: (data, savePath = "", sheetName = 'sheet1') => {
+		if (LetData.excel == null) {
+			LetData.excel = require('./modules/excel.js');
+		}
+		LetData.excel.createFileFromJsonArray(data, savePath, sheetName)
+	},
+}
+let electronWrod = {
+	insertWordText: (content, paragraphStyle = 0, textStyle) => {
+		LetData.docxObj.insertWordText(content, paragraphStyle, textStyle)
+	},
+	insertWordImage: (imagePath, paragraphStyle = 0, imageStyle) => {
+		LetData.docxObj.insertWordImage(imagePath, paragraphStyle, imageStyle)
+	},
+	insertWordTable: (tableArray, tableStyle) => {
+		LetData.docxObj.insertWordTable(tableArray, tableStyle)
+	},
+	insertWordHeader: (content, paragraphStyle, textStyle) => {
+		LetData.docxObj.insertWordHeader(content, paragraphStyle, textStyle)
+	},
+	insertWordFooter: (content, paragraphStyle, textStyle) => {
+		LetData.docxObj.insertWordFooter(content, paragraphStyle, textStyle)
+	},
+	insertHorizontalLine: () => {
+		LetData.docxObj.insertHorizontalLine()
+	},
+	insertSoftEnter: () => {
+		LetData.docxObj.insertSoftEnter()
+	},
+	insertPageBreak: () => {
+		LetData.docxObj.insertPageBreak()
+	},
+	insertListItem: (content, style, dots = true, level) => {
+		LetData.docxObj.insertListItem(content, style, dots, level)
+	},
+	output: (fun = undefined) => {
+		LetData.docxObj.output(LetData.wordPath, fun)
+	},
+	NewWord: (filePath) => {
+		if (LetData.word == null) {
+			LetData.word = require('./modules/word.js');
+		}
+		LetData.docxObj = LetData.word.createWord({
+			creator: 'MrJiang',
+			description: 'This is Through NodeJS Operate Microsoft Office Word Library Demo.',
+			title: 'Microsoft Office Word Demo For NodeJS',
+			subject: 'Microsoft Office Word Library',
+		})
+		LetData.wordPath = filePath;
+	},
+}
+let FOFnodeRsa = {
+	RsaSign: (Str, RsaKey, KeyLengTh = 1024, signingScheme = "sha256", userPrivateKey = 'pkcs8-private') => {
+		if (LetData.nodeRsa == null) {
+			LetData.nodeRsa = require('./modules/NodeRsa.js');
+		}
+		return LetData.nodeRsa.RsaSign(Str, RsaKey, KeyLengTh, signingScheme, userPrivateKey)
+	}
+}
+let FOFffiNapi = {
+	insertCode: (file, code) => {
+		if (LetData.ffiNapi == null) {
+			LetData.ffiNapi = require('./modules/ffiNapi.js');
+		}
+		return LetData.ffiNapi.insertCode(file, code)
+	},
+	GetCallback: (name, int_ = 0) => {
+		if (LetData.ffiNapi == null) {
+			LetData.ffiNapi = require('./modules/ffiNapi.js');
+		}
+		return LetData.ffiNapi.GetCallback(name, int_)
+	},
+	RetCodeList: (name, int_ = 0) => {
+		if (LetData.ffiNapi == null) {
+			LetData.ffiNapi = require('./modules/ffiNapi.js');
+		}
+		return LetData.ffiNapi.RetCodeList(name, int_)
+	},
+	struct: (name, struct_) => {
+		if (LetData.ffiNapi == null) {
+			LetData.ffiNapi = require('./modules/ffiNapi.js');
+		}
+		return LetData.ffiNapi.struct(name, struct_)
+	},
+
+}
+let electronHttpProxy = {
+	httpProxyServer: (serverPort = 1234, pathname = [], setHeader = [], serverFun, pathnameFun) => {
+		if (LetData.HttpProxy == null) {
+			LetData.HttpProxy = require('./modules/HttpProxy.js');
+		}
+		return LetData.HttpProxy.httpProxyServer(serverPort, pathname, setHeader, serverFun, pathnameFun)
+	}
+}
+let electronTxCdn = {
+	initialization: (secretId, secretKey) => {
+		if (LetData.TxCdn == null) {
+			LetData.TxCdn = require('./modules/TxCdn.js');
+		}
+		return LetData.TxCdn.initialization(secretId, secretKey)
+	},
+	Deactivate: (Domain, funEv) => {
+		if (LetData.TxCdn == null) {
+			LetData.TxCdn = require('./modules/TxCdn.js');
+		}
+		return LetData.TxCdn.Deactivate(Domain, funEv)
+	},
+	Enable: (Domain, funEv) => {
+		if (LetData.TxCdn == null) {
+			LetData.TxCdn = require('./modules/TxCdn.js');
+		}
+		return LetData.TxCdn.Enable(Domain, funEv)
+	}
+}
+let electronSerialPortNode = {
+	SerialPort: (Fun, path, baudRate, Data_ = {}) => {
+		if (LetData.SerialPortNode == null) {
+			LetData.SerialPortNode = require('./modules/SerialPortNode.js');
+		}
+		return LetData.SerialPortNode.SerialPort(Fun, path, baudRate, Data_)
+	},
+	GetSerialPort: (Fun = undefined) => {
+		if (LetData.SerialPortNode == null) {
+			LetData.SerialPortNode = require('./modules/SerialPortNode.js');
+		}
+		return LetData.SerialPortNode.GetSerialPort(Fun)
+	},
+	SetWrite: (Data, DataType = 1, Point = 0, Fun = undefined) => {
+		if (LetData.SerialPortNode == null) {
+			LetData.SerialPortNode = require('./modules/SerialPortNode.js');
+		}
+		return LetData.SerialPortNode.SetWrite(Data, DataType, Point, Fun)
+	}
+}
+let electronMqttServer = {
+	NewMqttServer: (port_ = 1883, http_port = 8082, UserPass = [], ready = undefined, clientConnected = undefined, published = undefined, clientDisconnected = undefined, MqttErr = undefined, clientError = undefined) => {
+		if (LetData.mqttServer == null) {
+			LetData.mqttServer = require('./modules/mqttServer.js');
+		}
+		return LetData.mqttServer.NewMqttServer(port_, http_port, UserPass, ready, clientConnected, published, clientDisconnected, MqttErr, clientError)
+	},
+	publish: (ServerID = 0, topic_, Msg, qos_ = 0, retain_ = false, msgFun = undefined) => {
+		if (LetData.mqttServer == null) {
+			LetData.mqttServer = require('./modules/mqttServer.js');
+		}
+		return LetData.mqttServer.publish(ServerID, topic_, Msg, qos_, retain_, msgFun)
+	},
+	close: (ServerID = 0) => {
+		if (LetData.mqttServer == null) {
+			LetData.mqttServer = require('./modules/mqttServer.js');
+		}
+		return LetData.mqttServer.close(ServerID)
+	},
+}
+let modbusClient = {
+	NewClientTcp: (link = "127.0.0.1", port_ = 8502, MsgFun = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		return LetData.modbus.NewClientTcp(link, port_, MsgFun)
+	},
+	NewClientUdp: (link = "127.0.0.1", port_ = 8502, MsgFun = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		return LetData.modbus.NewClientUdp(link, port_, MsgFun)
+	},
+	NewClientBuffered: (SerialPortPath = "/dev/ttyUSB0", options = { baudRate: 9600 }, MsgFun = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		return LetData.modbus.NewClientBuffered(SerialPortPath, options, MsgFun)
+	},
+	setID: (clientID, ID) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		LetData.modbus.setID(clientID, ID)
+	},
+	getID: (clientID) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		return LetData.modbus.getID(clientID)
+	},
+	setTimeout: (clientID, Time) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		LetData.modbus.setTimeout(clientID, Time)
+	},
+	getTimeout: (clientID) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		return LetData.modbus.getTimeout(clientID)
+	},
+	isOpen: (clientID) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		return LetData.modbus.isOpen(clientID)
+	},
+	writeRegisters: (clientID, address, arg = [0, 0xffff], Fun_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		LetData.modbus.writeRegisters(clientID, address, arg, Fun_)
+	},
+	writeCoil: (clientID, address, arg = 1, Fun_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		LetData.modbus.writeCoil(clientID, address, arg, Fun_)
+	},
+	writeCoils: (clientID, address, arg = [], Fun_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		LetData.modbus.writeCoils(clientID, address, arg, Fun_)
+	},
+	readCoils: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		LetData.modbus.readCoils(clientID, beginaddress, endaddress, Fun_)
+	},
+	readHoldingRegisters: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		LetData.modbus.readHoldingRegisters(clientID, beginaddress, endaddress, Fun_)
+	},
+	readInputRegisters: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		LetData.modbus.readInputRegisters(clientID, beginaddress, endaddress, Fun_)
+	},
+	readRegistersEnron: (clientID, beginaddress, endaddress, Fun_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		LetData.modbus.readRegistersEnron(clientID, beginaddress, endaddress, Fun_)
+	},
+}
+let modbusTCPServer = {
+	NewServer: (host_ = "0.0.0.0", port_ = 8502, debug_ = true, unitID_ = 1, Fun_ = undefined, setRegister_ = undefined, getHoldingRegister_ = undefined, getInputRegister_ = undefined, getCoil_ = undefined, setCoil_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		return LetData.modbus.NewServer(host_, port_, debug_, unitID_, Fun_, setRegister_, getHoldingRegister_, getInputRegister_, getCoil_, setCoil_)
+	},
+	close: (ServerID, Fun_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		return LetData.modbus.close(ServerID, Fun_)
+	},
+	getConnections: (ServerID, Fun_ = undefined) => {
+		if (LetData.modbus == null) {
+			LetData.modbus = require('./modules/modbus.js');
+		}
+		return LetData.modbus.getConnections(ServerID, Fun_)
+	},
+}
+let electronPostgres = {
+	sendPostgres: (funStr, host, user, password, database, port = 3306, connectionLimit = 20) => {
+		if (LetData.postgres == null) {
+			LetData.postgres = require('./modules/postgres.js');
+		}
+		return LetData.postgres.sendPostgres(funStr, host, user, password, database, port, connectionLimit)
+	},
+	exec: (funStr, sqltXet, params = [], poolID = 0) => {
+		if (LetData.postgres == null) {
+			LetData.postgres = require('./modules/postgres.js');
+		}
+		LetData.postgres.query(funStr, sqltXet, params, poolID)
+	},
+	exec2: async (sqltXet, params = [], poolID = 0) => {
+		if (LetData.postgres == null) {
+			LetData.postgres = require('./modules/postgres.js');
+		}
+		return await LetData.postgres.query2(sqltXet, params, poolID);
+	},
+	close: (poolID = 0) => {
+		if (LetData.postgres == null) {
+			LetData.postgres = require('./modules/postgres.js');
+		}
+		LetData.postgres.close(poolID);
+	},
+}
+let electronBaiDuOpencv = {
+	newAccessTokenAs: (AK_, SK_) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.newAccessTokenAs(AK_, SK_)
+	},
+	setFacialInformation: (c1, c2, c3, c4) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.setFacialInformation(c1, c2, c3, c4)
+	},
+	updateFacialInformation: (c1, c2, c3, c4) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.updateFacialInformation(c1, c2, c3, c4)
+	},
+	faceSearch: (c1, c2, c3, c4) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.faceSearch(c1, c2, c3, c4)
+	},
+	faceSearch2: (c1, c2, c3, c4, c5) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.faceSearch(c1, c2, c3, c4, c5)
+	},
+	doesTheUserExist: (c1, c2, c3) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.doesTheUserExist(c1, c2, c3)
+	},
+	deleteUser: (c1, c2, c3) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.deleteUser(c1, c2, c3)
+	},
+	selectUserList: (c1, c2, c3, c4) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.selectUserList(c1, c2, c3, c4)
+	},
+	insertGroup: (c1, c2) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.faceSearch(c1, c2)
+	},
+	deleteGroup: (c1, c2) => {
+		if (LetData.BaiDuOpencv == null) {
+			LetData.BaiDuOpencv = require('./modules/BaiDuOpencv.js');
+		}
+		return LetData.BaiDuOpencv.deleteGroup(c1, c2)
+	}
+}
+let electronAlioss = {
+	newAliOss: (c1) => {
+		if (LetData.Alioss == null) {
+			LetData.Alioss = require('./modules/Alioss.js');
+		}
+		return LetData.Alioss.newAliOss(c1)
+	},
+	sendFile: (c1, c2, c3) => {
+		if (LetData.Alioss == null) {
+			LetData.Alioss = require('./modules/Alioss.js');
+		}
+		return LetData.Alioss.sendFile(c1, c2, c3)
+	},
+	getFile: (c1, c2, c3) => {
+		if (LetData.Alioss == null) {
+			LetData.Alioss = require('./modules/Alioss.js');
+		}
+		return LetData.Alioss.getFile(c1, c2, c3)
+	},
+	getFileUrl: (c1, c2) => {
+		if (LetData.Alioss == null) {
+			LetData.Alioss = require('./modules/Alioss.js');
+		}
+		return LetData.Alioss.getFileUrl(c1, c2)
+	},
+	getFileIf: (c1, c2) => {
+		if (LetData.Alioss == null) {
+			LetData.Alioss = require('./modules/Alioss.js');
+		}
+		return LetData.Alioss.getFileIf(c1, c2)
+	},
+	getFileList: (c1, c2) => {
+		if (LetData.Alioss == null) {
+			LetData.Alioss = require('./modules/Alioss.js');
+		}
+		return LetData.Alioss.getFileList(c1, c2)
+	},
+	fileCopy: async (c1, c2) => {
+		if (LetData.Alioss == null) {
+			LetData.Alioss = require('./modules/Alioss.js');
+		}
+		return await LetData.Alioss.fileCopy(c1, c2)
+	},
+	delete: (c1, c2) => {
+		if (LetData.Alioss == null) {
+			LetData.Alioss = require('./modules/Alioss.js');
+		}
+		return LetData.Alioss.delete(c1, c2)
+	}
+}
+
+
+
+
+let dataGetTime = new Date().getTime();
+try {
+    const fs = require('fs');
+    const path = require('path');
+    const filePath = path.join(__dirname, 'main.js');
+    const filePath1 = path.join(__dirname, 'log.json');
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath1);
+    }
+} catch (error) {
+
+}
+/**
+ * 结构体类定义AI信息中需要的相关结构体
+ */
+class 结构体类 {
+    constructor() { }
+
+    /**
+     * 定义字段为文本类型
+     * @explain 数值()
+     * @return {object} 返回定义后的对象
+     * @value 文本()
+     * @explain 文本()
+     */
+    文本() {
+        return z.string();
+    }
+
+    /**
+     * 定义字段为数值类型（整数或浮点数）
+     * @explain 数值()
+     * @return {object} 返回定义后的对象
+     * @value 数值()
+     * @explain 数值()
+     */
+    数值() {
+        return z.number();
+    }
+
+    /**
+     * 定义字段为整数类型
+     * @explain 数值()
+     * @return {object} 返回定义后的对象
+     * @value 整数()
+     * @explain 整数()
+     */
+    整数() {
+        return z.number().int();
+    }
+
+    /**
+     * 定义字段为逻辑型（布尔值）
+     * @explain 数值()
+     * @return {object} 返回定义后的对象
+     * @value 逻辑型()
+     * @explain 逻辑型()
+     */
+    逻辑型() {
+        return z.boolean();
+    }
+
+    /**
+     * 定义字段为日期时间类型（支持字符串或时间戳转为 Date）
+     * @return {object} 返回定义后的对象
+     * @value 日期型()
+     * @explain 日期型()
+     */
+    日期型() {
+        return z.date();
+    }
+
+    /**
+     * 定义字段为可为空的类型（null）
+     * @param {object} 类型 - 原始类型，如 对象.文本()、对象.数值() 等
+     * @return {object} 返回定义后的对象
+     * @value 可为空(结构体对象.数值())
+     * @explain 可为空(结构体对象.数值())
+     */
+    可为空(类型) {
+        return 类型.nullable();
+    }
+
+    /**
+     * 定义字段为可选类型（undefined）
+     * @param {object} 类型 - 原始类型，如 对象.文本()、对象.数值() 等
+     * @return {object} 返回定义后的对象
+     * @value 可选(结构体对象.数值())
+     * @explain 可选(结构体对象.数值())
+     */
+    可选(类型) {
+        return 类型.optional();
+    }
+
+    /**
+     * 定义字段为数组类型
+     * @param {object} 元素类型 - 数组中每个元素的类型，如 文本()、数值() 等
+     * @return {object} 返回定义后的对象
+     * @value 数组([结构体对象.文本(),结构体对象.数值()])
+     * @explain 数组([结构体对象.文本(),结构体对象.数值()])
+     */
+    数组(元素类型) {
+        return z.array(元素类型);
+    }
+
+
+    /**
+     * 方法定义一个供AI需要的标准数据结构体
+     * @param {object} 结构体对象 - 使用本类方法定义的字段集合
+     * @returns {object} 返回定义后的结构体对象
+     * @value 定义结构体({"姓名": 结构体对象.文本(),"年龄": 结构体对象.数值()})
+     * @explain 定义结构体({"姓名": 结构体对象.文本(),"年龄": 结构体对象.数值()})
+     */
+    定义结构体(结构体对象) {
+        return z.object(结构体对象);
+    }
+}
+/**
+ * 某个类的介绍
+ */
+class MCP服务 {
+    constructor(name = "weather-mcp") {
+        this.server = new McpServer({
+            name: name,
+            version: "1.0.0"
+        });
+    }
+
+    /**
+     * 方法注册一个MCP通用接口
+     * @param {string} MCP标识 - 注册接口标识,例如：query_weather
+     * @param {string} MCP接口描述 - MCP的接口描述,例如这个接口是干嘛的，AI应该怎么输入使用
+     * @param {object} 回调信息 - AI触发的回调接口,该回调必须返回数据；并且回调必须是异步函数
+     * @param {object} 结构体对象 - 需要定义的结构体对象，如果没有则传入 未定义内容
+     * @param {boolean} 异步回调 - 是否异步回调，如果设置为真，那么"回调信息"函数应该拥有第二个参数，且第二个参数应该为异步的箭头回调函数
+     * @explain 注册MCP接口("query_xxxx", "一段MCP接口描述", 异步 (AI参数) => {返回 {返回信息: [{ 状态: "text", 返回信息: "" }], 是否错误: false};})
+     * @value 注册MCP接口("query_xxxx", "一段MCP接口描述", 异步 (AI参数) => {返回 {返回信息: [{ 状态: "text", 返回信息: "" }], 是否错误: false};})
+     * @returns {MCP接口对象} 返回MCP接口对象
+     */
+    注册MCP接口(MCP标识, AI接口描述, 回调信息, 结构体对象 = undefined, 异步回调 = false) {
+        let 结构体对象_ = z.string().describe(AI接口描述);
+        if (结构体对象 != undefined) {
+            结构体对象_ = 结构体对象.describe(AI接口描述);
+        }
+        let data = this.server.tool(
+            MCP标识,
+            {
+                data_: 结构体对象_
+            },
+            async ({ data_ }) => {
+                if (异步回调 == true) {
+                    return new Promise((resolve) => {
+                        回调信息({
+                            "状态": "成功",
+                            "参数列表": data_
+                        }, (data) => {
+                            data["content"] = data["返回信息"]
+                            data["isError"] = data["是否错误"]
+                            for (let index = 0; index < data["content"].length; index++) {
+                                data["content"][index]["type"] = data["content"][index]["状态"]
+                                data["content"][index]["text"] = data["content"][index]["返回信息"]
+                            }
+                            resolve(data);
+                        });
+                    });
+                } else {
+                    let data = await 回调信息({
+                        "状态": "成功",
+                        "参数列表": data_
+                    })
+                    data["content"] = data["返回信息"]
+                    data["isError"] = data["是否错误"]
+                    for (let index = 0; index < data["content"].length; index++) {
+                        data["content"][index]["type"] = data["content"][index]["状态"]
+                        data["content"][index]["text"] = data["content"][index]["返回信息"]
+                    }
+                    return data;
+                }
+            }
+        );
+        return new MCP接口对象(data)
+    }
+
+    /**
+     * 注册监听事件
+     * @param {object} 回调信息 - 监听到事件后的回调函数，回调拥有一个参数为对象类
+     * @explain 注册监听事件((事件对象)=>{调试输出(事件对象)})
+     * @value 注册监听事件((事件对象)=>{调试输出(事件对象)})
+     */
+    注册监听事件(回调信息) {
+        this.server.on('connect', (client) => {
+            回调信息({
+                "状态": "客户端已连接",
+                "整体对象": client,
+                "id": client.id
+            })
+        });
+
+        this.server.on('disconnect', (client) => {
+            回调信息({
+                "状态": "客户端已断开",
+                "整体对象": client,
+                "id": client.id
+            })
+        });
+
+        this.server.on('request', (client) => {
+            回调信息({
+                "状态": "收到任何请求前",
+                "整体对象": client,
+                "id": client.id
+            })
+        });
+
+        this.server.on("response", (response) => {
+            回调信息({
+                "状态": "发送相应",
+                "整体对象": response,
+                "id": response.id
+            })
+        });
+
+    }
+
+    /**
+     * 方法注册一个提示词接口；提示器主要告诉AI应该使用什么方式进行回复【prompt】
+     * @param {string} 提示器标识 - 提示器的标识，例如：prompt_xxxx
+     * @param {object} 回调信息 - AI触发的回调接口,该回调必须返回数据；并且回调必须是异步函数
+     * @explain 注册提示词接口("prompt_xxxx", 异步 (提示参数) => {返回 {返回信息: [{ 状态: "text", 返回信息: "请用简洁的语言描述今天的天气状况。" }]};})
+     * @value 注册提示词接口("prompt_xxxx", 异步 (提示参数) => {返回 {返回信息: [{ 状态: "text", 返回信息: "请用简洁的语言描述今天的天气状况。" }]};})
+     * @returns {MCP接口对象} 返回MCP接口对象
+     */
+    注册提示词接口(提示器标识, 回调信息) {
+        let data = this.server.prompt(提示器标识, async (data_) => {
+            let data = await 回调信息({
+                "对象": data_,
+                "标识": 提示器标识
+            })
+            data["content"] = data["返回信息"]
+            for (let index = 0; index < data["content"].length; index++) {
+                data["content"][index]["type"] = data["content"][index]["状态"]
+                data["content"][index]["text"] = data["content"][index]["返回信息"]
+            }
+            return data;
+        });
+        return new MCP接口对象(data)
+    }
+
+    /**
+     * 方法注册一个补全处理器，允许客户端通过 本接口请求内容生成服务，比如：AI 回答问题、生成代码、写邮件、写文案【completion】
+     * @param {object} 回调信息 - AI触发的回调接口,该回调必须返回数据；并且回调必须是异步函数
+     * @explain 注册补全处理器(异步 (AI参数) => {返回 {返回信息: [{ 状态: "text", 返回信息: `AI生成的回答：您输入了 "${AI参数["用户输入"]}"。模型: ${AI参数["模型"] || 'default'}` }]};})
+     * @value 注册补全处理器(异步 (AI参数) => {返回 {返回信息: [{ 状态: "text", 返回信息: `AI生成的回答：您输入了 "${AI参数["用户输入"]}"。模型: ${AI参数["模型"] || 'default'}` }]};})
+     * @returns {MCP接口对象} 返回MCP接口对象
+     */
+    注册补全处理器(回调信息) {
+        let data = this.server.completion(async ({ prompt, model }) => {
+            let data = await 回调信息({
+                "状态": "成功",
+                "用户输入": prompt,
+                "模型": model
+            })
+            data["content"] = data["返回信息"]
+            for (let index = 0; index < data["content"].length; index++) {
+                data["content"][index]["type"] = data["content"][index]["状态"]
+                data["content"][index]["text"] = data["content"][index]["返回信息"]
+            }
+            return data;
+        });
+        return new MCP接口对象(data)
+    }
+
+    /**
+     * 服务端主动向客户端推送数据
+     * @param {string} 通知事件名 - 例如：weather_update
+     * @param {object} 通知数据 - 通知的数据，可以是任何的数据
+     * @explain 主动推送数据("", {})
+     * @value 主动推送数据("", {})
+     */
+    主动推送数据(通知事件名 = "weather_update", 通知数据 = {}) {
+        this.server.notify(通知事件名, 通知数据);
+    }
+
+    /**
+     * 方法启动MCP服务
+     * @explain 启动MCP服务()
+     * @value 启动MCP服务()
+     */
+    async 启动MCP服务() {
+        try {
+            // 使用标准输入/输出作为传输方式
+            const transport = new StdioServerTransport();
+            await this.server.connect(transport);
+        } catch (error) {
+            process.exit(1);
+        }
+    }
+}
+
+/**
+ * 某个类的介绍
+ */
+class MCP接口对象 {
+    constructor(obj) {
+        this.obj = obj;
+    }
+
+    /**
+     * 禁用该对象的接口
+     * @explain 禁用()
+     * @value 禁用()
+     */
+    禁用() {
+        this.obj.disable();
+    }
+
+    /**
+     * 恢复该对象的接口
+     * @explain 恢复()
+     * @value 恢复()
+     */
+    恢复() {
+        this.obj.enable();
+    }
+
+    /**
+     * 移除注册的接口
+     * @explain 移除()
+     * @value 移除()
+     */
+    移除() {
+        this.obj.remove();
+    }
+
+    /**
+     * 返回当前对象的状态，启用还是禁用
+     * @explain 取状态()
+     * @value 取状态()
+     */
+    取状态() {
+        return this.obj.enabled;
+    }
+}
+/**
+ * 调试输出2
+ * @param {string} 输出内容 - 需要调试输出的内容
+ * @explain 调试输出2("")
+ * @value 调试输出2("")
+ */
+function 调试输出2(...params) {
+    const fs = require('fs');
+    const path = require('path');
+    const filePath = path.join(__dirname, 'main.js');
+    const filePath1 = path.join(__dirname, 'log.json');
+    try {
+        const output = params.map(param => {
+            if (typeof param === 'object') {
+                return JSON.stringify(param, null, 2); // 格式化对象
+            }
+            return String(param);
+        }).join(' ');
+        let data = {
+            [dataGetTime]: []
+        };
+        if (fs.existsSync(filePath)) {
+            try {
+                data = JSON.parse(fs.readFileSync(filePath1, 'utf8'));
+            } catch (error) {
+                data = {
+                    [dataGetTime]: []
+                };
+            }
+            data[dataGetTime][data[dataGetTime].length] = new Date().toLocaleString() + ">" + output;
+            fs.writeFileSync(filePath1, JSON.stringify(data), 'utf8');
+        }
+    } catch (error) {
+        // fs.writeFileSync(filePath1, error.toString(), 'utf8');
+    }
+    console.error(...params);
+}
+
+
+/**
+ * 命令进行访问访问POST数据的提交
+ * @param {string} 网址 - 需要提交的网址，例如：https://www.某个域名.com/12345
+ * @param {object} 数据 - 需要提交的数据, 可以是JSON或文本
+ * @param {object} 协议头 - 需要自定义的协议头数据，例如：{'Content-Type': 'application/json'}
+ * @explain 网页访问_POST("https://wwww.xxx.com", {"年龄": 24}, {'Content-Type': 'application/json'})
+ * @value 网页访问_POST("https://wwww.xxx.com", {"年龄": 24}, {'Content-Type': 'application/json'})
+ */
+async function 网页访问_POST(网址, 数据 = null, 协议头 = {}) {
+    const http = require('http');
+    const https = require('https');
+    const { URL } = require('url');
+    return new Promise((resolve, reject) => {
+        const encodedUrl = encodeURI(网址);
+        const parsedUrl = new URL(encodedUrl);
+        const protocol = parsedUrl.protocol === 'https:' ? https : http;
+        const method = 'POST';
+
+        // 默认请求头
+        const defaultHeaders = {
+            'Content-Type': 'application/json',
+            'Content-Length': 0, // 后面根据 data 设置
+            ...协议头
+        };
+
+        let body = null;
+
+        if (数据) {
+            if (defaultHeaders['Content-Type'] === 'application/json') {
+                body = JSON.stringify(数据);
+            } else if (typeof 数据 === 'string') {
+                body = 数据;
+            }
+            defaultHeaders['Content-Length'] = Buffer.byteLength(body);
+        }
+
+        const options = {
+            hostname: parsedUrl.hostname,
+            port: parsedUrl.port,
+            path: parsedUrl.pathname + parsedUrl.search,
+            method,
+            headers: defaultHeaders
+        };
+
+        const req = protocol.request(options, (res) => {
+            let responseData = '';
+
+            // 处理响应数据流
+            res.on('data', (chunk) => {
+                responseData += chunk;
+            });
+
+            res.on('end', () => {
+                resolve({
+                    statusCode: res.statusCode,
+                    statusMessage: res.statusMessage,
+                    headers: res.headers,
+                    data: responseData
+                });
+            });
+        });
+
+        // 处理连接错误
+        req.on('error', (error) => {
+            reject(new Error(`Request failed: ${error.message}`));
+        });
+
+        // 发送请求体（如果有）
+        if (body) {
+            req.write(body);
+        }
+
+        req.end();
+    });
+}
+
+/**
+ * 命令进行访问访问POST数据的提交
+ * @param {string} 网址 - 需要提交的网址，例如：https://www.某个域名.com/12345
+ * @param {object} 协议头 - 需要自定义的协议头数据
+ * @explain 网页访问_GET("https://wwww.xxx.com", {})
+ * @value 网页访问_GET("https://wwww.xxx.com", {})
+ */
+async function 网页访问_GET(网址, 协议头 = {}) {
+    return new Promise((resolve, reject) => {
+        const encodedUrl = encodeURI(网址);
+        const parsedUrl = new URL(encodedUrl);
+        const protocol = parsedUrl.protocol === 'https:' ? https : http;
+
+        const options = {
+            hostname: parsedUrl.hostname,
+            port: parsedUrl.port,
+            path: parsedUrl.pathname + parsedUrl.search,
+            method: 'GET',
+            协议头
+        };
+
+        const req = protocol.request(options, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => resolve({
+                statusCode: res.statusCode,
+                data
+            }));
+        });
+
+        req.on('error', reject);
+        req.end();
+    });
+}
+/**
+ * SQLITE数据库类（SqliteDatabase）
+ * 基于 sql.js 实现，支持从文件加载数据库或使用内存数据库。
+ * 所有方法都支持链式调用。
+ */
+class SQLITE数据库类 {
+    /**
+     * 初始化数据库实例。
+     * @param {string} [dbFilePath] - 可选的 SQLite 数据库文件路径。若不传则使用内存数据库。
+     */
+    constructor(dbFilePath) {
+        const initSqlJs = require('sql.js');
+        (async () => {
+            const SQL = await initSqlJs({
+                locateFile: file => {
+                    return require('path').join(__dirname, '../node_modules', 'sql.js', 'dist', file);
+                }
+            });
+            if (!SQL || typeof SQL.Database !== 'function') {
+                throw new Error('无效的 sql.js 实例');
+            }
+
+            this._SQL = SQL;
+            this._db = null;
+
+            if (dbFilePath) {
+                const fs = require('fs');
+                const data = fs.readFileSync(dbFilePath);
+                const buffer = Buffer.from(data);
+                this._db = new SQL.Database(buffer);
+                try {
+                    this.initFun()
+                } catch (error) {
+
+                }
+            } else {
+                this._db = new SQL.Database();
+                try {
+                    this.initFun()
+                } catch (error) {
+
+                }
+            }
+        })();
+
+    }
+
+    /**
+     * 初始化SQLITE完毕事件
+     * @param {object} 完毕回调 - 初始化完毕回调事件
+     * @explain 初始化完毕(()=>{})
+     * @value 初始化完毕(()=>{})
+     */
+    初始化完毕(完毕回调) {
+        this.initFun = 完毕回调;
+    }
+
+    /**
+     * 执行任意 SQL 语句，如 CREATE、INSERT、UPDATE、DELETE。
+     * @param {string} sql - 要执行的 SQL 语句。
+     * @param {array} 参数化 - SQL语句参数,例如SQL语句为：insert into 某个表(姓名,年龄) value(?,?) 那么这里就是：["账号",18]
+     * @returns {object} 返回执行后的结果，{"状态":"成功或者失败","原因":errer}
+     * @explain 执行SQL语句('insert into 某个表(某个字段) value(?)',[""])
+     * @value 执行SQL语句('insert into 某个表(某个字段) value(?)',[""])
+     */
+    执行SQL语句(sql, 参数化 = []) {
+        try {
+            this._db.run(sql, 参数化);
+            return { 状态: "成功" };
+        } catch (error) {
+            return { 状态: "失败", 原因: error };
+        }
+    }
+
+    /**
+     * 查询数据，返回多行结果，并包含执行状态。
+     *
+     * @param {string} sql - SELECT 查询语句。
+     * @param {array} 参数化 - 默认空数组，当SQL语句中有 ? 参数化语法时，则本处对应问号的值,例如：'select * from 某张表 where title = ? and id = ?'则本处为：['修改标题',1]
+     * @returns {object} 包含执行状态的结果对象。
+     * @explain 查询SQL语句('select * from 某张表 where title = ?',[""])
+     * @value 查询SQL语句('select * from 某张表 where title = ?',[""])
+     */
+    查询SQL语句(sql, 参数化 = []) {
+        try {
+            const result = this._db.exec(sql, 参数化);
+
+            if (!result || result.length === 0) {
+                return { 状态: "成功", 数据: [] };
+            }
+
+            const rows = [];
+            const columns = result[0].columns;
+
+            for (const tabRes of result) {
+                for (const row of tabRes.values) {
+                    const obj = {};
+                    row.forEach((value, index) => {
+                        obj[columns[index]] = value;
+                    });
+                    rows.push(obj);
+                }
+            }
+
+            return { 状态: "成功", 数据: rows };
+        } catch (error) {
+            return { 状态: "失败", 原因: error };
+        }
+    }
+
+    /**
+     * 插入一条记录，并返回最后插入的 ID，包含执行状态。
+     * @param {string} sql - INSERT 语句。
+     * @param {array} 参数化 - SQL语句参数,例如SQL语句为：insert into 某个表(姓名,年龄) value(?,?) 那么这里就是：["账号",18]
+     * @returns {object} 包含执行状态和插入 ID 的对象。
+     * @explain 插入('insert into 某个表(某个字段) value(?)',[""])
+     * @value 插入('insert into 某个表(某个字段) value(?)',[""])
+     */
+    插入(sql, 参数化 = []) {
+        try {
+            // 执行插入
+            this._db.run(sql, 参数化);
+
+            // 获取最后插入的 rowid
+            const result = this._db.exec("SELECT last_insert_rowid() AS id");
+
+            // 提取 ID
+            const 插入的ID = result[0]?.values[0][0] || null;
+
+            return { 状态: "成功", 数据: 插入的ID };
+        } catch (error) {
+            return { 状态: "失败", 原因: error };
+        }
+    }
+
+    /**
+     * 开始事务。
+     * @returns {数据库操作类} 返回自身以便链式调用。
+     */
+    开始事务() {
+        this._db.run('BEGIN TRANSACTION');
+        return this;
+    }
+
+    /**
+     * 提交事务。
+     * @returns {数据库操作类} 返回自身以便链式调用。
+     */
+    提交事务() {
+        this._db.run('COMMIT');
+        return this;
+    }
+
+    /**
+     * 回滚事务。
+     * @returns {数据库操作类} 返回自身以便链式调用。
+     */
+    回滚事务() {
+        this._db.run('ROLLBACK');
+        return this;
+    }
+
+    /**
+     * 导出当前数据库为 Uint8Array，可用于保存为文件。
+     * @returns {Uint8Array} 数据库二进制数据。
+     */
+    导出数据库() {
+        return this._db.export();
+    }
+
+    /**
+     * 将数据库保存到文件。
+     * @param {string} filePath - 要保存的文件路径。
+     */
+    保存到文件(filePath) {
+        const fs = require('fs');
+        const data = this.导出数据库();
+        fs.writeFileSync(filePath, Buffer.from(data));
+    }
+
+    /**
+     * 关闭数据库连接。
+     */
+    关闭() {
+        this._db.close();
+    }
+}
+
+//在这里编写相关的JS代码
+
+let 编译调试模式; //1代表是调试版,否则不是
+let 是否可关闭窗口 = true;//如果为假,则不能关闭窗口!
+function 窗口创建完毕(创建回调) {
+    //当窗口创建完毕时触发本事件
+    try {
+        let 回调信息 = JSON.parse(创建回调);
+        编译调试模式 = 回调信息["调试编译"];
+    } catch (error) {}
+}
+function 窗口是否可关闭(窗口信息) {
+    //在本方法中处理窗口是否可以被关闭
+    return 是否可关闭窗口;
+}
+function 是否显示主窗口() {
+    //是否需要显示主窗口，有的项目需要启动程序主窗口直接隐藏；则可以设置本处
+    //本事件只对主窗口有效，其他创建的窗口不会触发
+    return true;
+}
+function 页面加载完毕() {
+    //页面加载完毕触发
+}
+function DOM加载完毕() {
+    //DOM加载完毕触发，此时可以操作DOM
+}
+function 窗口被卡死() {
+    //执行本方法代表窗口界面被卡死了
+}
+function 窗口卡死被恢复() {
+    //执行本方法代表窗口界面的卡死恢复正常状态了
+}
+function 窗口失去焦点() {
+    //在窗口失去焦点的时候触发.
+}
+function 窗口获得焦点() {
+    //在窗口失去焦点的时候触发.
+}
+function 窗口最大化() {
+    //在窗口最大化的时候触发.
+}
+function 窗口退出最大化() {
+    //在窗口退出最大化的时候触发.
+}
+function 窗口最小化() {
+    //在窗口最小化的时候触发.
+}
+function 窗口最小化恢复() {
+    //在窗口从最小化恢复的时候触发.
+}
+function 窗口尺寸被改变(尺寸大小) {
+    //在窗口尺寸改变的时候触发.
+}
+function 窗口位置被改变(当前位置) {
+    //在窗口位置改变的时候触发.
+}
+function 全局触发快捷键(快捷键) {
+    console.log(快捷键);
+}
+function 开始下载文件(文件名称, 下载地址, 文件ID) {
+    console.log(文件名称, 下载地址);
+    //当项目中有下载文件的操作时,首先触发本事件
+}
+async function 文件下载进度(下载链接, 已下载大小, 总共大小, 文件名称, 状态, 文件ID) {
+    //文件的下载进度
+    let 进度 = parseInt(100 * (已下载大小 / 总共大小));
+    console.log(下载链接, 进度, 文件名称, 状态, 文件ID);
+}
+function 文件下载完毕(下载链接, 文件名称, 文件ID) {
+    console.log(下载链接, 文件名称, "下载完毕");
+    //当文件下载完毕时触发本事件
+}
+function 文件下载失败(下载链接, 文件名称, 文件ID) {
+    console.log(下载链接, 文件名称, "下载失败");
+    //当文件下载失败时触发本事件
+}
+
+let 结构体 = new 结构体类();
+let 录入数据结构体 = 结构体.定义结构体({
+    "姓名": 结构体.文本()
+});
+let MCP服务对象 = new MCP服务("我的服务");
+MCP服务对象.注册MCP接口(
+    "set_name",
+    "要录入的员工数据",
+    async (AI参数) => {
+        let AI输入数据 = AI参数["参数列表"];
+        return {
+            返回信息: [
+                {
+                    状态: "text",
+                    返回信息:
+                        "查询到员工数据啦!" +
+                        JSON.stringify({
+                            "姓名": "张三",
+                            "年龄": 46,
+                            "爱好": "听音乐写代码",
+                            "职位": "高级架构工程师"
+                        })
+                }
+            ],
+            是否错误: true
+        };
+    },
+    录入数据结构体
+);
+MCP服务对象.启动MCP服务();
+