NapCatQQ/packages/napcat-vite/vite-plugin-version.js

import fs from "fs";
import path from "path";
import https from "https";
import { fileURLToPath } from "url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

/**
 * NapCat Vite Plugin: fetches latest GitHub tag (not release) and injects into import.meta.env
 */
export default function vitePluginNapcatVersion() {
  const pluginDir = path.resolve(__dirname, "dist");
  const cacheFile = path.join(pluginDir, ".napcat-version.json");
  const owner = "NapNeko";
  const repo = "NapCatQQ";
  const maxAgeMs = 24 * 60 * 60 * 1000; // cache 1 day
  const githubToken = process.env.GITHUB_TOKEN;

  fs.mkdirSync(pluginDir, { recursive: true });

  function readCache() {
    try {
      const stat = fs.statSync(cacheFile);
      if (Date.now() - stat.mtimeMs < maxAgeMs) {
        const data = JSON.parse(fs.readFileSync(cacheFile, "utf8"));
        if (data?.tag) return data.tag;
      }
    } catch {}
    return null;
  }

  function writeCache(tag) {
    try {
      fs.writeFileSync(
        cacheFile,
        JSON.stringify({ tag, time: new Date().toISOString() }, null, 2)
      );
    } catch {}
  }

  async function fetchLatestTag() {
    const url = `https://api.github.com/repos/${owner}/${repo}/tags`;
    return new Promise((resolve, reject) => {
      const req = https.get(
        url,
        {
          headers: {
            "User-Agent": "vite-plugin-napcat-version",
            Accept: "application/vnd.github.v3+json",
            ...(githubToken ? { Authorization: `token ${githubToken}` } : {}),
          },
        },
        (res) => {
          let data = "";
          res.on("data", (c) => (data += c));
          res.on("end", () => {
            try {
              const json = JSON.parse(data);
              if (Array.isArray(json) && json[0]?.name) {
                resolve(json[0].name);
              } else reject(new Error("Invalid GitHub tag response"));
            } catch (e) {
              reject(e);
            }
          });
        }
      );
      req.on("error", reject);
    });
  }

  async function getVersion() {
    const cached = readCache();
    if (cached) return cached;
    try {
      const tag = await fetchLatestTag();
      writeCache(tag);
      return tag;
    } catch (e) {
      console.warn("[vite-plugin-napcat-version] Failed to fetch tag:", e.message);
      return cached ?? "v0.0.0";
    }
  }

  let lastTag = null;

  return {
    name: "vite-plugin-napcat-version",
    enforce: "pre",

    async config(userConfig) {
      const tag = await getVersion();
      console.log(`[vite-plugin-napcat-version] Using version: ${tag}`);
      lastTag = tag;
      return {
        define: {
          ...(userConfig.define || {}),
          "import.meta.env.VITE_NAPCAT_VERSION": JSON.stringify(tag),
        },
      };
    },

    handleHotUpdate(ctx) {
      if (path.resolve(ctx.file) === cacheFile) {
        try {
          const json = JSON.parse(fs.readFileSync(cacheFile, "utf8"));
          const tag = json?.tag;
          if (tag && tag !== lastTag) {
            lastTag = tag;
            ctx.server?.ws.send({ type: "full-reload" });
          }
        } catch {}
      }
    },
  };
}