semantic-release-minecraft 1.0.0

package/src/modrinth.ts

@@ -0,0 +1,316 @@
+import axios from 'axios';
+import FormData from 'form-data';
+import { readFile } from 'fs/promises';
+import { glob } from 'glob';
+import { template } from 'lodash';
+import { resolve } from 'path';
+import { PublishContext } from 'semantic-release';
+import { Plugin_config } from './definitions/plugin_config';
+import {
+    findFiles,
+    renderTemplates,
+    resolveTemplate,
+    toArray,
+} from './utils/utils';
+
+/**
+ * 发布到 Modrinth
+ */
+export async function publishToModrinth(
+    pluginConfig: Plugin_config,
+    context: PublishContext
+): Promise<string> {
+    const { env, logger } = context;
+    const { modrinth } = pluginConfig;
+    const token = env.MODRINTH_TOKEN!;
+    const projectId = modrinth?.project_id!;
+    const nextRelease = context.nextRelease;
+    const nextReleaseVersion = nextRelease.version;
+
+    // 查找文件并确定主要文件
+    const { files, primaryFile } = await findModrinthJarFiles(
+        pluginConfig,
+        context
+    );
+    logger.log(
+        `Publishing ${files.length} file(s) to Modrinth project ${projectId}...`
+    );
+
+    // 使用 multipart/form-data 方式上传文件和版本信息
+    const form = new FormData();
+    const filePartNames: string[] = [];
+    let primaryFilePartName: string | undefined = undefined;
+
+    // 上传所有文件
+    for (let i = 0; i < files.length; i++) {
+        const jarPath = files[i];
+        const jarFile = await readFile(jarPath);
+        const fileName = jarPath.split('\\').pop() || `mod-${i}.jar`;
+        const filePartName = `file-${i}`;
+
+        form.append(filePartName, jarFile, { filename: fileName });
+        filePartNames.push(filePartName);
+
+        // 标记主要文件
+        if (jarPath === primaryFile) {
+            primaryFilePartName = filePartName;
+        }
+    }
+
+    // 使用根据primaryFileGlob确定的主要文件
+    const finalPrimaryFile: string | undefined = primaryFilePartName;
+
+    // 准备版本信息，只包含必需字段和存在的可选字段
+    // displayName按照优先级：平台特定配置 > 全局配置 > 平台特定环境变量 > 全局环境变量
+    let displayName: string | undefined;
+    if (modrinth?.display_name) {
+        displayName = template(modrinth.display_name)(nextRelease) as string;
+    } else if (pluginConfig.display_name) {
+        displayName = template(pluginConfig.display_name)(
+            nextRelease
+        ) as string;
+    } else if (env.MODRINTH_DISPLAY_NAME) {
+        displayName = env.MODRINTH_DISPLAY_NAME;
+    } else if (env.DISPLAY_NAME) {
+        displayName = env.DISPLAY_NAME;
+    }
+
+    // version_number 按照优先级：平台特定配置 > 平台特定环境变量 > 全局环境变量
+    const versionNumber = resolveTemplate(
+        [modrinth?.version_number, env.MODRINTH_VERSION_NUMBER],
+        nextRelease
+    );
+
+    // 准备版本信息，只包含必需字段和存在的可选字段
+    const versionData: any = {
+        project_id: projectId,
+        file_parts: filePartNames, // 必需字段，列出所有文件部分的名称
+    };
+
+    // 只有找到值时才添加 name 字段
+    if (displayName) {
+        versionData.name = displayName;
+    } else {
+        // 如果没有找到任何配置，使用默认值
+        versionData.name = context.nextRelease.name;
+    }
+
+    // 只有找到值时才添加 version_number 字段
+    if (versionNumber) {
+        versionData.version_number = versionNumber;
+    } else {
+        // 如果没有找到任何配置，使用默认值
+        versionData.version_number = nextReleaseVersion;
+    }
+
+    // 只添加存在的可选字段
+    if (modrinth?.changelog || context.nextRelease?.notes) {
+        versionData.changelog =
+            modrinth?.changelog || context.nextRelease?.notes || '';
+    }
+
+    if (modrinth?.game_versions && modrinth.game_versions.length > 0) {
+        versionData.game_versions = renderTemplates(modrinth.game_versions, {
+            nextRelease,
+        }) as string[];
+    } else if (
+        pluginConfig.game_versions &&
+        pluginConfig.game_versions.length > 0
+    ) {
+        versionData.game_versions = renderTemplates(
+            toArray(pluginConfig.game_versions),
+            {
+                nextRelease,
+            }
+        ) as string[];
+    }
+
+    // modLoaders 按照优先级：平台特定配置 > 全局配置 > 平台特定环境变量 > 全局环境变量
+    let modLoaders: string[] | undefined;
+    if (modrinth?.mod_loaders && modrinth.mod_loaders.length > 0) {
+        modLoaders = renderTemplates(modrinth.mod_loaders, {
+            nextRelease,
+        }) as string[];
+    } else if (
+        pluginConfig.mod_loaders &&
+        pluginConfig.mod_loaders.length > 0
+    ) {
+        modLoaders = renderTemplates(toArray(pluginConfig.mod_loaders), {
+            nextRelease,
+        }) as string[];
+    } else if (env.MODRINTH_MOD_LOADERS) {
+        modLoaders = env.MODRINTH_MOD_LOADERS.split(',').map((s) => s.trim());
+    } else if (env.MOD_LOADERS) {
+        modLoaders = env.MOD_LOADERS.split(',').map((s) => s.trim());
+    }
+
+    if (modLoaders) {
+        versionData.loaders = modLoaders;
+    }
+
+    if (pluginConfig.release_type) {
+        versionData.version_type = pluginConfig.release_type;
+    }
+
+    if (modrinth?.dependencies && modrinth.dependencies.length > 0) {
+        versionData.dependencies = modrinth.dependencies;
+    }
+
+    if (modrinth?.featured !== undefined) {
+        versionData.featured = modrinth.featured;
+    }
+
+    if (modrinth?.status) {
+        versionData.status = modrinth.status;
+    }
+
+    if (modrinth?.requested_status) {
+        versionData.requested_status = modrinth.requested_status;
+    }
+
+    // 只有当 finalPrimaryFile 存在时才添加 primary_file 字段
+    if (finalPrimaryFile) {
+        versionData.primary_file = finalPrimaryFile;
+    }
+
+    // 添加版本信息作为 JSON
+    form.append('data', JSON.stringify(versionData));
+
+    // 发送版本创建请求
+    try {
+        const versionResponse = await axios.post(
+            'https://api.modrinth.com/v2/version',
+            form,
+            {
+                headers: {
+                    ...form.getHeaders(),
+                    Authorization: token,
+                },
+                validateStatus: (status) => status < 500, // 仅拒绝5xx错误
+            }
+        );
+
+        // 检查响应状态码
+        if (versionResponse.status === 200) {
+            // 成功
+            logger.log(
+                `Successfully published to Modrinth: ${versionResponse.data.name || versionResponse.data.id}`
+            );
+            return versionResponse.data.id;
+        } else if (
+            versionResponse.status === 400 ||
+            versionResponse.status === 401
+        ) {
+            // 处理客户端错误
+            const data = versionResponse.data;
+            if (data && data.error && data.description) {
+                logger.error(
+                    `Modrinth API Error (${versionResponse.status}): ${data.error} - ${data.description}`
+                );
+                throw new Error(
+                    `Modrinth发布失败: ${data.error} - ${data.description}`
+                );
+            } else {
+                logger.error(
+                    `Modrinth API Error (${versionResponse.status}): ${JSON.stringify(data)}`
+                );
+                throw new Error(
+                    `Modrinth发布失败 (状态码: ${versionResponse.status}): ${JSON.stringify(data)}`
+                );
+            }
+        } else {
+            // 其他错误状态码
+            const data = versionResponse.data;
+            logger.error(
+                `Modrinth API Error (${versionResponse.status}): ${JSON.stringify(data)}`
+            );
+            throw new Error(
+                `Modrinth发布失败 (状态码: ${versionResponse.status}): ${JSON.stringify(data)}`
+            );
+        }
+    } catch (error: any) {
+        if (error.response) {
+            // 已经在上面处理过
+            throw error;
+        } else if (error.request) {
+            // 请求已发送但未收到响应
+            logger.error('Modrinth API 请求失败，未收到响应');
+            throw new Error('Modrinth发布失败: 未收到服务器响应');
+        } else {
+            // 请求配置出错
+            logger.error('Modrinth API 请求配置错误:', error.message);
+            throw new Error(`Modrinth发布失败: ${error.message}`);
+        }
+    }
+}
+
+/**
+ * 为 Modrinth 查找文件并确定主要文件
+ */
+async function findModrinthJarFiles(
+    pluginConfig: Plugin_config,
+    context: PublishContext
+): Promise<{ files: string[]; primaryFile: string | undefined }> {
+    const { logger } = context;
+
+    // 获取 Modrinth 专用的 glob 配置，如果没有则使用全局配置
+    const modrinthGlob = pluginConfig.modrinth?.glob || pluginConfig.glob || [];
+
+    // 查找所有文件
+    const jarFiles = await findFiles(modrinthGlob, context);
+    logger.log(
+        `Found ${jarFiles.length} JAR file(s) for Modrinth: ${jarFiles.join(', ')}`
+    );
+
+    // 确定主要文件
+    let primaryFile: string | undefined = undefined;
+
+    // 检查是否提供了 primaryFileGlob
+    if (pluginConfig.modrinth?.primary_file_glob) {
+        const primaryPatterns = Array.isArray(
+            pluginConfig.modrinth.primary_file_glob
+        )
+            ? pluginConfig.modrinth.primary_file_glob
+            : [pluginConfig.modrinth.primary_file_glob];
+
+        // 查找匹配 primaryFileGlob 的文件
+        let primaryCandidates: string[] = [];
+
+        for (const pattern of primaryPatterns) {
+            logger.log(`Searching for primary file with pattern: ${pattern}`);
+            const matches = await glob(pattern, {
+                cwd: context.cwd,
+                nodir: true,
+            });
+            primaryCandidates.push(
+                ...matches.map((file) => resolve(context.cwd!, file))
+            );
+        }
+
+        // 过滤出 JAR 文件并与找到的文件列表交叉检查
+        primaryCandidates = primaryCandidates
+            .filter((file) => file.endsWith('.jar'))
+            .filter((file) => jarFiles.includes(file));
+
+        if (primaryCandidates.length === 1) {
+            primaryFile = primaryCandidates[0];
+            logger.log(`Selected primary file for Modrinth: ${primaryFile}`);
+        } else if (primaryCandidates.length > 1) {
+            throw new Error(
+                `Multiple files matched primaryFileGlob for Modrinth. Please specify a more specific pattern. Found: ${primaryCandidates.join(', ')}`
+            );
+        } else {
+            throw new Error(
+                `No files matched primaryFileGlob for Modrinth that were also in the main file list.`
+            );
+        }
+    } else if (jarFiles.length > 1) {
+        // 当有多个文件但没有指定 primaryFileGlob 时，需要指定主要文件
+        throw new Error(
+            `Multiple files found for Modrinth but no primaryFileGlob specified. Please specify which file should be primary.`
+        );
+    }
+    // 当只有一个文件时，不设置 primaryFile，让网站做决定
+
+    return { files: jarFiles, primaryFile };
+}

package/src/prepare.ts

@@ -0,0 +1,199 @@
+import axios from 'axios';
+import { NextRelease } from 'semantic-release';
+import {
+    BUKKIT_GAME_VERSION_TYPE,
+    CurseForgeGameVersion,
+    CurseForgeGameVersionMap,
+    CurseForgeGameVersionType,
+} from './definitions/curseforge';
+import { Plugin_config } from './definitions/plugin_config';
+import { getCurseForgeModLoaders, toArray } from './utils/utils';
+
+/**
+ * 根据提供的游戏版本联合对象检索游戏版本 ID 变体数组。
+ */
+export async function getCurseForgeGameVersionIds(
+    apiToken: string,
+    pluginConfig: Plugin_config,
+    env: Record<string, string>,
+    nextRelease: NextRelease
+): Promise<number[]> {
+    const curseforgeConfig = pluginConfig.curseforge!;
+
+    const modLoaders = getCurseForgeModLoaders(pluginConfig, env, nextRelease);
+    const javaVersions = toArray(curseforgeConfig.java_versions || []);
+    const gameVersions = toArray(
+        curseforgeConfig.game_versions || pluginConfig.game_versions || []
+    );
+    const pluginGameVersions = toArray(
+        curseforgeConfig.game_versions_for_plugins || []
+    );
+    const addonGameVersions = toArray(
+        curseforgeConfig.game_versions_for_addon || []
+    );
+    const environments = toArray(curseforgeConfig.environments || []);
+
+    const map = await createCurseForgeGameVersionMap(apiToken);
+
+    const javaVersionNames = javaVersions.map(
+        (javaVersion: string) => `Java ${javaVersion}`
+    );
+
+    // TODO: Modrinth 和 CurseForge 的游戏版本命名格式转化，以 Modrinth 为基准
+    // const gameVersionNames = gameVersions.map(x => formatCurseForgeGameVersionSnapshot(x));
+
+    // 模组的游戏版本名称
+    const gameVersionIds = findCurseForgeGameVersionIdsByNames(
+        map.game_versions,
+        gameVersions,
+        undefined,
+        CURSEFORGE_GAME_VERSION_SNAPSHOT_NAME_COMPARER
+    );
+
+    const loaderIds = findCurseForgeGameVersionIdsByNames(
+        map.loaders,
+        modLoaders
+    );
+
+    const javaIds = findCurseForgeGameVersionIdsByNames(
+        map.java_versions,
+        javaVersionNames
+    );
+
+    // 插件的游戏版本名称
+    const pluginGameVersionIds = findCurseForgeGameVersionIdsByNames(
+        map.game_versions_for_plugins,
+        pluginGameVersions
+    );
+
+    // 附加组件的游戏版本名称
+    const addonGameVersionIds = findCurseForgeGameVersionIdsByNames(
+        map.game_versions_for_addons,
+        addonGameVersions
+    );
+
+    const environmentIds = findCurseForgeGameVersionIdsByNames(
+        map.environments,
+        environments
+    );
+
+    const curseforgeGameVersionIds: number[] = [];
+    curseforgeGameVersionIds.push(
+        ...gameVersionIds,
+        ...loaderIds,
+        ...javaIds,
+        ...pluginGameVersionIds,
+        ...addonGameVersionIds,
+        ...environmentIds
+    );
+    return curseforgeGameVersionIds;
+}
+
+// 创建一个 CurseForge 游戏版本映射，通过根据类型名称对游戏版本类型进行分类。
+async function createCurseForgeGameVersionMap(
+    apiToken: string
+): Promise<CurseForgeGameVersionMap> {
+    const { versions, types } = await fetchCurseForgeGameVersionInfo(apiToken);
+    return {
+        game_versions: filterGameVersionsByTypeName(
+            versions,
+            types,
+            'minecraft'
+        ),
+        game_versions_for_plugins: filterGameVersionsByTypeName(
+            versions,
+            types,
+            'bukkit'
+        ),
+        game_versions_for_addons: filterGameVersionsByTypeName(
+            versions,
+            types,
+            'addon'
+        ),
+        loaders: filterGameVersionsByTypeName(versions, types, 'modloader'),
+        java_versions: filterGameVersionsByTypeName(versions, types, 'java'),
+        environments: filterGameVersionsByTypeName(
+            versions,
+            types,
+            'environment'
+        ),
+    };
+}
+
+function filterGameVersionsByTypeName(
+    versions: CurseForgeGameVersion[],
+    types: CurseForgeGameVersionType[],
+    typeName: string
+): CurseForgeGameVersion[] {
+    const filteredTypes = types.filter((x) => x.slug.startsWith(typeName));
+    return versions.filter((v) =>
+        filteredTypes.some((t) => t.id === v.gameVersionTypeID)
+    );
+}
+
+// 获取 CurseForge 游戏版本和版本类型信息
+async function fetchCurseForgeGameVersionInfo(apiToken: string): Promise<{
+    versions: CurseForgeGameVersion[];
+    types: CurseForgeGameVersionType[];
+}> {
+    const gameVersionsRes = await axios.get(
+        'https://minecraft.curseforge.com/api/game/versions',
+        {
+            headers: {
+                'X-Api-Token': apiToken,
+            },
+        }
+    );
+
+    const gameVersionTypesRes = await axios.get(
+        'https://minecraft.curseforge.com/api/game/version-types',
+        {
+            headers: {
+                'X-Api-Token': apiToken,
+            },
+        }
+    );
+
+    const gameVersionTypes =
+        gameVersionTypesRes.data as CurseForgeGameVersionType[];
+
+    if (!gameVersionTypes.some((x) => x.id === BUKKIT_GAME_VERSION_TYPE.id)) {
+        gameVersionTypes.unshift(BUKKIT_GAME_VERSION_TYPE);
+    }
+
+    return {
+        versions: gameVersionsRes.data,
+        types: gameVersionTypes,
+    };
+}
+
+function findCurseForgeGameVersionIdsByNames(
+    versions: { id: number; name: string }[],
+    names: string[],
+    comparer: (a: string, b: string) => boolean = (a, b) =>
+        a.toLowerCase() === b.toLowerCase(),
+    fallbackComparer?: (a: string, b: string) => boolean
+): number[] {
+    const result: number[] = [];
+
+    for (const name of names) {
+        let version = versions.find((v) => comparer(v.name, name));
+        if (!version && fallbackComparer) {
+            version = versions.find((v) => fallbackComparer(v.name, name));
+        }
+        if (version) result.push(version.id);
+    }
+
+    return [...new Set(result)];
+}
+
+/**
+ * 比较器：忽略名称中的 "-Snapshot" 后缀
+ */
+export const CURSEFORGE_GAME_VERSION_SNAPSHOT_NAME_COMPARER = (
+    a: string,
+    b: string
+): boolean => {
+    const normalize = (s: string) => s?.replace(/-snapshot$/i, '') ?? '';
+    return normalize(a).toLowerCase() === normalize(b).toLowerCase();
+};

package/src/utils/utils.ts

@@ -0,0 +1,120 @@
+import { glob } from 'glob/dist/esm';
+import { template } from 'lodash';
+import { resolve } from 'path';
+import { NextRelease, PublishContext } from 'semantic-release';
+import { Plugin_config } from '../definitions/plugin_config';
+
+/**
+ * 根据 glob 模式查找文件
+ */
+export async function findFiles(
+    patterns: string | string[],
+    context: PublishContext,
+    defaultPatterns: string[] = [
+        'build/libs/!(*-@(dev|sources|javadoc)).jar',
+        'build/libs/*-@(dev|sources|javadoc).jar',
+    ]
+): Promise<string[]> {
+    const { logger, cwd } = context;
+
+    // 使用提供的 glob 模式，如果没有则使用默认模式
+    const searchPatterns = patterns
+        ? Array.isArray(patterns)
+            ? patterns
+            : [patterns]
+        : defaultPatterns;
+
+    const allFiles: string[] = [];
+
+    for (const pattern of searchPatterns) {
+        logger.log(`Searching for files with pattern: ${pattern}`);
+        const files = await glob(pattern, {
+            cwd,
+            nodir: true,
+        });
+        allFiles.push(...files);
+    }
+
+    // 转换为绝对路径
+    const files = allFiles.map((file) => resolve(cwd!, file));
+
+    if (files.length === 0) {
+        throw new Error(
+            `No files found matching patterns: ${searchPatterns.join(', ')}`
+        );
+    }
+
+    return files;
+}
+
+/**
+ * 依次使用 lodash.template 渲染字符串数组。
+ * @param templates 字符串模板数组
+ * @param context 模板变量上下文对象
+ * @returns 渲染后的字符串数组
+ */
+export function renderTemplates(
+    templates: string[],
+    context: Record<string, any>
+): string[] {
+    return templates.map((tpl) => template(tpl)(context));
+}
+
+/**
+ * 从多个来源中按优先级选择第一个非空模板并渲染。
+ * @param sources 模板字符串来源（优先级从高到低）
+ * @param context 模板渲染上下文（传给 lodash.template）
+ * @returns 渲染后的字符串或 undefined
+ */
+export function resolveTemplate(
+    sources: Array<string | undefined | null>,
+    context: Record<string, any>
+): string | undefined {
+    const source = sources.find(Boolean);
+    if (!source) return undefined;
+
+    try {
+        return template(source)(context);
+    } catch (err) {
+        console.error('Failed to render template:', err);
+        return undefined;
+    }
+}
+
+/**
+ * 确保给定的值总是以数组形式返回。
+ *
+ * @param value - 单个项目或项目数组。
+ * @returns 如果不是数组，则将值包装在数组中返回。
+ */
+export function toArray<T>(value: T | T[]): T[] {
+    return Array.isArray(value) ? value : [value];
+}
+
+export function getCurseForgeModLoaders(
+    pluginConfig: Plugin_config,
+    env: Record<string, string>,
+    nextRelease: NextRelease
+): string[] {
+    const curseforge = pluginConfig.curseforge;
+
+    let modLoaders: string[] | undefined;
+    if (curseforge?.mod_loaders && curseforge.mod_loaders.length > 0) {
+        modLoaders = renderTemplates(toArray(curseforge.mod_loaders), {
+            nextRelease,
+        });
+    } else if (
+        pluginConfig.mod_loaders &&
+        pluginConfig.mod_loaders.length > 0
+    ) {
+        modLoaders = renderTemplates(toArray(pluginConfig.mod_loaders), {
+            nextRelease,
+        }) as string[];
+    } else if (env.CURSEFORGE_MOD_LOADERS) {
+        modLoaders = env.CURSEFORGE_MOD_LOADERS.split(',').map((s) => s.trim());
+    } else if (env.MOD_LOADERS) {
+        modLoaders = env.MOD_LOADERS.split(',').map((s) => s.trim());
+    }
+
+    return modLoaders || [];
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ES2022",                // 产物使用的 JS 语言版本（现代 Node 推荐 ES2022/ES2023/ESNext）
+    "module": "ES2022",                // 输出为 ESM 模块语法（import / export）
+    "moduleResolution": "node",        // 如何根据 node 风格解析模块（node 或 bundler 友好）
+    "lib": ["ES2022"],                 // 编译时可用的内置类型（Promise, Map, etc.）
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,               // 生成 .d.ts 类型声明文件（发布库时强烈推荐）
+    "sourceMap": true,                 // 生成 source map，便于调试
+    "strict": true,                    // 启用一整套严格检查（等价开启多项 strict 选项）
+    "noImplicitAny": true,             // 不允许隐式 any
+    "esModuleInterop": true,           // 与 CommonJS 的互操作（允许 default 导入 commonjs 模块）
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,              // 跳过依赖声明的类型检查，显著加快编译并减少第三方问题
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,         // 允许 import .json
+    "moduleDetection": "force",        // 强制模块类型检测（TypeScript 5+ 的选项）
+    "types": ["node"],                 // 引入 node 全局类型（比如 process、Buffer）
+    "declarationMap": true             // 生成 declaration maps（对调试 d.ts 有帮助）
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "coverage"]
+}