@rynt/sdk 0.9.53

package/src/shared/mods/mod-marketplace-registry.ts

@@ -0,0 +1,66 @@
+import { markRaw } from 'vue';
+
+import {
+  clearRegistryBucket,
+  deleteRegistryItem,
+  getRegistryEntryMeta,
+  getRegistryItem,
+  HOST_EXTENSION_ID,
+  listRegistryEntries,
+  listRegistryValuesSorted,
+} from '../../extensions/registries';
+import { useModProviderRegistry } from '../../extensions/registries/builtins/mod-provider';
+
+export type { ModMarketplaceProvider } from './mod-marketplace-types';
+
+import type { ModMarketplaceProvider } from './mod-marketplace-types';
+
+const RID = 'core.modProvider';
+
+/** Подготовить объект провайдера для реестра / `ctx.registerRegistryEntry` (Vue не должен делать функции реактивными). */
+export function markModMarketplaceProvider(
+  provider: ModMarketplaceProvider,
+): ModMarketplaceProvider {
+  return {
+    ...provider,
+    search: markRaw(provider.search),
+    install: markRaw(provider.install),
+    getProjectDetails: markRaw(provider.getProjectDetails),
+  };
+}
+
+/**
+ * `extensionId` определяется автоматически через scope: в коде расширения — id из `manifest.json`,
+ * в коде лаунчера — `rynt`.
+ */
+export function registerModMarketplaceProvider(
+  provider: ModMarketplaceProvider,
+): void {
+  const row = markModMarketplaceProvider(provider);
+  useModProviderRegistry().register(provider.id, row, provider.order);
+}
+
+export function unregisterModMarketplaceProvidersForExtension(
+  extensionId: string,
+): void {
+  if (extensionId === HOST_EXTENSION_ID) return;
+  for (const [key] of listRegistryEntries<ModMarketplaceProvider>(RID)) {
+    if (getRegistryEntryMeta(RID, key)?.extensionId === extensionId) {
+      deleteRegistryItem(RID, key);
+    }
+  }
+}
+
+export function resetModMarketplaceRegistry(): void {
+  clearRegistryBucket(RID);
+}
+
+export function listModMarketplaceProviders(): ModMarketplaceProvider[] {
+  return listRegistryValuesSorted<ModMarketplaceProvider>(RID);
+}
+
+export function getModMarketplaceProvider(
+  id: string,
+): ModMarketplaceProvider | undefined {
+  return getRegistryItem<ModMarketplaceProvider>(RID, id);
+}

package/src/shared/mods/mod-marketplace-types.ts

@@ -0,0 +1,28 @@
+import type { Mod, ResourcePack, ShaderPack } from '../minecraft-types/build-manifest';
+import type {
+  InstallContext,
+  MarketplaceInstallVersion,
+  MarketplaceItem,
+  MarketplaceSearchContext,
+  MarketplaceSearchResult,
+  ModsProviderId,
+  ProjectDetails,
+} from './types';
+
+/** Один контракт провайдера маркетплейса модов (встроенный или из расширения). `extensionId` — только в метаданных реестра. */
+export type ModMarketplaceProvider = {
+  id: ModsProviderId;
+  label: string;
+  order?: number;
+  search: (ctx: MarketplaceSearchContext) => Promise<MarketplaceSearchResult>;
+  install: (
+    item: MarketplaceItem,
+    ctx: InstallContext,
+    versionId?: string,
+  ) => Promise<Mod | ResourcePack | ShaderPack>;
+  getProjectDetails: (projectId: string) => Promise<ProjectDetails>;
+  getInstallVersions?: (
+    projectId: string,
+    ctx: InstallContext,
+  ) => Promise<MarketplaceInstallVersion[]>;
+};

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

@@ -0,0 +1,464 @@
+import type {
+  Mod,
+  ResourcePack,
+  ShaderPack,
+} from '../../minecraft-types/build-manifest';
+import { httpGet } from '../http';
+import type { ModMarketplaceProvider } from '../mod-marketplace-types';
+import { getCurseForgeMarketplaceLoaderId } from '../resolve-mods-provider-loader-ids';
+import type {
+  InstallContext,
+  MarketplaceInstallVersion,
+  MarketplaceItem,
+  MarketplaceSearchContext,
+  MarketplaceSearchResult,
+  ProjectDetails,
+  ProjectType,
+} from '../types';
+import { MARKETPLACE_SEARCH_PAGE_SIZE } from '../types';
+
+const CURSEFORGE_PROVIDER_ID = 'curseforge';
+
+const CURSEFORGE_BASE = 'https://api.curseforge.com';
+const MINECRAFT_GAME_ID = 432;
+const CLASS_ID_MODS = 6;
+const CLASS_ID_RESOURCE_PACKS = 12;
+const CLASS_ID_SHADER_PACKS = 6552;
+
+type CfLogo = { url?: string };
+
+type CfSearchItem = {
+  id: number;
+  name: string;
+  slug: string;
+  summary?: string;
+  downloadCount?: number;
+  logo?: CfLogo;
+};
+
+type CfPagination = {
+  index: number;
+  pageSize: number;
+  totalCount: number;
+};
+
+type CfResponse<T> = { data: T; pagination?: CfPagination };
+
+type CfFileHash = {
+  algo: number; // 1 = sha1
+  value: string;
+};
+
+type CfFile = {
+  id: number;
+  fileName: string;
+  fileLength: number;
+  displayName?: string;
+  downloadUrl?: string | null;
+  hashes?: CfFileHash[];
+};
+
+function getApiKey(): string | null {
+  // NOTE: client-side by request (will be bundled into app)
+  const key = (import.meta as any).env?.VITE_CURSEFORGE_API_KEY as
+    | string
+    | undefined;
+  return key?.trim() ? key.trim() : null;
+}
+
+function loaderToCfModLoaderType(
+  loader: string | undefined,
+): number | undefined {
+  // Best-effort mapping (CurseForge ModLoaderType enum)
+  // 0 Any, 1 Forge, 4 Fabric, 5 Quilt, 6 NeoForge
+  switch ((loader || '').toLowerCase()) {
+    case 'forge':
+      return 1;
+    case 'fabric':
+      return 4;
+    case 'quilt':
+      return 5;
+    case 'neoforge':
+      return 6;
+    default:
+      return undefined;
+  }
+}
+
+function getCfHeaders(): Record<string, string> {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error('VITE_CURSEFORGE_API_KEY is not set');
+  }
+  return {
+    'x-api-key': apiKey,
+  };
+}
+
+export async function curseforgeSearch(
+  ctx: MarketplaceSearchContext,
+): Promise<MarketplaceSearchResult> {
+  const classId =
+    ctx.projectType === 'resourcepack'
+      ? CLASS_ID_RESOURCE_PACKS
+      : ctx.projectType === 'shaderpack'
+        ? CLASS_ID_SHADER_PACKS
+        : CLASS_ID_MODS;
+
+  // Resource packs and shader packs don't depend on mod loader, so don't filter by loader
+  const marketplaceLoaderId =
+    ctx.projectType === 'resourcepack' || ctx.projectType === 'shaderpack'
+      ? undefined
+      : getCurseForgeMarketplaceLoaderId(ctx, CURSEFORGE_PROVIDER_ID);
+  const modLoaderType = loaderToCfModLoaderType(marketplaceLoaderId);
+
+  const page = ctx.page ?? 0;
+  const pageSize = MARKETPLACE_SEARCH_PAGE_SIZE;
+  const index = page * pageSize;
+
+  const url = `${CURSEFORGE_BASE}/v1/mods/search`;
+  const params: Record<string, string | number | undefined> = {
+    gameId: MINECRAFT_GAME_ID,
+    classId,
+    sortField: 12,
+    gameVersion: ctx.minecraftVersion || undefined,
+    modLoaderType: modLoaderType ?? undefined,
+    pageSize,
+    index,
+  };
+  if (ctx.query.trim()) {
+    params.searchFilter = ctx.query.trim();
+  }
+
+  const response = await httpGet<CfResponse<CfSearchItem[]>>(url, {
+    params,
+    headers: getCfHeaders(),
+  });
+
+  const data = response.data ?? [];
+  const items = data.map((m) => ({
+    provider: 'curseforge' as const,
+    projectType: ctx.projectType,
+    projectId: String(m.id),
+    slug: m.slug || String(m.id),
+    name: m.name,
+    summary: m.summary,
+    iconUrl: m.logo?.url,
+    downloads: m.downloadCount,
+  }));
+
+  const pagination = response.pagination;
+  const hasMore =
+    pagination != null
+      ? pagination.index + data.length < pagination.totalCount
+      : data.length === pageSize;
+
+  return { items, hasMore };
+}
+
+type CfSortableFile = CfFile & {
+  fileDate?: string;
+};
+
+async function curseforgeGetCompatibleFiles(
+  modId: string,
+  ctx: InstallContext,
+): Promise<CfSortableFile[]> {
+  const marketplaceLoaderId =
+    ctx.projectType === 'resourcepack' || ctx.projectType === 'shaderpack'
+      ? undefined
+      : getCurseForgeMarketplaceLoaderId(ctx, CURSEFORGE_PROVIDER_ID);
+  const modLoaderType = loaderToCfModLoaderType(marketplaceLoaderId);
+  const url = `${CURSEFORGE_BASE}/v1/mods/${encodeURIComponent(modId)}/files`;
+  const params = {
+    gameVersion: ctx.minecraftVersion || undefined,
+    modLoaderType: modLoaderType ?? undefined,
+    pageSize: 20,
+  };
+
+  try {
+    const response = await httpGet<CfResponse<CfFile[]>>(url, {
+      params,
+      headers: getCfHeaders(),
+    });
+
+    let files = (response.data ?? []) as CfSortableFile[];
+
+    if (!files.length && modLoaderType !== undefined) {
+      const paramsWithoutLoader = {
+        gameVersion: ctx.minecraftVersion || undefined,
+        pageSize: 20,
+      };
+      const retryResponse = await httpGet<CfResponse<CfFile[]>>(url, {
+        params: paramsWithoutLoader,
+        headers: getCfHeaders(),
+      });
+      files = (retryResponse.data ?? []) as CfSortableFile[];
+    }
+
+    if (!files.length && ctx.minecraftVersion) {
+      const paramsWithoutVersion = {
+        modLoaderType: modLoaderType ?? undefined,
+        pageSize: 20,
+      };
+      const retryResponse2 = await httpGet<CfResponse<CfFile[]>>(url, {
+        params: paramsWithoutVersion,
+        headers: getCfHeaders(),
+      });
+      files = (retryResponse2.data ?? []) as CfSortableFile[];
+    }
+
+    if (!files.length) {
+      const paramsNoFilters = {
+        pageSize: 1,
+      };
+      const retryResponse3 = await httpGet<CfResponse<CfFile[]>>(url, {
+        params: paramsNoFilters,
+        headers: getCfHeaders(),
+      });
+      files = (retryResponse3.data ?? []) as CfSortableFile[];
+    }
+
+    if (!files.length) {
+      throw new Error('No compatible files found on CurseForge');
+    }
+    return files;
+  } catch (error) {
+    throw error;
+  }
+}
+
+function getSha1FromHashes(hashes: CfFileHash[] | undefined): string | null {
+  const sha1 = hashes?.find((h) => h.algo === 1)?.value;
+  return sha1 || null;
+}
+
+function buildCurseForgeDownloadUrl(fileId: number, fileName: string): string {
+  // CurseForge CDN URL format: https://edge.forgecdn.net/files/{first4}/{rest}/{fileName}
+  const fileIdStr = String(fileId);
+  const firstPart = fileIdStr.slice(0, 4);
+  const secondPart = fileIdStr.slice(4);
+  return `https://edge.forgecdn.net/files/${firstPart}/${secondPart}/${fileName}`;
+}
+
+export async function curseforgeGetInstallVersions(
+  modId: string,
+  ctx: InstallContext,
+): Promise<MarketplaceInstallVersion[]> {
+  const files = await curseforgeGetCompatibleFiles(modId, ctx);
+  return files.map((file, index) => ({
+    id: String(file.id),
+    label: file.displayName || file.fileName,
+    publishedAt: file.fileDate,
+    recommended: index === 0,
+  }));
+}
+
+export async function curseforgeInstallToManifestEntry(
+  item: MarketplaceItem,
+  ctx: InstallContext,
+  selectedVersionId?: string,
+): Promise<Mod | ResourcePack | ShaderPack> {
+  try {
+    const files = await curseforgeGetCompatibleFiles(item.projectId, ctx);
+    const file = selectedVersionId
+      ? files.find((f) => String(f.id) === selectedVersionId)
+      : files[0];
+    if (!file) {
+      throw new Error('Selected CurseForge version not found');
+    }
+    const sha1 = getSha1FromHashes(file.hashes);
+    if (!sha1) {
+      throw new Error('CurseForge file does not contain sha1 hash');
+    }
+    // Build download URL if not provided by API
+    const downloadUrl =
+      file.downloadUrl || buildCurseForgeDownloadUrl(file.id, file.fileName);
+
+    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.fileLength,
+      hashes: { sha1 },
+      urls: [downloadUrl],
+      side: 'both' as const,
+    };
+
+    const versionLabel = file.displayName || file.fileName;
+
+    if (ctx.projectType === 'resourcepack') {
+      const rp: ResourcePack = {
+        source: 'curseforge',
+        id: item.projectId,
+        name: item.name,
+        projectSlug: item.slug,
+        version: versionLabel,
+        image: item.iconUrl,
+        constraints: {
+          minecraft: ctx.minecraftVersion,
+        },
+        files: [fileEntry],
+      };
+      return rp;
+    }
+
+    if (ctx.projectType === 'shaderpack') {
+      const sp: ShaderPack = {
+        source: 'curseforge',
+        id: item.projectId,
+        name: item.name,
+        projectSlug: item.slug,
+        version: versionLabel,
+        image: item.iconUrl,
+        constraints: {
+          minecraft: ctx.minecraftVersion,
+        },
+        files: [fileEntry],
+      };
+      return sp;
+    }
+
+    const mod: Mod = {
+      source: 'curseforge',
+      id: item.projectId, // Use projectId (CurseForge modId) for id
+      name: item.name,
+      projectSlug: item.slug, // Use slug for projectSlug
+      image: item.iconUrl,
+      version: versionLabel,
+      constraints: {
+        minecraft: ctx.minecraftVersion,
+        loader: ctx.loader,
+      },
+      files: [fileEntry],
+      dependencies: [], // CurseForge API doesn't provide dependencies in file endpoint
+    };
+    return mod;
+  } catch (error) {
+    throw error;
+  }
+}
+
+type CfProject = {
+  id: number;
+  name: string;
+  slug: string;
+  summary?: string;
+  description?: string;
+  downloadCount?: number;
+  logo?: CfLogo;
+  links?: {
+    websiteUrl?: string;
+    wikiUrl?: string;
+    issuesUrl?: string;
+    sourceUrl?: string;
+  };
+  categories?: Array<{
+    id?: number;
+    name?: string;
+    slug?: string;
+  }>;
+  authors?: Array<{
+    id?: number;
+    name?: string;
+    url?: string;
+  }>;
+  dateCreated?: string;
+  dateModified?: string;
+  dateReleased?: string;
+  status?: number;
+};
+
+type CfDescriptionResponse = {
+  data: string; // HTML description
+};
+
+export async function curseforgeGetProjectDetails(
+  modId: string,
+): Promise<ProjectDetails> {
+  const [projectResponse, descriptionResponse] = await Promise.allSettled([
+    httpGet<CfResponse<CfProject>>(
+      `${CURSEFORGE_BASE}/v1/mods/${encodeURIComponent(modId)}`,
+      {
+        headers: getCfHeaders(),
+      },
+    ),
+    httpGet<CfDescriptionResponse>(
+      `${CURSEFORGE_BASE}/v1/mods/${encodeURIComponent(modId)}/description`,
+      {
+        headers: getCfHeaders(),
+      },
+    ),
+  ]);
+
+  if (projectResponse.status === 'rejected') {
+    throw new Error('Failed to fetch CurseForge project details');
+  }
+
+  const project = projectResponse.value.data;
+
+  // Get HTML description from separate endpoint if available
+  let descriptionHtml: string | undefined = project.description;
+  if (descriptionResponse.status === 'fulfilled') {
+    descriptionHtml = descriptionResponse.value.data;
+  }
+
+  return {
+    provider: 'curseforge',
+    projectId: String(project.id),
+    slug: project.slug || String(project.id),
+    name: project.name,
+    summary: project.summary,
+    description: descriptionHtml,
+    iconUrl: project.logo?.url,
+    downloads: project.downloadCount,
+    categories: project.categories
+      ?.map((c) => c.name || c.slug || '')
+      .filter(Boolean),
+    authors: project.authors?.map((a) => a.name || '').filter(Boolean),
+    websiteUrl: project.links?.websiteUrl,
+    sourceUrl: project.links?.sourceUrl,
+    issuesUrl: project.links?.issuesUrl,
+    wikiUrl: project.links?.wikiUrl,
+  };
+}
+
+/**
+ * Get MarketplaceItem by project ID (for dependency resolution)
+ */
+export async function curseforgeGetItemById(
+  modId: string,
+  projectType: ProjectType,
+): Promise<MarketplaceItem | null> {
+  try {
+    const details = await curseforgeGetProjectDetails(modId);
+    return {
+      provider: 'curseforge',
+      projectType,
+      projectId: details.projectId,
+      slug: details.slug,
+      name: details.name,
+      summary: details.summary,
+      iconUrl: details.iconUrl,
+      downloads: details.downloads,
+    };
+  } catch (e) {
+    console.warn(`[curseforge] Failed to get mod ${modId}:`, e);
+    return null;
+  }
+}
+
+export const curseforgeModMarketplaceProvider: ModMarketplaceProvider = {
+  id: 'curseforge',
+  label: 'CurseForge',
+  order: 20,
+  search: curseforgeSearch,
+  install: curseforgeInstallToManifestEntry,
+  getProjectDetails: curseforgeGetProjectDetails,
+  getInstallVersions: curseforgeGetInstallVersions,
+};

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

@@ -0,0 +1,8 @@
+export {
+  curseforgeGetItemById,
+  curseforgeModMarketplaceProvider,
+} from './curseforge';
+export {
+  modrinthGetItemById,
+  modrinthModMarketplaceProvider,
+} from './modrinth';