Kaleido-Desktop/src/downloads/store.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

191 lines
6.6 KiB
TypeScript

import { create } from 'zustand';
import * as api from '../plex/api';
import { parseItem } from '../plex/parse';
import type { Item } from '../plex/types';
import { appInfo, invoke, isNative, listen } from '../platform/native';
import { useSession } from '../app/session';
import { useSettings } from '../app/settings';
import { isWatched } from '../app/format';
import { toast, toastError } from '../ui/overlays';
export type DownloadStatus = 'queued' | 'downloading' | 'paused' | 'completed' | 'failed';
export interface DownloadMeta {
serverId: string;
serverName: string;
ratingKey: string;
partKey: string;
raw: any;
localAssets?: Record<string, string>;
}
export interface Download {
id: string;
filePath: string;
total: number;
received: number;
status: DownloadStatus;
error?: string | null;
meta: DownloadMeta;
createdAt: number;
speed: number;
}
interface DownloadsState {
items: Download[];
ready: boolean;
dir: string;
init(): Promise<void>;
idFor(ratingKey: string, serverId?: string): string;
localFileFor(ratingKey: string): string | null;
start(item: Item): Promise<void>;
startAll(item: Item): Promise<void>;
pause(id: string): void;
resume(id: string): Promise<void>;
remove(id: string): Promise<void>;
resumeInterrupted(): void;
setDir(dir: string): Promise<void>;
itemOf(d: Download): Item;
}
function sanitize(s: string) {
return s.replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_').trim() || 'Untitled';
}
/** Trims metadata kept for offline display: no extras, related hubs or raw blobs. */
function slim(raw: any) {
const { Extras, Related, OnDeck, ...rest } = raw ?? {};
void Extras;
void Related;
void OnDeck;
return rest;
}
export const useDownloads = create<DownloadsState>((set, get) => ({
items: [],
ready: false,
dir: '',
async init() {
if (!isNative || get().ready) return;
const info = await appInfo();
const dir = useSettings.getState().downloadDir || info.defaultDownloadDir;
await invoke('download_set_dir', { dir }).catch(() => {});
const items = await invoke<Download[]>('download_list');
set({ items, ready: true, dir });
listen<Download>('download', (d) => {
const prev = get().items.find((x) => x.id === d.id);
set({ items: prev ? get().items.map((x) => (x.id === d.id ? d : x)) : [d, ...get().items] });
if (d.status === 'completed' && prev && prev.status !== 'completed') toast(`Downloaded “${d.meta.raw?.title ?? 'title'}”`, 'success');
if (d.status === 'failed' && prev?.status !== 'failed' && d.error) toast(d.error, 'error');
});
listen<string>('download-removed', (id) => set({ items: get().items.filter((x) => x.id !== id) }));
},
idFor(ratingKey, serverId) {
const sid = serverId ?? useSession.getState().server?.machineId ?? 'offline';
return `${sid}-${ratingKey}`;
},
localFileFor(ratingKey) {
const d = get().items.find((x) => x.meta.ratingKey === ratingKey && x.status === 'completed');
return d?.filePath ?? null;
},
async start(input) {
const server = useSession.getState().server;
if (!isNative) {
toast('Downloads are available in the Kaleido desktop app.', 'error');
return;
}
if (!server) return;
try {
await get().init();
const item = await api.metadata(server, input.id);
const media = item.media[0];
const part = media?.parts[0];
if (!part) throw new Error('This title has no downloadable file.');
const id = get().idFor(item.id);
if (get().items.some((d) => d.id === id && d.status !== 'failed')) {
toast('This title is already in Downloads.');
return;
}
const ext = part.file.split('.').pop() || part.container || media.container || 'mkv';
const baseName = part.file.split(/[\\/]/).pop() || `${item.title}.${ext}`;
const folder =
item.type === 'episode'
? `${sanitize(item.grandparentTitle)}/Season ${item.parentIndex}`
: sanitize(item.year ? `${item.title} (${item.year})` : item.title);
const assets: Record<string, string> = {};
const poster = item.type === 'episode' ? item.grandparentThumb : item.thumb;
if (poster) assets.poster = server.image(poster, 360, 540);
if (item.type === 'episode' && item.thumb) assets.still = server.image(item.thumb, 640, 360);
const backdrop = item.type === 'episode' ? item.grandparentArt : item.art;
if (backdrop) assets.art = server.image(backdrop, 1280, 720);
if (item.logo) assets.logo = server.image(item.logo, 600, 200, { format: 'png' });
await invoke('download_start', {
request: {
id,
url: server.signed(part.key, { download: 1 }),
folder,
fileName: sanitize(baseName),
meta: { serverId: server.machineId, serverName: server.name, ratingKey: item.id, partKey: part.key, raw: slim(item.raw) } satisfies DownloadMeta,
assets,
},
});
toast(`Downloading “${item.type === 'episode' ? `${item.grandparentTitle} · ${item.title}` : item.title}”`, 'success');
} catch (e) {
toastError(e);
}
},
async startAll(item) {
const server = useSession.getState().server;
if (!server) return;
try {
const leaves = await api.allLeaves(server, item.id);
const percent = useSettings.getState().watchedPercent;
const todo = leaves.filter((e) => !isWatched(e, percent));
const list = todo.length ? todo : leaves;
toast(`Queued ${list.length} episode${list.length === 1 ? '' : 's'} for download`, 'success');
for (const e of list) await get().start(e);
} catch (e) {
toastError(e);
}
},
pause(id) {
invoke('download_pause', { id }).catch(toastError);
},
async resume(id) {
const d = get().items.find((x) => x.id === id);
const server = useSession.getState().server;
if (!d || !server) return;
if (server.machineId !== d.meta.serverId) {
toast(`Connect to ${d.meta.serverName} to resume this download.`, 'error');
return;
}
await invoke('download_resume', { id, url: server.signed(d.meta.partKey, { download: 1 }) }).catch(toastError);
},
async remove(id) {
await invoke('download_remove', { id, deleteFiles: true }).catch(toastError);
},
resumeInterrupted() {
const server = useSession.getState().server;
if (!server) return;
for (const d of get().items) if (d.status === 'paused' && d.error === 'interrupted' && d.meta.serverId === server.machineId) get().resume(d.id);
},
async setDir(dir) {
await invoke('download_set_dir', { dir });
useSettings.getState().set('downloadDir', dir);
set({ dir });
},
itemOf(d) {
return parseItem(d.meta.raw ?? {});
},
}));