napcat-plugin-debug-cli 1.0.0 → 1.2.0

package/cli.mjs

@@ -5053,6 +5053,8 @@ function parseArgs() {
       opts.watchAll = true;
     } else if (arg === "--verbose" || arg === "-v") {
       opts.verbose = true;
+    } else if (arg === "--deploy" || arg === "-d") {
+      opts.deploy = args[++i] || ".";
     } else if (arg.startsWith("ws://") || arg.startsWith("wss://")) {
       opts.wsUrl = arg;
     }
@@ -5070,6 +5072,7 @@ napcat-plugin-debug CLI — NapCat 插件调试 & 热重载
   -t, --token <token>  认证 token
   -w, --watch <dir>    监听目录自动热重载
   -W, --watch-all      监听远程插件目录所有插件
+  -d, --deploy [dir]   部署插件 dist/ 到远程插件目录并重载 (默认: .)
   -v, --verbose        详细输出
   -h, --help           帮助
 
@@ -5079,6 +5082,7 @@ napcat-plugin-debug CLI — NapCat 插件调试 & 热重载
   load <id>            加载插件
   unload <id>          卸载插件
   info <id>            插件详情
+  deploy [dir]         部署插件到远程并重载
   watch <dir>          开始监听
   unwatch              停止监听
   status               服务状态
@@ -5202,6 +5206,73 @@ function createWatcher(watchPath, onPluginChange) {
     }
   };
 }
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDirRecursive(srcPath, destPath);
+    else fs.copyFileSync(srcPath, destPath);
+  }
+}
+function countFiles(dir) {
+  let count = 0;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) count += countFiles(path.join(dir, entry.name));
+    else count++;
+  }
+  return count;
+}
+async function deployPlugin(projectDir, remotePluginPath, rpc) {
+  const distDir = path.resolve(projectDir, "dist");
+  if (!fs.existsSync(distDir)) {
+    logErr(`dist/ 目录不存在: ${distDir}`);
+    logInfo("请先运行 pnpm run build 构建插件");
+    return false;
+  }
+  const distPkgPath = path.join(distDir, "package.json");
+  if (!fs.existsSync(distPkgPath)) {
+    logErr("dist/package.json 不存在，无法确定插件名称");
+    return false;
+  }
+  let pluginName;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(distPkgPath, "utf-8"));
+    pluginName = pkg.name;
+    if (!pluginName) {
+      logErr("dist/package.json 中缺少 name 字段");
+      return false;
+    }
+  } catch (e) {
+    logErr(`解析 dist/package.json 失败: ${e.message}`);
+    return false;
+  }
+  const destDir = path.join(remotePluginPath, pluginName);
+  logInfo(`部署 ${co(pluginName, C.bold, C.cyan)} → ${co(destDir, C.dim)}`);
+  try {
+    if (fs.existsSync(destDir)) {
+      fs.rmSync(destDir, { recursive: true, force: true });
+    }
+    copyDirRecursive(distDir, destDir);
+    logOk(`文件复制完成 (${countFiles(distDir)} 个文件)`);
+  } catch (e) {
+    logErr(`复制文件失败: ${e.message}`);
+    return false;
+  }
+  try {
+    await rpc.call("reloadPlugin", pluginName);
+    logOk(`${co(pluginName, C.green, C.bold)} 重载成功`);
+  } catch {
+    try {
+      logInfo("插件未注册，尝试从目录加载...");
+      await rpc.call("loadDirectoryPlugin", destDir);
+      logOk(`${co(pluginName, C.green, C.bold)} 首次加载成功`);
+    } catch (e2) {
+      logWarn(`自动加载失败: ${e2.message}，请手动 load ${pluginName}`);
+    }
+  }
+  return true;
+}
 async function main() {
   const opts = parseArgs();
   console.log(co("\n  napcat-plugin-debug CLI", C.bold, C.cyan));
@@ -5254,6 +5325,11 @@ async function main() {
         } catch (e) {
           logWarn(`获取信息失败: ${e.message}`);
         }
+        if (opts.deploy && remotePluginPath && rpc) {
+          const ok = await deployPlugin(path.resolve(opts.deploy), remotePluginPath, rpc);
+          ws.close(1e3);
+          process.exit(ok ? 0 : 1);
+        }
         if (opts.watch) {
           watcher = createWatcher(path.resolve(opts.watch), onFileChange);
           watcher.start();
@@ -5361,6 +5437,15 @@ function startRepl(rpc, watcher, remotePath, onFileChange) {
 `);
           break;
         }
+        case "deploy": {
+          if (!remotePath) {
+            logErr("远程插件目录未知，无法部署");
+            break;
+          }
+          const dir = args[0] || ".";
+          await deployPlugin(path.resolve(dir), remotePath, rpc);
+          break;
+        }
         case "watch": {
           if (!args[0]) {
             logErr("用法: watch <dir>");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "napcat-plugin-debug-cli",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "type": "module",
   "description": "NapCat 插件调试 CLI — 连接调试服务实现热重载",
   "author": "NapNeko",
@@ -8,14 +8,32 @@
   "bin": {
     "napcat-debug": "./cli.mjs"
   },
+  "exports": {
+    ".": "./cli.mjs",
+    "./vite": "./vite.mjs"
+  },
   "files": [
-    "cli.mjs"
+    "cli.mjs",
+    "vite.mjs"
   ],
+  "peerDependencies": {
+    "vite": ">=5.0.0",
+    "ws": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    },
+    "ws": {
+      "optional": false
+    }
+  },
   "keywords": [
     "napcat",
     "plugin",
     "debug",
     "hmr",
-    "hot-reload"
+    "hot-reload",
+    "vite-plugin"
   ]
 }

package/vite.mjs

@@ -0,0 +1,233 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+const co = (t, ...c) => c.join("") + t + C.reset;
+const PREFIX = co("[napcat-hmr]", C.magenta, C.bold);
+const log = (m) => console.log(`${PREFIX} ${m}`);
+const logOk = (m) => console.log(`${PREFIX} ${co("✓", C.green)} ${m}`);
+const logErr = (m) => console.log(`${PREFIX} ${co("✗", C.red)} ${m}`);
+const logHmr = (m) => console.log(`${PREFIX} ${co("🔥", C.magenta)} ${co(m, C.magenta)}`);
+class SimpleRpcClient {
+  ws;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  constructor(ws) {
+    this.ws = ws;
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (msg.jsonrpc === "2.0" && msg.id != null) {
+          const p = this.pending.get(msg.id);
+          if (p) {
+            this.pending.delete(msg.id);
+            if (msg.error) p.reject(new Error(msg.error.message));
+            else p.resolve(msg.result);
+          }
+        }
+      } catch {
+      }
+    });
+  }
+  call(method, ...params) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      this.pending.set(id, { resolve, reject });
+      const req = { jsonrpc: "2.0", id, method, params };
+      this.ws.send(JSON.stringify(req));
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error("RPC timeout"));
+        }
+      }, 1e4);
+    });
+  }
+  get connected() {
+    return this.ws?.readyState === 1;
+  }
+  close() {
+    try {
+      this.ws?.close(1e3);
+    } catch {
+    }
+  }
+}
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDirRecursive(srcPath, destPath);
+    else fs.copyFileSync(srcPath, destPath);
+  }
+}
+function countFiles(dir) {
+  let count = 0;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) count += countFiles(path.join(dir, entry.name));
+    else count++;
+  }
+  return count;
+}
+function napcatHmrPlugin(options = {}) {
+  const {
+    wsUrl = "ws://127.0.0.1:8998",
+    token,
+    enabled = true,
+    autoConnect = true
+  } = options;
+  let rpc = null;
+  let remotePluginPath = null;
+  let connecting = false;
+  let config;
+  let isFirstBuild = true;
+  async function connect() {
+    if (rpc?.connected) return true;
+    if (connecting) return false;
+    connecting = true;
+    try {
+      const { default: WebSocket } = await import('ws');
+      let url = wsUrl;
+      if (token) {
+        const u = new URL(url);
+        u.searchParams.set("token", token);
+        url = u.toString();
+      }
+      return await new Promise((resolve) => {
+        const ws = new WebSocket(url);
+        const timeout = setTimeout(() => {
+          ws.close();
+          connecting = false;
+          resolve(false);
+        }, 5e3);
+        ws.on("open", () => {
+          clearTimeout(timeout);
+        });
+        ws.on("message", async (raw) => {
+          try {
+            const msg = JSON.parse(raw.toString());
+            if (msg.method === "welcome") {
+              rpc = new SimpleRpcClient(ws);
+              try {
+                const info = await rpc.call("getDebugInfo");
+                remotePluginPath = info.pluginPath;
+                logOk(`已连接调试服务 (${info.loadedCount}/${info.pluginCount} 插件)`);
+                log(`远程插件目录: ${co(info.pluginPath, C.dim)}`);
+              } catch {
+              }
+              connecting = false;
+              resolve(true);
+            }
+          } catch {
+          }
+        });
+        ws.on("error", () => {
+          clearTimeout(timeout);
+          connecting = false;
+          resolve(false);
+        });
+        ws.on("close", () => {
+          rpc = null;
+          remotePluginPath = null;
+          connecting = false;
+        });
+      });
+    } catch (e) {
+      connecting = false;
+      return false;
+    }
+  }
+  async function deployAndReload(distDir) {
+    if (!rpc?.connected || !remotePluginPath) {
+      logErr("未连接到调试服务，跳过部署");
+      return;
+    }
+    const pkgPath = path.join(distDir, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+      logErr("dist/package.json 不存在，跳过部署");
+      return;
+    }
+    let pluginName;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      pluginName = pkg.name;
+      if (!pluginName) {
+        logErr("dist/package.json 中缺少 name 字段");
+        return;
+      }
+    } catch {
+      logErr("解析 dist/package.json 失败");
+      return;
+    }
+    const destDir = path.join(remotePluginPath, pluginName);
+    try {
+      if (fs.existsSync(destDir)) {
+        fs.rmSync(destDir, { recursive: true, force: true });
+      }
+      copyDirRecursive(distDir, destDir);
+    } catch (e) {
+      logErr(`复制文件失败: ${e.message}`);
+      return;
+    }
+    try {
+      await rpc.call("reloadPlugin", pluginName);
+      logHmr(`${co(pluginName, C.green, C.bold)} 已重载 (${countFiles(distDir)} 个文件)`);
+    } catch {
+      try {
+        await rpc.call("loadDirectoryPlugin", destDir);
+        logOk(`${co(pluginName, C.green, C.bold)} 首次加载成功`);
+      } catch (e2) {
+        logErr(`加载失败: ${e2.message}`);
+      }
+    }
+  }
+  return {
+    name: "napcat-hmr",
+    apply: "build",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async buildStart() {
+      if (!enabled) return;
+      if (!autoConnect) return;
+      if (isFirstBuild) {
+        log(`连接 ${co(wsUrl, C.cyan)}...`);
+        const ok = await connect();
+        if (!ok) {
+          logErr(`无法连接调试服务 ${wsUrl}`);
+          log("请确认 napcat-plugin-debug 已启用");
+          log("仅构建模式，不自动部署");
+        }
+      }
+    },
+    async writeBundle() {
+      if (!enabled) return;
+      const distDir = path.resolve(config.build.outDir);
+      if (!rpc?.connected) {
+        const ok = await connect();
+        if (!ok) return;
+      }
+      await deployAndReload(distDir);
+      isFirstBuild = false;
+    },
+    closeBundle() {
+      if (config.build.watch) return;
+      rpc?.close();
+      rpc = null;
+    }
+  };
+}
+
+export { napcatHmrPlugin as default, napcatHmrPlugin };