Files
Netcatty/components/KnownHostsManager.tsx
T
LAPTOP-O016UC3M\Qi Chen e00fa2733b Renames app and codebase from Nebula to Netcatty
Updates all code references, IPC channels, CSS classes, and storage keys
from "nebula" to "netcatty" to align with new branding and application identity.
Ensures consistency across frontend, Electron backend, global types,
and package metadata.
2025-12-11 18:42:01 +08:00

616 lines
19 KiB
TypeScript

import {
ArrowRight,
ChevronDown,
Clock,
FolderOpen,
Import,
Key,
LayoutGrid,
List as ListIcon,
RefreshCw,
Search,
Server,
Shield,
Trash2,
} from "lucide-react";
import React, {
memo,
useCallback,
useDeferredValue,
useEffect,
useMemo,
useState,
} from "react";
import { cn } from "../lib/utils";
import { Host, KnownHost } from "../types";
import { Button } from "./ui/button";
import { Dropdown, DropdownContent, DropdownTrigger } from "./ui/dropdown";
import { Input } from "./ui/input";
import { ScrollArea } from "./ui/scroll-area";
import { SortDropdown, SortMode } from "./ui/sort-dropdown";
interface KnownHostsManagerProps {
knownHosts: KnownHost[];
hosts: Host[];
onSave: (knownHost: KnownHost) => void;
onUpdate: (knownHost: KnownHost) => void;
onDelete: (id: string) => void;
onConvertToHost: (knownHost: KnownHost) => void;
onImportFromFile: (hosts: KnownHost[]) => void;
onRefresh: () => void;
}
type ViewMode = "grid" | "list";
// Helper functions outside component for stable references
const formatDateFn = (timestamp: number) => {
return new Date(timestamp).toLocaleDateString("en-US", {
year: "numeric",
month: "short",
day: "numeric",
});
};
const getKeyTypeColorFn = (keyType: string) => {
switch (keyType.toLowerCase()) {
case "ssh-ed25519":
return "text-emerald-500";
case "ssh-rsa":
return "text-amber-500";
case "ecdsa-sha2-nistp256":
case "ecdsa-sha2-nistp384":
case "ecdsa-sha2-nistp521":
return "text-blue-500";
default:
return "text-muted-foreground";
}
};
// Parse known_hosts file content - pure function, moved outside component
const parseKnownHostsFile = (content: string): KnownHost[] => {
const lines = content
.split("\n")
.filter((line) => line.trim() && !line.startsWith("#"));
const parsed: KnownHost[] = [];
for (const line of lines) {
try {
const parts = line.trim().split(/\s+/);
if (parts.length < 3) continue;
const [hostPattern, keyType, publicKey] = parts;
let hostname = hostPattern;
let port = 22;
const bracketMatch = hostPattern.match(/^\[([^\]]+)\]:(\d+)$/);
if (bracketMatch) {
hostname = bracketMatch[1];
port = parseInt(bracketMatch[2], 10);
} else if (hostPattern.includes(",")) {
hostname = hostPattern.split(",")[0];
}
if (hostname.startsWith("|1|")) {
hostname = "(hashed)";
}
parsed.push({
id: `kh-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
hostname,
port,
keyType,
publicKey: publicKey.slice(0, 64) + "...",
discoveredAt: Date.now(),
});
} catch {
console.warn("Failed to parse known_hosts line:", line);
}
}
return parsed;
};
// Memoized Grid Item Component
interface HostItemProps {
knownHost: KnownHost;
converted: boolean;
viewMode: ViewMode;
onDelete: (id: string) => void;
onConvertToHost: (knownHost: KnownHost) => void;
}
const HostItem = React.memo<HostItemProps>(
({ knownHost, converted, viewMode, onDelete, onConvertToHost }) => {
// Disabled to reduce log noise - uncomment for debugging
// console.log('[HostItem] render:', knownHost.hostname);
if (viewMode === "grid") {
return (
<div
className={cn(
"group cursor-pointer soft-card elevate rounded-xl h-[68px] px-3 py-2",
converted && "opacity-60",
)}
>
{/* Quick action buttons on hover */}
<div className="absolute top-1 right-1 flex gap-0.5 opacity-0 group-hover:opacity-100 transition-opacity">
{!converted && (
<button
className="p-1 rounded hover:bg-primary/20 text-primary"
onClick={(e) => {
e.stopPropagation();
onConvertToHost(knownHost);
}}
title="Convert to host"
>
<ArrowRight size={12} />
</button>
)}
<button
className="p-1 rounded hover:bg-destructive/20 text-destructive"
onClick={(e) => {
e.stopPropagation();
onDelete(knownHost.id);
}}
title="Remove"
>
<Trash2 size={12} />
</button>
</div>
<div className="flex items-center gap-3 h-full">
<div className="h-11 w-11 rounded-xl bg-primary/10 text-primary flex items-center justify-center flex-shrink-0">
<Server size={18} />
</div>
<div className="flex-1 min-w-0">
<div className="flex items-center gap-2">
<span className="text-sm font-semibold truncate">
{knownHost.hostname}
</span>
{knownHost.port !== 22 && (
<span className="text-xs text-muted-foreground">
:{knownHost.port}
</span>
)}
</div>
<div className="text-[11px] text-muted-foreground truncate">
<span className={cn(getKeyTypeColorFn(knownHost.keyType))}>
{knownHost.keyType}
</span>
</div>
</div>
</div>
</div>
);
}
// List view
return (
<div
className={cn(
"group flex items-center gap-3 px-3 py-2 h-14 rounded-lg hover:bg-secondary/60 transition-colors cursor-pointer",
converted && "opacity-60",
)}
>
<div className="h-11 w-11 rounded-xl bg-primary/10 text-primary flex items-center justify-center flex-shrink-0">
<Server size={18} />
</div>
<div className="flex-1 min-w-0">
<div className="flex items-center gap-2">
<span className="text-sm font-semibold truncate">
{knownHost.hostname}
</span>
{knownHost.port !== 22 && (
<span className="text-xs text-muted-foreground">
:{knownHost.port}
</span>
)}
{converted && (
<span className="text-[10px] px-1.5 py-0.5 rounded bg-emerald-500/20 text-emerald-500">
Managed
</span>
)}
</div>
<div className="flex items-center gap-3 text-xs text-muted-foreground">
<span
className={cn(
"flex items-center gap-1",
getKeyTypeColorFn(knownHost.keyType),
)}
>
<Key size={10} />
{knownHost.keyType}
</span>
<span className="flex items-center gap-1">
<Clock size={10} />
{formatDateFn(knownHost.discoveredAt)}
</span>
</div>
</div>
<div className="flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-opacity">
{!converted && (
<Button
variant="ghost"
size="icon"
className="h-8 w-8"
onClick={(e) => {
e.stopPropagation();
onConvertToHost(knownHost);
}}
title="Convert to managed host"
>
<ArrowRight size={14} />
</Button>
)}
</div>
</div>
);
},
);
HostItem.displayName = "HostItem";
const KnownHostsManager: React.FC<KnownHostsManagerProps> = ({
knownHosts,
hosts,
onSave: _onSave,
onUpdate: _onUpdate,
onDelete,
onConvertToHost,
onImportFromFile,
onRefresh,
}) => {
// Debug: track renders
const renderCountRef = React.useRef(0);
renderCountRef.current++;
console.log(
`[KnownHostsManager] render #${renderCountRef.current} - knownHosts: ${knownHosts.length}, hosts: ${hosts.length}`,
);
const [search, setSearch] = useState("");
const deferredSearch = useDeferredValue(search);
const [isScanning, setIsScanning] = useState(false);
const [viewMode, setViewMode] = useState<ViewMode>("grid");
const [sortMode, setSortMode] = useState<SortMode>("newest");
const fileInputRef = React.useRef<HTMLInputElement>(null);
const hasScannedRef = React.useRef(false);
const RENDER_LIMIT = 100; // Limit rendered items for performance
// Define handleScanSystem before useEffect that depends on it
const handleScanSystem = useCallback(async () => {
setIsScanning(true);
// Try to read from common known_hosts locations via Electron
if (window.netcatty?.readKnownHosts) {
try {
const content = await window.netcatty.readKnownHosts();
if (content) {
const parsed = parseKnownHostsFile(content);
const existingHostnames = new Set(
knownHosts.map((h) => `${h.hostname}:${h.port}`),
);
const newHosts = parsed.filter(
(h) => !existingHostnames.has(`${h.hostname}:${h.port}`),
);
// Directly import new hosts without dialog
if (newHosts.length > 0) {
onImportFromFile(newHosts);
}
}
} catch (err) {
console.error("Failed to scan system known_hosts:", err);
}
}
onRefresh();
setIsScanning(false);
}, [knownHosts, onRefresh, onImportFromFile]);
// Auto-scan on first mount
useEffect(() => {
if (!hasScannedRef.current) {
hasScannedRef.current = true;
// Delay scan slightly to not block initial render
const timer = setTimeout(() => {
handleScanSystem();
}, 100);
return () => clearTimeout(timer);
}
}, [handleScanSystem]);
// Sort and filter hosts
const filteredHosts = useMemo(() => {
let result = knownHosts;
// Filter by search
if (deferredSearch.trim()) {
const term = deferredSearch.toLowerCase();
result = result.filter(
(h) =>
h.hostname.toLowerCase().includes(term) ||
h.keyType.toLowerCase().includes(term),
);
}
// Sort
result = [...result].sort((a, b) => {
switch (sortMode) {
case "az":
return a.hostname.localeCompare(b.hostname);
case "za":
return b.hostname.localeCompare(a.hostname);
case "newest":
return b.discoveredAt - a.discoveredAt;
case "oldest":
return a.discoveredAt - b.discoveredAt;
default:
return 0;
}
});
return result;
}, [knownHosts, deferredSearch, sortMode]);
// Limit rendered items for performance
const displayedHosts = useMemo(() => {
return filteredHosts.slice(0, RENDER_LIMIT);
}, [filteredHosts]);
const hasMore = filteredHosts.length > RENDER_LIMIT;
const handleFileSelect = useCallback(
(e: React.ChangeEvent<HTMLInputElement>) => {
const file = e.target.files?.[0];
if (!file) return;
const reader = new FileReader();
reader.onload = (event) => {
const content = event.target?.result as string;
const parsed = parseKnownHostsFile(content);
// Filter out already existing hosts and directly import
const existingHostnames = new Set(
knownHosts.map((h) => `${h.hostname}:${h.port}`),
);
const newHosts = parsed.filter(
(h) => !existingHostnames.has(`${h.hostname}:${h.port}`),
);
if (newHosts.length > 0) {
onImportFromFile(newHosts);
}
};
reader.readAsText(file);
// Reset file input
if (fileInputRef.current) {
fileInputRef.current.value = "";
}
},
[knownHosts, onImportFromFile],
);
// Memoize host lookup for performance
const hostIdSet = useMemo(() => new Set(hosts.map((h) => h.id)), [hosts]);
// Pre-compute converted status for all known hosts
const convertedMap = useMemo(() => {
const map = new Map<string, boolean>();
for (const kh of knownHosts) {
if (kh.convertedToHostId) {
map.set(kh.id, hostIdSet.has(kh.convertedToHostId));
} else {
map.set(kh.id, false);
}
}
return map;
}, [knownHosts, hostIdSet]);
// Memoized handlers to prevent re-renders
const handleDelete = useCallback(
(id: string) => {
onDelete(id);
},
[onDelete],
);
const handleConvertToHost = useCallback(
(knownHost: KnownHost) => {
onConvertToHost(knownHost);
},
[onConvertToHost],
);
const openFilePicker = useCallback(() => fileInputRef.current?.click(), []);
// Memoize the rendered list to prevent re-renders
const renderedItems = useMemo(() => {
console.log(
"[KnownHostsManager] renderedItems useMemo recalculated - displayedHosts:",
displayedHosts.length,
);
return displayedHosts.map((knownHost) => (
<HostItem
key={knownHost.id}
knownHost={knownHost}
converted={convertedMap.get(knownHost.id) || false}
viewMode={viewMode}
onDelete={handleDelete}
onConvertToHost={handleConvertToHost}
/>
));
}, [
displayedHosts,
convertedMap,
viewMode,
handleDelete,
handleConvertToHost,
]);
console.log("[KnownHostsManager] about to return JSX");
return (
<div className="h-full flex flex-col">
{/* Header */}
<div className="flex items-center gap-3 px-4 py-3 border-b border-border/50 bg-secondary/50">
<div className="flex-1 min-w-0 flex items-center gap-2">
<div className="relative flex-1 max-w-xs">
<Search
size={14}
className="absolute left-3 top-1/2 -translate-y-1/2 text-muted-foreground"
/>
<Input
placeholder="Search known hosts..."
className="pl-9 h-9 bg-background border-border/60 text-sm"
value={search}
onChange={(e) => setSearch(e.target.value)}
/>
</div>
</div>
<div className="flex items-center gap-1">
{/* View Mode Toggle */}
<Dropdown>
<DropdownTrigger asChild>
<Button variant="ghost" size="icon" className="h-9 w-9">
{viewMode === "grid" ? (
<LayoutGrid size={16} />
) : (
<ListIcon size={16} />
)}
<ChevronDown size={10} className="ml-0.5" />
</Button>
</DropdownTrigger>
<DropdownContent className="w-32" align="end">
<Button
variant={viewMode === "grid" ? "secondary" : "ghost"}
className="w-full justify-start gap-2 h-9"
onClick={() => setViewMode("grid")}
>
<LayoutGrid size={14} /> Grid
</Button>
<Button
variant={viewMode === "list" ? "secondary" : "ghost"}
className="w-full justify-start gap-2 h-9"
onClick={() => setViewMode("list")}
>
<ListIcon size={14} /> List
</Button>
</DropdownContent>
</Dropdown>
{/* Sort Toggle */}
<SortDropdown
value={sortMode}
onChange={setSortMode}
className="h-9 w-9"
/>
</div>
<div className="w-px h-5 bg-border/50" />
<div className="flex items-center gap-2">
<Button
variant="ghost"
size="sm"
className="h-9 px-3 text-xs"
onClick={handleScanSystem}
disabled={isScanning}
>
<RefreshCw
size={14}
className={cn("mr-2", isScanning && "animate-spin")}
/>
Scan System
</Button>
<input
ref={fileInputRef}
type="file"
accept=".txt,known_hosts"
className="hidden"
onChange={handleFileSelect}
/>
<Button
variant="secondary"
size="sm"
className="h-9 px-3 text-xs"
onClick={openFilePicker}
>
<Import size={14} className="mr-2" />
Import File
</Button>
</div>
</div>
{/* Content */}
<ScrollArea className="flex-1">
<div
className={cn(
"p-4",
viewMode === "grid"
? "grid grid-cols-2 sm:grid-cols-3 xl:grid-cols-4 gap-3"
: "flex flex-col gap-0",
)}
>
{displayedHosts.length === 0 ? (
<div
className={cn(
"flex flex-col items-center justify-center py-16 text-muted-foreground",
viewMode === "grid" && "col-span-full",
)}
>
<div className="h-16 w-16 rounded-2xl bg-secondary/80 flex items-center justify-center mb-4">
<Shield size={32} className="opacity-60" />
</div>
<h3 className="text-lg font-semibold text-foreground mb-2">
No Known Hosts
</h3>
<p className="text-sm text-center max-w-sm mb-4">
Known hosts are SSH servers you've connected to before. Import
from your system's known_hosts file to get started.
</p>
<div className="flex gap-2">
<Button
variant="secondary"
onClick={handleScanSystem}
disabled={isScanning}
>
<RefreshCw
size={14}
className={cn("mr-2", isScanning && "animate-spin")}
/>
Scan System
</Button>
<Button variant="outline" onClick={openFilePicker}>
<FolderOpen size={14} className="mr-2" />
Browse File
</Button>
</div>
</div>
) : (
<>
{renderedItems}
{hasMore && (
<div
className={cn(
"text-center py-4 text-sm text-muted-foreground",
viewMode === "grid" && "col-span-full",
)}
>
Showing {RENDER_LIMIT} of {filteredHosts.length} hosts. Use
search to find specific hosts.
</div>
)}
</>
)}
</div>
</ScrollArea>
</div>
);
};
// Custom comparison - only compare data props, not callbacks
const knownHostsManagerAreEqual = (
prev: KnownHostsManagerProps,
next: KnownHostsManagerProps,
): boolean => {
return prev.knownHosts === next.knownHosts && prev.hosts === next.hosts;
};
export default memo(KnownHostsManager, knownHostsManagerAreEqual);