@spaceflow/publish 0.21.1

package/dist/index.js

@@ -0,0 +1,1160 @@
+import * as __rspack_external_fs from "fs";
+import * as __rspack_external_release_it_4c635798 from "release-it";
+import { ConfigReaderModule, ConfigReaderService, GitProviderModule, GitProviderService, addLocaleResources, ciConfig, t as core_t, z } from "@spaceflow/core";
+import { Injectable, Module } from "@nestjs/common";
+import { ConfigModule, ConfigService } from "@nestjs/config";
+import { Command, CommandRunner, Option } from "nest-commander";
+import { execSync } from "child_process";
+import { join } from "path";
+var __webpack_modules__ = ({
+421(module) {
+
+module.exports = __rspack_external_fs;
+
+
+},
+547(module) {
+
+module.exports = __rspack_external_release_it_4c635798;
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  Vy: () => (/* reexport */ MonorepoService),
+  Ay: () => (/* binding */ src),
+  D5: () => (/* reexport */ PublishCommand),
+  i8: () => (/* reexport */ PublishModule),
+  jX: () => (/* binding */ PublishExtension),
+  DU: () => (/* reexport */ PublishService),
+  bH: () => (/* binding */ publishMetadata)
+});
+
+;// CONCATENATED MODULE: external "@spaceflow/core"
+
+;// CONCATENATED MODULE: ./src/locales/zh-cn/publish.json
+var publish_namespaceObject = JSON.parse('{"description":"CI 发布命令，用于在发布流程中锁定/解锁分支","options.prerelease":"预发布标签，如 rc、beta、alpha、nightly 等","options.rehearsal":"预演模式：执行 hooks 但不修改文件/git，设置 PUBLISH_REHEARSAL=true 环境变量","rehearsalMode":"🎭 REHEARSAL mode: hooks will execute, but no file/git changes","dryRunMode":"🔍 DRY-RUN mode: no actual execution","extensionDescription":"CI 发布命令，用于在发布流程中锁定/解锁分支"}')
+;// CONCATENATED MODULE: ./src/locales/en/publish.json
+var en_publish_namespaceObject = JSON.parse('{"description":"CI publish command for branch lock/unlock during release","options.prerelease":"Prerelease tag, e.g. rc, beta, alpha, nightly","options.rehearsal":"Rehearsal mode: execute hooks but no file/git changes, sets PUBLISH_REHEARSAL=true","rehearsalMode":"🎭 REHEARSAL mode: hooks will execute, but no file/git changes","dryRunMode":"🔍 DRY-RUN mode: no actual execution","extensionDescription":"CI publish command for branch lock/unlock during release"}')
+;// CONCATENATED MODULE: ./src/locales/index.ts
+
+
+
+/** publish 命令 i18n 资源 */ const publishLocales = {
+    "zh-CN": publish_namespaceObject,
+    en: en_publish_namespaceObject
+};
+addLocaleResources("publish", publishLocales);
+
+;// CONCATENATED MODULE: external "@nestjs/common"
+
+;// CONCATENATED MODULE: external "@nestjs/config"
+
+;// CONCATENATED MODULE: external "nest-commander"
+
+;// CONCATENATED MODULE: external "child_process"
+
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(421);
+;// CONCATENATED MODULE: external "path"
+
+;// CONCATENATED MODULE: ./src/monorepo.service.ts
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+
+
+
+class MonorepoService {
+    cwd;
+    constructor(){
+        this.cwd = process.cwd();
+    }
+    /**
+   * 分析 monorepo 变更，返回需要发布的包列表（拓扑排序后）
+   * @param dryRun 是否为 dry-run 模式
+   * @param propagateDeps 是否传递依赖变更（依赖的包变更时，依赖方也发布）
+   */ async analyze(dryRun, propagateDeps = true) {
+        const workspacePackages = this.getWorkspacePackages();
+        const allPackages = this.getAllPackageInfos(workspacePackages);
+        // 为每个包单独检测变更（基于各自的最新 tag）
+        const changedPackages = this.getChangedPackages(allPackages, dryRun);
+        if (dryRun) {
+            console.log(`📦 直接变更的包: ${changedPackages.map((p)=>p.name).join(", ") || "无"}`);
+        }
+        // 计算依赖传递，找出所有需要发布的包
+        const packagesToPublish = propagateDeps ? this.calculateAffectedPackages(changedPackages, allPackages) : changedPackages;
+        if (dryRun) {
+            console.log(`🔄 需要发布的包（含依赖传递）: ${packagesToPublish.map((p)=>p.name).join(", ") || "无"}`);
+        }
+        // 拓扑排序
+        const sortedPackages = this.topologicalSort(packagesToPublish, allPackages);
+        if (dryRun) {
+            console.log(`📋 发布顺序: ${sortedPackages.map((p)=>p.name).join(" -> ") || "无"}`);
+        }
+        return {
+            changedPackages,
+            packagesToPublish: sortedPackages
+        };
+    }
+    /**
+   * 简单解析 pnpm-workspace.yaml（只提取 packages 数组）
+   */ parseSimpleYaml(content) {
+        const packages = [];
+        const lines = content.split("\n");
+        let inPackages = false;
+        for (const line of lines){
+            const trimmed = line.trim();
+            if (trimmed === "packages:") {
+                inPackages = true;
+                continue;
+            }
+            if (inPackages) {
+                if (trimmed.startsWith("- ")) {
+                    // 提取包路径，去除引号
+                    let pkg = trimmed.slice(2).trim();
+                    pkg = pkg.replace(/^["']|["']$/g, "");
+                    packages.push(pkg);
+                } else if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("-")) {
+                    break;
+                }
+            }
+        }
+        return {
+            packages: packages.length > 0 ? packages : undefined
+        };
+    }
+    /**
+   * 从 pnpm-workspace.yaml 读取 workspace 包配置
+   */ getWorkspacePackages() {
+        const workspaceFile = join(this.cwd, "pnpm-workspace.yaml");
+        if (!(0,external_fs_.existsSync)(workspaceFile)) {
+            throw new Error("未找到 pnpm-workspace.yaml 文件");
+        }
+        const content = (0,external_fs_.readFileSync)(workspaceFile, "utf-8");
+        const config = this.parseSimpleYaml(content);
+        if (!config.packages || !Array.isArray(config.packages)) {
+            throw new Error("pnpm-workspace.yaml 中未配置 packages");
+        }
+        return config.packages;
+    }
+    /**
+   * 展开 workspace 包配置，获取所有实际的包目录
+   */ expandWorkspacePatterns(patterns) {
+        const dirs = [];
+        for (const pattern of patterns){
+            if (pattern.includes("*")) {
+                // 使用 glob 展开，这里简化处理，只支持 extensions/* 这种模式
+                const baseDir = pattern.replace("/*", "");
+                const basePath = join(this.cwd, baseDir);
+                if ((0,external_fs_.existsSync)(basePath)) {
+                    const { readdirSync, statSync } = __webpack_require__(421);
+                    const entries = readdirSync(basePath);
+                    for (const entry of entries){
+                        const entryPath = join(basePath, entry);
+                        if (statSync(entryPath).isDirectory()) {
+                            const pkgJson = join(entryPath, "package.json");
+                            if ((0,external_fs_.existsSync)(pkgJson)) {
+                                dirs.push(join(baseDir, entry));
+                            }
+                        }
+                    }
+                }
+            } else {
+                // 直接目录
+                const pkgJson = join(this.cwd, pattern, "package.json");
+                if ((0,external_fs_.existsSync)(pkgJson)) {
+                    dirs.push(pattern);
+                }
+            }
+        }
+        return dirs;
+    }
+    /**
+   * 获取所有包的详细信息（排除私有包）
+   */ getAllPackageInfos(patterns) {
+        const dirs = this.expandWorkspacePatterns(patterns);
+        const packages = [];
+        for (const dir of dirs){
+            const pkgJsonPath = join(this.cwd, dir, "package.json");
+            if (!(0,external_fs_.existsSync)(pkgJsonPath)) continue;
+            const pkgJson = JSON.parse((0,external_fs_.readFileSync)(pkgJsonPath, "utf-8"));
+            // 跳过私有包
+            if (pkgJson.private === true) continue;
+            const workspaceDeps = this.extractWorkspaceDeps(pkgJson);
+            packages.push({
+                dir,
+                name: pkgJson.name,
+                version: pkgJson.version,
+                workspaceDeps
+            });
+        }
+        return packages;
+    }
+    /**
+   * 提取包的 workspace 依赖
+   */ extractWorkspaceDeps(pkgJson) {
+        const deps = [];
+        const allDeps = {
+            ...pkgJson.dependencies,
+            ...pkgJson.devDependencies,
+            ...pkgJson.peerDependencies
+        };
+        for (const [name, version] of Object.entries(allDeps)){
+            if (version && (version.startsWith("workspace:") || version === "*")) {
+                deps.push(name);
+            }
+        }
+        return deps;
+    }
+    /**
+   * 检测每个包的变更（基于各自的最新 tag）
+   */ getChangedPackages(allPackages, dryRun) {
+        const changedPackages = [];
+        for (const pkg of allPackages){
+            const hasChanges = this.hasPackageChanges(pkg);
+            if (hasChanges) {
+                changedPackages.push(pkg);
+            }
+            if (dryRun) {
+                console.log(`  ${hasChanges ? "✅" : "⭕"} ${pkg.name}`);
+            }
+        }
+        return changedPackages;
+    }
+    /**
+   * 检测单个包是否有变更（基于该包的最新 tag）
+   */ hasPackageChanges(pkg) {
+        try {
+            // 获取该包的最新 tag（格式: @scope/pkg@version 或 pkg@version）
+            const tagPattern = `${pkg.name}@*`;
+            const latestTag = execSync(`git describe --tags --abbrev=0 --match "${tagPattern}" 2>/dev/null || echo ''`, {
+                cwd: this.cwd,
+                encoding: "utf-8"
+            }).trim();
+            if (!latestTag) {
+                // 没有 tag，说明是新包，需要发布
+                console.log(`📌 ${pkg.name}: 无 tag，需要发布`);
+                return true;
+            }
+            // 检测从该 tag 到 HEAD，该包目录下是否有变更
+            const diffOutput = execSync(`git diff --name-only "${latestTag}"..HEAD -- "${pkg.dir}"`, {
+                cwd: this.cwd,
+                encoding: "utf-8"
+            }).trim();
+            const hasChanges = diffOutput.length > 0;
+            if (hasChanges) {
+                console.log(`📌 ${pkg.name}: ${latestTag} -> HEAD 有变更`);
+                console.log(`    变更文件: ${diffOutput.split("\n").slice(0, 3).join(", ")}${diffOutput.split("\n").length > 3 ? "..." : ""}`);
+            }
+            return hasChanges;
+        } catch (error) {
+            // 出错时保守处理，认为有变更
+            console.log(`📌 ${pkg.name}: 检测出错，保守处理为有变更`);
+            console.log(`    错误: ${error instanceof Error ? error.message : error}`);
+            return true;
+        }
+    }
+    /**
+   * 将变更文件映射到包目录
+   */ mapFilesToPackages(files, patterns) {
+        const packageDirs = this.expandWorkspacePatterns(patterns);
+        const changedPackages = new Set();
+        for (const file of files){
+            for (const dir of packageDirs){
+                if (file.startsWith(dir + "/") || file === dir) {
+                    changedPackages.add(dir);
+                    break;
+                }
+            }
+        }
+        return changedPackages;
+    }
+    /**
+   * 计算受影响的包（包含依赖传递）
+   */ calculateAffectedPackages(changedPackages, allPackages) {
+        const changedNames = new Set(changedPackages.map((p)=>p.name));
+        const affectedNames = new Set(changedNames);
+        // 构建反向依赖图：谁依赖了我
+        const reverseDeps = new Map();
+        for (const pkg of allPackages){
+            for (const dep of pkg.workspaceDeps){
+                if (!reverseDeps.has(dep)) {
+                    reverseDeps.set(dep, new Set());
+                }
+                reverseDeps.get(dep).add(pkg.name);
+            }
+        }
+        // BFS 传递依赖
+        const queue = [
+            ...changedNames
+        ];
+        while(queue.length > 0){
+            const current = queue.shift();
+            const dependents = reverseDeps.get(current);
+            if (dependents) {
+                for (const dependent of dependents){
+                    if (!affectedNames.has(dependent)) {
+                        affectedNames.add(dependent);
+                        queue.push(dependent);
+                    }
+                }
+            }
+        }
+        return allPackages.filter((p)=>affectedNames.has(p.name));
+    }
+    /**
+   * 拓扑排序：被依赖的包先发布
+   */ topologicalSort(packages, _allPackages) {
+        const packageNames = new Set(packages.map((p)=>p.name));
+        const nameToPackage = new Map(packages.map((p)=>[
+                p.name,
+                p
+            ]));
+        // 构建依赖图（只考虑待发布包之间的依赖）
+        const inDegree = new Map();
+        const graph = new Map();
+        for (const pkg of packages){
+            inDegree.set(pkg.name, 0);
+            graph.set(pkg.name, []);
+        }
+        for (const pkg of packages){
+            for (const dep of pkg.workspaceDeps){
+                if (packageNames.has(dep)) {
+                    graph.get(dep).push(pkg.name);
+                    inDegree.set(pkg.name, (inDegree.get(pkg.name) || 0) + 1);
+                }
+            }
+        }
+        // Kahn's algorithm
+        const queue = [];
+        for (const [name, degree] of inDegree){
+            if (degree === 0) {
+                queue.push(name);
+            }
+        }
+        const sorted = [];
+        while(queue.length > 0){
+            const current = queue.shift();
+            sorted.push(nameToPackage.get(current));
+            for (const neighbor of graph.get(current) || []){
+                const newDegree = (inDegree.get(neighbor) || 0) - 1;
+                inDegree.set(neighbor, newDegree);
+                if (newDegree === 0) {
+                    queue.push(neighbor);
+                }
+            }
+        }
+        if (sorted.length !== packages.length) {
+            throw new Error("检测到循环依赖，无法确定发布顺序");
+        }
+        return sorted;
+    }
+}
+MonorepoService = _ts_decorate([
+    Injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [])
+], MonorepoService);
+
+;// CONCATENATED MODULE: ./src/publish.service.ts
+function publish_service_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function publish_service_ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+
+
+
+
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const releaseItModule = __webpack_require__(547);
+const releaseIt = typeof releaseItModule === "function" ? releaseItModule : releaseItModule.default;
+class PublishService {
+    gitProvider;
+    configService;
+    configReader;
+    monorepoService;
+    cleanupOnExit = null;
+    uncaughtExceptionHandler = null;
+    branchUnlocked = false;
+    constructor(gitProvider, configService, configReader, monorepoService){
+        this.gitProvider = gitProvider;
+        this.configService = configService;
+        this.configReader = configReader;
+        this.monorepoService = monorepoService;
+    }
+    getContextFromEnv(options) {
+        this.gitProvider.validateConfig();
+        const ciConf = this.configService.get("ci");
+        const repository = ciConf?.repository;
+        const branch = ciConf?.refName;
+        if (!repository) {
+            throw new Error("缺少配置 ci.repository (环境变量 GITHUB_REPOSITORY)");
+        }
+        if (!branch) {
+            throw new Error("缺少配置 ci.refName (环境变量 GITHUB_REF_NAME)");
+        }
+        const [owner, repo] = repository.split("/");
+        if (!owner || !repo) {
+            throw new Error(`ci.repository 格式不正确，期望 "owner/repo"，实际: "${repository}"`);
+        }
+        return {
+            owner,
+            repo,
+            branch,
+            dryRun: options.dryRun ?? false,
+            prerelease: options.prerelease,
+            ci: options.ci,
+            rehearsal: options.rehearsal ?? false
+        };
+    }
+    async execute(context) {
+        const publishConf = this.configReader.getPluginConfig("publish");
+        const monorepoConf = publishConf.monorepo;
+        // CI 环境下自动 fetch tags，确保 release-it 能正确计算版本
+        if (context.ci) {
+            await this.ensureTagsFetched();
+        }
+        // 检查是否启用 monorepo 模式
+        if (monorepoConf?.enabled) {
+            return this.executeMonorepo(context, publishConf);
+        }
+        // 单包发布模式
+        return this.executeSinglePackage(context, publishConf);
+    }
+    /**
+   * Monorepo 发布模式：扫描变更包，按依赖顺序发布
+   */ async executeMonorepo(context, publishConf) {
+        const { dryRun } = context;
+        console.log("\n📦 Monorepo 发布模式");
+        console.log("=".repeat(50));
+        const propagateDeps = publishConf.monorepo?.propagateDeps ?? true;
+        // 分析变更包
+        const analysis = await this.monorepoService.analyze(dryRun, propagateDeps);
+        if (analysis.packagesToPublish.length === 0) {
+            console.log("\n✅ 没有需要发布的包");
+            return {
+                success: true,
+                message: "没有需要发布的包"
+            };
+        }
+        console.log(`\n🚀 将发布 ${analysis.packagesToPublish.length} 个包`);
+        await this.handleBegin(context, publishConf);
+        try {
+            // 按顺序发布每个包
+            for(let i = 0; i < analysis.packagesToPublish.length; i++){
+                const pkg = analysis.packagesToPublish[i];
+                console.log(`\n[${i + 1}/${analysis.packagesToPublish.length}] 发布 ${pkg.name}`);
+                console.log("-".repeat(40));
+                await this.executePackageRelease(context, publishConf, pkg);
+            }
+            await this.handleEnd(context, publishConf);
+            return {
+                success: true,
+                message: `成功发布 ${analysis.packagesToPublish.length} 个包`
+            };
+        } catch (error) {
+            console.error("\n❌ Monorepo 发布失败:", error instanceof Error ? error.message : error);
+            try {
+                await this.handleEnd(context, publishConf);
+            } catch (unlockError) {
+                console.error("⚠️ 解锁分支失败:", unlockError instanceof Error ? unlockError.message : unlockError);
+            }
+            return {
+                success: false,
+                message: "Monorepo 发布失败"
+            };
+        }
+    }
+    /**
+   * 发布单个包（monorepo 模式）
+   */ async executePackageRelease(context, publishConf, pkg) {
+        const { dryRun, prerelease, ci, rehearsal } = context;
+        if (rehearsal) {
+            console.log(`🎭 [REHEARSAL] 将发布包: ${pkg.name} (${pkg.dir})`);
+        } else if (dryRun) {
+            console.log(`🔍 [DRY-RUN] 将发布包: ${pkg.name} (${pkg.dir})`);
+        }
+        const pkgDir = join(process.cwd(), pkg.dir);
+        const originalCwd = process.cwd();
+        const config = this.buildReleaseItConfig({
+            dryRun,
+            prerelease,
+            ci,
+            rehearsal,
+            pkgDir,
+            pkgName: pkg.name,
+            pkgBase: pkg.dir.split("/").pop() || pkg.dir,
+            publishConf
+        });
+        // 切换到包目录运行 release-it，确保读取正确的 package.json
+        process.chdir(pkgDir);
+        try {
+            await releaseIt(config);
+            console.log(`✅ ${pkg.name} 发布完成`);
+        } finally{
+            // 恢复原工作目录
+            process.chdir(originalCwd);
+        }
+    }
+    /**
+   * 单包发布模式
+   */ async executeSinglePackage(context, publishConf) {
+        const { dryRun, prerelease, ci, rehearsal } = context;
+        await this.handleBegin(context, publishConf);
+        try {
+            const config = this.buildReleaseItConfig({
+                dryRun,
+                prerelease,
+                ci,
+                rehearsal,
+                pkgDir: process.cwd(),
+                pkgBase: process.cwd().split("/").pop() || ".",
+                publishConf
+            });
+            await releaseIt(config);
+        } catch (error) {
+            console.error("执行失败:", error instanceof Error ? error.message : error);
+            try {
+                await this.handleEnd(context, publishConf);
+            } catch (unlockError) {
+                console.error("⚠️ 解锁分支失败:", unlockError instanceof Error ? unlockError.message : unlockError);
+            }
+            return {
+                success: false,
+                message: "执行失败"
+            };
+        }
+        await this.handleEnd(context, publishConf);
+        return {
+            success: true,
+            message: "执行完成",
+            protection: null
+        };
+    }
+    /**
+   * 构建 release-it 配置（公共方法）
+   */ buildReleaseItConfig(opts) {
+        const { dryRun, prerelease, ci, rehearsal, pkgName, pkgBase, publishConf } = opts;
+        const changelogConf = publishConf.changelog;
+        const releaseConf = publishConf.release;
+        const npmConf = publishConf.npm;
+        const gitConf = publishConf.git;
+        // 预演模式：设置环境变量，hooks 可以通过它判断当前模式
+        if (rehearsal) {
+            process.env.PUBLISH_REHEARSAL = "true";
+        }
+        const isMonorepo = !!pkgName;
+        const tagMatchOpts = !prerelease ? {
+            tagExclude: `*[-]*`
+        } : {};
+        // monorepo: @scope/pkg@1.0.0, 单包: v1.0.0
+        const tagPrefix = isMonorepo ? `${pkgName}@` : "v";
+        const tagName = isMonorepo ? `${pkgName}@\${version}` : "v${version}";
+        const releaseName = isMonorepo ? `${pkgName}@\${version}` : "v${version}";
+        const releaseTitle = isMonorepo ? `🎉 ${pkgName}@\${version}` : "🎉 v${version}";
+        // monorepo 模式下在包目录运行，git commitsPath 为 "."
+        const commitsPath = ".";
+        const commitMessage = isMonorepo ? `chore(${pkgBase}): released version \${version} [no ci]` : "chore: released version v${version} [no ci]";
+        // 预演模式：禁用文件/git 修改，但保留 hooks
+        // dryRun 模式：完全跳过所有操作（包括 hooks）
+        const skipWrite = dryRun || rehearsal;
+        return {
+            "dry-run": dryRun,
+            d: dryRun,
+            ci: ci || dryRun,
+            plugins: {
+                // 预演模式下禁用 changelog 写入
+                ...!skipWrite && changelogConf ? {
+                    "@release-it/conventional-changelog": {
+                        // 现在在包目录下运行，使用相对路径
+                        infile: join(changelogConf.infileDir || ".", `CHANGELOG${!prerelease ? "" : "-" + prerelease.toUpperCase()}.md`),
+                        preset: {
+                            name: changelogConf.preset?.name || "conventionalcommits",
+                            types: changelogConf.preset?.type || []
+                        }
+                    }
+                } : {},
+                // 预演模式下禁用 release 创建
+                ...!skipWrite && releaseConf ? {
+                    "release-it-gitea": {
+                        releaseTitle,
+                        releaseNotes: this.formatReleaseNotes,
+                        assets: this.buildReleaseAssets(releaseConf)
+                    }
+                } : {}
+            },
+            git: {
+                // 预演模式：禁用 push/commit/tag
+                push: !skipWrite,
+                commit: !skipWrite,
+                tag: !skipWrite,
+                tagName,
+                commitsPath,
+                commitMessage,
+                requireCommits: false,
+                requireCommitsFail: false,
+                getLatestTagFromAllRefs: true,
+                requireBranch: gitConf?.requireBranch ?? [
+                    "main",
+                    "dev",
+                    "develop"
+                ],
+                requireCleanWorkingDir: !skipWrite,
+                ...isMonorepo ? {
+                    tagMatch: `${tagPrefix}*`
+                } : {},
+                ...tagMatchOpts
+            },
+            // 预演模式：禁用 npm
+            // 如果使用 pnpm，禁用内置 npm 发布，但保留版本更新功能
+            npm: skipWrite ? false : {
+                // pnpm 模式：禁用 publish（通过 hooks 实现），但保留版本更新
+                publish: npmConf?.packageManager === "pnpm" ? false : npmConf?.publish ?? false,
+                ignoreVersion: npmConf?.ignoreVersion ?? true,
+                tag: prerelease || npmConf?.tag || "latest",
+                versionArgs: npmConf?.versionArgs ?? [
+                    "--workspaces false"
+                ],
+                publishArgs: npmConf?.publishArgs ?? [],
+                ...npmConf?.registry ? {
+                    publishConfig: {
+                        registry: npmConf.registry
+                    }
+                } : {}
+            },
+            github: {
+                release: false,
+                releaseName: `Release ${releaseName}`,
+                autoGenerate: true,
+                skipChecks: true,
+                host: releaseConf?.host || "localhost"
+            },
+            // 合并用户 hooks 和内部 pnpm 发布 hook
+            hooks: this.buildHooks({
+                userHooks: publishConf.hooks,
+                npmConf,
+                prerelease,
+                skipWrite,
+                dryRun,
+                rehearsal
+            })
+        };
+    }
+    /**
+   * 格式化 release notes
+   */ formatReleaseNotes(t) {
+        const lines = t.changelog.split("\n");
+        const cateLines = lines.filter((line)=>line.startsWith("###") || line.startsWith("* "));
+        const cateMap = {};
+        let currentCate = "";
+        cateLines.forEach((line)=>{
+            if (line.startsWith("###")) {
+                currentCate = line;
+                cateMap[currentCate] = cateMap[currentCate] || [];
+            } else {
+                cateMap[currentCate].push(line);
+            }
+        });
+        return Object.entries(cateMap).map(([cate, catLines])=>`${cate}\n\n${catLines.join("\n")}\n`).join("\n");
+    }
+    /**
+   * 构建 release assets 配置
+   */ buildReleaseAssets(releaseConf) {
+        const assets = releaseConf.assetSourcemap ? [
+            {
+                path: releaseConf.assetSourcemap.path,
+                name: releaseConf.assetSourcemap.name,
+                type: "zip"
+            }
+        ] : [];
+        return assets.concat(releaseConf.assets || []);
+    }
+    /**
+   * 构建 hooks 配置，合并用户 hooks 和内部 pnpm 发布逻辑
+   */ buildHooks(opts) {
+        const { userHooks, npmConf, prerelease, skipWrite, dryRun, rehearsal } = opts;
+        // dryRun 模式下不执行任何 hooks
+        if (dryRun && !rehearsal) {
+            return undefined;
+        }
+        // 复制用户 hooks
+        let hooks = {
+            ...userHooks
+        };
+        // rehearsal 模式下过滤 after 前缀的 hooks（不执行实际的发布后操作）
+        if (rehearsal) {
+            hooks = Object.fromEntries(Object.entries(hooks).filter(([key])=>!key.startsWith("after:")));
+            // rehearsal 模式下也不添加 pnpm publish
+            return Object.keys(hooks).length > 0 ? hooks : undefined;
+        }
+        // 如果使用 pnpm 且需要发布
+        if (npmConf?.packageManager === "pnpm" && npmConf?.publish && !skipWrite) {
+            const tag = prerelease || npmConf.tag || "latest";
+            const publishArgs = npmConf.publishArgs ?? [];
+            const registry = npmConf.registry;
+            // 构建 pnpm publish 命令
+            // monorepo 模式下已切换到包目录，不需要 -C 参数
+            let publishCmd = `pnpm publish --tag ${tag} --no-git-checks`;
+            if (registry) {
+                publishCmd += ` --registry ${registry}`;
+            }
+            if (publishArgs.length > 0) {
+                publishCmd += ` ${publishArgs.join(" ")}`;
+            }
+            // 合并到 after:bump hook
+            const existingAfterBump = hooks["after:bump"];
+            if (existingAfterBump) {
+                hooks["after:bump"] = Array.isArray(existingAfterBump) ? [
+                    ...existingAfterBump,
+                    publishCmd
+                ] : [
+                    existingAfterBump,
+                    publishCmd
+                ];
+            } else {
+                hooks["after:bump"] = publishCmd;
+            }
+        }
+        return Object.keys(hooks).length > 0 ? hooks : undefined;
+    }
+    async handleBegin(context, publishConf) {
+        const { owner, repo, branch, dryRun } = context;
+        const shouldLockBranch = publishConf.git?.lockBranch ?? true;
+        if (!shouldLockBranch) {
+            console.log(`⏭️ 跳过分支锁定（已禁用）`);
+            return {
+                success: true,
+                message: "分支锁定已禁用",
+                protection: null
+            };
+        }
+        const pushWhitelistUsernames = [
+            ...publishConf.git?.pushWhitelistUsernames ?? []
+        ];
+        if (dryRun) {
+            console.log(`🔍 [DRY-RUN] 将锁定分支: ${owner}/${repo}#${branch}`);
+            return {
+                success: true,
+                message: "DRY-RUN: 分支锁定已跳过",
+                protection: null
+            };
+        }
+        console.log(`🔒 正在锁定分支: ${owner}/${repo}#${branch}`);
+        const protection = await this.gitProvider.lockBranch(owner, repo, branch, {
+            pushWhitelistUsernames
+        });
+        console.log(`✅ 分支已锁定`);
+        console.log(`   规则名称: ${protection.rule_name || protection.branch_name}`);
+        if (pushWhitelistUsernames?.length) {
+            console.log(`   允许推送用户: ${pushWhitelistUsernames.join(", ")}`);
+        } else {
+            console.log(`   允许推送: ${protection.enable_push ? "是" : "否"}`);
+        }
+        // 注册进程退出时的清理函数，确保即使 release-it 调用 process.exit() 也能解锁分支
+        this.branchUnlocked = false;
+        this.cleanupOnExit = ()=>{
+            if (this.branchUnlocked) return;
+            this.branchUnlocked = true;
+            console.log("\n🔓 进程退出，正在同步解锁分支...");
+            try {
+                this.unlockBranchSync(context, publishConf);
+            } catch (e) {
+                console.error("⚠️ 同步解锁分支失败:", e instanceof Error ? e.message : e);
+            }
+        };
+        this.uncaughtExceptionHandler = (err)=>{
+            console.error("\n❌ 未捕获的异常:", err.message);
+            if (this.cleanupOnExit) this.cleanupOnExit();
+            process.exit(1);
+        };
+        process.on("exit", this.cleanupOnExit);
+        process.on("SIGINT", this.cleanupOnExit);
+        process.on("SIGTERM", this.cleanupOnExit);
+        process.on("uncaughtException", this.uncaughtExceptionHandler);
+        return {
+            success: true,
+            message: "分支锁定完成",
+            protection
+        };
+    }
+    async handleEnd(context, publishConf) {
+        const { owner, repo, branch, dryRun } = context;
+        const shouldLockBranch = publishConf.git?.lockBranch ?? true;
+        if (!shouldLockBranch) {
+            return {
+                success: true,
+                message: "分支锁定已禁用，无需解锁",
+                protection: null
+            };
+        }
+        if (dryRun) {
+            console.log(`🔍 [DRY-RUN] 将解锁分支: ${owner}/${repo}#${branch}`);
+            return {
+                success: true,
+                message: "DRY-RUN: 分支解锁已跳过",
+                protection: null
+            };
+        }
+        console.log(`🔓 正在解锁分支: ${owner}/${repo}#${branch}`);
+        const protection = await this.gitProvider.unlockBranch(owner, repo, branch);
+        // 标记已解锁，防止清理函数重复执行
+        this.branchUnlocked = true;
+        // 移除事件监听器
+        if (this.cleanupOnExit) {
+            process.removeListener("exit", this.cleanupOnExit);
+            process.removeListener("SIGINT", this.cleanupOnExit);
+            process.removeListener("SIGTERM", this.cleanupOnExit);
+            this.cleanupOnExit = null;
+        }
+        if (this.uncaughtExceptionHandler) {
+            process.removeListener("uncaughtException", this.uncaughtExceptionHandler);
+            this.uncaughtExceptionHandler = null;
+        }
+        if (protection) {
+            console.log(`✅ 分支已解锁`);
+            console.log(`   规则名称: ${protection.rule_name || protection.branch_name}`);
+            console.log(`   允许推送: ${protection.enable_push ? "是" : "否"}`);
+            return {
+                success: true,
+                message: "分支解锁完成",
+                protection
+            };
+        } else {
+            console.log(`✅ 分支本身没有保护规则，无需解锁`);
+            return {
+                success: true,
+                message: "分支本身没有保护规则，无需解锁",
+                protection: null
+            };
+        }
+    }
+    /**
+   * 同步解锁分支（用于进程退出时的清理）
+   */ unlockBranchSync(context, publishConf) {
+        const { owner, repo, branch, dryRun } = context;
+        const shouldLockBranch = publishConf.git?.lockBranch ?? true;
+        if (!shouldLockBranch || dryRun) {
+            return;
+        }
+        this.gitProvider.unlockBranchSync(owner, repo, branch);
+    }
+    /**
+   * 确保 git tags 已获取（CI 环境中 shallow clone 可能缺失 tags）
+   * 这对于 release-it 正确计算版本号至关重要
+   */ async ensureTagsFetched() {
+        try {
+            // 检查是否有 tags
+            const existingTags = execSync("git tag --list 2>/dev/null || echo ''", {
+                encoding: "utf-8"
+            }).trim();
+            if (!existingTags) {
+                console.log("🏷️  正在获取 git tags...");
+                execSync("git fetch --tags --force", {
+                    stdio: "inherit"
+                });
+                console.log("✅ Git tags 已获取");
+            }
+        } catch (error) {
+            console.warn("⚠️ 获取 git tags 失败:", error instanceof Error ? error.message : error);
+            console.warn("   版本计算可能不准确，建议在 CI checkout 时添加 fetch-depth: 0 和 fetch-tags: true");
+        }
+    }
+}
+PublishService = publish_service_ts_decorate([
+    Injectable(),
+    publish_service_ts_metadata("design:type", Function),
+    publish_service_ts_metadata("design:paramtypes", [
+        typeof GitProviderService === "undefined" ? Object : GitProviderService,
+        typeof ConfigService === "undefined" ? Object : ConfigService,
+        typeof ConfigReaderService === "undefined" ? Object : ConfigReaderService,
+        typeof MonorepoService === "undefined" ? Object : MonorepoService
+    ])
+], PublishService);
+
+;// CONCATENATED MODULE: ./src/publish.command.ts
+function publish_command_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function publish_command_ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+
+
+class PublishCommand extends CommandRunner {
+    publishService;
+    constructor(publishService){
+        super(), this.publishService = publishService;
+    }
+    async run(_passedParams, options) {
+        if (options.rehearsal) {
+            console.log(core_t("publish:rehearsalMode"));
+        } else if (options.dryRun) {
+            console.log(core_t("publish:dryRunMode"));
+        }
+        try {
+            const context = this.publishService.getContextFromEnv(options);
+            await this.publishService.execute(context);
+        } catch (error) {
+            console.error(core_t("common.executionFailed", {
+                error: error instanceof Error ? error.message : error
+            }));
+            process.exit(1);
+        }
+    }
+    parseDryRun(val) {
+        return val;
+    }
+    parseCi(val) {
+        return val;
+    }
+    parsePrerelease(val) {
+        return val;
+    }
+    parseRehearsal(val) {
+        return val;
+    }
+}
+publish_command_ts_decorate([
+    Option({
+        flags: "-d, --dry-run",
+        description: core_t("common.options.dryRun")
+    }),
+    publish_command_ts_metadata("design:type", Function),
+    publish_command_ts_metadata("design:paramtypes", [
+        Boolean
+    ]),
+    publish_command_ts_metadata("design:returntype", Boolean)
+], PublishCommand.prototype, "parseDryRun", null);
+publish_command_ts_decorate([
+    Option({
+        flags: "-c, --ci",
+        description: core_t("common.options.ci")
+    }),
+    publish_command_ts_metadata("design:type", Function),
+    publish_command_ts_metadata("design:paramtypes", [
+        Boolean
+    ]),
+    publish_command_ts_metadata("design:returntype", Boolean)
+], PublishCommand.prototype, "parseCi", null);
+publish_command_ts_decorate([
+    Option({
+        flags: "-p, --prerelease <tag>",
+        description: core_t("publish:options.prerelease")
+    }),
+    publish_command_ts_metadata("design:type", Function),
+    publish_command_ts_metadata("design:paramtypes", [
+        String
+    ]),
+    publish_command_ts_metadata("design:returntype", String)
+], PublishCommand.prototype, "parsePrerelease", null);
+publish_command_ts_decorate([
+    Option({
+        flags: "-r, --rehearsal",
+        description: core_t("publish:options.rehearsal")
+    }),
+    publish_command_ts_metadata("design:type", Function),
+    publish_command_ts_metadata("design:paramtypes", [
+        Boolean
+    ]),
+    publish_command_ts_metadata("design:returntype", Boolean)
+], PublishCommand.prototype, "parseRehearsal", null);
+PublishCommand = publish_command_ts_decorate([
+    Command({
+        name: "publish",
+        description: core_t("publish:description")
+    }),
+    publish_command_ts_metadata("design:type", Function),
+    publish_command_ts_metadata("design:paramtypes", [
+        typeof PublishService === "undefined" ? Object : PublishService
+    ])
+], PublishCommand);
+
+;// CONCATENATED MODULE: ./src/publish.module.ts
+function publish_module_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+
+
+
+
+
+class PublishModule {
+}
+PublishModule = publish_module_ts_decorate([
+    Module({
+        imports: [
+            ConfigModule.forFeature(ciConfig),
+            GitProviderModule.forFeature(),
+            ConfigReaderModule
+        ],
+        providers: [
+            PublishCommand,
+            PublishService,
+            MonorepoService
+        ]
+    })
+], PublishModule);
+
+;// CONCATENATED MODULE: ./src/publish.config.ts
+
+/** publish 命令配置 schema */ const publishSchema = z.object({
+    /** monorepo 发布模式配置 */ monorepo: z.object({
+        /** 是否启用 monorepo 发布模式 */ enabled: z.boolean().default(false),
+        /** 是否传递依赖变更（依赖的包变更时，依赖方也发布） */ propagateDeps: z.boolean().default(true)
+    }).optional(),
+    changelog: z.object({
+        /** changelog 文件输出目录 */ infileDir: z.string().default(".").optional(),
+        preset: z.object({
+            /** preset 名称，默认 conventionalcommits */ name: z.string().default("conventionalcommits").optional(),
+            /** commit type 到 section 的映射 */ type: z.array(z.object({
+                type: z.string(),
+                section: z.string()
+            })).default([])
+        }).optional()
+    }).optional(),
+    /** npm 发布配置 */ npm: z.object({
+        /** 是否发布到 npm registry */ publish: z.boolean().default(false),
+        /** 包管理器，npm 或 pnpm */ packageManager: z["enum"]([
+            "npm",
+            "pnpm"
+        ]).default("npm"),
+        /** npm registry 地址 */ registry: z.string().optional(),
+        /** npm tag，如 latest、beta、next */ tag: z.string().default("latest"),
+        /** 是否忽略 package.json 中的版本号 */ ignoreVersion: z.boolean().default(true),
+        /** npm version 命令额外参数 */ versionArgs: z.array(z.string()).default([
+            "--workspaces false"
+        ]),
+        /** npm/pnpm publish 命令额外参数 */ publishArgs: z.array(z.string()).default([])
+    }).optional(),
+    release: z.object({
+        host: z.string().default("localhost"),
+        assetSourcemap: z.object({
+            path: z.string(),
+            name: z.string()
+        }).optional(),
+        assets: z.array(z.object({
+            path: z.string(),
+            name: z.string(),
+            type: z.string()
+        })).default([])
+    }).optional(),
+    /** git 配置 */ git: z.object({
+        /** 允许发布的分支列表 */ requireBranch: z.array(z.string()).default([
+            "main",
+            "dev",
+            "develop"
+        ]),
+        /** 分支锁定时允许推送的用户名白名单（如 CI 机器人） */ pushWhitelistUsernames: z.array(z.string()).default([]),
+        /** 是否在发布时锁定分支 */ lockBranch: z.boolean().default(true)
+    }).optional(),
+    /** release-it hooks 配置，如 before:bump, after:bump 等 */ hooks: z.record(z.string(), z.union([
+        z.string(),
+        z.array(z.string())
+    ])).optional()
+});
+
+;// CONCATENATED MODULE: ./src/index.ts
+
+
+
+
+/** publish Extension 元数据 */ const publishMetadata = {
+    name: "publish",
+    commands: [
+        "publish"
+    ],
+    configKey: "publish",
+    configSchema: ()=>publishSchema,
+    version: "1.0.0",
+    description: core_t("publish:extensionDescription")
+};
+class PublishExtension {
+    getMetadata() {
+        return publishMetadata;
+    }
+    getModule() {
+        return PublishModule;
+    }
+}
+/* export default */ const src = (PublishExtension);
+
+
+
+
+
+})();
+
+var __webpack_exports__MonorepoService = __webpack_exports__.Vy;
+var __webpack_exports__PublishCommand = __webpack_exports__.D5;
+var __webpack_exports__PublishExtension = __webpack_exports__.jX;
+var __webpack_exports__PublishModule = __webpack_exports__.i8;
+var __webpack_exports__PublishService = __webpack_exports__.DU;
+var __webpack_exports__default = __webpack_exports__.Ay;
+var __webpack_exports__publishMetadata = __webpack_exports__.bH;
+export { __webpack_exports__MonorepoService as MonorepoService, __webpack_exports__PublishCommand as PublishCommand, __webpack_exports__PublishExtension as PublishExtension, __webpack_exports__PublishModule as PublishModule, __webpack_exports__PublishService as PublishService, __webpack_exports__default as default, __webpack_exports__publishMetadata as publishMetadata };