fix: better offline handling

apps/app-frontend/src/components/ui/instance_settings/SharingSettings.vue

@@ -72,7 +72,6 @@ import {
 	ButtonStyled,
 	CopyCode,
 	defineMessages,
-	injectNotificationManager,
 	Table,
 	type TableColumn,
 	useFormatDateTime,
@@ -86,10 +85,11 @@ import ConfirmRevokeSharedInstanceInviteModal from '@/components/ui/shared-insta
 import SharedInstanceInstallationSettingsControls from '@/components/ui/shared-instances/SharedInstanceInstallationSettingsControls.vue'
 import { config } from '@/config'
 import { type SharedInstanceInvite, unpublish_shared_instance } from '@/helpers/instance'
+import { useSharedInstanceErrors } from '@/helpers/shared-instance-errors'
 import { injectInstanceSettings } from '@/providers/instance-settings'
 
 const { instance, offline, onUnlinked } = injectInstanceSettings()
-const { handleError } = injectNotificationManager()
+const { notifySharedInstanceError } = useSharedInstanceErrors()
 const { formatMessage } = useVIntl()
 const queryClient = useQueryClient()
 const unpublishing = ref(false)
@@ -162,7 +162,7 @@ async function unpublishSharedInstance() {
 		await queryClient.invalidateQueries({ queryKey: ['linkedModpackInfo', instance.value.id] })
 		onUnlinked()
 	} catch (error) {
-		handleError(error)
+		notifySharedInstanceError(error)
 	} finally {
 		unpublishing.value = false
 	}

apps/app-frontend/src/components/ui/shared-instances/shared-instance-invite-handler/use-shared-instance-invite-handler.ts

@@ -19,6 +19,7 @@ import {
 	install_shared_instance,
 } from '@/helpers/install'
 import { list } from '@/helpers/instance'
+import { useSharedInstanceErrors } from '@/helpers/shared-instance-errors'
 import { useTheming } from '@/store/state'
 
 import { parseSharedInstanceInviteNotification } from './shared-instance-invite-parser'
@@ -47,6 +48,8 @@ export function useSharedInstanceInviteHandler(
 	const auth = injectAuth()
 	const client = injectModrinthClient()
 	const { handleError } = injectNotificationManager()
+	const { notifySharedInstanceConnectionError, notifySharedInstanceError } =
+		useSharedInstanceErrors()
 	const popupNotificationManager = injectPopupNotificationManager()
 	const queryClient = useQueryClient()
 	const router = useRouter()
@@ -78,7 +81,10 @@ export function useSharedInstanceInviteHandler(
 			!invite.invitedByUsername && invite.invitedById
 				? get_user(invite.invitedById, 'bypass').catch(() => null)
 				: null,
-			client.sharedinstances.instances_v1.get(invite.sharedInstanceId).catch(() => null),
+			client.sharedinstances.instances_v1.get(invite.sharedInstanceId).catch(() => {
+				notifySharedInstanceConnectionError()
+				return null
+			}),
 		])
 
 		return {
@@ -177,7 +183,7 @@ export function useSharedInstanceInviteHandler(
 				() => markNotificationRead(notification),
 			)
 		} catch (error) {
-			handleError(toError(error))
+			notifySharedInstanceError(error)
 		}
 	}
 
@@ -267,7 +273,7 @@ export function useSharedInstanceInviteHandler(
 				await queryClient.invalidateQueries({ queryKey: ['instances'] })
 			})
 		} catch (error) {
-			handleError(toError(error))
+			notifySharedInstanceError(error)
 		}
 	}
 

apps/app-frontend/src/helpers/install.ts

@@ -102,6 +102,7 @@ export interface SharedInstanceUpdateDiff {
 }
 
 export const SHARED_INSTANCE_UNAVAILABLE_ERROR_CODE = 'shared_instance_unavailable'
+export const SHARED_INSTANCES_API_ERROR_CODE = 'shared_instances_api_error'
 
 export type SharedInstanceUnavailableReason = 'deleted' | 'access_revoked' | 'quarantined'
 
@@ -113,6 +114,10 @@ export function isSharedInstanceUnavailableError(error: unknown) {
 	return getSharedInstanceUnavailableReason(error) !== null
 }
 
+export function isSharedInstancesApiError(error: unknown) {
+	return isRecord(error) && error.code === SHARED_INSTANCES_API_ERROR_CODE
+}
+
 export function getSharedInstanceUnavailableReason(
 	error: unknown,
 ): SharedInstanceUnavailableReason | null {

apps/app-frontend/src/helpers/shared-instance-errors.ts

@@ -1,6 +1,10 @@
 import { defineMessages, injectNotificationManager, useVIntl } from '@modrinth/ui'
 
-import { getErrorMessage, type SharedInstanceUnavailableReason } from '@/helpers/install'
+import {
+	getErrorMessage,
+	isSharedInstancesApiError,
+	type SharedInstanceUnavailableReason,
+} from '@/helpers/install'
 
 export const sharedInstanceErrorMessages = defineMessages({
 	unavailableTitle: {
@@ -39,6 +43,14 @@ export const sharedInstanceErrorMessages = defineMessages({
 		id: 'instance.shared-instance.error.title',
 		defaultMessage: 'Something has gone wrong',
 	},
+	networkErrorTitle: {
+		id: 'instance.shared-instance.network-error.title',
+		defaultMessage: 'Network error',
+	},
+	networkErrorText: {
+		id: 'instance.shared-instance.network-error.text',
+		defaultMessage: 'Unable to connect to shared instances API',
+	},
 })
 
 export function sharedInstanceUnavailableTextMessage(
@@ -82,7 +94,20 @@ export function useSharedInstanceErrors() {
 		})
 	}
 
+	function notifySharedInstanceConnectionError() {
+		addNotification({
+			type: 'error',
+			title: formatMessage(sharedInstanceErrorMessages.networkErrorTitle),
+			text: formatMessage(sharedInstanceErrorMessages.networkErrorText),
+		})
+	}
+
 	function notifySharedInstanceError(error: unknown) {
+		if (isSharedInstancesApiError(error)) {
+			notifySharedInstanceConnectionError()
+			return
+		}
+
 		addNotification({
 			type: 'error',
 			title: formatMessage(sharedInstanceErrorMessages.errorTitle),
@@ -92,6 +117,7 @@ export function useSharedInstanceErrors() {
 
 	return {
 		formatSharedInstanceUnavailable,
+		notifySharedInstanceConnectionError,
 		notifySharedInstanceError,
 		notifySharedInstanceUnavailable,
 	}

apps/app-frontend/src/pages/instance/Index.vue

@@ -590,17 +590,16 @@ const startInstance = async (context: string) => {
 		!!instance.value.shared_instance && !sharedInstanceActionsLocked.value && !offline.value
 
 	if (canCheckSharedInstanceUpdate) {
-		let preview: Awaited<ReturnType<typeof refreshSharedInstanceUpdatePreview>>
+		let preview: Awaited<ReturnType<typeof refreshSharedInstanceUpdatePreview>> = null
 		checkingSharedInstanceLaunch.value = true
 		try {
 			preview = await refreshSharedInstanceUpdatePreview()
 		} catch (error) {
 			if (isSharedInstanceUnavailableError(error)) {
 				await handleSharedInstanceUnavailable(getSharedInstanceUnavailableReason(error))
-			} else {
+				return
-				notifySharedInstanceError(error)
 			}
-			return
+			notifySharedInstanceError(error)
 		} finally {
 			checkingSharedInstanceLaunch.value = false
 		}
@@ -707,7 +706,7 @@ async function reportSharedInstance(event?: MouseEvent, closeUpdateModal = false
 		if (closeUpdateModal) sharedInstanceUpdateModal.value?.hide()
 		sharedInstanceReportModal.value?.showReport(preview, event)
 	} catch (error) {
-		handleError(error as Error)
+		notifySharedInstanceError(error)
 	}
 }
 

apps/app-frontend/src/pages/instance/share/index.vue

@@ -47,7 +47,13 @@
 			@state-change="publishState = $event"
 		/>
 
-		<div v-if="membersTableLoading" class="h-64" aria-hidden="true" />
+		<SharedInstanceShareEmptyState
+			v-if="unableToConnect"
+			:heading="formatMessage(messages.unableToConnectHeading)"
+			:description="formatMessage(messages.unableToConnectDescription)"
+		/>
+
+		<div v-else-if="membersTableLoading" class="h-64" aria-hidden="true" />
 
 		<SharedInstanceMembersTable
 			v-else-if="showMembersTable"
@@ -150,7 +156,7 @@ import {
 	type InvitePlayersUser,
 	useVIntl,
 } from '@modrinth/ui'
-import { useQueryClient } from '@tanstack/vue-query'
+import { useQuery, useQueryClient } from '@tanstack/vue-query'
 import { openUrl } from '@tauri-apps/plugin-opener'
 import { computed, ref, toRef, watch } from 'vue'
 
@@ -158,9 +164,10 @@ import ModrinthAccountRequiredModal from '@/components/ui/modal/ModrinthAccountR
 import SharedInstancePublishModal from '@/components/ui/shared-instances/SharedInstancePublishModal.vue'
 import {
 	getSharedInstanceUnavailableReason,
+	isSharedInstancesApiError,
 	isSharedInstanceUnavailableError,
 } from '@/helpers/install'
-import { edit } from '@/helpers/instance'
+import { can_current_user_use_shared_instances, edit } from '@/helpers/instance'
 import type { ModrinthAuthFlow } from '@/helpers/mr_auth.ts'
 import {
 	sharedInstanceErrorMessages,
@@ -196,6 +203,7 @@ const actionsLocked = sharedInstanceState.shareActionsLocked
 const sharedInstanceActionsLocked = actionsLocked
 const currentUserId = computed(() => auth.user.value?.id ?? null)
 const isSignedIn = computed(() => !!auth.session_token.value)
+const sharedInstancesApiUnavailable = ref(false)
 const accountRequiredModal = ref<InstanceType<typeof ModrinthAccountRequiredModal>>()
 const invitePlayersModal = ref<InstanceType<typeof InvitePlayersModal>>()
 const unlinkModal = ref<InstanceType<typeof ConfirmUnlinkModal>>()
@@ -212,10 +220,22 @@ function notifyOperationError(error: unknown) {
 			sharedInstanceState.unavailableManager.value,
 		)
 	} else {
+		if (isSharedInstancesApiError(error)) sharedInstancesApiUnavailable.value = true
 		notifySharedInstanceError(error)
 	}
 }
 
+const eligibilityQuery = useQuery({
+	queryKey: computed(() => ['shared-instance-eligibility', currentUserId.value]),
+	queryFn: can_current_user_use_shared_instances,
+	enabled: () => isSignedIn.value && !!currentUserId.value,
+	retry: false,
+	staleTime: Infinity,
+	refetchOnMount: 'always',
+	refetchOnWindowFocus: false,
+	refetchOnReconnect: false,
+})
+
 const members = useSharedInstanceMembers({
 	instance,
 	currentUserId,
@@ -258,6 +278,12 @@ const lockedActionButton = computed(() =>
 const sharedInstanceUnavailableReason = sharedInstanceState.unavailableReason
 const sharedInstanceUnavailable = computed(() => !!sharedInstanceUnavailableReason.value)
 const sharedInstanceUnavailableManager = sharedInstanceState.unavailableManager
+const unableToConnect = computed(
+	() =>
+		sharedInstancesApiUnavailable.value ||
+		isSharedInstancesApiError(eligibilityQuery.error.value) ||
+		isSharedInstancesApiError(members.query.error.value),
+)
 const membersTableLoading = computed(
 	() =>
 		members.rows.value.length === 0 &&
@@ -289,6 +315,15 @@ const importedModpackBackupTip = computed(() =>
 
 const messages = defineMessages({
 	signInButton: { id: 'app.instance.share.sign-in.button', defaultMessage: 'Sign in' },
+	unableToConnectHeading: {
+		id: 'app.instance.share.unable-to-connect.heading',
+		defaultMessage: 'Unable to connect',
+	},
+	unableToConnectDescription: {
+		id: 'app.instance.share.unable-to-connect.description',
+		defaultMessage:
+			'The shared instances service is not accessible at the moment, please try again later',
+	},
 	noFriendsInvitedHeading: {
 		id: 'app.instance.share.empty.heading',
 		defaultMessage: 'No friends invited',
@@ -396,6 +431,23 @@ function signInToShare(event?: MouseEvent) {
 	void accountRequiredModal.value?.show(event)
 }
 
+watch(
+	[eligibilityQuery.error, members.query.error],
+	(errors) => {
+		for (const error of errors) {
+			if (isSharedInstancesApiError(error)) notifyOperationError(error)
+		}
+	},
+	{ immediate: true },
+)
+watch(
+	[eligibilityQuery.data, members.query.data],
+	([eligibility, memberRows]) => {
+		if (eligibility !== undefined && memberRows !== undefined) {
+			sharedInstancesApiUnavailable.value = false
+		}
+	},
+)
 watch(
 	() => props.instance.id,
 	() => {

apps/app-frontend/src/pages/instance/share/use-shared-instance-members.ts

@@ -58,6 +58,7 @@ export function useSharedInstanceMembers(options: {
 		queryFn: ({ queryKey }) => fetchRows(queryKey),
 		enabled: () =>
 			options.isSignedIn.value && !!options.instance.value.id && !options.actionsLocked.value,
+		retry: false,
 		staleTime: Infinity,
 		refetchOnMount: 'always',
 		refetchOnReconnect: false,

apps/app/src/api/mod.rs

@@ -91,14 +91,25 @@ macro_rules! impl_serialize {
                             theseus::ErrorKind::SharedInstanceUnavailable(reason) => Some(reason),
                             _ => None,
                         };
+                        let code = match theseus_error.raw.as_ref() {
+                            theseus::ErrorKind::SharedInstanceUnavailable(_) => {
+                                Some("shared_instance_unavailable")
+                            }
+                            theseus::ErrorKind::SharedInstancesApiError(_) => {
+                                Some("shared_instances_api_error")
+                            }
+                            _ => None,
+                        };
                         let mut state = serializer.serialize_struct(
                             "Theseus",
-                            if unavailable_reason.is_some() { 4 } else { 2 },
+                            2 + usize::from(code.is_some()) + usize::from(unavailable_reason.is_some()),
                         )?;
                         state.serialize_field("field_name", "Theseus")?;
                         state.serialize_field("message", &theseus_error.to_string())?;
+                        if let Some(code) = code {
+                            state.serialize_field("code", code)?;
+                        }
                         if let Some(reason) = unavailable_reason {
-                            state.serialize_field("code", "shared_instance_unavailable")?;
                             state.serialize_field("reason", reason)?;
                         }
                         state.end()

packages/app-lib/src/api/instance/shared/client.rs

@@ -713,9 +713,17 @@ where
     let body = match response.text().await {
         Ok(body) => body,
         Err(error) if strip_response_url => {
-            return Err(error.without_url().into());
+            return Err(crate::ErrorKind::SharedInstancesApiError(
+                error.without_url().to_string(),
+            )
+            .into());
+        }
+        Err(error) => {
+            return Err(crate::ErrorKind::SharedInstancesApiError(
+                error.to_string(),
+            )
+            .into());
         }
-        Err(error) => return Err(error.into()),
     };
     serde_json::from_str::<T>(&body).map_err(|error| {
 		tracing::warn!(
@@ -729,7 +737,7 @@ where
             error_column = error.column(),
             "Shared instances API returned an invalid JSON response"
 		);
-		crate::ErrorKind::OtherError(format!(
+		crate::ErrorKind::SharedInstancesApiError(format!(
 			"Shared instances API request {operation} {method} {log_path} returned invalid JSON with status {status}"
 		))
 		.into()
@@ -870,7 +878,12 @@ pub(super) async fn send_bytes_request_to_url(
         .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
         .body(body)
         .send()
-        .await?;
+        .await
+        .map_err(|error| {
+            crate::ErrorKind::SharedInstancesApiError(
+                error.without_url().to_string(),
+            )
+        })?;
 
     if response.status().is_success() {
         let request_id = response_request_id(&response);
@@ -960,9 +973,17 @@ async fn send_request_with_auth_and_log_path(
     let response = match request.send().await {
         Ok(response) => response,
         Err(error) if path != log_path => {
-            return Err(error.without_url().into());
+            return Err(crate::ErrorKind::SharedInstancesApiError(
+                error.without_url().to_string(),
+            )
+            .into());
+        }
+        Err(error) => {
+            return Err(crate::ErrorKind::SharedInstancesApiError(
+                error.to_string(),
+            )
+            .into());
         }
-        Err(error) => return Err(error.into()),
     };
     if response.status().is_success() {
         let request_id = response_request_id(&response);
@@ -995,10 +1016,14 @@ pub(super) async fn shared_instances_request_error<T>(
         request_id = request_id.as_deref().unwrap_or("none"),
         "Shared instances API request failed"
     );
-    Err(crate::ErrorKind::OtherError(format!(
+    let message = format!(
         "Shared instances API request {operation} {method} {path} failed with status {status}"
-    ))
+    );
-    .into())
+    if status.is_server_error() {
+        return Err(crate::ErrorKind::SharedInstancesApiError(message).into());
+    }
+
+    Err(crate::ErrorKind::OtherError(message).into())
 }
 
 pub(super) fn response_request_id(

packages/app-lib/src/api/instance/shared/install.rs

@@ -244,13 +244,7 @@ pub(crate) async fn check_shared_instance_availability_before_launch(
     let availability =
         match get_remote_instance_access(&attachment.id, state).await {
             Ok(availability) => availability,
-            Err(error)
+            Err(error) => {
-                if matches!(
-                    error.raw.as_ref(),
-                    crate::ErrorKind::NoCredentialsError
-                        | crate::ErrorKind::FetchError(_)
-                ) =>
-            {
                 tracing::warn!(
                     instance_id,
                     shared_instance_id = %attachment.id,
@@ -259,7 +253,6 @@ pub(crate) async fn check_shared_instance_availability_before_launch(
                 );
                 return Ok(());
             }
-            Err(error) => return Err(error),
         };
 
     if let SharedInstanceRemoteResponse::Unavailable(reason) = availability {

packages/app-lib/src/error.rs

@@ -124,6 +124,9 @@ pub enum ErrorKind {
     #[error("Shared instance unavailable: {0}")]
     SharedInstanceUnavailable(SharedInstanceUnavailableReason),
 
+    #[error("Shared instances API request failed: {0}")]
+    SharedInstancesApiError(String),
+
     #[error("Join handle error: {0}")]
     JoinError(#[from] tokio::task::JoinError),
 

packages/app-lib/src/install/runner.rs

@@ -1293,6 +1293,7 @@ fn install_error_code(
         ErrorKind::SharedInstanceUnavailable(_) => {
             "shared_instance_unavailable"
         }
+        ErrorKind::SharedInstancesApiError(_) => "shared_instances_api_error",
         ErrorKind::InputError(_) => match phase {
             PreparingInstance | Finalizing => "instance_error",
             ResolvingPack | DownloadingPackFile | ReadingPackManifest => {