koishi-plugin-csss 4.0.0 → 4.1.0

package/lib/index.d.ts

@@ -6,13 +6,12 @@ export interface Config {
     cacheTime: number;
     maxPlayers: number;
     retryCount: number;
-    showVAC: boolean;
-    showPassword: boolean;
     generateImage: boolean;
     imageWidth: number;
     imageHeight: number;
     fontFamily: string;
-    customCSS: string;
+    customHTML: string;
+    customBatchHTML: string;
 }
 export declare const Config: Schema<Config>;
 declare module 'koishi' {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-csss",
   "description": "一个用于 Koishi 的 CS:GO / CS2 服务器状态查询插件，支持单个/批量查询、服务器列表管理，并可将结果渲染为图片",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -40,5 +40,8 @@
         "database"
       ]
     }
+  },
+  "scripts": {
+    "build": "tsc"
   }
 }

package/readme.md

@@ -2,7 +2,7 @@
 
 [![npm](https://img.shields.io/npm/v/koishi-plugin-csss?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-csss)
 
-cs server status - 一个用于 Koishi 的 CS:GO / CS2 服务器状态查询插件，支持单个/批量查询、服务器列表管理，并可将结果渲染为图片。
+cs server status - 一个用于 Koishi 的 CS1.6 / CSS / CS:GO / CS2 服务器状态查询插件，支持单个/批量查询、服务器列表管理，并可将结果渲染为图片。
 
 ## 功能
 
@@ -14,8 +14,8 @@ cs server status - 一个用于 Koishi 的 CS:GO / CS2 服务器状态查询插
 
 本插件强依赖以下插件，请确保它们已安装并启用：
 
-- `koishi-plugin-gamedig`：用于查询 Source 引擎服务器。
-- `koishi-plugin-puppeteer`：用于将 HTML 渲染为图片。
+- [`koishi-plugin-gamedig`](https://www.npmjs.com/package/koishi-plugin-gamedig) – 查询 Source 引擎服务器
+- [`koishi-plugin-puppeteer`](https://www.npmjs.com/package/koishi-plugin-puppeteer) – 将 HTML 渲染为图片
 - `database`：用于存储服务器列表。
 
 ## 命令列表
@@ -92,11 +92,95 @@ csss -r 1                       #从数据库列表中移除序号为1的服务
 csss -c                         #清空数据库中的服务器列表
 ```
 
+> 批量查询最多支持 10 个服务器，超出时仅查询前 10 个并给出提示。
+
 ## 自定义样式指南
 
-`koishi-plugin-csss` 支持通过 `customCSS` 配置项注入自定义 CSS，让您能自由调整生成图片的视觉效果。本指南将说明可用的 HTML 结构、类名和修改示例。
+`koishi-plugin-csss` 支持通过 `customHTML` 和 `customBatchHTML` 配置项自定义服务器状态图片的 HTML 结构和样式，从而打造符合自己风格的展示效果。本指南将说明可用的 HTML 结构、类名和修改示例。
+
+### 1. 单个服务器查询模板 (`customHTML`)
+
+当用户执行 `cs <地址>` 命令并生成图片时，插件会使用此模板渲染 HTML。
+
+| 占位符 | 说明 | 示例值 |
+|--------|------|--------|
+| `{{SERVER_NAME}}` | 服务器名称（过滤特殊字符） | `HNS \| 身法躲猫猫` |
+| `{{MAP}}` | 当前地图名称 | `hns_bbcity` |
+| `{{PLAYERS_COUNT}}` | 当前玩家人数 | `4` |
+| `{{MAX_PLAYERS}}` | 服务器最大玩家数 | `20` |
+| `{{BOT_COUNT}}` | Bot 数量 | `2` |
+| `{{PING}}` | 服务器延迟（毫秒） | `35` |
+| `{{HOST}}` | 服务器 IP 或域名 | `127.0.0.1` |
+| `{{PORT}}` | 端口号 | `27015` |
+| `{{PLAYERS_LIST}}` | 玩家列表 HTML（自动生成，见下方说明） | - |
+| `{{TIMESTAMP}}` | 当前查询时间（本地化格式） | `2026/4/21 23:30:25` |
+
+### {{PLAYERS_LIST}} 生成的结构
+
+
+无玩家时：
+
+```html
+<div class="player-row" style="color: #aaaaaa;">服务器当前无玩家在线</div>
+```
+
+有玩家时（玩家数超过 10 人会自动分为两列显示，通过 display: flex 布局）：
+
+```html
+<div class="player-row">Player1</div>
+<div class="player-row">Player2</div>
+<!-- 超过 maxPlayers 时追加 -->
+<div class="player-row" style="color: #aaaaaa; font-style: italic;">... 还有 N 位玩家未显示</div>
+```
+
+
+### 2. 批量查询模板 (customBatchHTML)
+
+当用户执行 csss 命令（不带地址参数，查询数据库列表）并生成图片时使用。
+
+| 占位符 | 说明 | 示例值 |
+|--------|------|--------|
+| `{{TOTAL}}` | 查询的服务器总数 | `5` |
+| `{{SUCCESSFUL}}` | 成功查询的服务器数量 | `3` |
+| `{{QUERY_TIME}}` | 批量查询总耗时（格式化） | `1.2秒 或 350ms` |
+| `{{SERVERS_LIST}}` | 服务器列表 HTML（自动生成，见下方说明） | - |
+| `{{TIMESTAMP}}` | 当前查询时间（本地化格式） | `2026/4/21 23:30:25` |
 
-### HTML 结构概览
+### {{SERVERS_LIST}} 生成的结构
+
+每个服务器会生成如下 HTML（成功时）：
+
+```html
+<div class="server-item">
+  <div class="server-header">
+    <span class="server-index">1.</span>
+    <span class="server-name">HNS | 身法躲猫猫</span>
+    <span class="server-players">4/20</span>
+  </div>
+  <div class="server-details">
+    <span class="server-addr">127.0.0.1:27015</span>
+  </div>
+  <div class="server-details">
+    <span class="server-map">地图: hns_bbcity</span>
+    <span class="server-ping">延迟: 35ms</span>
+  </div>
+</div>
+```
+
+查询失败时：
+
+```html
+<div class="server-item error">
+  <div class="server-header">
+    <span class="server-index">2.</span>
+    <span class="server-name">127.0.0.1:27015</span>
+    <span class="server-status">❌ 查询失败</span>
+  </div>
+  <div class="server-details error-msg">连接超时</div>
+</div>
+```
+
+### 默认HTML模板结构参考
 
 ### 单个服务器查询 (cs)
 
@@ -137,17 +221,14 @@ csss -c                         #清空数据库中的服务器列表
 
 ```html
 <body>
-  <!-- 四角边框装饰 -->
-  <div class="corner corner-tl"></div> ...
-  
+  <div class="corner corner-tl"></div>
+  <!-- ... 其余三角 ... -->
   <div class="title">[服务器状态批量查询]</div>
   <div class="stats">
     <span>查询时间: ...</span>
     <span>耗时: 2.1秒 | 成功: 3/5</span>
   </div>
   <div class="divider"></div>
-  
-  <!-- 每个服务器一个 item -->
   <div class="server-item">
     <div class="server-header">
       <span class="server-index">1.</span>
@@ -162,8 +243,7 @@ csss -c                         #清空数据库中的服务器列表
       <span class="server-map">地图: de_dust2</span>
     </div>
   </div>
-  
-  <!-- 查询失败的条目 -->
+  <!-- 失败条目 -->
   <div class="server-item error">
     <div class="server-header">
       <span class="server-index">2.</span>
@@ -172,7 +252,6 @@ csss -c                         #清空数据库中的服务器列表
     </div>
     <div class="server-details error-msg">连接超时</div>
   </div>
-  
   <div class="timestamp">📋 输入 `cs 服务器地址` 查询单个服务器</div>
 </body>
 ```

package/lib/index.js

@@ -1,523 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Config: () => Config,
-  apply: () => apply,
-  inject: () => inject,
-  name: () => name
-});
-module.exports = __toCommonJS(src_exports);
-var import_koishi = require("koishi");
-var name = "csss";
-var inject = ["puppeteer", "gamedig", "database"];
-var Config = import_koishi.Schema.object({
-  timeout: import_koishi.Schema.number().min(100).max(3e4).default(500).description("查询超时时间(毫秒)"),
-  cacheTime: import_koishi.Schema.number().min(0).max(3e5).default(3e3).description("缓存时间(毫秒，0为禁用缓存)"),
-  maxPlayers: import_koishi.Schema.number().min(0).max(100).default(20).description("最大显示玩家数"),
-  retryCount: import_koishi.Schema.number().min(0).max(5).default(1).description("查询失败重试次数"),
-  showVAC: import_koishi.Schema.boolean().default(true).description("是否显示VAC状态"),
-  showPassword: import_koishi.Schema.boolean().default(true).description("是否显示密码保护信息"),
-  generateImage: import_koishi.Schema.boolean().default(true).description("是否生成图片横幅（影响cs和csss命令）"),
-  imageWidth: import_koishi.Schema.number().min(600).max(2e3).default(1200).description("图片宽度(像素)"),
-  imageHeight: import_koishi.Schema.number().min(200).max(2500).default(500).description("图片最小高度(像素)，实际高度会根据内容自适应"),
-  // 移除 fontSize 配置项
-  fontFamily: import_koishi.Schema.string().default("JetBrains Mono, monospace").description("字体"),
-  customCSS: import_koishi.Schema.string().role("textarea").description("自定义CSS样式，可通过此配置调整字体大小等").default("")
-});
-var CLEAN_NAME_REGEX = /^\d+|[\u0000-\u001F]/g;
-var ESCAPE_HTML_REGEX = /[&<>"']/g;
-var ESCAPE_MAP = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
-var utils = {
-  formatPing(ping) {
-    if (!ping || ping <= 0) return "未知";
-    if (ping < 50) return `🟢 ${ping}ms`;
-    if (ping < 100) return `🟡 ${ping}ms`;
-    if (ping < 200) return `🟠 ${ping}ms`;
-    return `🔴 ${ping}ms`;
-  },
-  cleanName(name2) {
-    return name2 ? name2.replace(CLEAN_NAME_REGEX, "").trim() : "未知";
-  },
-  truncateText(text, maxLength) {
-    return text.length > maxLength ? text.slice(0, maxLength) + "..." : text;
-  },
-  getPingColor(ping) {
-    if (ping < 50) return "#4CAF50";
-    if (ping < 100) return "#FFC107";
-    if (ping < 200) return "#FF9800";
-    return "#c03f36";
-  },
-  getPlayerColor(count) {
-    return count > 0 ? "#4CAF50" : "#c03f36";
-  },
-  formatTime(ms) {
-    if (ms < 1e3) return `${ms}ms`;
-    if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}秒`;
-    return `${(ms / 1e3).toFixed(0)}秒`;
-  },
-  escapeHtml(str) {
-    return str ? str.replace(ESCAPE_HTML_REGEX, (ch) => ESCAPE_MAP[ch] || ch) : "";
-  },
-  getVisualLength(str) {
-    let len = 0;
-    for (const char of str) {
-      len += char.charCodeAt(0) > 255 ? 2 : 1;
-    }
-    return len;
-  },
-  padEndVisual(str, targetLen) {
-    const currentLen = this.getVisualLength(str);
-    if (currentLen >= targetLen) return str;
-    return str + " ".repeat(targetLen - currentLen);
-  }
-};
-function apply(ctx, config) {
-  const cache = /* @__PURE__ */ new Map();
-  const logger = ctx.logger("csss");
-  if (!ctx.gamedig) {
-    logger.error("需要安装并启用 koishi-plugin-gamedig 插件");
-    return;
-  }
-  if (!ctx.puppeteer) {
-    logger.error("需要安装并启用 koishi-plugin-puppeteer 插件");
-    return;
-  }
-  if (!ctx.database) {
-    logger.error("需要安装并启用数据库插件以存储服务器列表");
-    return;
-  }
-  ctx.model.extend("csss_server", {
-    id: "unsigned",
-    address: "string"
-  }, {
-    primary: "id",
-    autoInc: true,
-    unique: ["address"]
-  });
-  async function getServerList() {
-    const records = await ctx.database.get("csss_server", {}, ["id", "address"]);
-    return records.sort((a, b) => a.id - b.id).map((r) => r.address);
-  }
-  __name(getServerList, "getServerList");
-  async function addServer(address) {
-    try {
-      await ctx.database.create("csss_server", { address });
-      return true;
-    } catch (error) {
-      if (error.message.includes("UNIQUE")) return false;
-      throw error;
-    }
-  }
-  __name(addServer, "addServer");
-  async function removeServerByIndex(index) {
-    const records = await ctx.database.get("csss_server", {}, ["id"]);
-    if (index < 1 || index > records.length) return false;
-    await ctx.database.remove("csss_server", { id: records[index - 1].id });
-    return true;
-  }
-  __name(removeServerByIndex, "removeServerByIndex");
-  async function clearServers() {
-    const count = (await ctx.database.get("csss_server", {}, ["id"])).length;
-    if (count === 0) return 0;
-    await ctx.database.remove("csss_server", {});
-    return count;
-  }
-  __name(clearServers, "clearServers");
-  function parseAddress(input) {
-    if (typeof input !== "string") throw new Error(`地址必须是字符串`);
-    let address = input.replace(/^(http|https|udp|tcp):\/\//, "");
-    const ipv6WithPortMatch = address.match(/^\[([^\]]+)\]:(\d+)$/);
-    if (ipv6WithPortMatch) {
-      const port = parseInt(ipv6WithPortMatch[2], 10);
-      if (port >= 1 && port <= 65535) return { host: ipv6WithPortMatch[1], port };
-      throw new Error("端口无效");
-    }
-    const ipv6OnlyMatch = address.match(/^\[([^\]]+)\]$/);
-    if (ipv6OnlyMatch) return { host: ipv6OnlyMatch[1], port: 27015 };
-    const parts = address.split(":");
-    if (parts.length === 2) {
-      const port = parseInt(parts[1], 10);
-      if (port >= 1 && port <= 65535) return { host: parts[0], port };
-      throw new Error("端口无效");
-    }
-    if (parts.length === 1) return { host: parts[0], port: 27015 };
-    throw new Error(`无效的地址格式 "${input}"。支持: IP:端口, 域名:端口, [IPv6]:端口`);
-  }
-  __name(parseAddress, "parseAddress");
-  async function queryServer(host, port) {
-    const cacheKey = `${host}:${port}`;
-    const now = Date.now();
-    if (config.cacheTime > 0) {
-      const cached = cache.get(cacheKey);
-      if (cached && now - cached.timestamp < config.cacheTime) {
-        return cached.data;
-      }
-    }
-    let lastError;
-    for (let i = 0; i <= config.retryCount; i++) {
-      try {
-        const result = await ctx.gamedig.query({
-          type: "csgo",
-          host,
-          port,
-          maxAttempts: 1,
-          socketTimeout: config.timeout,
-          attemptTimeout: config.timeout
-        });
-        const data = { game: "csgo", result };
-        if (config.cacheTime > 0) {
-          cache.set(cacheKey, { timestamp: now, data });
-        }
-        return data;
-      } catch (error) {
-        lastError = error;
-        if (i < config.retryCount) await new Promise((resolve) => setTimeout(resolve, 1e3));
-      }
-    }
-    throw new Error(`无法连接到服务器 ${lastError instanceof Error ? lastError.message : "未知错误"}`);
-  }
-  __name(queryServer, "queryServer");
-  async function queryServers(serversToQuery) {
-    const startTime = Date.now();
-    const results = await Promise.allSettled(
-      serversToQuery.map(async (server, index) => {
-        try {
-          const { host, port } = parseAddress(server);
-          const data = await queryServer(host, port);
-          return { index: index + 1, server, success: true, data };
-        } catch (error) {
-          return { index: index + 1, server, success: false, error: error.message };
-        }
-      })
-    );
-    return {
-      results: results.map((res, idx) => res.status === "fulfilled" ? res.value : { index: idx + 1, server: serversToQuery[idx], success: false, error: "未知错误" }),
-      queryTime: Date.now() - startTime,
-      serversToQuery
-    };
-  }
-  __name(queryServers, "queryServers");
-  function generateTextTable(results, serversToQuery, queryTime, title = "批量查询结果") {
-    const successful = results.filter((r) => r.success).length;
-    let message = `📊 ${title} (${utils.formatTime(queryTime)})
-✅ 成功 ${successful} 个 ❌ 失败 ${results.length - successful} 个
-
-`;
-    results.forEach((result, idx) => {
-      const num = (idx + 1).toString().padStart(2, " ");
-      if (result.success && result.data) {
-        const d = result.data.result;
-        const name2 = utils.cleanName(d.name || "未知");
-        const truncated = utils.truncateText(name2, 12);
-        const paddedName = utils.padEndVisual(truncated, 24);
-        message += `${num} ${paddedName} ${d.players.length}/${d.maxplayers}
-`;
-      } else {
-        message += `${num} ${serversToQuery[idx].padEnd(20)} ❌ 查询失败
-`;
-      }
-    });
-    return message;
-  }
-  __name(generateTextTable, "generateTextTable");
-  function formatServerInfo(data) {
-    const r = data.result;
-    const lines = [
-      ` Counter-Strike 服务器
-`,
-      r.name ? `🏷️ 名称 ${utils.cleanName(r.name)}` : null,
-      r.map ? `🗺️ 地图 ${r.map}` : null,
-      `👥 玩家 ${r.players.length}/${r.maxplayers}${r.bots.length ? ` (${r.bots.length} Bot)` : ""}`,
-      config.showPassword && r.password !== void 0 ? `🔒 密码 ${r.password ? "是 🔐" : "否 🔓"}` : null,
-      r.ping ? `📶 Ping ${utils.formatPing(r.ping)}` : null,
-      r.connect ? `🔗 连接 ${r.connect}` : `📍 地址 ${r.host || "未知"}:${r.port || "未知"}`,
-      config.showVAC && r.raw?.secure !== void 0 ? `🛡️ VAC ${r.raw.secure ? "启用 ✅" : "关闭 ❌"}` : null
-    ];
-    return lines.filter(Boolean).join("\n");
-  }
-  __name(formatServerInfo, "formatServerInfo");
-  function formatPlayers(players) {
-    if (!players.length) return "👤 服务器当前无在线玩家";
-    const sorted = [...players].sort((a, b) => utils.cleanName(a.name).localeCompare(utils.cleanName(b.name)));
-    const display = sorted.slice(0, config.maxPlayers);
-    let msg = `👤 在线玩家 (${players.length}人)
-`;
-    display.forEach((p, i) => msg += `${i + 1}. ${utils.cleanName(p.name)}
-`);
-    if (players.length > config.maxPlayers) msg += `... 还有 ${players.length - config.maxPlayers} 位玩家未显示`;
-    return msg.trim();
-  }
-  __name(formatPlayers, "formatPlayers");
-  function getBaseCSS() {
-    return `
-      * { margin: 0; padding: 0; box-sizing: border-box; }
-      body { 
-        background: #1c1c1fcc; 
-        font-family: ${config.fontFamily}; 
-        width: ${config.imageWidth}px; 
-        min-height: ${config.imageHeight}px; 
-        padding: 40px; 
-        color: #71717a; 
-        position: relative; 
-        border: 2px solid #2e2e33; 
-        font-size: 24px; /* 基础字体大小，原 fontSize 默认值 */
-      }
-      .corner { position: absolute; width: 25px; height: 25px; border-color: #fbbf24; border-style: solid; border-width: 0; }
-      .corner-tl { top: 2px; left: 2px; border-top-width: 3px; border-left-width: 3px; }
-      .corner-tr { top: 2px; right: 2px; border-top-width: 3px; border-right-width: 3px; }
-      .corner-bl { bottom: 2px; left: 2px; border-bottom-width: 3px; border-left-width: 3px; }
-      .corner-br { bottom: 2px; right: 2px; border-bottom-width: 3px; border-right-width: 3px; }
-      .divider { height: 2px; background: #2e2e33; margin: 20px 0; }
-      .timestamp { margin-top: 30px; font-size: 0.8em; color: #666666; text-align: left; }
-      ${config.customCSS ? `
-/* 用户自定义样式 */
-${config.customCSS}
-` : ""}
-    `;
-  }
-  __name(getBaseCSS, "getBaseCSS");
-  function generateServerHTML(data, host, port) {
-    const r = data.result;
-    const pCount = r.players.length;
-    let playersHTML = "";
-    if (pCount === 0) {
-      playersHTML = `<div class="player-row" style="color: #aaaaaa;">服务器当前无玩家在线</div>`;
-    } else {
-      const sorted = [...r.players].sort((a, b) => utils.cleanName(a.name).localeCompare(utils.cleanName(b.name))).slice(0, config.maxPlayers);
-      const isTwoCols = pCount > 10;
-      if (isTwoCols) {
-        const half = Math.ceil(sorted.length / 2);
-        const renderCol = /* @__PURE__ */ __name((arr) => arr.map((p) => `<div class="player-row">${utils.escapeHtml(utils.truncateText(utils.cleanName(p.name), 20))}</div>`).join(""), "renderCol");
-        playersHTML = `<div style="display: flex; gap: 40px;"><div>${renderCol(sorted.slice(0, half))}</div><div>${renderCol(sorted.slice(half))}</div></div>`;
-      } else {
-        playersHTML = sorted.map((p) => `<div class="player-row">${utils.escapeHtml(utils.truncateText(utils.cleanName(p.name), 20))}</div>`).join("");
-      }
-      if (pCount > config.maxPlayers) {
-        playersHTML += `<div class="player-row" style="color: #aaaaaa; font-style: italic;">... 还有 ${pCount - config.maxPlayers} 位玩家未显示</div>`;
-      }
-    }
-    return `<!DOCTYPE html><html><head><meta charset="UTF-8"><style>
-      ${getBaseCSS()}
-      .title { text-align: center; font-size: 1.5em; color: #71717a; margin-bottom: 20px; }
-      .server-name { text-align: center; font-size: 1.8em; font-weight: bold; color: #fbbf24; margin: 10px 0 20px; word-break: break-word; }
-      .info-row { display: flex; justify-content: space-between; margin: 15px 0; font-size: 1em; }
-      .player-section { margin-top: 20px; }
-      .player-section-title { font-size: 1em; font-weight: bold; color: #fcf8de; margin-bottom: 10px; }
-      .player-row { font-size: 0.9em; color: #dddddd; line-height: 1.8; }
-    </style></head><body>
-      <div class="corner corner-tl"></div><div class="corner corner-tr"></div><div class="corner corner-bl"></div><div class="corner corner-br"></div>
-      <div class="title">[服务器状态查询]</div>
-      <div class="server-name">${utils.escapeHtml(utils.cleanName(r.name || "未知服务器"))}</div>
-      <div class="divider"></div>
-      <div class="info-row"><span>地图: ${utils.escapeHtml(r.map || "未知")}</span><span>IP: ${utils.escapeHtml(`${host}:${port}`)}</span></div>
-      <div class="info-row"><span style="color: ${utils.getPlayerColor(pCount)};">人数: ${pCount}/${r.maxplayers}${r.bots.length ? ` (${r.bots.length} Bot)` : ""}</span><span style="color: ${utils.getPingColor(r.ping)};">Ping: ${r.ping ? r.ping + "ms" : "未知"}</span></div>
-      <div class="player-section"><div class="player-section-title">在线玩家</div><div class="divider" style="margin: 5px 0 15px;"></div>${playersHTML}</div>
-      <div class="timestamp">查询时间: ${(/* @__PURE__ */ new Date()).toLocaleString("zh-CN")}</div>
-    </body></html>`;
-  }
-  __name(generateServerHTML, "generateServerHTML");
-  function generateBatchHTML(results, serversToQuery, queryTime) {
-    const successful = results.filter((r) => r.success).length;
-    let serversHTML = results.map((result, index) => {
-      if (result.success && result.data) {
-        const d = result.data.result;
-        return `<div class="server-item">
-          <div class="server-header"><span class="server-index">${index + 1}.</span><span class="server-name">${utils.escapeHtml(utils.cleanName(d.name || "未知"))}</span><span class="server-players" style="color: ${utils.getPlayerColor(d.players.length)};">${d.players.length}/${d.maxplayers}</span></div>
-          <div class="server-details"><span class="server-addr">${utils.escapeHtml(serversToQuery[index])}</span></div>
-          <div class="server-details"><span class="server-map">地图: ${utils.escapeHtml(d.map || "")}</span><span class="server-ping" style="color: ${utils.getPingColor(d.ping)};">延迟: ${d.ping}ms</span></div>
-        </div>`;
-      }
-      return `<div class="server-item error">
-        <div class="server-header"><span class="server-index">${index + 1}.</span><span class="server-name">${utils.escapeHtml(serversToQuery[index])}</span><span class="server-status">❌ 查询失败</span></div>
-        <div class="server-details error-msg">${utils.escapeHtml(result.error || "未知错误")}</div>
-      </div>`;
-    }).join("");
-    return `<!DOCTYPE html><html><head><meta charset="UTF-8"><style>
-      ${getBaseCSS()}
-      .title { text-align: center; font-size: 1.8em; color: #71717a; margin-bottom: 20px; font-weight: bold; }
-      .stats { display: flex; justify-content: space-between; font-size: 1em; margin-bottom: 10px; }
-      .divider { background: #FFD700; margin: 15px 0 30px; }
-      .server-item { margin-bottom: 30px; border-bottom: 1px solid #555555; padding-bottom: 20px; }
-      .server-item:last-child { border-bottom: none; }
-      .server-header { display: flex; align-items: center; gap: 10px; font-size: 1.2em; font-weight: bold; color: #ffffff; margin-bottom: 8px; }
-      .server-index { color: #fbbf24; }
-      .server-players { margin-left: auto; }
-      .server-details { display: flex; flex-wrap: wrap; gap: 20px; font-size: 0.9em; color: #aaaaaa; position: relative; }
-      .server-details span { white-space: nowrap; }
-      .server-details .server-ping {position: absolute;right: 0;font-size: 24px;}
-      .error .server-name { color: #c03f36; }
-      .error-msg { color: #c03f36; font-size: 1em; }
-    </style></head><body>
-      <div class="corner corner-tl"></div><div class="corner corner-tr"></div><div class="corner corner-bl"></div><div class="corner corner-br"></div>
-      <div class="title">[服务器状态批量查询]</div>
-      <div class="stats"><span>查询时间: ${(/* @__PURE__ */ new Date()).toLocaleString("zh-CN")}</span><span>耗时: ${utils.formatTime(queryTime)} | 成功: ${successful}/${results.length}</span></div>
-      <div class="divider"></div>
-      ${serversHTML}
-      <div class="timestamp">📋 输入 \`cs 服务器地址\` 查询单个服务器</div>
-    </body></html>`;
-  }
-  __name(generateBatchHTML, "generateBatchHTML");
-  async function renderToImage(html) {
-    const page = await ctx.puppeteer.page();
-    try {
-      await page.setViewport({ width: config.imageWidth, height: config.imageHeight, deviceScaleFactor: 2 });
-      await page.setContent(html, { waitUntil: "load" });
-      return await page.screenshot({ fullPage: true, type: "png" });
-    } finally {
-      await page.close().catch(() => {
-      });
-    }
-  }
-  __name(renderToImage, "renderToImage");
-  ctx.command("cs <address:string>", "查询服务器状态").alias("查询").alias("server").option("image", "-i 生成图片横幅").option("text", "-t 输出文本信息").option("clear", "-c 清除缓存").action(async ({ options }, address) => {
-    if (!address) return "使用格式 cs [地址:端口]\n示例 cs 127.0.0.1:27015 cs edgebug.cn";
-    if (options?.clear) {
-      const count = cache.size;
-      cache.clear();
-      return `已清除 ${count} 条缓存记录`;
-    }
-    try {
-      const { host, port } = parseAddress(address);
-      const data = await queryServer(host, port);
-      const shouldGenImage = options?.image || config.generateImage && !options?.text;
-      if (shouldGenImage) {
-        try {
-          return import_koishi.h.image(await renderToImage(generateServerHTML(data, host, port)), "image/png");
-        } catch (imgErr) {
-          logger.error("生成图片失败", imgErr);
-          return `生成图片失败，已转为文本输出。
-
-${formatServerInfo(data)}
-
-${formatPlayers(data.result.players)}`;
-        }
-      }
-      return `${formatServerInfo(data)}
-
-${formatPlayers(data.result.players)}`;
-    } catch (error) {
-      const err = error;
-      let msg = `查询失败: ${err.message}
-
-`;
-      if (err.message.includes("无效的地址格式")) msg += "地址格式应为 地址:端口，默认端口27015";
-      else msg += "请检查地址、防火墙及服务器类型";
-      return msg;
-    }
-  });
-  ctx.command("cs.status", "检查插件状态和配置").action(async () => {
-    const gamedigStatus = ctx.gamedig ? "✅ 可用" : "❌ 不可用";
-    let puppeteerStatus = "❌ 不可用";
-    if (ctx.puppeteer) {
-      try {
-        const page = await ctx.puppeteer.page();
-        await page.setContent("<div>test</div>");
-        await page.close();
-        puppeteerStatus = "✅ 可用";
-      } catch (e) {
-        puppeteerStatus = `❌ 不可用`;
-      }
-    }
-    return `✅ CS服务器查询插件状态
-💾 缓存数量: ${cache.size}
-🗄️ 数据库服务器数量: ${(await getServerList()).length}
-🕹️ Gamedig: ${gamedigStatus}
-🖼️ Puppeteer: ${puppeteerStatus}
-⚙️ 配置: 超时=${config.timeout}ms 缓存=${config.cacheTime}ms 重试=${config.retryCount} 最大玩家=${config.maxPlayers} 图片=${config.generateImage ? "是" : "否"}`;
-  });
-  ctx.command("cs.help", "查看帮助").action(() => `🔫 CS服务器查询插件帮助
-
-📝 单服查询: cs [地址:端口]
-选项: -i 图片, -t 文本, -c 清除缓存
-
-🎯 批量查询: csss [地址1 地址2 ...]  (不指定地址则查询数据库列表)
-管理命令:
-csss -l                查看数据库列表
-csss -a <地址:端口>    添加服务器
-csss -r <序号>         移除服务器
-csss -c                清空数据库列表
-
-📋 状态: cs.status
-💡 默认端口27015，支持IPv6 (如 [::1]:27015)`);
-  ctx.command("csss", "批量查询服务器状态").alias("批量查询").option("list", "-l 显示配置的服务器列表").option("add", "-a <address:string> 添加服务器到列表").option("remove", "-r <index:number> 从列表中移除服务器").option("clear", "-c 清空服务器列表").option("image", "-i 生成图片横幅").option("text", "-t 输出文本信息").action(async ({ session, options }, ...addresses) => {
-    if (options?.list) {
-      const list = await getServerList();
-      if (!list.length) return "📋 服务器列表为空，请使用 csss -a 地址:端口 添加";
-      return "📋 数据库中的服务器列表\n" + list.map((s, i) => `${i + 1}. ${s}`).join("\n");
-    }
-    if (options?.add !== void 0) {
-      if (typeof options.add !== "string" || !options.add.trim()) return "❌ 请提供要添加的服务器地址\n正确用法：csss -a 127.0.0.1:27015";
-      try {
-        parseAddress(options.add);
-        const added = await addServer(options.add);
-        if (!added) return `⚠️ 服务器 ${options.add} 已存在于列表中`;
-        return `✅ 已添加服务器 ${options.add}
-当前列表 ${(await getServerList()).length} 个服务器`;
-      } catch (error) {
-        return `❌ 添加失败: ${error.message}`;
-      }
-    }
-    if (options?.remove !== void 0) {
-      const index = options.remove;
-      if (typeof index !== "number" || !Number.isInteger(index) || index < 1) {
-        return "❌ 请提供有效的服务器序号（正整数）";
-      }
-      const success = await removeServerByIndex(options.remove);
-      if (success) return `✅ 已移除序号 ${options.remove}
-当前列表 ${(await getServerList()).length} 个服务器`;
-      return `❌ 索引无效，请输入 1-${(await getServerList()).length} 之间的数字`;
-    }
-    if (options?.clear) {
-      return `✅ 已清空服务器列表，共移除 ${await clearServers()} 个服务器`;
-    }
-    let serversToQuery = addresses.length > 0 ? addresses : await getServerList();
-    if (!serversToQuery.length) return "❌ 没有可查询的服务器\n请使用 csss -a 地址:端口 添加服务器\n或使用 csss 地址1 地址2 ... 临时查询";
-    const maxServers = 10;
-    if (serversToQuery.length > maxServers) {
-      serversToQuery = serversToQuery.slice(0, maxServers);
-      if (session) session.send(`⚠️ 服务器数量超过限制，仅查询前 ${maxServers} 个`);
-    }
-    try {
-      const { results, queryTime } = await queryServers(serversToQuery);
-      const shouldGenImage = options?.image || config.generateImage && !options?.text;
-      if (shouldGenImage) {
-        try {
-          return import_koishi.h.image(await renderToImage(generateBatchHTML(results, serversToQuery, queryTime)), "image/png");
-        } catch (imgErr) {
-          logger.error("生成批量查询图片失败", imgErr);
-        }
-      }
-      return generateTextTable(results, serversToQuery, queryTime) + "\n📋 输入 `cs 服务器地址` 查询单个服务器";
-    } catch (error) {
-      return `❌ 批量查询失败: ${error.message}`;
-    }
-  });
-  ctx.on("dispose", () => cache.clear());
-}
-__name(apply, "apply");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Config,
-  apply,
-  inject,
-  name
-});