yds-tool 0.0.1

package/bin/app.js

@@ -0,0 +1,74 @@
+
+// 禁用vweb logo
+global.__vweb_logo = false;
+const {LoggerFactory, startup, defineEnvironment, getApplicationContext } = require('vweb-core');
+const confUtil = require('vweb-core/lib/conf/util')
+const {program} = require('commander');
+confUtil.logger.info = () => {}
+
+!(() => {
+    const {program} = require('commander');
+    let result = program.parseOptions(process.argv);
+    for (let i = 0; i < result.unknown?.length; i++) {
+    let name = result.unknown[i];
+    let value = result.unknown[i + 1] || '';
+    if (!value || value.startsWith('-')) continue;
+    if (name === '-l' || name === '--level') {
+        process.env.level = value;
+    }
+}})()
+
+process.on('unhandledRejection', (reason, p) => {
+    console.error(`${reason}`, p);
+});
+startup({
+    conf: defineEnvironment({
+        app: {
+            name: 'yds'
+        },
+        config: {
+            src: 'lib'
+        },
+        logger: {
+            appenders: {
+                console: {
+                    type: 'console'
+                },
+                file: {
+                    type: 'dateFile',
+                    filename: 'yds',
+                    pattern: 'yyyy-MM-dd.log',
+                    alwaysIncludePattern: true,
+                    compress: true,
+                    numBackups: 7,
+                    keepFileExt: true,
+                    layout: {
+                        type: 'pattern',
+                        pattern: '%d{yyyy-MM-dd hh.mm.ss.SSS} [%p] %m'
+                    }
+                }
+            },
+            categories: {
+                default: {
+                    appenders: [
+                        'console', 'file'
+                    ],
+                    level: '${level:info}'
+                },
+                VWebApplicationContext: {
+                    appenders: [
+                        'file'
+                    ],
+                    level: '${level:info}'
+                }
+            },
+            disableClustering: true
+        }
+    })
+}).then(() => {
+    let Main = require('./index');
+    return new Main(getApplicationContext()).startup();
+}).catch(err => {
+    console.log(err);
+})
+

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('./app')

package/bin/index.js

@@ -0,0 +1,3 @@
+(function() {
+   module.exports = require('./main').default;
+}).call(this);

package/bin/main.js

@@ -0,0 +1,459 @@
+"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;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const process = __importStar(require("process"));
+const vweb_core_1 = require("vweb-core");
+const path = __importStar(require("node:path"));
+const child_process = __importStar(require("node:child_process"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const crypto_1 = require("crypto");
+const domainKey = 'p-hcc-i000-p00a-hrcpe';
+const pkg = require('../package.json');
+const RS_URL = 'https://dfs.zhiper.com/v3r6';
+const logger = vweb_core_1.LoggerFactory.getLogger('YDS');
+const execCmd = (command, cwd) => __awaiter(void 0, void 0, void 0, function* () {
+    logger.info(`执行命令 ${command} ${cwd ? `，执行目录为${cwd}` : ''}`);
+    let start = Date.now();
+    child_process.execSync(command, {
+        cwd, encoding: 'utf-8',
+        timeout: 60000,
+        stdio: [0, 1, 2]
+    });
+    logger.info(`执行命令 ${command} 耗时 \x1B[34m <${Date.now() - start}ms>]`);
+});
+const platform = os.platform();
+if (platform !== 'win32') {
+    logger.error('当前工具仅支持windows系统');
+    process.exit(1);
+}
+const isAdmin = () => {
+    try {
+        child_process.execSync('net session >nul 2>&1');
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+};
+let wget = path.resolve('wget.exe');
+let zip = path.resolve('zip.exe');
+let unzip = path.resolve('unzip.exe');
+commander_1.program.name("yds")
+    .usage("[command] [options]")
+    .description("yds 制盘工具 如果命令参数中存在空格 使用双引号\"\"包裹")
+    .version(`yds ${pkg.version}`);
+class Main {
+    startup() {
+        commander_1.program
+            .command('init [workdir]')
+            .usage('init [workdir]')
+            .description('初始化YDS制盘环境, workdir表示制盘工作目录，如果不指定则使用当前目录')
+            .action((...args_1) => __awaiter(this, [...args_1], void 0, function* (workdir = path.resolve(process.cwd())) {
+            const dir = path.resolve(workdir);
+            logger.info(`初始化YDS制盘环境 工作目录：${dir}`);
+            const gitExists = yield vweb_core_1.util.cmd.exists('git');
+            logger.info(`检查是否安装了git >> ${gitExists ? '已安装' : '未安装'}`);
+            if (!gitExists && !fs.existsSync(`${dir}/git-for-windows`)) {
+                const gitZipName = 'git-for-windows.zip';
+                logger.info(`下载git 安装包 ${gitZipName}`);
+                const gitZipFile = `${dir}/${gitZipName}`;
+                if (fs.existsSync(gitZipFile)) {
+                    logger.info(`删除已存在安装包 ${gitZipFile}`);
+                    fs.rmSync(gitZipFile);
+                }
+                yield execCmd(`${wget} ${RS_URL}/${gitZipName} -O "${gitZipFile}"`);
+                logger.info(`解压安装包 ${gitZipFile}`);
+                yield execCmd(`"${unzip}" "${gitZipFile}" -d "${dir}"`);
+                fs.rmSync(gitZipFile);
+                logger.info(`git 安装完成`);
+            }
+            const javaExists = yield vweb_core_1.util.cmd.exists('java');
+            logger.info(`检查是否安装了java >> ${javaExists ? '已安装' : '未安装'}`);
+            if (!javaExists) {
+                logger.info('未找到java，准备安装java，开始下载jdk');
+                const jdkZipName = 'jdk-11.0.15.1_windows-x64_bin.zip';
+                yield execCmd(`${wget} ${RS_URL}/${jdkZipName} -O "${dir}/${jdkZipName}"`);
+                logger.info(`解压jdk 安装包 ${dir}/${jdkZipName}`);
+                yield execCmd(`"${unzip}" "${dir}/${jdkZipName}"`, dir);
+                logger.info(`配置java环境变量`);
+                let javaHome = `${dir}/jdk-11.0.15.1`;
+                yield execCmd(`setx JAVA_HOME "${javaHome}"`);
+                yield execCmd(`setx CLASS_PATH ".;%JAVA_HOME%\lib;"`);
+                yield execCmd(`setx PATH "%PATH%;%JAVA_HOME%\bin;"`);
+                process.env.JAVA_HOME = javaHome;
+                logger.info(`java 安装完成`);
+            }
+            logger.info(`检查java版本`);
+            yield execCmd('java -version');
+            const javaHome = process.env.JAVA_HOME;
+            if (javaHome) {
+                let certsFilename = 'lib/security/cacerts';
+                let certsFile = `${javaHome}/${certsFilename}`;
+                if (!fs.existsSync(certsFile)) {
+                    certsFile = `${javaHome}/jre/${certsFilename}`;
+                }
+                logger.info(`检查java证书目录 ${certsFile}`);
+                if (fs.existsSync(certsFile)) {
+                    try {
+                        yield execCmd(`keytool -list -v -keystore "${certsFile}" -storepass changeit --alias yyrd`);
+                        logger.info(`yyrd.crt 证书已存在`);
+                    }
+                    catch (e) {
+                        logger.info(`导入 yyrd.crt 证书到java ${certsFile}`);
+                        yield execCmd(`keytool -importcert -file "${dir}/yyrd.crt" -keystore "${certsFile}" -storepass changeit -noprompt`);
+                        logger.info(`yyrd.crt 证书导入完成`);
+                    }
+                }
+            }
+            const mavenHome = `${dir}/maven-3.8.6`;
+            const mavenExists = vweb_core_1.util.cmd.exists('mvn');
+            logger.info(`检查是否安装了maven >> ${mavenExists ? '已安装' : '未安装'}`);
+            if (!mavenExists) {
+                const mavenZipName = 'maven-3.8.6.zip';
+                logger.info(`下载maven 安装包 ${mavenZipName}`);
+                const mavenZipFile = `${dir}/${mavenZipName}`;
+                if (fs.existsSync(mavenZipFile)) {
+                    logger.info(`删除已存在安装包 ${mavenZipFile}`);
+                    fs.rmSync(mavenZipFile);
+                }
+                yield execCmd(`${wget} ${RS_URL}/${mavenZipName} -O "${mavenZipFile}"`);
+                logger.info(`解压安装包 ${mavenZipFile}`);
+                yield execCmd(`"${unzip}" "${mavenZipFile}" -d "${dir}"`);
+                fs.rmSync(mavenZipFile);
+                try {
+                    let mvnPath = path.resolve(`${mavenHome}/bin`);
+                    yield execCmd(`setx PATH "%PATH%;${mvnPath}"`);
+                    logger.info(`✅ 成功！Maven路径【${mvnPath}】已添加到系统PATH环境变量`);
+                }
+                catch (err) {
+                    console.error('❌ 添加失败：', err.message);
+                }
+                logger.info(`maven 安装完成`);
+            }
+            logger.info(`初始化node环境`);
+            yield execCmd('npm install -g pnpm typescript --registry=https://registry.npmmirror.com');
+            logger.info(`初始化node环境完成`);
+            logger.info(`检测code是否存在`);
+            const codeDir = `${dir}/yds-1.0.3`;
+            if (!fs.existsSync(codeDir)) {
+                const codeZipName = 'yds-1.0.3-jdk-8-windows-x86_64.zip';
+                logger.info(`下载code IDE 安装包 ${codeZipName}`);
+                const codeZipFile = `${dir}/${codeZipName}`;
+                if (fs.existsSync(codeZipFile)) {
+                    logger.info(`删除已存在安装包 ${codeZipFile}`);
+                    fs.rmSync(codeZipFile);
+                }
+                yield execCmd(`${wget} https://yoncommunity.yonyoucloud.com/YDSDownload/Window/x64/${codeZipName} -O "${codeZipFile}"`);
+                logger.info(`解压安装包 ${codeZipFile}`);
+                fs.mkdirSync(codeDir, { recursive: true });
+                yield execCmd(`"${unzip}" "${codeZipFile}" -d "${codeDir}"`);
+                fs.rmSync(codeZipFile);
+                yield new Promise((resolve) => setTimeout(resolve, 5000));
+                logger.info(`code IDE 安装完成`);
+            }
+            logger.info(`初始化YDS IDE 全局配置`);
+            const settingsJson = `${codeDir}/Code/data/user-data/User/settings.json`;
+            let settingsJsonObj = {};
+            if (fs.existsSync(settingsJson)) {
+                settingsJsonObj = JSON.parse(fs.readFileSync(settingsJson).toString('utf-8'));
+            }
+            let settingXml = path.resolve(`${mavenHome}/conf/settings.xml`);
+            if (!fs.existsSync(settingXml) && !fs.existsSync(`${dir}/settings.xml`)) {
+                yield execCmd(`${wget} ${RS_URL}/settings.xml`);
+                settingXml = path.resolve(`${dir}/settings.xml`);
+            }
+            settingsJsonObj["java.configuration.maven.globalSettings"] = settingXml;
+            settingsJsonObj["java.configuration.maven.userSettings"] = settingXml;
+            settingsJsonObj["maven.settingsFile"] = settingXml;
+            fs.writeFileSync(settingsJson, JSON.stringify(settingsJsonObj, null, 4));
+            logger.info(`初始化YDS IDE 全局配置完成`);
+            const sshDir = path.resolve(process.env.USERPROFILE, '.ssh');
+            if (!fs.existsSync(sshDir)) {
+                fs.mkdirSync(sshDir);
+            }
+            if (!fs.existsSync(`${sshDir}/id_ed25519.pub`)) {
+                logger.info(`拷贝密钥文件`);
+                fs.copyFileSync(`${dir}/id_ed25519.pub`, `${sshDir}/id_ed25519.pub`);
+                fs.copyFileSync(`${dir}/id_ed25519`, `${sshDir}/id_ed25519`);
+                logger.info(`拷贝密钥文件完成`);
+            }
+            logger.info(`初始化YDS制盘环境完成`);
+        })).hook('postAction', () => process.exit(0));
+        commander_1.program
+            .command('start <catalog> [workdir]')
+            .usage('start <catalog> [workdir]')
+            .option('-f, --file <file>', '配置文件')
+            .addHelpText('after', `
+配置文件内容示例：
+{
+    hosts?: Array<string>;
+    git: Record<'hrcpe' | 'fecode', string>;
+    catalogs: {
+        [catalog: string]: Record<'hrcpe' | 'fecode', string | { url: string, branch: string }>
+    }
+}`)
+            .description('启动制盘环境，catalog表示需要制盘的模块，对应配置文件中catalogs的key值，用于指定需要出盘的信息，workdir表示制盘工作目录，如果不指定则使用当前目录')
+            .action((catalog_1, ...args_1) => __awaiter(this, [catalog_1, ...args_1], void 0, function* (catalog, workdir = path.resolve(process.cwd()), options) {
+            const dir = path.resolve(workdir);
+            logger.info(`开始检测制盘环境检测`);
+            let gitCmd = 'git';
+            const gitExists = yield vweb_core_1.util.cmd.exists(gitCmd);
+            if (!gitExists) {
+                gitCmd = `${dir}/git-for-windows/bin/git.exe`;
+                if (!fs.existsSync(gitCmd)) {
+                    logger.error(`未找到git命令 ${gitCmd}, 请先执行 init 初始化制盘环境`);
+                    process.exit(1);
+                }
+            }
+            let settingXml = path.resolve(`${dir}/settings.xml`);
+            let mvnCmd = 'mvn';
+            if (!fs.existsSync(settingXml)) {
+                let mavenHome = `${dir}/maven-3.8.6`;
+                mvnCmd = `"${mavenHome}/bin/mvn.cmd"`;
+                settingXml = `${mavenHome}/conf/settings.xml`;
+                if (!fs.existsSync(mvnCmd)) {
+                    logger.error(`未找到mvn命令 ${mvnCmd}, 请先执行 init 初始化制盘环境`);
+                    process.exit(1);
+                }
+            }
+            let idePath = `${dir}/yds-1.0.3`;
+            if (!fs.existsSync(idePath)) {
+                logger.error(`未找到IDE ${idePath}, 请先执行 init 初始化制盘环境`);
+                process.exit(1);
+            }
+            logger.info(`制盘环境检测完成`);
+            const ydsJson = path.resolve(options.file || `${dir}/yds.json`);
+            logger.info(`开始制盘 ${catalog} 工作目录：${dir}`);
+            if (!fs.existsSync(ydsJson)) {
+                logger.error(`未找到配置文件 ${ydsJson}`);
+                process.exit(1);
+            }
+            const ydsJsonStr = fs.readFileSync(ydsJson).toString('utf-8');
+            let config;
+            const checkConfigError = () => {
+                logger.error(`配置文件 ${ydsJson} 格式错误 参考示例：
+{
+    hosts?: Array<string>;
+    git: Record<'hrcpe' | 'fecode', string>;
+    catalogs: {
+        [catalog: string]: Record<'hrcpe' | 'fecode', string | { url: string, branch: string }>
+    }
+}`);
+                process.exit(1);
+            };
+            try {
+                config = JSON.parse(ydsJsonStr);
+                if (!config.catalogs) {
+                    checkConfigError();
+                }
+            }
+            catch (e) {
+                checkConfigError();
+            }
+            const git = config.git;
+            const catalogConfig = config.catalogs[catalog];
+            if (typeof catalogConfig === 'undefined') {
+                logger.error(`配置文件 ${ydsJson} 找不到 catalogs.${catalog} 先关配置`);
+                process.exit(1);
+            }
+            if (typeof catalogConfig.hrcpe === 'undefined' || typeof catalogConfig.fecode === 'undefined') {
+                logger.error(`配置文件 ${ydsJson} catalogs.${catalog}.hrcpe 或 catalogs.${catalog}.fecode 字段缺失`);
+                process.exit(1);
+            }
+            const namespace = `${dir}/${catalog}`;
+            if (!fs.existsSync(namespace)) {
+                logger.info(`创建目录 ${namespace}`);
+                fs.mkdirSync(namespace);
+            }
+            else {
+                logger.info(`目录 ${namespace} 已存在`);
+            }
+            let hrcpeUrl = typeof catalogConfig.hrcpe === 'string' ? git === null || git === void 0 ? void 0 : git.hrcpe : catalogConfig.hrcpe.url;
+            if (!hrcpeUrl) {
+                logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 后端服务 未指定仓库地址，请通过 git.hrcpe 或者 catalogs.${catalog}.hrcpe.url 指定仓库地址`);
+            }
+            logger.info(`开始拉取后端服务仓库 ${hrcpeUrl}`);
+            if (fs.existsSync(`${namespace}/.git`)) {
+                logger.info(`目录 ${namespace} 已存在，开始更新仓库`);
+                yield execCmd(`"${gitCmd}" pull`, namespace);
+            }
+            else {
+                logger.info(`目录 ${namespace} 不存在，开始创建仓库`);
+                let branch = typeof catalogConfig.hrcpe === 'string' ? catalogConfig.hrcpe : catalogConfig.hrcpe.branch;
+                if (!branch) {
+                    logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 后端服务 未指定分支，请通过 git.hrcpe 或者 catalogs.${catalog}.hrcpe.branch 配置分支`);
+                    process.exit(1);
+                }
+                yield execCmd(`"${gitCmd}" clone -b ${branch} ${hrcpeUrl} ${namespace}`, namespace);
+            }
+            logger.info(`拉取后端服务仓库完成`);
+            let boostrapPomXml = `${namespace}/${domainKey}-be/dev-${domainKey}-bootstrap/pom.xml`;
+            logger.info(`替换文件 ${boostrapPomXml} 中的ROOT为domainKey，否则会导致制盘失败，无法找到制品`);
+            const boostrapPomXmlString = fs.readFileSync(boostrapPomXml).toString('utf-8');
+            if (boostrapPomXmlString.includes('ROOT')) {
+                fs.writeFileSync(boostrapPomXml, boostrapPomXmlString.replace(/ROOT/g, domainKey));
+            }
+            if (config.hosts && config.hosts.length) {
+                logger.info(`存在hosts配置，检测系统hosts配置文件是否已经配置`);
+                let hostsFile = path.resolve(process.env.WINDIR, 'System32', 'drivers', 'etc', 'hosts');
+                const hostList = fs.readFileSync(hostsFile).toString('utf-8').split('\n');
+                let appendHosts = [...config.hosts];
+                for (let hostItem of hostList) {
+                    if (/#/.test(hostItem)) {
+                        continue;
+                    }
+                    for (let appendHost of config.hosts) {
+                        const [ip, domain] = appendHost.split(' ').filter(item => item);
+                        if (hostItem.includes(ip) && hostItem.includes(domain)) {
+                            logger.info(`系统hosts配置文件已存在 ${appendHost}`);
+                            appendHosts.remove(appendHost);
+                        }
+                    }
+                }
+                if (appendHosts.length) {
+                    if (isAdmin()) {
+                        fs.appendFileSync(hostsFile, `\n${appendHosts.join('\n')}\n`, {
+                            encoding: 'utf-8'
+                        });
+                    }
+                    else {
+                        logger.error(`当前非管理员启动无法更改hosts文件，请使用管理员启动或者手动添加 ${appendHosts.join('\n')} 到文件 ${hostsFile}`);
+                    }
+                }
+                logger.info(`hosts 配置检测完成`);
+            }
+            logger.info('初始化项目maven环境');
+            let mvnConfigDir = `${namespace}/.mvn`;
+            if (!fs.existsSync(mvnConfigDir)) {
+                yield execCmd(`${mvnCmd} -N io.takari:maven:wrapper -Dmaven=3.8.6`, namespace);
+            }
+            let configFile = `${mvnConfigDir}/maven.config`;
+            if (fs.existsSync(configFile)) {
+                fs.rmSync(configFile);
+            }
+            fs.writeFileSync(`${mvnConfigDir}/maven.config`, `-s\n${settingXml}\n-Dmaven.wagon.http.ssl.insecure=true\n-Dmaven.wagon.http.ssl.allowall=true`);
+            logger.info(`当前maven信息`);
+            yield execCmd(`${mvnCmd} --version`, namespace);
+            logger.info('项目maven清理');
+            yield execCmd(`${mvnCmd} clean -DskipTests`, `${namespace}/${domainKey}-be`);
+            logger.info('处理前端构建，增加构建文件');
+            let feDir = `${namespace}/${domainKey}-fe`;
+            let feBuildJs = `${feDir}/build.js`;
+            if (!fs.existsSync(feBuildJs)) {
+                fs.cpSync(`${dir}/fe-build.js`, feBuildJs);
+            }
+            let fePackageJson = `${feDir}/package.json`;
+            const packageString = fs.readFileSync(fePackageJson).toString('utf-8');
+            if (!packageString.includes('build.js')) {
+                logger.info(`修改${fePackageJson}`);
+                const packageJson = JSON.parse(packageString);
+                packageJson.scripts['build:extend'] += ' && node build.js';
+                fs.writeFileSync(fePackageJson, JSON.stringify(packageJson, null, 4));
+                logger.info(`修改${fePackageJson}完成`);
+            }
+            let fecodeUrl = typeof catalogConfig.fecode === 'string' ? git === null || git === void 0 ? void 0 : git.fecode : catalogConfig.fecode.url;
+            if (!fecodeUrl) {
+                logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 后端服务 未指定仓库地址，请通过 git.fecode 或者 catalogs.${catalog}.fecode.url 指定仓库地址`);
+            }
+            logger.info(`开始拉取报告服务仓库 ${fecodeUrl}`);
+            let reportNamespace = `${namespace}/yonbip-yisv-izp1-dev-fecode`;
+            if (fs.existsSync(`${reportNamespace}/.git`)) {
+                logger.info(`目录 ${reportNamespace} 已存在，开始更新仓库`);
+                yield execCmd(`"${gitCmd}" pull`, reportNamespace);
+            }
+            else {
+                logger.info(`目录 ${reportNamespace} 不存在，开始创建仓库`);
+                let branch = typeof catalogConfig.fecode === 'string' ? catalogConfig.fecode : catalogConfig.fecode.branch;
+                if (!branch) {
+                    logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 报告服务未指定分支，请通过 git.fecode 或者 catalogs.${catalog}.fecode.branch 配置分支`);
+                    process.exit(1);
+                }
+                yield execCmd(`"${gitCmd}" clone -b ${branch} ${fecodeUrl} ${reportNamespace}`);
+            }
+            logger.info(`拉取报告服务仓库完成`);
+            logger.info('处理报告构建，增加构建文件');
+            let fecodeBuildJs = `${reportNamespace}/build.js`;
+            if (!fs.existsSync(fecodeBuildJs)) {
+                fs.cpSync(`${dir}/fecode-build.js`, fecodeBuildJs);
+            }
+            let fecodePackageJson = `${reportNamespace}/package.json`;
+            const fecodePackageString = fs.readFileSync(fecodePackageJson).toString('utf-8');
+            if (!fecodePackageString.includes('build.js')) {
+                logger.info(`修改${fecodePackageJson}`);
+                const packageJson = JSON.parse(fecodePackageString);
+                packageJson.scripts['build'] += ' && node build.js';
+                packageJson.domainKey = domainKey;
+                delete packageJson.dependencies.zlib;
+                fs.writeFileSync(fecodePackageJson, JSON.stringify(packageJson, null, 4));
+                logger.info(`修改${fecodePackageJson}完成`);
+            }
+            logger.info(`安装报告服务依赖`);
+            yield execCmd('npm i', reportNamespace);
+            logger.info(`生成version.json 文件`);
+            const uuid = (0, crypto_1.randomUUID)().toString();
+            fs.writeFileSync(`${reportNamespace}/version.json`, `{"version": "${uuid}"}`);
+            logger.info('初始化项目环境资源');
+            if (fs.existsSync(`${namespace}/disk`) || fs.existsSync(`${namespace}/disks`)) {
+                logger.info(`已存在，跳过环境资源文件下载`);
+            }
+            else {
+                logger.info(`开始下载项目环境资源文件`);
+                let gitZipFile = `${namespace}/env.zip`;
+                yield execCmd(`${wget} ${RS_URL}/env.zip -O "${gitZipFile}"`);
+                logger.info(`解压资源文件包 ${gitZipFile}`);
+                yield execCmd(`"${unzip}" "${gitZipFile}"`, namespace);
+                fs.rmSync(gitZipFile);
+            }
+            logger.info('启动IDE');
+            yield execCmd(`"${idePath}/Code/Code.exe" "${namespace}"`);
+            yield new Promise(resolve => setTimeout(resolve, 3000));
+            logger.info('已启动IDE，请按照文档说明进行制盘操作');
+        })).hook('postAction', () => process.exit(0));
+        commander_1.program.parse(process.argv);
+    }
+}
+exports.default = Main;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main.js","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"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","sourcesContent":["import {program} from \"commander\";\r\nimport * as process from \"process\";\r\nimport {LoggerFactory, util} from \"vweb-core\";\r\nimport * as path from \"node:path\";\r\nimport * as child_process from \"node:child_process\";\r\nimport * as fs from \"node:fs\";\r\nimport * as os from 'node:os';\r\nimport {randomUUID} from 'crypto'\r\n\r\nconst domainKey = 'p-hcc-i000-p00a-hrcpe';\r\nconst pkg = require('../package.json');\r\nconst RS_URL = 'https://dfs.zhiper.com/v3r6';\r\n\r\nconst logger: Logger = LoggerFactory.getLogger('YDS');\r\n\r\nconst execCmd = async (command: string, cwd?: string) => {\r\n    logger.info(`执行命令 ${command} ${cwd ? `，执行目录为${cwd}` :''}`);\r\n    let start  = Date.now();\r\n    child_process.execSync(command, {\r\n        cwd, encoding: 'utf-8',\r\n        timeout: 60000,\r\n        stdio: [0, 1, 2]\r\n    });\r\n    logger.info(`执行命令 ${command} 耗时 \\x1B[34m <${Date.now() - start}ms>]`)\r\n}\r\n\r\nconst platform = os.platform()\r\nif (platform !== 'win32') {\r\n    logger.error('当前工具仅支持windows系统');\r\n    process.exit(1);\r\n}\r\n\r\nconst isAdmin = () => {\r\n    try {\r\n        // 尝试执行一个只有管理员才能运行的命令\r\n        // 使用 >nul 2>&1 来抑制输出\r\n        child_process.execSync('net session >nul 2>&1');\r\n        return true; // 成功执行\r\n    } catch (err) {\r\n        return false; // 执行失败，权限不足\r\n    }\r\n}\r\n\r\nlet wget = path.resolve( 'wget.exe');\r\nlet zip = path.resolve('zip.exe');\r\nlet unzip = path.resolve('unzip.exe');\r\n\r\nprogram.name(\"yds\")\r\n    .usage(\"[command] [options]\")\r\n    .description(\"yds 制盘工具 如果命令参数中存在空格 使用双引号\\\"\\\"包裹\")\r\n    .version(`yds ${pkg.version}`);\r\n\r\ntype MicroService = 'hrcpe' | 'fecode';\r\n\r\ntype Git = {\r\n    url: string,\r\n    branch: string\r\n}\r\n\r\ntype YdsConfig = {\r\n    hosts: Array<string>;\r\n    git: Record<MicroService, string>;\r\n    catalogs: {\r\n        [catalog: string]: Record<MicroService, string | Git>\r\n    }\r\n}\r\n\r\nexport default class Main {\r\n\r\n    startup() {\r\n        program\r\n            .command('init [workdir]')\r\n            .usage('init [workdir]')\r\n            .description('初始化YDS制盘环境, workdir表示制盘工作目录，如果不指定则使用当前目录')\r\n            .action(async (workdir: string = path.resolve(process.cwd())) => {\r\n                const dir = path.resolve(workdir);\r\n                logger.info(`初始化YDS制盘环境 工作目录：${dir}`);\r\n                const gitExists = await util.cmd.exists('git');\r\n                logger.info(`检查是否安装了git >> ${gitExists ? '已安装' : '未安装'}`);\r\n                if (!gitExists && !fs.existsSync(`${dir}/git-for-windows`)) {\r\n                    const gitZipName = 'git-for-windows.zip'\r\n                    logger.info(`下载git 安装包 ${gitZipName}`);\r\n                    const gitZipFile = `${dir}/${gitZipName}`;\r\n                    // 检查是否已经存在安装包 如果有先删除\r\n                    if (fs.existsSync(gitZipFile)) {\r\n                        logger.info(`删除已存在安装包 ${gitZipFile}`);\r\n                        fs.rmSync(gitZipFile);\r\n                    }\r\n                    // 下载安装包并输出日志\r\n                    await execCmd(`${wget} ${RS_URL}/${gitZipName} -O \"${gitZipFile}\"`);\r\n                    logger.info(`解压安装包 ${gitZipFile}`)\r\n                    await execCmd(`\"${unzip}\" \"${gitZipFile}\" -d \"${dir}\"`);\r\n                    fs.rmSync(gitZipFile)\r\n                    logger.info(`git 安装完成`);\r\n                }\r\n\r\n                const javaExists = await util.cmd.exists('java');\r\n                logger.info(`检查是否安装了java >> ${javaExists ? '已安装' : '未安装'}`);\r\n                if (!javaExists) {\r\n                    logger.info('未找到java，准备安装java，开始下载jdk');\r\n                    const jdkZipName = 'jdk-11.0.15.1_windows-x64_bin.zip'\r\n                    await execCmd(`${wget} ${RS_URL}/${jdkZipName} -O \"${dir}/${jdkZipName}\"`);\r\n                    logger.info(`解压jdk 安装包 ${dir}/${jdkZipName}`)\r\n                    await execCmd(`\"${unzip}\" \"${dir}/${jdkZipName}\"`, dir);\r\n                    logger.info(`配置java环境变量`);\r\n                    let javaHome = `${dir}/jdk-11.0.15.1`;\r\n                    await execCmd(`setx JAVA_HOME \"${javaHome}\"`);\r\n                    await execCmd(`setx CLASS_PATH \".;%JAVA_HOME%\\lib;\"`);\r\n                    await execCmd( `setx PATH \"%PATH%;%JAVA_HOME%\\bin;\"` );\r\n                    process.env.JAVA_HOME = javaHome;\r\n                    logger.info(`java 安装完成`);\r\n                }\r\n\r\n                logger.info(`检查java版本`);\r\n                await execCmd('java -version');\r\n                // 导入证书到java 如果java是1.8版本 需要导入到 JAVA_HOME/jre/lib/security/cacerts 如果是11版本 需要导入到 JAVA_HOME/lib/security/cacerts\r\n                const javaHome = process.env.JAVA_HOME;\r\n                if (javaHome) {\r\n                    let certsFilename = 'lib/security/cacerts';\r\n                    let certsFile = `${javaHome}/${certsFilename}`;\r\n                    if (!fs.existsSync(certsFile)) {\r\n                        certsFile = `${javaHome}/jre/${certsFilename}`;\r\n                    }\r\n                    logger.info(`检查java证书目录 ${certsFile}`);\r\n                    if (fs.existsSync(certsFile)) {\r\n                        // 判断证书是否已经导入\r\n                        try {\r\n                            await execCmd(`keytool -list -v -keystore \"${certsFile}\" -storepass changeit --alias yyrd`)\r\n                            logger.info(`yyrd.crt 证书已存在`);\r\n                        } catch (e) {\r\n                            // 证书不存在\r\n                            logger.info(`导入 yyrd.crt 证书到java ${certsFile}`);\r\n                            await execCmd(`keytool -importcert -file \"${dir}/yyrd.crt\" -keystore \"${certsFile}\" -storepass changeit -noprompt`);\r\n                            logger.info(`yyrd.crt 证书导入完成`);\r\n                        }\r\n                    }\r\n                }\r\n\r\n                const mavenHome = `${dir}/maven-3.8.6`;\r\n                const mavenExists = util.cmd.exists('mvn');\r\n                logger.info(`检查是否安装了maven >> ${mavenExists ? '已安装' : '未安装'}`);\r\n                if (!mavenExists) {\r\n                    const mavenZipName = 'maven-3.8.6.zip'\r\n                    logger.info(`下载maven 安装包 ${mavenZipName}`);\r\n                    const mavenZipFile = `${dir}/${mavenZipName}`;\r\n                    // 检查是否已经存在安装包 如果有先删除\r\n                    if (fs.existsSync(mavenZipFile)) {\r\n                        logger.info(`删除已存在安装包 ${mavenZipFile}`);\r\n                        fs.rmSync(mavenZipFile);\r\n                    }\r\n                    // 下载安装包并输出日志\r\n                    await execCmd(`${wget} ${RS_URL}/${mavenZipName} -O \"${mavenZipFile}\"`);\r\n                    logger.info(`解压安装包 ${mavenZipFile}`)\r\n                    await execCmd(`\"${unzip}\" \"${mavenZipFile}\" -d \"${dir}\"`);\r\n                    fs.rmSync(mavenZipFile);\r\n\r\n                    // 添加maven 环境变量\r\n                    try {\r\n                        // Windows核心命令：永久追加路径到【用户环境变量PATH】，永久生效\r\n                        let mvnPath = path.resolve(`${mavenHome}/bin`);\r\n                        await execCmd( `setx PATH \"%PATH%;${mvnPath}\"` );\r\n                        logger.info(`✅ 成功！Maven路径【${mvnPath}】已添加到系统PATH环境变量`);\r\n                    } catch (err) {\r\n                        console.error('❌ 添加失败：', err.message);\r\n                    }\r\n\r\n                    logger.info(`maven 安装完成`);\r\n                }\r\n\r\n                logger.info(`初始化node环境`);\r\n                await execCmd('npm install -g pnpm typescript --registry=https://registry.npmmirror.com');\r\n                logger.info(`初始化node环境完成`);\r\n\r\n                logger.info(`检测code是否存在`)\r\n                const codeDir = `${dir}/yds-1.0.3`;\r\n                if (!fs.existsSync(codeDir)) {\r\n                    const codeZipName = 'yds-1.0.3-jdk-8-windows-x86_64.zip'\r\n                    logger.info(`下载code IDE 安装包 ${codeZipName}`);\r\n                    const codeZipFile = `${dir}/${codeZipName}`;\r\n                    // 检查是否已经存在安装包 如果有先删除\r\n                    if (fs.existsSync(codeZipFile)) {\r\n                        logger.info(`删除已存在安装包 ${codeZipFile}`);\r\n                        fs.rmSync(codeZipFile);\r\n                    }\r\n                    // 下载安装包并输出日志\r\n                    await execCmd(`${wget} https://yoncommunity.yonyoucloud.com/YDSDownload/Window/x64/${codeZipName} -O \"${codeZipFile}\"`);\r\n                    logger.info(`解压安装包 ${codeZipFile}`)\r\n                    fs.mkdirSync(codeDir, { recursive: true });\r\n                    await execCmd(`\"${unzip}\" \"${codeZipFile}\" -d \"${codeDir}\"`);\r\n                    fs.rmSync(codeZipFile)\r\n                    await new Promise((resolve) => setTimeout(resolve, 5000))\r\n                    logger.info(`code IDE 安装完成`);\r\n                }\r\n                logger.info(`初始化YDS IDE 全局配置`)\r\n                const settingsJson = `${codeDir}/Code/data/user-data/User/settings.json`;\r\n                let settingsJsonObj = {};\r\n                if (fs.existsSync(settingsJson)) {\r\n                    settingsJsonObj = JSON.parse(fs.readFileSync(settingsJson).toString('utf-8'));\r\n                }\r\n                let settingXml = path.resolve(`${mavenHome}/conf/settings.xml`);\r\n                if (!fs.existsSync(settingXml) && !fs.existsSync(`${dir}/settings.xml`)) {\r\n                    await execCmd(`${wget} ${RS_URL}/settings.xml`);\r\n                    settingXml = path.resolve(`${dir}/settings.xml`)\r\n                }\r\n                settingsJsonObj[\"java.configuration.maven.globalSettings\"] = settingXml;\r\n                settingsJsonObj[\"java.configuration.maven.userSettings\"] = settingXml;\r\n                settingsJsonObj[\"maven.settingsFile\"] = settingXml;\r\n                fs.writeFileSync(settingsJson, JSON.stringify(settingsJsonObj, null, 4));\r\n                logger.info(`初始化YDS IDE 全局配置完成`);\r\n\r\n                // 检查当前用户目录下.ssh是否存在 id_ed25519.pub 密钥文件，如果没有则放到.ssh 目录下\r\n                const sshDir = path.resolve(process.env.USERPROFILE, '.ssh');\r\n                if (!fs.existsSync(sshDir)) {\r\n                    fs.mkdirSync(sshDir);\r\n                }\r\n                if (!fs.existsSync(`${sshDir}/id_ed25519.pub`)) {\r\n                    logger.info(`拷贝密钥文件`);\r\n                    fs.copyFileSync(`${dir}/id_ed25519.pub`, `${sshDir}/id_ed25519.pub`);\r\n                    fs.copyFileSync(`${dir}/id_ed25519`, `${sshDir}/id_ed25519`);\r\n                    logger.info(`拷贝密钥文件完成`);\r\n                }\r\n\r\n                logger.info(`初始化YDS制盘环境完成`)\r\n            }).hook('postAction', () => process.exit(0));\r\n\r\n        program\r\n            .command('start <catalog> [workdir]')\r\n            .usage('start <catalog> [workdir]')\r\n            .option('-f, --file <file>', '配置文件')\r\n            .addHelpText('after', `\r\n配置文件内容示例：\r\n{\r\n    hosts?: Array<string>;\r\n    git: Record<'hrcpe' | 'fecode', string>;\r\n    catalogs: {\r\n        [catalog: string]: Record<'hrcpe' | 'fecode', string | { url: string, branch: string }>\r\n    }\r\n}`)\r\n            .description('启动制盘环境，catalog表示需要制盘的模块，对应配置文件中catalogs的key值，用于指定需要出盘的信息，workdir表示制盘工作目录，如果不指定则使用当前目录')\r\n            .action(async (catalog: string, workdir: string = path.resolve(process.cwd()), options: { file: string }) => {\r\n                const dir = path.resolve(workdir);\r\n\r\n                logger.info(`开始检测制盘环境检测`);\r\n                let gitCmd = 'git';\r\n                const gitExists = await util.cmd.exists(gitCmd);\r\n                if (!gitExists) {\r\n                    gitCmd = `${dir}/git-for-windows/bin/git.exe`;\r\n                    if (!fs.existsSync(gitCmd)) {\r\n                        logger.error(`未找到git命令 ${gitCmd}, 请先执行 init 初始化制盘环境`);\r\n                        process.exit(1)\r\n                    }\r\n                }\r\n\r\n                let settingXml = path.resolve(`${dir}/settings.xml`);\r\n                let mvnCmd = 'mvn';\r\n                if (!fs.existsSync(settingXml)) {\r\n                    let mavenHome = `${dir}/maven-3.8.6`;\r\n                    mvnCmd = `\"${mavenHome}/bin/mvn.cmd\"`;\r\n                    settingXml = `${mavenHome}/conf/settings.xml`;\r\n                    if (!fs.existsSync(mvnCmd)) {\r\n                        logger.error(`未找到mvn命令 ${mvnCmd}, 请先执行 init 初始化制盘环境`);\r\n                        process.exit(1)\r\n                    }\r\n                }\r\n\r\n                let idePath = `${dir}/yds-1.0.3`\r\n                if (!fs.existsSync(idePath)) {\r\n                    logger.error(`未找到IDE ${idePath}, 请先执行 init 初始化制盘环境`);\r\n                    process.exit(1)\r\n                }\r\n\r\n                logger.info(`制盘环境检测完成`)\r\n\r\n                const ydsJson = path.resolve(options.file || `${dir}/yds.json`);\r\n                logger.info(`开始制盘 ${catalog} 工作目录：${dir}`);\r\n                // 读取配置文件\r\n                if (!fs.existsSync(ydsJson)) {\r\n                    logger.error(`未找到配置文件 ${ydsJson}`);\r\n                    process.exit(1);\r\n                }\r\n                const ydsJsonStr = fs.readFileSync(ydsJson).toString('utf-8');\r\n                // 检测配置文件是否完整\r\n                let config: YdsConfig;\r\n                const checkConfigError = () => {\r\n                    logger.error(`配置文件 ${ydsJson} 格式错误 参考示例：\r\n{\r\n    hosts?: Array<string>;\r\n    git: Record<'hrcpe' | 'fecode', string>;\r\n    catalogs: {\r\n        [catalog: string]: Record<'hrcpe' | 'fecode', string | { url: string, branch: string }>\r\n    }\r\n}`);\r\n                    process.exit(1);\r\n                }\r\n                try {\r\n                    config = JSON.parse(ydsJsonStr);\r\n                    if (!config.catalogs) {\r\n                        checkConfigError()\r\n                    }\r\n                } catch (e) {\r\n                    checkConfigError()\r\n                }\r\n                const git = config.git;\r\n                const catalogConfig = config.catalogs[catalog];\r\n                if (typeof catalogConfig === 'undefined') {\r\n                    logger.error(`配置文件 ${ydsJson} 找不到 catalogs.${catalog} 先关配置`);\r\n                    process.exit(1);\r\n                }\r\n                if (typeof catalogConfig.hrcpe === 'undefined' || typeof catalogConfig.fecode === 'undefined') {\r\n                    logger.error(`配置文件 ${ydsJson} catalogs.${catalog}.hrcpe 或 catalogs.${catalog}.fecode 字段缺失`);\r\n                    process.exit(1);\r\n                }\r\n\r\n                const namespace = `${dir}/${catalog}`;\r\n                if (!fs.existsSync(namespace)) {\r\n                    logger.info(`创建目录 ${namespace}`);\r\n                    fs.mkdirSync(namespace);\r\n                } else {\r\n                    logger.info(`目录 ${namespace} 已存在`);\r\n                }\r\n                let hrcpeUrl = typeof catalogConfig.hrcpe === 'string' ? git?.hrcpe : catalogConfig.hrcpe.url;\r\n                if (!hrcpeUrl) {\r\n                    logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 后端服务 未指定仓库地址，请通过 git.hrcpe 或者 catalogs.${catalog}.hrcpe.url 指定仓库地址`);\r\n                }\r\n                logger.info(`开始拉取后端服务仓库 ${hrcpeUrl}`);\r\n                if (fs.existsSync(`${namespace}/.git`)) {\r\n                    logger.info(`目录 ${namespace} 已存在，开始更新仓库`);\r\n                    await execCmd(`\"${gitCmd}\" pull`, namespace);\r\n                } else {\r\n                    logger.info(`目录 ${namespace} 不存在，开始创建仓库`);\r\n                    let branch = typeof catalogConfig.hrcpe === 'string' ? catalogConfig.hrcpe : catalogConfig.hrcpe.branch;\r\n                    if (!branch) {\r\n                        logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 后端服务 未指定分支，请通过 git.hrcpe 或者 catalogs.${catalog}.hrcpe.branch 配置分支`);\r\n                        process.exit(1);\r\n                    }\r\n                    await execCmd(`\"${gitCmd}\" clone -b ${branch} ${hrcpeUrl} ${namespace}`, namespace);\r\n                }\r\n                logger.info(`拉取后端服务仓库完成`);\r\n                let boostrapPomXml = `${namespace}/${domainKey}-be/dev-${domainKey}-bootstrap/pom.xml`;\r\n                logger.info(`替换文件 ${boostrapPomXml} 中的ROOT为domainKey，否则会导致制盘失败，无法找到制品`);\r\n                const boostrapPomXmlString = fs.readFileSync(boostrapPomXml).toString('utf-8');\r\n                if (boostrapPomXmlString.includes('ROOT')) {\r\n                    fs.writeFileSync(boostrapPomXml, boostrapPomXmlString.replace(/ROOT/g, domainKey));\r\n                }\r\n\r\n                if (config.hosts && config.hosts.length) {\r\n                    logger.info(`存在hosts配置，检测系统hosts配置文件是否已经配置`);\r\n                    let hostsFile = path.resolve(process.env.WINDIR, 'System32', 'drivers', 'etc', 'hosts');\r\n                    const hostList = fs.readFileSync(hostsFile).toString('utf-8').split('\\n');\r\n                    let appendHosts = [...config.hosts]\r\n                    for (let hostItem of hostList) {\r\n                        if (/#/.test(hostItem)) {\r\n                            continue;\r\n                        }\r\n                        for (let appendHost of config.hosts) {\r\n                            const [ip, domain] = appendHost.split(' ').filter(item => item)\r\n                            if (hostItem.includes(ip) && hostItem.includes(domain)) {\r\n                                logger.info(`系统hosts配置文件已存在 ${appendHost}`);\r\n                                appendHosts.remove(appendHost);\r\n                            }\r\n                        }\r\n                    }\r\n                    // 读取系统hosts配置文件\r\n                    if (appendHosts.length) {\r\n                        if (isAdmin()) {\r\n                            fs.appendFileSync(hostsFile, `\\n${appendHosts.join('\\n')}\\n`, {\r\n                                encoding: 'utf-8'\r\n                            })\r\n                        } else {\r\n                            logger.error(`当前非管理员启动无法更改hosts文件，请使用管理员启动或者手动添加 ${appendHosts.join('\\n')} 到文件 ${hostsFile}`);\r\n                        }\r\n                    }\r\n                    logger.info(`hosts 配置检测完成`);\r\n                }\r\n\r\n                logger.info('初始化项目maven环境');\r\n                let mvnConfigDir = `${namespace}/.mvn`;\r\n                if (!fs.existsSync(mvnConfigDir)) {\r\n                    await execCmd(`${mvnCmd} -N io.takari:maven:wrapper -Dmaven=3.8.6`, namespace);\r\n                }\r\n                // 写入maven配置到 .mvn/maven.config\r\n                let configFile = `${mvnConfigDir}/maven.config`;\r\n                if (fs.existsSync(configFile)) {\r\n                    fs.rmSync(configFile)\r\n                }\r\n                fs.writeFileSync(`${mvnConfigDir}/maven.config`, `-s\\n${settingXml}\\n-Dmaven.wagon.http.ssl.insecure=true\\n-Dmaven.wagon.http.ssl.allowall=true`);\r\n                logger.info(`当前maven信息`)\r\n                await execCmd(`${mvnCmd} --version`, namespace);\r\n\r\n                logger.info('项目maven清理')\r\n                await execCmd(`${mvnCmd} clean -DskipTests`, `${namespace}/${domainKey}-be`);\r\n\r\n                logger.info('处理前端构建，增加构建文件');\r\n                let feDir = `${namespace}/${domainKey}-fe`;\r\n                let feBuildJs = `${feDir}/build.js`;\r\n                if (!fs.existsSync(feBuildJs)) {\r\n                    fs.cpSync(`${dir}/fe-build.js`, feBuildJs);\r\n                }\r\n                let fePackageJson = `${feDir}/package.json`;\r\n                const packageString = fs.readFileSync(fePackageJson).toString('utf-8');\r\n                if (!packageString.includes('build.js')) {\r\n                    logger.info(`修改${fePackageJson}`);\r\n                    const packageJson = JSON.parse(packageString);\r\n                    packageJson.scripts['build:extend'] += ' && node build.js';\r\n                    fs.writeFileSync(fePackageJson, JSON.stringify(packageJson, null, 4));\r\n                    logger.info(`修改${fePackageJson}完成`);\r\n                }\r\n\r\n\r\n                let fecodeUrl = typeof catalogConfig.fecode === 'string' ? git?.fecode : catalogConfig.fecode.url;\r\n                if (!fecodeUrl) {\r\n                    logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 后端服务 未指定仓库地址，请通过 git.fecode 或者 catalogs.${catalog}.fecode.url 指定仓库地址`);\r\n                }\r\n                logger.info(`开始拉取报告服务仓库 ${fecodeUrl}`);\r\n                let reportNamespace = `${namespace}/yonbip-yisv-izp1-dev-fecode`;\r\n                if (fs.existsSync(`${reportNamespace}/.git`)) {\r\n                    logger.info(`目录 ${reportNamespace} 已存在，开始更新仓库`);\r\n                    await execCmd(`\"${gitCmd}\" pull`, reportNamespace);\r\n                } else {\r\n                    logger.info(`目录 ${reportNamespace} 不存在，开始创建仓库`);\r\n                    let branch = typeof catalogConfig.fecode === 'string' ? catalogConfig.fecode : catalogConfig.fecode.branch;\r\n                    if (!branch) {\r\n                        logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 报告服务未指定分支，请通过 git.fecode 或者 catalogs.${catalog}.fecode.branch 配置分支`);\r\n                        process.exit(1);\r\n                    }\r\n                    await execCmd(`\"${gitCmd}\" clone -b ${branch} ${fecodeUrl} ${reportNamespace}`);\r\n                }\r\n                logger.info(`拉取报告服务仓库完成`);\r\n\r\n                logger.info('处理报告构建，增加构建文件');\r\n                let fecodeBuildJs = `${reportNamespace}/build.js`;\r\n                if (!fs.existsSync(fecodeBuildJs)) {\r\n                    fs.cpSync(`${dir}/fecode-build.js`, fecodeBuildJs);\r\n                }\r\n                let fecodePackageJson = `${reportNamespace}/package.json`;\r\n                const fecodePackageString = fs.readFileSync(fecodePackageJson).toString('utf-8');\r\n                if (!fecodePackageString.includes('build.js')) {\r\n                    logger.info(`修改${fecodePackageJson}`);\r\n                    const packageJson = JSON.parse(fecodePackageString);\r\n                    packageJson.scripts['build'] += ' && node build.js';\r\n                    packageJson.domainKey = domainKey;\r\n                    // 删除此依赖 会导致npm i 失败\r\n                    delete packageJson.dependencies.zlib\r\n                    fs.writeFileSync(fecodePackageJson, JSON.stringify(packageJson, null, 4));\r\n                    logger.info(`修改${fecodePackageJson}完成`);\r\n                }\r\n\r\n                logger.info(`安装报告服务依赖`);\r\n                await execCmd('npm i', reportNamespace);\r\n\r\n                logger.info(`生成version.json 文件`)\r\n                const uuid = randomUUID().toString()\r\n                fs.writeFileSync(`${reportNamespace}/version.json`, `{\"version\": \"${uuid}\"}`);\r\n\r\n                logger.info('初始化项目环境资源');\r\n                // 如果 namespace/(disk|disks) 如果存在 跳过\r\n                if (fs.existsSync(`${namespace}/disk`) || fs.existsSync(`${namespace}/disks`)) {\r\n                    logger.info(`已存在，跳过环境资源文件下载`);\r\n                } else {\r\n                    // https://dfs.zhiper.com/v3r6/env.zip\r\n                    logger.info(`开始下载项目环境资源文件`)\r\n                    let gitZipFile = `${namespace}/env.zip`;\r\n                    await execCmd(`${wget} ${RS_URL}/env.zip -O \"${gitZipFile}\"`);\r\n\r\n                    logger.info(`解压资源文件包 ${gitZipFile}`)\r\n                    await execCmd(`\"${unzip}\" \"${gitZipFile}\"`, namespace);\r\n                    fs.rmSync(gitZipFile)\r\n                }\r\n\r\n                logger.info('启动IDE');\r\n                await execCmd(`\"${idePath}/Code/Code.exe\" \"${namespace}\"`);\r\n                // 需要等待IDE启动完成后关闭\r\n                await new Promise(resolve => setTimeout(resolve, 3000))\r\n                logger.info('已启动IDE，请按照文档说明进行制盘操作')\r\n            }).hook('postAction', () => process.exit(0))\r\n\r\n        program.parse(process.argv)\r\n    }\r\n}\r\n"]}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "yds-tool",
+  "version": "0.0.1",
+  "description": "isv本地制盘工具",
+  "main": "./bin/index.js",
+  "bin": {
+    "yds": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "src"
+  ],
+  "keywords": [
+    "yds"
+  ],
+  "scripts": {
+    "init": "tsc -p tsconfig.json&node bin/app.js init",
+    "start": "tsc -p tsconfig.json&node bin/app.js start geer"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@codeup.aliyun.com:6166f78958608c6ab5d8d66d/isv/create-disk.git"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/cli": "^7.16.0",
+    "@babel/core": "^7.16.5",
+    "@babel/plugin-proposal-decorators": "^7.16.5",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-transform-runtime": "^7.16.5",
+    "@babel/preset-env": "^7.16.5",
+    "@babel/register": "^7.16.5",
+    "@babel/runtime": "^7.16.5",
+    "@types/node": "^20.1.3",
+    "babel-plugin-transform-decorators-legacy": "^1.3.5",
+    "commander": "^14.0.2",
+    "sqlite3": "^5.1.7",
+    "vweb-core": "^3.2.3"
+  }
+}

package/readme.md

@@ -0,0 +1,24 @@
+# YDS制盘工具
+
+> 支持ISV V3R6出盘
+
+## 本地开发
+
+```shell
+npm run init
+npm run start
+```
+
+## 本地安装调试
+
+```shell
+# 查看全局安装的包
+
+npm list -g --depth 0
+
+# 临时安装 退出时候务必卸载 否则会污染全局环境
+npm link
+
+# 卸载
+npm uninstall -g yds-tool
+```

package/src/main.ts

@@ -0,0 +1,479 @@
+import {program} from "commander";
+import * as process from "process";
+import {LoggerFactory, util} from "vweb-core";
+import * as path from "node:path";
+import * as child_process from "node:child_process";
+import * as fs from "node:fs";
+import * as os from 'node:os';
+import {randomUUID} from 'crypto'
+
+const domainKey = 'p-hcc-i000-p00a-hrcpe';
+const pkg = require('../package.json');
+const RS_URL = 'https://dfs.zhiper.com/v3r6';
+
+const logger: Logger = LoggerFactory.getLogger('YDS');
+
+const execCmd = async (command: string, cwd?: string) => {
+    logger.info(`执行命令 ${command} ${cwd ? `，执行目录为${cwd}` :''}`);
+    let start  = Date.now();
+    child_process.execSync(command, {
+        cwd, encoding: 'utf-8',
+        timeout: 60000,
+        stdio: [0, 1, 2]
+    });
+    logger.info(`执行命令 ${command} 耗时 \x1B[34m <${Date.now() - start}ms>]`)
+}
+
+const platform = os.platform()
+if (platform !== 'win32') {
+    logger.error('当前工具仅支持windows系统');
+    process.exit(1);
+}
+
+const isAdmin = () => {
+    try {
+        // 尝试执行一个只有管理员才能运行的命令
+        // 使用 >nul 2>&1 来抑制输出
+        child_process.execSync('net session >nul 2>&1');
+        return true; // 成功执行
+    } catch (err) {
+        return false; // 执行失败，权限不足
+    }
+}
+
+let wget = path.resolve( 'wget.exe');
+let zip = path.resolve('zip.exe');
+let unzip = path.resolve('unzip.exe');
+
+program.name("yds")
+    .usage("[command] [options]")
+    .description("yds 制盘工具 如果命令参数中存在空格 使用双引号\"\"包裹")
+    .version(`yds ${pkg.version}`);
+
+type MicroService = 'hrcpe' | 'fecode';
+
+type Git = {
+    url: string,
+    branch: string
+}
+
+type YdsConfig = {
+    hosts: Array<string>;
+    git: Record<MicroService, string>;
+    catalogs: {
+        [catalog: string]: Record<MicroService, string | Git>
+    }
+}
+
+export default class Main {
+
+    startup() {
+        program
+            .command('init [workdir]')
+            .usage('init [workdir]')
+            .description('初始化YDS制盘环境, workdir表示制盘工作目录，如果不指定则使用当前目录')
+            .action(async (workdir: string = path.resolve(process.cwd())) => {
+                const dir = path.resolve(workdir);
+                logger.info(`初始化YDS制盘环境 工作目录：${dir}`);
+                const gitExists = await util.cmd.exists('git');
+                logger.info(`检查是否安装了git >> ${gitExists ? '已安装' : '未安装'}`);
+                if (!gitExists && !fs.existsSync(`${dir}/git-for-windows`)) {
+                    const gitZipName = 'git-for-windows.zip'
+                    logger.info(`下载git 安装包 ${gitZipName}`);
+                    const gitZipFile = `${dir}/${gitZipName}`;
+                    // 检查是否已经存在安装包 如果有先删除
+                    if (fs.existsSync(gitZipFile)) {
+                        logger.info(`删除已存在安装包 ${gitZipFile}`);
+                        fs.rmSync(gitZipFile);
+                    }
+                    // 下载安装包并输出日志
+                    await execCmd(`${wget} ${RS_URL}/${gitZipName} -O "${gitZipFile}"`);
+                    logger.info(`解压安装包 ${gitZipFile}`)
+                    await execCmd(`"${unzip}" "${gitZipFile}" -d "${dir}"`);
+                    fs.rmSync(gitZipFile)
+                    logger.info(`git 安装完成`);
+                }
+
+                const javaExists = await util.cmd.exists('java');
+                logger.info(`检查是否安装了java >> ${javaExists ? '已安装' : '未安装'}`);
+                if (!javaExists) {
+                    logger.info('未找到java，准备安装java，开始下载jdk');
+                    const jdkZipName = 'jdk-11.0.15.1_windows-x64_bin.zip'
+                    await execCmd(`${wget} ${RS_URL}/${jdkZipName} -O "${dir}/${jdkZipName}"`);
+                    logger.info(`解压jdk 安装包 ${dir}/${jdkZipName}`)
+                    await execCmd(`"${unzip}" "${dir}/${jdkZipName}"`, dir);
+                    logger.info(`配置java环境变量`);
+                    let javaHome = `${dir}/jdk-11.0.15.1`;
+                    await execCmd(`setx JAVA_HOME "${javaHome}"`);
+                    await execCmd(`setx CLASS_PATH ".;%JAVA_HOME%\lib;"`);
+                    await execCmd( `setx PATH "%PATH%;%JAVA_HOME%\bin;"` );
+                    process.env.JAVA_HOME = javaHome;
+                    logger.info(`java 安装完成`);
+                }
+
+                logger.info(`检查java版本`);
+                await execCmd('java -version');
+                // 导入证书到java 如果java是1.8版本 需要导入到 JAVA_HOME/jre/lib/security/cacerts 如果是11版本 需要导入到 JAVA_HOME/lib/security/cacerts
+                const javaHome = process.env.JAVA_HOME;
+                if (javaHome) {
+                    let certsFilename = 'lib/security/cacerts';
+                    let certsFile = `${javaHome}/${certsFilename}`;
+                    if (!fs.existsSync(certsFile)) {
+                        certsFile = `${javaHome}/jre/${certsFilename}`;
+                    }
+                    logger.info(`检查java证书目录 ${certsFile}`);
+                    if (fs.existsSync(certsFile)) {
+                        // 判断证书是否已经导入
+                        try {
+                            await execCmd(`keytool -list -v -keystore "${certsFile}" -storepass changeit --alias yyrd`)
+                            logger.info(`yyrd.crt 证书已存在`);
+                        } catch (e) {
+                            // 证书不存在
+                            logger.info(`导入 yyrd.crt 证书到java ${certsFile}`);
+                            await execCmd(`keytool -importcert -file "${dir}/yyrd.crt" -keystore "${certsFile}" -storepass changeit -noprompt`);
+                            logger.info(`yyrd.crt 证书导入完成`);
+                        }
+                    }
+                }
+
+                const mavenHome = `${dir}/maven-3.8.6`;
+                const mavenExists = util.cmd.exists('mvn');
+                logger.info(`检查是否安装了maven >> ${mavenExists ? '已安装' : '未安装'}`);
+                if (!mavenExists) {
+                    const mavenZipName = 'maven-3.8.6.zip'
+                    logger.info(`下载maven 安装包 ${mavenZipName}`);
+                    const mavenZipFile = `${dir}/${mavenZipName}`;
+                    // 检查是否已经存在安装包 如果有先删除
+                    if (fs.existsSync(mavenZipFile)) {
+                        logger.info(`删除已存在安装包 ${mavenZipFile}`);
+                        fs.rmSync(mavenZipFile);
+                    }
+                    // 下载安装包并输出日志
+                    await execCmd(`${wget} ${RS_URL}/${mavenZipName} -O "${mavenZipFile}"`);
+                    logger.info(`解压安装包 ${mavenZipFile}`)
+                    await execCmd(`"${unzip}" "${mavenZipFile}" -d "${dir}"`);
+                    fs.rmSync(mavenZipFile);
+
+                    // 添加maven 环境变量
+                    try {
+                        // Windows核心命令：永久追加路径到【用户环境变量PATH】，永久生效
+                        let mvnPath = path.resolve(`${mavenHome}/bin`);
+                        await execCmd( `setx PATH "%PATH%;${mvnPath}"` );
+                        logger.info(`✅ 成功！Maven路径【${mvnPath}】已添加到系统PATH环境变量`);
+                    } catch (err) {
+                        console.error('❌ 添加失败：', err.message);
+                    }
+
+                    logger.info(`maven 安装完成`);
+                }
+
+                logger.info(`初始化node环境`);
+                await execCmd('npm install -g pnpm typescript --registry=https://registry.npmmirror.com');
+                logger.info(`初始化node环境完成`);
+
+                logger.info(`检测code是否存在`)
+                const codeDir = `${dir}/yds-1.0.3`;
+                if (!fs.existsSync(codeDir)) {
+                    const codeZipName = 'yds-1.0.3-jdk-8-windows-x86_64.zip'
+                    logger.info(`下载code IDE 安装包 ${codeZipName}`);
+                    const codeZipFile = `${dir}/${codeZipName}`;
+                    // 检查是否已经存在安装包 如果有先删除
+                    if (fs.existsSync(codeZipFile)) {
+                        logger.info(`删除已存在安装包 ${codeZipFile}`);
+                        fs.rmSync(codeZipFile);
+                    }
+                    // 下载安装包并输出日志
+                    await execCmd(`${wget} https://yoncommunity.yonyoucloud.com/YDSDownload/Window/x64/${codeZipName} -O "${codeZipFile}"`);
+                    logger.info(`解压安装包 ${codeZipFile}`)
+                    fs.mkdirSync(codeDir, { recursive: true });
+                    await execCmd(`"${unzip}" "${codeZipFile}" -d "${codeDir}"`);
+                    fs.rmSync(codeZipFile)
+                    await new Promise((resolve) => setTimeout(resolve, 5000))
+                    logger.info(`code IDE 安装完成`);
+                }
+                logger.info(`初始化YDS IDE 全局配置`)
+                const settingsJson = `${codeDir}/Code/data/user-data/User/settings.json`;
+                let settingsJsonObj = {};
+                if (fs.existsSync(settingsJson)) {
+                    settingsJsonObj = JSON.parse(fs.readFileSync(settingsJson).toString('utf-8'));
+                }
+                let settingXml = path.resolve(`${mavenHome}/conf/settings.xml`);
+                if (!fs.existsSync(settingXml) && !fs.existsSync(`${dir}/settings.xml`)) {
+                    await execCmd(`${wget} ${RS_URL}/settings.xml`);
+                    settingXml = path.resolve(`${dir}/settings.xml`)
+                }
+                settingsJsonObj["java.configuration.maven.globalSettings"] = settingXml;
+                settingsJsonObj["java.configuration.maven.userSettings"] = settingXml;
+                settingsJsonObj["maven.settingsFile"] = settingXml;
+                fs.writeFileSync(settingsJson, JSON.stringify(settingsJsonObj, null, 4));
+                logger.info(`初始化YDS IDE 全局配置完成`);
+
+                // 检查当前用户目录下.ssh是否存在 id_ed25519.pub 密钥文件，如果没有则放到.ssh 目录下
+                const sshDir = path.resolve(process.env.USERPROFILE, '.ssh');
+                if (!fs.existsSync(sshDir)) {
+                    fs.mkdirSync(sshDir);
+                }
+                if (!fs.existsSync(`${sshDir}/id_ed25519.pub`)) {
+                    logger.info(`拷贝密钥文件`);
+                    fs.copyFileSync(`${dir}/id_ed25519.pub`, `${sshDir}/id_ed25519.pub`);
+                    fs.copyFileSync(`${dir}/id_ed25519`, `${sshDir}/id_ed25519`);
+                    logger.info(`拷贝密钥文件完成`);
+                }
+
+                logger.info(`初始化YDS制盘环境完成`)
+            }).hook('postAction', () => process.exit(0));
+
+        program
+            .command('start <catalog> [workdir]')
+            .usage('start <catalog> [workdir]')
+            .option('-f, --file <file>', '配置文件')
+            .addHelpText('after', `
+配置文件内容示例：
+{
+    hosts?: Array<string>;
+    git: Record<'hrcpe' | 'fecode', string>;
+    catalogs: {
+        [catalog: string]: Record<'hrcpe' | 'fecode', string | { url: string, branch: string }>
+    }
+}`)
+            .description('启动制盘环境，catalog表示需要制盘的模块，对应配置文件中catalogs的key值，用于指定需要出盘的信息，workdir表示制盘工作目录，如果不指定则使用当前目录')
+            .action(async (catalog: string, workdir: string = path.resolve(process.cwd()), options: { file: string }) => {
+                const dir = path.resolve(workdir);
+
+                logger.info(`开始检测制盘环境检测`);
+                let gitCmd = 'git';
+                const gitExists = await util.cmd.exists(gitCmd);
+                if (!gitExists) {
+                    gitCmd = `${dir}/git-for-windows/bin/git.exe`;
+                    if (!fs.existsSync(gitCmd)) {
+                        logger.error(`未找到git命令 ${gitCmd}, 请先执行 init 初始化制盘环境`);
+                        process.exit(1)
+                    }
+                }
+
+                let settingXml = path.resolve(`${dir}/settings.xml`);
+                let mvnCmd = 'mvn';
+                if (!fs.existsSync(settingXml)) {
+                    let mavenHome = `${dir}/maven-3.8.6`;
+                    mvnCmd = `"${mavenHome}/bin/mvn.cmd"`;
+                    settingXml = `${mavenHome}/conf/settings.xml`;
+                    if (!fs.existsSync(mvnCmd)) {
+                        logger.error(`未找到mvn命令 ${mvnCmd}, 请先执行 init 初始化制盘环境`);
+                        process.exit(1)
+                    }
+                }
+
+                let idePath = `${dir}/yds-1.0.3`
+                if (!fs.existsSync(idePath)) {
+                    logger.error(`未找到IDE ${idePath}, 请先执行 init 初始化制盘环境`);
+                    process.exit(1)
+                }
+
+                logger.info(`制盘环境检测完成`)
+
+                const ydsJson = path.resolve(options.file || `${dir}/yds.json`);
+                logger.info(`开始制盘 ${catalog} 工作目录：${dir}`);
+                // 读取配置文件
+                if (!fs.existsSync(ydsJson)) {
+                    logger.error(`未找到配置文件 ${ydsJson}`);
+                    process.exit(1);
+                }
+                const ydsJsonStr = fs.readFileSync(ydsJson).toString('utf-8');
+                // 检测配置文件是否完整
+                let config: YdsConfig;
+                const checkConfigError = () => {
+                    logger.error(`配置文件 ${ydsJson} 格式错误 参考示例：
+{
+    hosts?: Array<string>;
+    git: Record<'hrcpe' | 'fecode', string>;
+    catalogs: {
+        [catalog: string]: Record<'hrcpe' | 'fecode', string | { url: string, branch: string }>
+    }
+}`);
+                    process.exit(1);
+                }
+                try {
+                    config = JSON.parse(ydsJsonStr);
+                    if (!config.catalogs) {
+                        checkConfigError()
+                    }
+                } catch (e) {
+                    checkConfigError()
+                }
+                const git = config.git;
+                const catalogConfig = config.catalogs[catalog];
+                if (typeof catalogConfig === 'undefined') {
+                    logger.error(`配置文件 ${ydsJson} 找不到 catalogs.${catalog} 先关配置`);
+                    process.exit(1);
+                }
+                if (typeof catalogConfig.hrcpe === 'undefined' || typeof catalogConfig.fecode === 'undefined') {
+                    logger.error(`配置文件 ${ydsJson} catalogs.${catalog}.hrcpe 或 catalogs.${catalog}.fecode 字段缺失`);
+                    process.exit(1);
+                }
+
+                const namespace = `${dir}/${catalog}`;
+                if (!fs.existsSync(namespace)) {
+                    logger.info(`创建目录 ${namespace}`);
+                    fs.mkdirSync(namespace);
+                } else {
+                    logger.info(`目录 ${namespace} 已存在`);
+                }
+                let hrcpeUrl = typeof catalogConfig.hrcpe === 'string' ? git?.hrcpe : catalogConfig.hrcpe.url;
+                if (!hrcpeUrl) {
+                    logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 后端服务 未指定仓库地址，请通过 git.hrcpe 或者 catalogs.${catalog}.hrcpe.url 指定仓库地址`);
+                }
+                logger.info(`开始拉取后端服务仓库 ${hrcpeUrl}`);
+                if (fs.existsSync(`${namespace}/.git`)) {
+                    logger.info(`目录 ${namespace} 已存在，开始更新仓库`);
+                    await execCmd(`"${gitCmd}" pull`, namespace);
+                } else {
+                    logger.info(`目录 ${namespace} 不存在，开始创建仓库`);
+                    let branch = typeof catalogConfig.hrcpe === 'string' ? catalogConfig.hrcpe : catalogConfig.hrcpe.branch;
+                    if (!branch) {
+                        logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 后端服务 未指定分支，请通过 git.hrcpe 或者 catalogs.${catalog}.hrcpe.branch 配置分支`);
+                        process.exit(1);
+                    }
+                    await execCmd(`"${gitCmd}" clone -b ${branch} ${hrcpeUrl} ${namespace}`, namespace);
+                }
+                logger.info(`拉取后端服务仓库完成`);
+                let boostrapPomXml = `${namespace}/${domainKey}-be/dev-${domainKey}-bootstrap/pom.xml`;
+                logger.info(`替换文件 ${boostrapPomXml} 中的ROOT为domainKey，否则会导致制盘失败，无法找到制品`);
+                const boostrapPomXmlString = fs.readFileSync(boostrapPomXml).toString('utf-8');
+                if (boostrapPomXmlString.includes('ROOT')) {
+                    fs.writeFileSync(boostrapPomXml, boostrapPomXmlString.replace(/ROOT/g, domainKey));
+                }
+
+                if (config.hosts && config.hosts.length) {
+                    logger.info(`存在hosts配置，检测系统hosts配置文件是否已经配置`);
+                    let hostsFile = path.resolve(process.env.WINDIR, 'System32', 'drivers', 'etc', 'hosts');
+                    const hostList = fs.readFileSync(hostsFile).toString('utf-8').split('\n');
+                    let appendHosts = [...config.hosts]
+                    for (let hostItem of hostList) {
+                        if (/#/.test(hostItem)) {
+                            continue;
+                        }
+                        for (let appendHost of config.hosts) {
+                            const [ip, domain] = appendHost.split(' ').filter(item => item)
+                            if (hostItem.includes(ip) && hostItem.includes(domain)) {
+                                logger.info(`系统hosts配置文件已存在 ${appendHost}`);
+                                appendHosts.remove(appendHost);
+                            }
+                        }
+                    }
+                    // 读取系统hosts配置文件
+                    if (appendHosts.length) {
+                        if (isAdmin()) {
+                            fs.appendFileSync(hostsFile, `\n${appendHosts.join('\n')}\n`, {
+                                encoding: 'utf-8'
+                            })
+                        } else {
+                            logger.error(`当前非管理员启动无法更改hosts文件，请使用管理员启动或者手动添加 ${appendHosts.join('\n')} 到文件 ${hostsFile}`);
+                        }
+                    }
+                    logger.info(`hosts 配置检测完成`);
+                }
+
+                logger.info('初始化项目maven环境');
+                let mvnConfigDir = `${namespace}/.mvn`;
+                if (!fs.existsSync(mvnConfigDir)) {
+                    await execCmd(`${mvnCmd} -N io.takari:maven:wrapper -Dmaven=3.8.6`, namespace);
+                }
+                // 写入maven配置到 .mvn/maven.config
+                let configFile = `${mvnConfigDir}/maven.config`;
+                if (fs.existsSync(configFile)) {
+                    fs.rmSync(configFile)
+                }
+                fs.writeFileSync(`${mvnConfigDir}/maven.config`, `-s\n${settingXml}\n-Dmaven.wagon.http.ssl.insecure=true\n-Dmaven.wagon.http.ssl.allowall=true`);
+                logger.info(`当前maven信息`)
+                await execCmd(`${mvnCmd} --version`, namespace);
+
+                logger.info('项目maven清理')
+                await execCmd(`${mvnCmd} clean -DskipTests`, `${namespace}/${domainKey}-be`);
+
+                logger.info('处理前端构建，增加构建文件');
+                let feDir = `${namespace}/${domainKey}-fe`;
+                let feBuildJs = `${feDir}/build.js`;
+                if (!fs.existsSync(feBuildJs)) {
+                    fs.cpSync(`${dir}/fe-build.js`, feBuildJs);
+                }
+                let fePackageJson = `${feDir}/package.json`;
+                const packageString = fs.readFileSync(fePackageJson).toString('utf-8');
+                if (!packageString.includes('build.js')) {
+                    logger.info(`修改${fePackageJson}`);
+                    const packageJson = JSON.parse(packageString);
+                    packageJson.scripts['build:extend'] += ' && node build.js';
+                    fs.writeFileSync(fePackageJson, JSON.stringify(packageJson, null, 4));
+                    logger.info(`修改${fePackageJson}完成`);
+                }
+
+
+                let fecodeUrl = typeof catalogConfig.fecode === 'string' ? git?.fecode : catalogConfig.fecode.url;
+                if (!fecodeUrl) {
+                    logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 后端服务 未指定仓库地址，请通过 git.fecode 或者 catalogs.${catalog}.fecode.url 指定仓库地址`);
+                }
+                logger.info(`开始拉取报告服务仓库 ${fecodeUrl}`);
+                let reportNamespace = `${namespace}/yonbip-yisv-izp1-dev-fecode`;
+                if (fs.existsSync(`${reportNamespace}/.git`)) {
+                    logger.info(`目录 ${reportNamespace} 已存在，开始更新仓库`);
+                    await execCmd(`"${gitCmd}" pull`, reportNamespace);
+                } else {
+                    logger.info(`目录 ${reportNamespace} 不存在，开始创建仓库`);
+                    let branch = typeof catalogConfig.fecode === 'string' ? catalogConfig.fecode : catalogConfig.fecode.branch;
+                    if (!branch) {
+                        logger.error(`配置文件 ${ydsJson} catalogs.${catalog} 报告服务未指定分支，请通过 git.fecode 或者 catalogs.${catalog}.fecode.branch 配置分支`);
+                        process.exit(1);
+                    }
+                    await execCmd(`"${gitCmd}" clone -b ${branch} ${fecodeUrl} ${reportNamespace}`);
+                }
+                logger.info(`拉取报告服务仓库完成`);
+
+                logger.info('处理报告构建，增加构建文件');
+                let fecodeBuildJs = `${reportNamespace}/build.js`;
+                if (!fs.existsSync(fecodeBuildJs)) {
+                    fs.cpSync(`${dir}/fecode-build.js`, fecodeBuildJs);
+                }
+                let fecodePackageJson = `${reportNamespace}/package.json`;
+                const fecodePackageString = fs.readFileSync(fecodePackageJson).toString('utf-8');
+                if (!fecodePackageString.includes('build.js')) {
+                    logger.info(`修改${fecodePackageJson}`);
+                    const packageJson = JSON.parse(fecodePackageString);
+                    packageJson.scripts['build'] += ' && node build.js';
+                    packageJson.domainKey = domainKey;
+                    // 删除此依赖 会导致npm i 失败
+                    delete packageJson.dependencies.zlib
+                    fs.writeFileSync(fecodePackageJson, JSON.stringify(packageJson, null, 4));
+                    logger.info(`修改${fecodePackageJson}完成`);
+                }
+
+                logger.info(`安装报告服务依赖`);
+                await execCmd('npm i', reportNamespace);
+
+                logger.info(`生成version.json 文件`)
+                const uuid = randomUUID().toString()
+                fs.writeFileSync(`${reportNamespace}/version.json`, `{"version": "${uuid}"}`);
+
+                logger.info('初始化项目环境资源');
+                // 如果 namespace/(disk|disks) 如果存在 跳过
+                if (fs.existsSync(`${namespace}/disk`) || fs.existsSync(`${namespace}/disks`)) {
+                    logger.info(`已存在，跳过环境资源文件下载`);
+                } else {
+                    // https://dfs.zhiper.com/v3r6/env.zip
+                    logger.info(`开始下载项目环境资源文件`)
+                    let gitZipFile = `${namespace}/env.zip`;
+                    await execCmd(`${wget} ${RS_URL}/env.zip -O "${gitZipFile}"`);
+
+                    logger.info(`解压资源文件包 ${gitZipFile}`)
+                    await execCmd(`"${unzip}" "${gitZipFile}"`, namespace);
+                    fs.rmSync(gitZipFile)
+                }
+
+                logger.info('启动IDE');
+                await execCmd(`"${idePath}/Code/Code.exe" "${namespace}"`);
+                // 需要等待IDE启动完成后关闭
+                await new Promise(resolve => setTimeout(resolve, 3000))
+                logger.info('已启动IDE，请按照文档说明进行制盘操作')
+            }).hook('postAction', () => process.exit(0))
+
+        program.parse(process.argv)
+    }
+}