import { useCallback, useEffect, useMemo, useRef } from "react"; import { Host, Identity, SftpFilenameEncoding, SftpFileEntry, SSHKey, } from "../../domain/models"; import { createEmptyPane, SftpStateOptions, } from "./sftp/types"; import { formatDate, formatFileSize, getFileExtension, getFileName, getParentPath, joinPath, } from "./sftp/utils"; import { useSftpTabsState } from "./sftp/useSftpTabsState"; import { isSessionError } from "./sftp/errors"; import { useSftpExternalOperations } from "./sftp/useSftpExternalOperations"; import { useSftpTransfers } from "./sftp/useSftpTransfers"; import { useSftpPaneActions } from "./sftp/useSftpPaneActions"; import { useSftpConnections } from "./sftp/useSftpConnections"; import { useSftpFileWatch } from "./sftp/useSftpFileWatch"; import { useSftpSessionCleanup } from "./sftp/useSftpSessionCleanup"; import { useSftpSessionErrors } from "./sftp/useSftpSessionErrors"; import { ensureRemoteSftpSession } from "./sftp/ensureRemoteSftpSession"; import { openTransferSftpSession } from "./sftp/dedicatedTransferResume"; import { buildTransferPoolKey, getSharedTransferConnectionPool, } from "./sftp/transferConnectionPool"; import { shouldParkBrowseSessions, shouldRestoreBrowseSessions, takeBrowseSessionsForClose, } from "./sftp/browseSessionLifecycle"; import { sftpTransferCenterStore } from "./sftpTransferCenterStore"; import { netcattyBridge } from "../../infrastructure/services/netcattyBridge"; import { logger } from "../../lib/logger"; // types + utils now live in ./sftp/* export const useSftpState = ( hosts: Host[], keys: SSHKey[], identities: Identity[], options?: SftpStateOptions ) => { const transferOwnerIdRef = useRef(options?.transferOwnerId ?? crypto.randomUUID()); const createPane = useCallback( (id?: string, showHiddenFiles = options?.defaultShowHiddenFiles ?? false) => createEmptyPane(id, showHiddenFiles), [options?.defaultShowHiddenFiles], ); const tabsState = useSftpTabsState({ defaultShowHiddenFiles: options?.defaultShowHiddenFiles, }); const { leftTabs, rightTabs, leftTabsRef, rightTabsRef, setLeftTabs, setRightTabs, leftPane, rightPane, getActivePane, updateTab, updateActiveTab, clearSelectionsExcept, setTabShowHiddenFiles, addTab, closeTab, selectTab, reorderTabs, moveTabToOtherSide, getTabsInfo, getActiveTabId, } = tabsState; // SFTP session refs const sftpSessionsRef = useRef>(new Map()); // connectionId -> sftpId // Getter for sftpId from connectionId (for stream transfers) const getSftpIdForConnection = useCallback((connectionId: string) => { return sftpSessionsRef.current.get(connectionId); }, []); // Directory listing cache (connectionId + path) const DIR_CACHE_TTL_MS = 10_000; const dirCacheRef = useRef< Map >(new Map()); // Navigation sequence per pane, used to ignore stale async results const navSeqRef = useRef<{ left: number; right: number }>({ left: 0, right: 0, }); const makeCacheKey = useCallback( (connectionId: string, path: string, encoding?: SftpFilenameEncoding) => `${connectionId}::${encoding || "auto"}::${path}`, [], ); const clearCacheForConnection = useCallback((connectionId: string) => { for (const key of dirCacheRef.current.keys()) { if (key.startsWith(`${connectionId}::`)) { dirCacheRef.current.delete(key); } } }, []); const clearDirCacheEntry = useCallback((connectionId: string, path: string) => { // Remove all encoding variants of this path from the cache for (const key of dirCacheRef.current.keys()) { if (key.startsWith(`${connectionId}::`) && key.endsWith(`::${path}`)) { dirCacheRef.current.delete(key); } } }, []); const getPaneByConnectionId = useCallback((connectionId: string) => { for (const tab of leftTabsRef.current.tabs) { if (tab.connection?.id === connectionId) return tab; } for (const tab of rightTabsRef.current.tabs) { if (tab.connection?.id === connectionId) return tab; } return null; }, [leftTabsRef, rightTabsRef]); const getPaneByTabId = useCallback((tabId: string) => { for (const tab of leftTabsRef.current.tabs) { if (tab.id === tabId) return tab; } for (const tab of rightTabsRef.current.tabs) { if (tab.id === tabId) return tab; } return null; }, [leftTabsRef, rightTabsRef]); const getSideByTabId = useCallback((tabId: string): "left" | "right" | null => { if (leftTabsRef.current.tabs.some((tab) => tab.id === tabId)) return "left"; if (rightTabsRef.current.tabs.some((tab) => tab.id === tabId)) return "right"; return null; }, [leftTabsRef, rightTabsRef]); const getTabByConnectionId = useCallback((connectionId: string) => { for (const tab of leftTabsRef.current.tabs) { if (tab.connection?.id === connectionId) { return { side: "left" as const, tabId: tab.id, pane: tab }; } } for (const tab of rightTabsRef.current.tabs) { if (tab.connection?.id === connectionId) { return { side: "right" as const, tabId: tab.id, pane: tab }; } } return null; }, [leftTabsRef, rightTabsRef]); // Ref to track pending reconnections to avoid multiple reconnect attempts const reconnectingRef = useRef<{ left: boolean; right: boolean }>({ left: false, right: false, }); // Map connectionId → cache key, set at connect time so each tab's // navigateTo can use the correct cache key even when multiple tabs // share the same hostId with different session-time overrides. const connectionCacheKeyMapRef = useRef>(new Map()); // Full Host used when each tab connected (includes session-time overrides). // Tab ids are stable across reconnect; connection ids are not. const connectedHostByTabIdRef = useRef>(new Map()); // Full endpoint key captured at connect time (hostId:hostname:port:…). const getConnectionCacheKey = useCallback((connectionId: string) => { return connectionCacheKeyMapRef.current.get(connectionId) ?? null; }, []); // Store last connected host info for reconnection const lastConnectedHostRef = useRef<{ left: Host | "local" | null; right: Host | "local" | null; }>({ left: null, right: null, }); // Keep reconnect metadata in sync when auto-connect reuses an existing tab // without calling connect() (selectTab alone does not update this ref). // Callers that selectTab then setLastConnectedHost must pass tabId explicitly: // selectTab only schedules a state update, so activeTabId on the ref is still // the previous tab until the next render. const setLastConnectedHost = useCallback(( side: "left" | "right", host: Host | "local" | null, tabId?: string | null, ) => { lastConnectedHostRef.current[side] = host; const resolvedTabId = tabId ?? (side === "left" ? leftTabsRef : rightTabsRef).current.activeTabId; if (!resolvedTabId) return; if (host) { connectedHostByTabIdRef.current.set(resolvedTabId, host); } else { connectedHostByTabIdRef.current.delete(resolvedTabId); } }, [leftTabsRef, rightTabsRef]); const closeTabAndClearHost = useCallback((side: "left" | "right", tabId: string) => { connectedHostByTabIdRef.current.delete(tabId); closeTab(side, tabId); }, [closeTab]); const handleSessionError = useSftpSessionErrors({ getActivePane, leftTabsRef, rightTabsRef, updateActiveTab, sftpSessionsRef, clearCacheForConnection, navSeqRef, lastConnectedHostRef, reconnectingRef, }); useSftpSessionCleanup(sftpSessionsRef); useSftpFileWatch(options); // FileZilla-style dedicated transfer connection pool (1–2 sessions per host). // Shared across SFTP panels so we never open more than maxPerHost globally. const transferPoolRef = useRef( getSharedTransferConnectionPool({ closeSession: async (sftpId) => { try { await netcattyBridge.get()?.closeSftp?.(sftpId); } catch { // best-effort idle/session cleanup } }, idleTtlMs: options?.transferPoolIdleTtlMs, }), ); // Keep shared pool TTL in sync with settings (singleton may already exist). useEffect(() => { if (options?.transferPoolIdleTtlMs === undefined) return; transferPoolRef.current.setIdleTtlMs(options.transferPoolIdleTtlMs); }, [options?.transferPoolIdleTtlMs]); // Periodically reclaim idle transfer sessions (busy holders are never closed). useEffect(() => { const pool = transferPoolRef.current; const timer = window.setInterval(() => { void pool.closeIdle().then((closed) => { if (closed > 0) { logger.debug(`[SFTP] Closed ${closed} idle transfer connection(s)`); } }); }, 15_000); return () => { window.clearInterval(timer); }; }, []); const openPoolSftpSession = useCallback( async (host: Host) => { // Always dedicated vault SSH: bulk transfers must survive SFTP/terminal // tab close. Warm this in the background so the user does not feel the handshake. logger.info(`[SFTP] Opening dedicated transfer connection for ${host.label || host.hostname}`); return openTransferSftpSession( host, { hosts, keys, identities, knownHosts: options?.knownHosts, terminalSettings: options?.terminalSettings, }, { dedicated: true }, ); }, [hosts, identities, keys, options?.knownHosts, options?.terminalSettings], ); const acquireTransferSession = useCallback( async (hostId: string, transferId: string, connectHost?: Host) => { // Prefer the connect-time Host (terminal session overrides) so pooled // uploads open the same endpoint as the browse tab, not the vault entry. const host = connectHost && connectHost.id === hostId ? connectHost : hosts.find((candidate) => candidate.id === hostId); if (!host) { throw new Error(`Host not found for transfer session: ${hostId}`); } if (connectHost && connectHost.id !== hostId) { throw new Error( `Transfer connect host id mismatch: expected ${hostId}, got ${connectHost.id}`, ); } const poolKey = buildTransferPoolKey({ hostId: host.id, hostname: host.hostname, port: host.port, username: host.username, protocol: host.protocol, sftpSudo: host.sftpSudo, }); return transferPoolRef.current.acquire(poolKey, transferId, () => openPoolSftpSession(host)); }, [hosts, openPoolSftpSession], ); /** * Warm one idle transfer-pool slot for a host (background). Prefer terminal * session reuse so the first real transfer skips a cold SSH handshake. */ const warmTransferPoolForHost = useCallback( async (hostId: string) => { const host = hosts.find((candidate) => candidate.id === hostId); if (!host || host.protocol === "serial") return; const poolKey = buildTransferPoolKey({ hostId: host.id, hostname: host.hostname, port: host.port, username: host.username, protocol: host.protocol, sftpSudo: host.sftpSudo, }); const stats = transferPoolRef.current.getStats(poolKey); if (stats.connections > 0) return; try { const lease = await transferPoolRef.current.acquire( poolKey, `warm:${hostId}`, () => openPoolSftpSession(host), ); lease.release(); logger.debug(`[SFTP] Warmed transfer pool for ${host.label || host.hostname}`); } catch (err) { logger.debug("[SFTP] Transfer pool warm failed (will open on first transfer)", err); } }, [hosts, openPoolSftpSession], ); /** True after browse channels were soft-closed while this owner stayed mounted. */ const browseParkedRef = useRef(false); const browseLifecycleGenRef = useRef(0); const { connect, disconnect, listLocalFiles, listRemoteFiles, hostKeyVerification, rejectHostKeyVerification, acceptHostKeyVerification, acceptAndSaveHostKeyVerification, } = useSftpConnections({ hosts, keys, identities, knownHosts: options?.knownHosts, onAddKnownHost: options?.onAddKnownHost, terminalSettings: options?.terminalSettings, leftTabsRef, rightTabsRef, leftTabs, rightTabs, leftPane, rightPane, setLeftTabs, setRightTabs, getActivePane, updateTab, navSeqRef, dirCacheRef, sftpSessionsRef, lastConnectedHostRef, connectionCacheKeyMapRef, connectedHostByTabIdRef, reconnectingRef, makeCacheKey, clearCacheForConnection, createEmptyPane: createPane, autoConnectLocalOnMount: options?.autoConnectLocalOnMount, }); const { navigateTo, refresh, navigateUp, openEntry, setFilter, toggleSelection, rangeSelect, clearSelection, selectAll, getFilteredFiles, createDirectory, createDirectoryAtPath, createFile, createFileAtPath, deleteFiles, deleteFilesAtPath, renameFile, renameFileAtPath, moveEntriesToPath, changePermissions, } = useSftpPaneActions({ hosts, getActivePane, updateTab, updateActiveTab, leftTabsRef, rightTabsRef, navSeqRef, dirCacheRef, sftpSessionsRef, lastConnectedHostRef, connectionCacheKeyMapRef, reconnectingRef, makeCacheKey, clearCacheForConnection, listLocalFiles, listRemoteFiles, handleSessionError, isSessionError, clearSelectionsExcept, dirCacheTtlMs: DIR_CACHE_TTL_MS, }); const setFilenameEncoding = useCallback( (side: "left" | "right", encoding: SftpFilenameEncoding) => { updateActiveTab(side, (prev) => ({ ...prev, filenameEncoding: encoding, })); const pane = getActivePane(side); if (pane?.connection && !pane.connection.isLocal) { clearCacheForConnection(pane.connection.id); // Defer refresh so state update lands before we read filenameEncoding in navigateTo. setTimeout(() => { const refreshedPane = getActivePane(side); if (refreshedPane?.connection) { navigateTo(side, refreshedPane.connection.currentPath, { force: true }); } }, 0); } }, [clearCacheForConnection, getActivePane, navigateTo, updateActiveTab], ); const setShowHiddenFiles = useCallback( (side: "left" | "right", tabId: string, showHiddenFiles: boolean) => { setTabShowHiddenFiles(side, tabId, showHiddenFiles); }, [setTabShowHiddenFiles], ); const { transfers, conflicts: transferConflicts, activeTransfersCount, startTransfer, downloadToLocal, addExternalUpload, updateExternalUpload, cancelTransfer, pauseTransfer, resumeTransfer, prioritizeTransfer, isTransferCancelled, retryTransfer, clearCompletedTransfers, dismissTransfer, resolveConflict: resolveTransferConflict, } = useSftpTransfers({ ownerId: transferOwnerIdRef.current, canPrepareAdoption: options?.canPrepareTransferAdoption, getActivePane, getPaneByConnectionId, getTabByConnectionId, updateTab, refresh, clearCacheForConnection, sftpSessionsRef, connectionCacheKeyMapRef, listLocalFiles, listRemoteFiles, handleSessionError, acquireTransferSession, }); const { readTextFile, readBinaryFile, writeTextFile, writeTextFileByConnection, downloadToTempAndOpen, openWithSystemDefault, uploadExternalFiles, uploadExternalFileList, uploadExternalFolderPath, uploadExternalEntries, cancelExternalUpload, selectApplication, activeFileWatchCountRef, uploadConflicts, resolveUploadConflict, } = useSftpExternalOperations({ ownerId: transferOwnerIdRef.current, getActivePane, getPaneByConnectionId, getPaneByTabId, getSideByTabId, refresh, sftpSessionsRef, connectionCacheKeyMapRef, ensureRemoteSftpId: async (side, ensureOptions) => { const bridge = netcattyBridge.get(); const connectionId = ensureOptions?.connectionId; // Tab ids survive reconnect; connection ids are regenerated by connect(). const tabId = ensureOptions?.tabId ?? (connectionId ? getTabByConnectionId(connectionId)?.tabId : undefined); // Prefer live side when the pinned tab was dragged left↔right mid-upload. const reconnectSide = tabId ? (getSideByTabId(tabId) ?? side) : side; const pinnedGetActivePane = tabId ? (_side: "left" | "right") => { const pane = getPaneByTabId(tabId); if (!pane) { throw new Error("Upload target connection is no longer available"); } return pane; } : getActivePane; return ensureRemoteSftpSession({ side: reconnectSide, getActivePane: pinnedGetActivePane, sftpSessionsRef, lastConnectedHostRef, connect, resolveConnectedHost: (id) => connectedHostByTabIdRef.current.get(id) ?? null, resolveHostById: (hostId) => hosts.find((host) => host.id === hostId) ?? null, forceReconnect: ensureOptions?.forceReconnect, tabId, probeSession: async (sftpId) => { // Lightweight liveness check; any session-error from the bridge // triggers a reconnect in ensureRemoteSftpSession. if (!bridge?.getSftpHomeDir) return true; const result = await bridge.getSftpHomeDir(sftpId); if (result && result.success === false) { throw new Error(result.error || "SFTP session not found"); } return true; }, }); }, resolveConnectedHost: (tabId) => connectedHostByTabIdRef.current.get(tabId) ?? null, acquireTransferSession, clearDirCacheEntry, useCompressedUpload: options?.useCompressedUpload, addExternalUpload, updateExternalUpload, isTransferCancelled, dismissExternalUpload: dismissTransfer, }); const conflicts = useMemo( () => [...transferConflicts, ...uploadConflicts], [transferConflicts, uploadConflicts], ); const resolveAnyConflict = useCallback( (...args: Parameters) => { const [conflictId] = args; if (uploadConflicts.some((conflict) => conflict.transferId === conflictId)) { return resolveUploadConflict(...args); } return resolveTransferConflict(...args); }, [resolveTransferConflict, resolveUploadConflict, uploadConflicts], ); // FileZilla-style: when the browser UI is hidden, soft-close browse SFTP // channels. Defer park while this owner still has unfinished transfers so // pre-lease prep (conflict/stat) cannot race a hard-close of the browse id. // In-flight streams also soft-close via leases; pool handles bulk I/O. const interactive = options?.interactive !== false; useEffect(() => { const gen = ++browseLifecycleGenRef.current; const parkBrowse = async () => { // Include global-center rows owned by this panel so we never soft-close // browse sessions while bulk work is still arming/running. // Match retain semantics: paused/interrupted folder walks still need the // browse (or work) session until resume finishes — do not hard-park them. const centerActive = sftpTransferCenterStore.getSnapshot().tasks.some((task) => ( task.ownerId === transferOwnerIdRef.current && !task.parentTaskId && task.status !== "completed" && task.status !== "cancelled" )); if (!shouldParkBrowseSessions({ interactive, browseParked: browseParkedRef.current, activeTransfersCount: Math.max(activeTransfersCount, centerActive ? 1 : 0), })) { return; } const entries = takeBrowseSessionsForClose(sftpSessionsRef.current); if (entries.length === 0) { browseParkedRef.current = true; return; } browseParkedRef.current = true; logger.info(`[SFTP] Parking ${entries.length} browse session(s) (transfers keep pool leases)`); await Promise.all(entries.map(async ({ connectionId, sftpId }) => { clearCacheForConnection(connectionId); try { // closeSftp soft-closes when transfer leases still hold the id. await netcattyBridge.get()?.closeSftp?.(sftpId); } catch { // best-effort — session may already be gone } })); }; const restoreBrowse = async () => { if (!shouldRestoreBrowseSessions({ interactive, browseParked: browseParkedRef.current, })) { return; } browseParkedRef.current = false; const sides: Array<"left" | "right"> = ["left", "right"]; for (const side of sides) { if (gen !== browseLifecycleGenRef.current) return; const pane = getActivePane(side); if (!pane?.connection || pane.connection.isLocal) continue; if (sftpSessionsRef.current.has(pane.connection.id)) continue; try { await ensureRemoteSftpSession({ side, getActivePane, sftpSessionsRef, lastConnectedHostRef, connect, resolveConnectedHost: (id) => connectedHostByTabIdRef.current.get(id) ?? null, resolveHostById: (hostId) => hosts.find((host) => host.id === hostId) ?? null, probeSession: async (sftpId) => { const bridge = netcattyBridge.get(); if (!bridge?.getSftpHomeDir) return true; const result = await bridge.getSftpHomeDir(sftpId); if (result && result.success === false) { throw new Error(result.error || "SFTP session not found"); } return true; }, }); logger.info(`[SFTP] Restored browse session on ${side}`); } catch (err) { logger.warn(`[SFTP] Failed to restore browse session on ${side}`, err); } } }; if (!interactive) { void parkBrowse(); } else { void restoreBrowse(); } }, [ interactive, activeTransfersCount, clearCacheForConnection, connect, getActivePane, hosts, lastConnectedHostRef, sftpSessionsRef, ]); // Store methods in a ref to create stable wrapper functions // This prevents callback reference changes from causing re-renders in consumers const methodsRef = useRef({ getFilteredFiles, addTab, closeTab: closeTabAndClearHost, selectTab, reorderTabs, moveTabToOtherSide, getTabsInfo, getActiveTabId, getActivePane, connect, disconnect, navigateTo, navigateUp, refresh, openEntry, toggleSelection, rangeSelect, clearSelection, clearSelectionsExcept, selectAll, setFilter, setFilenameEncoding, setShowHiddenFiles, createDirectory, createDirectoryAtPath, createFile, createFileAtPath, deleteFiles, deleteFilesAtPath, renameFile, renameFileAtPath, moveEntriesToPath, changePermissions, readTextFile, readBinaryFile, writeTextFile, writeTextFileByConnection, downloadToTempAndOpen, openWithSystemDefault, uploadExternalFiles, uploadExternalFileList, uploadExternalFolderPath, uploadExternalEntries, cancelExternalUpload, selectApplication, startTransfer, downloadToLocal, addExternalUpload, updateExternalUpload, cancelTransfer, pauseTransfer, resumeTransfer, prioritizeTransfer, retryTransfer, clearCompletedTransfers, dismissTransfer, resolveConflict: resolveAnyConflict, getSftpIdForConnection, getConnectionCacheKey, setLastConnectedHost, reportSessionError: handleSessionError, rejectHostKeyVerification, acceptHostKeyVerification, acceptAndSaveHostKeyVerification, warmTransferPoolForHost, }); methodsRef.current = { getFilteredFiles, addTab, closeTab: closeTabAndClearHost, selectTab, reorderTabs, moveTabToOtherSide, getTabsInfo, getActiveTabId, getActivePane, connect, disconnect, navigateTo, navigateUp, refresh, openEntry, toggleSelection, rangeSelect, clearSelection, clearSelectionsExcept, selectAll, setFilter, setFilenameEncoding, setShowHiddenFiles, createDirectory, createDirectoryAtPath, createFile, createFileAtPath, deleteFiles, deleteFilesAtPath, renameFile, renameFileAtPath, moveEntriesToPath, changePermissions, readTextFile, readBinaryFile, writeTextFile, writeTextFileByConnection, downloadToTempAndOpen, openWithSystemDefault, uploadExternalFiles, uploadExternalFileList, uploadExternalFolderPath, uploadExternalEntries, cancelExternalUpload, selectApplication, startTransfer, downloadToLocal, addExternalUpload, updateExternalUpload, cancelTransfer, retryTransfer, clearCompletedTransfers, dismissTransfer, resolveConflict: resolveAnyConflict, getSftpIdForConnection, getConnectionCacheKey, setLastConnectedHost, reportSessionError: handleSessionError, rejectHostKeyVerification, acceptHostKeyVerification, acceptAndSaveHostKeyVerification, warmTransferPoolForHost, }; // Create stable method wrappers that call through methodsRef // These are created once and never change reference const stableMethods = useMemo(() => ({ getFilteredFiles: (...args: Parameters) => methodsRef.current.getFilteredFiles(...args), addTab: (...args: Parameters) => methodsRef.current.addTab(...args), closeTab: (...args: Parameters) => methodsRef.current.closeTab(...args), selectTab: (...args: Parameters) => methodsRef.current.selectTab(...args), reorderTabs: (...args: Parameters) => methodsRef.current.reorderTabs(...args), moveTabToOtherSide: (...args: Parameters) => methodsRef.current.moveTabToOtherSide(...args), getTabsInfo: (...args: Parameters) => methodsRef.current.getTabsInfo(...args), getActiveTabId: (...args: Parameters) => methodsRef.current.getActiveTabId(...args), getActivePane: (...args: Parameters) => methodsRef.current.getActivePane(...args), connect: (...args: Parameters) => methodsRef.current.connect(...args), disconnect: (...args: Parameters) => methodsRef.current.disconnect(...args), navigateTo: (...args: Parameters) => methodsRef.current.navigateTo(...args), navigateUp: (...args: Parameters) => methodsRef.current.navigateUp(...args), refresh: (...args: Parameters) => methodsRef.current.refresh(...args), openEntry: (...args: Parameters) => methodsRef.current.openEntry(...args), toggleSelection: (...args: Parameters) => methodsRef.current.toggleSelection(...args), rangeSelect: (...args: Parameters) => methodsRef.current.rangeSelect(...args), clearSelection: (...args: Parameters) => methodsRef.current.clearSelection(...args), clearSelectionsExcept: (...args: Parameters) => methodsRef.current.clearSelectionsExcept(...args), selectAll: (...args: Parameters) => methodsRef.current.selectAll(...args), setFilter: (...args: Parameters) => methodsRef.current.setFilter(...args), setFilenameEncoding: (...args: Parameters) => methodsRef.current.setFilenameEncoding(...args), setShowHiddenFiles: (...args: Parameters) => methodsRef.current.setShowHiddenFiles(...args), createDirectory: (...args: Parameters) => methodsRef.current.createDirectory(...args), createDirectoryAtPath: (...args: Parameters) => methodsRef.current.createDirectoryAtPath(...args), createFile: (...args: Parameters) => methodsRef.current.createFile(...args), createFileAtPath: (...args: Parameters) => methodsRef.current.createFileAtPath(...args), deleteFiles: (...args: Parameters) => methodsRef.current.deleteFiles(...args), deleteFilesAtPath: (...args: Parameters) => methodsRef.current.deleteFilesAtPath(...args), renameFile: (...args: Parameters) => methodsRef.current.renameFile(...args), renameFileAtPath: (...args: Parameters) => methodsRef.current.renameFileAtPath(...args), moveEntriesToPath: (...args: Parameters) => methodsRef.current.moveEntriesToPath(...args), changePermissions: (...args: Parameters) => methodsRef.current.changePermissions(...args), readTextFile: (...args: Parameters) => methodsRef.current.readTextFile(...args), readBinaryFile: (...args: Parameters) => methodsRef.current.readBinaryFile(...args), writeTextFile: (...args: Parameters) => methodsRef.current.writeTextFile(...args), writeTextFileByConnection: (...args: Parameters) => methodsRef.current.writeTextFileByConnection(...args), downloadToTempAndOpen: (...args: Parameters) => methodsRef.current.downloadToTempAndOpen(...args), openWithSystemDefault: (...args: Parameters) => methodsRef.current.openWithSystemDefault(...args), uploadExternalFiles: (...args: Parameters) => methodsRef.current.uploadExternalFiles(...args), uploadExternalFileList: (...args: Parameters) => methodsRef.current.uploadExternalFileList(...args), uploadExternalFolderPath: (...args: Parameters) => methodsRef.current.uploadExternalFolderPath(...args), uploadExternalEntries: (...args: Parameters) => methodsRef.current.uploadExternalEntries(...args), cancelExternalUpload: (taskId?: string) => methodsRef.current.cancelExternalUpload(taskId), selectApplication: () => methodsRef.current.selectApplication(), startTransfer: (...args: Parameters) => methodsRef.current.startTransfer(...args), downloadToLocal: (...args: Parameters) => methodsRef.current.downloadToLocal(...args), addExternalUpload: (...args: Parameters) => methodsRef.current.addExternalUpload(...args), updateExternalUpload: (...args: Parameters) => methodsRef.current.updateExternalUpload(...args), cancelTransfer: (...args: Parameters) => methodsRef.current.cancelTransfer(...args), pauseTransfer: (...args: Parameters) => methodsRef.current.pauseTransfer(...args), resumeTransfer: (...args: Parameters) => methodsRef.current.resumeTransfer(...args), prioritizeTransfer: (...args: Parameters) => methodsRef.current.prioritizeTransfer(...args), retryTransfer: (...args: Parameters) => methodsRef.current.retryTransfer(...args), clearCompletedTransfers: () => methodsRef.current.clearCompletedTransfers(), dismissTransfer: (...args: Parameters) => methodsRef.current.dismissTransfer(...args), resolveConflict: (...args: Parameters) => methodsRef.current.resolveConflict(...args), getSftpIdForConnection: (...args: Parameters) => methodsRef.current.getSftpIdForConnection(...args), getConnectionCacheKey: (...args: Parameters) => methodsRef.current.getConnectionCacheKey(...args), setLastConnectedHost: (...args: Parameters) => methodsRef.current.setLastConnectedHost(...args), reportSessionError: (...args: Parameters) => methodsRef.current.reportSessionError(...args), rejectHostKeyVerification: () => methodsRef.current.rejectHostKeyVerification(), acceptHostKeyVerification: () => methodsRef.current.acceptHostKeyVerification(), acceptAndSaveHostKeyVerification: () => methodsRef.current.acceptAndSaveHostKeyVerification(), warmTransferPoolForHost: (...args: Parameters) => methodsRef.current.warmTransferPoolForHost(...args), activeFileWatchCountRef, }), [activeFileWatchCountRef]); // activeFileWatchCountRef is a stable ref // Return object with stable method references but reactive state // State changes will cause re-renders, but method references stay stable return useMemo(() => ({ // Reactive state - changes trigger re-renders leftPane, rightPane, leftTabs, rightTabs, transfers, activeTransfersCount, conflicts, hostKeyVerification, // Stable methods - never change reference ...stableMethods, // Pure helper functions (these are defined at module level, always stable) formatFileSize, formatDate, getFileExtension, joinPath, getParentPath, getFileName, }), [ // Only state in deps - methods come from stableMethods which is stable leftPane, rightPane, leftTabs, rightTabs, transfers, activeTransfersCount, conflicts, hostKeyVerification, stableMethods, ]); }; export type SftpStateApi = ReturnType;