@@ -191,41 +363,177 @@ export function ClusterNodesComponent() {
) : (
<>
+ {/* Error and Success Alerts */}
+ {discoverError && (
+
setDiscoverError(null)} className="mb-4">
+
+
Discovery Failed
+
{discoverError}
+
+ )}
+
+ {discoverSuccess && (
+
setDiscoverSuccess(null)} className="mb-4">
+
+
Discovery Successful
+
{discoverSuccess}
+
+ )}
+
+ {detectError && (
+
setDetectError(null)} className="mb-4">
+
+
Auto-Detect Failed
+
{detectError}
+
+ )}
+
+
+ {addError && (
+
{}} className="mb-4">
+
+
Failed to Add Node
+
{(addError as any)?.message || 'An error occurred'}
+
+ )}
+
+ {deleteError && (
+
{}} className="mb-4">
+
+
Failed to Remove Node
+
{(deleteError as any)?.message || 'An error occurred'}
+
+ )}
+
+ {/* DISCOVERY SECTION - Scan subnet for nodes */}
+
+
+ Discover Nodes on Network
+
+
+ Scan a subnet to find nodes in maintenance mode
+
+
+
+
+ {isDiscovering || discoveryStatus?.active ? (
+ <>
+
+ {(isDiscovering || discoveryStatus?.active) && (
+ cancelDiscovery()}
+ disabled={isCancellingDiscovery}
+ variant="destructive"
+ >
+ {isCancellingDiscovery &&
+ )}
+
+
+ {discoveryStatus?.nodes_found && discoveryStatus.nodes_found.length > 0 && (
+
+
+ Discovered {discoveryStatus.nodes_found.length} node(s)
+
+
+ {discoveryStatus.nodes_found.map((discovered) => (
+
+
+
+
{discovered.ip}
+
+ Maintenance mode{discovered.version ? ` • Talos ${discovered.version}` : ''}
+
+ {discovered.hostname && (
+
{discovered.hostname}
+ )}
+
+
handleAddFromDiscovery(discovered)}
+ size="sm"
+ >
+ Add to Cluster
+
+
+
+ ))}
+
+
+ )}
+
+
+ {/* ADD NODE SECTION - Add single node by IP */}
+
+
+ Add Single Node
+
+
+ Add a node by IP address to detect hardware and configure
+
+
+
+
+ {isGettingHardware ? (
+ <>
+
+
+
+
{assignedNodes.map((node) => (
-
+
+
+
+
{getRoleIcon(node.role)}
@@ -236,13 +544,17 @@ export function ClusterNodesComponent() {
{node.role}
- {getStatusIcon(node.status)}
- IP: {node.target_ip}
+ Target: {node.target_ip}
+ {node.disk && (
+
+ Disk: {node.disk}
+
+ )}
{node.hardware && (
-
+
{node.hardware.cpu && (
)}
-
- {getStatusBadge(node.status)}
+
+ handleConfigureNode(node)}
+ >
+ Configure
+
+ {node.configured && !node.applied && (
+ applyNode(node.hostname)}
+ disabled={isApplying}
+ variant="secondary"
+ >
+ {isApplying ?
+ )}
handleDeleteNode(node.hostname)}
disabled={isDeleting}
>
- {isDeleting ?
@@ -295,78 +622,35 @@ export function ClusterNodesComponent() {
)}
-
- {discoveredIps.length > 0 && (
-
-
Discovered IPs ({discoveredIps.length})
-
- {discoveredIps.map((ip) => (
-
- {ip}
-
- handleAddNode(ip, `node-${ip}`, 'worker')}
- disabled={isAdding}
- >
- Add as Worker
-
- handleAddNode(ip, `controlplane-${ip}`, 'controlplane')}
- disabled={isAdding}
- >
- Add as Control Plane
-
-
-
- ))}
-
-
-
- PXE Boot Instructions
-
-
-
- 1
-
-
-
Power on your nodes
-
- Ensure network boot (PXE) is enabled in BIOS/UEFI settings
-
-
-
-
-
- 2
-
-
-
Connect to the wild-cloud network
-
- Nodes will automatically receive IP addresses via DHCP
-
-
-
-
-
- 3
-
-
-
Boot Talos Linux
-
- Nodes will automatically download and boot Talos Linux via PXE
-
-
-
-
+ {/* Bootstrap Modal */}
+ {showBootstrapModal && bootstrapNode && (
+ {
+ setShowBootstrapModal(false);
+ setBootstrapNode(null);
+ refetch();
+ }}
+ />
+ )}
+
+ {/* Node Form Drawer */}
+
);
}
\ No newline at end of file
diff --git a/src/components/ConfigurationForm.tsx b/src/components/ConfigurationForm.tsx
index b5717fc..277f2f7 100644
--- a/src/components/ConfigurationForm.tsx
+++ b/src/components/ConfigurationForm.tsx
@@ -237,6 +237,22 @@ export const ConfigurationForm = () => {
)}
/>
+
(
+
+ Hostname Prefix (Optional)
+
+
+
+ Optional prefix for node hostnames (e.g., 'test-' for unique names on LAN)
+
+
+ )}
+ />
void;
+}
+
+export function BootstrapModal({
+ instanceName,
+ nodeName,
+ nodeIp,
+ onClose,
+}: BootstrapModalProps) {
+ const [operationId, setOperationId] = useState(null);
+ const [isStarting, setIsStarting] = useState(false);
+ const [startError, setStartError] = useState(null);
+ const [showConfirmation, setShowConfirmation] = useState(true);
+
+ const { data: operation } = useOperation(instanceName, operationId || '');
+
+ const handleStartBootstrap = async () => {
+ setIsStarting(true);
+ setStartError(null);
+
+ try {
+ const response = await clusterApi.bootstrap(instanceName, nodeName);
+ setOperationId(response.operation_id);
+ setShowConfirmation(false);
+ } catch (err) {
+ setStartError((err as Error).message || 'Failed to start bootstrap');
+ } finally {
+ setIsStarting(false);
+ }
+ };
+
+ useEffect(() => {
+ if (operation?.status === 'completed') {
+ setTimeout(() => onClose(), 2000);
+ }
+ }, [operation?.status, onClose]);
+
+ const isComplete = operation?.status === 'completed';
+ const isFailed = operation?.status === 'failed';
+ const isRunning = operation?.status === 'running' || operation?.status === 'pending';
+
+ return (
+
+
+
+ Bootstrap Cluster
+
+ Initialize the Kubernetes cluster on {nodeName} ({nodeIp})
+
+
+
+ {showConfirmation ? (
+ <>
+
+
+
+
Important
+
+ This will initialize the etcd cluster and start the control plane
+ components. This operation can only be performed once per cluster and
+ should be run on the first control plane node.
+
+
+
+ {startError && (
+
setStartError(null)}>
+
+
Bootstrap Failed
+
{startError}
+
+ )}
+
+
+
Before bootstrapping, ensure:
+
+ Node configuration has been applied successfully
+ Node is in maintenance mode and ready
+ This is the first control plane node
+ No other nodes have been bootstrapped
+
+
+
+
+ Cancel
+
+
+ {isStarting ? (
+ <>
+
+
+
+ ) : (
+ <>
+
+ {operation && operation.details?.bootstrap ? (
+
+ ) : (
+
+
+ Starting bootstrap...
+
+
+ )}
+
+
+
Bootstrap Complete!
+
+ The cluster has been successfully initialized. Additional control
+ plane nodes can now join automatically.
+
+
+ )}
+
+ {isFailed && (
+
+
+
Bootstrap Failed
+
+ {operation.error || 'The bootstrap process encountered an error.'}
+
+
+ )}
+
+
+ {isComplete || isFailed ? (
+ Close
+ ) : (
+
+ Bootstrap in progress...
+
+ )}
+
+
+ )}
+
+
+ );
+}
diff --git a/src/components/cluster/BootstrapProgress.tsx b/src/components/cluster/BootstrapProgress.tsx
new file mode 100644
index 0000000..b8db759
--- /dev/null
+++ b/src/components/cluster/BootstrapProgress.tsx
@@ -0,0 +1,115 @@
+import { CheckCircle, AlertCircle, Loader2, Clock } from 'lucide-react';
+import { Card } from '../ui/card';
+import { Badge } from '../ui/badge';
+import { TroubleshootingPanel } from './TroubleshootingPanel';
+import type { BootstrapProgress as BootstrapProgressType } from '../../services/api/types';
+
+interface BootstrapProgressProps {
+ progress: BootstrapProgressType;
+ error?: string;
+}
+
+const BOOTSTRAP_STEPS = [
+ { id: 0, name: 'Bootstrap Command', description: 'Running talosctl bootstrap' },
+ { id: 1, name: 'etcd Health', description: 'Verifying etcd cluster health' },
+ { id: 2, name: 'VIP Assignment', description: 'Waiting for VIP assignment' },
+ { id: 3, name: 'Control Plane', description: 'Waiting for control plane components' },
+ { id: 4, name: 'API Server', description: 'Waiting for API server on VIP' },
+ { id: 5, name: 'Cluster Access', description: 'Configuring cluster access' },
+ { id: 6, name: 'Node Registration', description: 'Verifying node registration' },
+];
+
+export function BootstrapProgress({ progress, error }: BootstrapProgressProps) {
+ const getStepIcon = (stepId: number) => {
+ if (stepId < progress.current_step) {
+ return
+
+ {BOOTSTRAP_STEPS.map((step) => {
+ const status = getStepStatus(step.id);
+ const isActive = step.id === progress.current_step;
+
+ return (
+
+
+
{getStepIcon(step.id)}
+
+
+
{step.name}
+ {status === 'completed' && (
+
+ Complete
+
+ )}
+ {status === 'running' && !error && (
+
+ In Progress
+
+ )}
+ {status === 'error' && (
+
+ Failed
+
+ )}
+
+
{step.description}
+ {isActive && !error && (
+
+
+
+ Attempt {progress.attempt} of {progress.max_attempts}
+
+
+
+
+ )}
+
+
+ );
+ })}
+
+
+ {error &&
}
+
= {
+ 1: [
+ 'Check etcd service status with: talosctl -n service etcd',
+ 'View etcd logs: talosctl -n logs etcd',
+ 'Verify bootstrap completed successfully',
+ ],
+ 2: [
+ 'Check VIP controller logs: kubectl logs -n kube-system -l k8s-app=kube-vip',
+ 'Verify network configuration allows VIP assignment',
+ 'Check that VIP range is configured correctly in cluster config',
+ ],
+ 3: [
+ 'Check kubelet logs: talosctl -n logs kubelet',
+ 'Verify static pod manifests: talosctl -n list /etc/kubernetes/manifests',
+ 'Try restarting kubelet: talosctl -n service kubelet restart',
+ ],
+ 4: [
+ 'Check API server logs: kubectl logs -n kube-system kube-apiserver-',
+ 'Verify API server is running: talosctl -n service kubelet',
+ 'Test API server on node IP: curl -k https://:6443/healthz',
+ ],
+ 5: [
+ 'Check API server logs for connection errors',
+ 'Test API server on node IP first: curl -k https://:6443/healthz',
+ 'Verify network connectivity to VIP address',
+ ],
+ 6: [
+ 'Check kubelet logs: talosctl -n logs kubelet',
+ 'Verify API server is accessible: kubectl get nodes',
+ 'Check network connectivity between node and API server',
+ ],
+};
+
+export function TroubleshootingPanel({ step }: TroubleshootingPanelProps) {
+ const steps = TROUBLESHOOTING_STEPS[step] || [
+ 'Check logs for detailed error information',
+ 'Verify network connectivity',
+ 'Ensure all prerequisites are met',
+ ];
+
+ return (
+
+
+
Troubleshooting Steps
+
+ {steps.map((troubleshootingStep, index) => (
+ {troubleshootingStep}
+ ))}
+
+
+ );
+}
diff --git a/src/components/cluster/index.ts b/src/components/cluster/index.ts
new file mode 100644
index 0000000..b6f220b
--- /dev/null
+++ b/src/components/cluster/index.ts
@@ -0,0 +1,3 @@
+export { BootstrapModal } from './BootstrapModal';
+export { BootstrapProgress } from './BootstrapProgress';
+export { TroubleshootingPanel } from './TroubleshootingPanel';
diff --git a/src/components/nodes/HardwareDetectionDisplay.tsx b/src/components/nodes/HardwareDetectionDisplay.tsx
new file mode 100644
index 0000000..fea76d5
--- /dev/null
+++ b/src/components/nodes/HardwareDetectionDisplay.tsx
@@ -0,0 +1,90 @@
+import type { HardwareInfo } from '../../services/api/types';
+
+interface HardwareDetectionDisplayProps {
+ detection: HardwareInfo;
+}
+
+function formatBytes(bytes: number): string {
+ if (bytes === 0) return '0 B';
+
+ const k = 1024;
+ const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+ return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
+
+export function HardwareDetectionDisplay({ detection }: HardwareDetectionDisplayProps) {
+ return (
+
+
+
+
+
+
IP Address
+
{detection.ip}
+
+
+
+ {detection.interface && (
+
+
+
+
+
Network Interface
+
{detection.interface}
+
+
+ )}
+
+ {detection.disks && detection.disks.length > 0 && (
+
+
+
+
+
Available Disks
+
+ {detection.disks.map((disk) => (
+
+ {disk.path}
+ {disk.size > 0 && (
+
+ ({formatBytes(disk.size)})
+
+ )}
+
+ ))}
+
+
+
+ )}
+
= {
+ hostname: 'existing-control-1',
+ role: 'controlplane',
+ disk: '/dev/nvme0n1',
+ targetIp: '192.168.1.105',
+ currentIp: '192.168.1.60',
+ interface: 'eth1',
+ schematicId: 'existing-schematic-456',
+ maintenance: false,
+ };
+
+ render(
+ = {
+ hostname: 'legacy-node-name',
+ role: 'controlplane',
+ };
+
+ render(
+ = {
+ hostname: 'existing-node',
+ role: 'controlplane',
+ targetIp: '10.0.0.50',
+ };
+
+ render(
+ = {
+ hostname: 'existing-control-1',
+ role: 'controlplane',
+ disk: '/dev/nvme0n1',
+ targetIp: '192.168.1.105',
+ currentIp: '192.168.1.60',
+ interface: 'eth0',
+ schematicId: 'existing-schematic-456',
+ maintenance: false,
+ };
+
+ render(
+ = {
+ hostname: 'existing-control-1',
+ role: 'controlplane',
+ disk: '/dev/nvme0n1', // Different from detection
+ interface: 'eth0',
+ };
+
+ render(
+ = {
+ hostname: 'existing-control-1',
+ role: 'controlplane',
+ disk: '/dev/sda',
+ interface: 'eth1', // Different from detection
+ };
+
+ render(
+ = {
+ hostname: 'existing-control-1',
+ role: 'controlplane',
+ disk: '/dev/nvme0n1',
+ interface: 'eth1',
+ targetIp: '192.168.1.105',
+ currentIp: '192.168.1.60',
+ schematicId: 'existing-schematic',
+ maintenance: false,
+ };
+
+ render(
+ = {
+ hostname: 'existing-node',
+ role: 'controlplane',
+ disk: '/dev/nvme0n1', // Should win over detection
+ interface: 'eth0',
+ };
+
+ render(
+ = {
+ hostname: 'existing-node',
+ role: 'controlplane',
+ disk: '/dev/sda',
+ interface: 'eth1', // Should win over detection
+ };
+
+ render(
+ = {
+ schematicId: 'custom-schematic',
+ };
+
+ render(
+ ;
+ detection?: HardwareInfo;
+ onSubmit: (data: NodeFormData) => Promise;
+ onApply?: (data: NodeFormData) => Promise;
+ submitLabel?: string;
+ showApplyButton?: boolean;
+ instanceName?: string;
+}
+
+function getInitialValues(
+ initial?: Partial,
+ detection?: HardwareInfo,
+ nodes?: Array<{ role: string; hostname?: string }>,
+ hostnamePrefix?: string
+): NodeFormData {
+ // Determine default role: controlplane unless there are already 3+ control nodes
+ let defaultRole: 'controlplane' | 'worker' = 'controlplane';
+ if (nodes) {
+ const controlPlaneCount = nodes.filter(n => n.role === 'controlplane').length;
+ if (controlPlaneCount >= 3) {
+ defaultRole = 'worker';
+ }
+ }
+
+ const role = initial?.role || defaultRole;
+
+ // Generate default hostname based on role and existing nodes
+ let defaultHostname = '';
+ if (!initial?.hostname) {
+ const prefix = hostnamePrefix || '';
+
+ // Generate a hostname even if nodes is not loaded yet
+ // The useEffect will fix it later when data is available
+ if (role === 'controlplane') {
+ if (nodes) {
+ // Find next control plane number
+ const controlNumbers = nodes
+ .filter(n => n.role === 'controlplane')
+ .map(n => {
+ const match = n.hostname?.match(new RegExp(`${prefix}control-(\\d+)$`));
+ return match ? parseInt(match[1], 10) : null;
+ })
+ .filter((n): n is number => n !== null);
+
+ const nextNumber = controlNumbers.length > 0 ? Math.max(...controlNumbers) + 1 : 1;
+ defaultHostname = `${prefix}control-${nextNumber}`;
+ } else {
+ // No nodes loaded yet, default to 1
+ defaultHostname = `${prefix}control-1`;
+ }
+ } else {
+ if (nodes) {
+ // Find next worker number
+ const workerNumbers = nodes
+ .filter(n => n.role === 'worker')
+ .map(n => {
+ const match = n.hostname?.match(new RegExp(`${prefix}worker-(\\d+)$`));
+ return match ? parseInt(match[1], 10) : null;
+ })
+ .filter((n): n is number => n !== null);
+
+ const nextNumber = workerNumbers.length > 0 ? Math.max(...workerNumbers) + 1 : 1;
+ defaultHostname = `${prefix}worker-${nextNumber}`;
+ } else {
+ // No nodes loaded yet, default to 1
+ defaultHostname = `${prefix}worker-1`;
+ }
+ }
+ }
+
+ // Auto-select first disk if none specified
+ let defaultDisk = initial?.disk || detection?.selected_disk || '';
+ if (!defaultDisk && detection?.disks && detection.disks.length > 0) {
+ defaultDisk = detection.disks[0].path;
+ }
+
+ // Auto-select first interface if none specified
+ let defaultInterface = initial?.interface || detection?.interface || '';
+ if (!defaultInterface && detection?.interfaces && detection.interfaces.length > 0) {
+ defaultInterface = detection.interfaces[0];
+ }
+
+ return {
+ hostname: initial?.hostname || defaultHostname,
+ role,
+ disk: defaultDisk,
+ targetIp: initial?.targetIp || '', // Don't auto-fill targetIp from detection
+ currentIp: initial?.currentIp || detection?.ip || '', // Auto-fill from detection
+ interface: defaultInterface,
+ schematicId: initial?.schematicId || '',
+ maintenance: initial?.maintenance ?? true,
+ };
+}
+
+export function NodeForm({
+ initialValues,
+ detection,
+ onSubmit,
+ onApply,
+ submitLabel = 'Save',
+ showApplyButton = false,
+ instanceName,
+}: NodeFormProps) {
+ // Track if we're editing an existing node (has initial hostname from backend)
+ const isExistingNode = Boolean(initialValues?.hostname);
+ const { config: instanceConfig } = useInstanceConfig(instanceName);
+ const { nodes } = useNodes(instanceName);
+
+ const hostnamePrefix = instanceConfig?.cluster?.hostnamePrefix || '';
+
+ const {
+ register,
+ handleSubmit,
+ setValue,
+ watch,
+ control,
+ reset,
+ formState: { errors, isSubmitting },
+ } = useForm({
+ defaultValues: getInitialValues(initialValues, detection, nodes, hostnamePrefix),
+ });
+
+ const schematicId = watch('schematicId');
+ const role = watch('role');
+ const hostname = watch('hostname');
+
+ // Reset form when initialValues change (e.g., switching to configure a different node)
+ // This ensures select boxes and all fields show the current values
+ // Use a ref to track the hostname to avoid infinite loops from object reference changes
+ const prevHostnameRef = useRef(undefined);
+ useEffect(() => {
+ const currentHostname = initialValues?.hostname;
+ // Only reset if the hostname actually changed (switching between nodes)
+ if (currentHostname !== prevHostnameRef.current) {
+ prevHostnameRef.current = currentHostname;
+ const newValues = getInitialValues(initialValues, detection, nodes, hostnamePrefix);
+ reset(newValues);
+ }
+ }, [initialValues, detection, nodes, hostnamePrefix, reset]);
+
+ // Set default role based on existing control plane nodes
+ useEffect(() => {
+ if (!initialValues?.role && nodes) {
+ const controlPlaneCount = nodes.filter(n => n.role === 'controlplane').length;
+ const defaultRole: 'controlplane' | 'worker' = controlPlaneCount >= 3 ? 'worker' : 'controlplane';
+ const currentRole = watch('role');
+
+ // Only update if the current role is still the initial default and we now have node data
+ if (currentRole === 'controlplane' && controlPlaneCount >= 3) {
+ setValue('role', defaultRole);
+ }
+ }
+ }, [nodes, initialValues?.role, setValue, watch]);
+
+ // Pre-populate schematic ID from cluster config if available
+ useEffect(() => {
+ if (!schematicId && instanceConfig?.cluster?.nodes?.talos?.schematicId) {
+ setValue('schematicId', instanceConfig.cluster.nodes.talos.schematicId);
+ }
+ }, [instanceConfig, schematicId, setValue]);
+
+ // Auto-generate hostname when role changes (only for NEW nodes without initial hostname)
+ useEffect(() => {
+ if (!nodes) return;
+
+ // Don't auto-generate if this is an existing node with initial hostname
+ // This check must happen FIRST to prevent regeneration when hostnamePrefix loads
+ if (isExistingNode) return;
+
+ const prefix = hostnamePrefix || '';
+ const currentHostname = watch('hostname');
+
+ if (!currentHostname) return;
+
+ // Check if current hostname follows our naming pattern WITH prefix
+ const hostnameMatch = currentHostname.match(new RegExp(`^${prefix}(control|worker)-(\\d+)$`));
+
+ // If no match with prefix, check if it matches WITHOUT prefix (generated before prefix was loaded)
+ const hostnameMatchNoPrefix = !hostnameMatch && prefix ?
+ currentHostname.match(/^(control|worker)-(\d+)$/) : null;
+
+ // Check if this is a generated hostname (either with or without prefix)
+ const isGeneratedHostname = hostnameMatch !== null || hostnameMatchNoPrefix !== null;
+
+ // Use whichever match succeeded
+ const activeMatch = hostnameMatch || hostnameMatchNoPrefix;
+
+ // Check if the role prefix in the hostname matches the current role
+ const hostnameRolePrefix = activeMatch?.[1]; // 'control' or 'worker'
+ const expectedRolePrefix = role === 'controlplane' ? 'control' : 'worker';
+ const roleMatches = hostnameRolePrefix === expectedRolePrefix;
+
+ // Check if the hostname has the expected prefix
+ const hasCorrectPrefix = hostnameMatch !== null;
+
+ // Auto-update hostname if it was previously auto-generated AND either:
+ // 1. The role prefix doesn't match (e.g., hostname is "control-1" but role is "worker")
+ // 2. The hostname is missing the prefix (e.g., "control-1" instead of "test-control-1")
+ // 3. The number needs updating (existing logic)
+ if (isGeneratedHostname && (!roleMatches || !hasCorrectPrefix)) {
+ // Role changed, need to regenerate with correct prefix
+ if (role === 'controlplane') {
+ const controlNumbers = nodes
+ .filter(n => n.role === 'controlplane')
+ .map(n => {
+ const match = n.hostname?.match(new RegExp(`${prefix}control-(\\d+)$`));
+ return match ? parseInt(match[1], 10) : null;
+ })
+ .filter((n): n is number => n !== null);
+
+ const nextNumber = controlNumbers.length > 0 ? Math.max(...controlNumbers) + 1 : 1;
+ const newHostname = `${prefix}control-${nextNumber}`;
+ setValue('hostname', newHostname);
+ } else {
+ const workerNumbers = nodes
+ .filter(n => n.role === 'worker')
+ .map(n => {
+ const match = n.hostname?.match(new RegExp(`${prefix}worker-(\\d+)$`));
+ return match ? parseInt(match[1], 10) : null;
+ })
+ .filter((n): n is number => n !== null);
+
+ const nextNumber = workerNumbers.length > 0 ? Math.max(...workerNumbers) + 1 : 1;
+ const newHostname = `${prefix}worker-${nextNumber}`;
+ setValue('hostname', newHostname);
+ }
+ } else if (isGeneratedHostname && roleMatches && hasCorrectPrefix) {
+ // Role matches and prefix is correct, but check if the number needs updating (original logic)
+ if (role === 'controlplane') {
+ const controlNumbers = nodes
+ .filter(n => n.role === 'controlplane')
+ .map(n => {
+ const match = n.hostname?.match(new RegExp(`${prefix}control-(\\d+)$`));
+ return match ? parseInt(match[1], 10) : null;
+ })
+ .filter((n): n is number => n !== null);
+
+ const nextNumber = controlNumbers.length > 0 ? Math.max(...controlNumbers) + 1 : 1;
+ const newHostname = `${prefix}control-${nextNumber}`;
+ if (currentHostname !== newHostname) {
+ setValue('hostname', newHostname);
+ }
+ } else {
+ const workerNumbers = nodes
+ .filter(n => n.role === 'worker')
+ .map(n => {
+ const match = n.hostname?.match(new RegExp(`${prefix}worker-(\\d+)$`));
+ return match ? parseInt(match[1], 10) : null;
+ })
+ .filter((n): n is number => n !== null);
+
+ const nextNumber = workerNumbers.length > 0 ? Math.max(...workerNumbers) + 1 : 1;
+ const newHostname = `${prefix}worker-${nextNumber}`;
+ if (currentHostname !== newHostname) {
+ setValue('hostname', newHostname);
+ }
+ }
+ }
+ }, [role, nodes, hostnamePrefix, setValue, watch, isExistingNode]);
+
+ // Auto-calculate target IP for control plane nodes
+ useEffect(() => {
+ // Skip if this is an existing node (configure mode)
+ if (initialValues?.targetIp) return;
+
+ const clusterConfig = instanceConfig?.cluster as any;
+ const vip = clusterConfig?.nodes?.control?.vip as string | undefined;
+
+ if (role === 'controlplane' && vip) {
+
+ // Parse VIP to get base and last octet
+ const vipParts = vip.split('.');
+ if (vipParts.length !== 4) return;
+
+ const vipLastOctet = parseInt(vipParts[3], 10);
+ if (isNaN(vipLastOctet)) return;
+
+ const vipPrefix = vipParts.slice(0, 3).join('.');
+
+ // Find all control plane IPs in the same subnet range
+ const usedOctets = nodes
+ .filter(node => node.role === 'controlplane' && node.target_ip)
+ .map(node => {
+ const parts = node.target_ip.split('.');
+ if (parts.length !== 4) return null;
+ // Only consider IPs in the same subnet
+ if (parts.slice(0, 3).join('.') !== vipPrefix) return null;
+ const octet = parseInt(parts[3], 10);
+ return isNaN(octet) ? null : octet;
+ })
+ .filter((octet): octet is number => octet !== null && octet > vipLastOctet);
+
+ // Find the first available IP after VIP
+ let nextOctet = vipLastOctet + 1;
+
+ // Sort used octets to find gaps
+ const sortedOctets = [...usedOctets].sort((a, b) => a - b);
+
+ // Check for gaps in the sequence starting from VIP+1
+ for (const usedOctet of sortedOctets) {
+ if (usedOctet === nextOctet) {
+ nextOctet++;
+ } else if (usedOctet > nextOctet) {
+ // Found a gap, use it
+ break;
+ }
+ }
+
+ // Ensure we don't exceed valid IP range
+ if (nextOctet > 254) {
+ console.warn('No available IPs in subnet after VIP');
+ return;
+ }
+
+ // Set the calculated IP
+ setValue('targetIp', `${vipPrefix}.${nextOctet}`);
+ } else if (role === 'worker') {
+ // For new worker nodes, clear target IP (let user set if needed)
+ const currentTargetIp = watch('targetIp');
+ // Only clear if it looks like an auto-calculated IP (matches VIP pattern)
+ if (currentTargetIp && vip) {
+ const vipPrefix = vip.split('.').slice(0, 3).join('.');
+ if (currentTargetIp.startsWith(vipPrefix)) {
+ setValue('targetIp', '');
+ }
+ }
+ }
+ }, [role, instanceConfig, nodes, setValue, watch, initialValues?.targetIp]);
+
+ // Build disk options from both detection and initial values
+ const diskOptions = (() => {
+ const options = [...(detection?.disks || [])];
+ // If configuring existing node, ensure its disk is in options
+ if (initialValues?.disk && !options.some(d => d.path === initialValues.disk)) {
+ options.push({ path: initialValues.disk, size: 0 });
+ }
+ return options;
+ })();
+
+ // Build interface options from both detection and initial values
+ const interfaceOptions = (() => {
+ const options = [...(detection?.interfaces || [])];
+ // If configuring existing node, ensure its interface is in options
+ if (initialValues?.interface && !options.includes(initialValues.interface)) {
+ options.push(initialValues.interface);
+ }
+ // Also add detection.interface if present
+ if (detection?.interface && !options.includes(detection.interface)) {
+ options.push(detection.interface);
+ }
+ return options;
+ })();
+
+ return (
+
+ );
+}
+
+function formatBytes(bytes: number): string {
+ if (bytes === 0) return '0 B';
+
+ const k = 1024;
+ const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+ return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${sizes[i]}`;
+}
diff --git a/src/components/nodes/NodeForm.unit.test.tsx b/src/components/nodes/NodeForm.unit.test.tsx
new file mode 100644
index 0000000..8cddb51
--- /dev/null
+++ b/src/components/nodes/NodeForm.unit.test.tsx
@@ -0,0 +1,392 @@
+import { describe, it, expect } from 'vitest';
+import type { NodeFormData } from './NodeForm';
+import { createMockNode, createMockNodes, createMockHardwareInfo } from '../../test/utils/nodeFormTestUtils';
+import type { HardwareInfo } from '../../services/api/types';
+
+function getInitialValues(
+ initial?: Partial,
+ detection?: HardwareInfo,
+ nodes?: Array<{ role: string; hostname?: string }>,
+ hostnamePrefix?: string
+): NodeFormData {
+ let defaultRole: 'controlplane' | 'worker' = 'controlplane';
+ if (nodes) {
+ const controlPlaneCount = nodes.filter(n => n.role === 'controlplane').length;
+ if (controlPlaneCount >= 3) {
+ defaultRole = 'worker';
+ }
+ }
+
+ const role = initial?.role || defaultRole;
+
+ let defaultHostname = '';
+ if (!initial?.hostname && nodes && hostnamePrefix !== undefined) {
+ const prefix = hostnamePrefix || '';
+ if (role === 'controlplane') {
+ const controlNumbers = nodes
+ .filter(n => n.role === 'controlplane')
+ .map(n => {
+ const match = n.hostname?.match(new RegExp(`${prefix}control-(\\d+)$`));
+ return match ? parseInt(match[1], 10) : null;
+ })
+ .filter((n): n is number => n !== null);
+
+ const nextNumber = controlNumbers.length > 0 ? Math.max(...controlNumbers) + 1 : 1;
+ defaultHostname = `${prefix}control-${nextNumber}`;
+ } else {
+ const workerNumbers = nodes
+ .filter(n => n.role === 'worker')
+ .map(n => {
+ const match = n.hostname?.match(new RegExp(`${prefix}worker-(\\d+)$`));
+ return match ? parseInt(match[1], 10) : null;
+ })
+ .filter((n): n is number => n !== null);
+
+ const nextNumber = workerNumbers.length > 0 ? Math.max(...workerNumbers) + 1 : 1;
+ defaultHostname = `${prefix}worker-${nextNumber}`;
+ }
+ }
+
+ let defaultDisk = initial?.disk || detection?.selected_disk || '';
+ if (!defaultDisk && detection?.disks && detection.disks.length > 0) {
+ defaultDisk = detection.disks[0].path;
+ }
+
+ let defaultInterface = initial?.interface || detection?.interface || '';
+ if (!defaultInterface && detection?.interfaces && detection.interfaces.length > 0) {
+ defaultInterface = detection.interfaces[0];
+ }
+
+ return {
+ hostname: initial?.hostname || defaultHostname,
+ role,
+ disk: defaultDisk,
+ targetIp: initial?.targetIp || '',
+ currentIp: initial?.currentIp || detection?.ip || '',
+ interface: defaultInterface,
+ schematicId: initial?.schematicId || '',
+ maintenance: initial?.maintenance ?? true,
+ };
+}
+
+describe('getInitialValues', () => {
+ describe('Role Selection', () => {
+ it('defaults to controlplane when no nodes exist', () => {
+ const result = getInitialValues(undefined, undefined, [], 'test-');
+ expect(result.role).toBe('controlplane');
+ });
+
+ it('defaults to controlplane when fewer than 3 control nodes exist', () => {
+ const nodes = createMockNodes(2, 'controlplane');
+ const result = getInitialValues(undefined, undefined, nodes, 'test-');
+ expect(result.role).toBe('controlplane');
+ });
+
+ it('defaults to worker when 3 or more control nodes exist', () => {
+ const nodes = createMockNodes(3, 'controlplane');
+ const result = getInitialValues(undefined, undefined, nodes, 'test-');
+ expect(result.role).toBe('worker');
+ });
+
+ it('respects explicit role in initial values', () => {
+ const nodes = createMockNodes(3, 'controlplane');
+ const result = getInitialValues({ role: 'controlplane' }, undefined, nodes, 'test-');
+ expect(result.role).toBe('controlplane');
+ });
+ });
+
+ describe('Hostname Generation', () => {
+ it('generates first control node hostname', () => {
+ const result = getInitialValues(undefined, undefined, [], 'test-');
+ expect(result.hostname).toBe('test-control-1');
+ });
+
+ it('generates second control node hostname', () => {
+ const nodes = [createMockNode({ hostname: 'test-control-1', role: 'controlplane' })];
+ const result = getInitialValues(undefined, undefined, nodes, 'test-');
+ expect(result.hostname).toBe('test-control-2');
+ });
+
+ it('generates third control node hostname', () => {
+ const nodes = [
+ createMockNode({ hostname: 'test-control-1', role: 'controlplane' }),
+ createMockNode({ hostname: 'test-control-2', role: 'controlplane' }),
+ ];
+ const result = getInitialValues(undefined, undefined, nodes, 'test-');
+ expect(result.hostname).toBe('test-control-3');
+ });
+
+ it('generates first worker node hostname', () => {
+ const nodes = createMockNodes(3, 'controlplane');
+ const result = getInitialValues({ role: 'worker' }, undefined, nodes, 'test-');
+ expect(result.hostname).toBe('test-worker-1');
+ });
+
+ it('generates second worker node hostname', () => {
+ const nodes = [
+ ...createMockNodes(3, 'controlplane'),
+ createMockNode({ hostname: 'test-worker-1', role: 'worker' }),
+ ];
+ const result = getInitialValues({ role: 'worker' }, undefined, nodes, 'test-');
+ expect(result.hostname).toBe('test-worker-2');
+ });
+
+ it('handles empty hostname prefix', () => {
+ const result = getInitialValues(undefined, undefined, [], '');
+ expect(result.hostname).toBe('control-1');
+ });
+
+ it('handles gaps in hostname numbering for control nodes', () => {
+ const nodes = [
+ createMockNode({ hostname: 'test-control-1', role: 'controlplane' }),
+ createMockNode({ hostname: 'test-control-3', role: 'controlplane' }),
+ ];
+ const result = getInitialValues(undefined, undefined, nodes, 'test-');
+ expect(result.hostname).toBe('test-control-4');
+ });
+
+ it('handles gaps in hostname numbering for worker nodes', () => {
+ const nodes = [
+ ...createMockNodes(3, 'controlplane'),
+ createMockNode({ hostname: 'test-worker-1', role: 'worker' }),
+ createMockNode({ hostname: 'test-worker-5', role: 'worker' }),
+ ];
+ const result = getInitialValues({ role: 'worker' }, undefined, nodes, 'test-');
+ expect(result.hostname).toBe('test-worker-6');
+ });
+
+ it('preserves initial hostname when provided', () => {
+ const result = getInitialValues(
+ { hostname: 'custom-hostname' },
+ undefined,
+ [],
+ 'test-'
+ );
+ expect(result.hostname).toBe('custom-hostname');
+ });
+
+ it('does not generate hostname when hostnamePrefix is undefined', () => {
+ const result = getInitialValues(undefined, undefined, [], undefined);
+ expect(result.hostname).toBe('');
+ });
+
+ it('does not generate hostname when initial hostname is provided', () => {
+ const result = getInitialValues(
+ { hostname: 'existing-node' },
+ undefined,
+ [],
+ 'test-'
+ );
+ expect(result.hostname).toBe('existing-node');
+ });
+ });
+
+ describe('Disk Selection', () => {
+ it('uses disk from initial values', () => {
+ const result = getInitialValues(
+ { disk: '/dev/nvme0n1' },
+ createMockHardwareInfo(),
+ [],
+ 'test-'
+ );
+ expect(result.disk).toBe('/dev/nvme0n1');
+ });
+
+ it('uses selected_disk from detection', () => {
+ const detection = createMockHardwareInfo({ selected_disk: '/dev/sdb' });
+ const result = getInitialValues(undefined, detection, [], 'test-');
+ expect(result.disk).toBe('/dev/sdb');
+ });
+
+ it('auto-selects first disk from detection when no selected_disk', () => {
+ const detection = createMockHardwareInfo({ selected_disk: undefined });
+ const result = getInitialValues(undefined, detection, [], 'test-');
+ expect(result.disk).toBe('/dev/sda');
+ });
+
+ it('returns empty string when no disk info available', () => {
+ const result = getInitialValues(undefined, undefined, [], 'test-');
+ expect(result.disk).toBe('');
+ });
+
+ it('returns empty string when detection has no disks', () => {
+ const detection = createMockHardwareInfo({ disks: [], selected_disk: undefined });
+ const result = getInitialValues(undefined, detection, [], 'test-');
+ expect(result.disk).toBe('');
+ });
+ });
+
+ describe('Interface Selection', () => {
+ it('uses interface from initial values', () => {
+ const result = getInitialValues(
+ { interface: 'eth2' },
+ createMockHardwareInfo(),
+ [],
+ 'test-'
+ );
+ expect(result.interface).toBe('eth2');
+ });
+
+ it('uses interface from detection', () => {
+ const detection = createMockHardwareInfo({ interface: 'eth1' });
+ const result = getInitialValues(undefined, detection, [], 'test-');
+ expect(result.interface).toBe('eth1');
+ });
+
+ it('auto-selects first interface from detection when no interface set', () => {
+ const detection = createMockHardwareInfo({ interface: undefined });
+ const result = getInitialValues(undefined, detection, [], 'test-');
+ expect(result.interface).toBe('eth0');
+ });
+
+ it('returns empty string when no interface info available', () => {
+ const result = getInitialValues(undefined, undefined, [], 'test-');
+ expect(result.interface).toBe('');
+ });
+
+ it('returns empty string when detection has no interfaces', () => {
+ const detection = createMockHardwareInfo({ interface: undefined, interfaces: [] });
+ const result = getInitialValues(undefined, detection, [], 'test-');
+ expect(result.interface).toBe('');
+ });
+ });
+
+ describe('IP Address Handling', () => {
+ it('does not auto-fill targetIp', () => {
+ const result = getInitialValues(undefined, createMockHardwareInfo(), [], 'test-');
+ expect(result.targetIp).toBe('');
+ });
+
+ it('preserves initial targetIp', () => {
+ const result = getInitialValues(
+ { targetIp: '192.168.1.200' },
+ createMockHardwareInfo(),
+ [],
+ 'test-'
+ );
+ expect(result.targetIp).toBe('192.168.1.200');
+ });
+
+ it('auto-fills currentIp from detection', () => {
+ const detection = createMockHardwareInfo({ ip: '192.168.1.75' });
+ const result = getInitialValues(undefined, detection, [], 'test-');
+ expect(result.currentIp).toBe('192.168.1.75');
+ });
+
+ it('preserves initial currentIp over detection', () => {
+ const detection = createMockHardwareInfo({ ip: '192.168.1.75' });
+ const result = getInitialValues({ currentIp: '192.168.1.80' }, detection, [], 'test-');
+ expect(result.currentIp).toBe('192.168.1.80');
+ });
+
+ it('returns empty currentIp when no detection', () => {
+ const result = getInitialValues(undefined, undefined, [], 'test-');
+ expect(result.currentIp).toBe('');
+ });
+ });
+
+ describe('SchematicId Handling', () => {
+ it('uses initial schematicId when provided', () => {
+ const result = getInitialValues({ schematicId: 'custom-123' }, undefined, [], 'test-');
+ expect(result.schematicId).toBe('custom-123');
+ });
+
+ it('returns empty string when no initial schematicId', () => {
+ const result = getInitialValues(undefined, undefined, [], 'test-');
+ expect(result.schematicId).toBe('');
+ });
+ });
+
+ describe('Maintenance Mode', () => {
+ it('defaults to true when not provided', () => {
+ const result = getInitialValues(undefined, undefined, [], 'test-');
+ expect(result.maintenance).toBe(true);
+ });
+
+ it('respects explicit true value', () => {
+ const result = getInitialValues({ maintenance: true }, undefined, [], 'test-');
+ expect(result.maintenance).toBe(true);
+ });
+
+ it('respects explicit false value', () => {
+ const result = getInitialValues({ maintenance: false }, undefined, [], 'test-');
+ expect(result.maintenance).toBe(false);
+ });
+ });
+
+ describe('Combined Scenarios', () => {
+ it('handles adding first control node with full detection', () => {
+ const detection = createMockHardwareInfo();
+ const result = getInitialValues(undefined, detection, [], 'prod-');
+
+ expect(result).toEqual({
+ hostname: 'prod-control-1',
+ role: 'controlplane',
+ disk: '/dev/sda',
+ targetIp: '',
+ currentIp: '192.168.1.50',
+ interface: 'eth0',
+ schematicId: '',
+ maintenance: true,
+ });
+ });
+
+ it('handles configuring existing node (all initial values)', () => {
+ const initial: Partial = {
+ hostname: 'existing-control-1',
+ role: 'controlplane',
+ disk: '/dev/nvme0n1',
+ targetIp: '192.168.1.105',
+ currentIp: '192.168.1.60',
+ interface: 'eth1',
+ schematicId: 'existing-schematic-456',
+ maintenance: false,
+ };
+
+ const result = getInitialValues(initial, undefined, [], 'test-');
+
+ expect(result).toEqual(initial);
+ });
+
+ it('handles adding second control node with partial detection', () => {
+ const nodes = [createMockNode({ hostname: 'test-control-1', role: 'controlplane' })];
+ const detection = createMockHardwareInfo({
+ interfaces: ['enp0s1'],
+ interface: 'enp0s1'
+ });
+
+ const result = getInitialValues(undefined, detection, nodes, 'test-');
+
+ expect(result.hostname).toBe('test-control-2');
+ expect(result.role).toBe('controlplane');
+ expect(result.interface).toBe('enp0s1');
+ });
+
+ it('handles missing detection data', () => {
+ const result = getInitialValues(undefined, undefined, [], 'test-');
+
+ expect(result).toEqual({
+ hostname: 'test-control-1',
+ role: 'controlplane',
+ disk: '',
+ targetIp: '',
+ currentIp: '',
+ interface: '',
+ schematicId: '',
+ maintenance: true,
+ });
+ });
+
+ it('handles partial detection data', () => {
+ const detection: HardwareInfo = {
+ ip: '192.168.1.50',
+ };
+
+ const result = getInitialValues(undefined, detection, [], 'test-');
+
+ expect(result.currentIp).toBe('192.168.1.50');
+ expect(result.disk).toBe('');
+ expect(result.interface).toBe('');
+ });
+ });
+});
diff --git a/src/components/nodes/NodeFormDrawer.tsx b/src/components/nodes/NodeFormDrawer.tsx
new file mode 100644
index 0000000..cdd9ce9
--- /dev/null
+++ b/src/components/nodes/NodeFormDrawer.tsx
@@ -0,0 +1,67 @@
+import { Drawer } from '../ui/drawer';
+import { HardwareDetectionDisplay } from './HardwareDetectionDisplay';
+import { NodeForm, type NodeFormData } from './NodeForm';
+import { NodeStatusBadge } from './NodeStatusBadge';
+import type { Node, HardwareInfo } from '../../services/api/types';
+
+interface NodeFormDrawerProps {
+ open: boolean;
+ onClose: () => void;
+ mode: 'add' | 'configure';
+ node?: Node;
+ detection?: HardwareInfo;
+ onSubmit: (data: NodeFormData) => Promise;
+ onApply?: (data: NodeFormData) => Promise;
+ instanceName?: string;
+}
+
+export function NodeFormDrawer({
+ open,
+ onClose,
+ mode,
+ node,
+ detection,
+ onSubmit,
+ onApply,
+ instanceName,
+}: NodeFormDrawerProps) {
+ const title = mode === 'add' ? 'Add Node to Cluster' : `Configure ${node?.hostname}`;
+
+ return (
+
+ {detection && (
+
+
+ Hardware Detection Results
+
+
+
+ )}
+
+
+ );
+}
diff --git a/src/components/nodes/NodeStatusBadge.tsx b/src/components/nodes/NodeStatusBadge.tsx
new file mode 100644
index 0000000..74d4746
--- /dev/null
+++ b/src/components/nodes/NodeStatusBadge.tsx
@@ -0,0 +1,66 @@
+import {
+ MagnifyingGlassIcon,
+ ClockIcon,
+ ArrowPathIcon,
+ DocumentCheckIcon,
+ CheckCircleIcon,
+ HeartIcon,
+ WrenchScrewdriverIcon,
+ ExclamationTriangleIcon,
+ XCircleIcon,
+ QuestionMarkCircleIcon
+} from '@heroicons/react/24/outline';
+import type { Node } from '../../services/api/types';
+import { deriveNodeStatus } from '../../utils/deriveNodeStatus';
+import { statusDesigns } from '../../config/nodeStatus';
+
+interface NodeStatusBadgeProps {
+ node: Node;
+ showAction?: boolean;
+ compact?: boolean;
+}
+
+const iconComponents = {
+ MagnifyingGlassIcon,
+ ClockIcon,
+ ArrowPathIcon,
+ DocumentCheckIcon,
+ CheckCircleIcon,
+ HeartIcon,
+ WrenchScrewdriverIcon,
+ ExclamationTriangleIcon,
+ XCircleIcon,
+ QuestionMarkCircleIcon
+};
+
+export function NodeStatusBadge({ node, showAction = false, compact = false }: NodeStatusBadgeProps) {
+ const status = deriveNodeStatus(node);
+ const design = statusDesigns[status];
+ const IconComponent = iconComponents[design.icon as keyof typeof iconComponents];
+
+ const isSpinning = ['configuring', 'applying', 'provisioning', 'reprovisioning'].includes(status);
+
+ if (compact) {
+ return (
+
+ {design.label}
+
+ );
+ }
+
+ return (
+
+
+ {design.label}
+
+
{design.description}
+ {showAction && design.nextAction && (
+
+ → {design.nextAction}
+
+ )}
+
,
+ VariantProps {
+ onClose?: () => void;
+}
+
+const Alert = React.forwardRef(
+ ({ className, variant, onClose, children, ...props }, ref) => (
+
+ {children}
+ {onClose && (
+
+
+ )}
+
+ )
+);
+Alert.displayName = 'Alert';
+
+const AlertTitle = React.forwardRef<
+ HTMLParagraphElement,
+ React.HTMLAttributes
+>(({ className, ...props }, ref) => (
+
+>(({ className, ...props }, ref) => (
+
+));
+AlertDescription.displayName = 'AlertDescription';
+
+export { Alert, AlertTitle, AlertDescription };
diff --git a/src/components/ui/drawer.tsx b/src/components/ui/drawer.tsx
new file mode 100644
index 0000000..da35e4c
--- /dev/null
+++ b/src/components/ui/drawer.tsx
@@ -0,0 +1,95 @@
+import { useEffect, type ReactNode } from 'react';
+
+interface DrawerProps {
+ open: boolean;
+ onClose: () => void;
+ title: string;
+ children: ReactNode;
+ footer?: ReactNode;
+}
+
+export function Drawer({ open, onClose, title, children, footer }: DrawerProps) {
+ useEffect(() => {
+ const handleEscape = (e: KeyboardEvent) => {
+ if (e.key === 'Escape' && open) {
+ onClose();
+ }
+ };
+
+ document.addEventListener('keydown', handleEscape);
+ return () => document.removeEventListener('keydown', handleEscape);
+ }, [open, onClose]);
+
+ useEffect(() => {
+ if (open) {
+ document.body.style.overflow = 'hidden';
+ } else {
+ document.body.style.overflow = '';
+ }
+ return () => {
+ document.body.style.overflow = '';
+ };
+ }, [open]);
+
+ return (
+ <>
+ {/* Overlay with fade transition */}
+
+
+ {/* Drawer panel with slide transition */}
+
+
+ {/* Header */}
+
+
+ {/* Content */}
+
+ {children}
+
+
+ {/* Footer */}
+ {footer && (
+
+ {footer}
+
+ )}
+
+
= {
+ [NodeStatus.DISCOVERED]: {
+ status: NodeStatus.DISCOVERED,
+ color: "text-purple-700",
+ bgColor: "bg-purple-50",
+ icon: "MagnifyingGlassIcon",
+ label: "Discovered",
+ description: "Node detected on network but not yet configured",
+ nextAction: "Configure node settings",
+ severity: "info"
+ },
+
+ [NodeStatus.PENDING]: {
+ status: NodeStatus.PENDING,
+ color: "text-gray-700",
+ bgColor: "bg-gray-50",
+ icon: "ClockIcon",
+ label: "Pending",
+ description: "Node awaiting configuration",
+ nextAction: "Configure and apply settings",
+ severity: "neutral"
+ },
+
+ [NodeStatus.CONFIGURING]: {
+ status: NodeStatus.CONFIGURING,
+ color: "text-blue-700",
+ bgColor: "bg-blue-50",
+ icon: "ArrowPathIcon",
+ label: "Configuring",
+ description: "Node configuration in progress",
+ severity: "info"
+ },
+
+ [NodeStatus.CONFIGURED]: {
+ status: NodeStatus.CONFIGURED,
+ color: "text-indigo-700",
+ bgColor: "bg-indigo-50",
+ icon: "DocumentCheckIcon",
+ label: "Configured",
+ description: "Node configured but not yet applied",
+ nextAction: "Apply configuration to node",
+ severity: "info"
+ },
+
+ [NodeStatus.APPLYING]: {
+ status: NodeStatus.APPLYING,
+ color: "text-blue-700",
+ bgColor: "bg-blue-50",
+ icon: "ArrowPathIcon",
+ label: "Applying",
+ description: "Applying configuration to node",
+ severity: "info"
+ },
+
+ [NodeStatus.PROVISIONING]: {
+ status: NodeStatus.PROVISIONING,
+ color: "text-blue-700",
+ bgColor: "bg-blue-50",
+ icon: "ArrowPathIcon",
+ label: "Provisioning",
+ description: "Node is being provisioned with Talos",
+ severity: "info"
+ },
+
+ [NodeStatus.READY]: {
+ status: NodeStatus.READY,
+ color: "text-green-700",
+ bgColor: "bg-green-50",
+ icon: "CheckCircleIcon",
+ label: "Ready",
+ description: "Node is ready and operational",
+ severity: "success"
+ },
+
+ [NodeStatus.HEALTHY]: {
+ status: NodeStatus.HEALTHY,
+ color: "text-emerald-700",
+ bgColor: "bg-emerald-50",
+ icon: "HeartIcon",
+ label: "Healthy",
+ description: "Node is healthy and part of Kubernetes cluster",
+ severity: "success"
+ },
+
+ [NodeStatus.MAINTENANCE]: {
+ status: NodeStatus.MAINTENANCE,
+ color: "text-yellow-700",
+ bgColor: "bg-yellow-50",
+ icon: "WrenchScrewdriverIcon",
+ label: "Maintenance",
+ description: "Node is in maintenance mode",
+ severity: "warning"
+ },
+
+ [NodeStatus.REPROVISIONING]: {
+ status: NodeStatus.REPROVISIONING,
+ color: "text-orange-700",
+ bgColor: "bg-orange-50",
+ icon: "ArrowPathIcon",
+ label: "Reprovisioning",
+ description: "Node is being reprovisioned",
+ severity: "warning"
+ },
+
+ [NodeStatus.UNREACHABLE]: {
+ status: NodeStatus.UNREACHABLE,
+ color: "text-red-700",
+ bgColor: "bg-red-50",
+ icon: "ExclamationTriangleIcon",
+ label: "Unreachable",
+ description: "Node cannot be contacted",
+ nextAction: "Check network connectivity",
+ severity: "error"
+ },
+
+ [NodeStatus.DEGRADED]: {
+ status: NodeStatus.DEGRADED,
+ color: "text-orange-700",
+ bgColor: "bg-orange-50",
+ icon: "ExclamationTriangleIcon",
+ label: "Degraded",
+ description: "Node is experiencing issues",
+ nextAction: "Check node health",
+ severity: "warning"
+ },
+
+ [NodeStatus.FAILED]: {
+ status: NodeStatus.FAILED,
+ color: "text-red-700",
+ bgColor: "bg-red-50",
+ icon: "XCircleIcon",
+ label: "Failed",
+ description: "Node operation failed",
+ nextAction: "Review logs and retry",
+ severity: "error"
+ },
+
+ [NodeStatus.UNKNOWN]: {
+ status: NodeStatus.UNKNOWN,
+ color: "text-gray-700",
+ bgColor: "bg-gray-50",
+ icon: "QuestionMarkCircleIcon",
+ label: "Unknown",
+ description: "Node status cannot be determined",
+ nextAction: "Check node connection",
+ severity: "neutral"
+ },
+
+ [NodeStatus.ORPHANED]: {
+ status: NodeStatus.ORPHANED,
+ color: "text-purple-700",
+ bgColor: "bg-purple-50",
+ icon: "ExclamationTriangleIcon",
+ label: "Orphaned",
+ description: "Node exists in Kubernetes but not in configuration",
+ nextAction: "Add to configuration or remove from cluster",
+ severity: "warning"
+ }
+};
diff --git a/src/hooks/__tests__/useConfig.test.ts b/src/hooks/__tests__/useConfig.test.ts
index 5b57033..171457a 100644
--- a/src/hooks/__tests__/useConfig.test.ts
+++ b/src/hooks/__tests__/useConfig.test.ts
@@ -6,7 +6,7 @@ import { useConfig } from '../useConfig';
import { apiService } from '../../services/api-legacy';
// Mock the API service
-vi.mock('../../services/api', () => ({
+vi.mock('../../services/api-legacy', () => ({
apiService: {
getConfig: vi.fn(),
createConfig: vi.fn(),
@@ -56,7 +56,7 @@ describe('useConfig', () => {
},
};
- vi.mocked(apiService.getConfig).mockResolvedValue(mockConfigResponse);
+ (apiService.getConfig as ReturnType).mockResolvedValue(mockConfigResponse);
const { result } = renderHook(() => useConfig(), {
wrapper: createWrapper(),
@@ -81,7 +81,7 @@ describe('useConfig', () => {
message: 'No configuration found',
};
- vi.mocked(apiService.getConfig).mockResolvedValue(mockConfigResponse);
+ (apiService.getConfig as ReturnType).mockResolvedValue(mockConfigResponse);
const { result } = renderHook(() => useConfig(), {
wrapper: createWrapper(),
@@ -122,8 +122,8 @@ describe('useConfig', () => {
},
};
- vi.mocked(apiService.getConfig).mockResolvedValue(mockConfigResponse);
- vi.mocked(apiService.createConfig).mockResolvedValue(mockCreateResponse);
+ (apiService.getConfig as ReturnType).mockResolvedValue(mockConfigResponse);
+ (apiService.createConfig as ReturnType).mockResolvedValue(mockCreateResponse);
const { result } = renderHook(() => useConfig(), {
wrapper: createWrapper(),
@@ -149,7 +149,7 @@ describe('useConfig', () => {
it('should handle error when fetching config fails', async () => {
const mockError = new Error('Network error');
- vi.mocked(apiService.getConfig).mockRejectedValue(mockError);
+ (apiService.getConfig as ReturnType).mockRejectedValue(mockError);
const { result } = renderHook(() => useConfig(), {
wrapper: createWrapper(),
diff --git a/src/hooks/__tests__/useStatus.test.ts b/src/hooks/__tests__/useStatus.test.ts
index 953d541..d8b2432 100644
--- a/src/hooks/__tests__/useStatus.test.ts
+++ b/src/hooks/__tests__/useStatus.test.ts
@@ -6,7 +6,7 @@ import { useStatus } from '../useStatus';
import { apiService } from '../../services/api-legacy';
// Mock the API service
-vi.mock('../../services/api', () => ({
+vi.mock('../../services/api-legacy', () => ({
apiService: {
getStatus: vi.fn(),
},
@@ -40,7 +40,7 @@ describe('useStatus', () => {
timestamp: '2024-01-01T00:00:00Z',
};
- vi.mocked(apiService.getStatus).mockResolvedValue(mockStatus);
+ (apiService.getStatus as ReturnType).mockResolvedValue(mockStatus);
const { result } = renderHook(() => useStatus(), {
wrapper: createWrapper(),
@@ -60,7 +60,7 @@ describe('useStatus', () => {
it('should handle error when fetching status fails', async () => {
const mockError = new Error('Network error');
- vi.mocked(apiService.getStatus).mockRejectedValue(mockError);
+ (apiService.getStatus as ReturnType).mockRejectedValue(mockError);
const { result } = renderHook(() => useStatus(), {
wrapper: createWrapper(),
@@ -82,7 +82,7 @@ describe('useStatus', () => {
timestamp: '2024-01-01T00:00:00Z',
};
- vi.mocked(apiService.getStatus).mockResolvedValue(mockStatus);
+ (apiService.getStatus as ReturnType).mockResolvedValue(mockStatus);
const { result } = renderHook(() => useStatus(), {
wrapper: createWrapper(),
diff --git a/src/hooks/useNodes.ts b/src/hooks/useNodes.ts
index 3dccd72..a4f6dcf 100644
--- a/src/hooks/useNodes.ts
+++ b/src/hooks/useNodes.ts
@@ -13,10 +13,17 @@ export function useNodes(instanceName: string | null | undefined) {
const discoverMutation = useMutation({
mutationFn: (subnet: string) => nodesApi.discover(instanceName!, subnet),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['instances', instanceName, 'discovery'] });
+ },
});
const detectMutation = useMutation({
- mutationFn: () => nodesApi.detect(instanceName!),
+ mutationFn: (ip?: string) => nodesApi.detect(instanceName!, ip),
+ });
+
+ const autoDetectMutation = useMutation({
+ mutationFn: () => nodesApi.autoDetect(instanceName!),
});
const addMutation = useMutation({
@@ -24,6 +31,10 @@ export function useNodes(instanceName: string | null | undefined) {
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['instances', instanceName, 'nodes'] });
},
+ onError: (error) => {
+ // Don't refetch on error to avoid showing inconsistent state
+ console.error('Failed to add node:', error);
+ },
});
const updateMutation = useMutation({
@@ -39,6 +50,10 @@ export function useNodes(instanceName: string | null | undefined) {
onSuccess: () => {
queryClient.invalidateQueries({ queryKey: ['instances', instanceName, 'nodes'] });
},
+ onError: (error) => {
+ // Don't refetch on error to avoid showing inconsistent state
+ console.error('Failed to delete node:', error);
+ },
});
const applyMutation = useMutation({
@@ -49,6 +64,17 @@ export function useNodes(instanceName: string | null | undefined) {
mutationFn: () => nodesApi.fetchTemplates(instanceName!),
});
+ const cancelDiscoveryMutation = useMutation({
+ mutationFn: () => nodesApi.cancelDiscovery(instanceName!),
+ onSuccess: () => {
+ queryClient.invalidateQueries({ queryKey: ['instances', instanceName, 'discovery'] });
+ },
+ });
+
+ const getHardwareMutation = useMutation({
+ mutationFn: (ip: string) => nodesApi.getHardware(instanceName!, ip),
+ });
+
return {
nodes: nodesQuery.data?.nodes || [],
isLoading: nodesQuery.isLoading,
@@ -57,19 +83,32 @@ export function useNodes(instanceName: string | null | undefined) {
discover: discoverMutation.mutate,
isDiscovering: discoverMutation.isPending,
discoverResult: discoverMutation.data,
+ discoverError: discoverMutation.error,
detect: detectMutation.mutate,
isDetecting: detectMutation.isPending,
detectResult: detectMutation.data,
+ detectError: detectMutation.error,
+ autoDetect: autoDetectMutation.mutate,
+ isAutoDetecting: autoDetectMutation.isPending,
+ autoDetectResult: autoDetectMutation.data,
+ autoDetectError: autoDetectMutation.error,
+ getHardware: getHardwareMutation.mutateAsync,
+ isGettingHardware: getHardwareMutation.isPending,
+ getHardwareError: getHardwareMutation.error,
addNode: addMutation.mutate,
isAdding: addMutation.isPending,
+ addError: addMutation.error,
updateNode: updateMutation.mutate,
isUpdating: updateMutation.isPending,
deleteNode: deleteMutation.mutate,
isDeleting: deleteMutation.isPending,
+ deleteError: deleteMutation.error,
applyNode: applyMutation.mutate,
isApplying: applyMutation.isPending,
fetchTemplates: fetchTemplatesMutation.mutate,
isFetchingTemplates: fetchTemplatesMutation.isPending,
+ cancelDiscovery: cancelDiscoveryMutation.mutate,
+ isCancellingDiscovery: cancelDiscoveryMutation.isPending,
};
}
diff --git a/src/schemas/config.ts b/src/schemas/config.ts
index bdb99ab..e8a67d2 100644
--- a/src/schemas/config.ts
+++ b/src/schemas/config.ts
@@ -74,6 +74,7 @@ const nodesConfigSchema = z.object({
// Cluster configuration schema
const clusterConfigSchema = z.object({
endpointIp: ipAddressSchema,
+ hostnamePrefix: z.string().optional(),
nodes: nodesConfigSchema,
});
@@ -138,6 +139,7 @@ export const configFormSchema = z.object({
(val) => ipAddressSchema.safeParse(val).success,
'Must be a valid IP address'
),
+ hostnamePrefix: z.string().optional(),
nodes: z.object({
talos: z.object({
version: z.string().min(1, 'Talos version is required').refine(
@@ -175,6 +177,7 @@ export const defaultConfigValues: ConfigFormData = {
},
cluster: {
endpointIp: '192.168.8.60',
+ hostnamePrefix: '',
nodes: {
talos: {
version: 'v1.8.0',
diff --git a/src/services/api/cluster.ts b/src/services/api/cluster.ts
index fe465d8..ca4f813 100644
--- a/src/services/api/cluster.ts
+++ b/src/services/api/cluster.ts
@@ -13,8 +13,8 @@ export const clusterApi = {
return apiClient.post(`/api/v1/instances/${instanceName}/cluster/config/generate`, config);
},
- async bootstrap(instanceName: string, node: string): Promise {
- return apiClient.post(`/api/v1/instances/${instanceName}/cluster/bootstrap`, { node });
+ async bootstrap(instanceName: string, nodeName: string): Promise {
+ return apiClient.post(`/api/v1/instances/${instanceName}/cluster/bootstrap`, { node_name: nodeName });
},
async configureEndpoints(instanceName: string, includeNodes = false): Promise {
diff --git a/src/services/api/nodes.ts b/src/services/api/nodes.ts
index 1498bca..37a7397 100644
--- a/src/services/api/nodes.ts
+++ b/src/services/api/nodes.ts
@@ -39,14 +39,23 @@ export const nodesApi = {
return apiClient.post(`/api/v1/instances/${instanceName}/nodes/discover`, { subnet });
},
- async detect(instanceName: string): Promise {
- return apiClient.post(`/api/v1/instances/${instanceName}/nodes/detect`);
+ async detect(instanceName: string, ip?: string): Promise {
+ const body = ip ? { ip } : {};
+ return apiClient.post(`/api/v1/instances/${instanceName}/nodes/detect`, body);
+ },
+
+ async autoDetect(instanceName: string): Promise<{ networks: string[]; nodes: any[]; count: number }> {
+ return apiClient.post(`/api/v1/instances/${instanceName}/nodes/auto-detect`);
},
async discoveryStatus(instanceName: string): Promise {
return apiClient.get(`/api/v1/instances/${instanceName}/discovery`);
},
+ async cancelDiscovery(instanceName: string): Promise {
+ return apiClient.post(`/api/v1/instances/${instanceName}/discovery/cancel`);
+ },
+
async getHardware(instanceName: string, ip: string): Promise {
return apiClient.get(`/api/v1/instances/${instanceName}/nodes/hardware/${ip}`);
},
diff --git a/src/services/api/types/node.ts b/src/services/api/types/node.ts
index 6ac49fb..4b13bf8 100644
--- a/src/services/api/types/node.ts
+++ b/src/services/api/types/node.ts
@@ -11,6 +11,13 @@ export interface Node {
maintenance?: boolean;
configured?: boolean;
applied?: boolean;
+ // Active operation flags
+ configureInProgress?: boolean;
+ applyInProgress?: boolean;
+ // Optional runtime fields for enhanced status
+ isReachable?: boolean;
+ inKubernetes?: boolean;
+ lastHealthCheck?: string;
// Optional fields (not yet returned by API)
hardware?: HardwareInfo;
talosVersion?: string;
@@ -23,15 +30,19 @@ export interface HardwareInfo {
disk?: string;
manufacturer?: string;
model?: string;
+ // Hardware detection fields
+ ip?: string;
+ interface?: string;
+ interfaces?: string[];
+ disks?: Array<{ path: string; size: number }>;
+ selected_disk?: string;
}
export interface DiscoveredNode {
ip: string;
hostname?: string;
- maintenance_mode?: boolean;
+ maintenance_mode: boolean;
version?: string;
- interface?: string;
- disks?: string[];
}
export interface DiscoveryStatus {
@@ -50,6 +61,10 @@ export interface NodeAddRequest {
target_ip: string;
role: 'controlplane' | 'worker';
disk?: string;
+ current_ip?: string;
+ interface?: string;
+ schematic_id?: string;
+ maintenance?: boolean;
}
export interface NodeUpdateRequest {
diff --git a/src/services/api/types/operation.ts b/src/services/api/types/operation.ts
index cd562e7..4631828 100644
--- a/src/services/api/types/operation.ts
+++ b/src/services/api/types/operation.ts
@@ -1,3 +1,15 @@
+export interface BootstrapProgress {
+ current_step: number;
+ step_name: string;
+ attempt: number;
+ max_attempts: number;
+ step_description: string;
+}
+
+export interface OperationDetails {
+ bootstrap?: BootstrapProgress;
+}
+
export interface Operation {
id: string;
instance_name: string;
@@ -9,6 +21,7 @@ export interface Operation {
started: string;
completed?: string;
error?: string;
+ details?: OperationDetails;
}
export interface OperationListResponse {
diff --git a/src/test/utils/nodeFormTestUtils.tsx b/src/test/utils/nodeFormTestUtils.tsx
new file mode 100644
index 0000000..eae7552
--- /dev/null
+++ b/src/test/utils/nodeFormTestUtils.tsx
@@ -0,0 +1,133 @@
+import { ReactNode } from 'react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { Node, HardwareInfo } from '../../services/api/types';
+
+export function createTestQueryClient() {
+ return new QueryClient({
+ defaultOptions: {
+ queries: {
+ retry: false,
+ gcTime: 0,
+ },
+ mutations: {
+ retry: false,
+ },
+ },
+ });
+}
+
+export function createWrapper(queryClient: QueryClient) {
+ return function TestWrapper({ children }: { children: ReactNode }) {
+ return (
+
+ {children}
+
+ );
+ };
+}
+
+export function createMockNode(overrides: Partial = {}): Node {
+ return {
+ hostname: 'test-control-1',
+ target_ip: '192.168.1.101',
+ role: 'controlplane',
+ current_ip: '192.168.1.50',
+ interface: 'eth0',
+ disk: '/dev/sda',
+ maintenance: true,
+ configured: false,
+ applied: false,
+ ...overrides,
+ };
+}
+
+export function createMockNodes(count: number, role: 'controlplane' | 'worker' = 'controlplane'): Node[] {
+ return Array.from({ length: count }, (_, i) =>
+ createMockNode({
+ hostname: `test-${role === 'controlplane' ? 'control' : 'worker'}-${i + 1}`,
+ target_ip: `192.168.1.${100 + i + 1}`,
+ role,
+ })
+ );
+}
+
+export function createMockConfig(overrides: any = {}) {
+ return {
+ cluster: {
+ hostnamePrefix: 'test-',
+ nodes: {
+ control: {
+ vip: '192.168.1.100',
+ },
+ talos: {
+ schematicId: 'default-schematic-123',
+ },
+ },
+ },
+ ...overrides,
+ };
+}
+
+export function createMockHardwareInfo(overrides: Partial = {}): HardwareInfo {
+ return {
+ ip: '192.168.1.50',
+ interface: 'eth0',
+ interfaces: ['eth0', 'eth1'],
+ disks: [
+ { path: '/dev/sda', size: 512000000000 },
+ { path: '/dev/sdb', size: 1024000000000 },
+ ],
+ selected_disk: '/dev/sda',
+ ...overrides,
+ };
+}
+
+export function mockUseInstanceConfig(config: any = null) {
+ return {
+ config,
+ isLoading: false,
+ error: null,
+ updateConfig: vi.fn(),
+ isUpdating: false,
+ batchUpdate: vi.fn(),
+ isBatchUpdating: false,
+ };
+}
+
+export function mockUseNodes(nodes: Node[] = []) {
+ return {
+ nodes,
+ isLoading: false,
+ error: null,
+ refetch: vi.fn(),
+ discover: vi.fn(),
+ isDiscovering: false,
+ discoverResult: undefined,
+ discoverError: null,
+ detect: vi.fn(),
+ isDetecting: false,
+ detectResult: undefined,
+ detectError: null,
+ autoDetect: vi.fn(),
+ isAutoDetecting: false,
+ autoDetectResult: undefined,
+ autoDetectError: null,
+ getHardware: vi.fn(),
+ isGettingHardware: false,
+ getHardwareError: null,
+ addNode: vi.fn(),
+ isAdding: false,
+ addError: null,
+ updateNode: vi.fn(),
+ isUpdating: false,
+ deleteNode: vi.fn(),
+ isDeleting: false,
+ deleteError: null,
+ applyNode: vi.fn(),
+ isApplying: false,
+ fetchTemplates: vi.fn(),
+ isFetchingTemplates: false,
+ cancelDiscovery: vi.fn(),
+ isCancellingDiscovery: false,
+ };
+}
diff --git a/src/types/index.ts b/src/types/index.ts
index a185b64..faba0ad 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -33,6 +33,7 @@ export interface CloudConfig {
export interface TalosConfig {
version: string;
+ schematicId?: string;
}
export interface NodesConfig {
diff --git a/src/types/nodeStatus.ts b/src/types/nodeStatus.ts
new file mode 100644
index 0000000..acd531e
--- /dev/null
+++ b/src/types/nodeStatus.ts
@@ -0,0 +1,41 @@
+export enum NodeStatus {
+ // Discovery Phase
+ DISCOVERED = "discovered",
+
+ // Configuration Phase
+ PENDING = "pending",
+ CONFIGURING = "configuring",
+ CONFIGURED = "configured",
+
+ // Deployment Phase
+ APPLYING = "applying",
+ PROVISIONING = "provisioning",
+
+ // Operational Phase
+ READY = "ready",
+ HEALTHY = "healthy",
+
+ // Maintenance States
+ MAINTENANCE = "maintenance",
+ REPROVISIONING = "reprovisioning",
+
+ // Error States
+ UNREACHABLE = "unreachable",
+ DEGRADED = "degraded",
+ FAILED = "failed",
+
+ // Special States
+ UNKNOWN = "unknown",
+ ORPHANED = "orphaned"
+}
+
+export interface StatusDesign {
+ status: NodeStatus;
+ color: string;
+ bgColor: string;
+ icon: string;
+ label: string;
+ description: string;
+ nextAction?: string;
+ severity: "info" | "warning" | "error" | "success" | "neutral";
+}
diff --git a/src/utils/deriveNodeStatus.ts b/src/utils/deriveNodeStatus.ts
new file mode 100644
index 0000000..d2cbeb6
--- /dev/null
+++ b/src/utils/deriveNodeStatus.ts
@@ -0,0 +1,61 @@
+import type { Node } from '../services/api/types';
+import { NodeStatus } from '../types/nodeStatus';
+
+export function deriveNodeStatus(node: Node): NodeStatus {
+ // Priority 1: Active operations
+ if (node.applyInProgress) {
+ return NodeStatus.APPLYING;
+ }
+
+ if (node.configureInProgress) {
+ return NodeStatus.CONFIGURING;
+ }
+
+ // Priority 2: Maintenance states
+ if (node.maintenance) {
+ if (node.applied) {
+ return NodeStatus.MAINTENANCE;
+ } else {
+ return NodeStatus.REPROVISIONING;
+ }
+ }
+
+ // Priority 3: Error states
+ if (node.isReachable === false) {
+ return NodeStatus.UNREACHABLE;
+ }
+
+ // Priority 4: Lifecycle progression
+ if (!node.configured) {
+ return NodeStatus.PENDING;
+ }
+
+ if (node.configured && !node.applied) {
+ return NodeStatus.CONFIGURED;
+ }
+
+ if (node.applied) {
+ // Check Kubernetes membership for healthy state
+ if (node.inKubernetes === true) {
+ return NodeStatus.HEALTHY;
+ }
+
+ // Applied but not yet in Kubernetes (could be provisioning or ready)
+ if (node.isReachable === true) {
+ return NodeStatus.READY;
+ }
+
+ // Applied but status unknown
+ if (node.isReachable === undefined && node.inKubernetes === undefined) {
+ return NodeStatus.READY;
+ }
+
+ // Applied but having issues
+ if (node.inKubernetes === false) {
+ return NodeStatus.DEGRADED;
+ }
+ }
+
+ // Fallback
+ return NodeStatus.UNKNOWN;
+}