import React from 'react'; import {Checkbox, Container, Dropdown, Form, Icon, Input} from "semantic-ui-react"; import {Button, Confirm, Header, Loader, Modal, Segment, Table} from "../Theme"; import {APIButton, BluetoothToggle, DirectorySearch, HandPointMessage, HotspotToggle, InfoMessage, ThrottleToggle, Toggle,} from "../Common"; import {useDockerized, useMediaDirectory} from "../../hooks/customHooks"; import {Media} from "../../contexts/contexts"; import { addFstabEntry, addSambaShare, disableService, enableService, getDisks, getFstabEntries, getHotspotDevices, getHotspotSettings, getSambaStatus, getServiceLogs, getServices, getSmartStatus, mountDisk, removeFstabEntry, removeSambaShare, restartService, restartServices, startService, stopService, unmountDisk, updateHotspotSettings, } from "../../api/controller"; import QRCode from "react-qr-code"; import {toast} from "react-semantic-toasts-2"; import {RestartButton, ShutdownButton} from "./Settings"; import Message from "semantic-ui-react/dist/commonjs/collections/Message"; import {CONTROLLER_URI} from "../Vars"; // Service status color mapping const statusColors = { running: 'green', stopped: 'red', failed: 'red', unknown: 'yellow', }; // Sort order within a group: problems first so they stay visible. const statusSortOrder = { failed: 0, unknown: 1, stopped: 2, running: 3, }; // Partition services into the two Controller groups. The backend computes each // service's `group` ("core" | "optional"); a missing group (e.g. Docker // containers) is treated as core so nothing is hidden. Within each group, // failed/stopped services sort first, then alphabetically. export const groupServices = (services) => { const byStatusThenName = (a, b) => { const sa = statusSortOrder[a.status] ?? 1; const sb = statusSortOrder[b.status] ?? 1; if (sa !== sb) return sa - sb; return a.name.localeCompare(b.name); }; const core = services.filter(s => s.group !== 'optional').sort(byStatusThenName); const optional = services.filter(s => s.group === 'optional').sort(byStatusThenName); return {core, optional}; }; const linesOptions = [ {key: 100, text: '100 lines', value: 100}, {key: 250, text: '250 lines', value: 250}, {key: 500, text: '500 lines', value: 500}, {key: 1000, text: '1000 lines', value: 1000}, {key: 5000, text: '5000 lines', value: 5000}, ]; // Custom hook for service row state and handlers function useServiceRow(service, onAction) { const [loading, setLoading] = React.useState(false); const [logsOpen, setLogsOpen] = React.useState(false); const [logs, setLogs] = React.useState(''); const [logsLoading, setLogsLoading] = React.useState(false); const [linesCount, setLinesCount] = React.useState(250); const [countdown, setCountdown] = React.useState(10); const logsRef = React.useRef(null); const handleAction = async (action, actionFn) => { setLoading(true); try { await actionFn(service.name); toast({ type: 'success', title: `${action} ${service.name}`, description: `Successfully ${action.toLowerCase()}ed ${service.name}`, time: 3000, }); if (onAction) onAction(); } catch (e) { toast({ type: 'error', title: `${action} Failed`, description: e.message, time: 5000, }); } finally { setLoading(false); } }; const fetchLogs = async (lines, showLoading = false) => { if (showLoading) setLogsLoading(true); try { const result = await getServiceLogs(service.name, lines); setLogs(result.logs || 'No logs available'); } catch (e) { setLogs(`Error fetching logs: ${e.message}`); } finally { if (showLoading) setLogsLoading(false); } }; // Scroll to bottom when logs finish loading React.useEffect(() => { if (!logsLoading && logsRef.current) { logsRef.current.scrollTop = logsRef.current.scrollHeight; } }, [logsLoading]); // Auto-refresh countdown timer (only when scrolled to bottom) React.useEffect(() => { if (!logsOpen) return; const interval = setInterval(() => { setCountdown(prev => { if (prev <= 1) { // Check if scrolled to bottom (within 50px threshold) if (logsRef.current) { const {scrollTop, scrollHeight, clientHeight} = logsRef.current; const isAtBottom = scrollHeight - scrollTop - clientHeight < 50; if (isAtBottom) { fetchLogs(linesCount); } } return 10; // Reset countdown } return prev - 1; }); }, 1000); return () => clearInterval(interval); }, [logsOpen, linesCount]); const handleViewLogs = async () => { setLogsOpen(true); fetchLogs(linesCount, true); // Show loading on initial open }; const handleLinesChange = (e, {value}) => { setLinesCount(value); fetchLogs(value); }; const handleDownloadLogs = () => { const datetime = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19); const filename = `${service.name}_${datetime}.txt`; const blob = new Blob([logs], {type: 'text/plain'}); const url = URL.createObjectURL(blob); const a = document.createElement('a'); a.href = url; a.download = filename; a.click(); URL.revokeObjectURL(url); }; const isRunning = service.status === 'running'; const statusColor = statusColors[service.status] || 'grey'; // Build view URL if service is viewable let viewUrl = null; if (service.viewable && service.port && isRunning) { const protocol = service.use_https ? 'https' : 'http'; const host = window.location.hostname; const path = service.view_path || ''; const isDefaultPort = (protocol === 'https' && service.port === 443) || (protocol === 'http' && service.port === 80); const portSuffix = isDefaultPort ? '' : `:${service.port}`; viewUrl = `${protocol}://${host}${portSuffix}${path}`; } return { loading, logsOpen, setLogsOpen, logs, logsLoading, linesCount, countdown, logsRef, handleAction, fetchLogs, handleViewLogs, handleLinesChange, handleDownloadLogs, isRunning, statusColor, viewUrl }; } // Logs modal component (shared between mobile and desktop) function ServiceLogsModal({ service, logsOpen, setLogsOpen, logs, logsLoading, logsRef, linesCount, countdown, handleViewLogs, handleLinesChange, handleDownloadLogs, fetchLogs }) { return ( setLogsOpen(false)} onOpen={handleViewLogs} trigger={ ); } // Mobile service row - simplified layout function MobileServiceRow({service, onAction}) { const { loading, logsOpen, setLogsOpen, logs, logsLoading, linesCount, countdown, logsRef, handleAction, fetchLogs, handleViewLogs, handleLinesChange, handleDownloadLogs, isRunning, statusColor, viewUrl } = useServiceRow(service, onAction); return ( {service.name} {service.description &&
{service.description}
}
{isRunning ? ( ; } const restartButton = (colSpan) => ( {restarting ? 'Restarting...' : 'Restart All Services'} ); const {core, optional} = groupServices(services); // Full-width labeled separator between the two service groups. const groupLabelRow = (key, title, colSpan) => ( {title} ); const groupedRows = (RowComponent, colSpan, extraProps = {}) => { const rows = []; // Only label the Core group when there is also an Optional group to // distinguish it from; otherwise a lone header adds noise. if (core.length > 0 && optional.length > 0) { rows.push(groupLabelRow('label-core', 'Core Services', colSpan)); } core.forEach(service => rows.push( )); if (optional.length > 0) { rows.push(groupLabelRow('label-optional', 'Optional & Maintenance', colSpan)); optional.forEach(service => rows.push( )); } return rows; }; return (
Services
{/* Mobile table - 2 columns */} Service Actions {groupedRows(MobileServiceRow, 2)} {restartButton(2)}
{/* Desktop table - full columns */} Service Port Actions {!dockerized && Boot} {groupedRows(DesktopServiceRow, dockerized ? 3 : 4, {dockerized})} {restartButton(dockerized ? 4 : 5)}
{services.length === 0 && (

No services found. Services may not be available in this environment.

)}
); } // Helper to get health status color from SMART assessment const getHealthColor = (assessment) => { if (!assessment) return 'grey'; const upper = assessment.toUpperCase(); if (upper === 'PASS') return 'green'; if (upper === 'WARN') return 'yellow'; if (upper === 'FAIL') return 'red'; return 'grey'; }; // Helper to format power-on hours const formatPowerOnHours = (hours) => { if (hours === null || hours === undefined) return '-'; const days = Math.floor(hours / 24); const years = Math.floor(days / 365); if (years > 0) return `${hours.toLocaleString()} hrs (${years}y ${days % 365}d)`; if (days > 0) return `${hours.toLocaleString()} hrs (${days}d)`; return `${hours} hrs`; }; function SmartDetailsModal({drive, open, onClose}) { if (!drive) return null; const healthColor = getHealthColor(drive.health || drive.assessment); return ( SMART Details: {drive.device} Model {drive.model || '-'} Serial {drive.serial || '-'} Capacity {drive.capacity || '-'} Assessment {drive.assessment || drive.health || 'Unknown'} {drive.smart_limited ? ' (limited — USB enclosure reports health only, no attributes)' : ''} Temperature {drive.temperature !== null && drive.temperature !== undefined ? `${drive.temperature}°C` : '-'} Power-On Hours {formatPowerOnHours(drive.power_on_hours)} Reallocated Sectors 0 ? 'orange' : 'inherit'}}> {drive.reallocated_sectors !== null && drive.reallocated_sectors !== undefined ? drive.reallocated_sectors : '-'} Pending Sectors 0 ? 'orange' : 'inherit'}}> {drive.pending_sectors !== null && drive.pending_sectors !== undefined ? drive.pending_sectors : '-'} Uncorrectable Sectors 0 ? 'orange' : 'inherit'}}> {drive.offline_uncorrectable !== null && drive.offline_uncorrectable !== undefined ? drive.offline_uncorrectable : '-'} SMART Enabled {drive.smart_enabled ? 'Yes' : 'No'}
); } // The primary mount can be unmounted (to swap in a backup drive), but doing // so stops the WROLPi API service — the unmount modal warns about this. Any // mount outside /media belongs to the system (/, /boot/efi, /boot/firmware, …) // and is entirely untouchable. const PRIMARY_MOUNT = '/media/wrolpi'; // Helper to format disk size const formatSize = (size) => { if (!size) return '-'; // If already a string (e.g., "59.5G" from lsblk), return as-is if (typeof size === 'string') return size; const units = ['B', 'KB', 'MB', 'GB', 'TB']; let i = 0; let bytes = size; while (bytes >= 1024 && i < units.length - 1) { bytes /= 1024; i++; } return `${bytes.toFixed(1)} ${units[i]}`; }; function formatBytes(bytes) { if (!bytes || bytes < 1) return '0 B'; const units = ['B', 'KB', 'MB', 'GB', 'TB']; let i = 0; let n = bytes; while (n >= 1024 && i < units.length - 1) { n /= 1024; i++; } return `${n.toFixed(n >= 10 ? 0 : 1)} ${units[i]}`; } function MountModal({disk, open, onClose, onMount}) { const [mountPoint, setMountPoint] = React.useState(''); const [persist, setPersist] = React.useState(false); const [loading, setLoading] = React.useState(false); const [shadowed, setShadowed] = React.useState(null); // Set default mount point when disk changes React.useEffect(() => { if (disk) { const defaultMount = disk.label ? `/media/${disk.label}` : `/media/${disk.name}`; setMountPoint(defaultMount); setPersist(false); setShadowed(null); } }, [disk]); const performMount = async (forceShadowed) => { setLoading(true); try { const result = await mountDisk(disk.path, mountPoint.trim(), disk.fstype, 'defaults', persist, forceShadowed); // Soft-block: target contains data that would be hidden by the mount. if (result && result.success === false && result.needs_force === 'shadowed') { setShadowed(result.shadowed_data || {entries: [], size_bytes: 0}); return; } toast({ type: 'success', title: 'Disk Mounted', description: `${disk.name} mounted at ${mountPoint}`, time: 3000, }); onClose(); if (onMount) onMount(); } catch (e) { toast({ type: 'error', title: 'Mount Failed', description: e.message, time: 5000, }); } finally { setLoading(false); } }; const handleMount = async () => { if (!mountPoint.trim()) { toast({ type: 'error', title: 'Mount point required', description: 'Please enter a mount point.', time: 3000, }); return; } await performMount(false); }; const handleForceMount = () => performMount(true); const handleCancel = () => { setShadowed(null); onClose(); }; if (!disk) return null; if (shadowed) { const entries = (shadowed.entries || []).join(', ') || '(unknown)'; return ( Existing Files Detected

Mounting {disk.name} at {mountPoint} would hide existing files that are already there.

Found {entries} ({formatBytes(shadowed.size_bytes)}) at the mount target.

Those files will continue to consume space on the underlying filesystem (typically the SD card on a Raspberry Pi) and can fill it up.

Recommended: cancel, move or delete the existing files, then mount.

); } return ( Mount Disk: {disk.name}
setMountPoint(e.target.value)} placeholder="/media/..." fluid /> setPersist(checked)} /> {disk.fstype && (

Filesystem: {disk.fstype} {disk.label && ` | Label: ${disk.label}`} {disk.size && ` | Size: ${formatSize(disk.size)}`}

)}
); } function DiskSection() { const [disks, setDisks] = React.useState([]); const [fstabEntries, setFstabEntries] = React.useState([]); const [smartDrives, setSmartDrives] = React.useState([]); const [smartAvailable, setSmartAvailable] = React.useState(true); const [loading, setLoading] = React.useState(true); const [error, setError] = React.useState(null); const [selectedDrive, setSelectedDrive] = React.useState(null); const [detailsOpen, setDetailsOpen] = React.useState(false); const [mountModalOpen, setMountModalOpen] = React.useState(false); const [selectedDisk, setSelectedDisk] = React.useState(null); const [unmountConfirmOpen, setUnmountConfirmOpen] = React.useState(false); const [unmountTarget, setUnmountTarget] = React.useState(null); const dockerized = useDockerized(); const fetchDiskInfo = async () => { setLoading(true); setError(null); try { const [disksResult, fstabResult, smartResult] = await Promise.allSettled([ getDisks(), getFstabEntries(), getSmartStatus(), ]); if (disksResult.status === 'fulfilled') { setDisks(Array.isArray(disksResult.value) ? disksResult.value : []); } if (fstabResult.status === 'fulfilled') { setFstabEntries(Array.isArray(fstabResult.value) ? fstabResult.value : []); } if (smartResult.status === 'fulfilled' && smartResult.value) { // Handle new API format: {available: bool, drives: [...]} const smartData = smartResult.value; setSmartAvailable(smartData.available !== false); setSmartDrives(Array.isArray(smartData.drives) ? smartData.drives : []); } else { setSmartAvailable(false); setSmartDrives([]); } } catch (e) { setError(e.message); } finally { setLoading(false); } }; const handleShowDetails = (drive) => { setSelectedDrive(drive); setDetailsOpen(true); }; const handleOpenMountModal = (disk) => { setSelectedDisk(disk); setMountModalOpen(true); }; const handleCloseMountModal = () => { setMountModalOpen(false); setSelectedDisk(null); }; const handleUnmountClick = (mountPoint) => { setUnmountTarget(mountPoint); setUnmountConfirmOpen(true); }; const handleUnmountConfirm = async () => { if (!unmountTarget) return; try { const result = await unmountDisk(unmountTarget); const stoppedServices = (result && result.stopped_services) || []; toast({ type: 'success', title: 'Disk Unmounted', description: stoppedServices.length > 0 ? `Unmounted ${unmountTarget}; stopped ${stoppedServices.join(', ')}` : `Unmounted ${unmountTarget}`, time: 5000, }); fetchDiskInfo(); } catch (e) { toast({ type: 'error', title: 'Unmount Failed', description: e.message, time: 5000, }); } finally { setUnmountConfirmOpen(false); setUnmountTarget(null); } }; const handleTogglePersist = async (disk, enable) => { try { if (enable) { await addFstabEntry(disk.path, disk.mountpoint, disk.fstype || 'auto'); toast({ type: 'success', title: 'Persistence Enabled', description: `${disk.mountpoint} will persist across reboots`, time: 3000, }); } else { await removeFstabEntry(disk.mountpoint); toast({ type: 'success', title: 'Persistence Disabled', description: `${disk.mountpoint} will not persist across reboots`, time: 3000, }); } fetchDiskInfo(); } catch (e) { toast({ type: 'error', title: 'Failed to update persistence', description: e.message, time: 5000, }); } }; // Check if a mount point is in fstab (persistent) const isPersistent = (mountpoint) => { return fstabEntries.some(entry => entry.mount_point === mountpoint); }; React.useEffect(() => { fetchDiskInfo(); }, []); if (dockerized) { return (
Disk Management

Disk management is not available in Docker environments.

); } if (loading) { return
Disk Management
; } return (
Disk Management
{error &&

Some disk information unavailable: {error}

}
Disks
{disks.length > 0 ? ( Name Size Type Label Mount Point Persist Actions {disks.map((disk) => { const isMounted = disk.mountpoint && disk.mountpoint !== ''; const isPrimary = disk.mountpoint === PRIMARY_MOUNT; // Mounts outside /media (/, /boot/efi, …) are system mounts. const isSystemMount = isMounted && !isPrimary && !disk.mountpoint.startsWith('/media/'); const persistent = isMounted && isPersistent(disk.mountpoint); return ( {disk.name} {formatSize(disk.size)} {disk.fstype || '-'} {disk.label || '-'} {isMounted ? ( {disk.mountpoint} ) : ( - )} {isMounted && !isSystemMount ? ( handleTogglePersist(disk, checked)} label={persistent ? 'Enabled' : 'Disabled'} /> ) : ( - )} {isMounted && isSystemMount ? ( System ) : isMounted ? (
) : (

No disks detected.

)}
SMART Health
{!smartAvailable ? (

SMART monitoring not available (pySMART not installed or not supported)

) : smartDrives.length > 0 ? ( Device Health Temperature Actions {smartDrives.map((drive) => ( {drive.device} {drive.health || drive.assessment || 'Unknown'} {drive.smart_limited ? ' (limited)' : ''} {drive.temperature !== null && drive.temperature !== undefined ? `${drive.temperature}°C` : '-'}
) : (

No SMART-capable drives detected.

)} setDetailsOpen(false)} />

Are you sure you want to unmount {unmountTarget}?

This is the primary WROLPi drive. The WROLPi API service will be stopped before unmounting, and your media will be unavailable until a drive is mounted at {PRIMARY_MOUNT} and the API service is started again.

) : `Are you sure you want to unmount ${unmountTarget}?`} onCancel={() => { setUnmountConfirmOpen(false); setUnmountTarget(null); }} onConfirm={handleUnmountConfirm} confirmButton='Unmount' />
); } function SambaSection() { const [status, setStatus] = React.useState(null); const [loading, setLoading] = React.useState(true); const [actionLoading, setActionLoading] = React.useState(false); const [addOpen, setAddOpen] = React.useState(false); const [shareAll, setShareAll] = React.useState(true); const [newName, setNewName] = React.useState(''); const [newPath, setNewPath] = React.useState(''); const [newReadOnly, setNewReadOnly] = React.useState(true); const [newComment, setNewComment] = React.useState(''); const [removeConfirmName, setRemoveConfirmName] = React.useState(null); const dockerized = useDockerized(); const mediaDirectory = useMediaDirectory(); const fetchStatus = async () => { try { const result = await getSambaStatus(); setStatus(result); } catch (e) { console.error('Failed to fetch Samba status:', e); } finally { setLoading(false); } }; React.useEffect(() => { fetchStatus(); const interval = setInterval(fetchStatus, 10000); return () => clearInterval(interval); }, []); const handleAddShare = async () => { if (!newName.trim()) return; setActionLoading(true); const absolutePath = shareAll ? mediaDirectory : `${mediaDirectory}/${newPath.trim()}`; try { await addSambaShare(newName.trim(), absolutePath, newReadOnly, newComment.trim()); toast({type: 'success', title: 'Share Added', description: `Added share "${newName}"`, time: 3000}); setAddOpen(false); setShareAll(true); setNewName(''); setNewPath(''); setNewReadOnly(true); setNewComment(''); await fetchStatus(); } catch (e) { toast({type: 'error', title: 'Add Share Failed', description: e.message, time: 5000}); } finally { setActionLoading(false); } }; const handleRemoveShare = async (name) => { setActionLoading(true); try { await removeSambaShare(name); toast({type: 'success', title: 'Share Removed', description: `Removed share "${name}"`, time: 3000}); await fetchStatus(); } catch (e) { toast({type: 'error', title: 'Remove Share Failed', description: e.message, time: 5000}); } finally { setActionLoading(false); setRemoveConfirmName(null); } }; if (loading) { return ; } if (!status || !status.available) { if (dockerized) return null; return (
Network Shares (Samba)
Samba is not available on this system.
); } const shares = status.shares || []; return (
Network Shares (Samba)

Configure directories to share over the local network. Start the smbd service to activate sharing.

{shares.length > 0 && ( Name Path Read Only Comment Actions {shares.map(share => ( {share.name} {share.path} {share.read_only ? 'Yes' : 'No'} {share.comment}
)} setRemoveConfirmName(null)} onConfirm={() => handleRemoveShare(removeConfirmName)} />
{ setAddOpen(false); setShareAll(true); }} size='small'> Add Samba Share
setNewName(value)} /> setShareAll(checked)} /> {!shareAll && ( )} setNewReadOnly(checked)} /> setNewComment(value)} />
setQrOpen(false)} onOpen={() => setQrOpen(true)} open={qrOpen} trigger={