koishi-plugin-hearthstone 1.0.0

package/lib/api.d.ts

@@ -0,0 +1,10 @@
+/** 在线搜索卡牌，返回 API 原始数据数组 */
+export declare function searchCardOnline(name: string): Promise<any[] | null>;
+/** 分页抓取全部卡牌，返回 { total, lastPage, data } */
+export declare function fetchCardPage(page: number): Promise<{
+    total: number;
+    lastPage: number;
+    data: any[];
+} | null>;
+/** 从 OSS 下载卡牌图片 */
+export declare function downloadCardImage(relativePath: string): Promise<Buffer | null>;

package/lib/db.d.ts

@@ -0,0 +1,10 @@
+export declare function searchCard_id(value: any): string;
+export declare function searchCard_img(value: any): string;
+export declare function searchCard(value: any): string;
+export declare function getCardCount(): number;
+export declare function getCardImagePath(cardId: number): string | null;
+export declare function updateCardImage(cardId: number, imageData: Buffer): void;
+/** 将一批 API 返回的卡牌数据存入本地数据库（使用事务加速） */
+export declare const storeCardsFromApi: any;
+/** 将单张 API 返回的卡牌数据存入本地数据库 */
+export declare function storeCardFromApi(card: any): void;

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "hearthstone";
+export interface Config {
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,581 @@
+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_koishi = require("koishi");
+
+// src/db.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"));
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var DB_DIR = import_path.default.resolve(__dirname, "../data");
+var DB_PATH = import_path.default.resolve(DB_DIR, "hearthstone_cards.db");
+import_fs.default.mkdirSync(DB_DIR, { recursive: true });
+var db = new import_better_sqlite3.default(DB_PATH);
+db.pragma("journal_mode = WAL");
+function ensureSchema() {
+  db.exec(`
+        CREATE TABLE IF NOT EXISTS cards (
+            id INTEGER PRIMARY KEY,
+            card_id TEXT NOT NULL,
+            dbfid INTEGER,
+            artist_name TEXT,
+            cost INTEGER,
+            card_set INTEGER,
+            card_class INTEGER,
+            card_type INTEGER,
+            collectible INTEGER,
+            tech_level INTEGER,
+            hidden INTEGER,
+            hash TEXT,
+            version TEXT,
+            image_normal TEXT,
+            image_normal_data BLOB,
+            image_battlegrounds TEXT,
+            image_battlegrounds_data BLOB,
+            tile_image TEXT,
+            tile_image_data BLOB,
+            created_at TEXT,
+            updated_at TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS card_names (
+            id INTEGER PRIMARY KEY,
+            card_id INTEGER NOT NULL,
+            name TEXT,
+            locale TEXT NOT NULL,
+            FOREIGN KEY (card_id) REFERENCES cards(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS card_texts (
+            id INTEGER PRIMARY KEY,
+            card_id INTEGER NOT NULL,
+            text TEXT,
+            plain_text TEXT,
+            locale TEXT NOT NULL,
+            FOREIGN KEY (card_id) REFERENCES cards(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS card_flavor_texts (
+            id INTEGER PRIMARY KEY,
+            card_id INTEGER NOT NULL,
+            flavor_text TEXT,
+            locale TEXT NOT NULL,
+            FOREIGN KEY (card_id) REFERENCES cards(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS card_tags (
+            card_id INTEGER NOT NULL,
+            tag_id INTEGER NOT NULL,
+            tag_name TEXT,
+            display_name TEXT,
+            tag_value INTEGER,
+            PRIMARY KEY (card_id, tag_id),
+            FOREIGN KEY (card_id) REFERENCES cards(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS card_classes (
+            id INTEGER PRIMARY KEY,
+            name TEXT NOT NULL,
+            display_name TEXT,
+            hero_dbfid INTEGER,
+            icon TEXT,
+            can_diy INTEGER,
+            can_build_deck INTEGER,
+            enabled INTEGER,
+            sort INTEGER
+        );
+
+        CREATE TABLE IF NOT EXISTS card_class_map (
+            card_id INTEGER NOT NULL,
+            class_id INTEGER NOT NULL,
+            PRIMARY KEY (card_id, class_id),
+            FOREIGN KEY (card_id) REFERENCES cards(id),
+            FOREIGN KEY (class_id) REFERENCES card_classes(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS card_sets (
+            id INTEGER PRIMARY KEY,
+            name TEXT NOT NULL,
+            display_name TEXT,
+            icon TEXT,
+            has_mini INTEGER,
+            mini_name TEXT,
+            logo TEXT,
+            reveal_date TEXT,
+            enabled INTEGER,
+            sort INTEGER
+        );
+
+        CREATE TABLE IF NOT EXISTS card_rarities (
+            id INTEGER PRIMARY KEY,
+            name TEXT NOT NULL,
+            display_name TEXT,
+            icon TEXT,
+            enabled INTEGER,
+            sort INTEGER
+        );
+
+        CREATE TABLE IF NOT EXISTS card_relations (
+            card_id INTEGER NOT NULL,
+            related_card_id INTEGER NOT NULL,
+            direction TEXT NOT NULL,
+            PRIMARY KEY (card_id, related_card_id, direction),
+            FOREIGN KEY (card_id) REFERENCES cards(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS card_how_to_earn (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            card_id INTEGER NOT NULL,
+            description TEXT,
+            locale TEXT,
+            FOREIGN KEY (card_id) REFERENCES cards(id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_cards_card_id ON cards(card_id);
+        CREATE INDEX IF NOT EXISTS idx_cards_dbfid ON cards(dbfid);
+        CREATE INDEX IF NOT EXISTS idx_card_names_card_id ON card_names(card_id);
+        CREATE INDEX IF NOT EXISTS idx_card_names_locale ON card_names(locale);
+        CREATE INDEX IF NOT EXISTS idx_card_texts_card_id ON card_texts(card_id);
+        CREATE INDEX IF NOT EXISTS idx_card_tags_card_id ON card_tags(card_id);
+        CREATE INDEX IF NOT EXISTS idx_cards_cost ON cards(cost);
+        CREATE INDEX IF NOT EXISTS idx_cards_card_type ON cards(card_type);
+        CREATE INDEX IF NOT EXISTS idx_cards_collectible ON cards(collectible);
+    `);
+}
+__name(ensureSchema, "ensureSchema");
+ensureSchema();
+function searchCard_id(value) {
+  const row = db.prepare("SELECT image_normal_data FROM cards WHERE id = ?").get(value);
+  if (!row?.image_normal_data) return null;
+  return Buffer.from(row.image_normal_data).toString("base64");
+}
+__name(searchCard_id, "searchCard_id");
+function searchCard(value) {
+  const rows = db.prepare(
+    `SELECT a.card_id as id, a.name, b.tag_value
+         FROM card_names a
+         JOIN card_tags b ON a.card_id = b.card_id
+         WHERE a.name LIKE ? AND b.tag_id = 321`
+  ).all(`%${value}%`);
+  if (!rows.length) return null;
+  const maxShow = 999;
+  const header = `📋 找到 ${rows.length} 张相关卡牌`;
+  const divider = "━".repeat(18);
+  const cards = rows.slice(0, maxShow).map(
+    (r, i) => `${i + 1}. 「${r.name}」
+   ID: ${r.id}
+   可收藏: ${r.tag_value === 1 ? "✅ 是" : "❌ 否"}`
+  ).join("\n" + "─".repeat(18) + "\n");
+  const footer = rows.length > maxShow ? `
+${divider}
+⚠ 结果过多，仅显示前 ${maxShow} 条（共 ${rows.length} 条）` : "";
+  return `${header}
+${divider}
+${cards}${footer}`;
+}
+__name(searchCard, "searchCard");
+function getCardCount() {
+  const row = db.prepare("SELECT COUNT(*) as count FROM cards").get();
+  return row?.count || 0;
+}
+__name(getCardCount, "getCardCount");
+function getCardImagePath(cardId) {
+  const row = db.prepare("SELECT image_normal FROM cards WHERE id = ?").get(cardId);
+  return row?.image_normal || null;
+}
+__name(getCardImagePath, "getCardImagePath");
+function updateCardImage(cardId, imageData) {
+  db.prepare("UPDATE cards SET image_normal_data = ? WHERE id = ?").run(imageData, cardId);
+}
+__name(updateCardImage, "updateCardImage");
+var storeCardsFromApi = db.transaction((cards) => {
+  for (const card of cards) {
+    storeCardFromApi(card);
+  }
+});
+function storeCardFromApi(card) {
+  const image = card.image || {};
+  const tile = card.tile || {};
+  db.prepare(`
+        INSERT OR REPLACE INTO cards
+        (id, card_id, dbfid, artist_name, cost, card_set, card_class, card_type,
+         collectible, tech_level, hidden, hash, version, image_normal,
+         image_battlegrounds, tile_image, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+    card.id,
+    card.card_id,
+    card.dbfid,
+    card.artist_name,
+    card.cost,
+    card.card_set,
+    card.card_class,
+    card.card_type,
+    card.collectible,
+    card.tech_level,
+    card.hidden,
+    card.hash,
+    card.version,
+    image.image_normal,
+    image.image_battlegrounds,
+    tile?.image,
+    card.created_at,
+    card.updated_at
+  );
+  const insertName = db.prepare(
+    "INSERT OR REPLACE INTO card_names (id, card_id, name, locale) VALUES (?, ?, ?, ?)"
+  );
+  for (const name2 of card.names || []) {
+    insertName.run(name2.id, card.id, name2.name, name2.locale);
+  }
+  const insertText = db.prepare(
+    "INSERT OR REPLACE INTO card_texts (id, card_id, text, plain_text, locale) VALUES (?, ?, ?, ?, ?)"
+  );
+  for (const text of card.texts || []) {
+    insertText.run(text.id, card.id, text.text, text.plain_text, text.locale);
+  }
+  const insertFlavor = db.prepare(
+    "INSERT OR REPLACE INTO card_flavor_texts (id, card_id, flavor_text, locale) VALUES (?, ?, ?, ?)"
+  );
+  for (const ft of card.flavor_texts || []) {
+    insertFlavor.run(ft.id, card.id, ft.flavor_text, ft.locale);
+  }
+  const insertTag = db.prepare(
+    "INSERT OR REPLACE INTO card_tags (card_id, tag_id, tag_name, display_name, tag_value) VALUES (?, ?, ?, ?, ?)"
+  );
+  for (const tag of card.tags || []) {
+    const pivot = tag.pivot || {};
+    insertTag.run(card.id, tag.id, tag.name, tag.display_name, pivot.game_tag_value);
+  }
+  const insertClass = db.prepare(`
+        INSERT OR REPLACE INTO card_classes
+        (id, name, display_name, hero_dbfid, icon, can_diy, can_build_deck, enabled, sort)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+  const insertClassMap = db.prepare(
+    "INSERT OR IGNORE INTO card_class_map (card_id, class_id) VALUES (?, ?)"
+  );
+  for (const cls of card.card_classes || []) {
+    insertClass.run(
+      cls.id,
+      cls.name,
+      cls.display_name,
+      cls.hero_dbfid,
+      cls.icon,
+      cls.can_diy,
+      cls.can_build_deck,
+      cls.enabled,
+      cls.sort
+    );
+    insertClassMap.run(card.id, cls.id);
+  }
+  const insertSet = db.prepare(`
+        INSERT OR REPLACE INTO card_sets
+        (id, name, display_name, icon, has_mini, mini_name, logo, reveal_date, enabled, sort)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+  for (const cs of card.card_sets || []) {
+    insertSet.run(
+      cs.id,
+      cs.name,
+      cs.display_name,
+      cs.icon,
+      cs.has_mini,
+      cs.mini_name,
+      cs.logo,
+      cs.reveal_date,
+      cs.enabled,
+      cs.sort
+    );
+  }
+  const insertRarity = db.prepare(
+    "INSERT OR REPLACE INTO card_rarities (id, name, display_name, icon, enabled, sort) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  for (const rarity of card.card_rarities || []) {
+    insertRarity.run(rarity.id, rarity.name, rarity.display_name, rarity.icon, rarity.enabled, rarity.sort);
+  }
+}
+__name(storeCardFromApi, "storeCardFromApi");
+
+// src/api.ts
+var https = __toESM(require("https"));
+var API_URL = "https://fbigame.com/card/search";
+var PAGE_URL = "https://fbigame.com/card";
+var OSS_BASE = "https://fbigame.oss-cn-beijing.aliyuncs.com/";
+var agent = new https.Agent({ rejectUnauthorized: false });
+var cachedSession = null;
+function httpsRequest(method, url, headers, body) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const req = https.request(
+      {
+        method,
+        hostname: urlObj.hostname,
+        path: urlObj.pathname + urlObj.search,
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36",
+          ...headers
+        },
+        agent
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          resolve({
+            statusCode: res.statusCode || 0,
+            headers: res.headers,
+            body: Buffer.concat(chunks).toString("utf-8")
+          });
+        });
+      }
+    );
+    req.on("error", reject);
+    if (body) req.write(body);
+    req.end();
+  });
+}
+__name(httpsRequest, "httpsRequest");
+function downloadBuffer(url) {
+  return new Promise((resolve) => {
+    const urlObj = new URL(url);
+    https.get(
+      {
+        hostname: urlObj.hostname,
+        path: urlObj.pathname + urlObj.search,
+        headers: {
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        },
+        agent
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          resolve(null);
+          return;
+        }
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+      }
+    ).on("error", () => resolve(null));
+  });
+}
+__name(downloadBuffer, "downloadBuffer");
+async function initSession() {
+  if (cachedSession) return cachedSession;
+  const resp = await httpsRequest("GET", PAGE_URL);
+  const csrfMatch = resp.body.match(/<meta name="csrf-token" content="([^"]+)"/);
+  if (!csrfMatch) throw new Error("无法获取CSRF token");
+  const setCookies = resp.headers["set-cookie"];
+  const cookieStr = Array.isArray(setCookies) ? setCookies.map((c) => c.split(";")[0]).join("; ") : setCookies?.split(";")[0] || "";
+  const xsrfMatch = cookieStr.match(/XSRF-TOKEN=([^;,]+)/);
+  const xsrf = xsrfMatch ? decodeURIComponent(xsrfMatch[1]) : "";
+  cachedSession = { csrf: csrfMatch[1], cookies: cookieStr, xsrf };
+  return cachedSession;
+}
+__name(initSession, "initSession");
+var sleep = /* @__PURE__ */ __name((ms) => new Promise((r) => setTimeout(r, ms)), "sleep");
+var MAX_RETRIES = 5;
+async function postSearchApi(searchQuery, page, retries = 0) {
+  try {
+    const session = await initSession();
+    const payload = JSON.stringify({
+      searchQuery,
+      page,
+      mode: "list",
+      zilliaxSearch: 0,
+      sideboardType: 0,
+      touristClassId: 0
+    });
+    const resp = await httpsRequest(
+      "POST",
+      API_URL,
+      {
+        "Content-Type": "application/json",
+        "Content-Length": String(Buffer.byteLength(payload)),
+        Accept: "application/json",
+        "X-Requested-With": "XMLHttpRequest",
+        "X-CSRF-TOKEN": session.csrf,
+        "X-XSRF-TOKEN": session.xsrf,
+        Cookie: session.cookies,
+        Referer: PAGE_URL,
+        Origin: "https://fbigame.com"
+      },
+      payload
+    );
+    if (resp.statusCode === 419 && retries < MAX_RETRIES) {
+      cachedSession = null;
+      return postSearchApi(searchQuery, page, retries + 1);
+    }
+    if (resp.statusCode === 429 && retries < MAX_RETRIES) {
+      const wait = Math.min(30 + retries * 15, 90) * 1e3;
+      await sleep(wait);
+      return postSearchApi(searchQuery, page, retries + 1);
+    }
+    if (resp.statusCode !== 200) return null;
+    return JSON.parse(resp.body);
+  } catch {
+    if (retries < MAX_RETRIES) {
+      cachedSession = null;
+      await sleep((retries + 1) * 3e3);
+      return postSearchApi(searchQuery, page, retries + 1);
+    }
+    return null;
+  }
+}
+__name(postSearchApi, "postSearchApi");
+async function searchCardOnline(name2) {
+  const data = await postSearchApi(name2, 1);
+  return data?.data || null;
+}
+__name(searchCardOnline, "searchCardOnline");
+async function fetchCardPage(page) {
+  const data = await postSearchApi("", page);
+  if (!data) return null;
+  return {
+    total: data.total,
+    lastPage: data.last_page,
+    data: data.data || []
+  };
+}
+__name(fetchCardPage, "fetchCardPage");
+async function downloadCardImage(relativePath) {
+  if (!relativePath) return null;
+  const url = OSS_BASE + relativePath + "?x-oss-process=style/hearthstone-image";
+  return downloadBuffer(url);
+}
+__name(downloadCardImage, "downloadCardImage");
+
+// src/index.ts
+var name = "hearthstone";
+var Config = import_koishi.Schema.object({});
+var PER_PAGE = 50;
+var isDownloading = false;
+function apply(ctx, config) {
+  ctx.command("卡牌查询 <message>").action(async (_, message) => {
+    const localResult = searchCard(message);
+    if (localResult) return localResult;
+    const onlineCards = await searchCardOnline(message);
+    if (!onlineCards?.length) return "未找到相关卡牌";
+    for (const card of onlineCards) {
+      storeCardFromApi(card);
+    }
+    return searchCard(message) ?? "未找到相关卡牌";
+  });
+  ctx.command("id查询卡牌 <message>").alias("id查询").action(async (_, message) => {
+    const localResult = searchCard_id(message);
+    if (localResult) {
+      return `<image url="data:image/png;base64,${localResult}"/>`;
+    }
+    const imagePath = getCardImagePath(Number(message));
+    if (imagePath) {
+      const imageData = await downloadCardImage(imagePath);
+      if (imageData) {
+        updateCardImage(Number(message), imageData);
+        return `<image url="data:image/png;base64,${imageData.toString("base64")}"/>`;
+      }
+    }
+    return "未找到相关卡牌";
+  });
+  ctx.command("下载卡牌数据").action(async (argv) => {
+    if (isDownloading) return "⏳ 正在下载中，请耐心等待...";
+    isDownloading = true;
+    try {
+      const existingCount = getCardCount();
+      const firstPage = await fetchCardPage(1);
+      if (!firstPage) {
+        isDownloading = false;
+        return "❌ 连接服务器失败，请稍后重试";
+      }
+      const { total, lastPage } = firstPage;
+      let startPage = 1;
+      let stored = existingCount;
+      if (existingCount > 0) {
+        startPage = Math.floor(existingCount / PER_PAGE) + 1;
+        if (startPage > lastPage) {
+          isDownloading = false;
+          return `✅ 数据库已包含全部 ${existingCount} 张卡牌，无需下载`;
+        }
+        await argv.session.send(
+          `📦 数据库已有 ${existingCount} 张卡牌，从第 ${startPage}/${lastPage} 页继续下载...`
+        );
+      } else {
+        await argv.session.send(
+          `📦 开始下载卡牌数据，共 ${total} 张卡牌（${lastPage} 页）...
+⏱ 预计需要几分钟，期间可正常使用其他命令`
+        );
+        storeCardsFromApi(firstPage.data);
+        stored = firstPage.data.length;
+        startPage = 2;
+      }
+      let failedPages = 0;
+      for (let page = startPage; page <= lastPage; page++) {
+        const pageData = await fetchCardPage(page);
+        if (pageData?.data?.length) {
+          storeCardsFromApi(pageData.data);
+          stored += pageData.data.length;
+        } else {
+          failedPages++;
+        }
+        if (page % 20 === 0) {
+          const pct = Math.round(page / lastPage * 100);
+          await argv.session.send(
+            `📥 下载进度: ${page}/${lastPage}（${pct}%）- 已存储 ${stored} 张`
+          );
+        }
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+      isDownloading = false;
+      const summary = [`✅ 卡牌数据下载完成！共 ${stored} 张卡牌`];
+      if (failedPages > 0) {
+        summary.push(`⚠ ${failedPages} 页下载失败，可重新执行命令补全`);
+      }
+      summary.push("💡 卡牌图片将在使用查询功能时按需下载");
+      return summary.join("\n");
+    } catch (e) {
+      isDownloading = false;
+      return `❌ 下载失败: ${e.message}`;
+    }
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "koishi-plugin-hearthstone",
+  "description": "炉石卡牌插件",
+  "version": "1.0.0",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/Stardustll/koishi-hearthstone",
+  "scripts": {},
+  "keywords": [
+    "hearthstone",
+    "koishi",
+    "plugin"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  },
+  "dependencies": {
+    "@types/express": "^5.0.6",
+    "@types/sqlite3": "^3.1.11",
+    "better-sqlite3": "^12.8.0",
+    "express": "^5.2.1",
+    "sqlite3": "^6.0.1"
+  }
+}

package/readme.md

@@ -0,0 +1,6 @@
+# koishi-plugin-hearthstone
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-hearthstone?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-hearthstone)
+
+炉石卡牌插件
+为koishi写的炉石插件