import { Terminal as XTerm } from "@xterm/xterm"; import { FitAddon } from "@xterm/addon-fit"; import { SerializeAddon } from "@xterm/addon-serialize"; import { SearchAddon } from "@xterm/addon-search"; import "@xterm/xterm/css/xterm.css"; import { Cpu, HardDrive, Maximize2, MemoryStick, Radio, ArrowDownToLine, ArrowUpFromLine } from "lucide-react"; import React, { memo, useEffect, useMemo, useRef, useState } from "react"; import { flushSync } from "react-dom"; import { useI18n } from "../application/i18n/I18nProvider"; import { logger } from "../lib/logger"; import { cn } from "../lib/utils"; import { Host, Identity, KnownHost, SerialConfig, SSHKey, Snippet, TerminalSession, TerminalTheme, TerminalSettings, KeyBinding, } from "../types"; import { resolveHostAuth } from "../domain/sshAuth"; import { useTerminalBackend } from "../application/state/useTerminalBackend"; import KnownHostConfirmDialog, { HostKeyInfo } from "./KnownHostConfirmDialog"; import SFTPModal from "./SFTPModal"; import { Button } from "./ui/button"; import { HoverCard, HoverCardContent, HoverCardTrigger } from "./ui/hover-card"; import { toast } from "./ui/toast"; import { useAvailableFonts } from "../application/state/fontStore"; import { TERMINAL_THEMES } from "../infrastructure/config/terminalThemes"; import { TerminalConnectionDialog } from "./terminal/TerminalConnectionDialog"; import { TerminalToolbar } from "./terminal/TerminalToolbar"; import { TerminalContextMenu } from "./terminal/TerminalContextMenu"; import { TerminalSearchBar } from "./terminal/TerminalSearchBar"; import { createTerminalSessionStarters, type PendingAuth } from "./terminal/runtime/createTerminalSessionStarters"; import { createXTermRuntime, type XTermRuntime } from "./terminal/runtime/createXTermRuntime"; import { XTERM_PERFORMANCE_CONFIG } from "../infrastructure/config/xtermPerformance"; import { useTerminalSearch } from "./terminal/hooks/useTerminalSearch"; import { useTerminalContextActions } from "./terminal/hooks/useTerminalContextActions"; import { useTerminalAuthState } from "./terminal/hooks/useTerminalAuthState"; import { useServerStats } from "./terminal/hooks/useServerStats"; import { extractDropEntries, getPathForFile, DropEntry } from "../lib/sftpFileUtils"; /** * Extract unique root paths from drop entries for local terminal path insertion. * For nested files, extracts the root folder path; for single files, uses the full path. * Paths with spaces are quoted. */ function extractRootPathsFromDropEntries(dropEntries: DropEntry[]): string[] { const paths: string[] = []; const seenPaths = new Set(); for (const entry of dropEntries) { if (!entry.file) continue; const fullPath = getPathForFile(entry.file); if (!fullPath) continue; const pathParts = entry.relativePath.split('/'); if (pathParts.length > 1) { // Nested file in a folder - extract the root folder path const rootFolderName = pathParts[0]; const separator = fullPath.includes('\\') ? '\\' : '/'; // Find the position of the root folder name in the full path const rootFolderIndex = fullPath.lastIndexOf(separator + rootFolderName + separator); const altRootFolderIndex = fullPath.lastIndexOf(separator + rootFolderName); const folderStartIndex = rootFolderIndex !== -1 ? rootFolderIndex + 1 : (altRootFolderIndex !== -1 ? altRootFolderIndex + 1 : -1); if (folderStartIndex !== -1) { const folderEndIndex = folderStartIndex + rootFolderName.length; const folderPath = fullPath.substring(0, folderEndIndex); if (!seenPaths.has(folderPath)) { paths.push(folderPath.includes(' ') ? `"${folderPath}"` : folderPath); seenPaths.add(folderPath); } } } else { // Single file (not in a folder) if (!seenPaths.has(fullPath)) { paths.push(fullPath.includes(' ') ? `"${fullPath}"` : fullPath); seenPaths.add(fullPath); } } } return paths; } interface TerminalProps { host: Host; keys: SSHKey[]; identities: Identity[]; snippets: Snippet[]; allHosts?: Host[]; knownHosts?: KnownHost[]; isVisible: boolean; inWorkspace?: boolean; isResizing?: boolean; isFocusMode?: boolean; isFocused?: boolean; fontFamilyId: string; fontSize: number; terminalTheme: TerminalTheme; terminalSettings?: TerminalSettings; sessionId: string; startupCommand?: string; serialConfig?: SerialConfig; onUpdateTerminalThemeId?: (themeId: string) => void; onUpdateTerminalFontFamilyId?: (fontFamilyId: string) => void; onUpdateTerminalFontSize?: (fontSize: number) => void; hotkeyScheme?: "disabled" | "mac" | "pc"; keyBindings?: KeyBinding[]; onHotkeyAction?: (action: string, event: KeyboardEvent) => void; onStatusChange?: (sessionId: string, status: TerminalSession["status"]) => void; onSessionExit?: (sessionId: string) => void; onTerminalDataCapture?: (sessionId: string, data: string) => void; onOsDetected?: (hostId: string, distro: string) => void; onCloseSession?: (sessionId: string) => void; onUpdateHost?: (host: Host) => void; onAddKnownHost?: (knownHost: KnownHost) => void; onExpandToFocus?: () => void; onCommandExecuted?: ( command: string, hostId: string, hostLabel: string, sessionId: string, ) => void; onSplitHorizontal?: () => void; onSplitVertical?: () => void; isBroadcastEnabled?: boolean; onToggleBroadcast?: () => void; onBroadcastInput?: (data: string, sourceSessionId: string) => void; } // Helper function to format network speed (bytes/sec) to human-readable format function formatNetSpeed(bytesPerSec: number): string { if (bytesPerSec < 1024) { return `${bytesPerSec}B/s`; } else if (bytesPerSec < 1024 * 1024) { return `${(bytesPerSec / 1024).toFixed(1)}K/s`; } else if (bytesPerSec < 1024 * 1024 * 1024) { return `${(bytesPerSec / (1024 * 1024)).toFixed(1)}M/s`; } else { return `${(bytesPerSec / (1024 * 1024 * 1024)).toFixed(1)}G/s`; } } const TerminalComponent: React.FC = ({ host, keys, identities, snippets, allHosts = [], knownHosts: _knownHosts = [], isVisible, inWorkspace, isResizing, isFocusMode, isFocused, fontFamilyId, fontSize, terminalTheme, terminalSettings, sessionId, startupCommand, serialConfig, onUpdateTerminalThemeId, onUpdateTerminalFontFamilyId, onUpdateTerminalFontSize, hotkeyScheme = "disabled", keyBindings = [], onHotkeyAction, onStatusChange, onSessionExit, onTerminalDataCapture, onOsDetected, onCloseSession, onUpdateHost, onAddKnownHost, onExpandToFocus, onCommandExecuted, onSplitHorizontal, onSplitVertical, isBroadcastEnabled, onToggleBroadcast, onBroadcastInput, }) => { // Timeout for connection - increased to 120s to allow time for keyboard-interactive (2FA) authentication const CONNECTION_TIMEOUT = 120000; const { t } = useI18n(); const availableFonts = useAvailableFonts(); const containerRef = useRef(null); const termRef = useRef(null); const fitAddonRef = useRef(null); const serializeAddonRef = useRef(null); const searchAddonRef = useRef(null); const xtermRuntimeRef = useRef(null); const disposeDataRef = useRef<(() => void) | null>(null); const disposeExitRef = useRef<(() => void) | null>(null); const sessionRef = useRef(null); const hasConnectedRef = useRef(false); const hasRunStartupCommandRef = useRef(false); const commandBufferRef = useRef(""); const serialLineBufferRef = useRef(""); const terminalSettingsRef = useRef(terminalSettings); terminalSettingsRef.current = terminalSettings; useEffect(() => { if (xtermRuntimeRef.current) { // Merge global rules with host-level rules // Host-level rules are appended to global rules, allowing hosts to add custom highlighting const globalRules = terminalSettings?.keywordHighlightRules ?? []; const hostRules = host?.keywordHighlightRules ?? []; // Check if highlighting is enabled at either global or host level const globalEnabled = terminalSettings?.keywordHighlightEnabled ?? false; const hostEnabled = host?.keywordHighlightEnabled ?? false; // Merge rules: include only rules from enabled sources const mergedRules = [ ...(globalEnabled ? globalRules : []), ...(hostEnabled ? hostRules : []) ]; // Enable highlighting if either global or host-level is enabled const isEnabled = globalEnabled || hostEnabled; xtermRuntimeRef.current.keywordHighlighter.setRules(mergedRules, isEnabled); } }, [ terminalSettings?.keywordHighlightEnabled, terminalSettings?.keywordHighlightRules, host?.keywordHighlightEnabled, host?.keywordHighlightRules ]); const hotkeySchemeRef = useRef(hotkeyScheme); const keyBindingsRef = useRef(keyBindings); const onHotkeyActionRef = useRef(onHotkeyAction); hotkeySchemeRef.current = hotkeyScheme; keyBindingsRef.current = keyBindings; onHotkeyActionRef.current = onHotkeyAction; const isBroadcastEnabledRef = useRef(isBroadcastEnabled); const onBroadcastInputRef = useRef(onBroadcastInput); isBroadcastEnabledRef.current = isBroadcastEnabled; onBroadcastInputRef.current = onBroadcastInput; // Snippets ref for shortkey support in terminal const snippetsRef = useRef(snippets); snippetsRef.current = snippets; const terminalBackend = useTerminalBackend(); const { resizeSession } = terminalBackend; const [isScriptsOpen, setIsScriptsOpen] = useState(false); const [status, setStatus] = useState("connecting"); const [error, setError] = useState(null); const lastToastedErrorRef = useRef(null); const [showLogs, setShowLogs] = useState(false); const [progressLogs, setProgressLogs] = useState([]); const [timeLeft, setTimeLeft] = useState(CONNECTION_TIMEOUT / 1000); const [isCancelling, setIsCancelling] = useState(false); const [showSFTP, setShowSFTP] = useState(false); const [sftpInitialPath, setSftpInitialPath] = useState(undefined); const [progressValue, setProgressValue] = useState(15); const [hasSelection, setHasSelection] = useState(false); const statusRef = useRef(status); statusRef.current = status; const [chainProgress, setChainProgress] = useState<{ currentHop: number; totalHops: number; currentHostLabel: string; } | null>(null); // Drag and drop state const [isDraggingOver, setIsDraggingOver] = useState(false); const dragCounterRef = useRef(0); const [pendingUploadEntries, setPendingUploadEntries] = useState([]); const terminalSearch = useTerminalSearch({ searchAddonRef, termRef }); const { isSearchOpen, setIsSearchOpen, searchMatchCount, handleToggleSearch, handleSearch, handleFindNext, handleFindPrevious, handleCloseSearch, } = terminalSearch; // Check if this is a local or serial connection (doesn't need connection dialog during connecting) const isLocalConnection = host.protocol === "local"; const isSerialConnection = host.protocol === "serial"; // Server stats (CPU, Memory, Disk) for Linux servers const { stats: serverStats } = useServerStats({ sessionId, enabled: terminalSettings?.showServerStats ?? true, refreshInterval: terminalSettings?.serverStatsRefreshInterval ?? 5, isLinux: host.os === 'linux', isConnected: status === 'connected', }); useEffect(() => { if (!error) { lastToastedErrorRef.current = null; return; } if (lastToastedErrorRef.current === error) return; lastToastedErrorRef.current = error; toast.error(error, t("terminal.connectionErrorTitle")); }, [error, t]); const pendingAuthRef = useRef(null); const sessionStartersRef = useRef | null>(null); const auth = useTerminalAuthState({ host, pendingAuthRef, termRef, onUpdateHost, onStartSsh: (term) => { sessionStartersRef.current?.startSSH(term); }, setStatus: (next) => setStatus(next), setProgressLogs, }); const [needsHostKeyVerification, setNeedsHostKeyVerification] = useState(false); const [pendingHostKeyInfo, setPendingHostKeyInfo] = useState(null); const pendingConnectionRef = useRef<(() => void) | null>(null); const effectiveTheme = useMemo(() => { if (host.theme) { const hostTheme = TERMINAL_THEMES.find((t) => t.id === host.theme); if (hostTheme) return hostTheme; } return terminalTheme; }, [host.theme, terminalTheme]); const resolvedChainHosts = (host.hostChain?.hostIds ?.map((id) => allHosts.find((h) => h.id === id)) .filter(Boolean) as Host[]) || []; const updateStatus = (next: TerminalSession["status"]) => { setStatus(next); hasConnectedRef.current = next === "connected"; onStatusChange?.(sessionId, next); }; const cleanupSession = () => { disposeDataRef.current?.(); disposeDataRef.current = null; disposeExitRef.current?.(); disposeExitRef.current = null; if (sessionRef.current) { try { terminalBackend.closeSession(sessionRef.current); } catch (err) { logger.warn("Failed to close SSH session", err); } } sessionRef.current = null; }; const teardown = () => { cleanupSession(); xtermRuntimeRef.current?.dispose(); xtermRuntimeRef.current = null; termRef.current = null; fitAddonRef.current = null; serializeAddonRef.current = null; searchAddonRef.current = null; }; const sessionStarters = createTerminalSessionStarters({ host, keys, identities, resolvedChainHosts, sessionId, startupCommand, terminalSettings, terminalBackend, serialConfig, sessionRef, hasConnectedRef, hasRunStartupCommandRef, disposeDataRef, disposeExitRef, fitAddonRef, serializeAddonRef, pendingAuthRef, updateStatus, setStatus, setError, setNeedsAuth: auth.setNeedsAuth, setAuthRetryMessage: auth.setAuthRetryMessage, setAuthPassword: auth.setAuthPassword, setProgressLogs, setProgressValue, setChainProgress, onSessionExit, onTerminalDataCapture, onOsDetected, onCommandExecuted, }); sessionStartersRef.current = sessionStarters; useEffect(() => { let disposed = false; setError(null); hasConnectedRef.current = false; setProgressLogs([]); setShowLogs(false); setIsCancelling(false); const boot = async () => { try { if (disposed || !containerRef.current) return; const runtime = createXTermRuntime({ container: containerRef.current, host, fontFamilyId, fontSize, terminalTheme: effectiveTheme, terminalSettingsRef, terminalBackend, sessionRef, hotkeySchemeRef, keyBindingsRef, onHotkeyActionRef, isBroadcastEnabledRef, onBroadcastInputRef, snippetsRef, sessionId, statusRef, onCommandExecuted, commandBufferRef, setIsSearchOpen, // Serial-specific options serialLocalEcho: serialConfig?.localEcho, serialLineMode: serialConfig?.lineMode, serialLineBufferRef, }); xtermRuntimeRef.current = runtime; termRef.current = runtime.term; fitAddonRef.current = runtime.fitAddon; serializeAddonRef.current = runtime.serializeAddon; searchAddonRef.current = runtime.searchAddon; // Apply merged keyword highlight rules immediately after runtime creation // This fixes a timing issue where the useEffect for keyword highlighting // runs before the runtime is created, causing host-level rules to be missed const globalRules = terminalSettingsRef.current?.keywordHighlightRules ?? []; const hostRules = host?.keywordHighlightRules ?? []; const globalEnabled = terminalSettingsRef.current?.keywordHighlightEnabled ?? false; const hostEnabled = host?.keywordHighlightEnabled ?? false; const mergedRules = [ ...(globalEnabled ? globalRules : []), ...(hostEnabled ? hostRules : []) ]; const isEnabled = globalEnabled || hostEnabled; runtime.keywordHighlighter.setRules(mergedRules, isEnabled); const term = runtime.term; if (host.protocol === "serial") { setStatus("connecting"); setProgressLogs(["Initializing serial connection..."]); await sessionStarters.startSerial(term); } else if (host.protocol === "local" || host.hostname === "localhost") { setStatus("connecting"); setProgressLogs(["Initializing local shell..."]); await sessionStarters.startLocal(term); } else if (host.protocol === "telnet") { setStatus("connecting"); setProgressLogs(["Initializing Telnet connection..."]); await sessionStarters.startTelnet(term); } else if (host.moshEnabled) { setStatus("connecting"); setProgressLogs(["Initializing Mosh connection..."]); await sessionStarters.startMosh(term); } else { const resolvedAuth = resolveHostAuth({ host, keys, identities }); const hasPassword = !!resolvedAuth.password; const hasKey = !!resolvedAuth.keyId; const hasPendingAuth = pendingAuthRef.current; if ( !hasPassword && !hasKey && !hasPendingAuth && !resolvedAuth.username ) { auth.setNeedsAuth(true); setStatus("disconnected"); return; } setStatus("connecting"); setProgressLogs(["Initializing secure channel..."]); await sessionStarters.startSSH(term); } } catch (err) { logger.error("Failed to initialize terminal", err); setError(err instanceof Error ? err.message : String(err)); updateStatus("disconnected"); } }; boot(); return () => { disposed = true; if (onTerminalDataCapture && serializeAddonRef.current) { try { const terminalData = serializeAddonRef.current.serialize(); logger.info("[Terminal] Capturing data on unmount", { sessionId, dataLength: terminalData.length }); onTerminalDataCapture(sessionId, terminalData); } catch (err) { logger.warn("Failed to serialize terminal data on unmount:", err); } } teardown(); }; // eslint-disable-next-line react-hooks/exhaustive-deps -- Effect only runs on host.id/sessionId change, internal functions are stable }, [host.id, sessionId]); // Connection timeline and timeout visuals useEffect(() => { if (status !== "connecting" || auth.needsAuth) return; // Local terminal and serial connections don't need timeout/progress UI if (isLocalConnection || isSerialConnection) return; // Only show SSH-specific scripted logs for SSH connections const isSSH = host.protocol !== "telnet"; let stepTimer: ReturnType | undefined; if (isSSH) { const scripted = [ "Resolving host and keys...", "Negotiating ciphers...", "Exchanging keys...", "Authenticating user...", "Waiting for server greeting...", ]; let idx = 0; stepTimer = setInterval(() => { setProgressLogs((prev) => { if (idx >= scripted.length) return prev; const next = scripted[idx++]; return prev.includes(next) ? prev : [...prev, next]; }); }, 900); } setTimeLeft(CONNECTION_TIMEOUT / 1000); const countdown = setInterval(() => { setTimeLeft((prev) => (prev > 0 ? prev - 1 : 0)); }, 1000); const timeout = setTimeout(() => { setError("Connection timed out. Please try again."); updateStatus("disconnected"); setProgressLogs((prev) => [...prev, "Connection timed out."]); }, CONNECTION_TIMEOUT); setProgressValue(5); const prog = setInterval(() => { setProgressValue((prev) => { if (prev >= 95) return prev; const remaining = 95 - prev; const increment = Math.max(1, remaining * 0.15); return Math.min(95, prev + increment); }); }, 200); return () => { if (stepTimer) clearInterval(stepTimer); clearInterval(countdown); clearTimeout(timeout); clearInterval(prog); }; // eslint-disable-next-line react-hooks/exhaustive-deps -- updateStatus is a stable internal helper }, [status, auth.needsAuth, host.protocol, host.hostname]); const safeFit = () => { const fitAddon = fitAddonRef.current; if (!fitAddon) return; const runFit = () => { try { fitAddon.fit(); } catch (err) { logger.warn("Fit failed", err); } }; if ( XTERM_PERFORMANCE_CONFIG.resize.useRAF && typeof requestAnimationFrame === "function" ) { requestAnimationFrame(runFit); } else { runFit(); } }; useEffect(() => { if (termRef.current) { const effectiveFontSize = host.fontSize || fontSize; termRef.current.options.fontSize = effectiveFontSize; termRef.current.options.theme = { ...effectiveTheme.colors, selectionBackground: effectiveTheme.colors.selection, }; if (terminalSettings) { termRef.current.options.cursorStyle = terminalSettings.cursorShape; termRef.current.options.cursorBlink = terminalSettings.cursorBlink; termRef.current.options.scrollback = terminalSettings.scrollback; termRef.current.options.fontWeight = terminalSettings.fontWeight as | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900; const resolvedFontWeightBold = (() => { const fontFamily = termRef.current?.options.fontFamily || ""; if (typeof document === "undefined" || !document.fonts?.check) { return terminalSettings.fontWeightBold; } const weightSpec = `${terminalSettings.fontWeightBold} ${effectiveFontSize}px ${fontFamily}`; return document.fonts.check(weightSpec) ? terminalSettings.fontWeightBold : terminalSettings.fontWeight; })(); termRef.current.options.fontWeightBold = resolvedFontWeightBold as | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900; termRef.current.options.lineHeight = 1 + terminalSettings.linePadding / 10; termRef.current.options.drawBoldTextInBrightColors = terminalSettings.drawBoldInBrightColors; termRef.current.options.minimumContrastRatio = terminalSettings.minimumContrastRatio; termRef.current.options.scrollOnUserInput = terminalSettings.scrollOnInput; termRef.current.options.altClickMovesCursor = !terminalSettings.altAsMeta; termRef.current.options.wordSeparator = terminalSettings.wordSeparators; } setTimeout(() => safeFit(), 50); } }, [fontSize, effectiveTheme, terminalSettings, host.fontSize]); useEffect(() => { if (termRef.current) { const effectiveFontSize = host.fontSize || fontSize; termRef.current.options.fontSize = effectiveFontSize; const hostFontId = host.fontFamily || fontFamilyId || "menlo"; const fontObj = availableFonts.find((f) => f.id === hostFontId) || availableFonts[0]; termRef.current.options.fontFamily = fontObj.family; termRef.current.options.theme = { ...effectiveTheme.colors, selectionBackground: effectiveTheme.colors.selection, }; setTimeout(() => safeFit(), 50); } }, [host.fontSize, host.fontFamily, host.theme, fontFamilyId, fontSize, effectiveTheme, availableFonts]); useEffect(() => { if (isVisible && fitAddonRef.current) { const timer = setTimeout(() => safeFit(), 50); return () => clearTimeout(timer); } }, [isVisible]); useEffect(() => { let cancelled = false; const waitForFonts = async () => { try { const fontFaceSet = document.fonts as FontFaceSet | undefined; if (!fontFaceSet?.ready) return; await fontFaceSet.ready; if (cancelled) return; const term = termRef.current as { cols: number; rows: number; renderer?: { remeasureFont?: () => void }; } | null; const fitAddon = fitAddonRef.current; try { term?.renderer?.remeasureFont?.(); } catch (err) { logger.warn("Font remeasure failed", err); } try { fitAddon?.fit(); } catch (err) { logger.warn("Fit after fonts ready failed", err); } if (terminalSettings && termRef.current) { const fontFamily = termRef.current.options?.fontFamily || ""; const effectiveFontSize = host.fontSize || fontSize; if (typeof document !== "undefined" && document.fonts?.check) { const weightSpec = `${terminalSettings.fontWeightBold} ${effectiveFontSize}px ${fontFamily}`; const resolvedBold = document.fonts.check(weightSpec) ? terminalSettings.fontWeightBold : terminalSettings.fontWeight; termRef.current.options.fontWeightBold = resolvedBold as | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900; } } const id = sessionRef.current; if (id && term) { try { resizeSession(id, term.cols, term.rows); } catch (err) { logger.warn("Resize session after fonts ready failed", err); } } } catch (err) { logger.warn("Waiting for fonts failed", err); } }; waitForFonts(); return () => { cancelled = true; }; }, [host.id, host.fontFamily, host.fontSize, fontFamilyId, fontSize, resizeSession, sessionId, terminalSettings]); useEffect(() => { if (!containerRef.current || !fitAddonRef.current) return; let resizeTimeout: ReturnType | null = null; const observer = new ResizeObserver(() => { if (isResizing) return; if (resizeTimeout) { clearTimeout(resizeTimeout); } resizeTimeout = setTimeout(() => { safeFit(); }, 250); }); observer.observe(containerRef.current); return () => { if (resizeTimeout) clearTimeout(resizeTimeout); observer.disconnect(); }; }, [isVisible, isResizing]); const prevIsResizingRef = useRef(isResizing); useEffect(() => { if (prevIsResizingRef.current && !isResizing && isVisible) { const timer = setTimeout(() => { safeFit(); }, 100); return () => clearTimeout(timer); } prevIsResizingRef.current = isResizing; }, [isResizing, isVisible]); useEffect(() => { if (!isVisible || !fitAddonRef.current) return; const timer = setTimeout(() => { safeFit(); }, 100); return () => clearTimeout(timer); }, [inWorkspace, isVisible]); useEffect(() => { const shouldAutoFocus = isVisible && termRef.current && (!inWorkspace || isFocusMode); if (shouldAutoFocus) { const timer = setTimeout(() => { termRef.current?.focus(); }, 50); return () => clearTimeout(timer); } }, [isVisible, inWorkspace, isFocusMode]); useEffect(() => { if (isFocused && termRef.current && isVisible) { const timer = setTimeout(() => { termRef.current?.focus(); }, 10); return () => clearTimeout(timer); } }, [isFocused, isVisible, sessionId]); useEffect(() => { const term = termRef.current; if (!term) return; const onSelectionChange = () => { const selection = term.getSelection(); const hasText = !!selection && selection.length > 0; setHasSelection(hasText); if (hasText && terminalSettings?.copyOnSelect) { navigator.clipboard.writeText(selection).catch((err) => { logger.warn("Copy on select failed:", err); }); } }; term.onSelectionChange(onSelectionChange); }, [terminalSettings?.copyOnSelect]); useEffect(() => { let resizeTimeout: ReturnType | null = null; const handler = () => { if (resizeTimeout) { clearTimeout(resizeTimeout); } resizeTimeout = setTimeout(() => { safeFit(); }, 250); }; window.addEventListener("resize", handler); return () => { if (resizeTimeout) clearTimeout(resizeTimeout); window.removeEventListener("resize", handler); }; }, []); const terminalContextActions = useTerminalContextActions({ termRef, sessionRef, terminalBackend, onHasSelectionChange: setHasSelection, }); const handleSnippetClick = (cmd: string) => { if (sessionRef.current) { terminalBackend.writeToSession(sessionRef.current, `${cmd}\r`); setIsScriptsOpen(false); termRef.current?.focus(); return; } termRef.current?.writeln("\r\n[No active SSH session]"); }; const handleOpenSFTP = async () => { // If SFTP is already open, toggle it off if (showSFTP) { setShowSFTP(false); return; } // Try to get the current working directory from the terminal session let initialPath: string | undefined = undefined; if (sessionRef.current) { try { const result = await terminalBackend.getSessionPwd(sessionRef.current); if (result.success && result.cwd) { initialPath = result.cwd; } } catch { // Silently fail and open SFTP without initial path } } // Use flushSync to ensure initialPath state is committed before opening SFTP modal // This prevents React's batching from causing the modal to open with stale/undefined initialPath flushSync(() => { setSftpInitialPath(initialPath); }); setShowSFTP(true); }; const handleCancelConnect = () => { setIsCancelling(true); auth.setNeedsAuth(false); auth.setAuthRetryMessage(null); setNeedsHostKeyVerification(false); setPendingHostKeyInfo(null); setError("Connection cancelled"); setProgressLogs((prev) => [...prev, "Cancelled by user."]); cleanupSession(); updateStatus("disconnected"); setChainProgress(null); setTimeout(() => setIsCancelling(false), 600); onCloseSession?.(sessionId); }; const handleHostKeyClose = () => { setNeedsHostKeyVerification(false); setPendingHostKeyInfo(null); handleCancelConnect(); }; const handleHostKeyContinue = () => { setNeedsHostKeyVerification(false); if (pendingConnectionRef.current) { pendingConnectionRef.current(); pendingConnectionRef.current = null; } setPendingHostKeyInfo(null); }; const handleHostKeyAddAndContinue = () => { if (pendingHostKeyInfo && onAddKnownHost) { const newKnownHost: KnownHost = { id: `kh-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`, hostname: pendingHostKeyInfo.hostname, port: pendingHostKeyInfo.port || host.port || 22, keyType: pendingHostKeyInfo.keyType, publicKey: pendingHostKeyInfo.fingerprint, discoveredAt: Date.now(), }; onAddKnownHost(newKnownHost); } setNeedsHostKeyVerification(false); if (pendingConnectionRef.current) { pendingConnectionRef.current(); pendingConnectionRef.current = null; } setPendingHostKeyInfo(null); }; const handleRetry = () => { if (!termRef.current) return; cleanupSession(); auth.resetForRetry(); setStatus("connecting"); setError(null); setProgressLogs(["Retrying secure channel..."]); setShowLogs(true); if (host.protocol === "local" || host.hostname === "localhost") { sessionStarters.startLocal(termRef.current); } else { sessionStarters.startSSH(termRef.current); } }; // Drag and drop handlers const handleDragEnter = (e: React.DragEvent) => { e.preventDefault(); e.stopPropagation(); dragCounterRef.current++; if (e.dataTransfer.types.includes('Files')) { setIsDraggingOver(true); } }; const handleDragOver = (e: React.DragEvent) => { e.preventDefault(); e.stopPropagation(); if (e.dataTransfer.types.includes('Files')) { e.dataTransfer.dropEffect = 'copy'; } }; const handleDragLeave = (e: React.DragEvent) => { e.preventDefault(); e.stopPropagation(); dragCounterRef.current--; if (dragCounterRef.current === 0) { setIsDraggingOver(false); } }; const handleDrop = async (e: React.DragEvent) => { e.preventDefault(); e.stopPropagation(); dragCounterRef.current = 0; setIsDraggingOver(false); if (!e.dataTransfer.types.includes('Files')) { return; } // Only handle drops on connected terminals if (status !== 'connected') { toast.error(t("terminal.dragDrop.notConnected"), t("terminal.dragDrop.errorTitle")); return; } try { const dropEntries = await extractDropEntries(e.dataTransfer); if (dropEntries.length === 0) { return; } if (isLocalConnection) { // Local terminal: Insert absolute paths const paths = extractRootPathsFromDropEntries(dropEntries); if (paths.length > 0 && termRef.current && sessionRef.current) { const pathsText = paths.join(' '); // Write the paths to the terminal terminalBackend.writeToSession(sessionRef.current, pathsText); termRef.current.focus(); } } else { // Remote terminal: Trigger SFTP upload // Get current working directory for SFTP initial path let initialPath: string | undefined = undefined; if (sessionRef.current) { try { const result = await terminalBackend.getSessionPwd(sessionRef.current); if (result.success && result.cwd) { initialPath = result.cwd; } } catch { // Silently fail and open SFTP without initial path } } setPendingUploadEntries(dropEntries); // Use flushSync to ensure sftpInitialPath is updated synchronously // before setShowSFTP(true) triggers the modal open flushSync(() => { setSftpInitialPath(initialPath); }); setShowSFTP(true); } } catch (error) { logger.error("Failed to handle file drop", error); toast.error(t("terminal.dragDrop.errorMessage"), t("terminal.dragDrop.errorTitle")); } }; const renderControls = (opts?: { showClose?: boolean }) => ( onCloseSession?.(sessionId)} isSearchOpen={isSearchOpen} onToggleSearch={handleToggleSearch} /> ); const statusDotTone = status === "connected" ? "bg-emerald-400" : status === "connecting" ? "bg-amber-400" : "bg-rose-500"; const _isConnecting = status === "connecting"; const _hasError = Boolean(error); return ( onCloseSession?.(sessionId) : undefined} >
{/* Drag and drop overlay */} {isDraggingOver && (
{isLocalConnection ? t("terminal.dragDrop.localTitle") : t("terminal.dragDrop.remoteTitle") }
{isLocalConnection ? t("terminal.dragDrop.localMessage") : t("terminal.dragDrop.remoteMessage") }
)}
{host.label}
{/* Server Stats Display - Linux only */} {host.os === 'linux' && terminalSettings?.showServerStats && status === 'connected' && serverStats.lastUpdated && (
{/* CPU with HoverCard for per-core details */}
{t("terminal.serverStats.cpuCores")}
{serverStats.cpuPerCore.length > 0 ? (
{serverStats.cpuPerCore.map((usage, index) => (
Core {index}
= 90 ? "bg-red-500" : usage >= 70 ? "bg-amber-500" : "bg-emerald-500" )} style={{ width: `${usage}%` }} />
= 90 ? "text-red-400" : usage >= 70 ? "text-amber-400" : "text-emerald-400" )}> {usage}%
))}
) : (
{t("terminal.serverStats.noData")}
)}
{/* Memory with HoverCard for htop-style bar and top processes */}
{t("terminal.serverStats.memoryDetails")}
{/* htop-style memory bar */} {serverStats.memTotal !== null && (
{/* Used (green) */} {serverStats.memUsed !== null && serverStats.memUsed > 0 && (
)} {/* Buffers (blue) */} {serverStats.memBuffers !== null && serverStats.memBuffers > 0 && (
)} {/* Cached (amber/orange) */} {serverStats.memCached !== null && serverStats.memCached > 0 && (
)}
{/* Legend */}
{t("terminal.serverStats.memUsed")}: {serverStats.memUsed !== null ? `${(serverStats.memUsed / 1024).toFixed(1)}G` : '--'}
{t("terminal.serverStats.memBuffers")}: {serverStats.memBuffers !== null ? `${(serverStats.memBuffers / 1024).toFixed(1)}G` : '--'}
{t("terminal.serverStats.memCached")}: {serverStats.memCached !== null ? `${(serverStats.memCached / 1024).toFixed(1)}G` : '--'}
{t("terminal.serverStats.memFree")}: {serverStats.memFree !== null ? `${(serverStats.memFree / 1024).toFixed(1)}G` : '--'}
)} {/* Top 10 processes */} {serverStats.topProcesses.length > 0 && (
{t("terminal.serverStats.topProcesses")}
{serverStats.topProcesses.map((proc, index) => (
{proc.memPercent.toFixed(1)}%
{proc.command.split('/').pop()?.split(' ')[0] || proc.command}
))}
)}
{/* Disk - with HoverCard for disk details */}
{t("terminal.serverStats.diskDetails")}
{serverStats.disks.length > 0 ? (
{serverStats.disks.map((disk, index) => (
{disk.mountPoint} = 90 ? "text-red-400" : disk.percent >= 80 ? "text-amber-400" : "text-emerald-400" )}> {disk.used}/{disk.total}G ({disk.percent}%)
= 90 ? "bg-red-500" : disk.percent >= 80 ? "bg-amber-500" : "bg-emerald-500" )} style={{ width: `${disk.percent}%` }} />
))}
) : (
{t("terminal.serverStats.noData")}
)}
{/* Network - with HoverCard for per-interface details */} {serverStats.netInterfaces.length > 0 && (
{t("terminal.serverStats.networkDetails")}
{serverStats.netInterfaces.map((iface, index) => (
{iface.name}
{formatNetSpeed(iface.rxSpeed)} {formatNetSpeed(iface.txSpeed)}
))}
)}
)}
{inWorkspace && onToggleBroadcast && ( )} {inWorkspace && !isFocusMode && onExpandToFocus && ( )} {renderControls({ showClose: inWorkspace })}
{isSearchOpen && (
)}
{needsHostKeyVerification && pendingHostKeyInfo && (
)} {/* Connection dialog: skip for local/serial during connecting phase, but show on error */} {status !== "connected" && !needsHostKeyVerification && !( (isLocalConnection || isSerialConnection) && status === "connecting" ) && ( auth.submit(), onSubmitWithoutSave: () => auth.submit({ saveToHost: false }), onCancel: handleCancelConnect, isValid: auth.isValid, }} progressProps={{ timeLeft, isCancelling, progressLogs, onCancel: handleCancelConnect, onRetry: handleRetry, }} /> )}
{ const resolvedAuth = resolveHostAuth({ host, keys, identities }); // Build proxy config if present const proxyConfig = host.proxyConfig ? { type: host.proxyConfig.type, host: host.proxyConfig.host, port: host.proxyConfig.port, username: host.proxyConfig.username, password: host.proxyConfig.password, } : undefined; // Build jump hosts array if host chain is configured let jumpHosts: NetcattyJumpHost[] | undefined; if (host.hostChain?.hostIds && host.hostChain.hostIds.length > 0) { jumpHosts = host.hostChain.hostIds .map((hostId) => allHosts.find((h) => h.id === hostId)) .filter((h): h is Host => !!h) .map((jumpHost) => { const jumpAuth = resolveHostAuth({ host: jumpHost, keys, identities, }); const jumpKey = jumpAuth.key; return { hostname: jumpHost.hostname, port: jumpHost.port || 22, username: jumpAuth.username || "root", password: jumpAuth.password, privateKey: jumpKey?.privateKey, certificate: jumpKey?.certificate, passphrase: jumpAuth.passphrase || jumpKey?.passphrase, publicKey: jumpKey?.publicKey, keyId: jumpAuth.keyId, keySource: jumpKey?.source, label: jumpHost.label, }; }); } return { username: resolvedAuth.username, hostname: host.hostname, port: host.port, password: resolvedAuth.password, privateKey: resolvedAuth.key?.privateKey, certificate: resolvedAuth.key?.certificate, passphrase: resolvedAuth.passphrase, publicKey: resolvedAuth.key?.publicKey, keyId: resolvedAuth.keyId, keySource: resolvedAuth.key?.source, proxy: proxyConfig, jumpHosts: jumpHosts && jumpHosts.length > 0 ? jumpHosts : undefined, sftpSudo: host.sftpSudo, }; })()} open={showSFTP && status === "connected"} onClose={() => { setShowSFTP(false); setPendingUploadEntries([]); }} initialPath={sftpInitialPath} initialEntriesToUpload={pendingUploadEntries} />
); }; const Terminal = memo(TerminalComponent); Terminal.displayName = "Terminal"; export default Terminal;