feat: add pds auto resolving

src/components/forms/HostingProvider.tsx

···
   onOpenDialog,
   minimal,
 }: {
-  serviceUrl: string
+  serviceUrl?: string | undefined
   onSelectServiceUrl: (provider: string) => void
   onOpenDialog?: () => void
   minimal?: boolean
···
   const serverInputControl = useDialogControl()
   const t = useTheme()
   const {_} = useLingui()
+  const serviceProviderLabel =
+    serviceUrl === undefined ? _(msg`Automatic`) : toNiceDomain(serviceUrl)
 
   const onPressSelectService = React.useCallback(() => {
     Keyboard.dismiss()
···
             <Trans>You are creating an account on</Trans>
           </Text>
           <Button
-            label={toNiceDomain(serviceUrl)}
+            label={serviceProviderLabel}
             accessibilityHint={_(msg`Changes hosting provider`)}
             onPress={onPressSelectService}
             variant="ghost"
···
               {marginHorizontal: tokens.space.xs * -1},
               {paddingVertical: 0},
             ]}>
-            <ButtonText style={[a.text_sm]}>
-              {toNiceDomain(serviceUrl)}
-            </ButtonText>
+            <ButtonText style={[a.text_sm]}>{serviceProviderLabel}</ButtonText>
             <ButtonIcon icon={PencilIcon} />
           </Button>
         </View>
       ) : (
         <Button
           testID="selectServiceButton"
-          label={toNiceDomain(serviceUrl)}
+          label={serviceProviderLabel}
           accessibilityHint={_(msg`Changes hosting provider`)}
           variant="solid"
           color="secondary"
···
                     }
                   />
                 </View>
-                <Text style={[a.text_md]}>{toNiceDomain(serviceUrl)}</Text>
+                <Text style={[a.text_md]}>{serviceProviderLabel}</Text>
                 <View
                   style={[
                     a.rounded_sm,

src/screens/Login/LoginForm.tsx

···
   onPressForgotPassword,
   onAttemptSuccess,
   onAttemptFailed,
+  debouncedResolveService,
+  isResolvingService,
 }: {
   error: string
-  serviceUrl: string
+  serviceUrl?: string | undefined
   serviceDescription: ServiceDescription | undefined
   initialHandle: string
   setError: (v: string) => void
···
   onPressForgotPassword: () => void
   onAttemptSuccess: () => void
   onAttemptFailed: () => void
+  debouncedResolveService: (identifier: string) => void
+  isResolvingService: boolean
 }) => {
   const t = useTheme()
   const [isProcessing, setIsProcessing] = useState<boolean>(false)
···
 
     if (!password) {
       setError(_(msg`Please enter your password`))
+      return
+    }
+
+    if (!serviceUrl) {
+      setError(_(msg`Please enter hosting provider URL`))
       return
     }
 
···
       <View>
         <TextField.LabelText>
           <Trans>Hosting provider</Trans>
+          {isResolvingService && (
+            <ActivityIndicator
+              size={12}
+              color={t.palette.contrast_500}
+              style={a.ml_sm}
+            />
+          )}
         </TextField.LabelText>
         <HostingProvider
           serviceUrl={serviceUrl}
···
               defaultValue={initialHandle || ''}
               onChangeText={v => {
                 identifierValueRef.current = v
+                // Trigger PDS auto-resolution for handles/DIDs
+                const id = v.trim()
+                if (!id) return
+                if (
+                  id.startsWith('did:') ||
+                  (id.includes('.') && !id.includes('@'))
+                ) {
+                  debouncedResolveService(id)
+                }
               }}
               onSubmitEditing={() => {
                 passwordRef.current?.focus()
···
               <Trans>Retry</Trans>
             </ButtonText>
           </Button>
-        ) : !serviceDescription ? (
+        ) : !serviceDescription && serviceUrl !== undefined ? (
           <>
-            <ActivityIndicator />
+            <ActivityIndicator color={t.palette.contrast_500} />
             <Text style={[t.atoms.text_contrast_high, a.pl_md]}>
               <Trans>Connecting...</Trans>
             </Text>

src/screens/Login/index.tsx

···
-import React, {useRef} from 'react'
+import React, {useCallback, useMemo, useRef} from 'react'
 import {KeyboardAvoidingView} from 'react-native'
 import {LayoutAnimationConfig} from 'react-native-reanimated'
 import {msg} from '@lingui/macro'
 import {useLingui} from '@lingui/react'
+import debounce from 'lodash.debounce'
 
 import {DEFAULT_SERVICE} from '#/lib/constants'
 import {logEvent} from '#/lib/statsig/statsig'
 import {logger} from '#/logger'
+import {resolvePdsServiceUrl} from '#/state/queries/resolve-identity'
 import {useServiceQuery} from '#/state/queries/service'
-import {type SessionAccount, useSession} from '#/state/session'
+import {type SessionAccount, useAgent, useSession} from '#/state/session'
 import {useLoggedOutView} from '#/state/shell/logged-out'
 import {LoggedOutLayout} from '#/view/com/util/layouts/LoggedOutLayout'
 import {ForgotPasswordForm} from '#/screens/Login/ForgotPasswordForm'
···
   const failedAttemptCountRef = useRef(0)
   const startTimeRef = useRef(Date.now())
 
+  const agent = useAgent()
   const {accounts} = useSession()
   const {requestedAccountSwitchTo} = useLoggedOutView()
   const requestedAccount = accounts.find(
     acc => acc.did === requestedAccountSwitchTo,
   )
 
+  const [isResolvingService, setIsResolvingService] = React.useState(false)
   const [error, setError] = React.useState<string>('')
-  const [serviceUrl, setServiceUrl] = React.useState<string>(
-    requestedAccount?.service || DEFAULT_SERVICE,
+  const [serviceUrl, setServiceUrl] = React.useState<string | undefined>(
+    requestedAccount?.service,
   )
   const [initialHandle, setInitialHandle] = React.useState<string>(
     requestedAccount?.handle || '',
···
     data: serviceDescription,
     error: serviceError,
     refetch: refetchService,
-  } = useServiceQuery(serviceUrl)
+  } = useServiceQuery(serviceUrl ?? '')
 
   const onSelectAccount = (account?: SessionAccount) => {
     if (account?.service) {
···
     }
   }, [serviceError, serviceUrl, _])
 
+  const resolveIdentity = useCallback(
+    async (identifier: string) => {
+      setIsResolvingService(true)
+
+      try {
+        const getDid = async () => {
+          if (identifier.startsWith('did:')) return identifier
+          else
+            return (
+              await agent.resolveHandle({
+                handle: identifier,
+              })
+            ).data.did
+        }
+
+        const did = (await getDid()) as `did:${string}`
+        const pdsUrl = await resolvePdsServiceUrl(did)
+
+        if (pdsUrl.endsWith('.bsky.network')) {
+          setServiceUrl('https://bsky.social')
+        } else {
+          setServiceUrl(pdsUrl)
+        }
+      } catch (err) {
+        logger.error(`Service auto-resolution failed: ${err}`)
+      } finally {
+        setIsResolvingService(false)
+      }
+    },
+    [agent],
+  )
+
+  const debouncedResolveService = useMemo(
+    () => debounce(resolveIdentity, 800),
+    [resolveIdentity],
+  )
+
   const onPressForgotPassword = () => {
     setCurrentForm(Forms.ForgotPassword)
     logEvent('signin:forgotPasswordPressed', {})
···
           }
           onPressForgotPassword={onPressForgotPassword}
           onPressRetryConnect={refetchService}
+          debouncedResolveService={debouncedResolveService}
+          isResolvingService={isResolvingService}
         />
       )
       break
···
       content = (
         <ForgotPasswordForm
           error={error}
-          serviceUrl={serviceUrl}
+          serviceUrl={serviceUrl ?? DEFAULT_SERVICE}
           serviceDescription={serviceDescription}
           setError={setError}
           setServiceUrl={setServiceUrl}
···
       content = (
         <SetNewPasswordForm
           error={error}
-          serviceUrl={serviceUrl}
+          serviceUrl={serviceUrl ?? DEFAULT_SERVICE}
           setError={setError}
           onPressBack={() => gotoForm(Forms.ForgotPassword)}
           onPasswordSet={() => gotoForm(Forms.PasswordUpdated)}

src/view/com/auth/server-input/index.tsx

···
 import {Button, ButtonText} from '#/components/Button'
 import * as Dialog from '#/components/Dialog'
 import * as TextField from '#/components/forms/TextField'
-import * as ToggleButton from '#/components/forms/ToggleButton'
 import {Globe_Stroke2_Corner0_Rounded as Globe} from '#/components/icons/Globe'
 import {InlineLinkText} from '#/components/Link'
 import {P, Text} from '#/components/Typography'
···
   const formRef = useRef<DialogInnerRef>(null)
 
   // persist these options between dialog open/close
-  const [fixedOption, setFixedOption] = useState(BSKY_SERVICE)
   const [previousCustomAddress, setPreviousCustomAddress] = useState('')
 
   const onClose = useCallback(() => {
···
       }
     }
     logEvent('signin:hostingProviderPressed', {
-      hostingProviderDidChange: fixedOption !== BSKY_SERVICE,
+      hostingProviderDidChange: false, // stubbed for PDS auto-resolution
     })
-  }, [onSelect, fixedOption])
+  }, [onSelect])
 
   return (
     <Dialog.Outer
···
       <Dialog.Handle />
       <DialogInner
         formRef={formRef}
-        fixedOption={fixedOption}
-        setFixedOption={setFixedOption}
         initialCustomAddress={previousCustomAddress}
       />
     </Dialog.Outer>
···
 
 function DialogInner({
   formRef,
-  fixedOption,
-  setFixedOption,
   initialCustomAddress,
 }: {
   formRef: React.Ref<DialogInnerRef>
-  fixedOption: string
-  setFixedOption: (opt: string) => void
   initialCustomAddress: string
 }) {
   const control = Dialog.useDialogContext()
···
     formRef,
     () => ({
       getFormState: () => {
-        let url
-        if (fixedOption === 'custom') {
-          url = customAddress.trim().toLowerCase()
-          if (!url) {
-            return null
-          }
-        } else {
-          url = fixedOption
+        let url = customAddress.trim().toLowerCase()
+        if (!url) {
+          return null
         }
         if (!url.startsWith('http://') && !url.startsWith('https://')) {
           if (url === 'localhost' || url.startsWith('localhost:')) {
···
           }
         }
 
-        if (fixedOption === 'custom') {
-          if (!pdsAddressHistory.includes(url)) {
-            const newHistory = [url, ...pdsAddressHistory.slice(0, 4)]
-            setPdsAddressHistory(newHistory)
-            persisted.write('pdsAddressHistory', newHistory)
-          }
+        if (!pdsAddressHistory.includes(url)) {
+          const newHistory = [url, ...pdsAddressHistory.slice(0, 4)]
+          setPdsAddressHistory(newHistory)
+          persisted.write('pdsAddressHistory', newHistory)
         }
 
         return url
       },
     }),
-    [customAddress, fixedOption, pdsAddressHistory],
+    [customAddress, pdsAddressHistory],
   )
 
   const isFirstTimeUser = accounts.length === 0
···
         <Text nativeID="dialog-title" style={[a.text_2xl, a.font_bold]}>
           <Trans>Choose your account provider</Trans>
         </Text>
-        <ToggleButton.Group
-          label="Preferences"
-          values={[fixedOption]}
-          onChange={values => setFixedOption(values[0])}>
-          <ToggleButton.Button name={BSKY_SERVICE} label={_(msg`Bluesky`)}>
-            <ToggleButton.ButtonText>{_(msg`Bluesky`)}</ToggleButton.ButtonText>
-          </ToggleButton.Button>
-          <ToggleButton.Button
-            testID="customSelectBtn"
-            name="custom"
-            label={_(msg`Custom`)}>
-            <ToggleButton.ButtonText>{_(msg`Custom`)}</ToggleButton.ButtonText>
-          </ToggleButton.Button>
-        </ToggleButton.Group>
 
-        {fixedOption === BSKY_SERVICE && isFirstTimeUser && (
+        {isFirstTimeUser && (
           <Admonition type="tip">
             <Trans>
               Bluesky is an open network where you can choose your own provider.
···
           </Admonition>
         )}
 
-        {fixedOption === 'custom' && (
-          <View
-            style={[
-              a.border,
-              t.atoms.border_contrast_low,
-              a.rounded_sm,
-              a.px_md,
-              a.py_md,
-            ]}>
-            <TextField.LabelText nativeID="address-input-label">
-              <Trans>Server address</Trans>
-            </TextField.LabelText>
-            <TextField.Root>
-              <TextField.Icon icon={Globe} />
-              <Dialog.Input
-                testID="customServerTextInput"
-                value={customAddress}
-                onChangeText={setCustomAddress}
-                label="my-server.com"
-                accessibilityLabelledBy="address-input-label"
-                autoCapitalize="none"
-                keyboardType="url"
-              />
-            </TextField.Root>
-            {pdsAddressHistory.length > 0 && (
-              <View style={[a.flex_row, a.flex_wrap, a.mt_xs]}>
-                {pdsAddressHistory.map(uri => (
-                  <Button
-                    key={uri}
-                    variant="ghost"
-                    color="primary"
-                    label={uri}
-                    style={[a.px_sm, a.py_xs, a.rounded_sm, a.gap_sm]}
-                    onPress={() => setCustomAddress(uri)}>
-                    <ButtonText>{uri}</ButtonText>
-                  </Button>
-                ))}
-              </View>
-            )}
-          </View>
-        )}
+        <View
+          style={[
+            a.border,
+            t.atoms.border_contrast_low,
+            a.rounded_sm,
+            a.px_md,
+            a.py_md,
+          ]}>
+          <TextField.LabelText nativeID="address-input-label">
+            <Trans>Server address</Trans>
+          </TextField.LabelText>
+          <TextField.Root>
+            <TextField.Icon icon={Globe} />
+            <Dialog.Input
+              testID="customServerTextInput"
+              value={customAddress}
+              onChangeText={setCustomAddress}
+              label="my-server.com"
+              accessibilityLabelledBy="address-input-label"
+              autoCapitalize="none"
+              keyboardType="url"
+            />
+          </TextField.Root>
+          {pdsAddressHistory.length > 0 && (
+            <View style={[a.flex_row, a.flex_wrap, a.mt_xs]}>
+              {pdsAddressHistory.map(uri => (
+                <Button
+                  key={uri}
+                  variant="ghost"
+                  color="primary"
+                  label={uri}
+                  style={[a.px_sm, a.py_xs, a.rounded_sm, a.gap_sm]}
+                  onPress={() => setCustomAddress(uri)}>
+                  <ButtonText>{uri}</ButtonText>
+                </Button>
+              ))}
+            </View>
+          )}
+        </View>
 
         <View style={[a.py_xs]}>
           <P