feat: initial ui redesign from demo

This commit is contained in:
LukeGus
2026-05-11 01:23:11 -05:00
parent eaa758effe
commit 33dcde0827
349 changed files with 23984 additions and 31634 deletions
+1192
View File
File diff suppressed because it is too large Load Diff
+203
View File
@@ -0,0 +1,203 @@
import React, { useState, useEffect, useRef, useCallback } from "react";
import { Alert, AlertDescription, AlertTitle } from "@/components/alert.tsx";
import { useTranslation } from "react-i18next";
import { AlertCircle, Loader2, ArrowLeft, RefreshCw } from "lucide-react";
interface ElectronLoginFormProps {
serverUrl: string;
onAuthSuccess: (token: string | null) => void | Promise<void>;
onChangeServer: () => void;
}
const AUTH_MESSAGE_SOURCES = new Set([
"auth_component",
"totp_auth_component",
"oidc_callback",
]);
export function ElectronLoginForm({
serverUrl,
onAuthSuccess,
onChangeServer,
}: ElectronLoginFormProps) {
const { t } = useTranslation();
const [loading, setLoading] = useState(true);
const [error, setError] = useState<string | null>(null);
const [isAuthenticating, setIsAuthenticating] = useState(false);
const isAuthenticatingRef = useRef(false);
const iframeRef = useRef<HTMLIFrameElement>(null);
const hasAuthenticatedRef = useRef(false);
const [currentUrl, setCurrentUrl] = useState(serverUrl);
const hasLoadedOnce = useRef(false);
const onAuthSuccessRef = useRef(onAuthSuccess);
useEffect(() => {
onAuthSuccessRef.current = onAuthSuccess;
}, [onAuthSuccess]);
const handleAuthSuccess = useCallback(
async (token: string | null) => {
if (hasAuthenticatedRef.current || isAuthenticatingRef.current) return;
hasAuthenticatedRef.current = true;
isAuthenticatingRef.current = true;
setIsAuthenticating(true);
try {
if (token) {
localStorage.setItem("jwt", token);
}
await onAuthSuccessRef.current(token);
} catch (_err) {
setError(t("errors.authTokenSaveFailed"));
isAuthenticatingRef.current = false;
setIsAuthenticating(false);
hasAuthenticatedRef.current = false;
}
},
[t],
);
// postMessage from server Auth.tsx after the backend has set the HttpOnly cookie.
// Uses '*' as target origin because the iframe may be cross-origin (e.g. remote Docker server).
useEffect(() => {
const handleMessage = async (event: MessageEvent) => {
try {
if (event.source !== iframeRef.current?.contentWindow) return;
if (!event.data || typeof event.data !== "object") return;
const { type, platform, source, token } = event.data;
if (
type === "AUTH_SUCCESS" &&
platform === "desktop" &&
AUTH_MESSAGE_SOURCES.has(source)
) {
await handleAuthSuccess(token ?? null);
}
} catch {
// ignore
}
};
window.addEventListener("message", handleMessage);
return () => window.removeEventListener("message", handleMessage);
}, [handleAuthSuccess]);
useEffect(() => {
const iframe = iframeRef.current;
if (!iframe) return;
const handleLoad = () => {
setLoading(false);
hasLoadedOnce.current = true;
setError(null);
try {
if (iframe.contentWindow) {
setCurrentUrl(iframe.contentWindow.location.href);
}
} catch {
setCurrentUrl(serverUrl);
}
};
const handleError = () => {
setLoading(false);
if (hasLoadedOnce.current) {
setError(t("errors.failedToLoadServer"));
}
};
iframe.addEventListener("load", handleLoad);
iframe.addEventListener("error", handleError);
return () => {
iframe.removeEventListener("load", handleLoad);
iframe.removeEventListener("error", handleError);
};
}, [serverUrl, t]);
const handleRefresh = () => {
if (iframeRef.current) {
iframeRef.current.src = serverUrl;
setLoading(true);
setError(null);
}
};
const displayUrl = currentUrl.replace(/^https?:\/\//, "");
const isEmbeddedServer = serverUrl.includes("localhost:30001");
return (
<div className="fixed inset-0 w-screen h-screen bg-canvas flex flex-col">
{isAuthenticating && (
<div className="absolute inset-0 flex items-center justify-center bg-canvas z-50">
<Loader2 className="h-8 w-8 animate-spin text-primary" />
</div>
)}
{!isAuthenticating && (
<div className="flex items-center justify-between p-4 bg-canvas border-b border-edge">
<button
onClick={onChangeServer}
className="flex items-center gap-2 text-foreground hover:text-primary transition-colors"
>
<ArrowLeft className="h-5 w-5" />
<span className="text-base font-medium">
{t("serverConfig.changeServer")}
</span>
</button>
{!isEmbeddedServer && (
<div className="flex-1 mx-4 text-center">
<span className="text-muted-foreground text-sm truncate block">
{displayUrl}
</span>
</div>
)}
{isEmbeddedServer && <div className="flex-1" />}
<button
onClick={handleRefresh}
className="p-2 text-foreground hover:text-primary transition-colors"
disabled={loading}
>
<RefreshCw className={`h-5 w-5 ${loading ? "animate-spin" : ""}`} />
</button>
</div>
)}
{error && !isAuthenticating && (
<div className="absolute top-20 left-1/2 transform -translate-x-1/2 z-50 w-full max-w-md px-4">
<Alert variant="destructive">
<AlertCircle className="h-4 w-4" />
<AlertTitle>{t("common.error")}</AlertTitle>
<AlertDescription>{error}</AlertDescription>
</Alert>
</div>
)}
{loading && !isAuthenticating && (
<div
className="absolute inset-0 flex items-center justify-center bg-canvas z-40"
style={{ marginTop: "60px" }}
>
<div className="flex items-center">
<Loader2 className="h-8 w-8 animate-spin text-primary" />
<span className="ml-3 text-muted-foreground">
{t("auth.loadingServer")}
</span>
</div>
</div>
)}
<div
className="flex-1 overflow-hidden"
style={{ visibility: isAuthenticating ? "hidden" : "visible" }}
>
<iframe
ref={iframeRef}
src={serverUrl}
className="w-full h-full border-0"
title="Server Authentication"
sandbox="allow-same-origin allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-storage-access-by-user-activation allow-top-navigation allow-top-navigation-by-user-activation allow-modals allow-downloads"
allow="clipboard-read; clipboard-write"
/>
</div>
</div>
);
}
+301
View File
@@ -0,0 +1,301 @@
import React, { useState, useEffect } from "react";
import { Button } from "@/components/button.tsx";
import { Input } from "@/components/input.tsx";
import { Label } from "@/components/label.tsx";
import { Alert, AlertTitle, AlertDescription } from "@/components/alert.tsx";
import { useTranslation } from "react-i18next";
import {
getServerConfig,
saveServerConfig,
getEmbeddedServerStatus,
setEmbeddedMode,
type ServerConfig,
} from "@/main-axios.ts";
import { Server, Monitor, Loader2 } from "lucide-react";
import { useTheme } from "@/components/theme-provider";
interface ServerConfigProps {
onServerConfigured: (serverUrl: string) => void;
onUseEmbedded?: () => void;
onCancel?: () => void;
isFirstTime?: boolean;
}
export function ElectronServerConfig({
onServerConfigured,
onUseEmbedded,
onCancel,
isFirstTime = false,
}: ServerConfigProps) {
const { t } = useTranslation();
const { theme } = useTheme();
const [serverUrl, setServerUrl] = useState("");
const [loading, setLoading] = useState(false);
const [embeddedLoading, setEmbeddedLoading] = useState(false);
const [error, setError] = useState<string | null>(null);
const [embeddedAvailable, setEmbeddedAvailable] = useState<boolean | null>(
null,
);
const isDarkMode =
theme === "dark" ||
theme === "dracula" ||
theme === "gentlemansChoice" ||
theme === "midnightEspresso" ||
theme === "catppuccinMocha" ||
(theme === "system" &&
window.matchMedia("(prefers-color-scheme: dark)").matches);
const lineColor = isDarkMode ? "#151517" : "#f9f9f9";
useEffect(() => {
loadServerConfig();
checkEmbeddedBackend();
}, []);
const loadServerConfig = async () => {
try {
const config = await getServerConfig();
if (config?.serverUrl) {
setServerUrl(config.serverUrl);
}
} catch (error) {
console.error("Server config operation failed:", error);
}
};
const checkEmbeddedBackend = async () => {
try {
const status = await getEmbeddedServerStatus();
setEmbeddedAvailable(!!status?.embedded);
} catch {
setEmbeddedAvailable(true);
}
};
const probeBackend = async (): Promise<boolean> => {
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), 3000);
try {
const res = await fetch("http://localhost:30001/health", {
signal: controller.signal,
});
clearTimeout(timer);
return res.ok;
} catch {
clearTimeout(timer);
}
const controller2 = new AbortController();
const timer2 = setTimeout(() => controller2.abort(), 3000);
try {
await fetch("http://localhost:30001/version", {
signal: controller2.signal,
});
clearTimeout(timer2);
return true;
} catch {
clearTimeout(timer2);
return false;
}
};
const handleUseEmbedded = async () => {
setEmbeddedLoading(true);
setError(null);
try {
const maxRetries = 10;
for (let i = 0; i < maxRetries; i++) {
if (await probeBackend()) {
setEmbeddedMode(true);
if (onUseEmbedded) {
onUseEmbedded();
} else {
onServerConfigured("http://localhost:30001");
}
return;
}
if (i < maxRetries - 1) {
await new Promise((r) => setTimeout(r, 2000));
}
}
setError(t("serverConfig.embeddedNotReady"));
} catch (err) {
setError(
err instanceof Error ? err.message : t("serverConfig.embeddedNotReady"),
);
} finally {
setEmbeddedLoading(false);
}
};
const handleSaveConfig = async () => {
if (!serverUrl.trim()) {
setError(t("serverConfig.enterServerUrl"));
return;
}
setLoading(true);
setError(null);
try {
const normalizedUrl = serverUrl.trim();
if (
!normalizedUrl.startsWith("http://") &&
!normalizedUrl.startsWith("https://")
) {
setError(t("serverConfig.mustIncludeProtocol"));
setLoading(false);
return;
}
const config: ServerConfig = {
serverUrl: normalizedUrl,
lastUpdated: new Date().toISOString(),
};
const success = await saveServerConfig(config);
if (success) {
onServerConfigured(normalizedUrl);
} else {
setError(t("serverConfig.saveFailed"));
}
} catch {
setError(t("serverConfig.saveError"));
} finally {
setLoading(false);
}
};
const handleUrlChange = (value: string) => {
setServerUrl(value);
setError(null);
};
return (
<div
className="fixed inset-0 flex items-center justify-center"
style={{
background: "var(--bg-elevated)",
backgroundImage: `repeating-linear-gradient(
45deg,
transparent,
transparent 35px,
${lineColor} 35px,
${lineColor} 37px
)`,
}}
>
<div className="w-[420px] max-w-full p-8 flex flex-col backdrop-blur-sm bg-card/50 rounded-2xl shadow-xl border-2 border-edge overflow-y-auto thin-scrollbar my-2 animate-in fade-in zoom-in-95 duration-300">
<div className="space-y-6">
<div className="text-center">
<div className="mx-auto mb-4 w-12 h-12 bg-primary/10 rounded-full flex items-center justify-center">
<Server className="w-6 h-6 text-primary" />
</div>
<h2 className="text-xl font-semibold">{t("serverConfig.title")}</h2>
<p className="text-sm text-muted-foreground mt-2">
{t("serverConfig.description")}
</p>
</div>
{embeddedAvailable !== false && (
<div className="space-y-2">
<Button
type="button"
variant="outline"
className="w-full"
onClick={handleUseEmbedded}
disabled={embeddedLoading || loading}
>
{embeddedLoading ? (
<div className="flex items-center space-x-2">
<Loader2 className="w-4 h-4 animate-spin" />
<span>{t("serverConfig.embeddedConnecting")}</span>
</div>
) : (
<div className="flex items-center justify-center space-x-2">
<Monitor className="w-4 h-4" />
<span>{t("serverConfig.useEmbedded")}</span>
<span className="px-1.5 py-0.5 text-[10px] font-bold bg-yellow-500/20 text-yellow-600 dark:text-yellow-400 rounded border border-yellow-500/30">
BETA
</span>
</div>
)}
</Button>
<p className="text-xs text-muted-foreground text-center">
{t("serverConfig.embeddedDesc")}
</p>
</div>
)}
{embeddedAvailable !== false && (
<div className="flex items-center gap-3">
<div className="h-px flex-1 bg-border" />
<span className="text-xs text-muted-foreground">
{t("common.or") || "OR"}
</span>
<div className="h-px flex-1 bg-border" />
</div>
)}
<div className="space-y-4">
<div className="space-y-2">
<Label htmlFor="server-url">{t("serverConfig.serverUrl")}</Label>
<Input
id="server-url"
type="text"
placeholder="https://your-server.com"
value={serverUrl}
onChange={(e) => handleUrlChange(e.target.value)}
className="w-full h-10"
disabled={loading || embeddedLoading}
/>
</div>
{error && (
<Alert variant="destructive">
<AlertTitle>{t("common.error")}</AlertTitle>
<AlertDescription>{error}</AlertDescription>
</Alert>
)}
<div className="flex space-x-2">
{onCancel && !isFirstTime && (
<Button
type="button"
variant="outline"
className="flex-1"
onClick={onCancel}
disabled={loading || embeddedLoading}
>
Cancel
</Button>
)}
<Button
type="button"
variant="outline"
className={onCancel && !isFirstTime ? "flex-1" : "w-full"}
onClick={handleSaveConfig}
disabled={loading || embeddedLoading || !serverUrl.trim()}
>
{loading ? (
<div className="flex items-center space-x-2">
<div className="w-4 h-4 border-2 border-white border-t-transparent rounded-full animate-spin" />
<span>{t("serverConfig.saving")}</span>
</div>
) : (
t("serverConfig.saveConfig")
)}
</Button>
</div>
<div className="text-xs text-muted-foreground text-center">
{t("serverConfig.helpText")}
</div>
</div>
</div>
</div>
</div>
);
}
File diff suppressed because it is too large Load Diff