Kaleido-Desktop/src/app/session.ts
Elijah 00d72e70f4 Create Kaleido Desktop, a cinematic Plex client for Windows
Tauri 2 shell with a React/TypeScript interface and libmpv playback composed
beneath the web view (DirectComposition on Windows). Shared code with per-OS
platform modules and configs so macOS and Linux can follow.

- Plex sign-in (browser, plex.tv/link or manual), server selection, Plex Home
- Home, Movies and TV Shows (Discover, Library, Collections), search, people
- Title pages with logos, ratings, cast, extras, seasons and episodes
- Direct play with Plex conversion fallback, tracks, markers, autoplay
- Metadata editing, artwork, fix match, refresh, analyze and deletion
- Resumable offline downloads
- App settings and Plex server administration with a live dashboard
- Signed updater feed and Forgejo CI

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 16:26:37 -07:00

213 lines
7.1 KiB
TypeScript

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<void>;
completeSignIn(token: string): Promise<void>;
refreshResources(): Promise<ServerResource[]>;
chooseServer(resource: ServerResource): Promise<void>;
connectManual(uri: string, token: string): Promise<void>;
reconnect(): Promise<void>;
switchUser(token: string): Promise<void>;
showServerPicker(): void;
signOut(): Promise<void>;
}
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<SessionState>((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;
}