diff --git a/apps/frontend/src/pages/discover/[type]/index.vue b/apps/frontend/src/pages/discover/[type]/index.vue
index 09213818fdb..67edb4a0b5a 100644
--- a/apps/frontend/src/pages/discover/[type]/index.vue
+++ b/apps/frontend/src/pages/discover/[type]/index.vue
@@ -19,8 +19,11 @@ import {
CreationFlowModal,
defineMessages,
formatProjectTypeSentence,
+ getProjectVersionFilterQuery,
injectModrinthClient,
injectUserPreferences,
+ isServerContentEnvironmentProjectType,
+ NavTabs,
PROJECT_DEP_MARKER_QUERY,
provideBrowseManager,
SelectedProjectsFloatingBar,
@@ -40,6 +43,7 @@ import LogoAnimated from '~/components/brand/LogoAnimated.vue'
import AdPlaceholder from '~/components/ui/AdPlaceholder.vue'
import { projectQueryOptions, warmProjectCheckCaches } from '~/composables/queries/project'
import { versionQueryOptions } from '~/composables/queries/version'
+import { useDiscoverProjectTypeLinks } from '~/composables/use-discover-project-type-links'
import type {
ServerInstallModalHandle,
ServerInstallSearchResult,
@@ -58,6 +62,7 @@ const { updatePreferences } = injectUserPreferences()
const queryClient = useQueryClient()
const filtersMenuOpen = ref(false)
+const { projectTypeLinks, isServerContext, isServerSetup } = useDiscoverProjectTypeLinks()
const route = useRoute()
const cosmetics = useCosmetics()
@@ -177,12 +182,13 @@ const onboardingModalRef = ref(null)
const {
currentServerId,
fromContext,
+ isSetupServerContext,
serverData,
serverContentData,
serverFilters,
serverHideInstalled,
- serverContentServerOnly,
- showServerOnlyToggle,
+ serverEnvironment,
+ showServerEnvironment,
serverEnvironmentOverride,
hideSelectedServerInstalls,
installingProjectIds,
@@ -204,6 +210,23 @@ const {
debug,
})
+watch(
+ [serverEnvironment, currentType, showServerEnvironment],
+ ([environment, type, show]) => {
+ if (!show) return
+ const allowed = type !== 'modpack' && isServerContentEnvironmentProjectType(environment, type)
+ if (allowed && (route.query.env ?? null) === environment) return
+ navigateTo(
+ {
+ path: allowed ? route.path : '/discover/mods',
+ query: { ...route.query, env: environment ?? undefined },
+ },
+ { replace: true },
+ )
+ },
+ { immediate: true },
+)
+
function getServerModpackContent(project: Labrinth.Search.v3.ResultSearchProject) {
const content = project.minecraft_java_server?.content
if (content?.kind === 'modpack') {
@@ -351,27 +374,31 @@ function getCardActions(
}
if (serverData.value) {
- const isQueued = queuedServerInstallProjectIds.value.has(result.project_id)
- const isQueuedRoot = queuedServerInstallRootProjectIds.value.has(result.project_id)
+ const isQueued =
+ !isSetupServerContext.value && queuedServerInstallProjectIds.value.has(result.project_id)
+ const isQueuedRoot =
+ !isSetupServerContext.value && queuedServerInstallRootProjectIds.value.has(result.project_id)
const isInstalled =
- projectResult.installed ||
- optimisticallyInstalledProjectIds.value.has(result.project_id) ||
- (serverContentData.value &&
- (serverContentData.value.addons ?? []).find((x) => x.project_id === result.project_id)) ||
- serverData.value.upstream?.project_id === result.project_id
+ !isSetupServerContext.value &&
+ (projectResult.installed ||
+ optimisticallyInstalledProjectIds.value.has(result.project_id) ||
+ (serverContentData.value &&
+ (serverContentData.value.addons ?? []).find((x) => x.project_id === result.project_id)) ||
+ serverData.value.upstream?.project_id === result.project_id)
const isInstalling = installingProjectIds.value.has(result.project_id)
const isInstallingSelection = isInstallingQueuedServerInstalls.value
+ const showAsInstalling = isInstalling || (isInstallingSelection && isQueuedRoot)
const validatingInstall =
isInstalling && currentProjectType !== 'modpack' && !isInstallingSelection
const installLabel = isInstalled
? formatMessage(commonMessages.installedLabel)
: isQueued
- ? isInstalling || isInstallingSelection
+ ? showAsInstalling
? validatingInstall
? formatMessage(commonMessages.validatingLabel)
: formatMessage(commonMessages.installingLabel)
: formatMessage(commonMessages.selectedLabel)
- : isInstalling || isInstallingSelection
+ : showAsInstalling
? validatingInstall
? formatMessage(commonMessages.validatingLabel)
: formatMessage(commonMessages.installingLabel)
@@ -381,16 +408,11 @@ function getCardActions(
{
key: 'install',
label: installLabel,
- icon:
- isInstalling || isInstallingSelection
- ? SpinnerIcon
- : isQueued || isInstalled
- ? CheckIcon
- : DownloadIcon,
- iconClass: isInstalling || isInstallingSelection ? 'animate-spin' : undefined,
+ icon: showAsInstalling ? SpinnerIcon : isQueued || isInstalled ? CheckIcon : DownloadIcon,
+ iconClass: showAsInstalling ? 'animate-spin' : undefined,
disabled:
!!isInstalled || isInstalling || isInstallingSelection || (isQueued && !isQueuedRoot),
- color: isQueued && !isInstalling && !isInstallingSelection ? 'green' : 'brand',
+ color: isQueued && !showAsInstalling ? 'green' : 'brand',
type: 'outlined',
onClick: () => serverInstall(projectResult),
},
@@ -464,10 +486,10 @@ const searchState = useBrowseSearch({
providedFilters: serverFilters,
environmentOverride: serverEnvironmentOverride,
search,
- persistentQueryParams: ['sid', 'wid', 'shi', 'so', 'from'],
+ persistentQueryParams: ['sid', 'wid', 'shi', 'env', 'from'],
getExtraQueryParams: () => ({
shi: serverHideInstalled.value ? 'true' : undefined,
- so: showServerOnlyToggle.value && serverContentServerOnly.value ? 'true' : undefined,
+ env: (showServerEnvironment.value && serverEnvironment.value) || undefined,
}),
maxResultsOptions: currentMaxResultsOptions,
displayMode: resultsDisplayMode,
@@ -543,10 +565,18 @@ provideBrowseManager({
tags,
projectType: projectTypeId,
...searchState,
- getProjectLink: (result: Labrinth.Search.v3.ResultSearchProject) =>
- withHostingContext(
- `/${projectType.value?.id ?? 'project'}/${result.slug ? result.slug : result.project_id}`,
- ),
+ getProjectLink: (result: Labrinth.Search.v3.ResultSearchProject) => ({
+ path: `/${projectType.value?.id ?? 'project'}/${result.slug ? result.slug : result.project_id}`,
+ query: {
+ ...hostingContextQuery.value,
+ ...getProjectVersionFilterQuery({
+ contentType: projectTypeId.value,
+ selectedFilters: searchState.currentFilters.value,
+ providedFilters: serverFilters.value,
+ overriddenProvidedFilterTypes: searchState.overriddenProvidedFilterTypes.value,
+ }),
+ },
+ }),
getServerProjectLink: (result: Labrinth.Search.v3.ResultSearchProject) =>
withHostingContext(`/server/${result.slug ?? result.project_id}`),
selectableProjectTypes: computed(() => []),
@@ -566,10 +596,9 @@ provideBrowseManager({
queuedServerInstallCount.value > 0,
),
hideSelectedLabel: computed(() => formatMessage(commonMessages.hideSelectedContentLabel)),
- serverOnly: serverContentServerOnly,
- showServerOnly: showServerOnlyToggle,
- serverOnlyLabel: computed(() => formatMessage(commonMessages.serverOnlyLabel)),
- hiddenFilterTypes: computed(() => (showServerOnlyToggle.value ? ['environment'] : [])),
+ serverEnvironment,
+ showServerEnvironment,
+ hiddenFilterTypes: computed(() => (showServerEnvironment.value ? ['environment'] : [])),
advancedFiltersCollapsed,
dismissedPhotosensitivityFilterWarning,
displayMode: resultsDisplayMode,
@@ -610,6 +639,14 @@ const { isStuck: isInstallHeaderStuck } = useStickyObserver(
+
+
-
+
diff --git a/apps/frontend/src/pages/hosting/manage/[id]/play.vue b/apps/frontend/src/pages/hosting/manage/[id]/play.vue
new file mode 100644
index 00000000000..183097faaa9
--- /dev/null
+++ b/apps/frontend/src/pages/hosting/manage/[id]/play.vue
@@ -0,0 +1,36 @@
+
+
+
+
+
diff --git a/apps/frontend/src/pages/share/[inviteId].vue b/apps/frontend/src/pages/share/[inviteId].vue
index 2aed9231856..3f925b84952 100644
--- a/apps/frontend/src/pages/share/[inviteId].vue
+++ b/apps/frontend/src/pages/share/[inviteId].vue
@@ -245,16 +245,11 @@ const hiddenUserCount = computed(() =>
onServerPrefetch(() => suspense())
-const inviter = computed(
- () =>
- invite.value?.managers.find((manager) => manager.type === 'user') ?? invite.value?.managers[0],
+const inviterName = computed(
+ () => invite.value?.inviter?.name ?? formatMessage(messages.unknownInviter),
)
-const inviterName = computed(() => inviter.value?.name ?? formatMessage(messages.unknownInviter))
-const inviterAvatar = computed(() => {
- if (!inviter.value) return null
- return inviter.value.type === 'user' ? inviter.value.avatar : inviter.value.icon
-})
-const moderationUserId = computed(() => (inviter.value?.type === 'user' ? inviter.value.id : null))
+const inviterAvatar = computed(() => invite.value?.inviter?.avatar ?? null)
+const moderationUserId = computed(() => invite.value?.inviter?.id ?? null)
const isStaff = computed(() => {
const role = auth.value.user?.role
return role === 'admin' || role === 'moderator'
diff --git a/packages/api-client/src/core/abstract-client.ts b/packages/api-client/src/core/abstract-client.ts
index e750505d046..f01133e340b 100644
--- a/packages/api-client/src/core/abstract-client.ts
+++ b/packages/api-client/src/core/abstract-client.ts
@@ -1,8 +1,10 @@
import type { InferredClientModules } from '../modules'
import { buildModuleStructure } from '../modules'
import type { BaseUrlConfig, ClientConfig } from '../types/client'
+import type { DownloadSink } from '../types/download'
import type { RequestContext, RequestOptions } from '../types/request'
import type { UploadMetadata, UploadProgress, UploadRequestOptions } from '../types/upload'
+import { appendRequestParams } from '../utils/fetch'
import type { AbstractFeature } from './abstract-feature'
import type { AbstractModule } from './abstract-module'
import type { AbstractSyncClient } from './abstract-sync'
@@ -169,6 +171,47 @@ export abstract class AbstractModrinthClient extends AbstractUploadClient {
}
}
+ async download(path: string, options: RequestOptions, sink: DownloadSink): Promise {
+ let baseUrl: string
+ if (options.api === 'labrinth') {
+ baseUrl = this.resolveBaseUrl(this.config.labrinthBaseUrl!)
+ } else if (options.api === 'archon') {
+ baseUrl = this.resolveBaseUrl(this.config.archonBaseUrl!)
+ } else if (options.api === 'sharedinstances') {
+ baseUrl = this.resolveBaseUrl(this.config.sharedInstancesBaseUrl!)
+ } else {
+ baseUrl = options.api
+ }
+
+ const mergedOptions: RequestOptions = {
+ method: 'GET',
+ retry: false,
+ circuitBreaker: false,
+ ...options,
+ headers: {
+ ...(await this.buildDefaultHeaders()),
+ ...options.headers,
+ },
+ }
+ this.attachArchonSentryCaptureHeader(mergedOptions)
+ const context = this.buildContext(
+ this.buildUrl(path, baseUrl, options.version),
+ path,
+ mergedOptions,
+ )
+
+ try {
+ await this.executeFeatureChain(context, () =>
+ sink(appendRequestParams(context.url, context.options.params), context.options),
+ )
+ await this.config.hooks?.onResponse?.(undefined, context)
+ } catch (error) {
+ const apiError = this.normalizeError(error, context)
+ await this.config.hooks?.onError?.(apiError, context)
+ throw apiError
+ }
+ }
+
async stream(path: string, options: RequestOptions): Promise> {
let baseUrl: string
if (options.api === 'labrinth') {
diff --git a/packages/api-client/src/index.ts b/packages/api-client/src/index.ts
index 226adcbabdd..511c32e7e98 100644
--- a/packages/api-client/src/index.ts
+++ b/packages/api-client/src/index.ts
@@ -43,7 +43,7 @@ export { XHRUploadClient } from './platform/xhr-upload-client'
export { clearNodeAuthState, nodeAuthState, setNodeAuthState } from './state/node-auth'
export * from './types'
export { withJWTRetry } from './utils/jwt-retry'
-export { getNodeWebSocketUrl } from './utils/node-url'
+export { getNodeBaseUrl, getNodeWebSocketUrl } from './utils/node-url'
export { pingWebSocketUrl, type WebSocketPingOptions } from './utils/pingtest'
export {
type ParsedSseEvent,
diff --git a/packages/api-client/src/modules/archon/content/v1.ts b/packages/api-client/src/modules/archon/content/v1.ts
index fa0c951d6f2..32e5537bb9a 100644
--- a/packages/api-client/src/modules/archon/content/v1.ts
+++ b/packages/api-client/src/modules/archon/content/v1.ts
@@ -6,6 +6,51 @@ export class ArchonContentV1Module extends AbstractModule {
return 'archon_content_v1'
}
+ public async share(
+ serverId: string,
+ worldId: string,
+ configPaths: string[] = [],
+ options?: { timeout?: number },
+ ): Promise {
+ return this.client.request(
+ `/servers/${encodeURIComponent(serverId)}/worlds/${encodeURIComponent(worldId)}/content/share`,
+ {
+ api: 'archon',
+ version: 1,
+ method: 'POST',
+ timeout: options?.timeout ?? 600_000,
+ retry: false,
+ body: { config_paths: configPaths },
+ },
+ )
+ }
+
+ public async getShareDiff(
+ serverId: string,
+ worldId: string,
+ ): Promise {
+ return this.client.request(
+ `/servers/${encodeURIComponent(serverId)}/worlds/${encodeURIComponent(worldId)}/content/share/diff`,
+ {
+ api: 'archon',
+ version: 1,
+ method: 'GET',
+ },
+ )
+ }
+
+ public async unshare(serverId: string, worldId: string): Promise {
+ return this.client.request(
+ `/servers/${encodeURIComponent(serverId)}/worlds/${encodeURIComponent(worldId)}/content/share`,
+ {
+ api: 'archon',
+ version: 1,
+ method: 'DELETE',
+ retry: false,
+ },
+ )
+ }
+
/** GET /v1/:server_id/worlds/:world_id/addons */
public async getAddons(
serverId: string,
@@ -13,6 +58,7 @@ export class ArchonContentV1Module extends AbstractModule {
options?: {
from_modpack?: boolean
disabled?: boolean
+ needs_side_type_review?: boolean
addons?: boolean
updates?: boolean
},
@@ -21,6 +67,8 @@ export class ArchonContentV1Module extends AbstractModule {
if (options?.from_modpack !== undefined)
params.set('from_modpack', String(options.from_modpack))
if (options?.disabled !== undefined) params.set('disabled', String(options.disabled))
+ if (options?.needs_side_type_review !== undefined)
+ params.set('needs_side_type_review', String(options.needs_side_type_review))
if (options?.addons !== undefined) params.set('addons', String(options.addons))
if (options?.updates !== undefined) params.set('updates', String(options.updates))
const query = params.toString()
@@ -105,6 +153,78 @@ export class ArchonContentV1Module extends AbstractModule {
})
}
+ /** POST /v1/:server_id/worlds/:world_id/addons/set-enabled-server */
+ public async setAddonEnabledServer(
+ serverId: string,
+ worldId: string,
+ request: Archon.Content.v1.SetAddonEnabledRequest,
+ ): Promise {
+ await this.client.request(
+ `/servers/${serverId}/worlds/${worldId}/addons/set-enabled-server`,
+ {
+ api: 'archon',
+ version: 1,
+ method: 'POST',
+ body: request,
+ },
+ )
+ }
+
+ /** POST /v1/:server_id/worlds/:world_id/addons/set-enabled-player */
+ public async setAddonEnabledPlayer(
+ serverId: string,
+ worldId: string,
+ request: Archon.Content.v1.SetAddonEnabledRequest,
+ ): Promise {
+ await this.client.request(
+ `/servers/${serverId}/worlds/${worldId}/addons/set-enabled-player`,
+ {
+ api: 'archon',
+ version: 1,
+ method: 'POST',
+ body: request,
+ },
+ )
+ }
+
+ /** POST /v1/:server_id/worlds/:world_id/addons/set-locked-side-toggle */
+ public async setAddonSideToggleLocked(
+ serverId: string,
+ worldId: string,
+ request: Archon.Content.v1.SetAddonSideToggleLockedRequest,
+ ): Promise {
+ await this.client.request(
+ `/servers/${serverId}/worlds/${worldId}/addons/set-locked-side-toggle`,
+ {
+ api: 'archon',
+ version: 1,
+ method: 'POST',
+ body: request,
+ },
+ )
+ }
+
+ /**
+ * POST /v1/:server_id/worlds/:world_id/addons/complete-side-type-review
+ *
+ * Clears the side review flag of the listed addons, or of every addon when none are listed.
+ */
+ public async completeSideTypeReview(
+ serverId: string,
+ worldId: string,
+ request: Archon.Content.v1.CompleteSideTypeReviewRequest = {},
+ ): Promise {
+ await this.client.request(
+ `/servers/${serverId}/worlds/${worldId}/addons/complete-side-type-review`,
+ {
+ api: 'archon',
+ version: 1,
+ method: 'POST',
+ body: request,
+ },
+ )
+ }
+
/** POST /v1/:server_id/worlds/:world_id/addons/delete-many */
public async deleteAddons(
serverId: string,
diff --git a/packages/api-client/src/modules/archon/icons/v1.ts b/packages/api-client/src/modules/archon/icons/v1.ts
new file mode 100644
index 00000000000..3808db70b70
--- /dev/null
+++ b/packages/api-client/src/modules/archon/icons/v1.ts
@@ -0,0 +1,41 @@
+import { AbstractModule } from '../../../core/abstract-module'
+
+export class ArchonIconsV1Module extends AbstractModule {
+ public getModuleID(): string {
+ return 'archon_icons_v1'
+ }
+
+ /**
+ * Get a server's custom icon.
+ * GET /v1/servers/:id/icon?original=true
+ *
+ * Returns the 64x64 game icon, or the up to 512x512 display icon when `original` is set.
+ */
+ public async get(serverId: string, original = false): Promise {
+ return this.client.request(`/servers/${encodeURIComponent(serverId)}/icon`, {
+ api: 'archon',
+ version: 1,
+ method: 'GET',
+ responseType: 'blob',
+ params: original ? { original: 'true' } : undefined,
+ })
+ }
+
+ public async set(serverId: string, image: Blob): Promise {
+ return this.client.request(`/servers/${encodeURIComponent(serverId)}/icon`, {
+ api: 'archon',
+ version: 1,
+ method: 'PUT',
+ headers: { 'Content-Type': 'application/octet-stream' },
+ body: image,
+ })
+ }
+
+ public async delete(serverId: string): Promise {
+ return this.client.request(`/servers/${encodeURIComponent(serverId)}/icon`, {
+ api: 'archon',
+ version: 1,
+ method: 'DELETE',
+ })
+ }
+}
diff --git a/packages/api-client/src/modules/archon/servers/v1.ts b/packages/api-client/src/modules/archon/servers/v1.ts
index baf1daef81f..955149bcdca 100644
--- a/packages/api-client/src/modules/archon/servers/v1.ts
+++ b/packages/api-client/src/modules/archon/servers/v1.ts
@@ -85,6 +85,23 @@ export class ArchonServersV1Module extends AbstractModule {
})
}
+ /**
+ * Modify a world
+ * PATCH /v1/servers/:server_id/worlds/:world_id
+ */
+ public async patchWorld(
+ serverId: string,
+ worldId: string,
+ body: Archon.Servers.v1.PatchWorld,
+ ): Promise {
+ await this.client.request(`/servers/${serverId}/worlds/${worldId}`, {
+ api: 'archon',
+ version: 1,
+ method: 'PATCH',
+ body,
+ })
+ }
+
/**
* Roll SFTP credentials for a server
* POST /v1/servers/:server_id/sftp/roll
diff --git a/packages/api-client/src/modules/archon/types.ts b/packages/api-client/src/modules/archon/types.ts
index a6c916a5b61..a0b9eaabb2e 100644
--- a/packages/api-client/src/modules/archon/types.ts
+++ b/packages/api-client/src/modules/archon/types.ts
@@ -121,10 +121,14 @@ export namespace Archon {
| 'addon_enabled'
| 'addon_deleted'
| 'addon_updated'
+ | 'addon_server_enabled'
+ | 'addon_player_enabled'
+ | 'addon_side_toggle_locked'
| 'modpack_changed'
| 'modpack_unlinked'
| 'server_repaired'
| 'server_reset'
+ | 'world_data_reset'
| 'server_started'
| 'server_stopped'
| 'server_restarted'
@@ -285,6 +289,44 @@ export namespace Archon {
export namespace Content {
export namespace v1 {
+ export type ShareWorldContentResponse = {
+ shared_instance_id: string
+ version: number | null
+ }
+
+ export type SharedContentChange =
+ | { kind: 'added'; after: T }
+ | { kind: 'removed'; before: T }
+ | { kind: 'updated'; before: T; after: T }
+
+ export type SharedContentDiffEntry =
+ | { type: 'project'; project_id: string; change: SharedContentChange }
+ | {
+ type: 'external_file'
+ file_type: string
+ file_name: string
+ kind: 'added' | 'removed' | 'updated'
+ }
+ | { type: 'modpack' | 'game_version'; change: SharedContentChange }
+ | { type: 'loader'; change: SharedContentChange<{ name: string; version: string | null }> }
+
+ export type SharedInstancePublishDiff = {
+ shared_instance_id: string
+ latest_version: number
+ local_updated_at: string
+ has_changes: boolean
+ diffs: SharedContentDiffEntry[]
+ projects: Record
+ versions: Record<
+ string,
+ {
+ project_id: string
+ name: string
+ version_number: string | null
+ }
+ >
+ }
+
export type AddonKind = 'mod' | 'plugin' | 'datapack' | 'shader' | 'resourcepack'
export type ContentOwnerType = 'user' | 'organization'
@@ -302,6 +344,25 @@ export namespace Archon {
environment?: Labrinth.Projects.v3.Environment | null
}
+ export type AddonManifestEnvironment =
+ | 'client_and_server'
+ | 'client_only'
+ | 'dedicated_server_only'
+
+ export type AddonManifestWarnings = {
+ multiple_mod_entries: number | null
+ malformed: boolean
+ }
+
+ export type AddonManifest = {
+ platform: Modloader
+ name: string | null
+ version: string | null
+ environment: AddonManifestEnvironment | null
+ icon_embedded: boolean
+ warnings: AddonManifestWarnings
+ }
+
export type AddonStatus =
| 'pending'
| 'installed'
@@ -317,11 +378,17 @@ export namespace Archon {
filesize: number
btime?: string
disabled: boolean
+ disabled_server: boolean
+ disabled_player: boolean
+ side_toggle_unlocked: boolean
+ manifest: AddonManifest | null
kind: AddonKind
from_modpack: boolean
status: AddonStatus
pack_client_retained: boolean
pack_client_depends: boolean
+ /** Whether the sides were guessed when installing its modpack, and should be reviewed. */
+ needs_side_type_review: boolean
has_update: string | null
name: string | null
project_id: string | null
@@ -334,14 +401,28 @@ export namespace Archon {
modloader: string | null
modloader_version: string | null
game_version: string | null
+ /** The least stable channel addon updates are offered from. */
+ update_channel: Archon.Servers.v1.ReleaseChannel
modpack: ModpackFields | null
installing?: 'loader' | 'modpack'
error?: {
message: string
}
+ /** The number of addons whose sides should be reviewed, regardless of the addon filters. */
+ files_need_side_type_review: number
addons: Addon[] | null
}
+ export type ReviewedAddon = {
+ kind: AddonKind
+ filename: string
+ }
+
+ export type CompleteSideTypeReviewRequest = {
+ /** The addons whose side review is completed, or every addon when absent. */
+ addons?: ReviewedAddon[] | null
+ }
+
export type AddAddonRequest = {
project_id: string
version_id?: string
@@ -355,6 +436,14 @@ export namespace Archon {
filename: string
}
+ export type SetAddonEnabledRequest = RemoveAddonRequest & {
+ enabled: boolean
+ }
+
+ export type SetAddonSideToggleLockedRequest = RemoveAddonRequest & {
+ locked: boolean
+ }
+
export type UpdateAddonRequest = {
filename: string
version_id?: string | null
@@ -382,7 +471,28 @@ export namespace Archon {
description: string | null
}
- export type ModpackSpec = ModpackSpecModrinth | ModpackSpecLocalFile
+ export type CurseForgeModpackLink = {
+ project_id: number
+ file_id: number
+ slug: string
+ name: string
+ /** The display name of the client pack file, usually including the modpack version. */
+ version_name: string
+ summary?: string
+ icon_url?: string
+ author?: string
+ server_pack_file_id?: number
+ }
+
+ export type ModpackSpecCurseForge = {
+ platform: 'curseforge'
+ /** The client pack's filename. */
+ filename: string
+ /** Present when installed from a link rather than uploaded packs. */
+ link?: CurseForgeModpackLink
+ }
+
+ export type ModpackSpec = ModpackSpecModrinth | ModpackSpecLocalFile | ModpackSpecCurseForge
export type ModpackOwner = {
id: string
@@ -798,9 +908,19 @@ export namespace Archon {
status: 'unassigned'
}
+ export type ReleaseChannel = 'release' | 'beta' | 'alpha'
+
+ export type PatchWorld = {
+ name?: string
+ icon_data?: string
+ update_channel?: ReleaseChannel
+ }
+
export type WorldFull = {
id: string
name: string
+ /** The least stable channel addon updates and dependencies are selected from. */
+ update_channel: ReleaseChannel
created_at: string
is_active: boolean
download_method: WorldDownloadMethod
@@ -817,6 +937,8 @@ export namespace Archon {
}
export type WorldContentInfo = {
+ shared_instance_id: string | null
+ shared_instance_needs_update: boolean
modloader: string
modloader_version: string
game_version: string
@@ -1060,8 +1182,24 @@ export namespace Archon {
game_version: string
platform_version: string | null
}
+ export type WorldContentCurseForgeModpackLink = {
+ project_id: number
+ file_id: number
+ slug: string
+ name: string
+ version_name: string
+ summary: string | null
+ icon_url: string | null
+ author: string | null
+ server_pack_file_id: number | null
+ }
export type WorldContentModpackSource =
- | 'CurseForge'
+ | {
+ CurseForge: {
+ filename: string
+ link: WorldContentCurseForgeModpackLink | null
+ }
+ }
| {
Modrinth: {
version_id: string
@@ -1091,6 +1229,10 @@ export namespace Archon {
has_update: string | null
}
export type WorldContentItem = {
+ disabled_server?: boolean
+ disabled_player?: boolean
+ side_toggle_unlocked?: boolean
+ needs_side_type_review?: boolean
parent_directory: string
file_sha1: string | null
filename: string
@@ -1100,6 +1242,7 @@ export namespace Archon {
project_id: string | null
pack_client_retained: boolean
pack_client_depends: boolean
+ manifest?: Archon.Content.v1.AddonManifest | null
status: Archon.Content.v1.AddonStatus
filesize: number | null
name: string | null
@@ -1119,6 +1262,33 @@ export namespace Archon {
}
content: WorldContentItem[]
}
+ export type WorldContentFileSideEvent = {
+ type: 'world.content.file.side.server.updated' | 'world.content.file.side.client.updated'
+ world_id: string
+ parent_directory: 'mods' | 'plugins' | 'datapacks' | 'resourcepacks' | 'shaderpacks'
+ filename: string
+ enabled: boolean
+ }
+ export type WorldContentFileSideLockEvent = {
+ type: 'world.content.file.side.lock.updated'
+ world_id: string
+ parent_directory: 'mods' | 'plugins' | 'datapacks' | 'resourcepacks' | 'shaderpacks'
+ filename: string
+ locked: boolean
+ }
+
+ export type WorldSharedInstanceUpdateEvent = {
+ type: 'world.shared_instance.update'
+ world_id: string
+ shared_instance_id: string
+ needs_update: boolean
+ }
+
+ export type WorldSharedInstanceDeleteEvent = {
+ type: 'world.shared_instance.delete'
+ world_id: string
+ shared_instance_id: string
+ }
export type SyncEvent =
| ProtocolResetEvent
@@ -1139,6 +1309,10 @@ export namespace Archon {
| WorldContentAddonPatchEvent
| WorldContentBaseUpdateEvent
| WorldContentUpdateEvent
+ | WorldContentFileSideEvent
+ | WorldContentFileSideLockEvent
+ | WorldSharedInstanceUpdateEvent
+ | WorldSharedInstanceDeleteEvent
}
}
@@ -1264,6 +1438,12 @@ export namespace Archon {
filename: string
}
+ export type InstallProgressCurseForgeModpackKey = {
+ type: 'curse_forge_modpack'
+ /** The client pack's filename. */
+ filename: string
+ }
+
export type InstallProgressPlatformKey = {
type: 'platform'
platform: 'forge' | 'neoforge' | 'fabric' | 'quilt' | 'paper' | 'purpur' | 'vanilla'
@@ -1275,6 +1455,7 @@ export namespace Archon {
| InstallProgressFileKey
| InstallProgressModrinthModpackKey
| InstallProgressLocalModpackKey
+ | InstallProgressCurseForgeModpackKey
| InstallProgressPlatformKey
export type InstallProgressItem = {
diff --git a/packages/api-client/src/modules/index.ts b/packages/api-client/src/modules/index.ts
index 6740b7a674e..711346ffd3d 100644
--- a/packages/api-client/src/modules/index.ts
+++ b/packages/api-client/src/modules/index.ts
@@ -4,6 +4,7 @@ import { ArchonActionsV1Module } from './archon/actions/v1'
import { ArchonBackupsV1Module } from './archon/backups/v1'
import { ArchonBackupsQueueV1Module } from './archon/backups-queue/v1'
import { ArchonContentV1Module } from './archon/content/v1'
+import { ArchonIconsV1Module } from './archon/icons/v1'
import { ArchonNodesInternalModule } from './archon/nodes/internal'
import { ArchonNoticesV0Module } from './archon/notices/v0'
import { ArchonOptionsV1Module } from './archon/options/v1'
@@ -17,6 +18,7 @@ import { ISO3166Module } from './iso3166'
import { KyrosContentV1Module } from './kyros/content/v1'
import { KyrosFilesV0Module } from './kyros/files/v0'
import { KyrosFilesV1Module } from './kyros/files/v1'
+import { KyrosFlameAnvilV1Module } from './kyros/flameanvil/v1'
import { KyrosLogsV1Module } from './kyros/logs/v1'
import { KyrosUploadSessionsV1Module } from './kyros/upload-sessions/v1'
import { LabrinthVersionsV2Module, LabrinthVersionsV3Module } from './labrinth'
@@ -84,6 +86,7 @@ export const MODULE_REGISTRY = {
archon_backups_queue_v1: ArchonBackupsQueueV1Module,
archon_backups_v1: ArchonBackupsV1Module,
archon_content_v1: ArchonContentV1Module,
+ archon_icons_v1: ArchonIconsV1Module,
archon_nodes_internal: ArchonNodesInternalModule,
archon_notices_v0: ArchonNoticesV0Module,
archon_options_v1: ArchonOptionsV1Module,
@@ -100,6 +103,7 @@ export const MODULE_REGISTRY = {
kyros_content_v1: KyrosContentV1Module,
kyros_files_v0: KyrosFilesV0Module,
kyros_files_v1: KyrosFilesV1Module,
+ kyros_flameanvil_v1: KyrosFlameAnvilV1Module,
kyros_logs_v1: KyrosLogsV1Module,
kyros_upload_sessions_v1: KyrosUploadSessionsV1Module,
labrinth_affiliate_internal: LabrinthAffiliateInternalModule,
diff --git a/packages/api-client/src/modules/kyros/content/v1.ts b/packages/api-client/src/modules/kyros/content/v1.ts
index 9f5f4f8b160..10e1bdbc9c6 100644
--- a/packages/api-client/src/modules/kyros/content/v1.ts
+++ b/packages/api-client/src/modules/kyros/content/v1.ts
@@ -1,5 +1,6 @@
import { AbstractModule } from '../../../core/abstract-module'
import type { UploadHandle, UploadProgress } from '../../../types/upload'
+import { getNodeBaseUrl } from '../../../utils/node-url'
import type { Archon } from '../../archon/types'
export class KyrosContentV1Module extends AbstractModule {
@@ -7,6 +8,25 @@ export class KyrosContentV1Module extends AbstractModule {
return 'kyros_content_v1'
}
+ /** GET /v1/worlds/:world_id/content/embedded-icon */
+ public async getEmbeddedAddonIcon(
+ worldId: string,
+ parentDirectory: 'mods' | 'plugins',
+ filename: string,
+ ): Promise {
+ return this.client.request(`/worlds/${worldId}/content/embedded-icon`, {
+ api: '',
+ version: 'v1',
+ method: 'GET',
+ responseType: 'blob',
+ params: {
+ parent_directory: parentDirectory,
+ filename,
+ },
+ useNodeAuth: true,
+ })
+ }
+
/**
* Upload addon files to a world via multipart form data
*
@@ -45,6 +65,7 @@ export class KyrosContentV1Module extends AbstractModule {
options?: {
softOverride?: boolean
onProgress?: (progress: UploadProgress) => void
+ auth?: Archon.Servers.v0.JWTAuth
},
): UploadHandle {
const formData = new FormData()
@@ -52,7 +73,7 @@ export class KyrosContentV1Module extends AbstractModule {
formData.append('properties', JSON.stringify(properties))
return this.client.upload(`/worlds/${worldId}/content/upload-modpack-file`, {
- api: '',
+ api: options?.auth ? getNodeBaseUrl(options.auth.url) : '',
version: 'v1',
formData,
params:
@@ -60,7 +81,9 @@ export class KyrosContentV1Module extends AbstractModule {
? { soft_override: String(options.softOverride) }
: undefined,
onProgress: options?.onProgress,
- useNodeAuth: true,
+ ...(options?.auth
+ ? { headers: { Authorization: `Bearer ${options.auth.token}` }, skipAuth: true }
+ : { useNodeAuth: true }),
})
}
}
diff --git a/packages/api-client/src/modules/kyros/files/v0.ts b/packages/api-client/src/modules/kyros/files/v0.ts
index f31ff5ec000..5866f4c92f7 100644
--- a/packages/api-client/src/modules/kyros/files/v0.ts
+++ b/packages/api-client/src/modules/kyros/files/v0.ts
@@ -1,4 +1,5 @@
import { AbstractModule } from '../../../core/abstract-module'
+import type { DownloadSink } from '../../../types/download'
import type { UploadHandle, UploadProgress } from '../../../types/upload'
import { getNodeBaseUrl } from '../../../utils/node-url'
import type { Archon } from '../../archon/types'
@@ -88,6 +89,21 @@ export class KyrosFilesV0Module extends AbstractModule {
})
}
+ public async downloadFileTo(auth: NodeFsAuth, path: string, sink: DownloadSink): Promise {
+ return this.client.download(
+ '/fs/download',
+ {
+ api: this.getNodeBaseUrl(auth),
+ version: 'modrinth/v0',
+ method: 'GET',
+ params: { path },
+ headers: { Authorization: `Bearer ${auth.token}` },
+ skipAuth: true,
+ },
+ sink,
+ )
+ }
+
/**
* Upload a file to a server's filesystem with progress tracking
*
diff --git a/packages/api-client/src/modules/kyros/flameanvil/v1.ts b/packages/api-client/src/modules/kyros/flameanvil/v1.ts
new file mode 100644
index 00000000000..f3bb88ee7ea
--- /dev/null
+++ b/packages/api-client/src/modules/kyros/flameanvil/v1.ts
@@ -0,0 +1,155 @@
+import { AbstractModule } from '../../../core/abstract-module'
+import type { UploadHandle, UploadProgress } from '../../../types/upload'
+import { getNodeBaseUrl } from '../../../utils/node-url'
+import type { Archon } from '../../archon/types'
+import type { Kyros } from '../types'
+
+export type FlameAnvilAuthOptions = {
+ auth?: Archon.Servers.v0.JWTAuth
+}
+
+export type FlameAnvilUploadOptions = FlameAnvilAuthOptions & {
+ onProgress?: (progress: UploadProgress) => void
+}
+
+function getSessionPath(worldId: string) {
+ return `/worlds/${worldId}/content/flameanvil/session`
+}
+
+function nodeRequestOptions(auth?: Archon.Servers.v0.JWTAuth) {
+ return {
+ api: auth ? getNodeBaseUrl(auth.url) : '',
+ version: 'v1' as const,
+ ...(auth
+ ? { headers: { Authorization: `Bearer ${auth.token}` }, skipAuth: true }
+ : { useNodeAuth: true }),
+ }
+}
+
+/**
+ * Installs CurseForge modpacks, either from a CurseForge link or from uploaded client and server packs.
+ */
+export class KyrosFlameAnvilV1Module extends AbstractModule {
+ public getModuleID(): string {
+ return 'kyros_flameanvil_v1'
+ }
+
+ /** POST /v1/worlds/:world_id/content/flameanvil/link/query */
+ public async queryLink(
+ worldId: string,
+ data: Kyros.FlameAnvil.v1.LinkQueryRequest,
+ options?: FlameAnvilAuthOptions,
+ ): Promise {
+ return this.client.request(
+ `/worlds/${worldId}/content/flameanvil/link/query`,
+ {
+ ...nodeRequestOptions(options?.auth),
+ method: 'POST',
+ body: data,
+ },
+ )
+ }
+
+ /** GET /v1/worlds/:world_id/content/flameanvil/session */
+ public async getSession(
+ worldId: string,
+ options?: FlameAnvilAuthOptions,
+ ): Promise {
+ return this.client.request(getSessionPath(worldId), {
+ ...nodeRequestOptions(options?.auth),
+ method: 'GET',
+ })
+ }
+
+ /** POST /v1/worlds/:world_id/content/flameanvil/session */
+ public async createSession(
+ worldId: string,
+ options?: FlameAnvilAuthOptions,
+ ): Promise {
+ return this.client.request(getSessionPath(worldId), {
+ ...nodeRequestOptions(options?.auth),
+ method: 'POST',
+ })
+ }
+
+ /** DELETE /v1/worlds/:world_id/content/flameanvil/session/:upload_id */
+ public async cancelSession(
+ worldId: string,
+ uploadId: string,
+ options?: FlameAnvilAuthOptions,
+ ): Promise {
+ return this.client.request(
+ `${getSessionPath(worldId)}/${uploadId}`,
+ {
+ ...nodeRequestOptions(options?.auth),
+ method: 'DELETE',
+ },
+ )
+ }
+
+ /**
+ * POST /v1/worlds/:world_id/content/flameanvil/session/:upload_id/upload/player
+ *
+ * Uploads the client modpack. Uploading again replaces it.
+ */
+ public uploadPlayerPack(
+ worldId: string,
+ uploadId: string,
+ file: File | Blob,
+ options?: FlameAnvilUploadOptions,
+ ): UploadHandle {
+ return this.uploadPack(worldId, uploadId, 'player', file, options)
+ }
+
+ /**
+ * POST /v1/worlds/:world_id/content/flameanvil/session/:upload_id/upload/server
+ *
+ * Uploads the server pack. Uploading again replaces it.
+ */
+ public uploadServerPack(
+ worldId: string,
+ uploadId: string,
+ file: File | Blob,
+ options?: FlameAnvilUploadOptions,
+ ): UploadHandle {
+ return this.uploadPack(worldId, uploadId, 'server', file, options)
+ }
+
+ /**
+ * POST /v1/worlds/:world_id/content/flameanvil/session/:upload_id/execute
+ *
+ * Queues the installation, either from `data.link` or from the uploaded packs.
+ */
+ public async executeSession(
+ worldId: string,
+ uploadId: string,
+ data: Kyros.FlameAnvil.v1.ExecuteSessionRequest,
+ options?: FlameAnvilAuthOptions,
+ ): Promise {
+ return this.client.request(`${getSessionPath(worldId)}/${uploadId}/execute`, {
+ ...nodeRequestOptions(options?.auth),
+ method: 'POST',
+ body: data,
+ })
+ }
+
+ private uploadPack(
+ worldId: string,
+ uploadId: string,
+ side: 'player' | 'server',
+ file: File | Blob,
+ options?: FlameAnvilUploadOptions,
+ ): UploadHandle {
+ const formData = new FormData()
+ formData.append('file', file, file instanceof File ? file.name : 'file')
+
+ return this.client.upload(
+ `${getSessionPath(worldId)}/${uploadId}/upload/${side}`,
+ {
+ ...nodeRequestOptions(options?.auth),
+ formData,
+ onProgress: options?.onProgress,
+ },
+ )
+ }
+}
diff --git a/packages/api-client/src/modules/kyros/types.ts b/packages/api-client/src/modules/kyros/types.ts
index 533a2178073..8bb8239b4f4 100644
--- a/packages/api-client/src/modules/kyros/types.ts
+++ b/packages/api-client/src/modules/kyros/types.ts
@@ -1,4 +1,63 @@
+import type { Archon } from '../archon/types'
+
export namespace Kyros {
+ export namespace FlameAnvil {
+ export namespace v1 {
+ export type SessionStatus = Kyros.UploadSessions.v1.UploadSessionStatus
+
+ export interface UploadedPack {
+ filename: string
+ size: number
+ }
+
+ export interface SessionResponse {
+ upload_id: string
+ status: SessionStatus
+ created_at: number
+ updated_at: number
+ expires_at: number
+ client_pack?: UploadedPack | null
+ server_pack?: UploadedPack | null
+ }
+
+ export interface GetSessionResponse {
+ session: SessionResponse | null
+ }
+
+ export interface LinkQueryRequest {
+ link: string
+ }
+
+ export interface LinkQueryFile {
+ id: number
+ display_name: string
+ file_name: string
+ file_date: string
+ file_length: number
+ game_versions: string[]
+ }
+
+ export interface LinkQueryResponse {
+ project_id: number
+ slug: string
+ name: string
+ summary?: string | null
+ icon_url?: string | null
+ authors: string[]
+ file: LinkQueryFile
+ server_pack?: LinkQueryFile | null
+ server_pack_missing: boolean
+ }
+
+ export interface ExecuteSessionRequest {
+ /** Mutually exclusive with uploaded packs. */
+ link?: string | null
+ soft_override?: boolean
+ properties: Archon.Content.v1.PropertiesFields
+ }
+ }
+ }
+
export namespace UploadSessions {
export namespace v1 {
export type Scope = 'content' | 'files'
diff --git a/packages/api-client/src/modules/shared-instances/instances/v1.ts b/packages/api-client/src/modules/shared-instances/instances/v1.ts
index 7b958104639..007aa4d1c5a 100644
--- a/packages/api-client/src/modules/shared-instances/instances/v1.ts
+++ b/packages/api-client/src/modules/shared-instances/instances/v1.ts
@@ -1,4 +1,5 @@
import { AbstractModule } from '../../../core/abstract-module'
+import type { DownloadSink } from '../../../types/download'
import type { SharedInstances } from '../types'
export class SharedInstancesInstancesV1Module extends AbstractModule {
@@ -6,13 +7,17 @@ export class SharedInstancesInstancesV1Module extends AbstractModule {
return 'sharedinstances_instances_v1'
}
- public async get(instanceId: string): Promise {
+ public async get(
+ instanceId: string,
+ params?: { query_linked_server?: boolean },
+ ): Promise {
return this.client.request(
`/instances/${encodeURIComponent(instanceId)}`,
{
api: 'sharedinstances',
version: 1,
method: 'GET',
+ params,
},
)
}
@@ -63,4 +68,48 @@ export class SharedInstancesInstancesV1Module extends AbstractModule {
},
)
}
+
+ public async inviteUsers(instanceId: string, userIds: string[]): Promise<{ failed: string[] }> {
+ return this.client.request(`/instances/${encodeURIComponent(instanceId)}/users`, {
+ api: 'sharedinstances',
+ version: 1,
+ method: 'POST',
+ body: { user_ids: userIds },
+ retry: false,
+ })
+ }
+
+ public async removeUsers(instanceId: string, userIds: string[]): Promise {
+ return this.client.request(`/instances/${encodeURIComponent(instanceId)}/users`, {
+ api: 'sharedinstances',
+ version: 1,
+ method: 'DELETE',
+ body: { user_ids: userIds },
+ })
+ }
+
+ public async downloadMrpack(instanceId: string, version: number): Promise {
+ return this.client.request(
+ `/instances/${encodeURIComponent(instanceId)}/versions/${version}/mrpack`,
+ {
+ api: 'sharedinstances',
+ version: 1,
+ method: 'GET',
+ responseType: 'blob',
+ timeout: 600_000,
+ },
+ )
+ }
+
+ public async downloadMrpackTo(
+ instanceId: string,
+ version: number,
+ sink: DownloadSink,
+ ): Promise {
+ return this.client.download(
+ `/instances/${encodeURIComponent(instanceId)}/versions/${version}/mrpack`,
+ { api: 'sharedinstances', version: 1, method: 'GET' },
+ sink,
+ )
+ }
}
diff --git a/packages/api-client/src/modules/shared-instances/invites/v1.ts b/packages/api-client/src/modules/shared-instances/invites/v1.ts
index 72536cd0a0e..93ce3c862a2 100644
--- a/packages/api-client/src/modules/shared-instances/invites/v1.ts
+++ b/packages/api-client/src/modules/shared-instances/invites/v1.ts
@@ -6,16 +6,52 @@ export class SharedInstancesInvitesV1Module extends AbstractModule {
return 'sharedinstances_invites_v1'
}
- public async get(inviteId: string): Promise {
+ public async get(
+ inviteId: string,
+ options?: { version?: boolean },
+ ): Promise {
return this.client.request(
`/invites/${encodeURIComponent(inviteId)}`,
{
api: 'sharedinstances',
version: 1,
method: 'GET',
+ params: options,
skipAuth: true,
retry: false,
},
)
}
+
+ public async list(instanceId: string): Promise {
+ return this.client.request(`/instances/${encodeURIComponent(instanceId)}/invites`, {
+ api: 'sharedinstances',
+ version: 1,
+ method: 'GET',
+ })
+ }
+
+ public async create(
+ instanceId: string,
+ options: { max_age?: number; max_uses: number },
+ ): Promise<{ id: string }> {
+ return this.client.request(`/instances/${encodeURIComponent(instanceId)}/invites`, {
+ api: 'sharedinstances',
+ version: 1,
+ method: 'POST',
+ body: options,
+ retry: false,
+ })
+ }
+
+ public async delete(instanceId: string, inviteId: string): Promise {
+ return this.client.request(
+ `/instances/${encodeURIComponent(instanceId)}/invites/${encodeURIComponent(inviteId)}`,
+ {
+ api: 'sharedinstances',
+ version: 1,
+ method: 'DELETE',
+ },
+ )
+ }
}
diff --git a/packages/api-client/src/modules/shared-instances/types.ts b/packages/api-client/src/modules/shared-instances/types.ts
index 4ad1e3afbf7..164d13dad71 100644
--- a/packages/api-client/src/modules/shared-instances/types.ts
+++ b/packages/api-client/src/modules/shared-instances/types.ts
@@ -1,6 +1,12 @@
export namespace SharedInstances {
export namespace Invites {
export namespace v1 {
+ export type Inviter = {
+ id: string
+ name: string
+ avatar: string | null
+ }
+
export type UserManager = {
id: string
name: string
@@ -23,24 +29,36 @@ export namespace SharedInstances {
joined_at: string | null
}
+ export type InviteLink = {
+ id: string
+ expiration: string
+ max_uses: number
+ uses: number
+ }
+
export type Invite = {
instance_id: string
instance_name: string
instance_icon?: string | null
game_version: string
loader_version: string
+ inviter: Inviter | null
managers: Manager[]
instance_users?: InviteUser[]
+ version?: Instances.v1.InstanceVersion
}
}
}
export namespace Instances {
export namespace v1 {
+ export type OnlineStatus = 'unknown' | 'running' | 'stopped' | null
+
export type Instance = {
name: string
icon: string | null
quarantine: boolean
+ linked_server: { domain: string; region: string; online_status: OnlineStatus } | null
}
export type JoinType = 'owner' | 'invite' | 'link'
@@ -54,7 +72,6 @@ export namespace SharedInstances {
export type InstanceUsers = {
users: InstanceUser[]
- tokens: number
}
export type FileMetadata = {
@@ -65,7 +82,7 @@ export namespace SharedInstances {
export type ExternalFile = {
file_name: string
file_type: string
- url: string
+ url: string | null
file_size?: number
metadata?: FileMetadata[]
}
@@ -76,6 +93,10 @@ export namespace SharedInstances {
ready: boolean
external_files: ExternalFile[]
modpack_id: string | null
+ removed_files: (
+ | { type: 'version'; version_id: string }
+ | { type: 'path'; parent: string; filename: string }
+ )[]
game_version: string
loader: string
loader_version: string
diff --git a/packages/api-client/src/platform/generic.ts b/packages/api-client/src/platform/generic.ts
index 7ec63b68249..bc2f1972286 100644
--- a/packages/api-client/src/platform/generic.ts
+++ b/packages/api-client/src/platform/generic.ts
@@ -46,8 +46,9 @@ export class GenericModrinthClient extends XHRUploadClient {
protected async executeRequest(url: string, options: RequestOptions): Promise {
try {
- const response = await $fetch(url, {
+ const response = await $fetch(url, {
method: options.method ?? 'GET',
+ responseType: options.responseType,
headers: options.headers,
body: options.body as BodyInit,
params: options.params as Record,
@@ -55,7 +56,7 @@ export class GenericModrinthClient extends XHRUploadClient {
signal: options.signal,
})
- return response
+ return response as T
} catch (error) {
// ofetch throws FetchError for HTTP errors
throw this.normalizeError(error)
diff --git a/packages/api-client/src/platform/nuxt.ts b/packages/api-client/src/platform/nuxt.ts
index a5308535ba3..b09f5077fca 100644
--- a/packages/api-client/src/platform/nuxt.ts
+++ b/packages/api-client/src/platform/nuxt.ts
@@ -160,6 +160,7 @@ export class NuxtModrinthClient extends XHRUploadClient {
// @ts-expect-error - $fetch is provided by Nuxt
const response = await $fetch(url, {
method: options.method ?? 'GET',
+ responseType: options.responseType,
headers: options.headers,
body: options.body,
params: options.params,
diff --git a/packages/api-client/src/platform/tauri.ts b/packages/api-client/src/platform/tauri.ts
index ac82b53edba..78fd17787c2 100644
--- a/packages/api-client/src/platform/tauri.ts
+++ b/packages/api-client/src/platform/tauri.ts
@@ -92,7 +92,7 @@ export class TauriModrinthClient extends XHRUploadClient {
// Handle binary downloads (e.g. kyros fs files) before JSON parsing.
const contentType = response.headers.get('content-type')?.toLowerCase() ?? ''
- if (fullUrl.includes('/fs/download')) {
+ if (options.responseType === 'blob' || fullUrl.includes('/fs/download')) {
return (await response.blob()) as T
}
if (
diff --git a/packages/api-client/src/types/download.ts b/packages/api-client/src/types/download.ts
new file mode 100644
index 00000000000..d8619e29415
--- /dev/null
+++ b/packages/api-client/src/types/download.ts
@@ -0,0 +1,3 @@
+import type { RequestOptions } from './request'
+
+export type DownloadSink = (url: string, options: RequestOptions) => Promise
diff --git a/packages/api-client/src/types/index.ts b/packages/api-client/src/types/index.ts
index 2fb40b14e4f..a825238577a 100644
--- a/packages/api-client/src/types/index.ts
+++ b/packages/api-client/src/types/index.ts
@@ -8,6 +8,7 @@ export type {
export type { BackoffStrategy, RetryConfig } from '../features/retry'
export type { Archon } from '../modules/archon/types'
export type { BaseUrlConfig, ClientConfig, RequestHooks } from './client'
+export type { DownloadSink } from './download'
export type { ApiErrorData, ModrinthErrorResponse } from './errors'
export { isModrinthErrorResponse } from './errors'
export type { HttpMethod, RequestContext, RequestOptions, ResponseData } from './request'
diff --git a/packages/api-client/src/types/request.ts b/packages/api-client/src/types/request.ts
index d1a57d8845a..ca7b9836530 100644
--- a/packages/api-client/src/types/request.ts
+++ b/packages/api-client/src/types/request.ts
@@ -29,6 +29,9 @@ export type RequestOptions = {
*/
method?: HttpMethod
+ /** Explicit response decoding for binary downloads. */
+ responseType?: 'blob'
+
/**
* Request headers
*/
diff --git a/packages/app-lib/.env.prod-with-staging-archon b/packages/app-lib/.env.prod-with-staging-archon
index d27b5433835..04cf875ab11 100644
--- a/packages/app-lib/.env.prod-with-staging-archon
+++ b/packages/app-lib/.env.prod-with-staging-archon
@@ -1,6 +1,6 @@
MODRINTH_URL=https://modrinth.com/
MODRINTH_API_BASE_URL=https://api.modrinth.com/
-SHARED_INSTANCES_API_BASE_URL=https://shared-instances.modrinth.com/
+SHARED_INSTANCES_API_BASE_URL=https://staging-shared-instances.modrinth.com/
MODRINTH_ARCHON_BASE_URL=https://staging-archon.modrinth.com/
MODRINTH_API_URL=https://api.modrinth.com/v2/
MODRINTH_API_URL_V3=https://api.modrinth.com/v3/
diff --git a/packages/app-lib/src/api/handler.rs b/packages/app-lib/src/api/handler.rs
index 1f16218dc8b..8615826e513 100644
--- a/packages/app-lib/src/api/handler.rs
+++ b/packages/app-lib/src/api/handler.rs
@@ -30,6 +30,28 @@ pub async fn handle_url(sublink: &str) -> crate::Result {
Some(("server", id)) => {
CommandPayload::InstallServer { id: id.to_string() }
}
+ Some(("hosting", path)) => {
+ let (server_id, world_id) =
+ path.split_once('/').ok_or_else(|| {
+ crate::ErrorKind::InputError(
+ "Missing hosting world ID".to_string(),
+ )
+ })?;
+ let server_id = uuid::Uuid::parse_str(server_id).map_err(|_| {
+ crate::ErrorKind::InputError(
+ "Invalid hosting server ID".to_string(),
+ )
+ })?;
+ let world_id = uuid::Uuid::parse_str(world_id).map_err(|_| {
+ crate::ErrorKind::InputError(
+ "Invalid hosting world ID".to_string(),
+ )
+ })?;
+ CommandPayload::PlayHostingServer {
+ server_id: server_id.to_string(),
+ world_id: world_id.to_string(),
+ }
+ }
// /share/{invite_id}
Some(("share", raw)) => {
let (raw, _) = raw.split_once('?').unwrap_or((raw, ""));
diff --git a/packages/app-lib/src/api/instance.rs b/packages/app-lib/src/api/instance.rs
index 9f7b21562b6..07984898f80 100644
--- a/packages/app-lib/src/api/instance.rs
+++ b/packages/app-lib/src/api/instance.rs
@@ -40,8 +40,9 @@ pub use self::groups::{
set_group_memberships, set_group_order,
};
pub use self::icon::{
- cache_generated_icon, edit_generated_icon, edit_generated_icon_if_empty,
- edit_icon, get_recent_icon_configs,
+ cache_generated_icon, cache_icon_bytes, cache_remote_icon,
+ edit_generated_icon, edit_generated_icon_if_empty, edit_icon,
+ get_recent_icon_configs,
};
pub(crate) use self::icon::{
cache_icon, cache_icon_from_path, migrate_legacy_icons,
@@ -75,21 +76,24 @@ pub use self::screenshots::{
};
pub(crate) use self::shared::{
CONFIG_BUNDLE_FILE_TYPE, CONFIG_DIRECTORY, CONFIG_FILE_EXTENSIONS,
- CONFIG_SYNC_ENABLED, MAX_CONFIG_BUNDLE_ENTRIES,
- read_bounded_config_bundle_entry,
+ CONFIG_FILE_TYPE, CONFIG_SYNC_ENABLED, MAX_CONFIG_BUNDLE_ENTRIES,
+ MAX_CONFIG_BUNDLE_FILE_SIZE, is_shareable_config_path,
+ is_supported_config_file, read_bounded_config_bundle_entry,
+ shared_modpack_files,
};
pub use self::shared::{
SharedInstanceExternalFilePreview, SharedInstanceInstallPreview,
- SharedInstanceInvite, SharedInstanceInviteInstallPreview,
- SharedInstanceInviteLink, SharedInstanceJoinType,
- SharedInstancePublishPreview, SharedInstanceUpdateDiff,
- SharedInstanceUpdateDiffType, SharedInstanceUpdatePreview,
- SharedInstanceUser, SharedInstanceUsers,
+ SharedInstanceInvite, SharedInstanceInviteCreator,
+ SharedInstanceInviteInstallPreview, SharedInstanceInviteLink,
+ SharedInstanceJoinType, SharedInstancePublishPreview,
+ SharedInstanceUpdateDiff, SharedInstanceUpdateDiffType,
+ SharedInstanceUpdatePreview, SharedInstanceUser, SharedInstanceUsers,
accept_pending_shared_instance_invite,
accept_shared_instance_invite_for_install,
- can_active_user_use_shared_instances, create_shared_instance_invite_link,
- decline_pending_shared_instance_invite,
- get_shared_instance_install_preview, get_shared_instance_invites,
+ cache_shared_instance_server_icon, can_active_user_use_shared_instances,
+ create_shared_instance_invite_link, decline_pending_shared_instance_invite,
+ get_shared_instance_install_preview,
+ get_shared_instance_invite_install_preview, get_shared_instance_invites,
get_shared_instance_publish_preview, get_shared_instance_update_preview,
get_shared_instance_users, install_shared_instance,
invite_shared_instance_users, publish_shared_instance,
diff --git a/packages/app-lib/src/api/instance/icon.rs b/packages/app-lib/src/api/instance/icon.rs
index e9692257d48..3bd894a5fb9 100644
--- a/packages/app-lib/src/api/instance/icon.rs
+++ b/packages/app-lib/src/api/instance/icon.rs
@@ -4,6 +4,7 @@ use crate::state::instances::adapters::sqlite::instance_rows;
use crate::state::{
EditInstance, InstanceIconBackground, InstanceIconConfig, State,
};
+use crate::util::content_hash::temporary_file;
use crate::util::fetch::{sha1_async, write};
use crate::util::io;
use bytes::Bytes;
@@ -12,6 +13,7 @@ use image::{DynamicImage, ImageFormat, ImageReader, Rgba, RgbaImage};
use std::fs::File as StdFile;
use std::io::{BufRead, BufReader, Cursor, Seek};
use std::path::{Path, PathBuf};
+use tokio::io::AsyncWriteExt;
const INSTANCE_ICON_MAX_BYTES: usize = 4 * 1024 * 1024;
const INSTANCE_ICON_MAX_DIMENSION: u32 = 512;
@@ -22,6 +24,12 @@ const MAX_ICON_CONFIG_ID_LENGTH: usize = 64;
const MAX_SYMBOL_BYTES: usize = 4 * 1024 * 1024;
const MAX_SYMBOL_DIMENSION: u32 = 4096;
+const REMOTE_ICON_MAX_BYTES: usize = 4 * 1024 * 1024;
+const REMOTE_ICON_MAX_AGE: std::time::Duration =
+ std::time::Duration::from_secs(24 * 60 * 60);
+static REMOTE_ICON_DOWNLOADS: tokio::sync::Semaphore =
+ tokio::sync::Semaphore::const_new(4);
+
enum LegacyIconAction {
Keep,
Normalize,
@@ -56,6 +64,99 @@ pub async fn edit_icon(
apply_instance_icon(instance_id, icon_path, None, &state).await
}
+pub async fn cache_icon_bytes(icon_bytes: Vec) -> crate::Result {
+ let state = State::get().await?;
+ let icon_path = cache_icon(Bytes::from(icon_bytes), &state).await?;
+ Ok(icon_path.to_string_lossy().to_string())
+}
+
+pub async fn cache_remote_icon(source: &str) -> crate::Result {
+ let state = State::get().await?;
+ let icons = state.directories.caches_dir().join("icons");
+ let source_hash =
+ sha1_async(Bytes::copy_from_slice(source.as_bytes())).await?;
+ let mapping = icons.join(format!("remote-{source_hash}.txt"));
+ let mut cached_path = None;
+ if let Ok(metadata) = tokio::fs::metadata(&mapping).await
+ && metadata.len() <= 44
+ && let Ok(filename) = tokio::fs::read_to_string(&mapping).await
+ && filename.len() == 44
+ && filename.ends_with(".png")
+ && filename.as_bytes()[..40].iter().all(u8::is_ascii_hexdigit)
+ {
+ let path = icons.join(filename);
+ if tokio::fs::try_exists(&path).await? {
+ let fresh = metadata
+ .modified()
+ .ok()
+ .and_then(|modified| modified.elapsed().ok())
+ .is_some_and(|age| age < REMOTE_ICON_MAX_AGE);
+ if fresh {
+ return Ok(io::canonicalize(path)?);
+ }
+ cached_path = Some(path);
+ }
+ }
+
+ let _permit = REMOTE_ICON_DOWNLOADS.acquire().await?;
+ let refreshed = async {
+ let bytes = download_remote_icon(source).await?;
+ let path = cache_icon(bytes, &state).await?;
+ let filename = path
+ .file_name()
+ .ok_or_else(|| {
+ crate::ErrorKind::InputError(
+ "Cached icon has no filename".to_string(),
+ )
+ })?
+ .to_string_lossy();
+ write(&mapping, filename.as_bytes(), &state.io_semaphore).await?;
+ Ok::<_, crate::Error>(path)
+ }
+ .await;
+
+ match refreshed {
+ Ok(path) => Ok(path),
+ Err(error) => {
+ if let Some(path) = cached_path {
+ tracing::warn!(source, %error, "Could not refresh cached icon");
+ Ok(io::canonicalize(path)?)
+ } else {
+ Err(error)
+ }
+ }
+ }
+}
+
+async fn download_remote_icon(source: &str) -> crate::Result {
+ let mut response = crate::util::fetch::REQWEST_CLIENT
+ .get(source)
+ .timeout(std::time::Duration::from_secs(15))
+ .send()
+ .await?
+ .error_for_status()?;
+ if response
+ .content_length()
+ .is_some_and(|length| length > REMOTE_ICON_MAX_BYTES as u64)
+ {
+ return Err(crate::ErrorKind::InputError(
+ "Remote icons must be at most 4 MiB".to_string(),
+ )
+ .into());
+ }
+ let mut bytes = Vec::new();
+ while let Some(chunk) = response.chunk().await? {
+ if bytes.len() + chunk.len() > REMOTE_ICON_MAX_BYTES {
+ return Err(crate::ErrorKind::InputError(
+ "Remote icons must be at most 4 MiB".to_string(),
+ )
+ .into());
+ }
+ bytes.extend_from_slice(&chunk);
+ }
+ Ok(Bytes::from(bytes))
+}
+
pub async fn edit_generated_icon(
instance_id: &str,
config: InstanceIconConfig,
@@ -317,12 +418,21 @@ async fn write_cached_icon(
}
let hash = sha1_async(bytes.clone()).await?;
- let path = state
- .directories
- .caches_dir()
- .join("icons")
- .join(format!("{hash}.png"));
- write(&path, &bytes, &state.io_semaphore).await?;
+ let directory = state.directories.caches_dir().join("icons");
+ let path = directory.join(format!("{hash}.png"));
+ if let Ok(metadata) = tokio::fs::metadata(&path).await
+ && metadata.is_file()
+ && metadata.len() == bytes.len() as u64
+ {
+ return Ok(io::canonicalize(path)?);
+ }
+ let _permit = state.io_semaphore.0.acquire().await?;
+ tokio::fs::create_dir_all(&directory).await?;
+ let (mut file, temporary) = temporary_file(Some(&directory)).await?;
+ file.write_all(&bytes).await?;
+ file.flush().await?;
+ drop(file);
+ tokio::fs::rename(&temporary, &path).await?;
Ok(io::canonicalize(path)?)
}
diff --git a/packages/app-lib/src/api/instance/shared/client.rs b/packages/app-lib/src/api/instance/shared/client.rs
index bedd567b3fc..90454569cd5 100644
--- a/packages/app-lib/src/api/instance/shared/client.rs
+++ b/packages/app-lib/src/api/instance/shared/client.rs
@@ -34,6 +34,11 @@ pub(super) enum SharedInstanceRemoteResponse {
#[derive(Clone, Debug, Deserialize)]
pub(super) struct RemoteInstanceResponse {
+ pub(super) name: String,
+ pub(super) icon: Option,
+ #[serde(default)]
+ pub(super) linked_server:
+ Option,
#[serde(default)]
pub(super) quarantine: bool,
}
@@ -48,7 +53,7 @@ pub(super) struct ExternalFileCandidate {
#[derive(Clone, Debug)]
pub(super) enum ExternalFileSource {
InstanceFile(String),
- ConfigBundle(std::sync::Arc),
+ ConfigFile(std::path::PathBuf),
}
#[derive(Clone, Debug, Serialize, Deserialize)]
@@ -93,7 +98,11 @@ pub(super) struct InstanceInviteInfoResponse {
#[serde(default)]
pub(super) instance_icon: Option,
#[serde(default)]
+ pub(super) inviter: Option,
+ #[serde(default)]
pub(super) managers: Vec,
+ #[serde(default)]
+ pub(super) version: Option,
}
#[derive(Clone, Debug, Deserialize)]
@@ -104,27 +113,85 @@ pub(super) enum InstanceInviteManagerResponse {
}
#[derive(Clone, Debug, Deserialize)]
+#[serde(from = "RawInstanceVersionResponse")]
pub(super) struct InstanceVersionResponse {
pub(super) version: i32,
- #[serde(default)]
pub(super) modrinth_ids: Vec,
pub(super) ready: bool,
- #[serde(default)]
pub(super) external_files: Vec,
- #[serde(default)]
pub(super) modpack_id: Option,
+ pub(super) removed_files: Vec,
pub(super) game_version: String,
pub(super) loader: ModLoader,
pub(super) loader_version: String,
}
+#[derive(Deserialize)]
+struct RawInstanceVersionResponse {
+ version: i32,
+ #[serde(default)]
+ modrinth_ids: Vec,
+ ready: bool,
+ #[serde(default)]
+ external_files: Vec,
+ #[serde(default)]
+ modpack_id: Option,
+ #[serde(default)]
+ removed_files: Vec,
+ game_version: String,
+ loader: String,
+ loader_version: String,
+}
+
+impl From for InstanceVersionResponse {
+ /// Servers without a client loader (vanilla, Paper, Purpur) are installed
+ /// as Fabric so players can add client-side mods on top.
+ fn from(raw: RawInstanceVersionResponse) -> Self {
+ let (loader, loader_version) = match ModLoader::from_string(&raw.loader)
+ {
+ ModLoader::Vanilla => (ModLoader::Fabric, String::new()),
+ loader => (loader, raw.loader_version),
+ };
+ Self {
+ version: raw.version,
+ modrinth_ids: raw.modrinth_ids,
+ ready: raw.ready,
+ external_files: raw.external_files,
+ modpack_id: raw.modpack_id,
+ removed_files: raw.removed_files,
+ game_version: raw.game_version,
+ loader,
+ loader_version,
+ }
+ }
+}
+
+impl InstanceVersionResponse {
+ pub(super) fn validate_removed_files(&self) -> crate::Result<()> {
+ if self.modpack_id.as_deref().is_none_or(str::is_empty)
+ && !self.removed_files.is_empty()
+ {
+ return Err(crate::ErrorKind::InputError(
+ "Removed modpack files require a modpack id".to_string(),
+ )
+ .into());
+ }
+ for removed in &self.removed_files {
+ removed.validate()?;
+ }
+ Ok(())
+ }
+}
+
#[derive(Clone, Debug, Deserialize)]
pub(super) struct ExternalFileResponse {
pub(super) file_name: String,
pub(super) file_type: String,
- pub(super) url: String,
+ pub(super) url: Option,
#[serde(default)]
pub(super) file_size: Option,
+ #[serde(default)]
+ pub(super) sha1: Option,
}
#[derive(Clone, Debug, Deserialize)]
@@ -242,7 +309,7 @@ pub(super) async fn update_remote_instance(
pub(super) async fn get_remote_instance_access(
shared_instance_id: &str,
state: &State,
-) -> crate::Result> {
+) -> crate::Result> {
let operation = "get_instance";
let method = Method::GET;
let path = format!("/instances/{shared_instance_id}");
@@ -278,7 +345,7 @@ pub(super) async fn get_remote_instance_access(
));
}
- Ok(SharedInstanceRemoteResponse::Available(()))
+ Ok(SharedInstanceRemoteResponse::Available(instance))
}
pub(super) async fn update_remote_instance_icon(
@@ -328,6 +395,30 @@ pub(super) async fn get_remote_users(
Ok(users.into_shared_users())
}
+pub(super) async fn get_remote_server_icon(
+ instance_id: &str,
+ etag: Option<&str>,
+ state: &State,
+) -> crate::Result {
+ let credentials =
+ ModrinthCredentials::get_and_refresh(&state.pool, &state.api_semaphore)
+ .await?
+ .ok_or(crate::ErrorKind::NoCredentialsError)?;
+ let _permit = state.api_semaphore.0.acquire().await?;
+ let base_url = service_base_url();
+ let path = format!("/instances/{instance_id}/server-icon");
+ let mut request = shared_instances_client(base_url)
+ .get(service_url(base_url, &path))
+ .bearer_auth(credentials.session)
+ .timeout(std::time::Duration::from_secs(15));
+ if let Some(etag) = etag {
+ request = request.header(reqwest::header::IF_NONE_MATCH, etag);
+ }
+ request.send().await.map_err(|error| {
+ crate::ErrorKind::SharedInstancesApiError(error.to_string()).into()
+ })
+}
+
pub(super) async fn get_latest_remote_version(
shared_instance_id: &str,
state: &State,
@@ -339,25 +430,6 @@ pub(super) async fn get_latest_remote_version(
.await?
{
SharedInstanceRemoteResponse::Available(version) => Ok(version),
- SharedInstanceRemoteResponse::Unavailable(
- reason @ SharedInstanceUnavailableReason::AccessRevoked,
- ) => {
- if !accept_pending_remote_invite(shared_instance_id, state).await? {
- return Err(shared_instance_unavailable_error(reason));
- }
-
- match get_latest_remote_version_optional_unavailable(
- shared_instance_id,
- state,
- )
- .await?
- {
- SharedInstanceRemoteResponse::Available(version) => Ok(version),
- SharedInstanceRemoteResponse::Unavailable(reason) => {
- Err(shared_instance_unavailable_error(reason))
- }
- }
- }
SharedInstanceRemoteResponse::Unavailable(reason) => {
Err(shared_instance_unavailable_error(reason))
}
@@ -392,6 +464,32 @@ pub(super) async fn get_latest_remote_version_optional_unavailable_with_auth(
.await
}
+/// Returns `None` for versions that never became ready.
+pub(super) async fn get_remote_version(
+ shared_instance_id: &str,
+ version: i32,
+ state: &State,
+) -> crate::Result> {
+ match request_json_optional_unavailable(
+ "get_instance_version",
+ Method::GET,
+ &format!("/instances/{shared_instance_id}/versions/{version}"),
+ None,
+ state,
+ SharedInstancesRequestAuth::ModrinthSession,
+ )
+ .await?
+ {
+ SharedInstanceRemoteResponse::Available(version) => Ok(Some(version)),
+ SharedInstanceRemoteResponse::Unavailable(
+ SharedInstanceUnavailableReason::Deleted,
+ ) => Ok(None),
+ SharedInstanceRemoteResponse::Unavailable(reason) => {
+ Err(shared_instance_unavailable_error(reason))
+ }
+ }
+}
+
pub(super) async fn add_remote_users(
shared_instance_id: &str,
user_ids: Vec,
@@ -530,7 +628,7 @@ pub(super) async fn get_shared_instance_invite_info(
) -> crate::Result {
let operation = "get_instance_invite";
let method = Method::GET;
- let path = format!("/invites/{invite_id}");
+ let path = format!("/invites/{invite_id}?version=true");
let log_path = "/invites/:invite_id";
let response = send_request_with_auth_and_log_path(
operation,
diff --git a/packages/app-lib/src/api/instance/shared/content.rs b/packages/app-lib/src/api/instance/shared/content.rs
new file mode 100644
index 00000000000..e3ea460c0da
--- /dev/null
+++ b/packages/app-lib/src/api/instance/shared/content.rs
@@ -0,0 +1,456 @@
+use super::client::{
+ ExternalFileResponse, InstanceVersionResponse, get_remote_version,
+};
+use super::diff::shared_external_file_key;
+use super::publish::dedupe_strings;
+use super::*;
+use crate::api::pack::install_from::{
+ EnvType, PackDependency, PackFileHash, PackFormat,
+};
+use crate::state::{DependencyType, SideType};
+use crate::util::fetch::{DownloadMeta, DownloadReason};
+use async_zip::tokio::read::fs::ZipFileReader;
+use std::collections::BTreeMap;
+
+pub(crate) struct SharedModpackFile {
+ pub relative_path: String,
+ pub sha1: Option,
+ pub version_id: Option,
+ removed_path_alias: Option,
+}
+
+impl SharedModpackFile {
+ pub(crate) fn is_removed(
+ &self,
+ removed_files: &[SharedInstanceRemovedFile],
+ ) -> bool {
+ removed_files.iter().any(|removed| {
+ removed.matches(self.version_id.as_deref(), &self.relative_path)
+ || self
+ .removed_path_alias
+ .as_deref()
+ .is_some_and(|path| removed.matches(None, path))
+ })
+ }
+}
+
+/// Reads the client content from the cached pack archive, including unresolved overrides.
+#[tracing::instrument(skip(state))]
+pub(crate) async fn shared_modpack_files(
+ modpack_id: &str,
+ state: &State,
+) -> crate::Result> {
+ let version = CachedEntry::get_version(
+ modpack_id,
+ Some(CacheBehaviour::MustRevalidate),
+ &state.pool,
+ &state.api_semaphore,
+ )
+ .await?
+ .ok_or_else(|| {
+ crate::ErrorKind::InputError(
+ "Shared instance modpack version was not found".to_string(),
+ )
+ })?;
+ let file = version
+ .files
+ .iter()
+ .find(|file| file.primary)
+ .or_else(|| version.files.first())
+ .ok_or_else(|| {
+ crate::ErrorKind::InputError(
+ "Shared instance modpack has no files".to_string(),
+ )
+ })?;
+ let download_meta = DownloadMeta {
+ reason: DownloadReason::Modpack,
+ game_version: version
+ .game_versions
+ .first()
+ .cloned()
+ .unwrap_or_default(),
+ loader: version.loaders.first().cloned().unwrap_or_default(),
+ dependent_on: Some(modpack_id.to_string()),
+ };
+ let archive = crate::util::fetch::fetch_content_file(
+ state,
+ &[&file.url],
+ file.hashes.get("sha512").map(String::as_str),
+ Some(u64::from(file.size)),
+ Some(&download_meta),
+ None,
+ )
+ .await?;
+ let zip = ZipFileReader::new(archive.path()).await?;
+ let manifest_index = zip
+ .file()
+ .entries()
+ .iter()
+ .position(|entry| {
+ matches!(entry.filename().as_str(), Ok("modrinth.index.json"))
+ })
+ .ok_or_else(|| {
+ crate::ErrorKind::InputError(
+ "No modrinth.index.json found in shared modpack".to_string(),
+ )
+ })?;
+ let mut manifest = String::new();
+ zip.reader_with_entry(manifest_index)
+ .await?
+ .read_to_string_checked(&mut manifest)
+ .await?;
+ let pack: PackFormat = serde_json::from_str(&manifest)?;
+ let default_parent = if pack
+ .dependencies
+ .keys()
+ .any(|loader| *loader != PackDependency::Minecraft)
+ {
+ "mods"
+ } else {
+ "datapacks"
+ };
+ let unresolved_basenames = version
+ .dependencies
+ .iter()
+ .filter(|dependency| {
+ matches!(dependency.dependency_type, DependencyType::Embedded)
+ && dependency.version_id.is_none()
+ })
+ .filter_map(|dependency| dependency.file_name.as_deref())
+ .filter(|filename| !filename.contains('/'))
+ .collect::>();
+ let mut files = BTreeMap::new();
+ for file in pack.files {
+ if file.env.as_ref().is_some_and(|env| {
+ env.get(&EnvType::Client) == Some(&SideType::Unsupported)
+ }) {
+ continue;
+ }
+ let path = file.path.as_str();
+ if is_content_path(path) {
+ files.insert(
+ path.to_string(),
+ file.hashes.get(&PackFileHash::Sha1).cloned(),
+ );
+ }
+ }
+ let overrides = zip
+ .file()
+ .entries()
+ .iter()
+ .enumerate()
+ .filter_map(|(index, entry)| {
+ let filename = entry.filename().as_str().ok()?;
+ let path = filename
+ .strip_prefix("overrides/")
+ .or_else(|| filename.strip_prefix("client-overrides/"))?;
+ is_content_path(path).then(|| (index, path.to_string()))
+ })
+ .collect::>();
+ let mut buffer = vec![0_u8; 256 * 1024];
+ for (index, path) in overrides {
+ let mut reader = zip.reader_with_entry(index).await?;
+ let crc32 = reader.entry().crc32();
+ let mut hash = sha1_smol::Sha1::new();
+ loop {
+ let read =
+ futures_lite::io::AsyncReadExt::read(&mut reader, &mut buffer)
+ .await?;
+ if read == 0 {
+ break;
+ }
+ hash.update(&buffer[..read]);
+ }
+ if reader.compute_hash() != crc32 {
+ return Err(async_zip::error::ZipError::CRC32CheckError.into());
+ }
+ files.insert(path, Some(hash.hexdigest()));
+ }
+ let hashes = files
+ .values()
+ .filter_map(|hash| hash.as_deref())
+ .collect::>();
+ let metadata = CachedEntry::get_file_many(
+ &hashes,
+ Some(CacheBehaviour::MustRevalidate),
+ &state.pool,
+ &state.api_semaphore,
+ )
+ .await?
+ .into_iter()
+ .map(|file| (file.hash.clone(), file))
+ .collect::>();
+ Ok(files
+ .into_iter()
+ .map(|(relative_path, hash)| {
+ let metadata = hash.as_ref().and_then(|hash| metadata.get(hash));
+ // Hosting uses the loader's default directory when Labrinth supplies only an unresolved basename.
+ let removed_path_alias =
+ relative_path.rsplit_once('/').and_then(|(_, filename)| {
+ unresolved_basenames
+ .contains(filename)
+ .then(|| format!("{default_parent}/{filename}"))
+ });
+ SharedModpackFile {
+ relative_path,
+ sha1: hash,
+ version_id: metadata.map(|file| file.version_id.clone()),
+ removed_path_alias,
+ }
+ })
+ .collect())
+}
+
+fn is_content_path(path: &str) -> bool {
+ crate::state::content_store::is_managed_content_path(path)
+ && !path.ends_with(".disabled")
+}
+
+pub(super) async fn remote_shared_content(
+ version: &InstanceVersionResponse,
+ state: &State,
+) -> crate::Result<(Vec, BTreeSet)> {
+ version.validate_removed_files()?;
+ let mut version_ids = version
+ .modrinth_ids
+ .iter()
+ .filter(|id| version.modpack_id.as_deref() != Some(id.as_str()))
+ .cloned()
+ .collect::>();
+ let mut external_files = version
+ .external_files
+ .iter()
+ .filter(|file| {
+ !matches!(
+ file.file_type.as_str(),
+ CONFIG_BUNDLE_FILE_TYPE | CONFIG_FILE_TYPE
+ )
+ })
+ .map(|file| shared_external_file_key(&file.file_type, &file.file_name))
+ .collect::>>()?;
+ let explicit_paths = version
+ .external_files
+ .iter()
+ .filter_map(|file| {
+ ProjectType::from_name(&file.file_type)
+ .map(|kind| format!("{}/{}", kind.get_folder(), file.file_name))
+ })
+ .collect::>();
+ if let Some(modpack_id) =
+ version.modpack_id.as_deref().filter(|id| !id.is_empty())
+ {
+ for file in shared_modpack_files(modpack_id, state).await? {
+ if file.is_removed(&version.removed_files)
+ || explicit_paths.contains(&file.relative_path)
+ {
+ continue;
+ }
+ if let Some(version_id) = file.version_id {
+ version_ids.push(version_id);
+ } else if let Some((parent, filename)) =
+ file.relative_path.split_once('/')
+ {
+ external_files.insert(ExternalFileKey {
+ content_type: ProjectType::from_name(parent)
+ .expect("pack content path was validated")
+ .into(),
+ path: filename.to_string(),
+ });
+ }
+ }
+ }
+ dedupe_strings(&mut version_ids);
+ Ok((version_ids, external_files))
+}
+
+const CONFIG_VERSION_FETCH_CONCURRENCY: usize = 4;
+
+/// Config files are published as deltas, so a member needs every config
+/// uploaded after `applied_version`, keeping the newest upload of each path.
+pub(super) async fn remote_shared_config_files(
+ shared_instance_id: &str,
+ applied_version: Option,
+ latest: &InstanceVersionResponse,
+ state: &State,
+) -> crate::Result> {
+ use futures::{StreamExt, TryStreamExt};
+
+ let first = applied_version.map_or(1, |version| version.saturating_add(1));
+ let intermediate = futures::stream::iter(first..latest.version)
+ .map(|version| get_remote_version(shared_instance_id, version, state))
+ .buffered(CONFIG_VERSION_FETCH_CONCURRENCY)
+ .try_collect::>()
+ .await?;
+
+ newest_config_files(
+ intermediate
+ .iter()
+ .flatten()
+ .chain((first <= latest.version).then_some(latest))
+ .map(|version| version.external_files.as_slice()),
+ )
+}
+
+/// Takes each version's external files in ascending version order. A legacy
+/// config bundle is a full snapshot, so it replaces every older config. The
+/// bundle comes first so newer individual files are written over it.
+///
+/// Limits apply per version, matching what a single publish may upload.
+fn newest_config_files<'a>(
+ versions: impl IntoIterator- ,
+) -> crate::Result> {
+ let mut bundle = None;
+ let mut files = BTreeMap::new();
+ for external_files in versions {
+ ensure_config_limits(external_files)?;
+ if let Some(newer) = external_files
+ .iter()
+ .find(|file| file.file_type == CONFIG_BUNDLE_FILE_TYPE)
+ {
+ bundle = Some(newer.clone());
+ files.clear();
+ }
+ for file in external_files
+ .iter()
+ .filter(|file| file.file_type == CONFIG_FILE_TYPE)
+ {
+ files.insert(file.file_name.clone(), file.clone());
+ }
+ }
+
+ Ok(bundle.into_iter().chain(files.into_values()).collect())
+}
+
+fn ensure_config_limits(
+ external_files: &[ExternalFileResponse],
+) -> crate::Result<()> {
+ let mut count = 0;
+ let mut size = 0_u64;
+ for file in external_files
+ .iter()
+ .filter(|file| file.file_type == CONFIG_FILE_TYPE)
+ {
+ count += 1;
+ size = size.saturating_add(
+ file.file_size
+ .and_then(|size| u64::try_from(size).ok())
+ .unwrap_or(u64::MAX),
+ );
+ }
+ if count > MAX_CONFIG_BUNDLE_ENTRIES || size > MAX_CONFIG_BUNDLE_TOTAL_SIZE
+ {
+ return Err(crate::ErrorKind::InputError(
+ "Shared instance config files exceed the size or file count limit"
+ .to_string(),
+ )
+ .into());
+ }
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn file(
+ file_type: &str,
+ file_name: &str,
+ url: &str,
+ ) -> ExternalFileResponse {
+ ExternalFileResponse {
+ file_name: file_name.to_string(),
+ file_type: file_type.to_string(),
+ url: Some(url.to_string()),
+ file_size: Some(1),
+ sha1: None,
+ }
+ }
+
+ fn names(files: &[ExternalFileResponse]) -> Vec<(&str, &str, &str)> {
+ files
+ .iter()
+ .map(|file| {
+ (
+ file.file_type.as_str(),
+ file.file_name.as_str(),
+ file.url.as_deref().unwrap_or_default(),
+ )
+ })
+ .collect()
+ }
+
+ #[test]
+ fn newest_upload_of_each_path_wins() {
+ let v1 = [
+ file(CONFIG_FILE_TYPE, "config/a.toml", "v1"),
+ file(CONFIG_FILE_TYPE, "config/b.toml", "v1"),
+ ];
+ let v2 = [file("mod", "extra.jar", "v2")];
+ let v3 = [file(CONFIG_FILE_TYPE, "config/a.toml", "v3")];
+
+ let files = newest_config_files([&v1[..], &v2[..], &v3[..]]).unwrap();
+
+ assert_eq!(
+ names(&files),
+ [
+ (CONFIG_FILE_TYPE, "config/a.toml", "v3"),
+ (CONFIG_FILE_TYPE, "config/b.toml", "v1"),
+ ]
+ );
+ }
+
+ #[test]
+ fn bundle_replaces_older_configs_and_is_written_first() {
+ let v1 = [file(CONFIG_FILE_TYPE, "config/old.toml", "v1")];
+ let v2 = [
+ file(CONFIG_FILE_TYPE, "config/same.toml", "v2"),
+ file(CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v2"),
+ ];
+ let v3 = [file(CONFIG_FILE_TYPE, "config/new.toml", "v3")];
+
+ let files = newest_config_files([&v1[..], &v2[..], &v3[..]]).unwrap();
+
+ assert_eq!(
+ names(&files),
+ [
+ (CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v2"),
+ (CONFIG_FILE_TYPE, "config/new.toml", "v3"),
+ (CONFIG_FILE_TYPE, "config/same.toml", "v2"),
+ ]
+ );
+ }
+
+ #[test]
+ fn limits_apply_per_version() {
+ let mut half = file(CONFIG_FILE_TYPE, "config/a.toml", "v1");
+ half.file_size = Some((MAX_CONFIG_BUNDLE_TOTAL_SIZE / 2 + 1) as i64);
+ let mut other_half = half.clone();
+ other_half.file_name = "config/b.toml".to_string();
+ let mut too_large = half.clone();
+ too_large.file_name = "config/c.toml".to_string();
+
+ assert!(
+ newest_config_files([
+ &[half.clone()][..],
+ &[other_half.clone()][..]
+ ])
+ .is_ok()
+ );
+ assert!(
+ newest_config_files([&[half, other_half, too_large][..]]).is_err()
+ );
+ }
+
+ #[test]
+ fn newest_bundle_wins() {
+ let v1 = [file(CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v1")];
+ let v2 = [file(CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v2")];
+
+ let files = newest_config_files([&v1[..], &v2[..]]).unwrap();
+
+ assert_eq!(
+ names(&files),
+ [(CONFIG_BUNDLE_FILE_TYPE, "configs.zip", "v2")]
+ );
+ }
+}
diff --git a/packages/app-lib/src/api/instance/shared/diff.rs b/packages/app-lib/src/api/instance/shared/diff.rs
index 84483bce32a..33cd59d109f 100644
--- a/packages/app-lib/src/api/instance/shared/diff.rs
+++ b/packages/app-lib/src/api/instance/shared/diff.rs
@@ -1,4 +1,5 @@
use super::client::*;
+use super::content::remote_shared_content;
use super::publish::*;
use super::types::*;
use super::*;
@@ -13,27 +14,27 @@ struct SharedContentSnapshot {
pub(super) async fn shared_instance_update_diffs(
metadata: &crate::state::InstanceMetadata,
version: &InstanceVersionResponse,
+ config_files: &[ExternalFileResponse],
state: &State,
) -> crate::Result> {
let before_configuration = local_configuration(metadata);
let after_configuration = remote_configuration(version);
- let modpack_unlinked = before_configuration.modpack_version_id.is_some()
- && after_configuration.modpack_version_id.is_none();
let (version_ids, external_files) =
- current_shared_content(metadata, modpack_unlinked, state).await?;
+ current_shared_content(metadata, state).await?;
let before = SharedContentSnapshot {
version_ids,
external_files,
configuration: before_configuration,
};
- let (version_ids, external_files) = remote_shared_content(version)?;
+ let (version_ids, external_files) =
+ remote_shared_content(version, state).await?;
let after = SharedContentSnapshot {
version_ids,
external_files,
configuration: after_configuration,
};
- shared_content_diffs(
+ let mut diffs = shared_content_diffs(
&before,
&after,
&HashSet::new(),
@@ -42,7 +43,24 @@ pub(super) async fn shared_instance_update_diffs(
CommonExternalFilePolicy::AssumeUpdated,
state,
)
- .await
+ .await?;
+ let config_file_count = config_files
+ .iter()
+ .filter(|file| file.file_type == CONFIG_FILE_TYPE)
+ .count();
+ if config_file_count > 0 {
+ diffs.push(SharedInstanceUpdateDiff {
+ type_: SharedInstanceUpdateDiffType::ConfigFilesUpdated,
+ project_id: None,
+ project_name: None,
+ file_name: None,
+ current_version_name: None,
+ new_version_name: None,
+ config_file_count: Some(config_file_count),
+ disabled: false,
+ });
+ }
+ Ok(diffs)
}
pub(super) async fn shared_instance_publish_diffs(
@@ -53,10 +71,8 @@ pub(super) async fn shared_instance_publish_diffs(
) -> crate::Result> {
let before_configuration = remote_configuration(version);
let after_configuration = local_configuration(metadata);
- let modpack_unlinked = before_configuration.modpack_version_id.is_some()
- && after_configuration.modpack_version_id.is_none();
let (version_ids, external_files) =
- remote_publish_content(version, modpack_unlinked, state).await?;
+ remote_shared_content(version, state).await?;
let before = SharedContentSnapshot {
version_ids,
external_files,
@@ -64,7 +80,7 @@ pub(super) async fn shared_instance_publish_diffs(
};
let after = SharedContentSnapshot {
version_ids: snapshot
- .version_ids
+ .effective_version_ids
.iter()
.filter(|id| {
after_configuration.modpack_version_id.as_deref()
@@ -472,20 +488,3 @@ pub(super) fn shared_external_file_key(
path: path.to_string(),
})
}
-
-fn remote_shared_content(
- version: &InstanceVersionResponse,
-) -> crate::Result<(Vec, BTreeSet)> {
- let mut version_ids = version.modrinth_ids.clone();
- if let Some(modpack_id) = version.modpack_id.as_deref() {
- version_ids.retain(|id| id != modpack_id);
- }
- dedupe_strings(&mut version_ids);
- let external_files = version
- .external_files
- .iter()
- .filter(|file| file.file_type != CONFIG_BUNDLE_FILE_TYPE)
- .map(|file| shared_external_file_key(&file.file_type, &file.file_name))
- .collect::>()?;
- Ok((version_ids, external_files))
-}
diff --git a/packages/app-lib/src/api/instance/shared/icons.rs b/packages/app-lib/src/api/instance/shared/icons.rs
new file mode 100644
index 00000000000..f31f5c8147b
--- /dev/null
+++ b/packages/app-lib/src/api/instance/shared/icons.rs
@@ -0,0 +1,122 @@
+use super::client::{get_remote_server_icon, shared_instances_request_error};
+use super::*;
+use std::path::PathBuf;
+
+#[derive(Serialize, Deserialize)]
+struct CachedServerIcon {
+ filename: String,
+ etag: Option,
+}
+
+#[tracing::instrument]
+pub async fn cache_shared_instance_server_icon(
+ instance_id: &str,
+) -> crate::Result> {
+ let state = State::get().await?;
+ shared_instance_server_icon(instance_id, &state).await
+}
+
+#[tracing::instrument(skip(state))]
+pub(super) async fn shared_instance_server_icon(
+ instance_id: &str,
+ state: &State,
+) -> crate::Result> {
+ let credentials =
+ ModrinthCredentials::get_and_refresh(&state.pool, &state.api_semaphore)
+ .await?
+ .ok_or(crate::ErrorKind::NoCredentialsError)?;
+ let key = sha1_smol::Sha1::from(
+ format!("{}:{instance_id}", credentials.user_id).as_bytes(),
+ )
+ .hexdigest();
+ let icons = state.directories.caches_dir().join("icons");
+ let mapping = icons.join(format!("shared-server-{key}.json"));
+ let cached = if tokio::fs::metadata(&mapping)
+ .await
+ .is_ok_and(|metadata| metadata.len() <= 1024)
+ {
+ tokio::fs::read(&mapping).await.ok().and_then(|bytes| {
+ serde_json::from_slice::(&bytes).ok()
+ })
+ } else {
+ None
+ };
+ let cached = match cached {
+ Some(cached)
+ if cached.filename.len() == 44
+ && cached.filename.ends_with(".png")
+ && cached.filename.as_bytes()[..40]
+ .iter()
+ .all(u8::is_ascii_hexdigit)
+ && tokio::fs::try_exists(icons.join(&cached.filename))
+ .await? =>
+ {
+ Some(cached)
+ }
+ _ => None,
+ };
+ let mut response = get_remote_server_icon(
+ instance_id,
+ cached.as_ref().and_then(|cached| cached.etag.as_deref()),
+ state,
+ )
+ .await?;
+ if response.status() == StatusCode::NOT_FOUND {
+ if tokio::fs::try_exists(&mapping).await? {
+ tokio::fs::remove_file(&mapping).await?;
+ }
+ return Ok(None);
+ }
+ if response.status() == StatusCode::NOT_MODIFIED
+ && let Some(cached) = cached
+ {
+ return Ok(Some(
+ crate::util::io::canonicalize(icons.join(cached.filename))?
+ .to_string_lossy()
+ .to_string(),
+ ));
+ }
+ if !response.status().is_success() {
+ return shared_instances_request_error(
+ "get_instance_server_icon",
+ Method::GET,
+ &format!("/instances/{instance_id}/server-icon"),
+ response,
+ )
+ .await;
+ }
+ let etag = response
+ .headers()
+ .get(reqwest::header::ETAG)
+ .and_then(|value| value.to_str().ok())
+ .map(str::to_string);
+ let mut bytes = Vec::new();
+ while let Some(chunk) = response.chunk().await? {
+ if bytes.len() + chunk.len() > 4 * 1024 * 1024 {
+ return Err(crate::ErrorKind::InputError(
+ "Server icons must be at most 4 MiB".to_string(),
+ )
+ .into());
+ }
+ bytes.extend_from_slice(&chunk);
+ }
+ let path: PathBuf =
+ crate::api::instance::cache_icon(bytes::Bytes::from(bytes), state)
+ .await?;
+ let filename = path
+ .file_name()
+ .ok_or_else(|| {
+ crate::ErrorKind::InputError(
+ "Cached server icon has no filename".to_string(),
+ )
+ })?
+ .to_string_lossy()
+ .to_string();
+ crate::util::fetch::write(
+ &mapping,
+ &serde_json::to_vec(&CachedServerIcon { filename, etag })?,
+ &state.io_semaphore,
+ )
+ .await?;
+ Ok(Some(path.to_string_lossy().to_string()))
+}
diff --git a/packages/app-lib/src/api/instance/shared/install.rs b/packages/app-lib/src/api/instance/shared/install.rs
index f2de99b2c4f..53eae31be64 100644
--- a/packages/app-lib/src/api/instance/shared/install.rs
+++ b/packages/app-lib/src/api/instance/shared/install.rs
@@ -1,5 +1,7 @@
use super::client::*;
+use super::content::{remote_shared_config_files, remote_shared_content};
use super::diff::*;
+use super::icons::shared_instance_server_icon;
use super::publish::*;
use super::types::*;
use super::*;
@@ -12,6 +14,27 @@ pub async fn install_shared_instance(
server_manager_name: Option,
server_manager_icon_url: Option,
instance_icon_url: Option,
+) -> crate::Result {
+ crate::util::fetch::wait_for_local_api_rate_limit(Box::pin(
+ install_shared_instance_inner(
+ shared_instance_id,
+ name,
+ manager_id,
+ server_manager_name,
+ server_manager_icon_url,
+ instance_icon_url,
+ ),
+ ))
+ .await
+}
+
+async fn install_shared_instance_inner(
+ shared_instance_id: &str,
+ name: String,
+ manager_id: Option,
+ server_manager_name: Option,
+ server_manager_icon_url: Option,
+ instance_icon_url: Option,
) -> crate::Result {
let state = State::get().await?;
let version = get_latest_remote_version(shared_instance_id, &state).await?;
@@ -23,6 +46,7 @@ pub async fn install_shared_instance(
instance_icon_url,
name,
version,
+ None,
&state,
)
.await?;
@@ -46,6 +70,16 @@ pub(super) fn shared_instance_invite_install_name(
pub async fn get_shared_instance_install_preview(
shared_instance_id: &str,
name: String,
+) -> crate::Result {
+ crate::util::fetch::wait_for_local_api_rate_limit(
+ get_shared_instance_install_preview_inner(shared_instance_id, name),
+ )
+ .await
+}
+
+async fn get_shared_instance_install_preview_inner(
+ shared_instance_id: &str,
+ name: String,
) -> crate::Result {
let state = State::get().await?;
let version = get_latest_remote_version(shared_instance_id, &state).await?;
@@ -59,23 +93,25 @@ pub async fn get_shared_instance_install_preview(
}
#[tracing::instrument(skip(invite_id))]
-pub async fn accept_shared_instance_invite_for_install(
+pub async fn get_shared_instance_invite_install_preview(
invite_id: &str,
) -> crate::Result {
let state = State::get().await?;
let invite = get_shared_instance_invite_info(invite_id, &state).await?;
let shared_instance_id = invite.instance_id;
let instance_icon_url = invite.instance_icon;
+ let inviter = invite.inviter;
let (manager_id, server_manager_name, server_manager_icon_url) =
shared_instance_invite_manager(invite.managers);
let name = shared_instance_invite_install_name(
&shared_instance_id,
invite.instance_name,
);
- accept_shared_instance_invite(&shared_instance_id, invite_id, &state)
- .await?;
- let version =
- get_latest_remote_version(&shared_instance_id, &state).await?;
+ let version = invite.version.ok_or_else(|| {
+ crate::ErrorKind::InputError(
+ "Invite preview has no ready version".to_string(),
+ )
+ })?;
let mut preview = shared_instance_install_preview_from_version(
shared_instance_id.clone(),
name,
@@ -89,6 +125,7 @@ pub async fn accept_shared_instance_invite_for_install(
Ok(SharedInstanceInviteInstallPreview {
shared_instance_id,
+ inviter,
manager_id,
server_manager_name,
server_manager_icon_url,
@@ -97,6 +134,26 @@ pub async fn accept_shared_instance_invite_for_install(
})
}
+#[tracing::instrument(skip(invite_id))]
+pub async fn accept_shared_instance_invite_for_install(
+ shared_instance_id: &str,
+ invite_id: &str,
+) -> crate::Result<()> {
+ let state = State::get().await?;
+ match get_remote_instance_access(shared_instance_id, &state).await? {
+ SharedInstanceRemoteResponse::Available(_) => Ok(()),
+ SharedInstanceRemoteResponse::Unavailable(
+ SharedInstanceUnavailableReason::AccessRevoked,
+ ) => {
+ accept_shared_instance_invite(shared_instance_id, invite_id, &state)
+ .await
+ }
+ SharedInstanceRemoteResponse::Unavailable(reason) => {
+ Err(shared_instance_unavailable_error(reason))
+ }
+ }
+}
+
pub(super) fn shared_instance_invite_manager(
managers: Vec,
) -> (Option, Option, Option) {
@@ -121,31 +178,19 @@ pub(super) async fn shared_instance_install_preview_from_version(
"" => "Shared instance".to_string(),
name => name.to_string(),
};
- let mut content_version_ids = version.modrinth_ids.clone();
- let mut seen_content_version_ids = HashSet::new();
- content_version_ids
- .retain(|id| seen_content_version_ids.insert(id.clone()));
let modpack = shared_instance_install_modpack(&version, state).await?;
- let modpack_dependency_count = modpack
- .as_ref()
- .map(|modpack| modpack.dependency_count)
- .unwrap_or_default();
+ let (content_version_ids, effective_external_files) =
+ remote_shared_content(&version, state).await?;
let modpack_version_id =
modpack.as_ref().map(|modpack| modpack.version_id.clone());
- if let Some(modpack_version_id) = modpack_version_id.as_deref() {
- content_version_ids.retain(|id| id != modpack_version_id);
- }
let icon_url = modpack
.as_ref()
.and_then(|modpack| modpack.icon_url.clone());
-
- let external_files = version
- .external_files
- .iter()
- .filter(|file| file.file_type != CONFIG_BUNDLE_FILE_TYPE)
+ let external_files = effective_external_files
+ .into_iter()
.map(|file| SharedInstanceExternalFilePreview {
- file_name: file.file_name.clone(),
- file_type: file.file_type.clone(),
+ file_name: file.path,
+ file_type: file.content_type.as_str().to_string(),
})
.collect::>();
let external_file_count = external_files.len();
@@ -157,19 +202,27 @@ pub(super) async fn shared_instance_install_preview_from_version(
icon_url,
game_version: version.game_version,
loader: version.loader,
- mod_count: modpack_dependency_count
- + content_version_ids.len()
- + external_file_count,
+ mod_count: content_version_ids.len() + external_file_count,
external_file_count,
modpack_version_id,
content_version_ids,
external_files,
+ removed_files: version.removed_files,
})
}
#[tracing::instrument]
pub async fn get_shared_instance_update_preview(
instance_id: &str,
+) -> crate::Result> {
+ crate::util::fetch::wait_for_local_api_rate_limit(
+ get_shared_instance_update_preview_inner(instance_id),
+ )
+ .await
+}
+
+async fn get_shared_instance_update_preview_inner(
+ instance_id: &str,
) -> crate::Result> {
let state = State::get().await?;
let metadata = crate::state::get_instance(instance_id, &state.pool)
@@ -209,12 +262,21 @@ pub async fn get_shared_instance_update_preview(
diffs: Vec::new(),
}));
}
+ version.validate_removed_files()?;
let update_available = attachment
.applied_version
.is_none_or(|current| current < version.version);
let diffs = if update_available {
- shared_instance_update_diffs(&metadata, &version, &state).await?
+ let config_files = remote_shared_config_files(
+ &attachment.id,
+ attachment.applied_version,
+ &version,
+ &state,
+ )
+ .await?;
+ shared_instance_update_diffs(&metadata, &version, &config_files, &state)
+ .await?
} else {
Vec::new()
};
@@ -272,6 +334,15 @@ pub(crate) async fn check_shared_instance_availability_before_launch(
#[tracing::instrument]
pub async fn update_shared_instance(
instance_id: &str,
+) -> crate::Result {
+ crate::util::fetch::wait_for_local_api_rate_limit(Box::pin(
+ update_shared_instance_inner(instance_id),
+ ))
+ .await
+}
+
+async fn update_shared_instance_inner(
+ instance_id: &str,
) -> crate::Result {
let state = State::get().await?;
let metadata = crate::state::get_instance(instance_id, &state.pool)
@@ -303,6 +374,7 @@ pub async fn update_shared_instance(
None,
metadata.instance.name,
version,
+ attachment.applied_version,
&state,
)
.await?;
@@ -439,6 +511,12 @@ pub(super) async fn handle_unavailable_shared_instance_if_current_user(
reason: SharedInstanceUnavailableReason,
state: &State,
) -> crate::Result<()> {
+ // A missing ID can belong to another API environment. Keep the attachment
+ // so opening a production instance in a staging build cannot unlink it.
+ if reason == SharedInstanceUnavailableReason::Deleted {
+ return Ok(());
+ }
+
if reason != SharedInstanceUnavailableReason::Quarantined
&& !shared_attachment_matches_current_user(attachment, state).await?
{
@@ -498,11 +576,18 @@ fn shared_instance_external_file_data(
))
})?;
+ let url = file.url.filter(|url| !url.is_empty()).ok_or_else(|| {
+ crate::ErrorKind::InputError(format!(
+ "Shared instance external file {} is missing its download URL",
+ file.file_name
+ ))
+ })?;
Ok(SharedInstanceExternalFileData {
file_name: file.file_name,
file_type: file.file_type,
- url: file.url,
+ url,
file_size,
+ sha1: file.sha1,
})
}
@@ -514,8 +599,10 @@ pub(super) async fn shared_instance_install_data(
instance_icon_url: Option,
name: String,
version: InstanceVersionResponse,
+ applied_version: Option,
state: &State,
) -> crate::Result {
+ version.validate_removed_files()?;
if !version.ready {
return Err(crate::ErrorKind::InputError(
"Shared instance version is not ready to install".to_string(),
@@ -523,18 +610,69 @@ pub(super) async fn shared_instance_install_data(
.into());
}
+ let remote =
+ match get_remote_instance_access(shared_instance_id, state).await? {
+ SharedInstanceRemoteResponse::Available(remote) => remote,
+ SharedInstanceRemoteResponse::Unavailable(reason) => {
+ return Err(shared_instance_unavailable_error(reason));
+ }
+ };
+ let config_files = remote_shared_config_files(
+ shared_instance_id,
+ applied_version,
+ &version,
+ state,
+ )
+ .await?;
+ let (manager_id, server_manager_name, server_manager_icon_url) = if remote
+ .linked_server
+ .is_some()
+ {
+ let icon = match shared_instance_server_icon(shared_instance_id, state)
+ .await
+ {
+ Ok(icon) => icon,
+ Err(error) => {
+ tracing::warn!(%error, "Could not fetch shared instance server icon");
+ server_manager_icon_url
+ }
+ };
+ (None, Some(remote.name), icon)
+ } else {
+ (manager_id, server_manager_name, server_manager_icon_url)
+ };
+ let instance_icon_url = if remote.linked_server.is_some() {
+ server_manager_icon_url.clone()
+ } else if server_manager_name.is_some() {
+ instance_icon_url.or(remote.icon)
+ } else {
+ remote.icon.or(instance_icon_url)
+ };
+
let name = shared_instance_name(name);
let linked_user_id = linked_modrinth_user_id(state).await?;
let modpack = shared_instance_install_modpack(&version, state).await?;
let modpack_version_id =
modpack.as_ref().map(|modpack| modpack.version_id.as_str());
+ let inherited = if let Some(modpack_id) = modpack_version_id {
+ shared_modpack_files(modpack_id, state).await?
+ } else {
+ Vec::new()
+ };
let modrinth_ids = version
.modrinth_ids
.into_iter()
- .filter(|id| Some(id.as_str()) != modpack_version_id)
+ .filter(|id| {
+ Some(id.as_str()) != modpack_version_id
+ && !inherited.iter().any(|file| {
+ file.version_id.as_deref() == Some(id.as_str())
+ && !file.is_removed(&version.removed_files)
+ })
+ })
.collect();
Ok(SharedInstanceInstallData {
+ linked_server: remote.linked_server,
shared_instance_id: shared_instance_id.to_string(),
manager_id,
server_manager_name,
@@ -544,9 +682,17 @@ pub(super) async fn shared_instance_install_data(
name,
version: version.version,
modrinth_ids,
+ removed_files: version.removed_files,
external_files: version
.external_files
.into_iter()
+ .filter(|file| {
+ !matches!(
+ file.file_type.as_str(),
+ CONFIG_BUNDLE_FILE_TYPE | CONFIG_FILE_TYPE
+ )
+ })
+ .chain(config_files)
.map(shared_instance_external_file_data)
.collect::>>()?,
modpack,
diff --git a/packages/app-lib/src/api/instance/shared/invites.rs b/packages/app-lib/src/api/instance/shared/invites.rs
index 1e322aa561e..f0bcea2e5f3 100644
--- a/packages/app-lib/src/api/instance/shared/invites.rs
+++ b/packages/app-lib/src/api/instance/shared/invites.rs
@@ -206,6 +206,16 @@ pub async fn accept_pending_shared_instance_invite(
) -> crate::Result<()> {
let state = State::get().await?;
+ match get_remote_instance_access(shared_instance_id, &state).await? {
+ SharedInstanceRemoteResponse::Available(_) => return Ok(()),
+ SharedInstanceRemoteResponse::Unavailable(
+ SharedInstanceUnavailableReason::AccessRevoked,
+ ) => {}
+ SharedInstanceRemoteResponse::Unavailable(reason) => {
+ return Err(shared_instance_unavailable_error(reason));
+ }
+ }
+
if accept_pending_remote_invite(shared_instance_id, &state).await? {
return Ok(());
}
diff --git a/packages/app-lib/src/api/instance/shared/mod.rs b/packages/app-lib/src/api/instance/shared/mod.rs
index 4fdce76f1c8..c5bb9e8f90a 100644
--- a/packages/app-lib/src/api/instance/shared/mod.rs
+++ b/packages/app-lib/src/api/instance/shared/mod.rs
@@ -3,7 +3,7 @@ use crate::event::InstancePayloadType;
use crate::event::emit::emit_instance;
use crate::install::{
InstallJobSnapshot, SharedInstanceExternalFileData,
- SharedInstanceInstallData,
+ SharedInstanceInstallData, SharedInstanceRemovedFile,
};
use crate::state::instances::{InstanceLink, SharedInstanceAttachment};
use crate::state::{
@@ -30,13 +30,13 @@ use std::collections::BTreeSet;
use std::collections::{HashMap, HashSet};
use std::io::Read;
-pub(crate) const CONFIG_BUNDLE_FILE_NAME: &str = "configs.zip";
pub(crate) const CONFIG_BUNDLE_FILE_TYPE: &str = "configs";
+pub(crate) const CONFIG_FILE_TYPE: &str = "config";
pub(crate) const CONFIG_SYNC_ENABLED: bool = true;
pub(crate) const CONFIG_DIRECTORY: &str = "config";
pub(crate) const MAX_CONFIG_BUNDLE_ENTRIES: usize = 4096;
-pub(crate) const MAX_CONFIG_BUNDLE_FILE_SIZE: u64 = 16 * 1024 * 1024;
-pub(crate) const MAX_CONFIG_BUNDLE_TOTAL_SIZE: u64 = 128 * 1024 * 1024;
+pub(crate) const MAX_CONFIG_BUNDLE_FILE_SIZE: u64 = 512 * 1024 * 1024;
+pub(crate) const MAX_CONFIG_BUNDLE_TOTAL_SIZE: u64 = 512 * 1024 * 1024;
pub(crate) const CONFIG_FILE_EXTENSIONS: [&str; 14] = [
"json",
"json5",
@@ -54,6 +54,23 @@ pub(crate) const CONFIG_FILE_EXTENSIONS: [&str; 14] = [
"nbt",
];
+pub(crate) fn is_supported_config_file(path: &std::path::Path) -> bool {
+ path.extension()
+ .and_then(|extension| extension.to_str())
+ .is_some_and(|extension| {
+ CONFIG_FILE_EXTENSIONS
+ .iter()
+ .any(|candidate| extension.eq_ignore_ascii_case(candidate))
+ })
+}
+
+/// Whether members can install a shared config at this instance-relative path.
+pub(crate) fn is_shareable_config_path(path: &str) -> bool {
+ crate::state::content_store::validate_relative(path).is_ok()
+ && !path.split('/').any(|part| part.starts_with('.'))
+ && is_supported_config_file(std::path::Path::new(path))
+}
+
pub(crate) fn read_bounded_config_bundle_entry(
reader: impl Read,
declared_size: u64,
@@ -101,19 +118,25 @@ pub(crate) fn read_bounded_config_bundle_entry(
}
mod client;
+mod content;
mod diff;
+mod icons;
mod install;
mod invites;
mod publish;
mod types;
+pub(crate) use self::content::shared_modpack_files;
+pub use self::icons::cache_shared_instance_server_icon;
pub(crate) use self::install::check_shared_instance_availability_before_launch;
pub(crate) use self::publish::sync_shared_instance_icon;
pub use self::install::{
accept_shared_instance_invite_for_install,
- get_shared_instance_install_preview, get_shared_instance_update_preview,
- install_shared_instance, update_shared_instance,
+ get_shared_instance_install_preview,
+ get_shared_instance_invite_install_preview,
+ get_shared_instance_update_preview, install_shared_instance,
+ update_shared_instance,
};
pub use self::invites::{
accept_pending_shared_instance_invite, create_shared_instance_invite_link,
@@ -127,11 +150,11 @@ pub use self::publish::{
};
pub use self::types::{
SharedInstanceExternalFilePreview, SharedInstanceInstallPreview,
- SharedInstanceInvite, SharedInstanceInviteInstallPreview,
- SharedInstanceInviteLink, SharedInstanceJoinType,
- SharedInstancePublishPreview, SharedInstanceUpdateDiff,
- SharedInstanceUpdateDiffType, SharedInstanceUpdatePreview,
- SharedInstanceUser, SharedInstanceUsers,
+ SharedInstanceInvite, SharedInstanceInviteCreator,
+ SharedInstanceInviteInstallPreview, SharedInstanceInviteLink,
+ SharedInstanceJoinType, SharedInstancePublishPreview,
+ SharedInstanceUpdateDiff, SharedInstanceUpdateDiffType,
+ SharedInstanceUpdatePreview, SharedInstanceUser, SharedInstanceUsers,
};
pub async fn can_active_user_use_shared_instances() -> crate::Result {
diff --git a/packages/app-lib/src/api/instance/shared/publish.rs b/packages/app-lib/src/api/instance/shared/publish.rs
index 26d4d0d12af..15b36356ae3 100644
--- a/packages/app-lib/src/api/instance/shared/publish.rs
+++ b/packages/app-lib/src/api/instance/shared/publish.rs
@@ -6,9 +6,6 @@ use super::*;
use async_walkdir::WalkDir;
use futures::StreamExt;
use sha2::Digest;
-use std::collections::BTreeMap;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
#[tracing::instrument]
pub async fn unpublish_shared_instance(instance_id: &str) -> crate::Result<()> {
@@ -168,91 +165,6 @@ pub async fn get_shared_instance_publish_preview(
}))
}
-pub(super) async fn remote_publish_content(
- version: &InstanceVersionResponse,
- include_modpack_dependencies: bool,
- state: &State,
-) -> crate::Result<(Vec, BTreeSet)> {
- let mut version_ids = version.modrinth_ids.clone();
- if let Some(modpack_id) =
- version.modpack_id.as_deref().filter(|id| !id.is_empty())
- {
- version_ids.retain(|id| id != modpack_id);
-
- if include_modpack_dependencies {
- extend_shared_modpack_dependencies(
- &mut version_ids,
- modpack_id,
- state,
- )
- .await?;
- }
- }
- dedupe_strings(&mut version_ids);
-
- Ok((
- version_ids,
- version
- .external_files
- .iter()
- .filter(|file| file.file_type != CONFIG_BUNDLE_FILE_TYPE)
- .map(|file| {
- shared_external_file_key(&file.file_type, &file.file_name)
- })
- .collect::>()?,
- ))
-}
-
-pub(super) async fn modpack_dependency_version_ids(
- modpack_id: &str,
- state: &State,
-) -> crate::Result> {
- let modpack_version = CachedEntry::get_version(
- modpack_id,
- Some(CacheBehaviour::Bypass),
- &state.pool,
- &state.api_semaphore,
- )
- .await?
- .ok_or_else(|| {
- crate::ErrorKind::InputError(
- "Shared instance modpack version was not found".to_string(),
- )
- })?;
-
- Ok(modpack_version
- .dependencies
- .into_iter()
- .filter_map(|dependency| dependency.version_id)
- .collect())
-}
-
-/// Adds the modpack's dependencies to the list. If a project is already in the
-/// list, keep that version instead of the one bundled with the modpack.
-async fn extend_shared_modpack_dependencies(
- version_ids: &mut Vec,
- modpack_id: &str,
- state: &State,
-) -> crate::Result<()> {
- let dependency_ids =
- modpack_dependency_version_ids(modpack_id, state).await?;
- let (explicit, inherited) = tokio::try_join!(
- shared_versions_by_id(version_ids, false, state),
- shared_versions_by_id(&dependency_ids, false, state),
- )?;
- version_ids.extend(
- inherited
- .into_values()
- .filter(|version| {
- !explicit
- .values()
- .any(|installed| installed.project_id == version.project_id)
- })
- .map(|version| version.id),
- );
- Ok(())
-}
-
pub(super) async fn shared_instance_install_modpack(
version: &InstanceVersionResponse,
state: &State,
@@ -285,7 +197,6 @@ pub(super) async fn shared_instance_install_modpack(
Ok(Some(crate::install::SharedInstanceInstallModpack {
project_id: modpack_version.project_id,
version_id: modpack_version.id,
- dependency_count: modpack_version.dependencies.len(),
title: project
.as_ref()
.map(|project| project.title.clone())
@@ -302,63 +213,66 @@ pub(super) fn shared_instance_loader_version(
pub(super) async fn current_shared_content(
metadata: &crate::state::InstanceMetadata,
- include_linked_modpack_content: bool,
state: &State,
) -> crate::Result<(Vec, BTreeSet)> {
- let entries =
- crate::state::instances::adapters::sqlite::content_rows::get_content_entries(
- &metadata.applied_content_set.id,
- &state.pool,
- )
- .await?;
+ let entries = crate::state::instances::adapters::sqlite::content_rows::get_content_entries(
+ &metadata.applied_content_set.id, &state.pool,
+ ).await?;
let files = crate::state::instances::adapters::sqlite::content_rows::get_instance_files(
- &metadata.instance.id,
+ &metadata.instance.id, &state.pool,
+ ).await?.into_iter().map(|file| (file.id.clone(), file)).collect::>();
+ let unresolved_hashes = entries
+ .iter()
+ .filter(|entry| {
+ entry.source_kind == ContentSourceKind::ModrinthModpack
+ && entry.version_id.is_none()
+ })
+ .filter_map(|entry| entry.file_id.as_ref().and_then(|id| files.get(id)))
+ .filter(|file| file.enabled && !file.missing)
+ .map(|file| file.sha1.as_str())
+ .collect::>();
+ let resolved_files = CachedEntry::get_file_many(
+ &unresolved_hashes,
+ Some(CacheBehaviour::MustRevalidate),
&state.pool,
+ &state.api_semaphore,
)
.await?
.into_iter()
- .map(|file| (file.id.clone(), file))
+ .map(|file| (file.hash.clone(), file))
.collect::>();
let mut version_ids = Vec::new();
let mut external_files = BTreeSet::new();
-
for entry in entries {
- let include_entry = entry.source_kind
- == crate::state::ContentSourceKind::SharedInstance
- || (include_linked_modpack_content
- && entry.source_kind
- == crate::state::ContentSourceKind::ModrinthModpack);
- if !include_entry {
+ if !entry.source_kind.is_shared_instance_managed() || !entry.enabled {
continue;
}
-
- if let Some(version_id) = entry.version_id {
- version_ids.push(version_id);
- continue;
- }
-
- let Some(file_id) = entry.file_id else {
+ let Some(file) = entry.file_id.as_ref().and_then(|id| files.get(id))
+ else {
continue;
};
- if let Some(file) = files.get(&file_id) {
+ if !file.enabled || file.missing {
+ continue;
+ }
+ let version_id = entry.version_id.or_else(|| {
+ (entry.source_kind == ContentSourceKind::ModrinthModpack)
+ .then(|| {
+ resolved_files
+ .get(&file.sha1)
+ .map(|file| file.version_id.clone())
+ })
+ .flatten()
+ });
+ if let Some(version_id) = version_id {
+ version_ids.push(version_id);
+ } else {
external_files.insert(ExternalFileKey {
content_type: entry.project_type.into(),
- path: file.file_name.clone(),
+ path: enabled_file_name(&file.file_name),
});
}
}
- if include_linked_modpack_content
- && let Some(modpack_id) = shared_modpack_id(&metadata.link)
- {
- extend_shared_modpack_dependencies(
- &mut version_ids,
- &modpack_id,
- state,
- )
- .await?;
- }
dedupe_strings(&mut version_ids);
-
Ok((version_ids, external_files))
}
@@ -369,6 +283,8 @@ pub(super) struct CurrentPublishSnapshot {
pub(super) disabled_version_ids: Vec,
pub(super) disabled_external_files: BTreeSet,
pub(super) config_files: Vec,
+ pub(super) removed_files: Vec,
+ pub(super) effective_version_ids: Vec,
}
/// Cached metadata can outlive a deleted or hidden version. Only publish version
@@ -403,6 +319,62 @@ pub(super) async fn collect_publish_snapshot(
Vec::new(),
)
};
+ let mut items = items;
+ let modpack_id = shared_modpack_id(&metadata.link);
+ let modpack_files = if let Some(modpack_id) = modpack_id.as_deref() {
+ let (managed, files) = tokio::try_join!(
+ crate::state::list_linked_modpack_content(
+ &metadata.instance.id,
+ None,
+ None,
+ state,
+ ),
+ shared_modpack_files(modpack_id, state),
+ )?;
+ items.extend(managed);
+ files
+ } else {
+ Vec::new()
+ };
+ let mut seen_paths = HashSet::new();
+ items.retain(|item| seen_paths.insert(item.file_path.clone()));
+ let enabled_versions = items
+ .iter()
+ .filter(|item| item.enabled)
+ .filter_map(|item| {
+ item.version.as_ref().map(|version| version.id.as_str())
+ })
+ .collect::>();
+ let enabled_paths = items
+ .iter()
+ .filter(|item| item.enabled)
+ .map(|item| item.file_path.trim_end_matches(".disabled"))
+ .collect::>();
+ let mut removed_files = Vec::new();
+ for file in &modpack_files {
+ if let Some(version_id) = &file.version_id {
+ if !enabled_versions.contains(version_id.as_str()) {
+ let removed = SharedInstanceRemovedFile::Version {
+ version_id: version_id.clone(),
+ };
+ if !removed_files.contains(&removed) {
+ removed_files.push(removed);
+ }
+ }
+ } else if !enabled_paths.contains(file.relative_path.as_str())
+ && let Some((parent, filename)) = file.relative_path.split_once('/')
+ {
+ removed_files.push(SharedInstanceRemovedFile::Path {
+ parent: parent.to_string(),
+ filename: filename.to_string(),
+ });
+ }
+ }
+ let inherited_versions = modpack_files
+ .iter()
+ .filter_map(|file| file.version_id.as_deref())
+ .collect::>();
+ let mut effective_version_ids = Vec::new();
let installed_version_ids = items
.iter()
.filter(|item| item.enabled)
@@ -420,7 +392,6 @@ pub(super) async fn collect_publish_snapshot(
.into_iter()
.map(|version| version.id)
.collect::>();
- let modpack_id = shared_modpack_id(&metadata.link);
let mut version_ids = Vec::new();
let mut seen_version_ids = HashSet::new();
let mut external_files = Vec::new();
@@ -436,7 +407,10 @@ pub(super) async fn collect_publish_snapshot(
&& available_version_ids.contains(&version.id)
{
if seen_version_ids.insert(version.id.clone()) {
- version_ids.push(version.id.clone());
+ effective_version_ids.push(version.id.clone());
+ if !inherited_versions.contains(version.id.as_str()) {
+ version_ids.push(version.id.clone());
+ }
}
continue;
}
@@ -494,6 +468,8 @@ pub(super) async fn collect_publish_snapshot(
disabled_version_ids,
disabled_external_files,
config_files,
+ removed_files,
+ effective_version_ids,
})
}
@@ -692,42 +668,20 @@ pub(super) async fn publish_current_content(
.await?;
let modpack_id = shared_modpack_id(&metadata.link);
let snapshot = collect_publish_snapshot(&metadata, state).await?;
- let previous_version = if CONFIG_SYNC_ENABLED
- && metadata
- .shared_instance
- .as_ref()
- .and_then(|attachment| attachment.applied_version)
- .is_some()
- {
- match get_latest_remote_version_optional_unavailable(
- shared_instance_id,
- state,
- )
- .await?
- {
- SharedInstanceRemoteResponse::Available(version) => Some(version),
- SharedInstanceRemoteResponse::Unavailable(_) => None,
- }
- } else {
- None
- };
- let config_bundle = if CONFIG_SYNC_ENABLED {
- build_config_bundle_candidate(
+ let config_files = if CONFIG_SYNC_ENABLED {
+ config_file_candidates(
&metadata.instance.path,
&snapshot.config_files,
config_paths,
- previous_version.as_ref(),
state,
)
.await?
} else {
- None
+ Vec::new()
};
let modrinth_ids = snapshot.version_ids;
let mut external_files = snapshot.external_files;
- if let Some(config_bundle) = config_bundle {
- external_files.push(config_bundle);
- }
+ external_files.extend(config_files);
tracing::debug!(
instance_id,
shared_instance_id,
@@ -751,6 +705,7 @@ pub(super) async fn publish_current_content(
"modrinth_ids": modrinth_ids,
"external_files": external_file_data,
"modpack_id": modpack_id,
+ "removed_files": snapshot.removed_files,
"game_version": metadata.applied_content_set.game_version.clone(),
"loader": metadata.applied_content_set.loader.as_str(),
"loader_version": metadata
@@ -812,15 +767,16 @@ pub(super) async fn collect_config_files(
"Failed to read config directory: {error}"
))
})?;
- if !entry.file_type().await?.is_file()
- || !is_supported_config_file(&entry.path())
- {
+ if !entry.file_type().await?.is_file() {
continue;
}
let entry_path = entry.path();
let relative_path = entry_path.strip_prefix(&config_path)?;
let path = relative_path.to_string_lossy().replace('\\', "/");
+ if !is_shareable_config_path(&format!("{CONFIG_DIRECTORY}/{path}")) {
+ continue;
+ }
files.push(ConfigFile { path });
}
@@ -828,235 +784,91 @@ pub(super) async fn collect_config_files(
Ok(files)
}
-fn is_supported_config_file(path: &std::path::Path) -> bool {
- path.extension()
- .and_then(|extension| extension.to_str())
- .is_some_and(|extension| {
- CONFIG_FILE_EXTENSIONS
- .iter()
- .any(|candidate| extension.eq_ignore_ascii_case(candidate))
- })
-}
-
-async fn build_config_bundle_candidate(
+/// Each selected config is uploaded as its own file under the instance root,
+/// matching how linked servers publish configs.
+async fn config_file_candidates(
instance_path: &str,
local_files: &[ConfigFile],
selected_paths: &[String],
- previous_version: Option<&InstanceVersionResponse>,
state: &State,
-) -> crate::Result> {
+) -> crate::Result> {
+ let local_paths = local_files
+ .iter()
+ .map(|file| file.path.as_str())
+ .collect::>();
let selected_paths = selected_paths
.iter()
.map(String::as_str)
- .collect::>();
- let local_files_by_path = local_files
+ .collect::>();
+ if let Some(missing) = selected_paths
.iter()
- .map(|file| (file.path.as_str(), file))
- .collect::>();
- for selected_path in &selected_paths {
- if !local_files_by_path.contains_key(selected_path) {
- return Err(crate::ErrorKind::InputError(format!(
- "Config file is unavailable for sharing: {selected_path}"
- ))
- .into());
- }
- }
-
- let previous_bundle = previous_version.and_then(|version| {
- version
- .external_files
- .iter()
- .find(|file| file.file_type == CONFIG_BUNDLE_FILE_TYPE)
- });
- if previous_bundle.is_none() && selected_paths.is_empty() {
- return Ok(None);
+ .find(|path| !local_paths.contains(*path))
+ {
+ return Err(crate::ErrorKind::InputError(format!(
+ "Config file is unavailable for sharing: {missing}"
+ ))
+ .into());
}
+ ensure_config_file_count(&selected_paths)?;
- let previous_bundle = if let Some(previous_bundle) = previous_bundle {
- Some(
- crate::util::fetch::fetch_file_mirrors(
- &[&previous_bundle.url],
- None,
- None,
- None,
- &state.fetch_semaphore,
- &state.pool,
- None,
- )
- .await?,
- )
- } else {
- None
- };
let config_path = state
.directories
.instances_dir()
.join(instance_path)
.join(CONFIG_DIRECTORY);
- let selected_files = selected_paths
- .into_iter()
- .map(|path| (path.to_string(), config_path.join(path)))
- .collect::>();
- let bundle = tokio::task::spawn_blocking(move || {
- let directory = tempfile::tempdir()?;
- let mut entries = match &previous_bundle {
- Some(bundle) => {
- read_config_bundle(bundle.path(), directory.path())?
- }
- None => BTreeMap::new(),
- };
- entries.extend(selected_files);
- config_bundle_file(&entries)
- })
- .await??;
-
- Ok(Some(ExternalFileCandidate {
- file_name: CONFIG_BUNDLE_FILE_NAME.to_string(),
- file_type: CONFIG_BUNDLE_FILE_TYPE.to_string(),
- source: ExternalFileSource::ConfigBundle(Arc::new(bundle)),
- }))
-}
-
-fn config_bundle_file(
- entries: &BTreeMap,
-) -> crate::Result {
- if entries.len() > MAX_CONFIG_BUNDLE_ENTRIES {
- let mut folder_entry_counts = HashMap::new();
- for path in entries.keys() {
- if let Some((folder, _)) = path.split_once('/') {
- *folder_entry_counts.entry(folder).or_insert(0_usize) += 1;
- }
- }
-
- if let Some((folder, count)) = folder_entry_counts
- .into_iter()
- .filter(|(_, count)| *count > MAX_CONFIG_BUNDLE_ENTRIES)
- .max_by_key(|(_, count)| *count)
+ let mut total_size = 0_u64;
+ let mut candidates = Vec::with_capacity(selected_paths.len());
+ for path in selected_paths {
+ let source = config_path.join(path);
+ let size = crate::util::io::metadata(&source).await?.len();
+ total_size = total_size.saturating_add(size);
+ if size > MAX_CONFIG_BUNDLE_FILE_SIZE
+ || total_size > MAX_CONFIG_BUNDLE_TOTAL_SIZE
{
- return Err(crate::ErrorKind::InputError(format!(
- "The \"{folder}\" config folder has too many files to share ({count}; maximum {MAX_CONFIG_BUNDLE_ENTRIES}). Select fewer files from this folder."
- ))
- .into());
+ return Err(crate::ErrorKind::InputError(
+ "Selected config files exceed the size limit for sharing"
+ .to_string(),
+ )
+ .into());
}
-
- return Err(crate::ErrorKind::InputError(format!(
- "Too many config files were selected to share ({}; maximum {MAX_CONFIG_BUNDLE_ENTRIES}). Select fewer files.",
- entries.len()
- ))
- .into());
- }
- let temporary = tempfile::NamedTempFile::new()?;
- let mut writer = zip::ZipWriter::new(temporary);
- let options = zip::write::SimpleFileOptions::default()
- .compression_method(zip::CompressionMethod::Deflated);
- let mut total_size = 0;
- for (path, source) in entries {
- let file = std::fs::File::open(source)?;
- let declared_size = file.metadata()?.len();
- writer
- .start_file(path, options)
- .map_err(std::io::Error::from)?;
- copy_config_bundle_entry(
- file,
- declared_size,
- &mut total_size,
- &mut writer,
- )?;
+ candidates.push(ExternalFileCandidate {
+ file_name: format!("{CONFIG_DIRECTORY}/{path}"),
+ file_type: CONFIG_FILE_TYPE.to_string(),
+ source: ExternalFileSource::ConfigFile(source),
+ });
}
- Ok(writer
- .finish()
- .map_err(std::io::Error::from)?
- .into_temp_path())
-}
-fn copy_config_bundle_entry(
- reader: impl std::io::Read,
- declared_size: u64,
- total_size: &mut u64,
- writer: &mut impl std::io::Write,
-) -> crate::Result<()> {
- let limit = MAX_CONFIG_BUNDLE_FILE_SIZE
- .min(MAX_CONFIG_BUNDLE_TOTAL_SIZE.saturating_sub(*total_size));
- if declared_size > limit {
- return Err(crate::ErrorKind::InputError(
- "Shared instance config bundle exceeds the uncompressed size limit"
- .to_string(),
- )
- .into());
- }
- let size = std::io::copy(&mut reader.take(limit + 1), writer)?;
- if size > limit {
- return Err(crate::ErrorKind::InputError(
- "Shared instance config bundle exceeds the uncompressed size limit"
- .to_string(),
- )
- .into());
- }
- *total_size += size;
- Ok(())
+ Ok(candidates)
}
-fn read_config_bundle(
- path: &Path,
- directory: &Path,
-) -> crate::Result> {
- let mut archive = zip::ZipArchive::new(std::fs::File::open(path)?)
- .map_err(|error| {
- crate::ErrorKind::InputError(format!(
- "Invalid shared instance config bundle: {error}"
- ))
- })?;
- if archive.len() > MAX_CONFIG_BUNDLE_ENTRIES {
- return Err(crate::ErrorKind::InputError(
- "Shared instance config bundle contains too many entries"
- .to_string(),
- )
- .into());
+fn ensure_config_file_count(paths: &BTreeSet<&str>) -> crate::Result<()> {
+ if paths.len() <= MAX_CONFIG_BUNDLE_ENTRIES {
+ return Ok(());
}
- let mut entries = BTreeMap::new();
- let mut total_size = 0;
- for index in 0..archive.len() {
- let file = archive.by_index(index).map_err(|error| {
- crate::ErrorKind::InputError(format!(
- "Invalid shared instance config bundle entry: {error}"
- ))
- })?;
- if file.is_dir() {
- continue;
- }
- let path = file.enclosed_name().ok_or_else(|| {
- crate::ErrorKind::InputError(
- "Shared instance config bundle contains an unsafe path"
- .to_string(),
- )
- })?;
- if !is_supported_config_file(&path) {
- return Err(crate::ErrorKind::InputError(format!(
- "Shared instance config bundle contains unsupported file {}",
- path.display()
- ))
- .into());
- }
- let path = path.to_string_lossy().replace('\\', "/");
- let declared_size = file.size();
- let destination = directory.join(index.to_string());
- let mut output = std::fs::File::create(&destination)?;
- copy_config_bundle_entry(
- file,
- declared_size,
- &mut total_size,
- &mut output,
- )?;
- if entries.insert(path.clone(), destination).is_some() {
- return Err(crate::ErrorKind::InputError(format!(
- "Shared instance config bundle contains duplicate file {path}"
- ))
- .into());
+ let mut folder_entry_counts = HashMap::new();
+ for path in paths {
+ if let Some((folder, _)) = path.split_once('/') {
+ *folder_entry_counts.entry(folder).or_insert(0_usize) += 1;
}
}
- Ok(entries)
+ if let Some((folder, count)) = folder_entry_counts
+ .into_iter()
+ .filter(|(_, count)| *count > MAX_CONFIG_BUNDLE_ENTRIES)
+ .max_by_key(|(_, count)| *count)
+ {
+ return Err(crate::ErrorKind::InputError(format!(
+ "The \"{folder}\" config folder has too many files to share ({count}; maximum {MAX_CONFIG_BUNDLE_ENTRIES}). Select fewer files from this folder."
+ ))
+ .into());
+ }
+
+ Err(crate::ErrorKind::InputError(format!(
+ "Too many config files were selected to share ({}; maximum {MAX_CONFIG_BUNDLE_ENTRIES}). Select fewer files.",
+ paths.len()
+ ))
+ .into())
}
pub(super) fn shared_modpack_id(link: &InstanceLink) -> Option {
@@ -1113,17 +925,21 @@ pub(super) async fn upload_external_files(
.ok_or_else(|| crate::state::content_store::input("Shared content file is not registered"))?;
state.content_store.read_path(&file, instance_path).await?
}
- ExternalFileSource::ConfigBundle(path) => {
+ ExternalFileSource::ConfigFile(path) => {
crate::state::content_store::ReadableContent::Local(
- path.as_ref().to_path_buf(),
+ path.clone(),
)
}
};
- let upload_url = url::Url::parse(&upload.url).map_err(|error| {
- crate::ErrorKind::OtherError(format!(
- "Invalid shared instance external file upload URL: {error}"
- ))
- })?;
+ let upload_url_string = upload.url.as_deref().filter(|url| !url.is_empty()).ok_or_else(|| {
+ crate::ErrorKind::InputError(format!("Shared instance external file {} is missing its upload URL", upload.file_name))
+ })?;
+ let upload_url =
+ url::Url::parse(upload_url_string).map_err(|error| {
+ crate::ErrorKind::OtherError(format!(
+ "Invalid shared instance external file upload URL: {error}"
+ ))
+ })?;
let mut file = tokio::fs::File::open(path.path()).await?;
let mut hasher = sha2::Sha512::new();
let mut buffer = vec![0_u8; 64 * 1024];
@@ -1146,7 +962,7 @@ pub(super) async fn upload_external_files(
"upload_external_file",
Method::PUT,
upload_url.path(),
- &upload.url,
+ upload_url_string,
body,
Some(size),
Some(&file_sha512),
diff --git a/packages/app-lib/src/api/instance/shared/types.rs b/packages/app-lib/src/api/instance/shared/types.rs
index a6def37decf..057833155e2 100644
--- a/packages/app-lib/src/api/instance/shared/types.rs
+++ b/packages/app-lib/src/api/instance/shared/types.rs
@@ -80,6 +80,8 @@ pub struct SharedInstanceInstallPreview {
pub modpack_version_id: Option,
pub content_version_ids: Vec,
pub external_files: Vec,
+ #[serde(default)]
+ pub removed_files: Vec,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
@@ -129,6 +131,7 @@ pub struct SharedInstanceInvite {
#[serde(rename_all = "camelCase")]
pub struct SharedInstanceInviteInstallPreview {
pub shared_instance_id: String,
+ pub inviter: Option,
pub manager_id: Option,
pub server_manager_name: Option,
pub server_manager_icon_url: Option,
@@ -136,6 +139,13 @@ pub struct SharedInstanceInviteInstallPreview {
pub preview: SharedInstanceInstallPreview,
}
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct SharedInstanceInviteCreator {
+ pub id: String,
+ pub name: String,
+ pub avatar: Option,
+}
+
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SharedInstanceUpdateDiff {
diff --git a/packages/app-lib/src/api/instance/synced_options/orchestration.rs b/packages/app-lib/src/api/instance/synced_options/orchestration.rs
index 4aa7319f1b6..a4cf57e12af 100644
--- a/packages/app-lib/src/api/instance/synced_options/orchestration.rs
+++ b/packages/app-lib/src/api/instance/synced_options/orchestration.rs
@@ -1141,9 +1141,10 @@ pub async fn reconcile_changed_file(
let state = State::get().await?;
let _guard = state.lock_synced_options().await;
apply_pending_changes(&state).await?;
- let metadata = crate::state::get_instance(instance_id, &state.pool)
- .await?
- .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+ let metadata = crate::state::get_instance(instance_id, &state.pool).await?;
+ let Some(metadata) = metadata else {
+ return Ok(());
+ };
if sync_files_are_protected(&metadata) {
return Ok(());
}
diff --git a/packages/app-lib/src/api/instance/synced_servers/mod.rs b/packages/app-lib/src/api/instance/synced_servers/mod.rs
index bde48e11b14..3ff271ae26d 100644
--- a/packages/app-lib/src/api/instance/synced_servers/mod.rs
+++ b/packages/app-lib/src/api/instance/synced_servers/mod.rs
@@ -7,6 +7,7 @@ mod types;
const SERVERS_FILE: &str = "servers.dat";
pub(crate) use self::codec::server_data;
+pub use self::modpack::discard_modpack_servers;
pub(crate) use self::modpack::{
MODPACK_SERVER_PATHS, capture_modpack_server_override,
};
diff --git a/packages/app-lib/src/api/instance/synced_servers/modpack.rs b/packages/app-lib/src/api/instance/synced_servers/modpack.rs
index 27858a16cf7..3cb44215d97 100644
--- a/packages/app-lib/src/api/instance/synced_servers/modpack.rs
+++ b/packages/app-lib/src/api/instance/synced_servers/modpack.rs
@@ -1,6 +1,7 @@
use super::super::synced_options::{instance_dir, instance_is_running};
-use super::codec::{read_servers, servers_from_bytes};
-use super::operations::{compose_instance, participating};
+use super::SERVERS_FILE;
+use super::codec::{read_servers, servers_from_bytes, write_servers};
+use super::operations::{compose_instance, effective, participating};
use super::storage::{load_local, write_local_rows};
use super::types::{LocalServer, ServerSource};
use crate::state::{CachedEntry, InstanceLink, InstanceMetadata};
@@ -42,6 +43,47 @@ pub(crate) async fn capture_modpack_server_override(
Ok(())
}
+pub async fn discard_modpack_servers(instance_id: &str) -> crate::Result<()> {
+ let state = State::get().await?;
+ let _guard = state.lock_synced_options().await;
+ let metadata = crate::state::get_instance(instance_id, &state.pool)
+ .await?
+ .ok_or_else(|| ErrorKind::InputError("Unknown instance".to_string()))?;
+ discard_modpack_servers_for_instance(&metadata, &state).await?;
+ if effective(&metadata, &state).await? {
+ compose_instance(&metadata, &state).await?;
+ }
+ Ok(())
+}
+
+async fn discard_modpack_servers_for_instance(
+ metadata: &InstanceMetadata,
+ state: &State,
+) -> crate::Result<()> {
+ let old_pack_servers = load_local(&metadata.instance.id, state)
+ .await?
+ .into_iter()
+ .filter(|server| server.source == ServerSource::Modpack)
+ .collect::>();
+ if !old_pack_servers.is_empty() {
+ let path = instance_dir(metadata, state).join(SERVERS_FILE);
+ let mut servers = read_servers(&path).await?;
+ let mut changed = false;
+ for old in old_pack_servers {
+ if let Some(index) =
+ servers.iter().position(|server| *server == old.data)
+ {
+ servers.remove(index);
+ changed = true;
+ }
+ }
+ if changed {
+ write_servers(&path, &servers).await?;
+ }
+ }
+ replace_modpack_servers(metadata, Vec::new(), state).await
+}
+
async fn replace_modpack_servers(
metadata: &InstanceMetadata,
servers: Vec,
@@ -125,6 +167,9 @@ pub(super) async fn reconstruct_modpack_servers(
metadata: &InstanceMetadata,
state: &State,
) -> crate::Result<()> {
+ if is_server_linked_shared_instance(metadata) {
+ return discard_modpack_servers_for_instance(metadata, state).await;
+ }
let version_id = modpack_version_id(&metadata.link).ok_or_else(|| {
ErrorKind::InputError(
"This modpack does not have a recoverable Modrinth version."
@@ -191,6 +236,14 @@ pub(super) async fn reconstruct_modpack_servers(
replace_modpack_servers(metadata, servers, state).await
}
+fn is_server_linked_shared_instance(metadata: &InstanceMetadata) -> bool {
+ matches!(&metadata.link, InstanceLink::SharedInstance { .. })
+ && metadata
+ .shared_instance
+ .as_ref()
+ .is_some_and(|attachment| attachment.server_manager_name.is_some())
+}
+
pub(super) fn is_modpack_link(link: &InstanceLink) -> bool {
matches!(
link,
diff --git a/packages/app-lib/src/api/instance/synced_servers/operations.rs b/packages/app-lib/src/api/instance/synced_servers/operations.rs
index 1a4cbefb93d..036de46c7d5 100644
--- a/packages/app-lib/src/api/instance/synced_servers/operations.rs
+++ b/packages/app-lib/src/api/instance/synced_servers/operations.rs
@@ -216,7 +216,25 @@ pub(in crate::api::instance) async fn reconcile_servers(
.as_ref()
.is_some_and(|value| value.source_revision == revision)
{
- return Ok(());
+ let projections =
+ load_projection_entries(&metadata.instance.id, state).await?;
+ let records = compose_records(metadata, state).await?;
+ if projections.len() == records.len()
+ && projections.iter().zip(&records).enumerate().all(
+ |(position, (projection, record))| {
+ let owner = match record.source {
+ ServerSource::UserSynced => ProjectionOwner::Synced,
+ _ => ProjectionOwner::Instance,
+ };
+ projection.id == record.id
+ && projection.owner == owner
+ && projection.data == record.data
+ && projection.position == position as i64
+ },
+ )
+ {
+ return Ok(());
+ }
}
return compose_instance(metadata, state).await;
}
diff --git a/packages/app-lib/src/api/pack/import/mod.rs b/packages/app-lib/src/api/pack/import/mod.rs
index 357002ab478..4d2746f5ce6 100644
--- a/packages/app-lib/src/api/pack/import/mod.rs
+++ b/packages/app-lib/src/api/pack/import/mod.rs
@@ -628,38 +628,34 @@ pub(crate) async fn finish_import(
Ok(())
}
-/// Recursively get a list of all subfiles in src
-/// uses async recursion
-
-#[async_recursion::async_recursion]
+/// Lists descendant files without following symlinks or recursing on the stack.
#[tracing::instrument]
pub async fn get_all_subfiles(
src: &Path,
include_empty_dirs: bool,
) -> crate::Result> {
- let metadata = tokio::fs::symlink_metadata(src).await?;
- if !metadata.is_dir() || metadata.file_type().is_symlink() {
- return Ok(vec![src.to_path_buf()]);
- }
-
let mut files = Vec::new();
- let mut dir = io::read_dir(&src).await?;
-
- let mut has_files = false;
- while let Some(child) = dir
- .next_entry()
- .await
- .map_err(|e| IOError::with_path(e, src))?
- {
- has_files = true;
- let src_child = child.path();
- files.append(
- &mut get_all_subfiles(&src_child, include_empty_dirs).await?,
- );
- }
+ let mut pending = vec![src.to_path_buf()];
+ while let Some(path) = pending.pop() {
+ let metadata = tokio::fs::symlink_metadata(&path).await?;
+ if !metadata.is_dir() || metadata.file_type().is_symlink() {
+ files.push(path);
+ continue;
+ }
- if !has_files && include_empty_dirs {
- files.push(src.to_path_buf());
+ let mut dir = io::read_dir(&path).await?;
+ let children_start = pending.len();
+ while let Some(child) = dir
+ .next_entry()
+ .await
+ .map_err(|error| IOError::with_path(error, &path))?
+ {
+ pending.push(child.path());
+ }
+ if pending.len() == children_start && include_empty_dirs {
+ files.push(path);
+ }
+ pending[children_start..].reverse();
}
Ok(files)
diff --git a/packages/app-lib/src/api/pack/install_from.rs b/packages/app-lib/src/api/pack/install_from.rs
index 0dfa24941b4..0c0f6544d12 100644
--- a/packages/app-lib/src/api/pack/install_from.rs
+++ b/packages/app-lib/src/api/pack/install_from.rs
@@ -630,12 +630,17 @@ pub async fn set_instance_information(
&instance_id,
EditInstance {
install_stage: Some(InstanceInstallStage::PackInstalling),
- name: Some(
- description
- .override_title
- .clone()
- .unwrap_or_else(|| backup_name.to_string()),
- ),
+ name: if matches!(&link, Some(InstanceLink::SharedInstance { .. }))
+ {
+ None
+ } else {
+ Some(
+ description
+ .override_title
+ .clone()
+ .unwrap_or_else(|| backup_name.to_string()),
+ )
+ },
icon_path: description
.icon
.as_ref()
diff --git a/packages/app-lib/src/api/pack/install_mrpack.rs b/packages/app-lib/src/api/pack/install_mrpack.rs
index b60d15fd6c9..73b995c2bdc 100644
--- a/packages/app-lib/src/api/pack/install_mrpack.rs
+++ b/packages/app-lib/src/api/pack/install_mrpack.rs
@@ -514,12 +514,16 @@ pub(crate) fn install_zipped_mrpack_files_with_reporter(
ignore_lock: bool,
reason: DownloadReason,
reporter: InstallProgressReporter,
+ ignore_modpack_servers: bool,
+ preserve_icon: bool,
) -> impl Future