fix: add missing files for alt text gen & toggling handle in URLs

src/lib/ai/generateAltText.ts

···
+import {DEFAULT_ALT_TEXT_AI_MODEL, MAX_ALT_TEXT} from '#/lib/constants'
+import {logger} from '#/logger'
+
+export async function generateAltText(
+  apiKey: string,
+  model: string,
+  imageBase64: string,
+  imageMimeType: string,
+): Promise<string> {
+  const response = await fetch(
+    'https://openrouter.ai/api/v1/chat/completions',
+    {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'HTTP-Referer': 'https://witchsky.app',
+        'X-Title': 'Witchsky',
+      },
+      body: JSON.stringify({
+        model: model || DEFAULT_ALT_TEXT_AI_MODEL,
+        messages: [
+          {
+            role: 'user',
+            content: [
+              {
+                type: 'text',
+                text: `Generate a concise, descriptive alt text for this image, also extract text if needed. The alt text should be clear and helpful for screen readers. Keep it under ${MAX_ALT_TEXT} characters. Only respond with the alt text itself, no explanations or quotes.`,
+              },
+              {
+                type: 'image_url',
+                image_url: {
+                  url: `data:${imageMimeType};base64,${imageBase64}`,
+                },
+              },
+            ],
+          },
+        ],
+        max_tokens: MAX_ALT_TEXT,
+      }),
+    },
+  )
+
+  if (!response.ok) {
+    const errorText = await response.text()
+    logger.error('OpenRouter API error', {
+      status: response.status,
+      error: errorText,
+    })
+    throw new Error(`OpenRouter API error: ${response.status}`)
+  }
+
+  const data = await response.json()
+  const altText = data.choices?.[0]?.message?.content?.trim()
+
+  if (!altText) {
+    throw new Error('No alt text generated')
+  }
+
+  return altText
+}

src/state/preferences/openrouter.tsx

···
+import React from 'react'
+
+import * as persisted from '#/state/persisted'
+
+type ApiKeyStateContext = persisted.Schema['openRouterApiKey']
+type SetApiKeyContext = (v: persisted.Schema['openRouterApiKey']) => void
+type ModelStateContext = persisted.Schema['openRouterModel']
+type SetModelContext = (v: persisted.Schema['openRouterModel']) => void
+
+const apiKeyStateContext = React.createContext<ApiKeyStateContext>(
+  persisted.defaults.openRouterApiKey,
+)
+const setApiKeyContext = React.createContext<SetApiKeyContext>(
+  (_: persisted.Schema['openRouterApiKey']) => {},
+)
+const modelStateContext = React.createContext<ModelStateContext>(
+  persisted.defaults.openRouterModel,
+)
+const setModelContext = React.createContext<SetModelContext>(
+  (_: persisted.Schema['openRouterModel']) => {},
+)
+
+export function Provider({children}: React.PropsWithChildren<{}>) {
+  const [apiKeyState, setApiKeyState] = React.useState(
+    persisted.get('openRouterApiKey'),
+  )
+  const [modelState, setModelState] = React.useState(
+    persisted.get('openRouterModel'),
+  )
+
+  const setApiKeyWrapped = React.useCallback(
+    (openRouterApiKey: persisted.Schema['openRouterApiKey']) => {
+      setApiKeyState(openRouterApiKey)
+      persisted.write('openRouterApiKey', openRouterApiKey)
+    },
+    [setApiKeyState],
+  )
+
+  const setModelWrapped = React.useCallback(
+    (openRouterModel: persisted.Schema['openRouterModel']) => {
+      setModelState(openRouterModel)
+      persisted.write('openRouterModel', openRouterModel)
+    },
+    [setModelState],
+  )
+
+  React.useEffect(() => {
+    return persisted.onUpdate('openRouterApiKey', nextApiKey => {
+      setApiKeyState(nextApiKey)
+    })
+  }, [setApiKeyWrapped])
+
+  React.useEffect(() => {
+    return persisted.onUpdate('openRouterModel', nextModel => {
+      setModelState(nextModel)
+    })
+  }, [setModelWrapped])
+
+  return (
+    <apiKeyStateContext.Provider value={apiKeyState}>
+      <setApiKeyContext.Provider value={setApiKeyWrapped}>
+        <modelStateContext.Provider value={modelState}>
+          <setModelContext.Provider value={setModelWrapped}>
+            {children}
+          </setModelContext.Provider>
+        </modelStateContext.Provider>
+      </setApiKeyContext.Provider>
+    </apiKeyStateContext.Provider>
+  )
+}
+
+export function useOpenRouterApiKey() {
+  return React.useContext(apiKeyStateContext)
+}
+
+export function useSetOpenRouterApiKey() {
+  return React.useContext(setApiKeyContext)
+}
+
+export function useOpenRouterModel() {
+  return React.useContext(modelStateContext)
+}
+
+export function useSetOpenRouterModel() {
+  return React.useContext(setModelContext)
+}
+
+export function useOpenRouterConfigured() {
+  const apiKey = useOpenRouterApiKey()
+  return !!apiKey && apiKey.length > 0
+}

src/state/preferences/use-handle-in-links.tsx

···
+import React from 'react'
+import {reloadAppAsync} from 'expo'
+
+import * as persisted from '#/state/persisted'
+import {IS_WEB} from '#/env'
+
+type StateContext = persisted.Schema['useHandleInLinks']
+type SetContext = (v: persisted.Schema['useHandleInLinks']) => void
+
+const stateContext = React.createContext<StateContext>(
+  persisted.defaults.useHandleInLinks,
+)
+const setContext = React.createContext<SetContext>(
+  (_: persisted.Schema['useHandleInLinks']) => {},
+)
+
+export function Provider({children}: React.PropsWithChildren<{}>) {
+  const [state, setState] = React.useState(persisted.get('useHandleInLinks'))
+
+  const setStateWrapped = React.useCallback(
+    (useHandleInLinks: persisted.Schema['useHandleInLinks']) => {
+      setState(useHandleInLinks)
+      persisted.write('useHandleInLinks', useHandleInLinks)
+    },
+    [setState],
+  )
+
+  React.useEffect(() => {
+    return persisted.onUpdate('useHandleInLinks', nextUseHandleInLinks => {
+      setState(nextUseHandleInLinks)
+    })
+  }, [setStateWrapped])
+
+  return (
+    <stateContext.Provider value={state}>
+      <setContext.Provider value={setStateWrapped}>
+        {children}
+      </setContext.Provider>
+    </stateContext.Provider>
+  )
+}
+
+export function useHandleInLinks() {
+  return React.useContext(stateContext)
+}
+
+export function useSetHandleInLinks() {
+  const set = React.useContext(setContext)
+
+  return React.useCallback(
+    (useHandleInLinks: persisted.Schema['useHandleInLinks']) => {
+      set(useHandleInLinks)
+
+      if (IS_WEB) {
+        window.location.reload()
+      } else {
+        void reloadAppAsync()
+      }
+    },
+    [set],
+  )
+}