@oxyhq/services 22.13.0 → 23.0.0

package/src/ui/boot/runProviderColdBoot.ts

@@ -8,15 +8,9 @@ import {
 } from '@oxyhq/core';
 import type { SessionClient } from '@oxyhq/core';
 import { loadPersistedDeviceCredential } from '../utils/deviceCredential';
-import {
-  consumeSilentOAuthError,
-  isSilentRestoreEligibleOrigin,
-  maybeStartSilentOAuthRestore,
-} from '../utils/crossOriginRestore';
-import { tryCompleteOAuthReturn, consumeHubSyncFailure } from '../utils/oauthReturn';
+import { tryCompleteOAuthReturn } from '../utils/oauthReturn';
 import { isWebBrowser } from '../utils/isWebBrowser';
-import { allowsAutomaticIdpRedirect } from '../oauth/legacyRedirectLanes';
-import type { WebAuthMode } from '../oauth/types';
+import { isNetConnectivityExplicitlyOffline } from '../utils/netConnectivity';
 import type { CommitInput } from '../context/oxyContextTypes';
 
 /** How long the cold boot waits for the post-boot SessionClient handoff (ms). */
@@ -67,8 +61,8 @@ async function detectOfflineHint(): Promise<boolean> {
       }),
     ]);
     // `null` ⇒ the probe timed out (unknown → assume online). Only an explicit
-    // `isConnected === false` disables the network steps.
-    return state?.isConnected === false;
+    // disconnected / unreachable verdict disables the network steps.
+    return isNetConnectivityExplicitlyOffline(state);
   } catch {
     // NetInfo missing / probe threw — never block sign-in on a probe failure.
     return false;
@@ -80,39 +74,19 @@ export interface RunProviderColdBootOptions {
   authStore: AuthStateStore;
   clientId?: string;
   authRedirectUri?: string;
-  /**
-   * Authorize endpoint override for silent cross-origin restore. Defaults to
-   * the production Oxy IdP when unset; a local/staging deployment sets it so the
-   * silent-restore redirect targets its own IdP, never production.
-   */
-  authorizeBaseUrl?: string;
   /**
    * Who owns the session this boot resolves. `'account'` (the default) is the
    * device's active account — every ordinary Oxy app. `'identity'` binds the
    * boot to the owner of this device's PRIMARY identity key and REQUIRES
-   * {@link identity}; it also disables the two web OAuth lanes below, which
-   * commit whatever account the IdP hands back.
+   * {@link identity}; it also disables the web OAuth return leg below, which
+   * commits whatever account the IdP hands back.
    */
   sessionMode?: SessionMode;
   /** The identity binding required by `sessionMode: 'identity'`. */
   identity?: IdentityBinding;
-  /**
-   * How this provider's WEB sign-in reaches the IdP
-   * (`OxyProviderProps.webAuthMode`).
-   *
-   * A first-class INPUT to the boot, not a UI-only concern: `'popup'` forbids
-   * the automatic full-page `prompt=none` restore in step 3, so a domain with no
-   * local credential resolves SIGNED OUT instead of bouncing the top-level
-   * window to `auth.oxy.so`. See `allowsAutomaticIdpRedirect`.
-   * @default 'redirect'
-   */
-  webAuthMode?: WebAuthMode;
   sessionClient: SessionClient;
   syncDeviceCredentialToHost: () => Promise<void>;
-  commitSession: (
-    input: CommitInput,
-    options: { activate: boolean; hubSync?: boolean },
-  ) => Promise<void>;
+  commitSession: (input: CommitInput, options: { activate: boolean }) => Promise<void>;
   markAuthResolved: () => void;
   setTokenReady: (ready: boolean) => void;
 }
@@ -121,19 +95,19 @@ export interface RunProviderColdBootOptions {
  * Device-first cold boot for `@oxyhq/services` providers.
  *
  * Ordered pipeline:
- * 1. Complete OAuth authorization-code return (web)
+ * 1. Complete an OAuth authorization-code return already on the URL (web)
  * 2. `runSessionColdBoot` — device-secret mint (+ native shared-key, or the
  *    primary-identity-key lane in `sessionMode: 'identity'`)
- * 3. Silent OAuth for all web apps when mint finds no session
  *
- * Steps 1 and 3 are ACCOUNT-MODE ONLY: both commit whichever account the IdP
- * resolves, which for an identity-bound client is somebody else's account by
- * construction. In `'identity'` mode the boot is exactly step 2.
+ * Step 1 is ACCOUNT-MODE ONLY: it commits whichever account the IdP resolves,
+ * which for an identity-bound client is somebody else's account by construction.
+ * In `'identity'` mode the boot is exactly step 2.
  *
- * Step 3 is additionally REDIRECT-MODE ONLY: it navigates the top-level window
- * with no user gesture behind it, which `webAuthMode: 'popup'` exists to
- * eliminate. In popup mode the boot is steps 1 and 2, and a domain with no local
- * credential simply resolves signed out. See `allowsAutomaticIdpRedirect`.
+ * The boot NEVER navigates the top-level window. There is no automatic
+ * `prompt=none` bounce to the IdP: a web origin with no local device credential
+ * resolves SIGNED OUT and waits for the user's next explicit "Continue with
+ * Oxy", which opens a popup from a real gesture (#691 phase 7b). Step 1 is not a
+ * navigation — it only consumes a code that is already in the address bar.
  */
 export async function runProviderColdBoot(opts: RunProviderColdBootOptions): Promise<void> {
   const {
@@ -141,10 +115,8 @@ export async function runProviderColdBoot(opts: RunProviderColdBootOptions): Pro
     authStore,
     clientId,
     authRedirectUri,
-    authorizeBaseUrl,
     sessionMode = 'account',
     identity,
-    webAuthMode = 'redirect',
     sessionClient,
     syncDeviceCredentialToHost,
     commitSession,
@@ -157,28 +129,19 @@ export async function runProviderColdBoot(opts: RunProviderColdBootOptions): Pro
   setTokenReady(false);
 
   try {
-    // MODE-INDEPENDENT URL cleanup, deliberately so: both consume query params a
-    // PREVIOUS redirect-mode session left in the address bar (`?error=login_required`
-    // from a silent authorize, `?hub_sync=failed` from the hub) and restore the
-    // page the visit started on. Flipping an app to popup mode must not strand
-    // those params, so neither is gated on `webAuthMode`. Neither starts a
-    // navigation — they only rewrite the URL via `history.replaceState`.
-    consumeSilentOAuthError();
-    consumeHubSyncFailure();
-
-    // The redirect transport's RETURN leg — also NOT gated on `webAuthMode`. A
-    // popup-mode app legitimately lands here with `?code=` whenever the browser
-    // blocked the popup and `startWebOAuthSignIn` fell back to a full-page
-    // redirect (`popup-blocked` / `popup-navigation-failed`), and an app that
-    // switched modes mid-flight must not be stranded with a dead `?code=`
-    // either. It consumes a code already on the URL; it never starts one.
+    // The redirect transport's RETURN leg. An app reaches it whenever the browser
+    // BLOCKED the sign-in popup and `startWebOAuthSignIn` fell back to a
+    // full-page redirect (`popup-blocked` / `popup-navigation-failed`), so it is
+    // load-bearing even though nothing here ever starts a redirect. It consumes a
+    // code (or a stale OAuth `error`) already in the address bar and rewrites the
+    // URL via `history.replaceState`; it never begins a navigation.
     const oauthCompleted = identityBound
       ? false
       : await tryCompleteOAuthReturn({
           oxyServices,
           clientId,
           authRedirectUri,
-          commitSession: (input) => commitSession(input, { activate: true, hubSync: false }),
+          commitSession: (input) => commitSession(input, { activate: true }),
         });
     if (oauthCompleted) {
       setTokenReady(true);
@@ -192,7 +155,7 @@ export async function runProviderColdBoot(opts: RunProviderColdBootOptions): Pro
     // resolves to "online" — the network steps still run.
     const offline = await detectOfflineHint();
 
-    const outcome = await runSessionColdBoot({
+    await runSessionColdBoot({
       oxy: oxyServices,
       store: authStore,
       platform: { isWeb: isWebBrowser(), isNative: !isWebBrowser() },
@@ -259,46 +222,6 @@ export async function runProviderColdBoot(opts: RunProviderColdBootOptions): Pro
         }
       },
     });
-
-    // Silent cross-origin OAuth restore (web cross-app SSO): a full-page
-    // `prompt=none` bounce to the IdP when the mint found no local session.
-    //
-    // TRANSPORT gate (`allowsAutomaticIdpRedirect`): `webAuthMode: 'popup'`
-    // FORBIDS this lane. It navigates the top-level window with no user gesture
-    // behind it, which is precisely what popup mode exists to eliminate — a
-    // popup-mode domain without a local credential resolves signed out right
-    // here and waits for the user's next explicit "Continue with Oxy" (issue
-    // #691, "Cold boot and cross-domain behavior"). `'redirect'` — still the
-    // default and the compatibility path — reaches this lane unchanged, and this
-    // whole block disappears with the transport in phase 7b.
-    //
-    // ORIGIN gate: same as the hub-sync WRITE side (`syncHubAfterSignIn`) —
-    // official web origins only, never the IdP hub itself, and — unlike the
-    // write side — never a loopback / local-dev origin (which must not be
-    // bounced to a hosted IdP on cold boot). The authorize endpoint is
-    // env-configurable so a local/staging app targets its own IdP instead of
-    // production.
-    const webOrigin = isWebBrowser()
-      ? (globalThis as { location?: Location }).location?.origin
-      : undefined;
-    if (
-      !identityBound &&
-      allowsAutomaticIdpRedirect(webAuthMode) &&
-      clientId &&
-      outcome.kind !== 'session' &&
-      webOrigin &&
-      isSilentRestoreEligibleOrigin(webOrigin)
-    ) {
-      const redirected = await maybeStartSilentOAuthRestore({
-        oxyServices,
-        clientId,
-        redirectUri: authRedirectUri,
-        authorizeBaseUrl,
-      });
-      if (redirected) {
-        return;
-      }
-    }
   } catch (error) {
     if (__DEV__) {
       loggerUtil.error(

package/src/ui/components/AvatarCameraBadge.tsx

@@ -1,6 +1,6 @@
 import type React from 'react';
 import { View, type ViewStyle } from 'react-native';
-import { Ionicons } from '@expo/vector-icons';
+import Ionicons from '@expo/vector-icons/Ionicons';
 import { useTheme } from '@oxyhq/bloom/theme';
 
 /**

package/src/ui/components/OxyAuthChooser.tsx

@@ -20,9 +20,11 @@
  *    auto-starts the instant the view is reached, because the request surface
  *    (a QR on an unknown desktop, "Check Commons on your phone" where Oxy could
  *    deliver) IS the primary route there, never something behind a second tap.
- *  - `qr` → `SignInRequestView` — the ACTIVE REQUEST: the route Oxy chose plus
- *    honest progress derived only from `snapshot.signIn`. Alternatives stay
- *    behind "Having trouble?" until the chosen route reports `routeFailed`.
+ *  - `qr` → `SignInRequestView` — the ACTIVE REQUEST: the controller-bound
+ *    wiring over the shared, presentational `OxySignInRequestSurface` (the same
+ *    component the auth.oxy.so IdP mounts from its OAuth-bound request). It maps
+ *    `snapshot.signIn` onto that surface's props; alternatives stay behind
+ *    "Having trouble?" until the chosen route reports `routeFailed`.
  *  - `signup` → `SignUpView` — account creation, Commons-first.
  *
  * Per-account color re-theming uses Bloom's `APP_COLOR_PRESETS` + `BloomColorScope`
@@ -376,7 +378,6 @@ const OxyAuthChooser: React.FC<OxyAuthChooserProps> = ({
     return (
       <SignInRequestView
         snapshot={snapshot}
-        theme={theme}
         t={t}
         onRetry={() => void controller.showQr()}
         alternatives={alternatives}

package/src/ui/components/OxyProvider.tsx

@@ -12,6 +12,7 @@ import { logger as loggerUtil } from '@oxyhq/core';
 import { RequireOxyAuth } from './RequireOxyAuth';
 import { attachQueryPersistence, createQueryClient } from '../hooks/queryClient';
 import { createPlatformStorage, type StorageInterface } from '../utils/storageHelpers';
+import { isNetConnectivityOnline } from '../utils/netConnectivity';
 
 /**
  * Background color shown for the brief window between mount and the
@@ -92,10 +93,9 @@ const OxyProvider: FC<OxyProviderProps> = ({
     authRedirectUri,
     authorizeBaseUrl,
     sessionMode = 'account',
-    webAuthMode = 'redirect',
+    webAuthMode = 'popup',
     queryClient: providedQueryClient,
     requireAuth = 'off',
-    hubSync = true,
 }) => {
 
     // Dynamic KeyboardProvider for native. Uses variable indirection
@@ -230,10 +230,10 @@ const OxyProvider: FC<OxyProviderProps> = ({
                     try {
                         const NetInfo = await import('@react-native-community/netinfo');
                         const state = await NetInfo.default.fetch();
-                        onlineManager.setOnline(state.isConnected ?? true);
+                        onlineManager.setOnline(isNetConnectivityOnline(state));
 
-                        const unsubscribe = NetInfo.default.addEventListener((state: { isConnected: boolean | null }) => {
-                            onlineManager.setOnline(state.isConnected ?? true);
+                        const unsubscribe = NetInfo.default.addEventListener((state: { isConnected: boolean | null; isInternetReachable?: boolean | null }) => {
+                            onlineManager.setOnline(isNetConnectivityOnline(state));
                         });
 
                         cleanup = () => unsubscribe();
@@ -293,7 +293,6 @@ const OxyProvider: FC<OxyProviderProps> = ({
                     clientId={clientId}
                     sessionMode={sessionMode}
                     webAuthMode={webAuthMode}
-                    hubSync={hubSync}
                     onAuthStateChange={onAuthStateChange as OxyContextProviderProps['onAuthStateChange']}
                 >
                     <SurfaceProvider>

package/src/ui/components/OxySignInRequestSurface.tsx

@@ -0,0 +1,202 @@
+/**
+ * `OxySignInRequestSurface` — the in-flight "Sign in with Oxy" request, rendered
+ * from plain facts (issue #691, Phase 5).
+ *
+ * The user already performed their one action. From here the surface only
+ * REPORTS: the route-appropriate primary visual, the status line for the
+ * progress it was told about, and nothing else at the same weight. Alternatives
+ * stay behind "Having trouble?" until the chosen route could not be carried out,
+ * at which point they ARE the content and render plainly.
+ *
+ * PRESENTATIONAL AND HEADLESS-FRIENDLY. It owns no request, no controller, no
+ * polling, and no state of its own: everything it draws is a prop. That is what
+ * lets the two hosts of this surface share ONE implementation —
+ *
+ *  - `OxyAuthChooser`'s `SignInRequestView`, driven by `AccountDialogController`'s
+ *    device flow;
+ *  - the auth.oxy.so IdP's OAuth-bound lane, whose request carries an OAuth
+ *    binding the account dialog's session has no concept of.
+ *
+ * It resolves only what every `@oxyhq/services` consumer already has in context:
+ * the Bloom theme (`useTheme`) and the SDK's own locale dictionary (`useI18n`,
+ * the `accountSwitcher.*` copy in all 11 locales). Host-specific copy — the
+ * labels on {@link OxySignInRequestSurfaceProps.subordinate} and
+ * {@link OxySignInRequestSurfaceProps.alternatives} — arrives already localized.
+ *
+ * TWO THINGS IT DELIBERATELY DOES NOT DO:
+ *  - it renders no failure REASON. A host surfaces that the way its own shell
+ *    demands (the account dialog toasts it — errors never render inline there;
+ *    a full page may show a banner around this surface). The surface only takes
+ *    the fact that the request failed, and offers the way forward.
+ *  - it derives nothing from {@link OxySignInRequestSurfaceProps.qrPayload}.
+ *    Application identity, origin, and scopes are resolved server-side by the
+ *    approver (Commons), never read out of a payload here — the plate encodes it
+ *    and shows nothing about it.
+ *
+ * SECRETS: every prop is safe to render. There is no `sessionToken` (the secret
+ * claim/finalize credential), no bearer, and no authorization code — a host
+ * keeps those in its own controller, and no prop on this component invites one.
+ */
+
+import type React from 'react';
+import { View } from 'react-native';
+import { Button } from '@oxyhq/bloom/button';
+import { useTheme } from '@oxyhq/bloom/theme';
+import { Text } from '@oxyhq/bloom/typography';
+import type { CommonsDeliveryRoute, SignInProgress } from '@oxyhq/core';
+import { useI18n } from '../hooks/useI18n';
+import TroubleDisclosure from './authChooser/TroubleDisclosure';
+import { SubtleLink } from './authChooser/primitives';
+import { GetCommonsPrompt, RequestPrimarySurface } from './authChooser/requestSurfaces';
+import { signInProgressLabel } from './authChooser/signInProgress';
+import { authChooserStyles as styles } from './authChooser/styles';
+import type { OxySignInSurfaceAction } from './authChooser/types';
+
+/** Shared empty list, so an omitted action bundle allocates nothing per render. */
+const NO_ACTIONS: readonly OxySignInSurfaceAction[] = [];
+
+export interface OxySignInRequestSurfaceProps {
+  /**
+   * The ONE primary delivery route chosen for this request, or `null` while it
+   * is still being resolved. There is no chain: the surface renders exactly one
+   * route's visual, and never guesses one that has not been chosen yet.
+   */
+  route: CommonsDeliveryRoute | null;
+  /**
+   * The request's DERIVED progress — the only thing the status line is built
+   * from. It must come from a real observed signal (a server-reported delivery,
+   * an approver opening the request, an approval); the surface owns no clock and
+   * will never advance it on its own. `'idle'` means there is nothing honest to
+   * report, and renders no status line.
+   */
+  progress: SignInProgress;
+  /**
+   * The PUBLIC `oxycommons://approve?…` payload to encode as the QR, or `null`.
+   * It carries the single-use approval handle — never a secret credential — and
+   * the surface renders NOTHING derived from it.
+   */
+  qrPayload?: string | null;
+  /**
+   * `true` when the chosen primary route could not be carried out on this device.
+   * The one signal that reveals {@link alternatives} without the user asking;
+   * a host never silently cascades to another route on its own.
+   */
+  routeFailed?: boolean;
+  /**
+   * `true` when the request itself is terminally failed — there is no working
+   * primary route left to report on, so {@link onRetry} becomes the surface's one
+   * primary action and the alternatives render plainly.
+   */
+  failed?: boolean;
+  /**
+   * Start a BRAND-NEW request. Rendered as the primary action while
+   * {@link failed}; omit it when a fresh attempt cannot help (a request that
+   * would fail identically every time), leaving the alternatives as the only
+   * way forward.
+   */
+  onRetry?: () => void;
+  /**
+   * The acquisition action for a device where Commons is known to be ABSENT.
+   *
+   * Pass it ONLY on a positive "not installed" verdict. There, acquiring Commons
+   * is the GENUINE primary route — a same-device QR the user would have to scan
+   * with the very screen showing it is a dead end — so the surface leads with it
+   * and reports no route progress. Omit it wherever absence cannot be known (a
+   * browser cannot ask whether a URL scheme is registered).
+   */
+  onAcquireCommons?: () => void;
+  /**
+   * Subordinate links rendered directly beneath the primary, always visible:
+   * the ways OUT of the surface that are not troubleshooting (creating an
+   * account, cancelling the request).
+   */
+  subordinate?: readonly OxySignInSurfaceAction[];
+  /**
+   * The alternative ways to authenticate, kept behind "Having trouble?" until
+   * the user asks — or shown plainly once {@link failed} / {@link routeFailed}
+   * says the chosen route cannot deliver.
+   */
+  alternatives?: readonly OxySignInSurfaceAction[];
+}
+
+export const OxySignInRequestSurface: React.FC<OxySignInRequestSurfaceProps> = ({
+  route,
+  progress,
+  qrPayload = null,
+  routeFailed = false,
+  failed = false,
+  onRetry,
+  onAcquireCommons,
+  subordinate = NO_ACTIONS,
+  alternatives = NO_ACTIONS,
+}) => {
+  const theme = useTheme();
+  const { t } = useI18n();
+
+  const subordinateLinks = subordinate.map((action) => (
+    <SubtleLink
+      key={action.key}
+      label={action.label}
+      theme={theme}
+      onPress={action.onPress}
+      disabled={action.disabled}
+      testID={action.key}
+    />
+  ));
+
+  // A failed request has no working primary route left. Its REASON is the host's
+  // to surface (toast / banner); all this owes the user is the way forward.
+  if (failed) {
+    return (
+      <View style={styles.centeredBlock}>
+        {onRetry ? (
+          <Button variant="primary" onPress={onRetry} style={styles.primaryButton}>
+            {t('common.actions.tryAgain')}
+          </Button>
+        ) : null}
+        {subordinateLinks}
+        <TroubleDisclosure actions={alternatives} revealed theme={theme} t={t} />
+      </View>
+    );
+  }
+
+  // Commons is absent: acquiring it IS the primary route, not a fallback, so it
+  // renders as the one primary action and no route progress is reported (there is
+  // no route to report on until the host says otherwise).
+  if (onAcquireCommons) {
+    return (
+      <View style={styles.centeredBlock}>
+        <GetCommonsPrompt theme={theme} t={t} onGetCommons={onAcquireCommons} />
+        {subordinateLinks}
+        <TroubleDisclosure actions={alternatives} revealed={false} theme={theme} t={t} />
+      </View>
+    );
+  }
+
+  const status = signInProgressLabel(progress, route, t);
+
+  return (
+    <View style={styles.centeredBlock}>
+      <RequestPrimarySurface
+        route={route}
+        progress={progress}
+        qrPayload={qrPayload}
+        theme={theme}
+        t={t}
+      />
+      {status ? (
+        <Text
+          style={[styles.mutedText, { color: theme.colors.textSecondary }]}
+          accessibilityLiveRegion="polite"
+          testID="signin-progress"
+        >
+          {status}
+        </Text>
+      ) : null}
+      {subordinateLinks}
+      <TroubleDisclosure actions={alternatives} revealed={routeFailed} theme={theme} t={t} />
+    </View>
+  );
+};
+
+export default OxySignInRequestSurface;

package/src/ui/components/ProfileButton.tsx

@@ -8,7 +8,7 @@ import {
     type StyleProp,
     type ViewStyle,
 } from 'react-native';
-import { MaterialCommunityIcons } from '@expo/vector-icons';
+import MaterialCommunityIcons from '@expo/vector-icons/MaterialCommunityIcons';
 import { Avatar } from '@oxyhq/bloom/avatar';
 import * as Skeleton from '@oxyhq/bloom/skeleton';
 import { Text } from '@oxyhq/bloom/typography';

package/src/ui/components/SettingsIcon.tsx

@@ -1,7 +1,7 @@
 import type React from 'react';
 import { memo } from 'react';
 import { View, StyleSheet } from 'react-native';
-import { MaterialCommunityIcons } from '@expo/vector-icons';
+import MaterialCommunityIcons from '@expo/vector-icons/MaterialCommunityIcons';
 import { darkenColor } from '../utils/colorUtils';
 
 interface SettingsIconProps {

package/src/ui/components/authChooser/AccountsMenuView.tsx

@@ -33,7 +33,7 @@ import Animated, {
   useSharedValue,
   withTiming,
 } from 'react-native-reanimated';
-import { MaterialCommunityIcons } from '@expo/vector-icons';
+import MaterialCommunityIcons from '@expo/vector-icons/MaterialCommunityIcons';
 import { Avatar } from '@oxyhq/bloom/avatar';
 import { AvatarGroup, type AvatarGroupItem } from '@oxyhq/bloom/avatar-group';
 import { Button } from '@oxyhq/bloom/button';

package/src/ui/components/authChooser/SignInEntryView.tsx

@@ -20,10 +20,16 @@ import type React from 'react';
 import { View } from 'react-native';
 import { Button } from '@oxyhq/bloom/button';
 import type { AccountDialogSnapshot } from '@oxyhq/core';
-import TroubleDisclosure, { type TroubleAction } from './TroubleDisclosure';
+import TroubleDisclosure from './TroubleDisclosure';
 import { AccountRow, Dividerish, SubtleLink } from './primitives';
 import { authChooserStyles as styles } from './styles';
-import type { OxyAuthChooserHandlers, SignInAlternatives, Theme, Translate } from './types';
+import type {
+  OxyAuthChooserHandlers,
+  OxySignInSurfaceAction,
+  SignInAlternatives,
+  Theme,
+  Translate,
+} from './types';
 
 interface SignInEntryViewProps {
   snapshot: AccountDialogSnapshot;
@@ -45,7 +51,7 @@ const SignInEntryView: React.FC<SignInEntryViewProps> = ({
 }) => {
   // The entry has no chosen route yet, so nothing here can have failed: the
   // alternatives stay behind the disclosure unconditionally.
-  const troubleActions: TroubleAction[] = [
+  const troubleActions: OxySignInSurfaceAction[] = [
     {
       key: 'scan-qr-link',
       label: t('accountSwitcher.scanQr'),