@rynt/sdk 0.9.53

package/src/shared/mods/providers/modrinth.ts

@@ -0,0 +1,402 @@
+import type { Mod, ResourcePack, ShaderPack } from '../../minecraft-types/build-manifest';
+import { httpGet } from '../http';
+import type { ModMarketplaceProvider } from '../mod-marketplace-types';
+import { getMarketplaceLoaderIds } from '../resolve-mods-provider-loader-ids';
+import type {
+  InstallContext,
+  MarketplaceInstallVersion,
+  MarketplaceItem,
+  MarketplaceSearchContext,
+  MarketplaceSearchResult,
+  ProjectType,
+  ProjectDetails,
+} from '../types';
+import { MARKETPLACE_SEARCH_PAGE_SIZE } from '../types';
+import { marked } from 'marked';
+
+const MODRINTH_PROVIDER_ID = 'modrinth';
+
+const MODRINTH_BASE = 'https://api.modrinth.com/v2';
+
+type ModrinthSearchHit = {
+  project_id: string;
+  slug: string;
+  title: string;
+  description: string;
+  icon_url?: string;
+  downloads?: number;
+};
+
+type ModrinthSearchResponse = {
+  hits: ModrinthSearchHit[];
+  offset?: number;
+  limit?: number;
+  total_hits?: number;
+};
+
+type ModrinthVersionFile = {
+  url: string;
+  filename: string;
+  primary?: boolean;
+  size: number;
+  hashes: {
+    sha1?: string;
+    sha512?: string;
+  };
+};
+
+type ModrinthVersionDependency = {
+  dependency_type: 'required' | 'optional' | 'incompatible' | 'embedded';
+  project_id?: string;
+};
+
+type ModrinthProjectVersion = {
+  id: string;
+  version_number: string;
+  date_published?: string;
+  files: ModrinthVersionFile[];
+  dependencies?: ModrinthVersionDependency[];
+};
+
+function modrinthFacets(ctx: MarketplaceSearchContext): string {
+  const facets: string[][] = [];
+  const projectType = ctx.projectType === 'shaderpack' ? 'shader' : ctx.projectType;
+  facets.push([`project_type:${projectType}`]);
+  if (ctx.minecraftVersion) {
+    facets.push([`versions:${ctx.minecraftVersion}`]);
+  }
+  // Resource packs and shader packs don't depend on mod loader, so don't filter by loader
+  if (
+    ctx.projectType !== 'resourcepack' &&
+    ctx.projectType !== 'shaderpack'
+  ) {
+    const loaderIds = getMarketplaceLoaderIds(ctx, MODRINTH_PROVIDER_ID);
+    if (loaderIds.length) {
+      // OR-группа: fabric OR quilt OR forge...
+      facets.push(loaderIds.map((id) => `categories:${id}`));
+    }
+  }
+  return JSON.stringify(facets);
+}
+
+export async function modrinthSearch(
+  ctx: MarketplaceSearchContext,
+): Promise<MarketplaceSearchResult> {
+  const page = ctx.page ?? 0;
+  const limit = MARKETPLACE_SEARCH_PAGE_SIZE;
+  const offset = page * limit;
+
+  const data = await httpGet<ModrinthSearchResponse>(
+    `${MODRINTH_BASE}/search`,
+    {
+      params: {
+        query: ctx.query,
+        facets: modrinthFacets(ctx),
+        limit,
+        offset,
+        index: 'relevance',
+      },
+    },
+  );
+
+  const hits = data.hits ?? [];
+  const items = hits.map((h) => ({
+    provider: 'modrinth' as const,
+    projectType: ctx.projectType,
+    projectId: h.project_id,
+    slug: h.slug,
+    name: h.title,
+    summary: h.description,
+    iconUrl: h.icon_url,
+    downloads: h.downloads,
+  }));
+
+  const totalHits = data.total_hits;
+  const hasMore =
+    typeof totalHits === 'number'
+      ? offset + hits.length < totalHits
+      : hits.length === limit;
+
+  return { items, hasMore };
+}
+
+async function modrinthGetCompatibleVersions(
+  projectId: string,
+  ctx: InstallContext,
+): Promise<ModrinthProjectVersion[]> {
+  const params: Record<string, string> = {};
+  if (ctx.minecraftVersion)
+    params.game_versions = JSON.stringify([ctx.minecraftVersion]);
+  if (
+    ctx.projectType !== 'resourcepack' &&
+    ctx.projectType !== 'shaderpack'
+  ) {
+    const loaderIds = getMarketplaceLoaderIds(ctx, MODRINTH_PROVIDER_ID);
+    if (loaderIds.length) {
+      params.loaders = JSON.stringify(loaderIds);
+    }
+  }
+
+  const data = await httpGet<ModrinthProjectVersion[]>(
+    `${MODRINTH_BASE}/project/${encodeURIComponent(projectId)}/version`,
+    { params },
+  );
+  if (!data?.length) {
+    throw new Error('No compatible versions found on Modrinth');
+  }
+  return data;
+}
+
+function pickPrimaryFile(files: ModrinthVersionFile[]): ModrinthVersionFile {
+  const primary = files.find((f) => f.primary);
+  return primary ?? files[0];
+}
+
+/**
+ * Convert Modrinth dependencies to Mod dependencies
+ * Note: This function needs to fetch project details to get slug
+ * For now, we'll return dependencies with modId only, and fetch slug/version during install
+ */
+async function toDependencies(
+  deps: ModrinthVersionDependency[] | undefined,
+  ctx: InstallContext,
+): Promise<Mod['dependencies']> {
+  if (!deps?.length) return [];
+
+  const result: Mod['dependencies'] = [];
+
+  for (const dep of deps) {
+    if (
+      !dep.project_id ||
+      (dep.dependency_type !== 'required' &&
+        dep.dependency_type !== 'incompatible')
+    ) {
+      continue;
+    }
+
+    try {
+      // Fetch project details to get slug
+      const projectDetails = await modrinthGetProjectDetails(dep.project_id);
+
+      result.push({
+        type: dep.dependency_type,
+        source: 'modrinth',
+        modId: dep.project_id,
+        slug: projectDetails.slug,
+        version: '', // Empty string means "any version" - Modrinth API doesn't provide version requirement
+      });
+    } catch (e) {
+      console.warn(
+        `[modrinth] Failed to get project details for dependency ${dep.project_id}:`,
+        e,
+      );
+      // Fallback: use project_id as slug
+      result.push({
+        type: dep.dependency_type,
+        source: 'modrinth',
+        modId: dep.project_id,
+        slug: dep.project_id,
+        version: '', // Empty string - don't use fallback version of the mod itself
+      });
+    }
+  }
+
+  return result;
+}
+
+export async function modrinthGetInstallVersions(
+  projectId: string,
+  ctx: InstallContext,
+): Promise<MarketplaceInstallVersion[]> {
+  const versions = await modrinthGetCompatibleVersions(projectId, ctx);
+  return versions.map((version, index) => ({
+    id: version.id,
+    label: version.version_number,
+    publishedAt: version.date_published,
+    recommended: index === 0,
+  }));
+}
+
+export async function modrinthInstallToManifestEntry(
+  item: MarketplaceItem,
+  ctx: InstallContext,
+  selectedVersionId?: string,
+): Promise<Mod | ResourcePack | ShaderPack> {
+  const versions = await modrinthGetCompatibleVersions(item.projectId, ctx);
+  const version = selectedVersionId
+    ? versions.find((v) => v.id === selectedVersionId)
+    : versions[0];
+  if (!version) {
+    throw new Error('Selected Modrinth version not found');
+  }
+  const file = pickPrimaryFile(version.files ?? []);
+  const sha1 = file?.hashes?.sha1;
+  if (!sha1) {
+    throw new Error('Modrinth file does not contain sha1 hash');
+  }
+
+  const fileEntry = {
+    type: 'primary' as const,
+    filename: file.filename,
+    path:
+      ctx.projectType === 'resourcepack'
+        ? `resourcepacks/${file.filename}`
+        : ctx.projectType === 'shaderpack'
+          ? `shaderpacks/${file.filename}`
+          : `mods/${file.filename}`,
+    size: file.size,
+    hashes: { sha1 },
+    urls: [file.url],
+    side: 'both' as const,
+  };
+
+  if (ctx.projectType === 'resourcepack') {
+    const rp: ResourcePack = {
+      source: 'modrinth',
+      id: item.projectId,
+      name: item.name,
+      projectSlug: item.slug,
+      version: version.version_number,
+      image: item.iconUrl,
+      constraints: {
+        minecraft: ctx.minecraftVersion,
+      },
+      files: [fileEntry],
+    };
+    return rp;
+  }
+
+  if (ctx.projectType === 'shaderpack') {
+    const sp: ShaderPack = {
+      source: 'modrinth',
+      id: item.projectId,
+      name: item.name,
+      projectSlug: item.slug,
+      version: version.version_number,
+      image: item.iconUrl,
+      constraints: {
+        minecraft: ctx.minecraftVersion,
+      },
+      files: [fileEntry],
+    };
+    return sp;
+  }
+
+  const mod: Mod = {
+    source: 'modrinth',
+    id: item.projectId, // Use projectId (provider-specific ID) for id
+    name: item.name,
+    projectSlug: item.slug, // Use slug for projectSlug
+    image: item.iconUrl,
+    version: version.version_number,
+    constraints: {
+      minecraft: ctx.minecraftVersion,
+      loader: ctx.loader,
+    },
+    files: [fileEntry],
+    dependencies: await toDependencies(version.dependencies, ctx),
+  };
+  return mod;
+}
+
+type ModrinthProject = {
+  id: string;
+  slug: string;
+  title: string;
+  description?: string;
+  body?: string;
+  icon_url?: string;
+  downloads?: number;
+  categories?: string[];
+  client_side?: 'required' | 'optional' | 'unsupported';
+  server_side?: 'required' | 'optional' | 'unsupported';
+  project_type: 'mod' | 'modpack' | 'resourcepack' | 'plugin' | 'shader';
+  author?: string;
+  team?: string;
+  published?: string;
+  updated?: string;
+  approved?: string;
+  status?: string;
+  license?: {
+    id?: string;
+    name?: string;
+    url?: string;
+  };
+  gallery?: Array<{ url?: string; featured?: boolean }>;
+  color?: number;
+  thread_id?: string;
+  monetization_status?: string;
+  project_id?: string;
+  follows?: number;
+  versions?: string[];
+};
+
+export async function modrinthGetProjectDetails(
+  projectIdOrSlug: string,
+): Promise<ProjectDetails> {
+  const data = await httpGet<ModrinthProject>(
+    `${MODRINTH_BASE}/project/${encodeURIComponent(projectIdOrSlug)}`,
+  );
+
+  // Parse Markdown to HTML if body exists
+  let descriptionHtml: string | undefined;
+  if (data.body) {
+    try {
+      descriptionHtml = marked.parse(data.body) as string;
+    } catch (e) {
+      console.warn('[modrinth] Failed to parse markdown:', e);
+      descriptionHtml = data.body; // Fallback to raw text
+    }
+  }
+
+  return {
+    provider: 'modrinth',
+    projectId: data.id,
+    slug: data.slug,
+    name: data.title,
+    summary: data.description,
+    description: descriptionHtml || data.body,
+    iconUrl: data.icon_url,
+    downloads: data.downloads,
+    categories: data.categories,
+    authors: data.author ? [data.author] : undefined,
+    websiteUrl: data.thread_id
+      ? `https://modrinth.com/project/${data.slug}`
+      : undefined,
+  };
+}
+
+/**
+ * Get MarketplaceItem by project ID (for dependency resolution)
+ */
+export async function modrinthGetItemById(
+  projectId: string,
+  projectType: ProjectType,
+): Promise<MarketplaceItem | null> {
+  try {
+    const details = await modrinthGetProjectDetails(projectId);
+    return {
+      provider: 'modrinth',
+      projectType,
+      projectId: details.projectId,
+      slug: details.slug,
+      name: details.name,
+      summary: details.summary,
+      iconUrl: details.iconUrl,
+      downloads: details.downloads,
+    };
+  } catch (e) {
+    console.warn(`[modrinth] Failed to get project ${projectId}:`, e);
+    return null;
+  }
+}
+
+export const modrinthModMarketplaceProvider: ModMarketplaceProvider = {
+  id: 'modrinth',
+  label: 'Modrinth',
+  order: 10,
+  search: modrinthSearch,
+  install: modrinthInstallToManifestEntry,
+  getProjectDetails: modrinthGetProjectDetails,
+  getInstallVersions: modrinthGetInstallVersions,
+};

package/src/shared/mods/resolve-mods-provider-loader-ids.ts

@@ -0,0 +1,77 @@
+import type { ModsProviderLoaderIds } from '../../minecraft-loader/base-loader';
+import { loaderRegistry } from '../../minecraft-loader/loader-registry';
+
+type ModsProviderLoaderIdsByProvider = Readonly<
+  Partial<Record<string, string | readonly string[]>>
+>;
+
+function normalizeToArray(value: string | readonly string[]): string[] {
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed ? [trimmed] : [];
+  }
+  return value.map((s) => s.trim()).filter(Boolean);
+}
+
+function resolveFromMapping(
+  mapping: ModsProviderLoaderIds,
+  providerId: string,
+  fallbackLoaderId: string,
+): string[] {
+  if (typeof mapping === 'string') {
+    return normalizeToArray(mapping);
+  }
+  if (Array.isArray(mapping)) {
+    return normalizeToArray(mapping);
+  }
+  const byProvider = mapping as ModsProviderLoaderIdsByProvider;
+  const forProvider = byProvider[providerId];
+  if (forProvider !== undefined) {
+    return normalizeToArray(forProvider);
+  }
+  return [fallbackLoaderId];
+}
+
+/**
+ * Id загрузчика для фильтрации в конкретном маркетплейсе модов.
+ * Берёт `modsProviderLoaderIds` с зарегистрированного лоадера или fallback на `loader.id`.
+ */
+export function resolveModsProviderLoaderIds(
+  loaderId: string | undefined,
+  providerId: string,
+): string[] {
+  if (!loaderId || loaderId === 'vanilla') {
+    return [];
+  }
+
+  const loader = loaderRegistry.get(loaderId);
+  if (!loader) {
+    return [loaderId];
+  }
+
+  const mapping = loader.modsProviderLoaderIds;
+  if (!mapping) {
+    return [loader.id];
+  }
+
+  return resolveFromMapping(mapping, providerId, loader.id);
+}
+
+export function getMarketplaceLoaderIds(
+  ctx: { loader?: string; marketplaceLoaderIds?: string[] },
+  providerId: string,
+): string[] {
+  if (ctx.marketplaceLoaderIds?.length) {
+    return ctx.marketplaceLoaderIds;
+  }
+  return resolveModsProviderLoaderIds(ctx.loader, providerId);
+}
+
+/** Первый id для CurseForge (API принимает один modLoaderType). */
+export function getCurseForgeMarketplaceLoaderId(
+  ctx: { loader?: string; marketplaceLoaderIds?: string[] },
+  providerId: string = 'curseforge',
+): string | undefined {
+  const ids = getMarketplaceLoaderIds(ctx, providerId);
+  return ids[0];
+}

package/src/shared/mods/types.ts

@@ -0,0 +1,76 @@
+export const MARKETPLACE_SEARCH_PAGE_SIZE = 20;
+
+export type ModsProviderId = 'modrinth' | 'curseforge' | 'optifine';
+
+export type ProjectType = 'mod' | 'resourcepack' | 'shaderpack';
+
+export type LoaderId = 'vanilla' | 'fabric' | 'quilt' | 'forge' | 'neoforge' | string;
+
+export type MarketplaceItem = {
+    provider: ModsProviderId;
+    projectType: ProjectType;
+    /**
+     * Provider-specific project id (Modrinth project_id, CurseForge modId)
+     */
+    projectId: string;
+    /**
+     * Human-friendly slug (if provider has it)
+     */
+    slug: string;
+    name: string;
+    summary?: string;
+    iconUrl?: string;
+    downloads?: number;
+};
+
+export type MarketplaceSearchContext = {
+    projectType: ProjectType;
+    query: string;
+    minecraftVersion?: string;
+    /** Id лоадера в реестре сборки */
+    loader?: LoaderId;
+    /** Id для фильтрации в конкретном провайдере (из `modsProviderLoaderIds`) */
+    marketplaceLoaderIds?: string[];
+    /** 0-based страница; Modrinth offset = page * PAGE_SIZE, CurseForge index = page * PAGE_SIZE */
+    page?: number;
+};
+
+export type MarketplaceSearchResult = {
+    items: MarketplaceItem[];
+    hasMore: boolean;
+};
+
+export type InstallContext = {
+    projectType: ProjectType;
+    minecraftVersion: string;
+    /** Id лоадера в реестре сборки */
+    loader: LoaderId;
+    /** Id для фильтрации в конкретном провайдере (из `modsProviderLoaderIds`) */
+    marketplaceLoaderIds?: string[];
+};
+
+export type ProjectDetails = {
+    provider: ModsProviderId;
+    projectId: string;
+    slug: string;
+    name: string;
+    summary?: string;
+    description?: string;
+    iconUrl?: string;
+    downloads?: number;
+    categories?: string[];
+    authors?: string[];
+    websiteUrl?: string;
+    sourceUrl?: string;
+    issuesUrl?: string;
+    wikiUrl?: string;
+    supportUrl?: string;
+};
+
+export type MarketplaceInstallVersion = {
+    id: string;
+    label: string;
+    publishedAt?: string;
+    recommended?: boolean;
+};
+