koishi-plugin-jscn-aaaquery 1.0.21 → 1.1.0

package/lib/index.d.ts

@@ -5,6 +5,7 @@ export interface Config {
     password: string;
     baseUrl: string;
     radiusApiUrl?: string;
+    captchaMode?: 'interactive';
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -32,7 +32,9 @@ var Config = import_koishi.Schema.object({
   password: import_koishi.Schema.string().required().description("运维系统登录密码").default("admin"),
   baseUrl: import_koishi.Schema.string().default("http://172.16.251.75:8090/nms/api").description("运维系统API地址"),
   // 添加RADIUS API的配置项
-  radiusApiUrl: import_koishi.Schema.string().description("RADIUS API基础URL").default("http://111.208.114.248:28210/api/radius")
+  radiusApiUrl: import_koishi.Schema.string().description("RADIUS API基础URL").default("http://111.208.114.248:28210/api/radius"),
+  // 验证码模式
+  captchaMode: import_koishi.Schema.const("interactive").description("登录验证码获取方式（发送图片到对话，用户输入）").default("interactive")
 });
 function evaluateOpticalPower(power) {
   if (power === "设备不在线" || power === void 0 || power === null) {
@@ -83,6 +85,7 @@ function apply(ctx, config) {
   const requestWaitQueue = [];
   const messageQueue = [];
   let isProcessingMessage = false;
+  let currentSession = null;
   const MESSAGE_TIMEOUT2 = 1 * 60 * 1e3;
   const MESSAGE_CLEAN_INTERVAL2 = 60 * 1e3;
   const MAX_QUEUE_LENGTH = 50;
@@ -260,7 +263,7 @@ function apply(ctx, config) {
       refreshTokenInBackground();
       return currentToken;
     }
-    return refreshToken();
+    return refreshToken(currentSession);
   }
   __name(getToken, "getToken");
   async function refreshTokenInBackground() {
@@ -274,28 +277,107 @@ function apply(ctx, config) {
     }
   }
   __name(refreshTokenInBackground, "refreshTokenInBackground");
-  async function refreshToken() {
+  const captchaPendingMap = /* @__PURE__ */ new Map();
+  const CAPTCHA_TIMEOUT = 5 * 60 * 1e3;
+  setInterval(() => {
+    const now = Date.now();
+    for (const [key, task] of captchaPendingMap) {
+      if (now - task.timestamp > CAPTCHA_TIMEOUT) {
+        task.reject(new Error("验证码输入超时（5分钟），登录已取消"));
+        captchaPendingMap.delete(key);
+        console.log(`清理超时的验证码等待任务: ${key}`);
+      }
+    }
+  }, 30 * 1e3);
+  function extractBase64(dataUri) {
+    const commaIdx = dataUri.indexOf(",");
+    if (commaIdx >= 0) return dataUri.substring(commaIdx + 1);
+    return dataUri;
+  }
+  __name(extractBase64, "extractBase64");
+  async function fetchCaptcha() {
+    const response = await ctx.http.get(`${config.baseUrl}/admin/captcha`, {
+      headers: {
+        "Accept": "application/json"
+      },
+      timeout: 1e4
+    });
+    if (response.status === 200 && response.data && response.data.captchaKey && response.data.captchaImage) {
+      return {
+        captchaKey: response.data.captchaKey,
+        captchaImage: response.data.captchaImage
+      };
+    }
+    throw new Error(`获取验证码失败：${response.message || "未知错误"}`);
+  }
+  __name(fetchCaptcha, "fetchCaptcha");
+  async function refreshToken(session) {
     try {
       console.log("开始登录请求刷新token...");
       await waitForRequestSlot();
-      const response = await ctx.http.post(
-        `${config.baseUrl}/admin/login`,
-        `loginName=${encodeURIComponent(config.loginName)}&pwd=${encodeURIComponent(config.password)}`,
-        {
-          headers: {
-            "Content-Type": "application/x-www-form-urlencoded",
-            "Accept": "application/json"
+      let captchaKey = "";
+      let captchaCode = "";
+      if (config.captchaMode === "interactive") {
+        if (!session) {
+          throw new Error("交互式验证码需要 session，但未检测到用户会话，请稍后重试");
+        }
+        const MAX_CAPTCHA_ATTEMPTS = 5;
+        const sessionKey = `${session.userId || "anon"}:${session.channelId || "dm"}`;
+        for (let attempt = 1; attempt <= MAX_CAPTCHA_ATTEMPTS; attempt++) {
+          captchaPendingMap.delete(sessionKey);
+          const { captchaKey: key, captchaImage } = await fetchCaptcha();
+          captchaKey = key;
+          try {
+            const base64Data = extractBase64(captchaImage);
+            const promptText = attempt > 1 ? `🔐 验证码错误，请重新输入新图中的验证码（第${attempt}/${MAX_CAPTCHA_ATTEMPTS}次）` : "🔐 请输入图中验证码（5分钟内有效，超时需重新发起查询）";
+            await session.send([
+              import_koishi.h.image(Buffer.from(base64Data, "base64"), "image/png"),
+              promptText
+            ]);
+          } catch (sendError) {
+            console.error("发送验证码图片失败:", sendError);
+            throw new Error("发送验证码图片失败，请检查图片发送权限");
           }
+          captchaCode = await new Promise((resolve, reject) => {
+            captchaPendingMap.set(sessionKey, {
+              session,
+              captchaKey,
+              captchaImage,
+              resolve,
+              reject,
+              timestamp: Date.now()
+            });
+            console.log(`验证码等待任务已注册: ${sessionKey}, captchaKey: ${captchaKey}, 第${attempt}轮`);
+          });
+          const response = await ctx.http.post(
+            `${config.baseUrl}/admin/login`,
+            `loginName=${encodeURIComponent(config.loginName)}&pwd=${encodeURIComponent(config.password)}&captchaKey=${encodeURIComponent(captchaKey)}&captchaCode=${encodeURIComponent(captchaCode)}`,
+            {
+              headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Accept": "application/json"
+              }
+            }
+          );
+          console.log("登录响应:", JSON.stringify(response, null, 2));
+          if (response.status === 200 && response.data && response.data.token) {
+            currentToken = response.data.token;
+            tokenExpireTime = response.data.timeStamp * 1e3;
+            console.log("获取新token成功，过期时间:", new Date(tokenExpireTime).toLocaleString());
+            return currentToken;
+          }
+          const message = response.data?.message || response.message || "";
+          if (message.includes("验证码") || message.includes("captcha")) {
+            console.log(`验证码错误，第${attempt}轮失败，准备进入第${attempt + 1}轮`);
+            captchaPendingMap.delete(sessionKey);
+            if (attempt === MAX_CAPTCHA_ATTEMPTS) {
+              throw new Error("验证码错误次数过多，请稍后重新发起查询");
+            }
+            continue;
+          }
+          throw new Error(`登录失败：${message || "未知错误"}`);
         }
-      );
-      console.log("登录响应:", JSON.stringify(response, null, 2));
-      if (response.status === 200 && response.data && response.data.token) {
-        currentToken = response.data.token;
-        tokenExpireTime = response.data.timeStamp * 1e3;
-        console.log("获取新token成功，过期时间:", new Date(tokenExpireTime).toLocaleString());
-        return currentToken;
       }
-      throw new Error(`登录失败：${response.message || "未知错误"}`);
     } catch (error) {
       console.error("登录错误详情:", error);
       if (error.response) {
@@ -647,40 +729,77 @@ function apply(ctx, config) {
   __name(queryOrderLog, "queryOrderLog");
   async function queryRadiusUser(account) {
     return addToQueue("radiusUser", { account }, async () => {
-      try {
-        console.log("开始查询RADIUS用户信息...");
-        const response = await ctx.http.post(
-          `${config.radiusApiUrl}/userquery`,
-          {
-            login_name: account,
-            org_code: "403",
-            // 固定值
-            channel: "ALL"
-            // 固定值
-          },
-          {
-            headers: {
-              "Content-Type": "application/json",
-              "Accept": "application/json"
+      const maxRetries = 2;
+      let lastError = null;
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+          console.log(`开始查询RADIUS用户信息... (第${attempt}次尝试)`);
+          console.log(`RADIUS API地址: ${config.radiusApiUrl}/userquery`);
+          const response = await ctx.http.post(
+            `${config.radiusApiUrl}/userquery`,
+            {
+              login_name: account,
+              org_code: "403",
+              // 固定值
+              channel: "ALL"
+              // 固定值
             },
-            timeout: 2e4
-            // 设置20秒超时，避免长时间无响应
+            {
+              headers: {
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+                "User-Agent": "JSCN-AAAQuery/1.0"
+              },
+              timeout: 15e3
+              // 减少超时时间到15秒
+            }
+          );
+          console.log("RADIUS查询成功，响应:", JSON.stringify(response, null, 2));
+          return response;
+        } catch (error) {
+          lastError = error;
+          console.error(`RADIUS查询第${attempt}次尝试失败:`, error.message || error);
+          if (error.code) {
+            console.error(`错误代码: ${error.code}`);
           }
-        );
-        console.log("查询响应:", JSON.stringify(response, null, 2));
-        return response;
-      } catch (error) {
-        console.error("查询RADIUS用户错误详情:", error);
-        if (error.response) {
-          console.error("错误响应:", error.response.data);
+          if (error.cause) {
+            console.error(`错误原因: ${error.cause.message || error.cause}`);
+            if (error.cause.code) {
+              console.error(`原因代码: ${error.cause.code}`);
+            }
+          }
+          if (error.response) {
+            console.error("HTTP响应状态:", error.response.status);
+            console.error("HTTP响应数据:", error.response.data);
+          }
+          const isNetworkError = error.code === "UND_ERR_CONNECT_TIMEOUT" || error.code === "UND_ERR_SOCKET" || error.message?.includes("fetch failed") || error.message?.includes("timeout") || error.message?.includes("network");
+          if (isNetworkError && attempt < maxRetries) {
+            console.log(`网络错误，${attempt < maxRetries ? "准备重试" : "重试次数已用完"}`);
+            await new Promise((resolve) => setTimeout(resolve, 2e3 * attempt));
+            continue;
+          }
+          break;
         }
-        const fallbackResponse = {
-          code: "ERROR",
-          message: `查询RADIUS系统失败: ${error.message || "未知错误，可能是网络连接问题"}`,
-          data: null
-        };
-        return fallbackResponse;
       }
+      console.error("RADIUS查询最终失败，所有重试已用完");
+      let errorMessage = "查询RADIUS系统失败";
+      if (lastError?.code === "UND_ERR_CONNECT_TIMEOUT") {
+        errorMessage = "RADIUS服务器连接超时，请检查网络连接或服务器状态";
+      } else if (lastError?.code === "UND_ERR_SOCKET") {
+        errorMessage = "RADIUS服务器网络连接失败，请检查网络配置";
+      } else if (lastError?.message?.includes("fetch failed")) {
+        errorMessage = "RADIUS服务器请求失败，可能是网络问题或服务器不可达";
+      } else if (lastError?.response?.status) {
+        errorMessage = `RADIUS服务器返回错误状态码: ${lastError.response.status}`;
+      } else {
+        errorMessage = `RADIUS查询失败: ${lastError?.message || "未知错误"}`;
+      }
+      const fallbackResponse = {
+        code: "ERROR",
+        message: errorMessage,
+        data: null
+      };
+      return fallbackResponse;
     });
   }
   __name(queryRadiusUser, "queryRadiusUser");
@@ -856,6 +975,7 @@ function apply(ctx, config) {
         return;
       }
       console.log("开始处理消息队列中的任务");
+      currentSession = task.session || null;
       const result = await task.handler();
       if (result && task.session?.send) {
         const formattedResult = formatOutputMessage(result);
@@ -1032,6 +1152,26 @@ function apply(ctx, config) {
     }
   }
   __name(smartQueryMacAddress, "smartQueryMacAddress");
+  ctx.middleware(async (session, next) => {
+    const input = (session.stripped?.content || session.content || "").trim();
+    if (!input) return next();
+    const sessionKey = `${session.userId || "anon"}:${session.channelId || "dm"}`;
+    const pendingTask = captchaPendingMap.get(sessionKey);
+    if (!pendingTask) {
+      return next();
+    }
+    console.log(`捕获到验证码输入: "${input}"，对应 captchaKey: ${pendingTask.captchaKey}`);
+    if (!/^[a-z0-9]{2,8}$/i.test(input)) {
+      return next();
+    }
+    captchaPendingMap.delete(sessionKey);
+    pendingTask.resolve(input.replace(/\s+/g, "").toLowerCase());
+    try {
+      await session.send("✅ 验证码已接收，正在登录...");
+    } catch (_) {
+    }
+    return;
+  });
   ctx.middleware(async (session, next) => {
     console.log("原始消息:", session.content);
     const originalInput = session.stripped.content.trim();
@@ -1583,6 +1723,53 @@ function apply(ctx, config) {
     const result = clearCache();
     return formatOutputMessage(`✅ ${result}`);
   });
+  ctx.command("强制刷新token", "强制清除缓存的token，重新获取登录验证码").action(async ({ session }) => {
+    currentToken = null;
+    tokenExpireTime = 0;
+    const token = await refreshToken(session);
+    return formatOutputMessage(`✅ Token已刷新，过期时间: ${new Date(tokenExpireTime).toLocaleString()}`);
+  });
+  async function diagnoseNetwork() {
+    const results = [];
+    results.push("🌐 网络连接诊断");
+    results.push(getSeparator());
+    try {
+      const radiusUrl = new URL(config.radiusApiUrl || "http://111.208.114.248:28210/api/radius");
+      const host = radiusUrl.hostname;
+      const port = radiusUrl.port || "80";
+      results.push(`RADIUS服务器: ${host}:${port}`);
+      try {
+        const startTime = Date.now();
+        const response = await ctx.http.get(`${config.radiusApiUrl}/health`, {
+          timeout: 5e3,
+          validateStatus: /* @__PURE__ */ __name(() => true, "validateStatus")
+          // 接受任何状态码
+        });
+        const endTime = Date.now();
+        const latency = endTime - startTime;
+        results.push(`✅ 连接正常 (延迟: ${latency}ms)`);
+        results.push(`   状态码: ${response.status || "N/A"}`);
+      } catch (error) {
+        results.push(`❌ 连接失败`);
+        if (error.code === "UND_ERR_CONNECT_TIMEOUT") {
+          results.push(`   原因: 连接超时`);
+        } else if (error.code === "UND_ERR_SOCKET") {
+          results.push(`   原因: 网络连接失败`);
+        } else {
+          results.push(`   原因: ${error.message || "未知错误"}`);
+        }
+      }
+      results.push("");
+      results.push("📋 当前配置");
+      results.push(`RADIUS API地址: ${config.radiusApiUrl || "未配置"}`);
+      results.push(`运维系统地址: ${config.baseUrl || "未配置"}`);
+    } catch (error) {
+      results.push(`❌ 诊断过程出错: ${error.message}`);
+    }
+    results.push(getSeparator());
+    return results.join("\n");
+  }
+  __name(diagnoseNetwork, "diagnoseNetwork");
   function getSystemStatus() {
     updateCacheStats();
     const hitRate = cacheStats.hits + cacheStats.misses > 0 ? Math.round(cacheStats.hits / (cacheStats.hits + cacheStats.misses) * 100) : 0;
@@ -1612,6 +1799,9 @@ function apply(ctx, config) {
   ctx.command("系统状态").alias("/系统状态").action(async ({ session }) => {
     return formatOutputMessage(getSystemStatus());
   });
+  ctx.command("网络诊断").alias("/网络诊断").action(async ({ session }) => {
+    return formatOutputMessage(await diagnoseNetwork());
+  });
   ctx.command("使用说明", "显示插件的使用方法和命令说明").alias("/使用说明").action(async ({ session }) => {
     const helpText = [
       "📋 JSCN小帮手使用说明",
@@ -1655,6 +1845,19 @@ function apply(ctx, config) {
       "  示例：",
       "    输入 GDC8510019239048 → 触发账号查询",
       "    输入 00:11:22:33:44:55 → 触发终端查询",
+      "",
+      "6. 系统管理",
+      "  命令：系统状态",
+      "  功能：查看系统运行状态、缓存统计、队列状态等。",
+      "",
+      "  命令：网络诊断",
+      "  功能：诊断RADIUS服务器网络连接状态，帮助排查连接问题。",
+      "",
+      "  命令：缓存统计",
+      "  功能：查看缓存使用情况和命中率统计。",
+      "",
+      "  命令：清理缓存",
+      "  功能：清理所有缓存数据。",
       getSeparator()
     ].join("\n");
     return formatOutputMessage(helpText);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-jscn-aaaquery",
   "description": "江苏有线无锡分公司宽带信息查询插件",
-  "version": "1.0.21",
+  "version": "1.1.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [