import { useCallback, useEffect, useRef, useState } from "react"; import { migrateHostsFromLegacyLineTimestamps, normalizeDistroId, sanitizeHost } from "../../domain/host"; import { sanitizeGroupConfig } from "../../domain/groupConfig"; import { normalizeKnownHosts } from "../../domain/knownHosts"; import { ConnectionLog, GroupConfig, Host, Identity, KeyCategory, KnownHost, ManagedSource, ProxyProfile, ShellHistoryEntry, Snippet, SSHKey, } from "../../domain/models"; import { INITIAL_HOSTS, INITIAL_SNIPPETS, } from "../../infrastructure/config/defaultData"; import { STORAGE_KEY_CONNECTION_LOGS, STORAGE_KEY_GROUP_CONFIGS, STORAGE_KEY_GROUPS, STORAGE_KEY_HOSTS, STORAGE_KEY_IDENTITIES, STORAGE_KEY_KEYS, STORAGE_KEY_KNOWN_HOSTS, STORAGE_KEY_LEGACY_KEYS, STORAGE_KEY_MANAGED_SOURCES, STORAGE_KEY_PROXY_PROFILES, STORAGE_KEY_SHELL_HISTORY, STORAGE_KEY_SNIPPET_PACKAGES, STORAGE_KEY_SNIPPETS, STORAGE_KEY_TERM_SETTINGS, } from "../../infrastructure/config/storageKeys"; import { localStorageAdapter } from "../../infrastructure/persistence/localStorageAdapter"; import { mergeGlobalHistoryOnAppend, sanitizeGlobalHistoryEntries } from "../../domain/globalHistory"; import { getNextVaultOrder, normalizeVaultOrder } from "../../domain/vaultOrder"; import { loadSanitizedShellHistory } from "./shellHistoryPersistence"; import { decryptGroupConfigs, decryptHosts, decryptIdentities, decryptKeys, decryptProxyProfiles, encryptGroupConfigs, encryptHosts, encryptIdentities, encryptKeys, encryptProxyProfiles, } from "../../infrastructure/persistence/secureFieldAdapter"; type ExportableVaultData = { hosts: Host[]; keys: SSHKey[]; identities?: Identity[]; proxyProfiles?: ProxyProfile[]; snippets: Snippet[]; customGroups: string[]; snippetPackages?: string[]; knownHosts?: KnownHost[]; groupConfigs?: GroupConfig[]; }; type LegacyKeyRecord = Record & { id?: string; source?: string }; // Migration helper for old SSHKey format to new format const migrateKey = (key: Partial): SSHKey => { const id = key.id ?? crypto.randomUUID(); const label = key.label ?? `Key ${id.slice(0, 8)}`; const source = key.source === "generated" || key.source === "imported" || key.source === "reference" ? key.source : key.privateKey ? "imported" : "generated"; return { id, label, type: key.type || "ED25519", privateKey: key.privateKey || "", publicKey: key.publicKey, certificate: key.certificate, passphrase: key.passphrase, savePassphrase: key.savePassphrase, source, category: key.category || ((key.certificate ? "certificate" : "key") as KeyCategory), created: key.created || Date.now(), filePath: key.filePath, order: key.order, }; }; const isLegacyUnsupportedKey = (key: LegacyKeyRecord): boolean => { const source = key.source; if (source === "biometric" || source === "fido2" || source === "passkey") return true; // Legacy experimental WebAuthn fields if ("credentialId" in key || "rpId" in key || "userVerification" in key) return true; return false; }; const safeParse = (value: string | null): T | null => { if (!value) return null; try { return JSON.parse(value) as T; } catch { return null; } }; /** * Strip the bulky `terminalData` replay buffer from transient (unsaved) * connection logs before persisting. `terminalData` is the full terminal * scrollback for a session; with up to 500 logs it grew the * `netcatty_connection_logs_v1` localStorage blob to ~11 MB, and every * add/update re-serialized + wrote the whole thing synchronously * (50–73 ms on the main thread), causing freezes on connect/disconnect. * * The full `terminalData` stays in the in-memory React state (so in-session * replay still works); only explicitly *saved* logs keep it on disk. This * keeps the persisted blob small and writes fast. */ const pruneConnectionLogsForStorage = (logs: ConnectionLog[]): ConnectionLog[] => { let changed = false; const next = logs.map((log) => { if (log.saved || log.terminalData === undefined) return log; changed = true; const { terminalData: _omitted, ...rest } = log; return rest; }); return changed ? next : logs; }; const readLegacyLineTimestampsEnabled = (): boolean => { const stored = localStorageAdapter.read>(STORAGE_KEY_TERM_SETTINGS); return stored?.showLineTimestamps === true; }; export const useVaultState = () => { const [isInitialized, setIsInitialized] = useState(false); const [hosts, setHosts] = useState([]); const [keys, setKeys] = useState([]); const [identities, setIdentities] = useState([]); const [proxyProfiles, setProxyProfiles] = useState([]); const [snippets, setSnippets] = useState([]); const [customGroups, setCustomGroups] = useState([]); const [snippetPackages, setSnippetPackages] = useState([]); const [knownHosts, setKnownHosts] = useState([]); const [shellHistory, setShellHistory] = useState([]); const [connectionLogs, setConnectionLogs] = useState([]); const [managedSources, setManagedSources] = useState([]); const [groupConfigs, setGroupConfigs] = useState([]); // Write-version counters prevent out-of-order async writes from overwriting // newer data. Each update bumps the counter; the .then() callback only // persists if its version still matches the latest. const hostsWriteVersion = useRef(0); const keysWriteVersion = useRef(0); const identitiesWriteVersion = useRef(0); const proxyProfilesWriteVersion = useRef(0); const groupConfigsWriteVersion = useRef(0); // Read-sequence counters for cross-window storage events. Each incoming // event bumps the counter; the async decrypt callback only applies state if // its sequence still matches, preventing stale decrypts from overwriting // newer data when multiple events arrive in quick succession. const hostsReadSeq = useRef(0); const keysReadSeq = useRef(0); const identitiesReadSeq = useRef(0); const proxyProfilesReadSeq = useRef(0); const groupConfigsReadSeq = useRef(0); const updateHosts = useCallback((data: Host[]) => { const cleaned = normalizeVaultOrder(data.map(sanitizeHost)); setHosts(cleaned); const ver = ++hostsWriteVersion.current; return encryptHosts(cleaned).then((enc) => { if (ver === hostsWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_HOSTS, enc); }); }, []); const updateKeys = useCallback((data: SSHKey[]) => { const cleaned = normalizeVaultOrder(data); setKeys(cleaned); const ver = ++keysWriteVersion.current; return encryptKeys(cleaned).then((enc) => { if (ver === keysWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_KEYS, enc); }); }, []); const importOrReuseKey = useCallback((draft: Partial): SSHKey => { const existing = keys.find((k) => { if (draft.source === 'reference' && draft.filePath) { return k.source === 'reference' && k.filePath === draft.filePath; } if (draft.privateKey) { return k.privateKey === draft.privateKey; } return false; }); if (existing) return existing; const newKey: SSHKey = { id: crypto.randomUUID(), label: draft.label || 'Imported Key', type: draft.type || 'ED25519', privateKey: draft.privateKey || '', publicKey: draft.publicKey, certificate: draft.certificate, passphrase: draft.passphrase, savePassphrase: draft.savePassphrase, source: draft.source || 'imported', category: (draft.category || 'key') as KeyCategory, created: Date.now(), filePath: draft.filePath, order: getNextVaultOrder(keys), }; const updated = normalizeVaultOrder([...keys, newKey]); setKeys(updated); const ver = ++keysWriteVersion.current; void encryptKeys(updated).then((enc) => { if (ver === keysWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_KEYS, enc); }); return newKey; }, [keys]); const updateIdentities = useCallback((data: Identity[]) => { const cleaned = normalizeVaultOrder(data); setIdentities(cleaned); const ver = ++identitiesWriteVersion.current; return encryptIdentities(cleaned).then((enc) => { if (ver === identitiesWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_IDENTITIES, enc); }); }, []); const updateProxyProfiles = useCallback((data: ProxyProfile[]) => { const cleaned = normalizeVaultOrder(data); setProxyProfiles(cleaned); const ver = ++proxyProfilesWriteVersion.current; return encryptProxyProfiles(cleaned).then((enc) => { if (ver === proxyProfilesWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_PROXY_PROFILES, enc); }); }, []); const updateSnippets = useCallback((data: Snippet[]) => { const cleaned = normalizeVaultOrder(data); setSnippets(cleaned); localStorageAdapter.write(STORAGE_KEY_SNIPPETS, cleaned); }, []); const updateSnippetPackages = useCallback((data: string[]) => { setSnippetPackages(data); localStorageAdapter.write(STORAGE_KEY_SNIPPET_PACKAGES, data); }, []); const updateCustomGroups = useCallback((data: string[]) => { setCustomGroups(data); localStorageAdapter.write(STORAGE_KEY_GROUPS, data); const groupOrderByPath = new Map( data.map((path, index) => [path, (index + 1) * 1000]), ); const existingConfigByPath = new Map( groupConfigs.map((config) => [config.path, config]), ); const orderedConfigs = data.map((path) => { const existing = existingConfigByPath.get(path); const base: GroupConfig = existing ? { ...existing } : { path }; return sanitizeGroupConfig({ ...base, path, order: groupOrderByPath.get(path), }); }); const retainedConfigs = groupConfigs.filter((config) => !groupOrderByPath.has(config.path)); const cleanedGroupConfigs = normalizeVaultOrder([ ...orderedConfigs, ...retainedConfigs.map(sanitizeGroupConfig), ]); setGroupConfigs(cleanedGroupConfigs); const ver = ++groupConfigsWriteVersion.current; void encryptGroupConfigs(cleanedGroupConfigs).then((enc) => { if (ver === groupConfigsWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_GROUP_CONFIGS, enc); }); }, [groupConfigs]); const updateKnownHosts = useCallback((data: KnownHost[]) => { const cleaned = normalizeVaultOrder(data); setKnownHosts(cleaned); localStorageAdapter.write(STORAGE_KEY_KNOWN_HOSTS, cleaned); }, []); const updateManagedSources = useCallback((data: ManagedSource[]) => { setManagedSources(data); localStorageAdapter.write(STORAGE_KEY_MANAGED_SOURCES, data); }, []); const updateGroupConfigs = useCallback((data: GroupConfig[]) => { // Sanitize on the write path too — applySyncPayload / importVaultData // route legacy payloads through here, and without this step a saved // pingfang-sc / comic-sans-ms override from an older client would // sit in memory and re-persist with `fontFamilyOverride: true` until // the next reload. Mirrors updateHosts → sanitizeHost. const cleaned = normalizeVaultOrder(data.map(sanitizeGroupConfig)); setGroupConfigs(cleaned); const ver = ++groupConfigsWriteVersion.current; return encryptGroupConfigs(cleaned).then((enc) => { if (ver === groupConfigsWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_GROUP_CONFIGS, enc); }); }, []); const clearVaultData = useCallback(() => { updateHosts([]); updateKeys([]); updateIdentities([]); updateProxyProfiles([]); updateSnippets([]); updateSnippetPackages([]); updateCustomGroups([]); updateKnownHosts([]); updateManagedSources([]); updateGroupConfigs([]); localStorageAdapter.remove(STORAGE_KEY_LEGACY_KEYS); }, [ updateHosts, updateKeys, updateIdentities, updateProxyProfiles, updateSnippets, updateSnippetPackages, updateCustomGroups, updateKnownHosts, updateManagedSources, updateGroupConfigs, ]); const addShellHistoryEntry = useCallback( (entry: Omit) => { setShellHistory((prev) => { const updated = mergeGlobalHistoryOnAppend(prev, entry); if (updated === prev) return prev; localStorageAdapter.write(STORAGE_KEY_SHELL_HISTORY, updated); return updated; }); }, [], ); const clearShellHistory = useCallback(() => { setShellHistory([]); localStorageAdapter.write(STORAGE_KEY_SHELL_HISTORY, []); }, []); // Connection logs management const addConnectionLog = useCallback( (log: Omit) => { const newLog: ConnectionLog = { ...log, id: crypto.randomUUID(), }; setConnectionLogs((prev) => { // Keep only the last 500 non-saved entries plus all saved entries const savedLogs = prev.filter((l) => l.saved); const unsavedLogs = prev.filter((l) => !l.saved); const updated = [newLog, ...unsavedLogs].slice(0, 500); const final = [...updated, ...savedLogs].sort( (a, b) => b.startTime - a.startTime ); localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, pruneConnectionLogsForStorage(final)); return final; }); return newLog.id; }, [] ); const updateConnectionLog = useCallback( (id: string, updates: Partial) => { setConnectionLogs((prev) => { const updated = prev.map((log) => log.id === id ? { ...log, ...updates } : log ); localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, pruneConnectionLogsForStorage(updated)); return updated; }); }, [] ); const toggleConnectionLogSaved = useCallback((id: string) => { setConnectionLogs((prev) => { const updated = prev.map((log) => log.id === id ? { ...log, saved: !log.saved } : log ); localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, updated); return updated; }); }, []); const deleteConnectionLog = useCallback((id: string) => { setConnectionLogs((prev) => { const updated = prev.filter((log) => log.id !== id); localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, updated); return updated; }); }, []); const clearUnsavedConnectionLogs = useCallback(() => { setConnectionLogs((prev) => { const saved = prev.filter((log) => log.saved); localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, pruneConnectionLogsForStorage(saved)); return saved; }); }, []); // Convert a known host to a managed host const convertKnownHostToHost = useCallback((knownHost: KnownHost): Host => { const newHost: Host = { id: `host-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`, label: knownHost.hostname, hostname: knownHost.hostname, port: knownHost.port, username: "", // Will be set when connecting os: "linux", group: "", tags: [], protocol: "ssh", order: getNextVaultOrder(hosts), }; // Update the known host to mark it as converted using functional update setKnownHosts((prevKnownHosts) => { const updated = prevKnownHosts.map((kh) => kh.id === knownHost.id ? { ...kh, convertedToHostId: newHost.id } : kh, ); localStorageAdapter.write(STORAGE_KEY_KNOWN_HOSTS, updated); return updated; }); // Add to hosts using functional update setHosts((prevHosts) => { const updated = normalizeVaultOrder([...prevHosts, sanitizeHost(newHost)]); const ver = ++hostsWriteVersion.current; encryptHosts(updated).then((enc) => { if (ver === hostsWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_HOSTS, enc); }); return updated; }); return newHost; }, [hosts]); useEffect(() => { const init = async () => { try { const savedHosts = localStorageAdapter.read(STORAGE_KEY_HOSTS); if (savedHosts) { // Capture version before the async gap so that any write occurring // during decryption (storage event, user edit) advances the counter // and causes this stale result to be discarded. const ver = ++hostsWriteVersion.current; const decrypted = await decryptHosts(savedHosts); if (ver === hostsWriteVersion.current) { const sanitized = normalizeVaultOrder( migrateHostsFromLegacyLineTimestamps( decrypted.map(sanitizeHost), readLegacyLineTimestampsEnabled(), ), ); setHosts(sanitized); encryptHosts(sanitized).then((enc) => { if (ver === hostsWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_HOSTS, enc); }); } } else { updateHosts(INITIAL_HOSTS); } // Read keys fresh here (not before the hosts await) so we don't apply // a stale snapshot if keys were updated during host decryption. const savedKeysRaw = localStorageAdapter.read(STORAGE_KEY_KEYS); // Migrate old keys to new format with source/category fields if (savedKeysRaw?.length) { const migratedKeys: SSHKey[] = []; const legacyKeys: LegacyKeyRecord[] = []; for (const entry of savedKeysRaw) { const record = entry && typeof entry === "object" ? (entry as LegacyKeyRecord) : null; if (!record) continue; if (isLegacyUnsupportedKey(record)) { legacyKeys.push(record); continue; } migratedKeys.push(migrateKey(record as Partial)); } // Decrypt sensitive fields (passphrase, privateKey) const keyVer = ++keysWriteVersion.current; const decryptedKeys = await decryptKeys(migratedKeys); if (keyVer === keysWriteVersion.current) { const orderedKeys = normalizeVaultOrder(decryptedKeys); setKeys(orderedKeys); encryptKeys(orderedKeys).then((enc) => { if (keyVer === keysWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_KEYS, enc); }); } if (legacyKeys.length) { localStorageAdapter.write(STORAGE_KEY_LEGACY_KEYS, legacyKeys); } } // Read identities fresh here (not before the hosts/keys awaits) so we // don't apply a stale snapshot if identities were updated during prior decryption. const savedIdentities = localStorageAdapter.read(STORAGE_KEY_IDENTITIES); if (savedIdentities) { const idVer = ++identitiesWriteVersion.current; const decryptedIds = await decryptIdentities(savedIdentities); if (idVer === identitiesWriteVersion.current) { const orderedIdentities = normalizeVaultOrder(decryptedIds); setIdentities(orderedIdentities); encryptIdentities(orderedIdentities).then((enc) => { if (idVer === identitiesWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_IDENTITIES, enc); }); } } const savedProxyProfiles = localStorageAdapter.read(STORAGE_KEY_PROXY_PROFILES); if (savedProxyProfiles) { const proxyVer = ++proxyProfilesWriteVersion.current; const decryptedProfiles = await decryptProxyProfiles(savedProxyProfiles); if (proxyVer === proxyProfilesWriteVersion.current) { const orderedProfiles = normalizeVaultOrder(decryptedProfiles); setProxyProfiles(orderedProfiles); encryptProxyProfiles(orderedProfiles).then((enc) => { if (proxyVer === proxyProfilesWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_PROXY_PROFILES, enc); }); } } // Read remaining non-encrypted data fresh after all async gaps above const savedGroups = localStorageAdapter.read(STORAGE_KEY_GROUPS); const savedSnippets = localStorageAdapter.read(STORAGE_KEY_SNIPPETS); const savedSnippetPackages = localStorageAdapter.read( STORAGE_KEY_SNIPPET_PACKAGES, ); if (savedSnippets) { const orderedSnippets = normalizeVaultOrder(savedSnippets); setSnippets(orderedSnippets); localStorageAdapter.write(STORAGE_KEY_SNIPPETS, orderedSnippets); } else updateSnippets(INITIAL_SNIPPETS); if (savedGroups) setCustomGroups(savedGroups); if (savedSnippetPackages) setSnippetPackages(savedSnippetPackages); // Load known hosts. Records imported from `~/.ssh/known_hosts` and // records saved by older builds may be missing the `fingerprint` / // `keyType` fields the verifier compares against; backfill them now // so the next SSH connect can match without falling into the brittle // re-derivation path that caused the repeated "fingerprint changed" // warnings in #972. const savedKnownHosts = localStorageAdapter.read( STORAGE_KEY_KNOWN_HOSTS, ); if (savedKnownHosts) { const normalized = normalizeKnownHosts(savedKnownHosts); const orderedKnownHosts = normalizeVaultOrder(normalized); setKnownHosts(orderedKnownHosts); if (normalized !== savedKnownHosts || orderedKnownHosts !== normalized) { localStorageAdapter.write(STORAGE_KEY_KNOWN_HOSTS, orderedKnownHosts); } } // Load shell history const savedShellHistory = loadSanitizedShellHistory(); if (savedShellHistory) { setShellHistory(savedShellHistory); } // Load connection logs const savedConnectionLogs = localStorageAdapter.read( STORAGE_KEY_CONNECTION_LOGS, ); if (savedConnectionLogs) setConnectionLogs(savedConnectionLogs); // Load managed sources const savedManagedSources = localStorageAdapter.read( STORAGE_KEY_MANAGED_SOURCES, ); if (savedManagedSources) setManagedSources(savedManagedSources); // Load group configs const savedGroupConfigs = localStorageAdapter.read(STORAGE_KEY_GROUP_CONFIGS); if (savedGroupConfigs) { const gcVer = ++groupConfigsWriteVersion.current; const decryptedGC = await decryptGroupConfigs(savedGroupConfigs); if (gcVer === groupConfigsWriteVersion.current) { const sanitizedGC = normalizeVaultOrder(decryptedGC.map(sanitizeGroupConfig)); setGroupConfigs(sanitizedGC); encryptGroupConfigs(sanitizedGC).then((enc) => { if (gcVer === groupConfigsWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_GROUP_CONFIGS, enc); }); } } } finally { setIsInitialized(true); } }; init(); }, [updateHosts, updateSnippets]); useEffect(() => { if (typeof window === "undefined") return; const handleStorage = (event: StorageEvent) => { if (event.storageArea !== window.localStorage) return; const key = event.key; if (!key) return; if (key === STORAGE_KEY_HOSTS) { const next = safeParse(event.newValue) ?? []; // Bump write version to invalidate any in-flight encrypt from this // window — the cross-window data is newer and must not be overwritten. ++hostsWriteVersion.current; const seq = ++hostsReadSeq.current; const writeAtStart = hostsWriteVersion.current; decryptHosts(next).then((dec) => { // Discard if a newer storage event arrived OR a local write occurred // during the decrypt (writeVersion would have advanced). if (seq === hostsReadSeq.current && writeAtStart === hostsWriteVersion.current) setHosts(normalizeVaultOrder(dec.map(sanitizeHost))); }); return; } if (key === STORAGE_KEY_KEYS) { const raw = safeParse(event.newValue) ?? []; const migratedKeys: SSHKey[] = []; for (const entry of raw) { const record = entry && typeof entry === "object" ? (entry as LegacyKeyRecord) : null; if (!record || isLegacyUnsupportedKey(record)) continue; migratedKeys.push(migrateKey(record as Partial)); } ++keysWriteVersion.current; const seq = ++keysReadSeq.current; const writeAtStart = keysWriteVersion.current; decryptKeys(migratedKeys).then((dec) => { if (seq === keysReadSeq.current && writeAtStart === keysWriteVersion.current) setKeys(normalizeVaultOrder(dec)); }); return; } if (key === STORAGE_KEY_IDENTITIES) { const next = safeParse(event.newValue) ?? []; ++identitiesWriteVersion.current; const seq = ++identitiesReadSeq.current; const writeAtStart = identitiesWriteVersion.current; decryptIdentities(next).then((dec) => { if (seq === identitiesReadSeq.current && writeAtStart === identitiesWriteVersion.current) setIdentities(normalizeVaultOrder(dec)); }); return; } if (key === STORAGE_KEY_PROXY_PROFILES) { const next = safeParse(event.newValue) ?? []; ++proxyProfilesWriteVersion.current; const seq = ++proxyProfilesReadSeq.current; const writeAtStart = proxyProfilesWriteVersion.current; decryptProxyProfiles(next).then((dec) => { if (seq === proxyProfilesReadSeq.current && writeAtStart === proxyProfilesWriteVersion.current) setProxyProfiles(normalizeVaultOrder(dec)); }); return; } if (key === STORAGE_KEY_SNIPPETS) { const next = safeParse(event.newValue) ?? []; setSnippets(normalizeVaultOrder(next)); return; } if (key === STORAGE_KEY_GROUPS) { const next = safeParse(event.newValue) ?? []; setCustomGroups(next); return; } if (key === STORAGE_KEY_SNIPPET_PACKAGES) { const next = safeParse(event.newValue) ?? []; setSnippetPackages(next); return; } if (key === STORAGE_KEY_KNOWN_HOSTS) { const next = safeParse(event.newValue) ?? []; setKnownHosts(normalizeVaultOrder(normalizeKnownHosts(next))); return; } if (key === STORAGE_KEY_SHELL_HISTORY) { const next = sanitizeGlobalHistoryEntries( safeParse(event.newValue) ?? [], ); setShellHistory(next); return; } if (key === STORAGE_KEY_CONNECTION_LOGS) { const next = safeParse(event.newValue) ?? []; setConnectionLogs(next); return; } if (key === STORAGE_KEY_MANAGED_SOURCES) { const next = safeParse(event.newValue) ?? []; setManagedSources(next); return; } if (key === STORAGE_KEY_GROUP_CONFIGS) { const next = safeParse(event.newValue) ?? []; ++groupConfigsWriteVersion.current; const seq = ++groupConfigsReadSeq.current; const writeAtStart = groupConfigsWriteVersion.current; decryptGroupConfigs(next).then((dec) => { if (seq === groupConfigsReadSeq.current && writeAtStart === groupConfigsWriteVersion.current) setGroupConfigs(normalizeVaultOrder(dec.map(sanitizeGroupConfig))); }); return; } }; window.addEventListener("storage", handleStorage); return () => window.removeEventListener("storage", handleStorage); }, []); const updateHostLastConnected = useCallback((hostId: string) => { setHosts((prev) => { const next = prev.map((h) => h.id === hostId ? { ...h, lastConnectedAt: Date.now() } : h, ); const ver = ++hostsWriteVersion.current; encryptHosts(next).then((enc) => { if (ver === hostsWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_HOSTS, enc); }); return next; }); }, []); const updateHostDistro = useCallback((hostId: string, distro: string) => { const normalized = normalizeDistroId(distro); setHosts((prev) => { const next = prev.map((h) => h.id === hostId ? { ...h, distro: normalized } : h, ); const ver = ++hostsWriteVersion.current; encryptHosts(next).then((enc) => { if (ver === hostsWriteVersion.current) localStorageAdapter.write(STORAGE_KEY_HOSTS, enc); }); return next; }); }, []); const exportData = useCallback( (): ExportableVaultData => ({ hosts, keys, identities, proxyProfiles, snippets, customGroups, snippetPackages, knownHosts, groupConfigs, }), [hosts, keys, identities, proxyProfiles, snippets, customGroups, snippetPackages, knownHosts, groupConfigs], ); const importData = useCallback( (payload: Partial): Promise => { const encryptedWrites: Promise[] = []; if (payload.hosts) encryptedWrites.push(updateHosts(payload.hosts)); if (payload.keys) encryptedWrites.push(updateKeys(payload.keys)); if (payload.identities) encryptedWrites.push(updateIdentities(payload.identities)); if (Array.isArray(payload.proxyProfiles)) encryptedWrites.push(updateProxyProfiles(payload.proxyProfiles)); if (payload.snippets) updateSnippets(payload.snippets); if (payload.customGroups) updateCustomGroups(payload.customGroups); if (payload.snippetPackages) updateSnippetPackages(payload.snippetPackages); if (payload.knownHosts) updateKnownHosts(payload.knownHosts); if (Array.isArray(payload.groupConfigs)) encryptedWrites.push(updateGroupConfigs(payload.groupConfigs)); return Promise.all(encryptedWrites).then(() => undefined); }, [ updateHosts, updateKeys, updateIdentities, updateProxyProfiles, updateSnippets, updateCustomGroups, updateSnippetPackages, updateKnownHosts, updateGroupConfigs, ], ); const importDataFromString = useCallback( (jsonString: string): Promise => { const data = JSON.parse(jsonString); return importData(data); }, [importData], ); return { isInitialized, hosts, keys, identities, proxyProfiles, snippets, customGroups, snippetPackages, knownHosts, shellHistory, connectionLogs, managedSources, groupConfigs, updateHosts, updateKeys, importOrReuseKey, updateIdentities, updateProxyProfiles, updateSnippets, updateSnippetPackages, updateCustomGroups, updateKnownHosts, updateManagedSources, updateGroupConfigs, addShellHistoryEntry, clearShellHistory, addConnectionLog, updateConnectionLog, toggleConnectionLogSaved, deleteConnectionLog, clearUnsavedConnectionLogs, updateHostDistro, updateHostLastConnected, convertKnownHostToHost, exportData, importDataFromString, clearVaultData, }; };