Files
Netcatty/application/state/useSftpState.ts
T
LAPTOP-O016UC3M\Qi Chen b8c221d112 Organize and normalize imports across project
Reorder and normalize import statements, group icon imports, and add
missing utility imports (cn). Fix export/newline formatting and minor
type import tweaks. Add ESLint scripts to package.json and update the
lockfile.
2025-12-11 16:01:03 +08:00

1397 lines
52 KiB
TypeScript

import { useCallback,useEffect,useRef,useState } from 'react';
import {
FileConflict,
Host,
SftpConnection,
SftpFileEntry,
SSHKey,
TransferDirection,
TransferStatus,
TransferTask,
} from '../../domain/models';
// Helper functions
const formatFileSize = (bytes: number): string => {
if (bytes === 0) return '--';
const units = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
const i = Math.floor(Math.log(bytes) / Math.log(1024));
const size = bytes / Math.pow(1024, i);
return `${size.toFixed(i === 0 ? 0 : 2)} ${units[i]}`;
};
const formatDate = (timestamp: number): string => {
if (!timestamp) return '--';
const date = new Date(timestamp);
return date.toLocaleDateString('en-US', {
month: 'short',
day: 'numeric',
year: 'numeric',
hour: 'numeric',
minute: '2-digit',
});
};
const getFileExtension = (name: string): string => {
if (name === '..') return 'folder';
const ext = name.split('.').pop()?.toLowerCase();
return ext || 'file';
};
// Check if path is Windows-style
const isWindowsPath = (path: string): boolean => /^[A-Za-z]:/.test(path);
const joinPath = (base: string, name: string): string => {
if (isWindowsPath(base)) {
// Windows path
const normalizedBase = base.replace(/[\\/]+$/, ''); // Remove trailing slashes
return `${normalizedBase}\\${name}`;
}
// Unix path
if (base === '/') return `/${name}`;
return `${base}/${name}`;
};
const getParentPath = (path: string): string => {
if (isWindowsPath(path)) {
// Windows path
const parts = path.split(/[\\/]/).filter(Boolean);
if (parts.length <= 1) return parts[0] || 'C:'; // Return drive root
parts.pop();
return parts.join('\\');
}
// Unix path
if (path === '/') return '/';
const parts = path.split('/').filter(Boolean);
parts.pop();
return parts.length ? `/${parts.join('/')}` : '/';
};
const getFileName = (path: string): string => {
const parts = path.split(/[\\/]/).filter(Boolean);
return parts[parts.length - 1] || '';
};
export interface SftpPane {
connection: SftpConnection | null;
files: SftpFileEntry[];
loading: boolean;
reconnecting: boolean;
error: string | null;
selectedFiles: Set<string>;
filter: string;
}
export const useSftpState = (hosts: Host[], keys: SSHKey[]) => {
// Connections
const [leftPane, setLeftPane] = useState<SftpPane>({
connection: null,
files: [],
loading: false,
reconnecting: false,
error: null,
selectedFiles: new Set(),
filter: '',
});
const [rightPane, setRightPane] = useState<SftpPane>({
connection: null,
files: [],
loading: false,
reconnecting: false,
error: null,
selectedFiles: new Set(),
filter: '',
});
// Transfer management
const [transfers, setTransfers] = useState<TransferTask[]>([]);
const [conflicts, setConflicts] = useState<FileConflict[]>([]);
// SFTP session refs
const sftpSessionsRef = useRef<Map<string, string>>(new Map()); // connectionId -> sftpId
// Progress simulation refs
const progressIntervalsRef = useRef<Map<string, NodeJS.Timeout>>(new Map());
// Simulate progress for a transfer (used when real progress callbacks aren't available)
const startProgressSimulation = useCallback((taskId: string, estimatedBytes: number) => {
// Clear any existing interval for this task
const existing = progressIntervalsRef.current.get(taskId);
if (existing) clearInterval(existing);
// Estimate transfer speed based on file size (simulate realistic speeds)
// Smaller files: faster perceived progress, larger files: slower but steady
const baseSpeed = Math.max(50000, Math.min(500000, estimatedBytes / 10)); // 50KB/s to 500KB/s base
const variability = 0.3; // 30% speed variation
let transferred = 0;
const interval = setInterval(() => {
// Add some randomness to simulate real network conditions
const speedFactor = 1 + (Math.random() - 0.5) * variability;
const chunkSize = Math.floor(baseSpeed * speedFactor * 0.1); // Update every 100ms
transferred = Math.min(transferred + chunkSize, estimatedBytes);
setTransfers(prev => prev.map(t => {
if (t.id !== taskId || t.status !== 'transferring') return t;
return {
...t,
transferredBytes: transferred,
totalBytes: estimatedBytes,
speed: chunkSize * 10, // Convert to per-second
};
}));
// If we've reached the estimated size, slow down to show we're finishing
if (transferred >= estimatedBytes * 0.95) {
clearInterval(interval);
progressIntervalsRef.current.delete(taskId);
}
}, 100);
progressIntervalsRef.current.set(taskId, interval);
}, []);
const stopProgressSimulation = useCallback((taskId: string) => {
const interval = progressIntervalsRef.current.get(taskId);
if (interval) {
clearInterval(interval);
progressIntervalsRef.current.delete(taskId);
}
}, []);
// Check if an error indicates a stale/lost SFTP session
const isSessionError = (err: unknown): boolean => {
if (!(err instanceof Error)) return false;
const msg = err.message.toLowerCase();
return msg.includes('session not found') ||
msg.includes('sftp session') ||
msg.includes('not found') ||
msg.includes('closed') ||
msg.includes('connection reset');
};
// Ref to track pending reconnections to avoid multiple reconnect attempts
const reconnectingRef = useRef<{ left: boolean; right: boolean }>({ left: false, right: false });
// Store last connected host info for reconnection
const lastConnectedHostRef = useRef<{ left: Host | 'local' | null; right: Host | 'local' | null }>({
left: null,
right: null
});
// Handle session error - will trigger auto-reconnect if host info is available
const handleSessionError = useCallback((side: 'left' | 'right', error: Error) => {
const pane = side === 'left' ? leftPane : rightPane;
const setPane = side === 'left' ? setLeftPane : setRightPane;
if (pane.connection) {
// Clean up stale session reference
sftpSessionsRef.current.delete(pane.connection.id);
}
// Check if we have host info to attempt reconnection
const lastHost = lastConnectedHostRef.current[side];
if (lastHost && pane.files.length > 0 && !reconnectingRef.current[side]) {
// We have files displayed, try to auto-reconnect
reconnectingRef.current[side] = true;
setPane(prev => ({
...prev,
reconnecting: true,
error: 'Connection lost. Reconnecting...',
}));
} else {
// No host info or empty files, just clear the connection
setPane({
connection: null,
files: [],
loading: false,
reconnecting: false,
error: 'SFTP session lost. Please reconnect.',
selectedFiles: new Set(),
filter: '',
});
}
}, [leftPane, rightPane]);
// Cleanup on unmount
useEffect(() => {
return () => {
// Clear all SFTP sessions
sftpSessionsRef.current.forEach(async (sftpId) => {
try {
await window.nebula?.closeSftp(sftpId);
} catch {}
});
// Clear all progress simulation intervals
progressIntervalsRef.current.forEach((interval) => {
clearInterval(interval);
});
progressIntervalsRef.current.clear();
};
}, []);
// Track if initial auto-connect has been done
const initialConnectDoneRef = useRef(false);
// Get host credentials
const getHostCredentials = useCallback((host: Host) => {
const key = host.identityFileId ? keys.find(k => k.id === host.identityFileId) : null;
return {
hostname: host.hostname,
username: host.username,
port: host.port || 22,
password: host.password,
privateKey: key?.privateKey,
};
}, [keys]);
// Connect to a host
const connect = useCallback(async (side: 'left' | 'right', host: Host | 'local') => {
const currentPane = side === 'left' ? leftPane : rightPane;
const setPane = side === 'left' ? setLeftPane : setRightPane;
const connectionId = `${side}-${Date.now()}`;
// Save host info for potential reconnection
lastConnectedHostRef.current[side] = host;
// First, disconnect any existing connection
if (currentPane.connection && !currentPane.connection.isLocal) {
const oldSftpId = sftpSessionsRef.current.get(currentPane.connection.id);
if (oldSftpId) {
try {
await window.nebula?.closeSftp(oldSftpId);
} catch {}
sftpSessionsRef.current.delete(currentPane.connection.id);
}
}
if (host === 'local') {
// Local filesystem connection
// Try to get home directory from backend, fallback to platform-specific default
let homeDir = await window.nebula?.getHomeDir?.();
if (!homeDir) {
// Detect platform and use appropriate default
const isWindows = navigator.platform.toLowerCase().includes('win');
homeDir = isWindows ? 'C:\\Users\\damao' : '/Users/damao';
}
const connection: SftpConnection = {
id: connectionId,
hostId: 'local',
hostLabel: 'Local',
isLocal: true,
status: 'connected',
currentPath: homeDir,
homeDir,
};
setPane(prev => ({
...prev,
connection,
loading: true,
reconnecting: false,
error: null,
}));
try {
const files = await listLocalFiles(homeDir);
// Clear reconnecting flag on success
reconnectingRef.current[side] = false;
setPane(prev => ({
...prev,
files,
loading: false,
reconnecting: false,
}));
} catch (err) {
reconnectingRef.current[side] = false;
setPane(prev => ({
...prev,
error: err instanceof Error ? err.message : 'Failed to list directory',
loading: false,
reconnecting: false,
}));
}
} else {
// Remote SFTP connection
const connection: SftpConnection = {
id: connectionId,
hostId: host.id,
hostLabel: host.label,
isLocal: false,
status: 'connecting',
currentPath: '/',
};
setPane(prev => ({
...prev,
connection,
loading: true,
reconnecting: prev.reconnecting, // Preserve reconnecting state during connection
error: null,
files: prev.reconnecting ? prev.files : [], // Keep files if reconnecting
}));
try {
const credentials = getHostCredentials(host);
const sftpId = await window.nebula?.openSftp({
sessionId: `sftp-${connectionId}`,
...credentials,
});
if (!sftpId) throw new Error('Failed to open SFTP session');
sftpSessionsRef.current.set(connectionId, sftpId);
// Try to get home directory, default to /
let startPath = '/';
try {
const homeFiles = await window.nebula?.listSftp(sftpId, `/home/${credentials.username}`);
if (homeFiles) startPath = `/home/${credentials.username}`;
} catch {
try {
const rootFiles = await window.nebula?.listSftp(sftpId, '/root');
if (rootFiles) startPath = '/root';
} catch {}
}
const files = await listRemoteFiles(sftpId, startPath);
// Clear reconnecting flag on success
reconnectingRef.current[side] = false;
setPane(prev => ({
...prev,
connection: prev.connection ? {
...prev.connection,
status: 'connected',
currentPath: startPath,
homeDir: startPath,
} : null,
files,
loading: false,
reconnecting: false,
}));
} catch (err) {
reconnectingRef.current[side] = false;
setPane(prev => ({
...prev,
connection: prev.connection ? {
...prev.connection,
status: 'error',
error: err instanceof Error ? err.message : 'Connection failed',
} : null,
error: err instanceof Error ? err.message : 'Connection failed',
loading: false,
reconnecting: false,
}));
}
}
}, [getHostCredentials, leftPane, rightPane]);
// Auto-connect left pane to local filesystem on first mount
useEffect(() => {
if (!initialConnectDoneRef.current && !leftPane.connection) {
initialConnectDoneRef.current = true;
// Use setTimeout to ensure connect is defined before calling
setTimeout(() => {
connect('left', 'local');
}, 0);
}
}, [connect, leftPane.connection]);
// Auto-reconnect when reconnecting flag is set
useEffect(() => {
const attemptReconnect = async (side: 'left' | 'right') => {
const lastHost = lastConnectedHostRef.current[side];
if (lastHost && reconnectingRef.current[side]) {
// Small delay before reconnecting
await new Promise(resolve => setTimeout(resolve, 1000));
if (reconnectingRef.current[side]) {
connect(side, lastHost);
}
}
};
if (leftPane.reconnecting && reconnectingRef.current.left) {
attemptReconnect('left');
}
if (rightPane.reconnecting && reconnectingRef.current.right) {
attemptReconnect('right');
}
}, [leftPane.reconnecting, rightPane.reconnecting, connect]);
// Disconnect
const disconnect = useCallback(async (side: 'left' | 'right') => {
const pane = side === 'left' ? leftPane : rightPane;
const setPane = side === 'left' ? setLeftPane : setRightPane;
// Clear reconnection state
reconnectingRef.current[side] = false;
lastConnectedHostRef.current[side] = null;
if (pane.connection && !pane.connection.isLocal) {
const sftpId = sftpSessionsRef.current.get(pane.connection.id);
if (sftpId) {
try {
await window.nebula?.closeSftp(sftpId);
} catch {}
sftpSessionsRef.current.delete(pane.connection.id);
}
}
setPane({
connection: null,
files: [],
loading: false,
reconnecting: false,
error: null,
selectedFiles: new Set(),
filter: '',
});
}, [leftPane, rightPane]);
// Mock local file data for development (when backend is not available)
const getMockLocalFiles = (path: string): SftpFileEntry[] => {
// Normalize path for matching (handle both Windows and Unix paths)
const normPath = path.replace(/\\/g, '/').replace(/\/$/, '') || '/';
const mockData: Record<string, SftpFileEntry[]> = {
// Unix-style paths
'/': [
{ name: 'Users', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
{ name: 'Applications', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 172800000, lastModifiedFormatted: formatDate(Date.now() - 172800000) },
{ name: 'System', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 259200000, lastModifiedFormatted: formatDate(Date.now() - 259200000) },
],
'/Users': [
{ name: 'damao', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 3600000, lastModifiedFormatted: formatDate(Date.now() - 3600000) },
{ name: 'Shared', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
],
'/Users/damao': [
{ name: 'Desktop', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 1800000, lastModifiedFormatted: formatDate(Date.now() - 1800000) },
{ name: 'Documents', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 7200000, lastModifiedFormatted: formatDate(Date.now() - 7200000) },
{ name: 'Downloads', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 3600000, lastModifiedFormatted: formatDate(Date.now() - 3600000) },
{ name: 'Pictures', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 172800000, lastModifiedFormatted: formatDate(Date.now() - 172800000) },
{ name: 'Projects', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 900000, lastModifiedFormatted: formatDate(Date.now() - 900000) },
],
// Windows-style paths (normalized to forward slashes for matching)
'C:': [
{ name: 'Users', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
{ name: 'Program Files', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 172800000, lastModifiedFormatted: formatDate(Date.now() - 172800000) },
{ name: 'Windows', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 259200000, lastModifiedFormatted: formatDate(Date.now() - 259200000) },
],
'C:/Users': [
{ name: 'damao', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 3600000, lastModifiedFormatted: formatDate(Date.now() - 3600000) },
{ name: 'Public', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
{ name: 'Default', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 172800000, lastModifiedFormatted: formatDate(Date.now() - 172800000) },
],
'C:/Users/damao': [
{ name: 'Desktop', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 1800000, lastModifiedFormatted: formatDate(Date.now() - 1800000) },
{ name: 'Documents', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 7200000, lastModifiedFormatted: formatDate(Date.now() - 7200000) },
{ name: 'Downloads', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 3600000, lastModifiedFormatted: formatDate(Date.now() - 3600000) },
{ name: 'Pictures', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 172800000, lastModifiedFormatted: formatDate(Date.now() - 172800000) },
{ name: 'Projects', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 900000, lastModifiedFormatted: formatDate(Date.now() - 900000) },
],
'C:/Users/damao/Desktop': [
{ name: 'Netcatty', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 300000, lastModifiedFormatted: formatDate(Date.now() - 300000) },
{ name: 'notes.txt', type: 'file', size: 2048, sizeFormatted: '2 KB', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
{ name: 'screenshot.png', type: 'file', size: 1048576, sizeFormatted: '1 MB', lastModified: Date.now() - 43200000, lastModifiedFormatted: formatDate(Date.now() - 43200000) },
],
'C:/Users/damao/Desktop/Netcatty': [
{ name: 'src', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 600000, lastModifiedFormatted: formatDate(Date.now() - 600000) },
{ name: 'package.json', type: 'file', size: 1536, sizeFormatted: '1.5 KB', lastModified: Date.now() - 3600000, lastModifiedFormatted: formatDate(Date.now() - 3600000) },
{ name: 'README.md', type: 'file', size: 4096, sizeFormatted: '4 KB', lastModified: Date.now() - 7200000, lastModifiedFormatted: formatDate(Date.now() - 7200000) },
{ name: 'tsconfig.json', type: 'file', size: 512, sizeFormatted: '512 Bytes', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
],
'C:/Users/damao/Documents': [
{ name: 'Work', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
{ name: 'Personal', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 172800000, lastModifiedFormatted: formatDate(Date.now() - 172800000) },
{ name: 'report.pdf', type: 'file', size: 2097152, sizeFormatted: '2 MB', lastModified: Date.now() - 259200000, lastModifiedFormatted: formatDate(Date.now() - 259200000) },
],
'C:/Users/damao/Downloads': [
{ name: 'installer.exe', type: 'file', size: 52428800, sizeFormatted: '50 MB', lastModified: Date.now() - 3600000, lastModifiedFormatted: formatDate(Date.now() - 3600000) },
{ name: 'archive.zip', type: 'file', size: 10485760, sizeFormatted: '10 MB', lastModified: Date.now() - 7200000, lastModifiedFormatted: formatDate(Date.now() - 7200000) },
{ name: 'document.pdf', type: 'file', size: 524288, sizeFormatted: '512 KB', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
],
'C:/Users/damao/Projects': [
{ name: 'webapp', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 1800000, lastModifiedFormatted: formatDate(Date.now() - 1800000) },
{ name: 'scripts', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 43200000, lastModifiedFormatted: formatDate(Date.now() - 43200000) },
],
'/Users/damao/Desktop': [
{ name: 'Netcatty', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 300000, lastModifiedFormatted: formatDate(Date.now() - 300000) },
{ name: 'notes.txt', type: 'file', size: 2048, sizeFormatted: '2 KB', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
{ name: 'screenshot.png', type: 'file', size: 1048576, sizeFormatted: '1 MB', lastModified: Date.now() - 43200000, lastModifiedFormatted: formatDate(Date.now() - 43200000) },
],
'/Users/damao/Desktop/Netcatty': [
{ name: 'src', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 600000, lastModifiedFormatted: formatDate(Date.now() - 600000) },
{ name: 'package.json', type: 'file', size: 1536, sizeFormatted: '1.5 KB', lastModified: Date.now() - 3600000, lastModifiedFormatted: formatDate(Date.now() - 3600000) },
{ name: 'README.md', type: 'file', size: 4096, sizeFormatted: '4 KB', lastModified: Date.now() - 7200000, lastModifiedFormatted: formatDate(Date.now() - 7200000) },
{ name: 'tsconfig.json', type: 'file', size: 512, sizeFormatted: '512 Bytes', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
],
'/Users/damao/Documents': [
{ name: 'Work', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
{ name: 'Personal', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 172800000, lastModifiedFormatted: formatDate(Date.now() - 172800000) },
{ name: 'report.pdf', type: 'file', size: 2097152, sizeFormatted: '2 MB', lastModified: Date.now() - 259200000, lastModifiedFormatted: formatDate(Date.now() - 259200000) },
],
'/Users/damao/Downloads': [
{ name: 'installer.exe', type: 'file', size: 52428800, sizeFormatted: '50 MB', lastModified: Date.now() - 3600000, lastModifiedFormatted: formatDate(Date.now() - 3600000) },
{ name: 'archive.zip', type: 'file', size: 10485760, sizeFormatted: '10 MB', lastModified: Date.now() - 7200000, lastModifiedFormatted: formatDate(Date.now() - 7200000) },
{ name: 'document.pdf', type: 'file', size: 524288, sizeFormatted: '512 KB', lastModified: Date.now() - 86400000, lastModifiedFormatted: formatDate(Date.now() - 86400000) },
],
'/Users/damao/Projects': [
{ name: 'webapp', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 1800000, lastModifiedFormatted: formatDate(Date.now() - 1800000) },
{ name: 'scripts', type: 'directory', size: 0, sizeFormatted: '--', lastModified: Date.now() - 43200000, lastModifiedFormatted: formatDate(Date.now() - 43200000) },
],
};
return mockData[normPath] || [];
};
// List local files
const listLocalFiles = async (path: string): Promise<SftpFileEntry[]> => {
const rawFiles = await window.nebula?.listLocalDir?.(path);
if (!rawFiles) {
// Fallback mock for development
return getMockLocalFiles(path);
}
return rawFiles.map(f => ({
name: f.name,
type: f.type as 'file' | 'directory' | 'symlink',
size: parseInt(f.size) || 0,
sizeFormatted: f.size,
lastModified: new Date(f.lastModified).getTime(),
lastModifiedFormatted: f.lastModified,
}));
};
// List remote files
const listRemoteFiles = async (sftpId: string, path: string): Promise<SftpFileEntry[]> => {
const rawFiles = await window.nebula?.listSftp(sftpId, path);
if (!rawFiles) return [];
return rawFiles.map(f => ({
name: f.name,
type: f.type as 'file' | 'directory' | 'symlink',
size: parseInt(f.size) || 0,
sizeFormatted: f.size,
lastModified: new Date(f.lastModified).getTime(),
lastModifiedFormatted: f.lastModified,
}));
};
// Navigate to path
const navigateTo = useCallback(async (side: 'left' | 'right', path: string) => {
const pane = side === 'left' ? leftPane : rightPane;
const setPane = side === 'left' ? setLeftPane : setRightPane;
if (!pane.connection) return;
setPane(prev => ({ ...prev, loading: true, error: null }));
try {
let files: SftpFileEntry[];
if (pane.connection.isLocal) {
files = await listLocalFiles(path);
} else {
const sftpId = sftpSessionsRef.current.get(pane.connection.id);
if (!sftpId) {
// Session lost - clear connection state
setPane({
connection: null,
files: [],
loading: false,
error: 'SFTP session lost. Please reconnect.',
selectedFiles: new Set(),
filter: '',
});
return;
}
try {
files = await listRemoteFiles(sftpId, path);
} catch (err) {
// Check if it's a session error
const errorMsg = err instanceof Error ? err.message : 'Unknown error';
if (errorMsg.includes('session') || errorMsg.includes('not found') || errorMsg.includes('closed')) {
// Clean up stale session reference
sftpSessionsRef.current.delete(pane.connection.id);
setPane({
connection: null,
files: [],
loading: false,
error: 'SFTP session expired. Please reconnect.',
selectedFiles: new Set(),
filter: '',
});
return;
}
throw err;
}
}
setPane(prev => ({
...prev,
connection: prev.connection ? { ...prev.connection, currentPath: path } : null,
files,
loading: false,
selectedFiles: new Set(),
}));
} catch (err) {
setPane(prev => ({
...prev,
error: err instanceof Error ? err.message : 'Failed to list directory',
loading: false,
}));
}
}, [leftPane, rightPane]);
// Refresh current directory
const refresh = useCallback(async (side: 'left' | 'right') => {
const pane = side === 'left' ? leftPane : rightPane;
if (pane.connection) {
await navigateTo(side, pane.connection.currentPath);
}
}, [leftPane, rightPane, navigateTo]);
// Navigate up
const navigateUp = useCallback(async (side: 'left' | 'right') => {
const pane = side === 'left' ? leftPane : rightPane;
if (!pane.connection) return;
const currentPath = pane.connection.currentPath;
// Check if we're at root (Unix "/" or Windows "C:")
const isAtRoot = currentPath === '/' || /^[A-Za-z]:[\\/]?$/.test(currentPath);
if (!isAtRoot) {
const parentPath = getParentPath(currentPath);
await navigateTo(side, parentPath);
}
}, [leftPane, rightPane, navigateTo]);
// Open file/directory
const openEntry = useCallback(async (side: 'left' | 'right', entry: SftpFileEntry) => {
const pane = side === 'left' ? leftPane : rightPane;
if (!pane.connection) return;
if (entry.name === '..') {
await navigateUp(side);
return;
}
if (entry.type === 'directory') {
const newPath = joinPath(pane.connection.currentPath, entry.name);
await navigateTo(side, newPath);
}
// TODO: Handle file open/preview
}, [leftPane, rightPane, navigateTo, navigateUp]);
// Selection management
const toggleSelection = useCallback((side: 'left' | 'right', fileName: string, multiSelect: boolean) => {
const setPane = side === 'left' ? setLeftPane : setRightPane;
setPane(prev => {
const newSelection = new Set(multiSelect ? prev.selectedFiles : []);
if (newSelection.has(fileName)) {
newSelection.delete(fileName);
} else {
newSelection.add(fileName);
}
return { ...prev, selectedFiles: newSelection };
});
}, []);
// Range selection for shift-click
// Now accepts the actual file names to select directly from the UI
const rangeSelect = useCallback((side: 'left' | 'right', fileNames: string[]) => {
const setPane = side === 'left' ? setLeftPane : setRightPane;
const newSelection = new Set<string>();
for (const name of fileNames) {
if (name && name !== '..') {
newSelection.add(name);
}
}
setPane(prev => ({ ...prev, selectedFiles: newSelection }));
}, []);
const clearSelection = useCallback((side: 'left' | 'right') => {
const setPane = side === 'left' ? setLeftPane : setRightPane;
setPane(prev => ({ ...prev, selectedFiles: new Set() }));
}, []);
const selectAll = useCallback((side: 'left' | 'right') => {
const pane = side === 'left' ? leftPane : rightPane;
const setPane = side === 'left' ? setLeftPane : setRightPane;
setPane(prev => ({
...prev,
selectedFiles: new Set(pane.files.filter(f => f.name !== '..').map(f => f.name)),
}));
}, [leftPane, rightPane]);
// Filter
const setFilter = useCallback((side: 'left' | 'right', filter: string) => {
const setPane = side === 'left' ? setLeftPane : setRightPane;
setPane(prev => ({ ...prev, filter }));
}, []);
// Create directory
const createDirectory = useCallback(async (side: 'left' | 'right', name: string) => {
const pane = side === 'left' ? leftPane : rightPane;
if (!pane.connection) return;
const fullPath = joinPath(pane.connection.currentPath, name);
try {
if (pane.connection.isLocal) {
await window.nebula?.mkdirLocal?.(fullPath);
} else {
const sftpId = sftpSessionsRef.current.get(pane.connection.id);
if (!sftpId) {
handleSessionError(side, new Error('SFTP session not found'));
return;
}
await window.nebula?.mkdirSftp(sftpId, fullPath);
}
await refresh(side);
} catch (err) {
if (isSessionError(err)) {
handleSessionError(side, err as Error);
return;
}
throw err;
}
}, [leftPane, rightPane, refresh, handleSessionError]);
// Delete files
const deleteFiles = useCallback(async (side: 'left' | 'right', fileNames: string[]) => {
const pane = side === 'left' ? leftPane : rightPane;
if (!pane.connection) return;
try {
for (const name of fileNames) {
const fullPath = joinPath(pane.connection.currentPath, name);
if (pane.connection.isLocal) {
await window.nebula?.deleteLocalFile?.(fullPath);
} else {
const sftpId = sftpSessionsRef.current.get(pane.connection.id);
if (!sftpId) {
handleSessionError(side, new Error('SFTP session not found'));
return;
}
await window.nebula?.deleteSftp?.(sftpId, fullPath);
}
}
await refresh(side);
} catch (err) {
if (isSessionError(err)) {
handleSessionError(side, err as Error);
return;
}
throw err;
}
}, [leftPane, rightPane, refresh, handleSessionError]);
// Rename file
const renameFile = useCallback(async (side: 'left' | 'right', oldName: string, newName: string) => {
const pane = side === 'left' ? leftPane : rightPane;
if (!pane.connection) return;
const oldPath = joinPath(pane.connection.currentPath, oldName);
const newPath = joinPath(pane.connection.currentPath, newName);
try {
if (pane.connection.isLocal) {
await window.nebula?.renameLocalFile?.(oldPath, newPath);
} else {
const sftpId = sftpSessionsRef.current.get(pane.connection.id);
if (!sftpId) {
handleSessionError(side, new Error('SFTP session not found'));
return;
}
await window.nebula?.renameSftp?.(sftpId, oldPath, newPath);
}
await refresh(side);
} catch (err) {
if (isSessionError(err)) {
handleSessionError(side, err as Error);
return;
}
throw err;
}
}, [leftPane, rightPane, refresh, handleSessionError]);
// Transfer files
const startTransfer = useCallback(async (
sourceFiles: { name: string; isDirectory: boolean }[],
sourceSide: 'left' | 'right',
targetSide: 'left' | 'right'
) => {
const sourcePane = sourceSide === 'left' ? leftPane : rightPane;
const targetPane = targetSide === 'left' ? leftPane : rightPane;
if (!sourcePane.connection || !targetPane.connection) return;
const sourcePath = sourcePane.connection.currentPath;
const targetPath = targetPane.connection.currentPath;
// Get SFTP session ID if remote
const sourceSftpId = sourcePane.connection.isLocal ? null :
sftpSessionsRef.current.get(sourcePane.connection.id);
// Create transfer tasks with actual file sizes
const newTasks: TransferTask[] = [];
for (const file of sourceFiles) {
const direction: TransferDirection =
sourcePane.connection!.isLocal && !targetPane.connection!.isLocal ? 'upload' :
!sourcePane.connection!.isLocal && targetPane.connection!.isLocal ? 'download' :
'remote-to-remote';
// Get actual file size from source
let fileSize = 0;
if (!file.isDirectory) {
try {
const fullPath = joinPath(sourcePath, file.name);
if (sourcePane.connection!.isLocal) {
const stat = await window.nebula?.statLocal?.(fullPath);
if (stat) fileSize = stat.size;
} else if (sourceSftpId) {
const stat = await window.nebula?.statSftp?.(sourceSftpId, fullPath);
if (stat) fileSize = stat.size;
}
} catch {
// If stat fails, we'll use estimate later
}
}
newTasks.push({
id: crypto.randomUUID(),
fileName: file.name,
sourcePath: joinPath(sourcePath, file.name),
targetPath: joinPath(targetPath, file.name),
sourceConnectionId: sourcePane.connection!.id,
targetConnectionId: targetPane.connection!.id,
direction,
status: 'pending' as TransferStatus,
totalBytes: fileSize,
transferredBytes: 0,
speed: 0,
startTime: Date.now(),
isDirectory: file.isDirectory,
});
}
setTransfers(prev => [...prev, ...newTasks]);
// Process transfers
for (const task of newTasks) {
await processTransfer(task, sourcePane, targetPane);
}
}, [leftPane, rightPane]);
// Process a single transfer
const processTransfer = async (
task: TransferTask,
sourcePane: SftpPane,
targetPane: SftpPane
) => {
const updateTask = (updates: Partial<TransferTask>) => {
setTransfers(prev => prev.map(t => t.id === task.id ? { ...t, ...updates } : t));
};
// Get actual file size if not already known
let actualFileSize = task.totalBytes;
if (!task.isDirectory && actualFileSize === 0) {
try {
const sourceSftpId = sourcePane.connection?.isLocal ? null :
sftpSessionsRef.current.get(sourcePane.connection!.id);
if (sourcePane.connection?.isLocal) {
const stat = await window.nebula?.statLocal?.(task.sourcePath);
if (stat) actualFileSize = stat.size;
} else if (sourceSftpId) {
const stat = await window.nebula?.statSftp?.(sourceSftpId, task.sourcePath);
if (stat) actualFileSize = stat.size;
}
} catch {
// Ignore stat errors, use estimate
}
}
// Estimate file size for progress simulation (use a reasonable default if unknown)
const estimatedSize = actualFileSize > 0 ? actualFileSize :
task.isDirectory ? 1024 * 1024 : // 1MB estimate for directories
256 * 1024; // 256KB default for files
// Check if streaming transfer is available (will provide real progress)
const hasStreamingTransfer = !!window.nebula?.startStreamTransfer;
updateTask({
status: 'transferring',
totalBytes: estimatedSize,
transferredBytes: 0,
startTime: Date.now(),
});
// Only use simulated progress for directories or when streaming is not available
const useSimulatedProgress = task.isDirectory || !hasStreamingTransfer;
if (useSimulatedProgress) {
startProgressSimulation(task.id, estimatedSize);
}
try {
const sourceSftpId = sourcePane.connection?.isLocal ? null :
sftpSessionsRef.current.get(sourcePane.connection!.id);
const targetSftpId = targetPane.connection?.isLocal ? null :
sftpSessionsRef.current.get(targetPane.connection!.id);
// Check if file already exists at target (conflict detection)
// Skip if user already resolved conflict with replace/duplicate
if (!task.isDirectory && !task.skipConflictCheck) {
let targetExists = false;
let existingStat: { size: number; mtime: number } | null = null;
let sourceStat: { size: number; mtime: number } | null = null;
// Get source file stat for accurate size and mtime
try {
if (sourcePane.connection?.isLocal) {
const stat = await window.nebula?.statLocal?.(task.sourcePath);
if (stat) {
sourceStat = { size: stat.size, mtime: stat.lastModified || Date.now() };
}
} else if (sourceSftpId && window.nebula?.statSftp) {
const stat = await window.nebula.statSftp(sourceSftpId, task.sourcePath);
if (stat) {
sourceStat = { size: stat.size, mtime: stat.lastModified || Date.now() };
}
}
} catch {
// Use estimated size if stat fails
}
// Get target file stat to check for conflict
try {
if (targetPane.connection?.isLocal) {
const stat = await window.nebula?.statLocal?.(task.targetPath);
if (stat) {
targetExists = true;
existingStat = { size: stat.size, mtime: stat.lastModified || Date.now() };
}
} else if (targetSftpId && window.nebula?.statSftp) {
const stat = await window.nebula.statSftp(targetSftpId, task.targetPath);
if (stat) {
targetExists = true;
existingStat = { size: stat.size, mtime: stat.lastModified || Date.now() };
}
}
} catch {
// File doesn't exist, no conflict
}
if (targetExists && existingStat) {
// Stop progress simulation while waiting for user decision
stopProgressSimulation(task.id);
// Add conflict for user to resolve
const newConflict: FileConflict = {
transferId: task.id,
fileName: task.fileName,
sourcePath: task.sourcePath,
targetPath: task.targetPath,
existingSize: existingStat.size,
newSize: sourceStat?.size || estimatedSize, // Use actual source size
existingModified: existingStat.mtime,
newModified: sourceStat?.mtime || Date.now(), // Use actual source mtime
};
setConflicts(prev => [...prev, newConflict]);
updateTask({ status: 'pending', totalBytes: sourceStat?.size || estimatedSize }); // Wait for user decision
return;
}
}
if (task.isDirectory) {
// Handle directory transfer recursively
await transferDirectory(task, sourceSftpId, targetSftpId, sourcePane.connection!.isLocal, targetPane.connection!.isLocal);
} else {
// Handle file transfer
await transferFile(task, sourceSftpId, targetSftpId, sourcePane.connection!.isLocal, targetPane.connection!.isLocal);
}
// Stop progress simulation (only if it was started)
if (useSimulatedProgress) {
stopProgressSimulation(task.id);
}
// Get the current state of the task to use accurate totalBytes
setTransfers(prev => prev.map(t => {
if (t.id !== task.id) return t;
return {
...t,
status: 'completed' as TransferStatus,
endTime: Date.now(),
transferredBytes: t.totalBytes, // Use actual totalBytes from state
speed: 0,
};
}));
// Refresh target pane
const targetSide = targetPane === leftPane ? 'left' : 'right';
await refresh(targetSide as 'left' | 'right');
} catch (err) {
// Stop progress simulation on failure (only if it was started)
if (useSimulatedProgress) {
stopProgressSimulation(task.id);
}
updateTask({
status: 'failed',
error: err instanceof Error ? err.message : 'Transfer failed',
endTime: Date.now(),
speed: 0,
});
}
};
// Transfer a single file using streaming with real progress
const transferFile = async (
task: TransferTask,
sourceSftpId: string | null,
targetSftpId: string | null,
sourceIsLocal: boolean,
targetIsLocal: boolean
): Promise<void> => {
// Try to use streaming transfer if available
if (window.nebula?.startStreamTransfer) {
return new Promise((resolve, reject) => {
const options = {
transferId: task.id,
sourcePath: task.sourcePath,
targetPath: task.targetPath,
sourceType: sourceIsLocal ? 'local' as const : 'sftp' as const,
targetType: targetIsLocal ? 'local' as const : 'sftp' as const,
sourceSftpId: sourceSftpId || undefined,
targetSftpId: targetSftpId || undefined,
totalBytes: task.totalBytes || undefined,
};
const onProgress = (transferred: number, total: number, speed: number) => {
setTransfers(prev => prev.map(t => {
if (t.id !== task.id) return t;
// Check if cancelled
if (t.status === 'cancelled') return t;
return {
...t,
transferredBytes: transferred,
totalBytes: total || t.totalBytes,
speed,
};
}));
};
const onComplete = () => {
resolve();
};
const onError = (error: string) => {
reject(new Error(error));
};
window.nebula!.startStreamTransfer!(options, onProgress, onComplete, onError)
.catch(reject);
});
}
// Fallback to legacy transfer (read all then write all)
let content: ArrayBuffer | string;
// Read from source
if (sourceIsLocal) {
content = await window.nebula?.readLocalFile?.(task.sourcePath) || new ArrayBuffer(0);
} else if (sourceSftpId) {
if (window.nebula?.readSftpBinary) {
content = await window.nebula.readSftpBinary(sourceSftpId, task.sourcePath);
} else {
content = await window.nebula?.readSftp(sourceSftpId, task.sourcePath) || '';
}
} else {
throw new Error('No source connection');
}
// Write to target
if (targetIsLocal) {
if (content instanceof ArrayBuffer) {
await window.nebula?.writeLocalFile?.(task.targetPath, content);
} else {
const encoder = new TextEncoder();
await window.nebula?.writeLocalFile?.(task.targetPath, encoder.encode(content).buffer);
}
} else if (targetSftpId) {
if (content instanceof ArrayBuffer && window.nebula?.writeSftpBinary) {
await window.nebula.writeSftpBinary(targetSftpId, task.targetPath, content);
} else {
const text = content instanceof ArrayBuffer
? new TextDecoder().decode(content)
: content;
await window.nebula?.writeSftp(targetSftpId, task.targetPath, text);
}
} else {
throw new Error('No target connection');
}
};
// Transfer a directory
const transferDirectory = async (
task: TransferTask,
sourceSftpId: string | null,
targetSftpId: string | null,
sourceIsLocal: boolean,
targetIsLocal: boolean
) => {
// Create target directory
if (targetIsLocal) {
await window.nebula?.mkdirLocal?.(task.targetPath);
} else if (targetSftpId) {
await window.nebula?.mkdirSftp(targetSftpId, task.targetPath);
}
// List source directory
let files: SftpFileEntry[];
if (sourceIsLocal) {
files = await listLocalFiles(task.sourcePath);
} else if (sourceSftpId) {
files = await listRemoteFiles(sourceSftpId, task.sourcePath);
} else {
throw new Error('No source connection');
}
// Transfer each item
for (const file of files) {
if (file.name === '..') continue;
const childTask: TransferTask = {
...task,
id: crypto.randomUUID(),
fileName: file.name,
sourcePath: joinPath(task.sourcePath, file.name),
targetPath: joinPath(task.targetPath, file.name),
isDirectory: file.type === 'directory',
parentTaskId: task.id,
};
if (file.type === 'directory') {
await transferDirectory(childTask, sourceSftpId, targetSftpId, sourceIsLocal, targetIsLocal);
} else {
await transferFile(childTask, sourceSftpId, targetSftpId, sourceIsLocal, targetIsLocal);
}
}
};
// Cancel transfer
// This will stop the streaming transfer at the backend level if supported
const cancelTransfer = useCallback(async (transferId: string) => {
// Stop progress simulation (for directory transfers or fallback mode)
stopProgressSimulation(transferId);
// Mark as cancelled
setTransfers(prev => prev.map(t =>
t.id === transferId ? { ...t, status: 'cancelled' as TransferStatus, endTime: Date.now() } : t
));
// Remove from conflicts if present
setConflicts(prev => prev.filter(c => c.transferId !== transferId));
// Cancel at backend level if streaming transfer is in progress
if (window.nebula?.cancelTransfer) {
try {
await window.nebula.cancelTransfer(transferId);
} catch (err) {
console.warn('Failed to cancel transfer at backend:', err);
}
}
}, [stopProgressSimulation]);
// Retry failed transfer
const retryTransfer = useCallback(async (transferId: string) => {
const task = transfers.find(t => t.id === transferId);
if (!task) return;
const sourcePane = task.sourceConnectionId.startsWith('left') ? leftPane : rightPane;
const targetPane = task.targetConnectionId.startsWith('left') ? leftPane : rightPane;
if (sourcePane.connection && targetPane.connection) {
setTransfers(prev => prev.map(t =>
t.id === transferId ? { ...t, status: 'pending' as TransferStatus, error: undefined } : t
));
await processTransfer(task, sourcePane, targetPane);
}
}, [transfers, leftPane, rightPane]);
// Clear completed transfers
const clearCompletedTransfers = useCallback(() => {
setTransfers(prev => prev.filter(t => t.status !== 'completed' && t.status !== 'cancelled'));
}, []);
// Dismiss transfer
const dismissTransfer = useCallback((transferId: string) => {
setTransfers(prev => prev.filter(t => t.id !== transferId));
}, []);
// Handle file conflict
const resolveConflict = useCallback(async (conflictId: string, action: 'replace' | 'skip' | 'duplicate') => {
const conflict = conflicts.find(c => c.transferId === conflictId);
if (!conflict) return;
// Remove from conflicts list
setConflicts(prev => prev.filter(c => c.transferId !== conflictId));
// Find the task
const task = transfers.find(t => t.id === conflictId);
if (!task) return;
if (action === 'skip') {
// Mark as cancelled
setTransfers(prev => prev.map(t =>
t.id === conflictId ? { ...t, status: 'cancelled' as TransferStatus } : t
));
return;
}
// For replace or duplicate, we need to update the task and re-process
let updatedTask = { ...task };
if (action === 'duplicate') {
// Generate new name and update task
const ext = task.fileName.includes('.') ? '.' + task.fileName.split('.').pop() : '';
const baseName = task.fileName.includes('.')
? task.fileName.slice(0, task.fileName.lastIndexOf('.'))
: task.fileName;
const newName = `${baseName} (copy)${ext}`;
const newTargetPath = task.targetPath.replace(task.fileName, newName);
updatedTask = {
...task,
fileName: newName,
targetPath: newTargetPath,
skipConflictCheck: true, // Skip check for new name
};
} else if (action === 'replace') {
// For replace, we just need to skip the conflict check
updatedTask = {
...task,
skipConflictCheck: true, // User explicitly chose to replace
};
}
// Update task status and re-process
setTransfers(prev => prev.map(t =>
t.id === conflictId ? { ...updatedTask, status: 'pending' as TransferStatus } : t
));
// Find source and target panes and re-process transfer
const sourcePane = updatedTask.sourceConnectionId.startsWith('left') ? leftPane : rightPane;
const targetPane = updatedTask.targetConnectionId.startsWith('left') ? leftPane : rightPane;
if (sourcePane.connection && targetPane.connection) {
// Small delay to ensure state is updated
setTimeout(async () => {
await processTransfer(updatedTask, sourcePane, targetPane);
}, 100);
}
}, [conflicts, transfers, leftPane, rightPane]);
// Get filtered files
const getFilteredFiles = (pane: SftpPane): SftpFileEntry[] => {
const term = pane.filter.trim().toLowerCase();
if (!term) return pane.files;
return pane.files.filter(f => f.name === '..' || f.name.toLowerCase().includes(term));
};
// Get active transfers count
const activeTransfersCount = transfers.filter(t =>
t.status === 'pending' || t.status === 'transferring'
).length;
// Change file permissions (SFTP only)
const changePermissions = useCallback(async (
side: 'left' | 'right',
filePath: string,
mode: string // octal string like "755"
) => {
const pane = side === 'left' ? leftPane : rightPane;
if (!pane.connection || pane.connection.isLocal) {
console.warn('Cannot change permissions on local files');
return;
}
const sftpId = sftpSessionsRef.current.get(pane.connection.id);
if (!sftpId || !window.nebula?.chmodSftp) {
handleSessionError(side, new Error('SFTP session not found'));
return;
}
try {
await window.nebula.chmodSftp(sftpId, filePath, mode);
await refresh(side);
} catch (err) {
if (isSessionError(err)) {
handleSessionError(side, err as Error);
return;
}
console.error('Failed to change permissions:', err);
}
}, [leftPane, rightPane, refresh, handleSessionError]);
return {
// Panes
leftPane,
rightPane,
getFilteredFiles,
// Connection
connect,
disconnect,
// Navigation
navigateTo,
navigateUp,
refresh,
openEntry,
// Selection
toggleSelection,
rangeSelect,
clearSelection,
selectAll,
setFilter,
// File operations
createDirectory,
deleteFiles,
renameFile,
changePermissions,
// Transfers
transfers,
activeTransfersCount,
startTransfer,
cancelTransfer,
retryTransfer,
clearCompletedTransfers,
dismissTransfer,
// Conflicts
conflicts,
resolveConflict,
// Helpers
formatFileSize,
formatDate,
getFileExtension,
joinPath,
getParentPath,
getFileName,
};
};