chanjs 2.7.2 → 2.7.4

package/common/category.js

@@ -1,22 +0,0 @@
-/**
- * 分类工具函数
- * 提供分类相关的辅助方法
- */
-
-/**
- * 根据拼音或ID获取分类信息
- * @param {string|number} py - 拼音或ID
- * @param {Array} source - 分类数据源
- * @returns {Object} 包含分类对象和ID的对象
- */
-export function getChildrenId(py, source) {
-  let cate = {};
-  let id = "";
-  source.forEach((item) => {
-    if (item.pinyin == py || item.id == py) {
-      cate = item;
-      id = item.id;
-    }
-  });
-  return { cate, id };
-}

package/common/sms.js

@@ -1,104 +0,0 @@
-import crypto from 'crypto';
-
-/**
- * 阿里云短信发送工具
- * 提供短信发送客户端创建和发送功能
- */
-
-const API_CONFIG = {
-  host: 'https://sms.aliyuncs.com/',
-  action: 'SingleSendSms',
-  version: '2016-09-27',
-  format: 'JSON',
-  signatureMethod: 'HMAC-SHA1',
-  signatureVersion: '1.0'
-};
-
-/**
- * 生成签名
- * @private
- * @param {Object} params - 请求参数
- * @param {string} secret - AccessKeySecret
- * @returns {string} Base64编码的签名
- */
-function generateSignature(params, secret) {
-  const sortedParams = Object.keys(params).sort()
-    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
-    .join('&');
-
-  const signatureStr = `POST&${encodeURIComponent('/')}&${encodeURIComponent(sortedParams)}`;
-  
-  return crypto
-    .createHmac('sha1', `${secret}&`)
-    .update(Buffer.from(signatureStr, 'utf8'))
-    .digest('base64');
-}
-
-/**
- * 创建短信客户端
- * @param {Object} config - 配置对象
- * @param {string} config.accessKeyId - AccessKey ID
- * @param {string} config.accessKeySecret - AccessKey Secret
- * @param {string} config.signName - 短信签名
- * @param {string} config.templateCode - 短信模板代码
- * @returns {Object} 短信客户端对象，包含send方法
- * @throws {Error} 缺少必要配置时抛出异常
- */
-export function createSmsClient(config) {
-  const requiredFields = ['accessKeyId', 'accessKeySecret', 'signName', 'templateCode'];
-  const missingFields = requiredFields.filter(field => !config[field]);
-  
-  if (missingFields.length) {
-    throw new Error(`缺少必要配置: ${missingFields.join(', ')}`);
-  }
-
-  return {
-    /**
-     * 发送短信
-     * @param {Object} options - 发送选项
-     * @param {string} options.phone - 手机号
-     * @param {Object} options.params - 模板参数
-     * @returns {Promise<Object>} 发送结果
-     * @throws {Error} 手机号或模板参数缺失，或发送失败时抛出异常
-     */
-    async send({ phone, params }) {
-      if (!phone || !params) {
-        throw new Error('手机号和模板参数为必填项');
-      }
-
-      const requestParams = {
-        Action: API_CONFIG.action,
-        Version: API_CONFIG.version,
-        Format: API_CONFIG.format,
-        AccessKeyId: config.accessKeyId,
-        SignatureMethod: API_CONFIG.signatureMethod,
-        SignatureVersion: API_CONFIG.signatureVersion,
-        SignatureNonce: crypto.randomUUID(),
-        Timestamp: new Date().toISOString(),
-        SignName: config.signName,
-        TemplateCode: config.templateCode,
-        RecNum: phone,
-        ParamString: JSON.stringify(params)
-      };
-
-      requestParams.Signature = generateSignature(requestParams, config.accessKeySecret);
-
-      const formData = new URLSearchParams();
-      Object.entries(requestParams).forEach(([key, value]) => formData.append(key, value));
-
-      const response = await fetch(API_CONFIG.host, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-        body: formData
-      });
-
-      const result = await response.json();
-
-      if (result.Code) {
-        throw new Error(`[${result.Code}] ${result.Message}`);
-      }
-
-      return result;
-    }
-  };
-}

package/extend/art-template.js

@@ -1,129 +0,0 @@
-import template from "art-template";
-import dayjs from "dayjs";
-import relativeTime from "dayjs/plugin/relativeTime.js";
-import "dayjs/locale/zh-cn.js";
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-const { marked } = require('marked');
-
-dayjs.extend(relativeTime);
-dayjs.locale('zh-cn');
-
-template.defaults.native = false; // 禁用原生模板引擎 防止模板直接调用nodejs语法
-//template.defaults.debug = false; // 禁用调试模式
-
-
-/**
- * 日期格式化过滤器
- * @param {Date|string|number} date - 日期对象、日期字符串或时间戳
- * @param {string} format - 日期格式字符串
- * @returns {string} 格式化后的日期字符串
- */
-template.defaults.imports.dateFormat = function (date, format) {
-    if (!date) {
-      return "";
-    }
-    if (
-      date instanceof Date ||
-      typeof date === "string" ||
-      typeof date === "number"
-    ) {
-      date = dayjs(date);
-    } else {
-      return "";
-    }
-    return date.format(format);
-  };
-
-/**
- * 相对时间过滤器（如"刚刚"、"5分钟前"、"3小时前"）
- * @param {Date|string|number} date - 日期对象、日期字符串或时间戳
- * @returns {string} 相对时间字符串
- */
-template.defaults.imports.timeAgo = function (date) {
-    if (!date) return "";
-    const d = dayjs(date);
-    if (!d.isValid()) return "";
-    return d.fromNow();
-  };
-
-/**
- * 字符串截断过滤器
- * @param {string} str - 原始字符串
- * @param {number} length - 截断长度，默认10
- * @returns {string} 截断后的字符串
- */
-template.defaults.imports.truncate = (str, length = 10) => {
-    return str.length > length ? str.slice(0, length) + "..." : str;
-  };
-
-/**
- * 安全的 JSON 序列化过滤器
- * 用于在模板中调试和显示对象内容
- * @param {Object} obj - 要序列化的对象
- * @param {Array} keys - 可选，只返回指定的字段
- * @returns {string} JSON字符串
- */
-template.defaults.imports.safeStringify = (obj, keys) => {
-    if (!obj) return 'null';
-    
-    // 如果指定了 keys，只返回这些字段
-    if (keys && Array.isArray(keys) && keys.length > 0) {
-        const filteredObj = {};
-        keys.forEach(key => {
-            if (obj.hasOwnProperty(key)) {
-                filteredObj[key] = obj[key];
-            }
-        });
-        return JSON.stringify(filteredObj, null, 2);
-    }
-    
-    // 否则返回完整对象
-    return JSON.stringify(obj, null, 2);
-};
-
-/**
- * 获取对象所有key的过滤器，方便调试查看数据结构
- * 用法：{{$data | objKeys}} 或 {{$data | objKeys ','}}
- * @param {Object} obj - 要获取key的对象
- * @param {string} separator - 分隔符，默认为换行
- * @returns {string} 所有key的字符串
- */
-template.defaults.imports.objKeys = (obj, separator) => {
-    if (!obj || typeof obj !== 'object') return '';
-    const sep = separator !== undefined ? separator : '\n';
-    return Object.keys(obj).join(sep);
-};
-
-/**
- * Markdown 渲染过滤器
- * 自动检测内容是否为 Markdown 格式，如果是则渲染为 HTML
- * @param {string} content - 文章内容
- * @returns {string} 渲染后的 HTML
- */
-template.defaults.imports.renderContent = (content, editorType = 'rich', allowScript = 0) => {
-  if (!content || typeof content !== 'string') {
-    return content || '';
-  }
-
-  let html = content;
-  
-  // Markdown 需要转换
-  if (editorType === 'md') {
-    try {
-      html = marked.parse(content);
-    } catch (err) {
-      console.error('[renderContent] Markdown 渲染失败:', err.message);
-      html = content;
-    }
-  }
-  
-  // 如果 allowScript !== 1，转义 script 标签
-  if (Number(allowScript) !== 1) {
-    html = html
-      .replace(/<script\b[^>]*>/gi, '&amp;lt;script&amp;gt;')
-      .replace(/<\/script>/gi, '&amp;lt;/script&amp;gt;');
-  }
-  
-  return html;
-};

package/extend/index.js

@@ -1,6 +0,0 @@
-/**
- * 扩展模块入口
- * 导入所有扩展功能
- */
-
-import "./art-template.js";

package/global/global.js

@@ -1,63 +0,0 @@
-import path from "path";
-import { readFileSync } from "fs";
-import { pathToFileURL, fileURLToPath } from "url";
-import { Paths } from "../config/index.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/**
- * 获取应用版本号
- * @returns {string} 版本号
- */
-const getVersion = () => {
-  const packageJsonPath = path.join(Paths.rootPath, "package.json");
-  const packageJson = JSON.parse(
-    readFileSync(packageJsonPath, "utf8")
-  );
-  return packageJson?.version || "1.0.0";
-};
-
-/**
- * 全局变量定义
- * 将常用变量挂载到global对象上
- */
-const globals = {
-  /**
-   * 当前模块文件所在目录的绝对路径
-   */
-  __dirname,
-  /**
-   * 当前模块文件的绝对路径
-   */
-  __filename,
-  /**
-   * 应用版本号
-   */
-  APP_VERSION: getVersion(),
-  /**
-   * 路径配置对象
-   */
-  Paths,
-  /**
-   * 通用模块目录路径
-   */
-  COMMON_PATH: Paths.commonPath,
-  /**
-   * 辅助函数目录路径
-   */
-  HELPER_PATH: Paths.helperPath,
-  /**
-   * 扩展目录路径
-   */
-  EXTEND_PATH: Paths.extendPath,
-};
-
-for (const [key, value] of Object.entries(globals)) {
-  Object.defineProperty(global, key, {
-    value,
-    writable: false,
-    configurable: false,
-    enumerable: true,
-  });
-}

package/helper/cache.js

@@ -1,187 +0,0 @@
-/**
- * LRU（最近最少使用）缓存类
- * @class Cache
- * @description
- * 实现了一个基于内存的 LRU 缓存，支持 TTL（生存时间）和自动过期清理
- * 使用 Map 存储缓存数据，另一个 Map 记录访问顺序以实现 LRU 淘汰策略
- * @example
- * const cache = new Cache({ maxSize: 500, defaultTTL: 60000 });
- * cache.set('user:123', { name: '张三' }, 30000);
- * const user = cache.get('user:123');
- * console.log(user); // { name: '张三' }
- */
-class Cache {
-  /**
-   * 创建缓存实例
-   * @param {Object} [options={}] - 配置选项
-   * @param {number} [options.maxSize=1000] - 最大缓存条目数
-   * @param {number} [options.defaultTTL=300000] - 默认过期时间（毫秒），默认 5 分钟
-   * @description
-   * 初始化缓存实例，设置最大容量和默认过期时间
-   * 当缓存达到最大容量时，会自动淘汰最久未使用的条目
-   */
-  constructor(options = {}) {
-    this.cache = new Map();
-    this.accessOrder = new Map();
-    this.maxSize = options.maxSize || 1000;
-    this.defaultTTL = options.defaultTTL || 5 * 60 * 1000;
-  }
-
-  /**
-   * 设置缓存值
-   * @param {string} key - 缓存键
-   * @param {*} value - 要缓存的值
-   * @param {number} [ttl=this.defaultTTL] - 过期时间（毫秒）
-   * @description
-   * 将键值对存入缓存，如果缓存已满则淘汰最久未使用的条目
-   * 每次设置都会更新访问时间 + 过期时间
-   * @example
-   * cache.set('key1', 'value1', 60000); // 60 秒后过期
-   * cache.set('key2', { data: 123 }); // 使用默认过期时间
-   */
-  set(key, value, ttl = this.defaultTTL) {
-    // 修复：缓存满 + 是新 key 才淘汰
-    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-      this._evictLRU();
-    }
-
-    // 修复：无论 key 是否存在，都更新 过期时间 + 访问时间
-    this.cache.set(key, { value, expireAt: Date.now() + ttl });
-    // LRU：先删除再插入，保证 Map 尾部是最新访问
-    this.accessOrder.delete(key);
-    this.accessOrder.set(key, Date.now());
-  }
-
-  /**
-   * 获取缓存值
-   * @param {string} key - 缓存键
-   * @returns {*} 缓存的值，如果键不存在或已过期则返回 null
-   * @description
-   * 获取指定键的缓存值
-   * 如果值已过期，会自动删除该条目
-   * 每次获取都会更新访问时间 + 刷新过期时间
-   * @example
-   * const value = cache.get('key1');
-   * if (value !== null) {
-   *   console.log('缓存命中:', value);
-   * }
-   */
-  get(key) {
-    const item = this.cache.get(key);
-    if (!item) return null;
-
-    const now = Date.now();
-    // 已过期直接删除
-    if (now > item.expireAt) {
-      this.cache.delete(key);
-      this.accessOrder.delete(key);
-      return null;
-    }
-
-    // 修复：命中缓存 → 刷新 LRU 顺序 + 刷新 TTL
-    this.accessOrder.delete(key);
-    this.accessOrder.set(key, now);
-    // 重新计算过期时间（访问续命，标准行为）
-    const ttl = item.expireAt - (now - (item.expireAt - this.defaultTTL));
-    this.cache.set(key, { value: item.value, expireAt: now + ttl });
-
-    return item.value;
-  }
-
-  /**
-   * 删除缓存条目
-   * @param {string} key - 要删除的缓存键
-   * @description
-   * 从缓存中删除指定的键及其访问记录
-   * @example
-   * cache.del('key1');
-   */
-  del(key) {
-    this.cache.delete(key);
-    this.accessOrder.delete(key);
-  }
-
-  /**
-   * 清空所有缓存
-   * @description
-   * 删除所有缓存条目和访问记录
-   * @example
-   * cache.clear();
-   */
-  clear() {
-    this.cache.clear();
-    this.accessOrder.clear();
-  }
-
-  /**
-   * 检查键是否存在
-   * @param {string} key - 要检查的缓存键
-   * @returns {boolean} 如果键存在且未过期返回 true，否则返回 false
-   * @description
-   * 检查指定的键是否存在于缓存中且未过期
-   * 如果键已过期，会自动删除该条目
-   * @example
-   * if (cache.has('key1')) {
-   *   console.log('缓存存在');
-   * }
-   */
-  has(key) {
-    const item = this.cache.get(key);
-    if (!item) return false;
-    if (Date.now() > item.expireAt) {
-      this.cache.delete(key);
-      this.accessOrder.delete(key);
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * 获取当前缓存大小
-   * @returns {number} 当前缓存中的有效条目数
-   * @description
-   * 返回当前缓存中的条目数量
-   * 会先清理已过期的条目
-   * @example
-   * console.log(`当前缓存大小: ${cache.size()}`);
-   */
-  size() {
-    this._cleanupExpired();
-    return this.cache.size;
-  }
-
-  /**
-   * 淘汰最久未使用的条目（内部方法）
-   * @private
-   * @description
-   * Map 头部就是最早访问，直接删除（O(1)）
-   */
-  _evictLRU() {
-    // 修复：Map 有序，keys().next() 直接拿到最久未使用的 key，性能 O(1)
-    const oldestKey = this.accessOrder.keys().next().value;
-    if (oldestKey) {
-      this.cache.delete(oldestKey);
-      this.accessOrder.delete(oldestKey);
-    }
-  }
-
-  /**
-   * 清理已过期的条目（内部方法）
-   * @private
-   * @description
-   * 遍历所有缓存条目，删除已过期的条目
-   * 在获取缓存大小时自动调用
-   */
-  _cleanupExpired() {
-    const now = Date.now();
-    for (const [key, item] of this.cache.entries()) {
-      if (now > item.expireAt) {
-        this.cache.delete(key);
-        this.accessOrder.delete(key);
-      }
-    }
-  }
-}
-
-export const cache = new Cache();
-export default Cache;

package/helper/keywords.js

@@ -1,132 +0,0 @@
-/**
- * 安全关键词规则定义
- * 定义各类恶意攻击的关键词检测规则
- */
-
-export const KEYWORD_RULES = {
-  /**
-   * 整词匹配规则（需完整匹配）
-   */
-  wholeWord: [
-    "netcat", "nc", "php-cgi", "process", "require","exec","import",
-    "child_process", "execSync", "mainModule"
-  ],
-  /**
-   * 敏感文件扩展名
-   */
-  extensions: [
-    ".php", ".asp", ".aspx", ".jsp", ".jspx", ".do", ".action", ".cgi",
-    ".py", ".pl", ".cfm", ".jhtml", ".shtml",".sql",".env",".git"
-  ],
-  /**
-   * 敏感目录名称
-   */
-  directories: [
-    "/administrator", "/wp-admin", "phpMyAdmin", "cgi-bin",
-    "setup", "staging", "internal", "debug", "metadata", "secret"
-  ],
-  /**
-   * SQL 注入关键词
-   */
-  sqlInjection: [
-    "sleep(", "benchmark(", "concat(", "extractvalue(", "updatexml(", "version(",
-    "union select", "union all", "select @@", "drop ", "alter ", "truncate ",
-    "(select", "information_schema", "load_file(", "into outfile", "into dumpfile"
-  ],
-  /**
-   * 命令注入关键词
-   */
-  commandInjection: [
-    "cmd=", "system(", "exec(", "shell_exec(", "passthru(",
-    "eval(", "assert(", "preg_replace", "bash -i", "rm -rf",
-    "wget ", "curl ", "chmod ", "base64_decode", "phpinfo()",
-    "kill ", "killall", "shutdown", "reboot", "halt", "fdisk",
-    "mkfs", "dd ", "ssh ", "scp ", "rsync", "nc ",
-    "netcat", "nmap", "iptables", "systemctl", "service",
-    "crontab", "at ", "su ", "sudo", "useradd",
-    "userdel", "usermod", "groupadd", "groupdel", "passwd",
-    "chpasswd", "mount ", "umount", "ln -s"
-  ],
-  /**
-   * 路径遍历关键词
-   */
-  pathTraversal: [
-    "../", "..\\", "/etc/passwd", "/etc/shadow", "/etc/hosts",
-    "/etc/", "/var/www/", "/app/", "/root/", "__dirname", "__filename"
-  ],
-  /**
-   * XSS 攻击关键词
-   */
-  xss: [
-    "<script", "javascript:", "onerror=", "onload=", "onclick=",
-    "alert(", "document.cookie", "document.write"
-  ],
-  /**
-   * 编码绕过关键词
-   */
-  encoding: [
-    "0x7e", "UNION%20SELECT", "%27OR%27", "{{", "}}", "${", "1+1"
-  ],
-  /**
-   * 敏感标识符
-   */
-  sensitiveIdentifiers: [
-    "wp-", "smtp", "redirect", "configs", ".well-known/",
-    "fs.readFile", "fs.existsSync", "process.env", "process.argv"
-  ],
-};
-
-/**
- * 关键词正则表达式缓存
- * 将关键词规则编译为正则表达式以提高检测性能
- */
-export let keywordRegexCache = (() => {
-  const regexSpecialChars = /[.*+?^${}()|[\]\\]/g;
-  const cache = {};
-
-  for (const [category, keywords] of Object.entries(KEYWORD_RULES)) {
-    if (!Array.isArray(keywords)) continue;
-
-    cache[category] = keywords.map((keyword) => {
-      const escaped = keyword.replace(regexSpecialChars, "\\$&").replace(/ /g, "\\s");
-      return {
-        keyword,
-        regex: new RegExp(
-          category === 'wholeWord' ? `\\b${escaped}\\b` : escaped,
-          "i"
-        ),
-      };
-    });
-  }
-
-  return cache;
-})();
-
-/**
- * 更新关键词缓存
- * @param {Object} newRules - 新的关键词规则
- * @description
- * 允许动态添加或更新关键词检测规则
- * @example
- * updateKeywordCache({
- *   customKeywords: ['malicious', 'attack']
- * });
- */
-export function updateKeywordCache(newRules = {}) {
-  const regexSpecialChars = /[.*+?^${}()|[\]\\]/g;
-
-  for (const [category, keywords] of Object.entries(newRules)) {
-    if (!Array.isArray(keywords)) continue;
-
-    keywordRegexCache[category] = keywords.map((keyword) => {
-      const escaped = keyword.replace(regexSpecialChars, "\\$&").replace(/ /g, "\\s");
-      return {
-        keyword,
-        regex: new RegExp(
-          category === 'wholeWord' ? `\\b${escaped}\\b` : escaped,
-          "i"
-        ),
-      };
-    });
-  }
-}