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>
213 lines
7.1 KiB
TypeScript
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;
|
|
}
|