mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-17 13:01:24 +00:00
* feat: sync global SFTP bookmarks via cloud sync Global SFTP path bookmarks were stored only in localStorage and not included in the cloud sync payload, so they could not be synced across devices. Add them to the sync settings, with auto-sync detection via a custom event and in-memory snapshot rehydration on import. Local bookmarks remain device-specific by design. Closes #548 Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: deduplicate global SFTP bookmarks by path during merge When the same path is bookmarked independently on two devices, each generates a different random ID. The entity-array merge preserves both, creating duplicates. Add path-based deduplication after settings merge, following the same pattern used for known hosts. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: sync global bookmarks across renderer windows via storage event When cloud sync imports bookmarks in the Settings window, the main window's in-memory snapshot stays stale. Listen for cross-window storage events on the bookmark key to auto-rehydrate. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
331 lines
11 KiB
TypeScript
331 lines
11 KiB
TypeScript
/**
|
|
* useAutoSync - Auto-sync Hook for Cloud Sync
|
|
*
|
|
* Provides automatic sync capabilities:
|
|
* - Sync when data changes (hosts, keys, snippets, port forwarding rules)
|
|
* - Check remote version on app startup
|
|
* - Debounced sync to avoid too frequent API calls
|
|
*/
|
|
|
|
import { useCallback, useEffect, useRef, useState } from 'react';
|
|
import { useCloudSync } from './useCloudSync';
|
|
import { useI18n } from '../i18n/I18nProvider';
|
|
import { getCloudSyncManager } from '../../infrastructure/services/CloudSyncManager';
|
|
import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
|
|
import {
|
|
findSyncPayloadEncryptedCredentialPaths,
|
|
} from '../../domain/credentials';
|
|
import { isProviderReadyForSync, type CloudProvider, type SyncPayload } from '../../domain/sync';
|
|
import { collectSyncableSettings } from '../syncPayload';
|
|
import { STORAGE_KEY_PORT_FORWARDING } from '../../infrastructure/config/storageKeys';
|
|
import { localStorageAdapter } from '../../infrastructure/persistence/localStorageAdapter';
|
|
import { getEffectiveKnownHosts } from '../../infrastructure/syncHelpers';
|
|
import { notify } from '../notification';
|
|
|
|
interface AutoSyncConfig {
|
|
// Data to sync
|
|
hosts: SyncPayload['hosts'];
|
|
keys: SyncPayload['keys'];
|
|
identities?: SyncPayload['identities'];
|
|
snippets: SyncPayload['snippets'];
|
|
customGroups: SyncPayload['customGroups'];
|
|
snippetPackages?: SyncPayload['snippetPackages'];
|
|
portForwardingRules?: SyncPayload['portForwardingRules'];
|
|
knownHosts?: SyncPayload['knownHosts'];
|
|
/** Opaque token that changes whenever a synced setting changes. */
|
|
settingsVersion?: number;
|
|
|
|
// Callbacks
|
|
onApplyPayload: (payload: SyncPayload) => void;
|
|
}
|
|
|
|
// Get manager singleton for direct state access
|
|
const manager = getCloudSyncManager();
|
|
const AUTO_SYNC_PROVIDER_ORDER: CloudProvider[] = ['github', 'google', 'onedrive', 'webdav', 's3'];
|
|
|
|
type SyncTrigger = 'auto' | 'manual';
|
|
|
|
interface SyncNowOptions {
|
|
trigger?: SyncTrigger;
|
|
}
|
|
|
|
export const useAutoSync = (config: AutoSyncConfig) => {
|
|
const { t } = useI18n();
|
|
const sync = useCloudSync();
|
|
const { onApplyPayload } = config;
|
|
const syncTimeoutRef = useRef<NodeJS.Timeout | null>(null);
|
|
const lastSyncedDataRef = useRef<string>('');
|
|
const hasCheckedRemoteRef = useRef(false);
|
|
const isInitializedRef = useRef(false);
|
|
const isSyncRunningRef = useRef(false);
|
|
const skipNextSyncRef = useRef(false);
|
|
|
|
// Listen for SFTP bookmark changes to trigger auto-sync
|
|
const [bookmarksVersion, setBookmarksVersion] = useState(0);
|
|
useEffect(() => {
|
|
const handler = () => setBookmarksVersion((v) => v + 1);
|
|
window.addEventListener('sftp-bookmarks-changed', handler);
|
|
return () => window.removeEventListener('sftp-bookmarks-changed', handler);
|
|
}, []);
|
|
|
|
const getSyncSnapshot = useCallback(() => {
|
|
let effectivePFRules = config.portForwardingRules;
|
|
if (!effectivePFRules || effectivePFRules.length === 0) {
|
|
const stored = localStorageAdapter.read<SyncPayload['portForwardingRules']>(
|
|
STORAGE_KEY_PORT_FORWARDING,
|
|
);
|
|
if (stored && Array.isArray(stored) && stored.length > 0) {
|
|
effectivePFRules = stored.map((rule) => ({
|
|
...rule,
|
|
status: 'inactive' as const,
|
|
error: undefined,
|
|
lastUsedAt: undefined,
|
|
}));
|
|
}
|
|
}
|
|
|
|
const effectiveKnownHosts = getEffectiveKnownHosts(config.knownHosts);
|
|
|
|
return {
|
|
hosts: config.hosts,
|
|
keys: config.keys,
|
|
identities: config.identities,
|
|
snippets: config.snippets,
|
|
customGroups: config.customGroups,
|
|
snippetPackages: config.snippetPackages,
|
|
portForwardingRules: effectivePFRules,
|
|
knownHosts: effectiveKnownHosts,
|
|
};
|
|
}, [
|
|
config.hosts,
|
|
config.keys,
|
|
config.identities,
|
|
config.snippets,
|
|
config.customGroups,
|
|
config.snippetPackages,
|
|
config.portForwardingRules,
|
|
config.knownHosts,
|
|
]);
|
|
|
|
// Build sync payload
|
|
const buildPayload = useCallback((): SyncPayload => {
|
|
return {
|
|
...getSyncSnapshot(),
|
|
settings: collectSyncableSettings(),
|
|
syncedAt: Date.now(),
|
|
};
|
|
}, [getSyncSnapshot]);
|
|
|
|
// Create a hash of current data for comparison (includes settings)
|
|
const getDataHash = useCallback(() => {
|
|
return JSON.stringify({ ...getSyncSnapshot(), settings: collectSyncableSettings() });
|
|
}, [getSyncSnapshot]);
|
|
|
|
// Sync now handler - get fresh state directly from manager
|
|
const syncNow = useCallback(async (options?: SyncNowOptions) => {
|
|
const trigger: SyncTrigger = options?.trigger ?? 'auto';
|
|
|
|
isSyncRunningRef.current = true;
|
|
try {
|
|
// Get fresh state directly from CloudSyncManager singleton
|
|
let state = manager.getState();
|
|
|
|
const hasProvider = Object.values(state.providers).some((provider) => isProviderReadyForSync(provider));
|
|
const syncing = state.syncState === 'SYNCING';
|
|
|
|
if (!hasProvider) {
|
|
throw new Error(t('sync.autoSync.noProvider'));
|
|
}
|
|
if (syncing) {
|
|
if (trigger === 'auto') {
|
|
console.info('[AutoSync] Skipping overlapping auto-sync because another sync is already running.');
|
|
return;
|
|
}
|
|
throw new Error(t('sync.autoSync.alreadySyncing'));
|
|
}
|
|
|
|
// If another window unlocked, reuse the in-memory session password from main process.
|
|
if (state.securityState !== 'UNLOCKED') {
|
|
const bridge = netcattyBridge.get();
|
|
const sessionPassword = await bridge?.cloudSyncGetSessionPassword?.();
|
|
if (sessionPassword) {
|
|
const ok = await sync.unlock(sessionPassword);
|
|
if (!ok) {
|
|
void bridge?.cloudSyncClearSessionPassword?.();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Re-check after unlock attempt
|
|
state = manager.getState();
|
|
if (state.securityState !== 'UNLOCKED') {
|
|
throw new Error(t('sync.autoSync.vaultLocked'));
|
|
}
|
|
|
|
const dataHash = getDataHash();
|
|
const payload = buildPayload();
|
|
const encryptedCredentialPaths = findSyncPayloadEncryptedCredentialPaths(payload);
|
|
if (encryptedCredentialPaths.length > 0) {
|
|
console.warn('[AutoSync] Blocked: encrypted credential placeholders found at:', encryptedCredentialPaths.join(', '));
|
|
throw new Error(t('sync.credentialsUnavailable'));
|
|
}
|
|
|
|
const results = await sync.syncNow(payload);
|
|
|
|
// Apply merged payloads first (before checking for failures) so local
|
|
// state gets updated even when some providers failed
|
|
for (const result of results.values()) {
|
|
if (result.mergedPayload) {
|
|
onApplyPayload(result.mergedPayload);
|
|
skipNextSyncRef.current = true;
|
|
break; // All providers share the same merged payload
|
|
}
|
|
}
|
|
|
|
for (const result of results.values()) {
|
|
if (!result.success) {
|
|
if (result.conflictDetected) {
|
|
throw new Error(t('sync.autoSync.conflictDetected'));
|
|
}
|
|
throw new Error(result.error || t('sync.autoSync.syncFailed'));
|
|
}
|
|
}
|
|
|
|
lastSyncedDataRef.current = dataHash;
|
|
} catch (error) {
|
|
if (trigger === 'manual') {
|
|
throw error;
|
|
}
|
|
console.error('[AutoSync] Sync failed:', error);
|
|
notify.error(
|
|
error instanceof Error ? error.message : t('common.unknownError'),
|
|
t('sync.autoSync.failedTitle'),
|
|
);
|
|
} finally {
|
|
isSyncRunningRef.current = false;
|
|
}
|
|
}, [sync, buildPayload, getDataHash, onApplyPayload, t]);
|
|
|
|
// Check remote version and pull if newer (on startup)
|
|
const checkRemoteVersion = useCallback(async () => {
|
|
const state = manager.getState();
|
|
const hasProvider = Object.values(state.providers).some((provider) => isProviderReadyForSync(provider));
|
|
const unlocked = state.securityState === 'UNLOCKED';
|
|
|
|
if (!hasProvider || !unlocked || hasCheckedRemoteRef.current) {
|
|
return;
|
|
}
|
|
|
|
hasCheckedRemoteRef.current = true;
|
|
|
|
// Find connected provider
|
|
const connectedProvider = AUTO_SYNC_PROVIDER_ORDER.find((provider) =>
|
|
isProviderReadyForSync(state.providers[provider]),
|
|
) ?? null;
|
|
|
|
if (!connectedProvider) return;
|
|
|
|
try {
|
|
// Load base BEFORE downloading (downloadFromProvider overwrites the base)
|
|
const base = await manager.loadSyncBase(connectedProvider);
|
|
const remotePayload = await sync.downloadFromProvider(connectedProvider);
|
|
|
|
if (remotePayload && remotePayload.syncedAt > state.localUpdatedAt) {
|
|
const { mergeSyncPayloads } = await import('../../domain/syncMerge');
|
|
const localPayload = buildPayload();
|
|
const mergeResult = mergeSyncPayloads(base, localPayload, remotePayload);
|
|
|
|
config.onApplyPayload(mergeResult.payload);
|
|
// Don't save base or skip auto-sync — let the data-change effect
|
|
// naturally trigger an upload of the merged payload (which will
|
|
// go through syncAllProviders and save base on success).
|
|
notify.success(t('sync.autoSync.syncedMessage'), t('sync.autoSync.syncedTitle'));
|
|
}
|
|
} catch (error) {
|
|
console.error('[AutoSync] Failed to check remote version:', error);
|
|
}
|
|
}, [sync, config, buildPayload, t]);
|
|
|
|
// Debounced auto-sync when data changes
|
|
useEffect(() => {
|
|
// Skip if not ready
|
|
if (!sync.hasAnyConnectedProvider || !sync.autoSyncEnabled || !sync.isUnlocked) {
|
|
return;
|
|
}
|
|
|
|
// Skip initial render
|
|
if (!isInitializedRef.current) {
|
|
isInitializedRef.current = true;
|
|
lastSyncedDataRef.current = getDataHash();
|
|
return;
|
|
}
|
|
|
|
const currentHash = getDataHash();
|
|
|
|
// After a merge, onApplyPayload changes local state which triggers
|
|
// this effect. Skip that cycle and just update the hash baseline.
|
|
if (skipNextSyncRef.current) {
|
|
skipNextSyncRef.current = false;
|
|
lastSyncedDataRef.current = currentHash;
|
|
return;
|
|
}
|
|
|
|
// Skip if data hasn't changed
|
|
if (currentHash === lastSyncedDataRef.current) {
|
|
return;
|
|
}
|
|
|
|
// Wait for the current sync to finish, then this effect will re-run
|
|
// because sync.isSyncing changed.
|
|
if (sync.isSyncing || isSyncRunningRef.current) {
|
|
return;
|
|
}
|
|
|
|
// Clear existing timeout
|
|
if (syncTimeoutRef.current) {
|
|
clearTimeout(syncTimeoutRef.current);
|
|
}
|
|
|
|
// Debounce sync by 3 seconds
|
|
syncTimeoutRef.current = setTimeout(() => {
|
|
syncNow();
|
|
}, 3000);
|
|
|
|
return () => {
|
|
if (syncTimeoutRef.current) {
|
|
clearTimeout(syncTimeoutRef.current);
|
|
}
|
|
};
|
|
// eslint-disable-next-line react-hooks/exhaustive-deps
|
|
}, [sync.hasAnyConnectedProvider, sync.autoSyncEnabled, sync.isUnlocked, sync.isSyncing, getDataHash, syncNow, config.settingsVersion, bookmarksVersion]);
|
|
|
|
// Check remote version on startup/unlock
|
|
useEffect(() => {
|
|
if (sync.hasAnyConnectedProvider && sync.isUnlocked && !hasCheckedRemoteRef.current) {
|
|
// Delay check to ensure everything is loaded
|
|
const timer = setTimeout(() => {
|
|
checkRemoteVersion();
|
|
}, 1000);
|
|
|
|
return () => clearTimeout(timer);
|
|
}
|
|
}, [sync.hasAnyConnectedProvider, sync.isUnlocked, checkRemoteVersion]);
|
|
|
|
// Reset check flag when provider disconnects
|
|
useEffect(() => {
|
|
if (!sync.hasAnyConnectedProvider) {
|
|
hasCheckedRemoteRef.current = false;
|
|
}
|
|
}, [sync.hasAnyConnectedProvider]);
|
|
|
|
return {
|
|
syncNow,
|
|
buildPayload,
|
|
isSyncing: sync.isSyncing,
|
|
isConnected: sync.hasAnyConnectedProvider,
|
|
autoSyncEnabled: sync.autoSyncEnabled,
|
|
};
|
|
};
|
|
|
|
export default useAutoSync;
|