@spaceflow/publish 0.21.2 → 0.22.0

package/dist/index.js

@@ -1,11 +1,8 @@
 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 { addLocaleResources, ciConfig, defineExtension, t as core_t, z } from "@spaceflow/core";
 import { join } from "path";
+import { execSync } from "child_process";
 var __webpack_modules__ = ({
 421(module) {
 
@@ -64,13 +61,8 @@ var __webpack_exports__ = {};
 
 // 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)
+  A: () => (/* binding */ src),
+  c: () => (/* binding */ extension)
 });
 
 ;// CONCATENATED MODULE: external "@spaceflow/core"
@@ -89,469 +81,201 @@ var en_publish_namespaceObject = JSON.parse('{"description":"CI publish command
 };
 addLocaleResources("publish", publishLocales);
 
-;// CONCATENATED MODULE: external "@nestjs/common"
-
-;// CONCATENATED MODULE: external "@nestjs/config"
-
-;// CONCATENATED MODULE: external "nest-commander"
+;// CONCATENATED MODULE: ./src/publish.config.ts
 
-;// CONCATENATED MODULE: external "child_process"
+/** 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()
+});
 
-// 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);
-}
+;// CONCATENATED MODULE: external "child_process"
 
+;// CONCATENATED MODULE: ./src/publish.service.ts
 
 
 
-class MonorepoService {
-    cwd;
-    constructor(){
-        this.cwd = process.cwd();
+// 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;
+    config;
+    configReader;
+    monorepoService;
+    cleanupOnExit = null;
+    uncaughtExceptionHandler = null;
+    branchUnlocked = false;
+    constructor(gitProvider, config, configReader, monorepoService){
+        this.gitProvider = gitProvider;
+        this.config = config;
+        this.configReader = configReader;
+        this.monorepoService = monorepoService;
     }
-    /**
-   * 分析 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(", ") || "无"}`);
+    getContextFromEnv(options) {
+        this.gitProvider.validateConfig();
+        const ciConf = ciConfig();
+        const repository = ciConf.repository;
+        const branch = ciConf.refName;
+        if (!repository) {
+            throw new Error("缺少配置 ci.repository (环境变量 GITHUB_REPOSITORY)");
         }
-        // 计算依赖传递，找出所有需要发布的包
-        const packagesToPublish = propagateDeps ? this.calculateAffectedPackages(changedPackages, allPackages) : changedPackages;
-        if (dryRun) {
-            console.log(`🔄 需要发布的包（含依赖传递）: ${packagesToPublish.map((p)=>p.name).join(", ") || "无"}`);
+        if (!branch) {
+            throw new Error("缺少配置 ci.refName (环境变量 GITHUB_REF_NAME)");
         }
-        // 拓扑排序
-        const sortedPackages = this.topologicalSort(packagesToPublish, allPackages);
-        if (dryRun) {
-            console.log(`📋 发布顺序: ${sortedPackages.map((p)=>p.name).join(" -> ") || "无"}`);
+        const [owner, repo] = repository.split("/");
+        if (!owner || !repo) {
+            throw new Error(`ci.repository 格式不正确，期望 "owner/repo"，实际: "${repository}"`);
         }
         return {
-            changedPackages,
-            packagesToPublish: sortedPackages
+            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);
+    }
     /**
-   * 简单解析 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;
+   * 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);
             }
-            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;
-                }
+            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 发布失败"
+            };
         }
-        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 文件");
+   * 发布单个包（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 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);
+        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);
         }
     }
     /**
@@ -887,274 +611,402 @@ class PublishService {
         }
     }
     /**
-   * 同步解锁分支（用于进程退出时的清理）
-   */ unlockBranchSync(context, publishConf) {
-        const { owner, repo, branch, dryRun } = context;
-        const shouldLockBranch = publishConf.git?.lockBranch ?? true;
-        if (!shouldLockBranch || dryRun) {
-            return;
+   * 同步解锁分支（用于进程退出时的清理）
+   */ 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");
+        }
+    }
+}
+
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(421);
+;// CONCATENATED MODULE: ./src/monorepo.service.ts
+
+
+
+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}`);
+            }
         }
-        this.gitProvider.unlockBranchSync(owner, repo, branch);
+        return changedPackages;
     }
     /**
-   * 确保 git tags 已获取（CI 环境中 shallow clone 可能缺失 tags）
-   * 这对于 release-it 正确计算版本号至关重要
-   */ async ensureTagsFetched() {
+   * 检测单个包是否有变更（基于该包的最新 tag）
+   */ hasPackageChanges(pkg) {
         try {
-            // 检查是否有 tags
-            const existingTags = execSync("git tag --list 2>/dev/null || echo ''", {
+            // 获取该包的最新 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 (!existingTags) {
-                console.log("🏷️  正在获取 git tags...");
-                execSync("git fetch --tags --force", {
-                    stdio: "inherit"
-                });
-                console.log("✅ Git tags 已获取");
+            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.warn("⚠️ 获取 git tags 失败:", error instanceof Error ? error.message : error);
-            console.warn("   版本计算可能不准确，建议在 CI checkout 时添加 fetch-depth: 0 和 fetch-tags: true");
+            // 出错时保守处理，认为有变更
+            console.log(`📌 ${pkg.name}: 检测出错，保守处理为有变更`);
+            console.log(`    错误: ${error instanceof Error ? error.message : error}`);
+            return 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;
+    /**
+   * 将变更文件映射到包目录
+   */ 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;
     }
-    async run(_passedParams, options) {
-        if (options.rehearsal) {
-            console.log(core_t("publish:rehearsalMode"));
-        } else if (options.dryRun) {
-            console.log(core_t("publish:dryRunMode"));
+    /**
+   * 计算受影响的包（包含依赖传递）
+   */ 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);
+            }
         }
-        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);
+        // 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));
     }
-    parseDryRun(val) {
-        return val;
-    }
-    parseCi(val) {
-        return val;
-    }
-    parsePrerelease(val) {
-        return val;
-    }
-    parseRehearsal(val) {
-        return val;
+    /**
+   * 拓扑排序：被依赖的包先发布
+   */ 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;
     }
 }
-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 = {
+
+const extension = defineExtension({
     name: "publish",
-    commands: [
-        "publish"
-    ],
+    version: "1.0.0",
+    description: core_t("publish:extensionDescription"),
     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);
-
-
-
-
+    commands: [
+        {
+            name: "publish",
+            description: core_t("publish:description"),
+            options: [
+                {
+                    flags: "-d, --dry-run",
+                    description: core_t("common.options.dryRun")
+                },
+                {
+                    flags: "-c, --ci",
+                    description: core_t("common.options.ci")
+                },
+                {
+                    flags: "-p, --prerelease <tag>",
+                    description: core_t("publish:options.prerelease")
+                },
+                {
+                    flags: "-r, --rehearsal",
+                    description: core_t("publish:options.rehearsal")
+                }
+            ],
+            run: async (_args, options, ctx)=>{
+                const gitProvider = ctx.getService("gitProvider");
+                const configReader = ctx.getService("config");
+                if (!gitProvider) {
+                    ctx.output.error("publish 命令需要配置 Git Provider");
+                    process.exit(1);
+                }
+                const monorepoService = new MonorepoService();
+                const publishService = new PublishService(gitProvider, ctx.config, configReader, monorepoService);
+                const publishOptions = {
+                    dryRun: !!options?.dryRun,
+                    ci: !!options?.ci,
+                    prerelease: options?.prerelease,
+                    rehearsal: !!options?.rehearsal
+                };
+                if (publishOptions.rehearsal) {
+                    console.log(core_t("publish:rehearsalMode"));
+                } else if (publishOptions.dryRun) {
+                    console.log(core_t("publish:dryRunMode"));
+                }
+                try {
+                    const context = publishService.getContextFromEnv(publishOptions);
+                    await publishService.execute(context);
+                } catch (error) {
+                    ctx.output.error(core_t("common.executionFailed", {
+                        error: error instanceof Error ? error.message : error
+                    }));
+                    process.exit(1);
+                }
+            }
+        }
+    ]
+});
+/* export default */ const src = (extension);
 
 })();
 
-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 };
+var __webpack_exports__default = __webpack_exports__.A;
+var __webpack_exports__extension = __webpack_exports__.c;
+export { __webpack_exports__default as default, __webpack_exports__extension as extension };