env-plugin 0.5.6

package/dist/service/EnvService.js

@@ -0,0 +1,214 @@
+import { v4 as uuidv4 } from "uuid";
+import PreProxyServer from "./PreProxyServer.js";
+import { AppError } from "../utils/errors.js";
+import { envLogger } from "../utils/logger.js";
+/**
+ * 环境服务类
+ * 负责处理与环境相关的核心业务逻辑，包括环境的增删改查、服务器启停等操作
+ * 依赖环境仓库(EnvRepo)和开发服务器仓库(DevServerRepo)实现数据持久化和关联操作
+ */
+class EnvService {
+    /**
+     * 构造函数 - 通过依赖注入初始化仓库实例
+     * @param envRepo - 环境仓库实例，用于环境数据的持久化操作
+     * @param devServerRepo - 开发服务器仓库实例，用于关联开发服务器的操作
+     * @param routeRuleRepo - 路由规则仓库实例，用于获取路由规则数量
+     */
+    constructor(envRepo, devServerRepo, routeRuleRepo) {
+        this.envRepo = envRepo;
+        this.devServerRepo = devServerRepo;
+        this.routeRuleRepo = routeRuleRepo;
+    }
+    /**
+     * 添加新环境
+     * 1. 校验输入参数合法性 2. 检查环境是否已存在 3. 生成唯一ID 4. 保存新环境
+     * @param envItem - 待添加的环境信息（不含ID）
+     * @returns {void}
+     * @throws {AppError} 当输入参数不合法时抛出
+     * @throws {AppError} 当环境已存在（通过apiBaseUrl判断）时抛出
+     */
+    handleAddEnv(envItem) {
+        // 参数校验
+        envLogger.debug({ envItem }, "准备添加环境");
+        // 检查环境是否已存在（通过apiBaseUrl唯一标识）
+        const existingEnv = this.envRepo.findOneByApiBaseUrl(envItem);
+        if (existingEnv) {
+            throw new AppError(`添加失败，环境【${existingEnv.apiBaseUrl}】已存在`);
+        }
+        // 生成唯一ID并组装完整环境信息
+        const newEnvItem = {
+            ...envItem,
+            id: uuidv4(),
+            status: "stopped", // 默认初始状态为停止
+        };
+        // 保存环境
+        this.envRepo.addEnv(newEnvItem);
+        envLogger.info({ newEnvItem }, "环境添加成功");
+    }
+    /**
+     * 删除指定环境
+     * 1. 校验输入参数 2. 检查环境是否存在 3. 执行删除操作
+     * @param envItem - 包含待删除环境ID的对象
+     * @returns {void}
+     * @throws {AppError} 当输入参数不合法时抛出
+     * @throws {AppError} 当环境不存在时抛出
+     */
+    async handleDeleteEnv(envItem) {
+        // 参数校验
+        const { id } = envItem;
+        envLogger.info({ envItem }, "准备删除环境");
+        // 检查环境是否存在
+        const existingEnv = this.envRepo.findOneById(id);
+        if (!existingEnv) {
+            throw new AppError(`删除失败，环境【${id}】不存在`);
+        }
+        if (existingEnv.status === "running") {
+            await this.handleStopServer(existingEnv);
+        }
+        // 执行删除
+        this.envRepo.deleteEnv(envItem);
+        envLogger.info({ envItem }, "环境删除成功");
+    }
+    /**
+     * 更新环境信息
+     * 1. 校验输入参数 2. 检查环境是否存在 3. 执行更新操作
+     * @param envItem - 包含待更新环境ID及字段的对象
+     * @returns {void}
+     * @throws {AppError} 当输入参数不合法时抛出
+     * @throws {AppError} 当环境不存在时抛出
+     */
+    handleUpdateEnv(envItem) {
+        // 参数校验
+        const { id } = envItem;
+        envLogger.info({ envItem }, "准备更新环境");
+        // 检查环境是否存在
+        const existingEnv = this.envRepo.findOneById(id);
+        if (!existingEnv) {
+            throw new AppError(`更新失败，环境【${id}】不存在`);
+        }
+        // 执行更新
+        this.envRepo.update(envItem);
+        envLogger.info({ envItem }, "环境更新成功");
+    }
+    /**
+     * 获取所有环境列表
+     * @returns {Array<EnvModel & {routeRuleCount?: number}>} 环境信息数组
+     */
+    handleGetList() {
+        const list = this.envRepo.getAll();
+        // 如果有 routeRuleRepo，则统计每个环境的路由规则数量
+        if (this.routeRuleRepo) {
+            const result = list.map((env) => ({
+                ...env,
+                routeRuleCount: this.routeRuleRepo?.countByEnvId(env.id) ?? 0,
+            }));
+            envLogger.info({ count: list.length }, `查询到${list.length}个环境`);
+            return result;
+        }
+        envLogger.info({ count: list.length }, `查询到${list.length}个环境`);
+        return list;
+    }
+    findOneById(id) {
+        return this.envRepo.findOneById(id);
+    }
+    /**
+     * 启动指定环境的代理服务器
+     * 1. 校验参数 2. 检查环境存在性 3. 先停止同端口服务 4. 启动新服务 5. 更新状态
+     * @param env - 包含待启动环境ID的对象
+     * @returns {Promise<void>}
+     * @throws {AppError} 当输入参数不合法时抛出
+     * @throws {AppError} 当环境不存在时抛出
+     * @throws {Error} 当服务器启动失败时抛出
+     */
+    async handleStartServer(env) {
+        const { id } = env;
+        envLogger.info({ env }, "准备启动环境服务");
+        // 检查环境是否存在
+        const envItem = this.envRepo.findOneById(id);
+        if (!envItem) {
+            throw new AppError(`启动失败，环境【${id}】不存在`);
+        }
+        try {
+            // 先查与当前服务同端口的环境，如果启动，则关闭掉
+            await this.stopServerAtSamePort(envItem);
+            // 启动新的代理服务器
+            await PreProxyServer.create(id, this.envRepo, this.devServerRepo, this.routeRuleRepo);
+            // 更新环境状态为运行中
+            await this.updateEnvStatus({
+                ...env,
+                status: "running",
+            });
+            envLogger.info({ envItem }, "环境服务启动成功");
+        }
+        catch (error) {
+            envLogger.error(error, "环境服务启动失败");
+            throw new AppError(`启动服务失败：${error.message}`);
+        }
+    }
+    /**
+     * 关闭指定端口的服务
+     * @param port
+     */
+    async stopServerAtSamePort(envItem) {
+        // 先查与当前服务同端口的环境，如果启动，则关闭掉
+        const samePortAndRunningEnv = this.envRepo.findOne({
+            $and: [
+                { id: { $ne: envItem.id } }, // $ne 表示 "不等于"
+                { port: envItem.port },
+                { status: "running" }, // 直接匹配等于的值
+            ],
+        });
+        if (samePortAndRunningEnv) {
+            envLogger.info({
+                name: samePortAndRunningEnv.name,
+            }, `关闭 ${samePortAndRunningEnv.port} 端口服务`);
+            await this.handleStopServer(samePortAndRunningEnv);
+        }
+        envLogger.info({ port: envItem.port }, `端口${envItem.port}没有服务启动`);
+    }
+    /**
+     * 停止指定环境的代理服务器
+     * 1. 校验参数 2. 检查环境存在性 3. 停止服务 4. 更新状态
+     * @param env - 包含待停止环境ID的对象
+     * @returns {Promise<void>}
+     * @throws {AppError} 当输入参数不合法时抛出
+     * @throws {AppError} 当环境不存在时抛出
+     */
+    async handleStopServer(env) {
+        const { id } = env;
+        envLogger.info({ id }, "准备停止环境服务");
+        // 检查环境是否存在
+        const envItem = this.envRepo.findOneById(id);
+        if (!envItem) {
+            throw new AppError(`停止失败，环境【${id}】不存在`);
+        }
+        // 停止对应端口的服务
+        await PreProxyServer.stopServer(id);
+        envLogger.info({ envItem }, `环境【${envItem.name}】的服务已停止`);
+        // 更新环境的运行状态
+        await this.updateEnvStatus({
+            id,
+            status: "stopped",
+        });
+    }
+    /**
+     * 私有方法：更新环境运行状态
+     * @param env - 包含环境ID的对象
+     * @param status - 目标状态（running/stopped）
+     * @returns {Promise<EnvModel | undefined>} 更新后的环境信息
+     */
+    async updateEnvStatus(env) {
+        // 查找最新的环境信息（避免使用旧引用）
+        const envItem = this.envRepo.findOneById(env.id);
+        if (!envItem) {
+            envLogger.warn(`更新状态失败，环境【${env.id}】不存在`);
+            return undefined;
+        }
+        // 执行状态更新
+        const updatedEnv = { ...envItem, ...env };
+        this.envRepo.update(updatedEnv);
+        envLogger.info({ env, updatedEnv }, `环境【${env.id}】状态已更新为${updatedEnv.status}`);
+        return updatedEnv;
+    }
+}
+export { EnvService };

package/dist/service/PasswordService.js

@@ -0,0 +1,100 @@
+import { v4 as uuidv4 } from "uuid";
+/**
+ * 密码服务类
+ * 负责处理与密码相关的核心业务逻辑，包括密码的增删改查等操作
+ * 依赖密码仓库(PasswordRepo)实现数据持久化
+ */
+class PasswordService {
+    /**
+     * 构造函数 - 通过依赖注入初始化仓库实例
+     * @param passwordRepo - 密码仓库实例，用于密码数据的持久化操作
+     */
+    constructor(passwordRepo) {
+        this.passwordRepo = passwordRepo;
+    }
+    /**
+     * 获取指定环境的所有密码
+     * @param envId - 环境ID
+     * @returns 该环境的所有密码数组
+     */
+    handleGetByEnvId(envId) {
+        return this.passwordRepo.getByEnvId(envId);
+    }
+    /**
+     * 添加新密码
+     * 1. 校验输入参数合法性 2. 检查是否已存在相同名称 3. 如果设为默认密码则先清除其他默认密码 4. 生成唯一ID 5. 保存
+     * @param passwordItem - 待添加的密码信息（不含ID）
+     * @returns 新创建的密码
+     * @throws {Error} 当输入参数不合法或已存在相同名称时抛出
+     */
+    handleAdd(passwordItem) {
+        const { envId, name, isDefault } = passwordItem;
+        // 检查是否已存在相同名称的密码（同一环境下）
+        if (this.passwordRepo.existsByEnvIdAndName(envId, name)) {
+            throw new Error(`添加失败，该环境下已存在名称为【${name}】的密码`);
+        }
+        // 如果设为默认密码，先清除其他默认密码
+        if (isDefault) {
+            this.passwordRepo.clearDefaultByEnvId(envId);
+        }
+        // 生成唯一ID并组装完整密码信息
+        const now = new Date().toISOString();
+        const newPassword = {
+            ...passwordItem,
+            id: uuidv4(),
+            createdAt: now,
+            updatedAt: now,
+        };
+        // 保存密码
+        this.passwordRepo.create(newPassword);
+        return newPassword;
+    }
+    /**
+     * 更新密码
+     * 1. 校验输入参数 2. 检查密码是否存在 3. 如果设为默认密码则先清除其他默认密码 4. 执行更新
+     * @param passwordItem - 包含待更新密码ID及字段的对象
+     * @returns 更新后的密码
+     * @throws {Error} 当输入参数不合法或密码不存在时抛出
+     */
+    handleUpdate(passwordItem) {
+        const { id, isDefault } = passwordItem;
+        // 检查密码是否存在
+        const existingPassword = this.passwordRepo.findOneById(id);
+        if (!existingPassword) {
+            throw new Error(`更新失败，密码【${id}】不存在`);
+        }
+        // 如果更新了名称，检查是否与其他密码冲突
+        if (passwordItem.name && passwordItem.name !== existingPassword.name) {
+            if (this.passwordRepo.existsByEnvIdAndName(existingPassword.envId, passwordItem.name)) {
+                throw new Error(`更新失败，该环境下已存在名称为【${passwordItem.name}】的密码`);
+            }
+        }
+        // 如果设为默认密码（从false改为true），先清除其他默认密码
+        if (isDefault && !existingPassword.isDefault) {
+            this.passwordRepo.clearDefaultByEnvId(existingPassword.envId, id);
+        }
+        // 添加更新时间
+        passwordItem.updatedAt = new Date().toISOString();
+        // 执行更新
+        this.passwordRepo.update(passwordItem);
+        // 返回更新后的密码
+        return this.passwordRepo.findOneById(id);
+    }
+    /**
+     * 删除指定密码
+     * 1. 校验输入参数 2. 检查密码是否存在 3. 执行删除操作
+     * @param passwordItem - 包含待删除密码ID的对象
+     * @throws {Error} 当输入参数不合法或密码不存在时抛出
+     */
+    handleDelete(passwordItem) {
+        const { id } = passwordItem;
+        // 检查密码是否存在
+        const existingPassword = this.passwordRepo.findOneById(id);
+        if (!existingPassword) {
+            throw new Error(`删除失败，密码【${id}】不存在`);
+        }
+        // 执行删除
+        this.passwordRepo.delete(passwordItem);
+    }
+}
+export { PasswordService };

package/dist/service/PreProxyServer.js

@@ -0,0 +1,344 @@
+import express from "express";
+import { createProxyMiddleware } from "http-proxy-middleware";
+import setCookieParser from "set-cookie-parser";
+import * as libCookie from "cookie";
+import { minimatch } from "minimatch";
+import * as fs from "fs";
+import * as path from "path";
+import { getConfig } from "../utils/ResolveConfig.js";
+import { devServerLogger } from "../utils/logger.js";
+class PreProxyServer {
+    /**
+     * 判断该端口是否已经有服务存在
+     * @param port
+     * @returns
+     */
+    static getAppInsByPort(port) {
+        return this.appMap[port];
+    }
+    static async create(envId, envRepo, devServerRepo, routeRuleRepo) {
+        if (this.appMap[envId]) {
+            devServerLogger.info(`环境 ${envId} 已经启动`);
+            return null;
+        }
+        const preProxyServer = new PreProxyServer(envId, envRepo, devServerRepo, routeRuleRepo);
+        await preProxyServer.startServer();
+        PreProxyServer.appMap[envId] = preProxyServer;
+        return preProxyServer;
+    }
+    constructor(envId, envRepo, devServerRepo, routeRuleRepo, app = express()) {
+        this.envId = envId;
+        this.envRepo = envRepo;
+        this.devServerRepo = devServerRepo;
+        this.routeRuleRepo = routeRuleRepo;
+        this.app = app;
+        app.use([`${getConfig().apiPrefix}/inject/getcurrentenv`], (req, res) => {
+            res.json({ envId: this.envId });
+            res.end();
+        });
+        // 代理 /envm 相关的请求到无需经过 Dev Server ProxyServer（PostProxyServer）
+        app.use(["/envm-inject", getConfig().apiPrefix], this.createInjectProxyMiddleware());
+        // 主代理中间件
+        app.use(this.createPreProxyMiddleware());
+    }
+    /**
+     * 创建注入脚本的代理中间件
+     * 代理所有 /envm-inject 开头的请求到 ProxyServer
+     */
+    createInjectProxyMiddleware() {
+        return createProxyMiddleware({
+            ws: true,
+            pathRewrite: (path, req) => {
+                return req.originalUrl;
+            },
+            router: () => {
+                const config = getConfig();
+                // 代理到 ProxyServer（后置代理服务器）
+                return `http://localhost:${config.port}`;
+            },
+        });
+    }
+    /**
+     *
+     * @returns 获取绑定的环境信息
+     */
+    getEnvItem() {
+        const envItem = this.envRepo.findOneById(this.envId);
+        return envItem;
+    }
+    /**
+     * 获取绑定的服务器详情
+     */
+    getDevServer() { }
+    /**
+     * 当前 代理的 cookie 后缀
+     */
+    get cookieSuffix() {
+        const envItem = this.getEnvItem();
+        return `-${envItem?.port}-${PreProxyServer.configCookieSuffix}`;
+    }
+    /**
+     * 配置的 cookie 后缀
+     */
+    static get configCookieSuffix() {
+        return `${getConfig().cookieSuffix}`;
+    }
+    /**
+     * 根据请求路径匹配路由规则，检查是否需要注入 Script
+     * @param requestPath 请求路径
+     * @returns 是否需要注入 Script
+     */
+    shouldInjectScript(requestPath) {
+        const routeRules = this.routeRuleRepo.getByEnvId(this.envId);
+        const enabledRules = routeRules.filter((rule) => rule.enabled !== false);
+        for (const rule of enabledRules) {
+            if (minimatch(requestPath, rule.pathPrefix, { dot: true })) {
+                return rule.injectScript === true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 根据请求路径匹配路由规则
+     * @param requestPath 请求路径
+     * @returns 匹配到的目标环境地址，如果没有匹配则返回 null
+     */
+    matchRouteRule(requestPath) {
+        const routeRules = this.routeRuleRepo.getByEnvId(this.envId);
+        // 过滤出已启用的规则
+        const enabledRules = routeRules.filter((rule) => rule.enabled !== false);
+        // 按 pathPrefix 长度降序排序，确保最长前缀匹配优先
+        const sortedRules = [...enabledRules].sort((a, b) => b.pathPrefix.length - a.pathPrefix.length);
+        for (const rule of sortedRules) {
+            // 使用 minimatch 支持 glob 模式匹配
+            if (minimatch(requestPath, rule.pathPrefix, { dot: true })) {
+                // 获取目标环境信息
+                if (rule.targetEnvId) {
+                    const targetEnv = this.envRepo.findOneById(rule.targetEnvId);
+                    if (targetEnv?.apiBaseUrl) {
+                        devServerLogger.info(`路由规则匹配成功: ${requestPath} -> ${rule.pathPrefix}, 转发到: ${targetEnv.apiBaseUrl}`);
+                        return targetEnv.apiBaseUrl;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * 生成代理中间件
+     * @returns
+     */
+    createPreProxyMiddleware() {
+        // 前置转发：将请求转发到 开发服务器
+        return createProxyMiddleware({
+            ws: true,
+            changeOrigin: true,
+            selfHandleResponse: true,
+            router: (req) => {
+                const requestPath = req.path || "/";
+                // 1. 检查是否配置了路由规则
+                const customTarget = this.matchRouteRule(requestPath);
+                if (customTarget) {
+                    return customTarget;
+                }
+                // 2. 默认转发到 devServer
+                const envItem = this.getEnvItem();
+                const devServerConfig = this.devServerRepo.findOneById({
+                    id: envItem?.devServerId ?? "",
+                });
+                return `${devServerConfig?.devServerUrl}`;
+            },
+            on: {
+                proxyReq: (proxyReq, req) => {
+                    const requestPath = req.path || "/";
+                    // 优先使用路由规则的目标地址，否则使用环境默认的 apiBaseUrl
+                    const customTarget = this.matchRouteRule(requestPath);
+                    const target = customTarget || `${this.getEnvItem()?.apiBaseUrl}`;
+                    proxyReq.setHeader("x-api-server", `${target}`);
+                    this._rewrieCookieOnProxyReq(proxyReq, req);
+                },
+                proxyRes: (proxyRes, req, res) => {
+                    this._rewriteSetCookieOnProxyRes(proxyRes);
+                    this._rewriteLoginRedirect(proxyRes, req, res);
+                },
+                proxyReqWs: (proxyReq, req) => {
+                    const requestPath = req.path || "/";
+                    const customTarget = this.matchRouteRule(requestPath);
+                    const target = customTarget || `${this.getEnvItem()?.apiBaseUrl}`;
+                    proxyReq.setHeader("x-api-server", `${target}`);
+                },
+            },
+        });
+    }
+    /**
+     * 代理的时候如果收到了 setcookie 请求
+     * 给 每一个 setcookie 追加保存一个 代理cookie
+     * @param proxyRes
+     */
+    _rewriteSetCookieOnProxyRes(proxyRes) {
+        const envItem = this.getEnvItem();
+        const setCookie = proxyRes.headers["set-cookie"];
+        if (envItem && setCookie) {
+            const setCookies = setCookieParser.parse(setCookie);
+            const proxyCookie = setCookies.map((item) => {
+                const cookie = {
+                    ...item,
+                    name: `${item.name}${this.cookieSuffix}`,
+                };
+                return libCookie.serialize(cookie.name, cookie.value, cookie);
+            });
+            setCookie.push(...proxyCookie);
+        }
+    }
+    /**
+     * 代理 转发的时候，将对应端口的cookie 重写回去
+     */
+    _rewrieCookieOnProxyReq(proxyReq, req) {
+        const envItem = this.getEnvItem();
+        if (envItem && req.headers.cookie) {
+            const cookie = libCookie.parse(req.headers.cookie || "");
+            const newCookies = [];
+            Object.keys(cookie).forEach((item) => {
+                if (item.endsWith(PreProxyServer.configCookieSuffix)) {
+                    return;
+                }
+                let cookieName = `${item}${this.cookieSuffix}`;
+                if (!cookie[cookieName]) {
+                    cookieName = item;
+                }
+                newCookies.push(libCookie.serialize(item, cookie[cookieName] || ""));
+            });
+            proxyReq.setHeader("cookie", newCookies.join(";"));
+        }
+    }
+    _rewriteLoginRedirect(proxyRes, req, res) {
+        const contentType = proxyRes.headers["content-type"] || "";
+        const requestPath = req.path || "/";
+        // 转发状态码 + 响应头
+        res.statusCode = proxyRes.statusCode || 200;
+        for (const key in proxyRes.headers) {
+            if (!res.headersSent && proxyRes.headers[key]) {
+                res.setHeader(key, proxyRes.headers[key]);
+            }
+        }
+        const chunks = [];
+        proxyRes.on("data", (chunk) => chunks.push(chunk));
+        proxyRes.on("end", () => {
+            try {
+                const body = Buffer.concat(chunks);
+                // 只对 HTML && 路由规则开启注入的路径
+                if (contentType.includes("text/html") &&
+                    this.shouldInjectScript(requestPath)) {
+                    const config = getConfig();
+                    const scriptDir = config.injectScriptDir;
+                    if (!scriptDir) {
+                        devServerLogger.warn("未配置注入脚本目录 (injectScriptDir)");
+                        res.end(body);
+                        return;
+                    }
+                    let html = body.toString("utf8");
+                    // 读取文件夹下所有 js 文件（排除 # 开头的文件）
+                    const scriptTags = this.generateImportScripts(scriptDir);
+                    html = html.replace(/<\/body>\s*<\/html>/gi, `${scriptTags}</body></html>`);
+                    const newBody = Buffer.from(html, "utf8");
+                    res.setHeader("Content-Length", newBody.length);
+                    res.end(newBody);
+                }
+                else {
+                    // 其他内容原样返回
+                    res.end(body);
+                }
+            }
+            catch (err) {
+                console.error("注入处理异常", err);
+                res.end(Buffer.concat(chunks));
+            }
+        });
+    }
+    /**
+     * 生成导入脚本的 HTML
+     * @param scriptDir 脚本文件夹路径
+     * @returns 脚本标签 HTML
+     */
+    generateImportScripts(scriptDir) {
+        const fullPath = path.resolve(scriptDir);
+        if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
+            devServerLogger.warn(`注入脚本目录不存在: ${fullPath}`);
+            return "";
+        }
+        const files = fs.readdirSync(fullPath);
+        const jsFiles = files
+            .filter((file) => file.endsWith(".js") && !file.startsWith("#"))
+            .sort();
+        if (jsFiles.length === 0) {
+            devServerLogger.warn(`注入脚本目录没有 js 文件: ${fullPath}`);
+            return "";
+        }
+        const importStatements = jsFiles
+            .map((file) => `<script type="module" src="/envm-inject/${file}"></script>`)
+            .join("\n");
+        return importStatements;
+    }
+    /**
+     * 启动服务
+     * @param envItem
+     * @returns
+     */
+    async startServer() {
+        const { port } = this.getEnvItem();
+        if (PreProxyServer.appMap[this.envId]) {
+            devServerLogger.info(`环境 ${this.envId} 已经启动`);
+            return;
+        }
+        this.server = await new Promise((resolve, reject) => {
+            const server = this.app.listen(port, () => {
+                devServerLogger.info(`Server is running on http://localhost:${port}`);
+                resolve(server);
+            });
+            server.on("error", (err) => {
+                console.error(`端口 ${port} 启动失败:`, err.message);
+                reject(err);
+            });
+        });
+        this.sockets = new Set();
+        this.server.on("connection", (socket) => {
+            this.sockets.add(socket);
+            socket.setTimeout(300000);
+            socket.on("timeout", () => {
+                socket.destroy();
+                this.sockets.delete(socket);
+            });
+            socket.on("close", () => {
+                this.sockets.delete(socket);
+            });
+        });
+    }
+    static stopServer(id) {
+        return new Promise((resolve) => {
+            if (!this.getAppInsByPort(id)) {
+                devServerLogger.info(`端口 【${id}】 未启动，无需停止！`);
+                resolve(1);
+                return;
+            }
+            for (const socket of this.appMap[id].sockets) {
+                socket.destroy();
+            }
+            this.appMap[id].server.close((err) => {
+                if (err) {
+                    console.error("服务器关闭失败：", err);
+                    resolve(0);
+                }
+                else {
+                    delete this.appMap[id];
+                    devServerLogger.info({ id }, `Server on port ${id} 已关闭`);
+                    resolve(1);
+                }
+            });
+        });
+    }
+}
+/**
+ * 保存启动的环境实例
+ */
+PreProxyServer.appMap = {};
+export default PreProxyServer;