mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
* feat(vault): optimize large imports and vault rendering (#2526) * fix(vault): address import review findings * fix(vault): preserve filtered selection and import consistency * fix(vault): complete import review fixes * fix(vault): make import cancellation concurrency-safe * fix(vault): preserve concurrent edits during import rollback * fix(vault): handle concurrent saves and reset import target * fix(vault): drop empty source groups after targeted import * fix(vault): preserve sidebar accessibility check * fix(vault): correct group counts and selection semantics * fix(vault): preserve imports across concurrent saves * fix(vault): preserve concurrent group changes during import * fix(vault): close concurrent import edge cases * fix(vault): retry rollback and enable tree keyboard selection * fix(vault): retain concurrent sources and visible selections * fix(vault): merge imported sources with persisted state * fix(vault): serialize duplicate managed imports * fix(vault): keep imports non-blocking and grouped views responsive * fix(vault): preserve concurrent managed sessions * fix(vault): preserve concurrent groups and keyboard access * fix(vault): serialize cross-window import commits * fix(vault): make import commits atomic * fix(vault): surface import rollback failures * fix(vault): recover import transactions safely * fix(vault): commit imported hosts atomically * fix(vault): preserve unfinished import recovery * fix(vault): wait for edits and preserve keyboard focus * fix(vault): protect group settings and lock fallback * fix(vault): keep virtual focus aligned * fix(vault): complete keyboard navigation semantics * fix(vault): finish keyboard navigation * fix(vault): close large-vault concurrency gaps * fix(vault): finish large-vault interaction safety * fix(vault): harden filtered large-vault flows * fix(vault): keep managed deletion atomic * fix(vault): coordinate managed file deletion * fix(vault): close cross-window managed races * fix(vault): refresh persisted managed state * fix(vault): preserve distinct imported sessions * fix(vault): keep failed progress accurate * fix(vault): keep search tree collapsible * fix(vault): close final review gaps * fix(vault): reveal filtered tree matches * fix(vault): close final review edge cases * fix(vault): preserve concurrent import changes * fix(vault): serialize all vault saves under one cross-window lock Hold the shared import lock for ordinary host/group/key writes and the full import commit path so check-then-write can no longer interleave across windows. Make the lock re-entrant in-window to avoid nested deadlocks, and announce large tree item positions for screen readers. * fix(vault): keep concurrent saves serialized and fix tree ARIA siblings Stop treating same-window concurrent work as nested lock re-entry; nested helpers skip re-acquire only when the outer critical section already owns the lock. Announce treeitem position among true siblings at each level. * fix(vault): require explicit lock handle for nested saves Independent concurrent vault writes always queue on the shared lock. Nested import/deletion helpers continue only when they pass the active lock handle from their outer critical section. * fix(vault): avoid lock deadlocks with encrypt-then-write saves Encrypt outside the shared lock and only acquire it for the final write so importers waiting on pending work cannot deadlock on lock acquisition. Retry plugin commits outside the lock when concurrent edits intervene, and rebase imports onto in-memory host edits when disk is still stale. * fix(vault): release import lock before concurrent-edit retries Drain encrypt work under the lock and full disk writes only outside it. When an import or group deletion is superseded by a concurrent edit, release the shared lock so that edit can finish, then retry. Functional group updates now base on the latest in-memory snapshot while a write is still pending. * fix(vault): tidy import dialog destination and SecureCRT prompts Move import destination settings behind a bottom-left control with its own step, and keep SecureCRT guidance in a dedicated chooser instead of inside the format tile. * test(vault): fix import dialog layout guard test under ESM * fix(vault): simplify import destination footer control Replace the heavy two-line destination card with a single quiet text link that shows the current placement choice. * fix(vault): simplify import destination settings page Drop the nested card and duplicate headings. Show only the three placement choices, finish immediately for preserve, and keep Done only when a group name is needed. * fix(vault): simplify SecureCRT chooser and iconify destination options Remove redundant SecureCRT prompt copy while keeping the two source cards with icons. Add small folder icons to the import-location choices so that page is less plain. * fix(vault): use SecureCRT logo in import chooser header * fix(vault): drop border around SecureCRT import logo * fix(vault): clarify import location footer with icon and label Show a folder icon plus "Import location · current choice" so the control is recognizable without becoming a heavy card again. * fix(vault): remove border from import progress status icon
420 lines
15 KiB
TypeScript
420 lines
15 KiB
TypeScript
import { useCallback, useEffect, useRef } from "react";
|
|
import { Host, ManagedSource } from "../../domain/models";
|
|
import {
|
|
serializeHostsToSshConfig,
|
|
mergeWithExistingSshConfig,
|
|
toSafeSshHostAlias,
|
|
isSafeSshHostMatchLiteral,
|
|
} from "../../domain/sshConfigSerializer";
|
|
import { netcattyBridge } from "../../infrastructure/services/netcattyBridge";
|
|
import { STORAGE_KEY_MANAGED_SOURCES } from "../../infrastructure/config/storageKeys";
|
|
import { localStorageAdapter } from "../../infrastructure/persistence/localStorageAdapter";
|
|
import { withVaultImportLock } from "./vaultManagedImportLock";
|
|
|
|
const MANAGED_BLOCK_BEGIN = "# BEGIN NETCATTY MANAGED - DO NOT EDIT THIS BLOCK";
|
|
const MANAGED_BLOCK_END = "# END NETCATTY MANAGED";
|
|
|
|
export interface UseManagedSourceSyncOptions {
|
|
hosts: Host[];
|
|
managedSources: ManagedSource[];
|
|
onUpdateManagedSources: (sources: ManagedSource[]) => void;
|
|
onReadPersistedHosts: () => Promise<Host[]>;
|
|
}
|
|
|
|
export const haveSameManagedSshAgentFields = (previous: Host, current: Host): boolean => (
|
|
previous.useSshAgent === current.useSshAgent
|
|
&& previous.identityAgent === current.identityAgent
|
|
&& previous.identitiesOnly === current.identitiesOnly
|
|
&& previous.addKeysToAgent === current.addKeysToAgent
|
|
&& previous.useKeychain === current.useKeychain
|
|
&& (previous.identityFilePaths?.length ?? 0) === (current.identityFilePaths?.length ?? 0)
|
|
&& (previous.identityFilePaths ?? []).every(
|
|
(path, index) => path === current.identityFilePaths?.[index],
|
|
)
|
|
);
|
|
|
|
export const useManagedSourceSync = ({
|
|
hosts,
|
|
managedSources,
|
|
onUpdateManagedSources,
|
|
onReadPersistedHosts,
|
|
}: UseManagedSourceSyncOptions) => {
|
|
const previousHostsRef = useRef<Host[]>([]);
|
|
const hostsRef = useRef(hosts);
|
|
hostsRef.current = hosts;
|
|
const syncInProgressRef = useRef(false);
|
|
// Keep a ref to the latest managedSources to avoid stale closure issues
|
|
const managedSourcesRef = useRef(managedSources);
|
|
managedSourcesRef.current = managedSources;
|
|
|
|
const getManagedHostsForSource = useCallback(
|
|
(sourceId: string) => {
|
|
return hostsRef.current.filter((h) => h.managedSourceId === sourceId);
|
|
},
|
|
[],
|
|
);
|
|
|
|
const readExistingFileContent = useCallback(
|
|
async (filePath: string): Promise<string | null> => {
|
|
const bridge = netcattyBridge.get();
|
|
if (!bridge?.readLocalFile) {
|
|
return null;
|
|
}
|
|
try {
|
|
const buffer = await bridge.readLocalFile(filePath);
|
|
const decoder = new TextDecoder();
|
|
return decoder.decode(buffer);
|
|
} catch {
|
|
// File might not exist yet
|
|
return null;
|
|
}
|
|
},
|
|
[],
|
|
);
|
|
|
|
const mergeWithExistingContent = useCallback(
|
|
(
|
|
existingContent: string | null,
|
|
managedHosts: Host[],
|
|
allHosts: Host[],
|
|
): string => {
|
|
// Serialize the managed hosts
|
|
const managedContent = serializeHostsToSshConfig(managedHosts, allHosts);
|
|
|
|
if (!existingContent) {
|
|
// No existing file, just wrap the managed content
|
|
return `${MANAGED_BLOCK_BEGIN}\n${managedContent}${MANAGED_BLOCK_END}\n`;
|
|
}
|
|
|
|
const beginIndex = existingContent.indexOf(MANAGED_BLOCK_BEGIN);
|
|
const endIndex = existingContent.indexOf(MANAGED_BLOCK_END);
|
|
|
|
if (beginIndex === -1 || endIndex === -1 || endIndex < beginIndex) {
|
|
// No existing managed block - need to remove duplicate Host entries
|
|
// Build a set of hostnames/aliases that will be managed
|
|
const managedHostnameSet = new Set<string>();
|
|
for (const host of managedHosts) {
|
|
if (!host.protocol || host.protocol === "ssh") {
|
|
// Add both hostname and sanitized label (alias) for matching
|
|
if (isSafeSshHostMatchLiteral(host.hostname)) {
|
|
managedHostnameSet.add(host.hostname.toLowerCase());
|
|
}
|
|
if (host.label) {
|
|
managedHostnameSet.add(toSafeSshHostAlias(host.label, host.hostname).toLowerCase());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Use mergeWithExistingSshConfig to filter out existing Host blocks
|
|
// that match our managed hosts, keeping preserved content outside markers
|
|
const mergedContent = mergeWithExistingSshConfig(
|
|
existingContent,
|
|
managedHosts,
|
|
managedHostnameSet,
|
|
allHosts,
|
|
);
|
|
return mergedContent;
|
|
}
|
|
|
|
// Replace the existing managed block
|
|
const before = existingContent.substring(0, beginIndex);
|
|
const after = existingContent.substring(endIndex + MANAGED_BLOCK_END.length);
|
|
return `${before}${MANAGED_BLOCK_BEGIN}\n${managedContent}${MANAGED_BLOCK_END}${after}`;
|
|
},
|
|
[],
|
|
);
|
|
|
|
const writeSshConfigToFile = useCallback(
|
|
async (source: ManagedSource, managedHosts: Host[], allHosts = hostsRef.current) => {
|
|
const bridge = netcattyBridge.get();
|
|
if (!bridge?.writeLocalFile) {
|
|
console.warn("[ManagedSourceSync] writeLocalFile not available");
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
// Read existing file content to preserve non-managed parts
|
|
const existingContent = await readExistingFileContent(source.filePath);
|
|
|
|
// Merge with existing content, preserving non-managed parts and removing duplicates
|
|
const finalContent = mergeWithExistingContent(
|
|
existingContent,
|
|
managedHosts,
|
|
allHosts,
|
|
);
|
|
const encoder = new TextEncoder();
|
|
const buffer = encoder.encode(finalContent);
|
|
await bridge.writeLocalFile(source.filePath, buffer.buffer as ArrayBuffer);
|
|
return true;
|
|
} catch (err) {
|
|
console.error("[ManagedSourceSync] Failed to write SSH config:", err);
|
|
return false;
|
|
}
|
|
},
|
|
[readExistingFileContent, mergeWithExistingContent],
|
|
);
|
|
|
|
const syncManagedSource = useCallback(
|
|
async (source: ManagedSource): Promise<{ sourceId: string; success: boolean }> => {
|
|
return withVaultImportLock("vault", async () => {
|
|
const persistedSources = localStorageAdapter.read<ManagedSource[]>(
|
|
STORAGE_KEY_MANAGED_SOURCES,
|
|
) ?? managedSourcesRef.current;
|
|
if (!persistedSources.some((candidate) => candidate.id === source.id)) {
|
|
return { sourceId: source.id, success: false };
|
|
}
|
|
const latestHosts = await onReadPersistedHosts();
|
|
const managedHosts = latestHosts.filter((host) => host.managedSourceId === source.id);
|
|
const success = await writeSshConfigToFile(source, managedHosts, latestHosts);
|
|
return { sourceId: source.id, success };
|
|
});
|
|
},
|
|
[onReadPersistedHosts, writeSshConfigToFile],
|
|
);
|
|
|
|
const unmanageSource = useCallback(
|
|
(sourceId: string) => {
|
|
const updatedSources = managedSourcesRef.current.filter((s) => s.id !== sourceId);
|
|
onUpdateManagedSources(updatedSources);
|
|
},
|
|
[onUpdateManagedSources],
|
|
);
|
|
|
|
// Clear the managed block before the caller atomically removes the Vault
|
|
// source and hosts. Keeping state unchanged here lets a failed clear abort
|
|
// the deletion without leaving a half-removed source record.
|
|
const clearAndRemoveSource = useCallback(
|
|
async (source: ManagedSource) => {
|
|
const success = await writeSshConfigToFile(source, []);
|
|
if (!success) throw new Error("Could not clear managed SSH config source");
|
|
return async () => {
|
|
const latestHosts = await onReadPersistedHosts();
|
|
const restored = await writeSshConfigToFile(
|
|
source,
|
|
latestHosts.filter((host) => host.managedSourceId === source.id),
|
|
latestHosts,
|
|
);
|
|
if (!restored) throw new Error("Could not restore managed SSH config source");
|
|
};
|
|
},
|
|
[onReadPersistedHosts, writeSshConfigToFile],
|
|
);
|
|
|
|
// Clear and remove multiple sources atomically to avoid race conditions
|
|
// when multiple sources are removed concurrently
|
|
const clearAndRemoveSources = useCallback(
|
|
async (sources: ManagedSource[]) => {
|
|
const clearedSources: ManagedSource[] = [];
|
|
for (const source of sources) {
|
|
const success = await writeSshConfigToFile(source, []);
|
|
if (!success) {
|
|
const latestHosts = await onReadPersistedHosts();
|
|
const restored = await Promise.all(clearedSources.map((clearedSource) => writeSshConfigToFile(
|
|
clearedSource,
|
|
latestHosts.filter((host) => host.managedSourceId === clearedSource.id),
|
|
latestHosts,
|
|
)));
|
|
if (restored.some((result) => !result)) {
|
|
throw new Error("Could not clear or restore every managed SSH config source");
|
|
}
|
|
throw new Error("Could not clear every managed SSH config source");
|
|
}
|
|
clearedSources.push(source);
|
|
}
|
|
return async () => {
|
|
const latestHosts = await onReadPersistedHosts();
|
|
const results = await Promise.all(clearedSources.map((source) => writeSshConfigToFile(
|
|
source,
|
|
latestHosts.filter((host) => host.managedSourceId === source.id),
|
|
latestHosts,
|
|
)));
|
|
if (results.some((success) => !success)) {
|
|
throw new Error("Could not restore every managed SSH config source");
|
|
}
|
|
};
|
|
},
|
|
[onReadPersistedHosts, writeSshConfigToFile],
|
|
);
|
|
|
|
const pendingSyncRef = useRef(false);
|
|
const checkAndSyncRef = useRef<() => void>(() => {});
|
|
|
|
const checkAndSync = useCallback(() => {
|
|
if (managedSources.length === 0) {
|
|
// Still update previousHostsRef so we have a baseline when sources are added
|
|
previousHostsRef.current = hosts;
|
|
return;
|
|
}
|
|
|
|
const prevHosts = previousHostsRef.current;
|
|
previousHostsRef.current = hosts;
|
|
|
|
// On initial sync (prevHosts empty), sync all sources that have managed hosts
|
|
const isInitialSync = prevHosts.length === 0;
|
|
|
|
const changedSourceIds = new Set<string>();
|
|
|
|
if (isInitialSync) {
|
|
// Initial sync: sync all sources that have hosts
|
|
for (const source of managedSources) {
|
|
const currManaged = hosts.filter((h) => h.managedSourceId === source.id);
|
|
if (currManaged.length > 0) {
|
|
changedSourceIds.add(source.id);
|
|
}
|
|
}
|
|
} else {
|
|
// Build maps for all hosts (for jump host lookup)
|
|
const prevHostMap = new Map<string, Host>(prevHosts.map((h) => [h.id, h]));
|
|
const currHostMap = new Map<string, Host>(hosts.map((h) => [h.id, h]));
|
|
|
|
// Index hosts by managedSourceId to avoid O(N*M) lookups
|
|
const prevHostsBySource = new Map<string, Host[]>();
|
|
for (const h of prevHosts) {
|
|
if (h.managedSourceId) {
|
|
let list = prevHostsBySource.get(h.managedSourceId);
|
|
if (!list) {
|
|
list = [];
|
|
prevHostsBySource.set(h.managedSourceId, list);
|
|
}
|
|
list.push(h);
|
|
}
|
|
}
|
|
|
|
const currHostsBySource = new Map<string, Host[]>();
|
|
for (const h of hosts) {
|
|
if (h.managedSourceId) {
|
|
let list = currHostsBySource.get(h.managedSourceId);
|
|
if (!list) {
|
|
list = [];
|
|
currHostsBySource.set(h.managedSourceId, list);
|
|
}
|
|
list.push(h);
|
|
}
|
|
}
|
|
|
|
// Helper to check if a host's SSH-relevant fields changed
|
|
const hostChanged = (prevHost: Host | undefined, currHost: Host | undefined): boolean => {
|
|
if (!prevHost || !currHost) return prevHost !== currHost;
|
|
return (
|
|
prevHost.hostname !== currHost.hostname ||
|
|
prevHost.port !== currHost.port ||
|
|
prevHost.username !== currHost.username ||
|
|
prevHost.label !== currHost.label
|
|
);
|
|
};
|
|
|
|
for (const source of managedSources) {
|
|
const prevManaged = prevHostsBySource.get(source.id) || [];
|
|
const currManaged = currHostsBySource.get(source.id) || [];
|
|
|
|
if (prevManaged.length !== currManaged.length) {
|
|
changedSourceIds.add(source.id);
|
|
continue;
|
|
}
|
|
|
|
const prevManagedMap = new Map<string, Host>(prevManaged.map((h) => [h.id, h]));
|
|
let sourceChanged = false;
|
|
|
|
for (const curr of currManaged) {
|
|
const prev = prevManagedMap.get(curr.id);
|
|
if (!prev) {
|
|
sourceChanged = true;
|
|
break;
|
|
}
|
|
// Compare hostChain arrays for ProxyJump changes
|
|
const prevChain = prev.hostChain?.hostIds || [];
|
|
const currChain = curr.hostChain?.hostIds || [];
|
|
const chainChanged =
|
|
prevChain.length !== currChain.length ||
|
|
prevChain.some((id, i) => id !== currChain[i]);
|
|
|
|
const hasChanged =
|
|
prev.hostname !== curr.hostname ||
|
|
prev.port !== curr.port ||
|
|
prev.username !== curr.username ||
|
|
prev.label !== curr.label ||
|
|
prev.group !== curr.group ||
|
|
prev.protocol !== curr.protocol ||
|
|
!haveSameManagedSshAgentFields(prev, curr) ||
|
|
chainChanged;
|
|
if (hasChanged) {
|
|
sourceChanged = true;
|
|
break;
|
|
}
|
|
|
|
// Check if any referenced jump hosts changed (even if outside this managed source)
|
|
for (const jumpHostId of currChain) {
|
|
const prevJumpHost = prevHostMap.get(jumpHostId);
|
|
const currJumpHost = currHostMap.get(jumpHostId);
|
|
if (hostChanged(prevJumpHost, currJumpHost)) {
|
|
sourceChanged = true;
|
|
break;
|
|
}
|
|
}
|
|
if (sourceChanged) break;
|
|
}
|
|
|
|
if (sourceChanged) {
|
|
changedSourceIds.add(source.id);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (changedSourceIds.size > 0) {
|
|
syncInProgressRef.current = true;
|
|
|
|
Promise.all(
|
|
managedSources
|
|
.filter((s) => changedSourceIds.has(s.id))
|
|
.map((source) => syncManagedSource(source)),
|
|
).then(async (results) => {
|
|
// Batch update lastSyncedAt for all successful syncs to avoid race conditions
|
|
const successfulSourceIds = new Set(
|
|
results.filter(r => r.success).map(r => r.sourceId)
|
|
);
|
|
|
|
if (successfulSourceIds.size > 0) {
|
|
await withVaultImportLock("vault", async () => {
|
|
const currentSources = localStorageAdapter.read<ManagedSource[]>(
|
|
STORAGE_KEY_MANAGED_SOURCES,
|
|
) ?? managedSourcesRef.current;
|
|
const now = Date.now();
|
|
const updatedSources = currentSources.map((s) =>
|
|
successfulSourceIds.has(s.id) ? { ...s, lastSyncedAt: now } : s,
|
|
);
|
|
onUpdateManagedSources(updatedSources);
|
|
});
|
|
}
|
|
}).finally(() => {
|
|
syncInProgressRef.current = false;
|
|
// Check if there were changes during sync that need to be processed
|
|
// Use ref to get the latest checkAndSync to avoid stale closure
|
|
if (pendingSyncRef.current) {
|
|
pendingSyncRef.current = false;
|
|
checkAndSyncRef.current();
|
|
}
|
|
});
|
|
}
|
|
}, [hosts, managedSources, syncManagedSource, onUpdateManagedSources]);
|
|
|
|
// Keep ref updated with the latest checkAndSync
|
|
checkAndSyncRef.current = checkAndSync;
|
|
|
|
useEffect(() => {
|
|
if (syncInProgressRef.current) {
|
|
// Mark that we need to re-sync after current sync completes
|
|
pendingSyncRef.current = true;
|
|
return;
|
|
}
|
|
checkAndSync();
|
|
}, [hosts, managedSources, checkAndSync]);
|
|
|
|
return {
|
|
syncManagedSource,
|
|
unmanageSource,
|
|
clearAndRemoveSource,
|
|
clearAndRemoveSources,
|
|
getManagedHostsForSource,
|
|
};
|
|
};
|