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>
This commit is contained in:
Elijah 2026-10-30 16:26:37 -07:00
commit 00d72e70f4
121 changed files with 25315 additions and 0 deletions

258
src/app/App.tsx Normal file
View file

@ -0,0 +1,258 @@
import { lazy, Suspense, useEffect, useLayoutEffect, useRef, useState } from 'react';
import { QueryClientProvider } from '@tanstack/react-query';
import { queryClient, invalidateLibrary } from './queries';
import { useSession } from './session';
import { useRouter, navigate, type Route } from './router';
import { useSettings } from './settings';
import { TopBar } from './TopBar';
import { MenuHost, ToastHost, ConfirmHost } from '../ui/overlays';
import { HoverPreviewHost } from '../ui/HoverPreview';
import { PageLoader } from '../ui/primitives';
import { Splash } from '../screens/Splash';
import { SignIn } from '../screens/SignIn';
import { ServerPicker } from '../screens/ServerPicker';
import { win } from '../platform/native';
import { usePlayer } from '../player/store';
import { PlayerOverlay } from '../player/PlayerOverlay';
import { DialogHost } from '../screens/dialogs/DialogHost';
import { useDownloads } from '../downloads/store';
import { libraryRevision } from '../plex/api';
import { checkForUpdate } from './updater';
import { Home } from '../screens/Home';
import { SectionScreen } from '../screens/Section';
import { ItemScreen } from '../screens/Item';
const Search = lazy(() => import('../screens/Search'));
const Downloads = lazy(() => import('../screens/Downloads'));
const Settings = lazy(() => import('../screens/settings/Settings'));
const Person = lazy(() => import('../screens/Person'));
const HubScreen = lazy(() => import('../screens/HubScreen'));
function Screen({ route }: { route: Route }) {
switch (route.name) {
case 'home':
return <Home />;
case 'section':
return <SectionScreen kind={route.kind} tab={route.tab} />;
case 'item':
return <ItemScreen id={route.id} />;
case 'person':
return <Person id={route.id} title={route.title} thumb={route.thumb} />;
case 'hub':
return <HubScreen hubKey={route.key} title={route.title} />;
case 'search':
return <Search initial={route.query} />;
case 'downloads':
return <Downloads />;
case 'settings':
return <Settings mode={route.mode} tab={route.tab} />;
}
}
/** One scroll container per history entry; its position is restored on Back. */
function Page({ onScrolled }: { onScrolled: (top: number) => void }) {
const entry = useRouter((s) => s.current);
const ref = useRef<HTMLDivElement>(null);
useLayoutEffect(() => {
const el = ref.current;
if (!el) return;
const target = entry.scroll;
el.scrollTop = target;
onScrolled(target);
if (!target) return;
// Content may still be loading; keep trying briefly until it is tall enough.
let tries = 0;
const t = setInterval(() => {
if (!ref.current || tries++ > 30) return clearInterval(t);
ref.current.scrollTop = target;
if (Math.abs(ref.current.scrollTop - target) < 2) clearInterval(t);
}, 50);
return () => clearInterval(t);
}, [entry]);
return (
<div
ref={ref}
className="main-scroll"
data-route={entry.route.name}
onScroll={(e) => {
const top = (e.target as HTMLDivElement).scrollTop;
entry.scroll = top;
onScrolled(top);
}}
>
<Suspense fallback={<PageLoader />}>
<main className="page-enter" key={entry.id}>
<Screen route={entry.route} />
</main>
</Suspense>
</div>
);
}
function useGlobalShortcuts() {
useEffect(() => {
const isTyping = (t: EventTarget | null) => t instanceof HTMLElement && (t.isContentEditable || ['INPUT', 'TEXTAREA', 'SELECT'].includes(t.tagName));
const onKey = (e: KeyboardEvent) => {
if (usePlayer.getState().open) return;
if ((e.ctrlKey || e.metaKey) && (e.key === 'k' || e.key === 'f')) {
e.preventDefault();
navigate({ name: 'search' });
} else if (e.altKey && e.key === 'ArrowLeft') {
e.preventDefault();
useRouter.getState().back();
} else if (e.altKey && e.key === 'ArrowRight') {
e.preventDefault();
useRouter.getState().forward();
} else if (e.key === 'F11') {
e.preventDefault();
win.isFullscreen().then((fs) => win.setFullscreen(!fs));
} else if ((e.key === 'Escape' || e.key === 'Backspace') && !isTyping(e.target) && !document.querySelector('.menu-layer, .dialog-layer')) {
if (e.key === 'Escape' && document.fullscreenElement) return;
useRouter.getState().back();
} else if ((e.ctrlKey || e.metaKey) && e.key === ',') {
e.preventDefault();
navigate({ name: 'settings', mode: 'app', tab: 'general' });
}
};
// Mouse back/forward buttons.
const onMouse = (e: MouseEvent) => {
if (usePlayer.getState().open) return;
if (e.button === 3) {
e.preventDefault();
useRouter.getState().back();
} else if (e.button === 4) {
e.preventDefault();
useRouter.getState().forward();
}
};
window.addEventListener('keydown', onKey);
window.addEventListener('mouseup', onMouse);
return () => {
window.removeEventListener('keydown', onKey);
window.removeEventListener('mouseup', onMouse);
};
}, []);
}
/** Refreshes browsing when the server's libraries change. */
function useLibrarySync() {
const server = useSession((s) => s.server);
useEffect(() => {
if (!server) return;
let last = '';
let stopped = false;
const tick = async () => {
if (stopped || document.hidden || usePlayer.getState().open) return;
try {
const rev = await libraryRevision(server);
if (last && rev !== last) invalidateLibrary();
last = rev;
} catch {
/* transient */
}
};
tick();
const t = setInterval(tick, 20000);
const onVisible = () => !document.hidden && tick();
document.addEventListener('visibilitychange', onVisible);
return () => {
stopped = true;
clearInterval(t);
document.removeEventListener('visibilitychange', onVisible);
};
}, [server]);
}
function Shell() {
const [scrolled, setScrolled] = useState(false);
const playerOpen = usePlayer((s) => s.open);
const startPage = useSettings.getState().startPage;
useGlobalShortcuts();
useLibrarySync();
useEffect(() => {
if (startPage !== 'home') useRouter.getState().reset(startPage === 'movies' ? { name: 'section', kind: 'movie', tab: 'discover' } : { name: 'section', kind: 'show', tab: 'discover' });
useDownloads.getState().init().then(() => useDownloads.getState().resumeInterrupted());
const t = setTimeout(() => checkForUpdate(false), 8000);
return () => clearTimeout(t);
}, []);
return (
<>
<div className="app-shell" aria-hidden={playerOpen}>
<TopBar solid={scrolled} />
<Page onScrolled={(top) => setScrolled(top > 24)} />
</div>
<PlayerOverlay />
</>
);
}
function OfflineShell() {
const error = useSession((s) => s.error);
const init = useSession((s) => s.init);
useEffect(() => {
useDownloads.getState().init();
useRouter.getState().reset({ name: 'downloads' });
}, []);
return (
<>
<div className="app-shell offline">
<div className="offline-banner" data-tauri-drag-region>
<span>{error || 'You’re offline.'}</span>
<button className="btn text" onClick={() => init()}>
Try again
</button>
</div>
<div className="main-scroll">
<Suspense fallback={<PageLoader />}>
<Downloads offline />
</Suspense>
</div>
</div>
<PlayerOverlay />
</>
);
}
export function App() {
const status = useSession((s) => s.status);
const hasServer = useSession((s) => !!s.server);
const reducedMotion = useSettings((s) => s.reducedMotion);
const [splashDone, setSplashDone] = useState(false);
useEffect(() => {
useSession.getState().init();
// The window appears once the first frame is painted (no white flash).
requestAnimationFrame(() => win.show());
}, []);
useEffect(() => {
document.documentElement.classList.toggle('reduced-motion', reducedMotion);
}, [reducedMotion]);
// Switching servers or users starts browsing fresh.
const serverId = useSession((s) => s.server?.machineId);
useEffect(() => {
if (serverId) useRouter.getState().reset({ name: 'home' });
}, [serverId]);
let body;
if (status === 'loading') body = null;
else if (status === 'signed-out') body = <SignIn />;
else if (status === 'choose-server' || (status === 'connecting' && !hasServer)) body = <ServerPicker />;
else if (status === 'offline') body = <OfflineShell />;
else body = <Shell />;
return (
<QueryClientProvider client={queryClient}>
{body}
{(!splashDone || status === 'loading') && <Splash ready={status !== 'loading'} onDone={() => setSplashDone(true)} />}
<HoverPreviewHost />
<DialogHost />
<MenuHost />
<ConfirmHost />
<ToastHost />
</QueryClientProvider>
);
}