ms-vite-plugin 1.0.2 → 1.0.3

package/dist/ws-manager.js

@@ -0,0 +1,367 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServerManager = exports.WSManager = void 0;
+const os = __importStar(require("os"));
+const uuid_1 = require("uuid");
+const ws_1 = require("ws");
+/**
+ * 选择当前机器最合适的局域网 IP
+ * @returns 返回可用的 IPv4 地址，兜底 127.0.0.1
+ * @example
+ * const ip = detectHostIp()
+ */
+function detectHostIp() {
+    const nets = os.networkInterfaces();
+    const entries = [];
+    for (const name of Object.keys(nets)) {
+        for (const info of nets[name] || []) {
+            const i = info;
+            const addr = String(i.address || "");
+            const bad = /(awdl|utun|llw|bridge|vmnet|vbox|docker)/i.test(name);
+            const linkLocal = /^169\.254\./.test(addr);
+            if (i.family === "IPv4" && !i.internal && !bad && !linkLocal) {
+                entries.push({ name, addr });
+            }
+        }
+    }
+    const score = (e) => {
+        let s = 0;
+        if (process.platform === "darwin" && e.name === "en0") {
+            s += 60;
+        }
+        if (/(wi-?fi|wlan|wlp|wl)/i.test(e.name)) {
+            s += 50;
+        }
+        if (/^(en|eth)\d+$/i.test(e.name)) {
+            s += 40;
+        }
+        if (/^192\.168\./.test(e.addr)) {
+            s += 30;
+        }
+        else if (/^10\./.test(e.addr)) {
+            s += 25;
+        }
+        else if (/^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(e.addr)) {
+            s += 20;
+        }
+        return s;
+    };
+    entries.sort((a, b) => score(b) - score(a));
+    return entries[0]?.addr ?? "127.0.0.1";
+}
+/**
+ * CLI 版 WebSocket 管理器
+ */
+class WSManager {
+    constructor() {
+        Object.defineProperty(this, "wss", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "checkInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "hostIp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: detectHostIp()
+        });
+        Object.defineProperty(this, "port", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 31111
+        });
+        Object.defineProperty(this, "pending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * 获取 WS 管理器单例
+     * @returns 返回单例实例
+     * @example
+     * const ws = WSManager.get()
+     */
+    static get() {
+        if (!this.instance) {
+            this.instance = new WSManager();
+        }
+        return this.instance;
+    }
+    /**
+     * 判断是否已有设备连接
+     * @returns 已连接返回 true，否则 false
+     * @example
+     * WSManager.isConnected()
+     */
+    static isConnected() {
+        return this.get().client !== null;
+    }
+    /**
+     * 静态请求入口
+     * @param type 请求类型
+     * @param message 请求参数
+     * @param timeoutMs 超时时间（毫秒）
+     * @returns 返回设备响应
+     * @example
+     * await WSManager.request("runtime_status", {}, 5000)
+     */
+    static request(type, message = {}, timeoutMs = 60000) {
+        return this.get().request(type, message, timeoutMs);
+    }
+    /**
+     * 获取监听地址
+     * @returns 返回 ws 地址
+     * @example
+     * ws.getAddress()
+     */
+    getAddress() {
+        return `ws://${this.hostIp}:${this.port}`;
+    }
+    /**
+     * 判断服务器是否已启动
+     * @returns 已启动返回 true，否则 false
+     * @example
+     * ws.isStarted()
+     */
+    isStarted() {
+        return this.wss !== null;
+    }
+    /**
+     * 启动 WS 服务
+     * @param port 指定端口，默认 31111
+     * @returns 启动完成后返回 Promise<void>
+     * @example
+     * await ws.start(31111)
+     */
+    async start(port = 31111) {
+        if (this.wss) {
+            console.log(`服务已开启，地址 ${this.getAddress()}`);
+            return;
+        }
+        this.port = port;
+        this.wss = new ws_1.WebSocketServer({ port: this.port, host: "0.0.0.0" });
+        this.wss.on("connection", (ws) => {
+            if (this.client) {
+                ws.send(JSON.stringify({ type: "reject", reason: "only-one-client" }));
+                ws.close(1013, "Only one client allowed");
+                return;
+            }
+            this.client = ws;
+            ws.on("close", () => {
+                if (this.client === ws) {
+                    const socket = ws;
+                    console.log(`设备已断开，设备IP: ${socket._socket?.remoteAddress || "unknown"}`);
+                    this.stopStatusInterval();
+                    this.client = null;
+                }
+            });
+            ws.on("message", (data) => {
+                let message = null;
+                try {
+                    message = JSON.parse(data.toString());
+                }
+                catch {
+                    return;
+                }
+                if (message.type === "log") {
+                    console.log("[device-log]", JSON.stringify(message));
+                    return;
+                }
+                const id = message.requestId;
+                if (id && this.pending.has(id)) {
+                    const p = this.pending.get(id);
+                    clearTimeout(p.timer);
+                    this.pending.delete(id);
+                    p.resolve(message);
+                }
+            });
+            const socket = ws;
+            console.log(`设备已连接，设备IP: ${socket._socket?.remoteAddress || "unknown"}`);
+            this.startStatusInterval();
+        });
+        await new Promise((resolve, reject) => {
+            this.wss.once("listening", () => {
+                console.log(`服务已开启，地址 ${this.getAddress()}`);
+                resolve();
+            });
+            this.wss.once("error", (err) => {
+                this.wss = null;
+                console.error(`服务启动失败: ${String(err)}`);
+                reject(err);
+            });
+        });
+    }
+    /**
+     * 等待设备连接
+     * @param timeoutMs 超时时间（毫秒）
+     * @returns 成功连接后返回 Promise<void>
+     * @example
+     * await ws.waitForClient(30000)
+     */
+    async waitForClient(timeoutMs = 30000) {
+        if (this.client) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const start = Date.now();
+            const timer = setInterval(() => {
+                if (this.client) {
+                    clearInterval(timer);
+                    resolve();
+                    return;
+                }
+                if (Date.now() - start > timeoutMs) {
+                    clearInterval(timer);
+                    reject(new Error("等待设备连接超时"));
+                }
+            }, 200);
+        });
+    }
+    /**
+     * 发送请求并等待响应
+     * @param type 请求类型
+     * @param message 请求消息
+     * @param timeoutMs 超时时间（毫秒）
+     * @returns 返回设备响应
+     * @example
+     * await ws.request("files", {}, 60000)
+     */
+    async request(type, message = {}, timeoutMs = 5000) {
+        if (!this.client || this.client.readyState !== this.client.OPEN) {
+            throw new Error("no-client");
+        }
+        const id = (0, uuid_1.v4)();
+        const payload = JSON.stringify({ ...message, type, requestId: id });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error("timeout"));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.client.send(payload);
+            }
+            catch (e) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(e);
+            }
+        });
+    }
+    /**
+     * 停止 WS 服务
+     * @returns 停止完成后返回 Promise<void>
+     * @example
+     * await ws.stop()
+     */
+    async stop() {
+        if (!this.wss) {
+            return;
+        }
+        if (this.client) {
+            this.client.close(1000);
+        }
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(new Error("server-stopped"));
+        }
+        this.pending.clear();
+        await new Promise((resolve) => this.wss.close(() => resolve()));
+        this.wss = null;
+        this.stopStatusInterval();
+        console.log("服务已停止");
+    }
+    /**
+     * 启动运行状态轮询
+     * @returns 无返回值
+     * @example
+     * ws.startStatusInterval()
+     */
+    startStatusInterval() {
+        this.stopStatusInterval();
+        this.checkInterval = setInterval(async () => {
+            try {
+                const data = await this.request("runtime_status");
+                if (data.success) {
+                    const status = (data.data || {});
+                    console.log(`[runtime] memory=${status.memory ?? "unknown"}, isRunning=${status.isRunning ?? "unknown"}`);
+                }
+            }
+            catch {
+                // ignore
+            }
+        }, 2000);
+    }
+    /**
+     * 停止运行状态轮询
+     * @returns 无返回值
+     * @example
+     * ws.stopStatusInterval()
+     */
+    stopStatusInterval() {
+        if (this.checkInterval) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = null;
+        }
+    }
+}
+exports.WSManager = WSManager;
+Object.defineProperty(WSManager, "instance", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: null
+});
+/**
+ * 对齐原有命名导出
+ */
+exports.WebSocketServerManager = WSManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms-vite-plugin",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "commonjs",
   "license": "MIT",
   "publishConfig": {
@@ -19,16 +19,22 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "archiver": "^7.0.1",
     "commander": "^14.0.3",
+    "crc": "^4.3.2",
     "fs-extra": "^11.3.4",
+    "uuid": "^14.0.0",
     "vite": "^8.0.9",
     "vite-plugin-bundle-obfuscator": "^1.11.0",
-    "archiver": "^7.0.1"
+    "ws": "^8.20.0"
   },
   "devDependencies": {
+    "@types/archiver": "^7.0.0",
+    "@types/crc": "^4.0.0",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^25.6.0",
-    "@types/archiver": "^7.0.0",
+    "@types/uuid": "^11.0.0",
+    "@types/ws": "^8.18.1",
     "typescript": "~6.0.3"
   }
 }