koishi-plugin-cunapp-val 0.0.1

package/lib/commands/set.d.ts

@@ -0,0 +1,7 @@
+import { Context } from 'koishi';
+export interface Config {
+    mongodbUrl: string;
+    mongodbDb: string;
+    Key: string;
+}
+export declare function applySet(ctx: Context, config: Config): void;

package/lib/commands/shop.d.ts

@@ -0,0 +1,7 @@
+import { Context } from 'koishi';
+export interface Config {
+    mongodbUrl: string;
+    mongodbDb: string;
+    Key: string;
+}
+export declare function applySd(ctx: Context, config: Config): void;

package/lib/database/index.d.ts

@@ -0,0 +1,9 @@
+import { Db } from 'mongodb';
+export interface Config {
+    mongodbUrl: string;
+    mongodbDb: string;
+}
+export declare function connectMongo(config: Config): Promise<Db>;
+export declare function getDb(): Db | null;
+export declare function closeMongo(): Promise<void>;
+export declare function getCollection(name: string, config: Config): Promise<import("mongodb").Collection<import("bson").Document>>;

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "val-cunapp";
+export interface Config {
+    mongodbUrl: string;
+    mongodbDb: string;
+    Key: string;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,622 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi3 = require("koishi");
+
+// src/database/index.ts
+var import_mongodb = require("mongodb");
+var import_koishi = require("koishi");
+var logger = new import_koishi.Logger("val-cunapp/database");
+var mongoClient = null;
+var mongoDb = null;
+async function connectMongo(config) {
+  try {
+    if (mongoClient) {
+      await mongoClient.close();
+    }
+  } catch (e) {
+    logger.debug("关闭旧连接失败，忽略");
+  }
+  mongoClient = null;
+  mongoDb = null;
+  mongoClient = new import_mongodb.MongoClient(config.mongodbUrl);
+  await mongoClient.connect();
+  mongoDb = mongoClient.db(config.mongodbDb);
+  return mongoDb;
+}
+__name(connectMongo, "connectMongo");
+function getDb() {
+  return mongoDb;
+}
+__name(getDb, "getDb");
+async function closeMongo() {
+  if (mongoClient) {
+    try {
+      await mongoClient.close();
+      mongoClient = null;
+      mongoDb = null;
+    } catch (e) {
+      logger.error("关闭连接失败:", e);
+    }
+  }
+}
+__name(closeMongo, "closeMongo");
+
+// src/utils/crypto.ts
+var import_crypto = __toESM(require("crypto"));
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 16;
+var TAG_LENGTH = 16;
+var SALT_LENGTH = 64;
+var KEY_LENGTH = 32;
+var ITERATIONS = 1e5;
+function getKey(salt, passphrase) {
+  return import_crypto.default.pbkdf2Sync(passphrase, salt, ITERATIONS, KEY_LENGTH, "sha512");
+}
+__name(getKey, "getKey");
+function encrypt(plaintext, passphrase) {
+  if (!passphrase) return plaintext;
+  const salt = import_crypto.default.randomBytes(SALT_LENGTH);
+  const iv = import_crypto.default.randomBytes(IV_LENGTH);
+  const key = getKey(salt, passphrase);
+  const cipher = import_crypto.default.createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([salt, iv, tag, encrypted]).toString("base64");
+}
+__name(encrypt, "encrypt");
+function decrypt(ciphertext, passphrase) {
+  if (!passphrase) return ciphertext;
+  try {
+    const raw = Buffer.from(ciphertext, "base64");
+    const salt = raw.subarray(0, SALT_LENGTH);
+    const iv = raw.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+    const tag = raw.subarray(SALT_LENGTH + IV_LENGTH, SALT_LENGTH + IV_LENGTH + TAG_LENGTH);
+    const encrypted = raw.subarray(SALT_LENGTH + IV_LENGTH + TAG_LENGTH);
+    const key = getKey(salt, passphrase);
+    const decipher = import_crypto.default.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(tag);
+    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    return decrypted.toString("utf8");
+  } catch {
+    return null;
+  }
+}
+__name(decrypt, "decrypt");
+
+// src/commands/set.ts
+function getReplyAt(session) {
+  return session.user?.valReplyAt || "";
+}
+__name(getReplyAt, "getReplyAt");
+function applySet(ctx, config) {
+  ctx.command("val.set [cookie:string]", "设置认证信息").action(async (argv) => {
+    const { session, args } = argv;
+    const prefix = getReplyAt(session);
+    const cookie = args[0];
+    if (!cookie) {
+      return `${prefix} 请提供cookie参数`;
+    }
+    if (!config.Key) {
+      return `${prefix} 请先配置加密密钥`;
+    }
+    try {
+      const db = getDb();
+      if (!db) return `${prefix} 数据库未连接`;
+      const encryptedCookie = config.Key ? encrypt(cookie, config.Key) : cookie;
+      await db.collection("val_cookies").updateOne(
+        { userId: session.userId },
+        { $set: { cookie: encryptedCookie, updatedAt: /* @__PURE__ */ new Date() } },
+        { upsert: true }
+      );
+      return `${prefix} Cookie设置成功`;
+    } catch (e) {
+      return `${prefix} Cookie设置失败: ${e.message}`;
+    }
+  });
+}
+__name(applySet, "applySet");
+
+// src/commands/shop.ts
+var import_koishi2 = require("koishi");
+
+// src/utils/shop.ts
+var import_axios = __toESM(require("axios"));
+function cleanUrl(url) {
+  return url.replace(/`/g, "").trim();
+}
+__name(cleanUrl, "cleanUrl");
+async function fetchShop(cookie) {
+  const url = "https://app.mval.qq.com/go/mlol_store/agame/user_store";
+  const headers = {
+    "Cookie": cookie,
+    "Content-Type": "application/json",
+    "Referer": "https://mval.qq.com/"
+  };
+  const body = {
+    scene: "",
+    source_game_zone: "agame",
+    game_zone: "agame"
+  };
+  const response = await import_axios.default.post(url, body, { headers });
+  const data = response.data;
+  data.data.forEach((store) => {
+    store.list.forEach((item) => {
+      item.goods_pic = cleanUrl(item.goods_pic);
+      if (item.bg_image) {
+        item.bg_image = cleanUrl(item.bg_image);
+      }
+    });
+  });
+  return data;
+}
+__name(fetchShop, "fetchShop");
+async function fetchUserProfile(cookie) {
+  try {
+    const userIdMatch = cookie.match(/userId=([^;]+)/);
+    if (!userIdMatch) return null;
+    const userId = userIdMatch[1];
+    const url = "https://app.mval.qq.com/go/user_profile/query/user";
+    const headers = {
+      "Cookie": cookie,
+      "Content-Type": "application/json",
+      "Referer": "https://mval.qq.com/"
+    };
+    const body = {
+      opUuid: userId,
+      isNeedGameInfo: 1,
+      isNeedMedal: 1,
+      isNeedDress: 1,
+      clientType: 10,
+      isNeedCommunityInfo: 1,
+      isNeedMainInfo: 1,
+      source_game_zone: "agame",
+      game_zone: "agame",
+      uuidSceneList: [{ uuid: userId }],
+      isNeedRemark: 1
+    };
+    const response = await import_axios.default.post(url, body, { headers, timeout: 15e3 });
+    const data = response.data;
+    if (data.result !== 0 || !data.data || data.data.length === 0) {
+      return null;
+    }
+    const userData = data.data[0];
+    if (!userData.gameInfoList || !Array.isArray(userData.gameInfoList) || userData.gameInfoList.length === 0) {
+      return null;
+    }
+    const valGame = userData.gameInfoList.find((g) => {
+      const gameId = String(g.gameId || "").trim().toLowerCase();
+      return gameId === "agame";
+    });
+    if (!valGame) {
+      const firstGame = userData.gameInfoList[0];
+      if (firstGame) {
+        return {
+          gameId: firstGame.gameId || "",
+          roleName: firstGame.roleName || "",
+          tier: firstGame.tier || "",
+          level: firstGame.level || 0,
+          gameHeadUrl: firstGame.gameHeadUrl || ""
+        };
+      }
+      return null;
+    }
+    return {
+      gameId: valGame.gameId || "",
+      roleName: valGame.roleName || "",
+      tier: valGame.tier || "",
+      level: valGame.level || 0,
+      gameHeadUrl: cleanUrl(valGame.gameHeadUrl || "")
+    };
+  } catch (e) {
+    return null;
+  }
+}
+__name(fetchUserProfile, "fetchUserProfile");
+
+// src/utils/render.ts
+var import_sharp = __toESM(require("sharp"));
+var import_axios2 = __toESM(require("axios"));
+function cleanUrl2(url) {
+  if (!url) return "";
+  return url.replace(/`/g, "").trim();
+}
+__name(cleanUrl2, "cleanUrl");
+async function downloadImage(url) {
+  try {
+    if (!url || !url.startsWith("http")) return null;
+    const response = await import_axios2.default.get(url, { responseType: "arraybuffer", timeout: 1e4 });
+    return Buffer.from(response.data);
+  } catch (e) {
+    return null;
+  }
+}
+__name(downloadImage, "downloadImage");
+async function composeShopImage(items, type = "m", userName = "", subtitleText = "", gameHeadUrl = "") {
+  const width = 400;
+  const height = 146;
+  const headerHeight = 122;
+  const bottomPadding = 100;
+  const padding = 8;
+  const paddingX = 30;
+  const contentWidth = width;
+  const totalHeight = headerHeight + items.length * (height + padding) + padding + bottomPadding;
+  const bgRgb = { r: 235, g: 235, b: 226 };
+  const itemRgb = { r: 0, g: 0, b: 0, alpha: 0 };
+  const shadowOpacity = type === "g" ? 0.1 : 0.4;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const composites = [];
+      const shadowComposites = [];
+      const picComposites = [];
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const y = headerHeight + i * (height + padding) + padding;
+        let itemBuffer = null;
+        const bgUrl = cleanUrl2(item.bg_image || "");
+        if (bgUrl) {
+          const bgBuffer = await downloadImage(bgUrl);
+          if (bgBuffer) {
+            try {
+              const metadata = await (0, import_sharp.default)(bgBuffer).metadata();
+              const originalWidth = metadata.width || contentWidth;
+              const originalHeight = metadata.height || height;
+              const ratio = Math.min(contentWidth / originalWidth, height / originalHeight);
+              const newWidth = Math.round(originalWidth * ratio);
+              const newHeight = Math.round(originalHeight * ratio);
+              const resizedBuffer = await (0, import_sharp.default)(bgBuffer).resize(newWidth, newHeight, { fit: "fill" }).flatten({ background: { r: 255, g: 255, b: 255, alpha: 1 } }).png({ force: true }).toBuffer();
+              const shadowOffset = 24;
+              const cornerRadius2 = 12;
+              const canvasWidth = newWidth + shadowOffset * 2;
+              const canvasHeight = newHeight + shadowOffset * 2;
+              const shadowSvg = Buffer.from(
+                `<svg width="${canvasWidth}" height="${canvasHeight}">
+                  <rect x="${shadowOffset}" y="${shadowOffset + 4}" width="${newWidth}" height="${newHeight}" rx="${cornerRadius2}" ry="${cornerRadius2}" fill="black" fill-opacity="${shadowOpacity}"/>
+                </svg>`
+              );
+              const maskSvg = Buffer.from(
+                `<svg width="${newWidth}" height="${newHeight}">
+                  <rect width="${newWidth}" height="${newHeight}" rx="${cornerRadius2}" ry="${cornerRadius2}" fill="white"/>
+                </svg>`
+              );
+              const blurredShadow = await (0, import_sharp.default)(shadowSvg).blur(18).png().toBuffer();
+              const roundedImage = await (0, import_sharp.default)(resizedBuffer).composite([{
+                input: maskSvg,
+                top: 0,
+                left: 0,
+                blend: "dest-in"
+              }]).png().toBuffer();
+              itemBuffer = await (0, import_sharp.default)(blurredShadow).composite([{
+                input: roundedImage,
+                top: shadowOffset,
+                left: shadowOffset
+              }]).png({ force: true }).toBuffer();
+              const itemNameText = item.goods_name || "";
+              const itemPrice = item.rmb_price ? `${item.rmb_price} VP` : "";
+              if (itemNameText || itemPrice) {
+                const textColor = type === "g" ? "#000000" : "#ffffff";
+                const priceColor = type === "g" ? "#000000b7" : "#ffffffb7";
+                let textElements = "";
+                if (itemPrice) {
+                  textElements += `<text x="${width - shadowOffset - 10}" y="${canvasHeight - 34}" text-anchor="end" font-family="思源黑体, Source Han Sans, Noto Sans CJK, Arial, sans-serif" font-size="16" fill="${priceColor}" font-weight="bold">${itemPrice}</text>`;
+                }
+                if (itemNameText) {
+                  textElements += `<text x="${shadowOffset + 10}" y="${canvasHeight - 34}" font-family="思源黑体, Source Han Sans, Noto Sans CJK, Arial, sans-serif" font-size="16" fill="${textColor}">${itemNameText}</text>`;
+                }
+                const textSvg = Buffer.from(
+                  `<svg width="${canvasWidth}" height="${canvasHeight}">
+                    ${textElements}
+                  </svg>`
+                );
+                const textBuffer = await (0, import_sharp.default)(textSvg).png().toBuffer();
+                itemBuffer = await (0, import_sharp.default)(itemBuffer).composite([{
+                  input: textBuffer,
+                  top: 0,
+                  left: 0
+                }]).png({ force: true }).toBuffer();
+              }
+            } catch (e) {
+              itemBuffer = null;
+            }
+          }
+        }
+        if (!itemBuffer) {
+          try {
+            itemBuffer = await (0, import_sharp.default)({
+              create: {
+                width: contentWidth,
+                height,
+                channels: 4,
+                background: { r: itemRgb.r, g: itemRgb.g, b: itemRgb.b, alpha: 1 }
+              }
+            }).png({ force: true }).toBuffer();
+          } catch (e) {
+            return null;
+          }
+        }
+        composites.push({ input: itemBuffer, top: y, left: 0 });
+        const picBuffer = await downloadImage(cleanUrl2(item.goods_pic));
+        if (picBuffer) {
+          try {
+            const picMetadata = await (0, import_sharp.default)(picBuffer).metadata();
+            const picOriginalWidth = picMetadata.width || 80;
+            const picOriginalHeight = picMetadata.height || 80;
+            const picRatio = Math.min(contentWidth * 0.7 / picOriginalWidth, height * 0.7 / picOriginalHeight);
+            const picNewWidth = Math.round(picOriginalWidth * picRatio);
+            const picNewHeight = Math.round(picOriginalHeight * picRatio);
+            const picResized = await (0, import_sharp.default)(picBuffer).resize(picNewWidth, picNewHeight, { fit: "fill" }).ensureAlpha(0.01).png({ force: true }).toBuffer();
+            const picLeft = (contentWidth - picNewWidth) / 2;
+            const picTop = y + 20 + (height - picNewHeight) / 2;
+            picComposites.push({ input: picResized, top: Math.round(picTop), left: Math.round(picLeft) });
+          } catch (e) {
+          }
+        }
+      }
+      const titleText = type === "g" ? "王国商店" : "每日商店";
+      const headerSvg = Buffer.from(
+        `<svg width="${width}" height="${headerHeight}">
+          <text x="${paddingX}" y="80" font-family="思源黑体, Source Han Sans, Noto Sans CJK, Arial, sans-serif" font-size="46" font-weight="bold" fill="#333">${userName}</text>
+          <text x="${paddingX}" y="118" font-family="思源黑体, Source Han Sans, Noto Sans CJK, Arial, sans-serif" font-size="26" font-weight="bold" fill="#333">的${titleText}</text>
+        </svg>`
+      );
+      const headerBuffer = await (0, import_sharp.default)(headerSvg).png().toBuffer();
+      const baseImage = (0, import_sharp.default)({
+        create: {
+          width,
+          height: totalHeight,
+          channels: 4,
+          background: { r: bgRgb.r, g: bgRgb.g, b: bgRgb.b, alpha: 1 }
+        }
+      });
+      let finalComposites = [...composites];
+      if (shadowComposites.length > 0) {
+        finalComposites = [...finalComposites, ...shadowComposites];
+      }
+      if (picComposites.length > 0) {
+        finalComposites = [...finalComposites, ...picComposites];
+      }
+      if (subtitleText) {
+        const footerHeight = 50;
+        const footerY = totalHeight - footerHeight;
+        const avatarX = paddingX;
+        const avatarY = footerY - 20;
+        const avatarSize = 25;
+        const textX = paddingX + 35;
+        if (gameHeadUrl && gameHeadUrl.startsWith("http")) {
+          const avatarBuffer = await downloadImage(gameHeadUrl);
+          if (avatarBuffer) {
+            try {
+              const avatarResized = await (0, import_sharp.default)(avatarBuffer).resize(avatarSize, avatarSize, { fit: "cover" }).png().toBuffer();
+              const avatarMaskSvg = Buffer.from(
+                `<svg width="${avatarSize}" height="${avatarSize}">
+                  <circle cx="${avatarSize / 2}" cy="${avatarSize / 2}" r="${avatarSize / 2}" fill="white"/>
+                </svg>`
+              );
+              const avatarRounded = await (0, import_sharp.default)(avatarResized).composite([{
+                input: avatarMaskSvg,
+                top: 0,
+                left: 0,
+                blend: "dest-in"
+              }]).png().toBuffer();
+              finalComposites.push({ input: avatarRounded, top: avatarY, left: avatarX });
+            } catch (e) {
+            }
+          }
+        }
+        const textSvg = Buffer.from(
+          `<svg width="${width}" height="${footerHeight + 20}">
+            <text x="${textX}" y="30" font-family="思源黑体, Source Han Sans, Noto Sans CJK, Arial, sans-serif" font-size="18" fill="#666">${subtitleText}</text>
+            <text x="${width / 2}" y="65" text-anchor="middle" font-family="思源黑体, Source Han Sans, Noto Sans CJK, Arial, sans-serif" font-size="16" font-weight="bold" fill="#15151553">By Xiaoming</text>
+        </svg>`
+        );
+        const textBuffer = await (0, import_sharp.default)(textSvg).png().toBuffer();
+        finalComposites.push({ input: textBuffer, top: footerY - 30, left: 0 });
+      }
+      finalComposites.push({ input: headerBuffer, top: 0, left: 0 });
+      const imageBuffer = await baseImage.composite(finalComposites).png({ force: true }).toBuffer();
+      const cornerRadius = 20;
+      const roundedSvg = Buffer.from(
+        `<svg width="${width}" height="${totalHeight}">
+          <rect x="0" y="0" width="${width}" height="${totalHeight}" rx="${cornerRadius}" ry="${cornerRadius}" fill="white"/>
+        </svg>`
+      );
+      return await (0, import_sharp.default)(imageBuffer).composite([{
+        input: roundedSvg,
+        blend: "dest-in"
+      }]).png({ force: true }).toBuffer();
+    } catch (e) {
+      if (attempt === 0) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        continue;
+      }
+      return null;
+    }
+  }
+  return null;
+}
+__name(composeShopImage, "composeShopImage");
+
+// src/commands/shop.ts
+function getReplyAt2(session) {
+  return session.user?.valReplyAt || "";
+}
+__name(getReplyAt2, "getReplyAt");
+function applySd(ctx, config) {
+  ctx.command("val.sd [type]", "获取商店信息").action(async (argv) => {
+    const { session, args } = argv;
+    const prefix = getReplyAt2(session);
+    const type = args[0] || "m";
+    if (type !== "m" && type !== "g") {
+      return `${prefix} v: 参数无效`;
+    }
+    try {
+      const db = getDb();
+      if (!db) return `${prefix} 数据库未连接`;
+      if (!config.Key) return `${prefix} 加密密钥未配置`;
+      const userData = await db.collection("val_cookies").findOne({ userId: session.userId });
+      if (!userData || !userData.cookie) {
+        return `${prefix} 请先设置Cookie，使用 val set <cookie>`;
+      }
+      const cookie = decrypt(userData.cookie, config.Key);
+      if (!cookie) {
+        return `${prefix} Cookie解密失败，请检查加密密钥`;
+      }
+      const shopData = await fetchShop(cookie);
+      if (shopData.result !== 0) {
+        return `${prefix} 获取商店失败: ${shopData.msg || shopData.err_msg}`;
+      }
+      const storeKey = type === "m" ? "dailystore" : "kingdomstore";
+      const storeInfo = shopData.data.find((s) => s.key === storeKey);
+      if (!storeInfo) {
+        return `${prefix} ${type === "m" ? "每日商店" : "王国商店"}暂无可用商品`;
+      }
+      try {
+        const userName = session.author?.name || session.user?.name || "";
+        const gameInfo = await fetchUserProfile(cookie);
+        let roleText = "";
+        let gameHeadUrl = "";
+        if (gameInfo) {
+          roleText = `${gameInfo.roleName} | Lv${gameInfo.level} | ${gameInfo.tier}`;
+          gameHeadUrl = gameInfo.gameHeadUrl;
+        }
+        const imageBuffer = await composeShopImage(storeInfo.list, type, userName, roleText, gameHeadUrl);
+        if (!imageBuffer) {
+          return `${prefix} 图片生成失败，请稍后再试`;
+        }
+        return prefix + "\n" + import_koishi2.h.image(imageBuffer, "image/png");
+      } catch (e) {
+        return `${prefix} 图片生成失败: ${e.message}`;
+      }
+    } catch (e) {
+      return `${prefix} 获取失败: ${e.message}`;
+    }
+  });
+}
+__name(applySd, "applySd");
+
+// src/index.ts
+var name = "val-cunapp";
+var Config = import_koishi3.Schema.object({
+  mongodbUrl: import_koishi3.Schema.string().description("MongoDB 连接地址").default(""),
+  Key: import_koishi3.Schema.string().description("存储信息加密密钥，请勿随意修改").default(""),
+  mongodbDb: import_koishi3.Schema.string().description("数据库名称").default("mongodb_botuser")
+});
+var logger2 = new import_koishi3.Logger("val-cunapp");
+function checkAt(session) {
+  if (session.isDirect) return "";
+  const message = session.content || "";
+  if (!message.startsWith("@")) return null;
+  const atElement = session.elements?.filter((element) => element.type == "at")?.[0];
+  const atId = atElement?.attrs?.id;
+  if (!atId || atId !== session.selfId) return null;
+  return import_koishi3.h.at(session.userId).toString();
+}
+__name(checkAt, "checkAt");
+function getReplyAt3(session) {
+  if (session.isDirect) return "";
+  return import_koishi3.h.at(session.userId).toString();
+}
+__name(getReplyAt3, "getReplyAt");
+function apply(ctx, config) {
+  ctx.middleware(async (session, next) => {
+    const message = session.content || "";
+    const strippedMessage = session.stripped?.content || "";
+    logger2.info(`消息内容: "${message}", 去掉@后内容: "${strippedMessage}", 是否群聊: ${!session.isDirect}`);
+    const isValCommand = strippedMessage.includes("val.set") || strippedMessage.includes("val.sd") || strippedMessage.trim().startsWith("val");
+    if (isValCommand) {
+      const atResult = checkAt(session);
+      session.valAt = atResult;
+      session.valReplyAt = getReplyAt3(session);
+    }
+    return next();
+  });
+  const cmd = ctx.command("val", "瓦罗兰特相关功能");
+  delete cmd["_options"].help;
+  cmd.action(async ({ session, args, options }) => {
+    logger2.info(`命令处理函数被调用: 用户=${session.userId}, 消息="${session.content}"`);
+    if (!session.isDirect) {
+      const message = session.content || "";
+      logger2.info(`群聊消息检查: 消息="${message}", 包含@机器人: ${message.includes("@" + session.selfId)}`);
+      if (!message.includes("@" + session.selfId)) {
+        logger2.warn(`群聊命令执行被阻止: 用户=${session.userId}, 群组=${session.guildId}, 消息="${message}"`);
+        return;
+      }
+      logger2.info(`群聊命令开始执行: 用户=${session.userId}, 群组=${session.guildId}, 参数=${JSON.stringify(args)}`);
+    }
+    const atResult = session.valAt || "";
+    const replyAt = session.valReplyAt || "";
+    const prefix = replyAt || atResult || "";
+    logger2.info(`回复前缀: "${prefix}"`);
+    if (options?.help) {
+      logger2.info(`显示帮助信息: 用户=${session.userId}`);
+      return `${prefix} val ~ 瓦罗兰特指令模板
+
+  val set 设置认证信息
+  val sd  获取商店信息
+
+选项：
+  -h, --help  显示帮助信息`;
+    }
+    if (args[0]) {
+      logger2.warn(`无效子指令: 用户=${session.userId}, 指令="${args[0]}"`);
+      return `${prefix} 无效的子指令：${args[0]}
+请使用 val -h 查看帮助`;
+    }
+    logger2.info(`提示使用帮助: 用户=${session.userId}`);
+    return `${prefix} 请使用 val -h 查看命令帮助`;
+  });
+  applySet(ctx, config);
+  applySd(ctx, config);
+  ctx.on("ready", async () => {
+    try {
+      await connectMongo(config);
+      logger2.info("MongoDB 连接就绪");
+    } catch (e) {
+      logger2.error("MongoDB 连接失败:", e.message);
+    }
+  });
+  ctx.on("dispose", async () => {
+    await closeMongo();
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name
+});

package/lib/utils/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare function encrypt(plaintext: string, passphrase: string): string;
+export declare function decrypt(ciphertext: string, passphrase: string): string | null;

package/lib/utils/render.d.ts

@@ -0,0 +1,11 @@
+export interface ShopItem {
+    goods_name: string;
+    goods_pic: string;
+    goods_id: string;
+    rmb_price: string;
+    quality: string;
+    like_num: string;
+    tips: string;
+    bg_image?: string;
+}
+export declare function composeShopImage(items: ShopItem[], type?: 'm' | 'g', userName?: string, subtitleText?: string, gameHeadUrl?: string): Promise<Buffer | null>;

package/lib/utils/shop.d.ts

@@ -0,0 +1,40 @@
+export interface ShopItem {
+    goods_name: string;
+    goods_pic: string;
+    goods_id: string;
+    rmb_price: string;
+    quality: string;
+    like_num: string;
+    tips: string;
+    bg_image?: string;
+}
+export interface ShopData {
+    key: string;
+    title: string;
+    time: number;
+    end_ts: number;
+    cur_ts: number;
+    list: ShopItem[];
+}
+export interface ShopResponse {
+    result: number;
+    msg: string;
+    err_msg: string;
+    req_id: string;
+    data: ShopData[];
+}
+export interface GameInfo {
+    gameId: string;
+    roleName: string;
+    tier: string;
+    level: number;
+    gameHeadUrl: string;
+}
+export interface UserProfileResponse {
+    result: number;
+    msg: string;
+    err_msg: string;
+    data: any[];
+}
+export declare function fetchShop(cookie: string): Promise<ShopResponse>;
+export declare function fetchUserProfile(cookie: string): Promise<GameInfo | null>;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "koishi-plugin-cunapp-val",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin",
+    "valorant"
+  ],
+  "contributors": [
+    "cunbot"
+  ],
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "homepage": "",
+  "peerDependencies": {
+    "koishi": "^4.18.7",
+    "mongodb": "*"
+  },
+  "devDependencies": {
+    "axios": "^1.6.2",
+    "mongodb": "^6.3.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.2",
+    "follow-redirects": "^1.15.6",
+    "form-data": "^4.0.0",
+    "proxy-from-env": "^1.1.0",
+    "sharp": "^0.34.5"
+  },
+  "koishi": {
+    "description": {
+      "en": "Valorant plugin for viewing shop and player info",
+      "zh": "瓦罗兰特商店查询和玩家信息插件(自用)"
+    },
+    "service": {
+      "required": []
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-val-cunapp
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-val-cunapp?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-val-cunapp)
+
+获取瓦罗兰特玩家信息，需要登录账户