semantic-release-minecraft 1.0.0

package/src/curseforge.ts

@@ -0,0 +1,192 @@
+import axios from 'axios';
+import FormData from 'form-data';
+import { readFile } from 'fs/promises';
+import { template } from 'lodash';
+import { PublishContext } from 'semantic-release';
+import { Plugin_config } from './definitions/plugin_config';
+import {
+    findFiles,
+    getCurseForgeModLoaders,
+    resolveTemplate,
+} from './utils/utils';
+
+/**
+ * 为 CurseForge 查找单个文件
+ */
+async function findFileCurseforge(
+    pluginConfig: Plugin_config,
+    context: PublishContext
+): Promise<string> {
+    const { logger } = context;
+    const version = context.nextRelease.version;
+
+    // 获取 CurseForge 的 glob 配置，如果没有则使用全局配置
+    const curseforgeGlob =
+        pluginConfig.curseforge?.glob || pluginConfig.glob || [];
+
+    // 查找文件
+    const files = await findFiles(curseforgeGlob, context);
+
+    // 如果只找到一个文件，直接返回
+    if (files.length === 1) {
+        logger.log(`Using the only found file for CurseForge: ${files[0]}`);
+        return files[0];
+    }
+
+    logger.log(
+        `Found ${files.length} files for CurseForge, trying to filter by version`
+    );
+
+    // 如果有版本号，尝试筛选包含版本号的文件
+    if (version) {
+        const versionedFiles = files.filter((file) => file.includes(version));
+        if (versionedFiles.length === 1) {
+            logger.log(
+                `Using versioned file for CurseForge: ${versionedFiles[0]}`
+            );
+            return versionedFiles[0];
+        } else if (versionedFiles.length > 1) {
+            throw new Error(
+                `Multiple files found containing version ${version} for CurseForge. Please specify a more specific glob pattern. Found: ${versionedFiles.join(', ')}`
+            );
+        }
+    }
+
+    // 如果无法筛选出单个文件，报错
+    throw new Error(
+        `Multiple files found for CurseForge but could not determine which to use. Found: ${files.join(', ')}`
+    );
+}
+
+export async function publishToCurseforge(
+    pluginConfig: Plugin_config,
+    context: PublishContext,
+    curseforgeGameVersionIds?: number[]
+): Promise<string> {
+    const { env, logger } = context;
+    const { curseforge } = pluginConfig;
+    const apiKey = env.CURSEFORGE_TOKEN!;
+    const projectId = curseforge!.project_id!;
+    const nextRelease = context.nextRelease;
+
+    // 查找单个文件
+    const filePath = await findFileCurseforge(pluginConfig, context);
+    logger.log(
+        `Publishing file ${filePath} to CurseForge project ${projectId}...`
+    );
+
+    const form = new FormData();
+    const file = await readFile(filePath);
+    form.append('file', file, {
+        filename: filePath.split('\\').pop() || 'mod.jar',
+    });
+
+    // 准备 metadata
+    // display_name 按照优先级：平台特定配置 > 全局配置 > 平台特定环境变量 > 全局环境变量
+    const displayName = resolveTemplate(
+        [
+            curseforge?.display_name,
+            pluginConfig.display_name,
+            env.CURSEFORGE_DISPLAY_NAME,
+            env.DISPLAY_NAME,
+        ],
+        nextRelease
+    );
+
+    // 准备基础 metadata
+    const metadata: any = {
+        gameVersions: curseforgeGameVersionIds,
+        releaseType: pluginConfig.release_type || 'release',
+        changelog: curseforge?.changelog || context.nextRelease.notes,
+        changelogType: curseforge?.changelog_type || 'markdown',
+    };
+
+    // 只有找到值时才添加 displayName
+    if (displayName) {
+        metadata.displayName = displayName;
+    } else {
+        // 如果没有找到任何配置，使用默认值
+        metadata.displayName = context.nextRelease.name;
+    }
+
+    // 添加 metadataModLoaders（如果有值）
+    const metadataModLoaders = getCurseForgeModLoaders(
+        pluginConfig,
+        env,
+        nextRelease
+    );
+    if (metadataModLoaders) {
+        metadata.modLoaders = metadataModLoaders;
+    }
+
+    // 只有当提供值时才添加这三个特定字段
+    if (curseforge?.parent_file_id !== undefined) {
+        metadata.parentFileID = curseforge.parent_file_id;
+    }
+
+    if (curseforge?.is_marked_for_manual_release !== undefined) {
+        metadata.isMarkedForManualRelease =
+            curseforge.is_marked_for_manual_release;
+    }
+
+    if (curseforge?.relations && Object.keys(curseforge.relations).length > 0) {
+        metadata.relations = curseforge.relations;
+    }
+
+    form.append('metadata', JSON.stringify(metadata));
+
+    try {
+        const response = await axios.post(
+            `https://upload.curseforge.com/api/projects/${projectId}/upload-file`,
+            form,
+            {
+                headers: {
+                    ...form.getHeaders(),
+                    'X-API-Key': apiKey,
+                },
+            }
+        );
+
+        // 验证返回的数据是否包含 id 字段
+        if (response.data && typeof response.data.id === 'number') {
+            logger.log(
+                `Successfully published to CurseForge: ${response.data.displayName || `File ID: ${response.data.id}`}`
+            );
+            return response.data.id.toString();
+        } else {
+            throw new Error(
+                `CurseForge API returned unexpected response: ${JSON.stringify(response.data)}`
+            );
+        }
+    } catch (error: any) {
+        if (error.response) {
+            // 服务器返回了错误响应
+            const status = error.response.status;
+            const data = error.response.data;
+
+            if (data && data.error && data.description) {
+                logger.error(
+                    `CurseForge API Error (${status}): ${data.error} - ${data.description}`
+                );
+                throw new Error(
+                    `CurseForge 发布失败：${data.error} - ${data.description}`
+                );
+            } else {
+                logger.error(
+                    `CurseForge API Error (${status}): ${JSON.stringify(data)}`
+                );
+                throw new Error(
+                    `CurseForge 发布失败 (状态码：${status}): ${JSON.stringify(data)}`
+                );
+            }
+        } else if (error.request) {
+            // 请求已发送但未收到响应
+            logger.error('CurseForge API 请求失败，未收到响应');
+            throw new Error('CurseForge 发布失败：未收到服务器响应');
+        } else {
+            // 请求配置出错
+            logger.error('CurseForge API 请求配置错误：', error.message);
+            throw new Error(`CurseForge 发布失败：${error.message}`);
+        }
+    }
+}

package/src/definitions/curseforge.ts

@@ -0,0 +1,51 @@
+export interface CurseForgeGameVersion {
+    id: number;
+    gameVersionTypeID: number;
+    name: string;
+    slug: string;
+    url: string;
+}
+
+export interface CurseForgeGameVersionType {
+    id: number;
+    name: string;
+    slug: string;
+}
+
+export interface CurseForgeGameVersionMap {
+    /**
+     * Minecraft 游戏版本的数组。
+     */
+    game_versions: CurseForgeGameVersion[];
+
+    /**
+     * 主要用于 Bukkit 插件的游戏版本数组。
+     */
+    game_versions_for_plugins: CurseForgeGameVersion[];
+
+    /**
+     * 附加组件的游戏版本数组。
+     */
+    game_versions_for_addons: CurseForgeGameVersion[];
+
+    /**
+     * Java 版本的数组。
+     */
+    java_versions: CurseForgeGameVersion[];
+
+    /**
+     * 模组加载器的游戏版本数组。
+     */
+    loaders: CurseForgeGameVersion[];
+
+    /**
+     * 不同环境的游戏版本数组。
+     */
+    environments: CurseForgeGameVersion[];
+}
+
+export const BUKKIT_GAME_VERSION_TYPE: CurseForgeGameVersionType = {
+    id: 1,
+    name: 'Bukkit',
+    slug: 'bukkit',
+};

package/src/definitions/plugin_config.ts

@@ -0,0 +1,68 @@
+export type Plugin_config = {
+    // 全局发布相关配置
+    release_type?: 'alpha' | 'beta' | 'release'; // 全局发布类型
+    game_versions?: string | string[]; // 全局游戏版本列表
+    mod_loaders?: string | string[]; // 全局模组加载器列表
+    display_name?: string;
+
+    // 全局文件查找相关配置（如果平台没有指定自己的 glob，则使用此配置）
+    glob?: string | string[]; // glob 模式，用于查找要发布的文件
+
+    // Minecraft 发布相关配置
+    curseforge?: {
+        project_id: string;
+        game_versions?: string | string[]; // CurseForge 专用的游戏版本列表
+        java_versions?: string | string[];
+        environments?: string | string[];
+        game_versions_for_plugins?: string | string[];
+        game_versions_for_addon?: string | string[];
+        mod_loaders?: string | string[]; // CurseForge 专用的模组加载器列表
+        changelog?: string;
+        changelog_type?: 'text' | 'html' | 'markdown';
+        display_name?: string; // 可选：网站上显示的友好名称
+        parent_file_id?: number; // 可选：此文件的父文件 ID
+        is_marked_for_manual_release?: boolean; // 可选：如果为 true，文件获批后不会立即发布
+        relations?: {
+            projects?: Array<{
+                slug: string; // 相关插件的 slug
+                project_id?: string; // 可选：用于精确匹配项目
+                type:
+                    | 'embedded_library'
+                    | 'incompatible'
+                    | 'optional_dependency'
+                    | 'required_dependency'
+                    | 'tool';
+            }>;
+        };
+        glob?: string | string[]; // CurseForge 专用的 glob 模式，用于查找要发布的 JAR 文件
+    };
+    modrinth?: {
+        project_id: string;
+        version_number?: string;
+        display_name?: string;
+        game_versions?: string[]; // Modrinth 专用的游戏版本列表
+        mod_loaders?: string[]; // Modrinth 专用的模组加载器列表
+        changelog?: string;
+        dependencies?: Array<{
+            version_id?: string; // 可选：依赖版本的 ID
+            project_id?: string; // 可选：依赖项目的 ID
+            file_name?: string; // 可选：依赖的文件名
+            dependency_type:
+                | 'required'
+                | 'optional'
+                | 'incompatible'
+                | 'embedded'; // 依赖类型
+        }>;
+        featured?: boolean; // 是否标记为特色版本
+        status?:
+            | 'listed'
+            | 'archived'
+            | 'draft'
+            | 'unlisted'
+            | 'scheduled'
+            | 'unknown'; // 版本状态
+        requested_status?: 'listed' | 'archived' | 'draft' | 'unlisted'; // 请求的状态
+        glob?: string | string[]; // Modrinth 专用的 glob 模式
+        primary_file_glob?: string | string[]; // 用于匹配主要文件的 glob 模式
+    };
+};

package/src/index.ts

@@ -0,0 +1,98 @@
+import {
+    PrepareContext,
+    PublishContext,
+    VerifyConditionsContext,
+} from 'semantic-release';
+import { publishToCurseforge } from './curseforge';
+import { Plugin_config } from './definitions/plugin_config';
+import { publishToModrinth } from './modrinth';
+import { getCurseForgeGameVersionIds } from './prepare';
+
+// 模块级变量存储 CurseForge 版本映射
+let curseforgeGameVersionsIds: number[] | undefined;
+
+export async function verifyConditions(
+    pluginConfig: Plugin_config,
+    context: VerifyConditionsContext
+) {
+    // 验证配置：只检查 project_id，token 通过环境变量验证
+    if (pluginConfig.curseforge && !pluginConfig.curseforge.project_id) {
+        throw new Error('CurseForge project ID is required');
+    }
+
+    if (pluginConfig.modrinth && !pluginConfig.modrinth.project_id) {
+        throw new Error('Modrinth project ID is required');
+    }
+}
+
+export async function prepare(
+    pluginConfig: Plugin_config,
+    context: PrepareContext
+) {
+    const { env, logger } = context;
+
+    if (env.CURSEFORGE_TOKEN) {
+        const apiKey = env.CURSEFORGE_TOKEN;
+        try {
+            logger.log('Fetching CurseForge game versions and types...');
+
+            // 创建版本映射并存储在模块级变量中供后续使用
+            curseforgeGameVersionsIds = await getCurseForgeGameVersionIds(
+                apiKey,
+                pluginConfig.curseforge!,
+                env,
+                context.nextRelease
+            );
+
+            logger.log(
+                `Successfully transform ${Object.keys(curseforgeGameVersionsIds).length} CurseForge game versions`
+            );
+        } catch (error) {
+            logger.warn(
+                `Failed to fetch CurseForge game versions: ${error instanceof Error ? error.message : 'Unknown error'}`
+            );
+        }
+    }
+}
+
+export async function publish(
+    pluginConfig: Plugin_config,
+    context: PublishContext
+): Promise<{ url: string }[]> {
+    const { env, logger } = context;
+    const results: { url: string }[] = [];
+
+    try {
+        if (env.CURSEFORGE_TOKEN) {
+            const curseforgeId = await publishToCurseforge(
+                pluginConfig,
+                context,
+                curseforgeGameVersionsIds
+            );
+            results.push({
+                url: `https://www.curseforge.com/minecraft/mc-mods/${pluginConfig.curseforge!.project_id}/files/${curseforgeId}`,
+            });
+        } else {
+            logger.log(
+                'CurseForge publishing is skipped: CURSEFORGE_TOKEN environment variable not found.'
+            );
+        }
+
+        // 发布到 Modrinth（如果配置了 Modrinth 且存在环境变量）
+        if (env.MODRINTH_TOKEN) {
+            const modrinthId = await publishToModrinth(pluginConfig, context);
+            results.push({
+                url: `https://modrinth.com/mod/${pluginConfig.modrinth!.project_id}/version/${modrinthId}`,
+            });
+        } else {
+            logger.log(
+                'Modrinth publishing is skipped: MODRINTH_TOKEN environment variable not found.'
+            );
+        }
+
+        return results;
+    } catch (error) {
+        logger.error('Failed to publish:', error);
+        throw error;
+    }
+}