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',
};
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={}
size='fullscreen'
>
Logs: {service.name}
{logsLoading ? (
) : (
{logs}
)}
{countdown}s
);
}
// 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 ? (
handleAction('Stop', stopService)}
/>
) : (
handleAction('Start', startService)}
/>
)}
handleAction('Restart', restartService)}
/>
{viewUrl && (
)}
);
}
// Desktop service row - full layout with all columns
function DesktopServiceRow({service, onAction, dockerized}) {
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}
}
{service.port || '-'}
{isRunning ? (
handleAction('Stop', stopService)}
/>
) : (
handleAction('Start', startService)}
/>
)}
handleAction('Restart', restartService)}
/>
{viewUrl && (
)}
{!dockerized && (
{
if (checked) {
await handleAction('Enable', enableService);
} else {
await handleAction('Disable', disableService);
}
}}
label={service.enabled ? 'Enabled' : 'Disabled'}
/>
)}
);
}
function ServicesSection() {
const [services, setServices] = React.useState([]);
const [loading, setLoading] = React.useState(true);
const [error, setError] = React.useState(null);
const [restarting, setRestarting] = React.useState(false);
const dockerized = useDockerized();
const handleRestartServices = async () => {
setRestarting(true);
try {
await restartServices();
toast({
type: 'success',
title: 'Services Restarting',
description: 'All WROLPi services are being restarted.',
time: 5000,
});
// Refresh service list after restart initiated
fetchServices();
} catch (e) {
toast({
type: 'error',
title: 'Restart Failed',
description: e.message,
time: 5000,
});
} finally {
setRestarting(false);
}
};
const fetchServices = async () => {
setLoading(true);
setError(null);
try {
const result = await getServices();
setServices(Array.isArray(result) ? result : []);
} catch (e) {
setError(e.message);
setServices([]);
} finally {
setLoading(false);
}
};
React.useEffect(() => {
fetchServices();
// Refresh every 10 seconds
const interval = setInterval(fetchServices, 10000);
return () => clearInterval(interval);
}, []);
if (loading && services.length === 0) {
return
;
}
if (error) {
return
Error loading services: {error}
Retry
;
}
const restartButton = (colSpan) => (
{restarting ? 'Restarting...' : 'Restart All Services'}
);
return (
{/* Mobile table - 2 columns */}
Service
Actions
{services.map(service => (
))}
{restartButton(2)}
{/* Desktop table - full columns */}
Service
Port
Actions
{!dockerized && Boot}
{services.map(service => (
))}
{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'}
Close
);
}
// The primary mount cannot be unmounted from the UI, but its persistence
// (an /etc/fstab entry) can be toggled. 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.
Cancel
Mount Anyway
);
}
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)}`}
)}
Cancel
Mount
);
}
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 {
await unmountDisk(unmountTarget);
toast({
type: 'success',
title: 'Disk Unmounted',
description: `Unmounted ${unmountTarget}`,
time: 3000,
});
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 is not available in Docker environments.
);
}
if (loading) {
return
;
}
return (
{error && Some disk information unavailable: {error}
}
{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 || isPrimary) ? (
System
) : isMounted ? (
handleUnmountClick(disk.mountpoint)}
/>
) : (
handleOpenMountModal(disk)}
/>
)}
);
})}
) : (
No disks detected.
)}
{!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`
: '-'}
handleShowDetails(drive)}
/>
))}
) : (
No SMART-capable drives detected.
)}
setDetailsOpen(false)}
/>
{
setUnmountConfirmOpen(false);
setUnmountTarget(null);
}}
onConfirm={handleUnmountConfirm}
confirmButton='Unmount'
/>
Refresh
);
}
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 (
Samba is not available on this system.
);
}
const shares = status.shares || [];
return (
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(share.name)}
/>
))}
)}
setRemoveConfirmName(null)}
onConfirm={() => handleRemoveShare(removeConfirmName)}
/>
setAddOpen(true)}
disabled={actionLoading}
/>
{ setAddOpen(false); setShareAll(true); }} size='small'>
Add Samba Share
setNewName(value)}
/>
setShareAll(checked)}
/>
{!shareAll && (
)}
setNewReadOnly(checked)}
/>
setNewComment(value)}
/>
setAddOpen(false)}>Cancel
);
}
function HotspotSettingsForm() {
const dockerized = useDockerized();
const [devices, setDevices] = React.useState([]);
const [form, setForm] = React.useState({device: '', ssid: '', password: ''});
const [loading, setLoading] = React.useState(true);
const [saving, setSaving] = React.useState(false);
const [qrOpen, setQrOpen] = React.useState(false);
React.useEffect(() => {
const fetchSettings = async () => {
try {
const [settings, devicesResponse] = await Promise.all([getHotspotSettings(), getHotspotDevices()]);
setForm({device: settings.device, ssid: settings.ssid, password: settings.password});
setDevices(devicesResponse.devices || []);
} catch (e) {
console.error('Failed to fetch hotspot settings', e);
} finally {
setLoading(false);
}
};
fetchSettings();
}, []);
const handleSave = async () => {
setSaving(true);
try {
const settings = await updateHotspotSettings(form);
setForm(settings);
toast({type: 'success', title: 'Hotspot settings saved', time: 3000});
} catch (e) {
toast({type: 'error', title: 'Failed to save hotspot settings', description: e.message, time: 5000});
} finally {
setSaving(false);
}
};
if (loading) {
return
;
}
// Keep the saved device selectable even if it is not currently present
// (e.g. a USB WiFi dongle is unplugged).
const deviceOptions = [...new Set([...devices, form.device].filter(Boolean))]
.map(device => ({key: device, value: device, text: device}));
// Special string which allows a mobile device to connect to a specific Wi-Fi.
// The WPA QR format requires backslash-escaping of \ ; , " in the SSID and password.
const escapeWifi = (s) => s.replace(/([\\;,"])/g, '\\$1');
const qrCodeValue = `WIFI:S:${escapeWifi(form.ssid)};T:WPA;P:${escapeWifi(form.password)};;`;
return
setForm({...form, ssid: value})}
/>
setForm({...form, password: value})}
/>
setForm({...form, device: value})}
/>
Save
setQrOpen(false)}
onOpen={() => setQrOpen(true)}
open={qrOpen}
trigger={}
>
Scan this code to join the hotspot
;
}
function AdminControlsSection() {
const dockerized = useDockerized();
return (
{!dockerized && (
)}
);
}
export function ControllerPage() {
return (
);
}
export default ControllerPage;