import { create } from 'zustand'; import { appInfo, devSession, isNative, secrets } from '../platform/native'; import { configureClient, PlexError, PlexServer } from '../plex/client'; import * as account from '../plex/account'; import type { PlexUser, ServerResource } from '../plex/types'; export type Status = 'loading' | 'signed-out' | 'choose-server' | 'connecting' | 'ready' | 'offline'; interface StoredServer { id: string; name: string; uri: string; owned: boolean; manual?: boolean; } interface SessionState { status: Status; error: string; accountToken: string | null; user: PlexUser | null; resources: ServerResource[]; server: PlexServer | null; connection: { local: boolean; relay: boolean } | null; init(): Promise; completeSignIn(token: string): Promise; refreshResources(): Promise; chooseServer(resource: ServerResource): Promise; connectManual(uri: string, token: string): Promise; reconnect(): Promise; switchUser(token: string): Promise; showServerPicker(): void; signOut(): Promise; } const SERVER_KEY = 'kaleido.server'; const loadStoredServer = (): StoredServer | null => { try { return JSON.parse(localStorage.getItem(SERVER_KEY) ?? 'null'); } catch { return null; } }; const storeServer = (s: StoredServer | null) => (s ? localStorage.setItem(SERVER_KEY, JSON.stringify(s)) : localStorage.removeItem(SERVER_KEY)); export const useSession = create((set, get) => ({ status: 'loading', error: '', accountToken: null, user: null, resources: [], server: null, connection: null, async init() { const info = await appInfo(); configureClient({ version: info.version, deviceName: info.deviceName }); let token = await secrets.get('account-token'); const stored = loadStoredServer(); if (!token) { const dev = await devSession(); if (dev) { // The development token is the owner's account token. try { await account.getUser(dev.token); token = dev.token; await secrets.set('account-token', token); } catch { try { await get().connectManual(dev.server, dev.token); return; } catch { /* fall through to sign-in */ } } } } if (stored?.manual) { const serverToken = await secrets.get('server-token'); if (serverToken) { try { await get().connectManual(stored.uri, serverToken); return; } catch (e: any) { set({ status: 'offline', error: e.message }); return; } } } if (!token) { set({ status: 'signed-out' }); return; } set({ accountToken: token }); try { const user = await account.getUser(token); set({ user }); } catch (e: any) { if (e instanceof PlexError && (e.status === 401 || e.status === 403)) { await secrets.delete('account-token'); set({ status: 'signed-out', accountToken: null, error: 'Your Plex session has expired. Sign in again.' }); return; } // plex.tv unreachable: try the last server directly. if (stored) { const serverToken = (await secrets.get('server-token')) ?? token; try { await get().connectManual(stored.uri, serverToken); return; } catch { /* offline */ } } set({ status: 'offline', error: 'Kaleido cannot reach Plex right now. Downloaded titles are still available.' }); return; } const resources = await get().refreshResources().catch(() => [] as ServerResource[]); const preferred = resources.find((r) => r.id === stored?.id); if (preferred) { await get().chooseServer(preferred); return; } if (resources.length === 1) { await get().chooseServer(resources[0]); return; } set({ status: resources.length ? 'choose-server' : 'choose-server', error: resources.length ? '' : 'No Plex Media Servers are available to this account.' }); }, async completeSignIn(token) { await secrets.set('account-token', token); set({ accountToken: token, error: '', status: 'connecting' }); const user = await account.getUser(token); set({ user }); const resources = await get().refreshResources(); if (resources.length === 1) await get().chooseServer(resources[0]); else set({ status: 'choose-server' }); }, async refreshResources() { const token = get().accountToken; if (!token) return []; const resources = await account.getResources(token); resources.sort((a, b) => Number(b.owned) - Number(a.owned) || Number(b.presence) - Number(a.presence) || a.name.localeCompare(b.name)); set({ resources }); return resources; }, async chooseServer(resource) { set({ status: 'connecting', error: '' }); const stored = loadStoredServer(); try { const r = await account.connect(resource, stored?.id === resource.id ? stored.uri : undefined); const server = new PlexServer(r.uri, resource.accessToken, r.machineId, resource.name, resource.owned, r.local); storeServer({ id: resource.id, name: resource.name, uri: r.uri, owned: resource.owned }); await secrets.set('server-token', resource.accessToken); set({ server, status: 'ready', connection: { local: r.local, relay: r.relay } }); } catch (e: any) { set({ status: 'choose-server', error: e.message ?? String(e) }); } }, async connectManual(uri, token) { set({ status: 'connecting', error: '' }); const r = await account.connectManual(uri, token); const owned = await account .getUser(token) .then(() => true) .catch(() => false); const server = new PlexServer(r.uri, token, r.machineId, r.name, owned, r.local); storeServer({ id: r.machineId, name: r.name, uri: r.uri, owned, manual: !get().accountToken }); await secrets.set('server-token', token); set({ server, status: 'ready', connection: { local: r.local, relay: false } }); }, async reconnect() { const { resources, server } = get(); const resource = resources.find((r) => r.id === server?.machineId); if (resource) await get().chooseServer(resource); else await get().init(); }, async switchUser(token) { await secrets.set('account-token', token); storeServer(null); set({ accountToken: token, server: null, status: 'connecting' }); await get().init(); }, showServerPicker() { set({ status: 'choose-server', error: '' }); get().refreshResources().catch(() => {}); }, async signOut() { const token = get().accountToken; if (token && isNative) await account.signOut(token); await secrets.delete('account-token'); await secrets.delete('server-token'); storeServer(null); set({ status: 'signed-out', accountToken: null, user: null, server: null, resources: [], connection: null, error: '' }); }, })); /** The connected server. Only call beneath screens rendered when status is ready. */ export function useServer(): PlexServer { const s = useSession((st) => st.server); if (!s) throw new Error('No server connection'); return s; }