mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 23:20:46 +00:00
* fix: resolve SFTP tab connection key race condition in workspace mode When rapidly switching focus between workspace panes, the single pendingConnectionKeyRef could be overwritten before the tracking effect mapped it to the created tab. This left tabs unmapped in tabConnectionKeyMapRef, causing duplicate tabs on subsequent switches. Replace the two-step async mechanism (pendingConnectionKeyRef + deferred tracking effect) with a synchronous onTabCreated callback on connect(). The callback fires immediately after the tab ID is determined, before any async SSH work begins, eliminating the race window entirely. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: scope SFTP transfers to active connection and prevent stale session lookups Two fixes for workspace focus-switching issues: 1. Transfer queue now filters by the active connection's host, so switching focus between workspace panes only shows transfers relevant to the currently displayed SFTP tab. 2. Move sftpSessionsRef.delete() before the async closeSftp() call to close the race window where concurrent code could look up a stale sftpId that the backend has already removed, causing "SFTP session not found" errors. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: allow SFTP focus switching during file transfers Active transfers should not block workspace focus-following. Transfers run on their own sftpId independent of the active tab, and forceNewTab preserves old connections, so switching focus is safe. Only interactive operations (text editor, permissions dialog, file opener, file watches) still block host switching. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: refresh correct SFTP tab after transfer completes during focus switch When a transfer completes while focus has switched to a different host, refresh was targeting the currently active pane instead of the pane that initiated the transfer. Add optional tabId parameter to navigateTo() and refresh() so callers can target a specific tab. Capture the tab ID at transfer start and use it for the post-transfer refresh, ensuring the correct tab's file list is updated regardless of which tab is currently focused. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: auto-reconnect SFTP when session is lost during navigation When navigateTo() detected a missing or expired SFTP session, it cleared the connection to null, showing the empty "Select a host" state. Now it delegates to handleSessionError(), which triggers the existing reconnection mechanism — keeping files visible while reconnecting in the background. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * perf: eliminate redundant stat calls before file transfers Before this change, each file transfer performed 3-4 stat calls over the network before the progress bar started moving: 1. startTransfer: stat to get file size (~100ms) 2. processTransfer: stat again if size was 0 (~100ms) 3. Conflict check: stat source file for mtime (~100ms) 4. Backend: stat again if totalBytes missing (~100ms) Now: - Use the source pane's cached file list for size and mtime (zero network cost) instead of stat calls in startTransfer - Store sourceLastModified on TransferTask so the conflict check can use it directly instead of a redundant source stat - Backend already skips stat when totalBytes is provided This saves ~200-300ms of network round-trips per file before the progress bar starts moving. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * perf: show immediate progress feedback during transfer setup The progress bar previously stayed at 0% for ~500ms-1s while the backend acquired an isolated SFTP channel and waited for the first data chunk. Users perceived this as the transfer being "sluggish". Now start simulated progress immediately for all single-file transfers (not just non-streaming ones). When the first real progress update arrives from the backend, the simulation is stopped and real progress takes over seamlessly. This gives instant visual feedback that the transfer is in progress. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: show accurate transfer progress instead of simulated values The progress system had fundamental issues: 1. Simulated progress ran for ALL transfers including streaming ones, creating fake progress that could reach 95% while real progress was at 60%. The Math.max ratchet prevented regression, so users saw inflated numbers. 2. Speed and remaining time were based on simulated data during the setup phase, giving misleading estimates. Changes: - Only use simulated progress for non-streaming transfers (no real progress callback available). Streaming transfers get real data. - Remove the double ratchet (Math.max) from onProgress — the backend already enforces monotonic progress, so the frontend should trust the reported values directly. - Show an indeterminate "preparing..." state during the setup phase (channel acquisition, conflict check) instead of fake progress. This honestly communicates that the transfer is starting. - Hide speed and remaining time during the indeterminate phase since no real data is available yet. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * refactor: remove dead progress simulation and non-streaming transfer code startStreamTransfer is always available in Electron, so: - Remove the non-streaming fallback path in transferFile() that read entire files into memory with no progress reporting - Remove startProgressSimulation / stopProgressSimulation and all related refs (progressIntervalsRef, useSimulatedProgress, hasStreamingTransfer) - Remove the cleanup effect for progress intervals All transfers now use the streaming path with real backend-reported progress. The indeterminate "preparing..." state covers the setup phase until the first real progress arrives. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * perf: reduce SFTP transfer concurrency from 64 to 4 64 parallel SFTP read/write requests overwhelmed servers, causing the first chunk response to be delayed by 46+ seconds. Reducing to 4 concurrent requests provides a responsive first progress update (~1-2s) while still offering significant speedup over sequential streaming. Also adds timing logs to the transfer pipeline (processTransfer, transferFile, downloadFile, uploadFile) to aid future diagnostics. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: address review findings from PR #443 Critical fixes: - Fix refresh/navigateTo type signatures to include the tabId option parameter — previously it was silently ignored, making tab-targeted refresh non-functional - Fix handleSessionError/reconnection in navigateTo for background tabs: when called with explicit tabId, update that specific tab instead of the active tab (which could be a different host) - Fix uploadExternalFiles to capture and pass tabId for post-upload refresh (was missing, only uploadExternalEntries was fixed) Medium fixes: - Restore Math.max monotonic ratchet on single-file onProgress to guard against any non-monotonic backend values - Add stat fallback in processTransfer to populate sourceLastModified when file is not in the pane's visible file list (filtered/search) - Adjust TRANSFER_CONCURRENCY from 4 to 8 as a better throughput/ responsiveness balance Cleanup: - Remove all debug timing logs (console.log with Transfer/downloadFile/ uploadFile prefixes) from both frontend and backend Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix: prevent background tab navigation from rolling back active tab Two P1 fixes from automated review: 1. navSeqRef race: navigateTo uses a per-side sequence counter, so a background tab refresh would bump it and cause the active tab's concurrent navigation to think it was superseded, restoring previousPath instead of applying the fetched files. Now when navSeqRef is superseded but tabNavSeqRef still matches, the fetched result is applied (it's valid for this tab — only a different tab bumped the counter). 2. Auto-follow tear down: needsNewTab only checked hostId, so same host with different session-time overrides (port/protocol) would reuse the tab and close the old SFTP session, aborting any in-flight transfer. Now needsNewTab is true whenever the current connection is alive, always preserving it with forceNewTab. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
766 lines
25 KiB
JavaScript
766 lines
25 KiB
JavaScript
/**
|
|
* Transfer Bridge - Handles file transfers with progress and cancellation
|
|
* Extracted from main.cjs for single responsibility
|
|
*/
|
|
|
|
const fs = require("node:fs");
|
|
const path = require("node:path");
|
|
const os = require("node:os");
|
|
const { encodePathForSession, ensureRemoteDirForSession, requireSftpChannel } = require("./sftpBridge.cjs");
|
|
|
|
/**
|
|
* Safely ensure a local directory exists.
|
|
* On Windows, `mkdir("E:\\", { recursive: true })` throws EPERM for drive roots.
|
|
* We catch that and verify the directory already exists before re-throwing.
|
|
*/
|
|
async function ensureLocalDir(dir) {
|
|
try {
|
|
await fs.promises.mkdir(dir, { recursive: true });
|
|
} catch (err) {
|
|
// If the directory already exists, ignore the error (covers EPERM on drive roots)
|
|
try {
|
|
const stat = await fs.promises.stat(dir);
|
|
if (stat.isDirectory()) return;
|
|
} catch { /* stat failed, re-throw original */ }
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
// ── Transfer performance tuning ──────────────────────────────────────────────
|
|
// ssh2's fastPut/fastGet send multiple SFTP read/write requests in parallel,
|
|
// dramatically improving throughput over sequential stream piping.
|
|
// Note: High concurrency (e.g. 64) can overwhelm SFTP servers, causing
|
|
// extreme delays before the first chunk arrives. 8 balances throughput
|
|
// on fast connections with responsiveness on slower servers.
|
|
const TRANSFER_CHUNK_SIZE = 512 * 1024; // 512KB per SFTP request
|
|
const TRANSFER_CONCURRENCY = 8; // 8 parallel SFTP requests
|
|
// Progress IPC throttle: sending too many IPC messages bogs down the event loop
|
|
const PROGRESS_THROTTLE_MS = 100; // Send IPC at most every 100ms
|
|
const PROGRESS_THROTTLE_BYTES = 256 * 1024; // Or every 256KB of progress
|
|
const ISOLATED_DOWNLOAD_IDLE_TTL_MS = 5000;
|
|
|
|
// Speed calculation uses strict sliding-window average:
|
|
// speed = bytes_delta_in_window / time_delta_in_window
|
|
const SPEED_WINDOW_MS = 3000; // Keep 3s of samples
|
|
const SPEED_MIN_ELAPSED_MS = 50; // Minimum elapsed time to avoid divide-by-near-zero spikes
|
|
|
|
// Shared references
|
|
let sftpClients = null;
|
|
|
|
// Active transfers storage
|
|
const activeTransfers = new Map();
|
|
const isolatedDownloadChannelPools = new WeakMap();
|
|
|
|
/**
|
|
* Initialize the transfer bridge with dependencies
|
|
*/
|
|
function init(deps) {
|
|
sftpClients = deps.sftpClients;
|
|
}
|
|
|
|
async function openIsolatedSftpChannel(client) {
|
|
const sshClient = client?.client;
|
|
if (!sshClient || typeof sshClient.sftp !== "function") return null;
|
|
|
|
return new Promise((resolve, reject) => {
|
|
sshClient.sftp((err, sftp) => {
|
|
if (err) reject(err);
|
|
else resolve(sftp);
|
|
});
|
|
});
|
|
}
|
|
|
|
function getIsolatedDownloadChannelPool(client) {
|
|
let pool = isolatedDownloadChannelPools.get(client);
|
|
if (!pool) {
|
|
pool = {
|
|
idle: [],
|
|
idleTimers: new Map(),
|
|
busy: new Set(),
|
|
waiters: [],
|
|
opening: 0,
|
|
maxChannels: null,
|
|
warnedCapacity: false,
|
|
};
|
|
isolatedDownloadChannelPools.set(client, pool);
|
|
}
|
|
return pool;
|
|
}
|
|
|
|
function isIsolatedChannelOpenFailure(err) {
|
|
const message = err?.message || String(err || "");
|
|
return (
|
|
message.includes("Channel open failure") ||
|
|
message.includes("open failed")
|
|
);
|
|
}
|
|
|
|
function waitForIsolatedDownloadChannel(pool, transfer) {
|
|
return new Promise((resolve) => {
|
|
let settled = false;
|
|
const waiter = () => {
|
|
if (settled) return;
|
|
settled = true;
|
|
const index = pool.waiters.indexOf(waiter);
|
|
if (index !== -1) {
|
|
pool.waiters.splice(index, 1);
|
|
}
|
|
if (transfer?.wakeWaiter === waiter) {
|
|
transfer.wakeWaiter = null;
|
|
}
|
|
resolve();
|
|
};
|
|
if (transfer) {
|
|
transfer.wakeWaiter = waiter;
|
|
}
|
|
pool.waiters.push(waiter);
|
|
});
|
|
}
|
|
|
|
function notifyIsolatedDownloadWaiter(pool) {
|
|
const waiter = pool.waiters.shift();
|
|
if (waiter) waiter();
|
|
}
|
|
|
|
function removeIdleIsolatedDownloadChannel(pool, sftp) {
|
|
const index = pool.idle.indexOf(sftp);
|
|
if (index !== -1) {
|
|
pool.idle.splice(index, 1);
|
|
}
|
|
}
|
|
|
|
function clearIdleIsolatedDownloadTimer(pool, sftp) {
|
|
const timer = pool.idleTimers.get(sftp);
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
pool.idleTimers.delete(sftp);
|
|
}
|
|
}
|
|
|
|
function scheduleIdleIsolatedDownloadChannel(client, sftp) {
|
|
const pool = isolatedDownloadChannelPools.get(client);
|
|
if (!pool) return;
|
|
|
|
clearIdleIsolatedDownloadTimer(pool, sftp);
|
|
const timer = setTimeout(() => {
|
|
clearIdleIsolatedDownloadTimer(pool, sftp);
|
|
removeIdleIsolatedDownloadChannel(pool, sftp);
|
|
try { sftp?.end?.(); } catch { }
|
|
}, ISOLATED_DOWNLOAD_IDLE_TTL_MS);
|
|
pool.idleTimers.set(sftp, timer);
|
|
}
|
|
|
|
function releaseIsolatedDownloadChannel(client, sftp, options = {}) {
|
|
const { dispose = false } = options;
|
|
const pool = isolatedDownloadChannelPools.get(client);
|
|
if (!pool) {
|
|
if (dispose) {
|
|
try { sftp?.end?.(); } catch { }
|
|
}
|
|
return;
|
|
}
|
|
|
|
pool.busy.delete(sftp);
|
|
clearIdleIsolatedDownloadTimer(pool, sftp);
|
|
|
|
if (dispose) {
|
|
try { sftp?.end?.(); } catch { }
|
|
notifyIsolatedDownloadWaiter(pool);
|
|
return;
|
|
}
|
|
|
|
pool.idle.push(sftp);
|
|
scheduleIdleIsolatedDownloadChannel(client, sftp);
|
|
notifyIsolatedDownloadWaiter(pool);
|
|
}
|
|
|
|
async function acquireIsolatedDownloadChannel(client, transfer) {
|
|
const pool = getIsolatedDownloadChannelPool(client);
|
|
|
|
while (true) {
|
|
if (transfer?.cancelled) return null;
|
|
|
|
const cached = pool.idle.pop();
|
|
if (cached) {
|
|
clearIdleIsolatedDownloadTimer(pool, cached);
|
|
pool.busy.add(cached);
|
|
return cached;
|
|
}
|
|
|
|
const knownCapacity = pool.maxChannels;
|
|
const currentChannelCount = pool.idle.length + pool.busy.size + pool.opening;
|
|
if (knownCapacity !== null && currentChannelCount >= knownCapacity) {
|
|
if (pool.opening > 0) {
|
|
await waitForIsolatedDownloadChannel(pool, transfer);
|
|
if (transfer?.cancelled) return null;
|
|
continue;
|
|
}
|
|
if (pool.busy.size === 0) {
|
|
return null;
|
|
}
|
|
await waitForIsolatedDownloadChannel(pool, transfer);
|
|
if (transfer?.cancelled) return null;
|
|
continue;
|
|
}
|
|
|
|
pool.opening += 1;
|
|
try {
|
|
const opened = await openIsolatedSftpChannel(client);
|
|
pool.opening -= 1;
|
|
notifyIsolatedDownloadWaiter(pool);
|
|
if (!opened) return null;
|
|
pool.busy.add(opened);
|
|
const knownCapacity = pool.idle.length + pool.busy.size;
|
|
if (pool.maxChannels !== null) {
|
|
pool.maxChannels = Math.max(pool.maxChannels, knownCapacity);
|
|
}
|
|
return opened;
|
|
} catch (err) {
|
|
pool.opening -= 1;
|
|
notifyIsolatedDownloadWaiter(pool);
|
|
if (isIsolatedChannelOpenFailure(err)) {
|
|
if (pool.opening > 0) {
|
|
await waitForIsolatedDownloadChannel(pool, transfer);
|
|
if (transfer?.cancelled) return null;
|
|
continue;
|
|
}
|
|
const detectedCapacity = pool.idle.length + pool.busy.size;
|
|
pool.maxChannels = detectedCapacity;
|
|
if (!pool.warnedCapacity) {
|
|
pool.warnedCapacity = true;
|
|
console.warn(
|
|
`[transferBridge] Isolated fastGet channel capacity reached; reusing up to ${detectedCapacity} extra channel(s) for this SFTP session.`,
|
|
);
|
|
}
|
|
if (detectedCapacity > 0) {
|
|
await waitForIsolatedDownloadChannel(pool, transfer);
|
|
if (transfer?.cancelled) return null;
|
|
continue;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
console.warn(
|
|
"[transferBridge] Failed to open isolated SFTP channel for fastGet, falling back to streams:",
|
|
err.message || String(err),
|
|
);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Upload a local file to SFTP using ssh2's fastPut (parallel SFTP requests).
|
|
* Falls back to sequential stream piping if fastPut is unavailable.
|
|
*/
|
|
async function uploadFile(localPath, remotePath, client, fileSize, transfer, sendProgress) {
|
|
await requireSftpChannel(client);
|
|
const sftp = client.sftp;
|
|
if (!sftp) throw new Error("SFTP client not ready");
|
|
|
|
// Prefer fastPut on an isolated SFTP channel so cancellation can abort just this transfer.
|
|
if (!client.__netcattySudoMode) {
|
|
let fastSftp = null;
|
|
try {
|
|
fastSftp = await openIsolatedSftpChannel(client);
|
|
} catch (err) {
|
|
console.warn("[transferBridge] Failed to open isolated SFTP channel for fastPut, falling back to streams:", err.message || String(err));
|
|
}
|
|
|
|
if (fastSftp && typeof fastSftp.fastPut === "function") {
|
|
return new Promise((resolve, reject) => {
|
|
let settled = false;
|
|
let onFastSftpError = null;
|
|
const finish = (err) => {
|
|
if (settled) return;
|
|
settled = true;
|
|
if (transfer.abort === abortFastTransfer) {
|
|
transfer.abort = null;
|
|
}
|
|
if (onFastSftpError) {
|
|
try { fastSftp.removeListener("error", onFastSftpError); } catch { }
|
|
onFastSftpError = null;
|
|
}
|
|
try { fastSftp.end(); } catch { }
|
|
|
|
if (transfer.cancelled) reject(new Error("Transfer cancelled"));
|
|
else if (err) reject(err);
|
|
else resolve();
|
|
};
|
|
const abortFastTransfer = () => {
|
|
if (settled) return;
|
|
transfer.cancelled = true;
|
|
try { fastSftp.end(); } catch { }
|
|
finish(new Error("Transfer cancelled"));
|
|
};
|
|
transfer.abort = abortFastTransfer;
|
|
onFastSftpError = (err) => finish(err);
|
|
fastSftp.once("error", onFastSftpError);
|
|
|
|
if (transfer.cancelled) {
|
|
finish(new Error("Transfer cancelled"));
|
|
return;
|
|
}
|
|
|
|
fastSftp.fastPut(localPath, remotePath, {
|
|
chunkSize: TRANSFER_CHUNK_SIZE,
|
|
concurrency: TRANSFER_CONCURRENCY,
|
|
step: (transferred, _chunk, total) => {
|
|
if (transfer.cancelled) return;
|
|
sendProgress(transferred, total || fileSize);
|
|
},
|
|
}, finish);
|
|
});
|
|
}
|
|
|
|
if (fastSftp && typeof fastSftp.end === "function") {
|
|
try { fastSftp.end(); } catch { }
|
|
}
|
|
}
|
|
|
|
// Fallback: sequential stream piping
|
|
return new Promise((resolve, reject) => {
|
|
const readStream = fs.createReadStream(localPath, { highWaterMark: TRANSFER_CHUNK_SIZE });
|
|
const writeStream = sftp.createWriteStream(remotePath, { highWaterMark: TRANSFER_CHUNK_SIZE });
|
|
let transferred = 0;
|
|
let finished = false;
|
|
|
|
transfer.readStream = readStream;
|
|
transfer.writeStream = writeStream;
|
|
|
|
const cleanup = (err) => {
|
|
if (finished) return;
|
|
finished = true;
|
|
readStream.removeAllListeners();
|
|
writeStream.removeAllListeners();
|
|
if (err) {
|
|
try { readStream.destroy(); } catch { }
|
|
try { writeStream.destroy(); } catch { }
|
|
reject(err);
|
|
} else {
|
|
resolve();
|
|
}
|
|
};
|
|
|
|
readStream.on('data', (chunk) => {
|
|
if (transfer.cancelled) { cleanup(new Error('Transfer cancelled')); return; }
|
|
transferred += chunk.length;
|
|
sendProgress(transferred, fileSize);
|
|
});
|
|
readStream.on('error', cleanup);
|
|
writeStream.on('error', cleanup);
|
|
writeStream.on('close', () => {
|
|
if (transfer.cancelled) cleanup(new Error('Transfer cancelled'));
|
|
else cleanup(null);
|
|
});
|
|
readStream.pipe(writeStream);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Download from SFTP to local file using ssh2's fastGet (parallel SFTP requests).
|
|
* Falls back to sequential stream piping if fastGet is unavailable.
|
|
*/
|
|
async function downloadFile(remotePath, localPath, client, fileSize, transfer, sendProgress) {
|
|
await requireSftpChannel(client);
|
|
const sftp = client.sftp;
|
|
if (!sftp) throw new Error("SFTP client not ready");
|
|
|
|
// Prefer fastGet on an isolated SFTP channel so cancellation can abort just this transfer.
|
|
if (!client.__netcattySudoMode) {
|
|
const fastSftp = await acquireIsolatedDownloadChannel(client, transfer);
|
|
|
|
if (fastSftp && typeof fastSftp.fastGet === "function") {
|
|
return new Promise((resolve, reject) => {
|
|
let settled = false;
|
|
let onFastSftpError = null;
|
|
const finish = (err) => {
|
|
if (settled) return;
|
|
settled = true;
|
|
if (transfer.abort === abortFastTransfer) {
|
|
transfer.abort = null;
|
|
}
|
|
if (onFastSftpError) {
|
|
try { fastSftp.removeListener("error", onFastSftpError); } catch { }
|
|
onFastSftpError = null;
|
|
}
|
|
releaseIsolatedDownloadChannel(client, fastSftp, {
|
|
dispose: !!err || transfer.cancelled,
|
|
});
|
|
|
|
if (transfer.cancelled) reject(new Error("Transfer cancelled"));
|
|
else if (err) reject(err);
|
|
else resolve();
|
|
};
|
|
const abortFastTransfer = () => {
|
|
if (settled) return;
|
|
transfer.cancelled = true;
|
|
finish(new Error("Transfer cancelled"));
|
|
};
|
|
transfer.abort = abortFastTransfer;
|
|
onFastSftpError = (err) => finish(err);
|
|
fastSftp.once("error", onFastSftpError);
|
|
|
|
if (transfer.cancelled) {
|
|
finish(new Error("Transfer cancelled"));
|
|
return;
|
|
}
|
|
|
|
fastSftp.fastGet(remotePath, localPath, {
|
|
chunkSize: TRANSFER_CHUNK_SIZE,
|
|
concurrency: TRANSFER_CONCURRENCY,
|
|
step: (transferred, _chunk, total) => {
|
|
if (transfer.cancelled) return;
|
|
sendProgress(transferred, total || fileSize);
|
|
},
|
|
}, finish);
|
|
});
|
|
}
|
|
}
|
|
|
|
// Fallback: sequential stream piping
|
|
return new Promise((resolve, reject) => {
|
|
const readStream = sftp.createReadStream(remotePath, { highWaterMark: TRANSFER_CHUNK_SIZE });
|
|
const writeStream = fs.createWriteStream(localPath, { highWaterMark: TRANSFER_CHUNK_SIZE });
|
|
let transferred = 0;
|
|
let finished = false;
|
|
|
|
transfer.readStream = readStream;
|
|
transfer.writeStream = writeStream;
|
|
|
|
const cleanup = (err) => {
|
|
if (finished) return;
|
|
finished = true;
|
|
readStream.removeAllListeners();
|
|
writeStream.removeAllListeners();
|
|
if (err) {
|
|
try { readStream.destroy(); } catch { }
|
|
try { writeStream.destroy(); } catch { }
|
|
reject(err);
|
|
} else {
|
|
resolve();
|
|
}
|
|
};
|
|
|
|
readStream.on('data', (chunk) => {
|
|
if (transfer.cancelled) { cleanup(new Error('Transfer cancelled')); return; }
|
|
transferred += chunk.length;
|
|
sendProgress(transferred, fileSize);
|
|
});
|
|
readStream.on('error', cleanup);
|
|
writeStream.on('error', cleanup);
|
|
writeStream.on('finish', () => {
|
|
if (transfer.cancelled) cleanup(new Error('Transfer cancelled'));
|
|
else cleanup(null);
|
|
});
|
|
writeStream.on('close', () => {
|
|
if (transfer.cancelled) cleanup(new Error('Transfer cancelled'));
|
|
});
|
|
readStream.pipe(writeStream);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Start a file transfer
|
|
*/
|
|
async function startTransfer(event, payload, onProgress) {
|
|
const {
|
|
transferId,
|
|
sourcePath,
|
|
targetPath,
|
|
sourceType,
|
|
targetType,
|
|
sourceSftpId,
|
|
targetSftpId,
|
|
totalBytes,
|
|
sourceEncoding,
|
|
targetEncoding,
|
|
} = payload;
|
|
const sender = event.sender;
|
|
|
|
const transfer = { cancelled: false, readStream: null, writeStream: null, abort: null, wakeWaiter: null };
|
|
activeTransfers.set(transferId, transfer);
|
|
const transferCreatedAt = Date.now();
|
|
|
|
// ── Progress/speed tracking ──────────────────────────────────────────────
|
|
// Keep progress monotonic and compute speed from a strict sliding window.
|
|
const speedSamples = [{ time: transferCreatedAt, bytes: 0 }]; // [{ time, bytes }]
|
|
let lastObservedTransferred = 0;
|
|
let lastObservedTotal = Math.max(0, totalBytes || 0);
|
|
let lastProgressSentTime = 0;
|
|
let lastProgressSentBytes = -1;
|
|
|
|
const computeWindowSpeed = (now, transferred) => {
|
|
const targetTime = now - SPEED_WINDOW_MS;
|
|
|
|
// Keep exactly one sample before targetTime for boundary interpolation.
|
|
while (speedSamples.length >= 2 && speedSamples[1].time <= targetTime) {
|
|
speedSamples.shift();
|
|
}
|
|
|
|
const first = speedSamples[0];
|
|
if (!first) return 0;
|
|
|
|
let boundaryTime = first.time;
|
|
let boundaryBytes = first.bytes;
|
|
|
|
if (speedSamples.length >= 2 && targetTime > first.time) {
|
|
const next = speedSamples[1];
|
|
const range = next.time - first.time;
|
|
if (range > 0) {
|
|
const ratio = (targetTime - first.time) / range;
|
|
boundaryBytes = first.bytes + (next.bytes - first.bytes) * ratio;
|
|
boundaryTime = targetTime;
|
|
}
|
|
}
|
|
|
|
const elapsedMs = now - boundaryTime;
|
|
if (elapsedMs < SPEED_MIN_ELAPSED_MS) return 0;
|
|
|
|
const deltaBytes = transferred - boundaryBytes;
|
|
if (deltaBytes <= 0) return 0;
|
|
|
|
const speed = (deltaBytes * 1000) / elapsedMs;
|
|
return Number.isFinite(speed) && speed > 0 ? Math.round(speed) : 0;
|
|
};
|
|
|
|
const emitProgress = (now, transferred, total, speed, force = false) => {
|
|
const isComplete = total > 0 && transferred >= total;
|
|
const transferredChanged = transferred !== lastProgressSentBytes;
|
|
const timeSinceLast = now - lastProgressSentTime;
|
|
const bytesSinceLast = transferred - lastProgressSentBytes;
|
|
|
|
if (
|
|
force ||
|
|
isComplete ||
|
|
(transferredChanged &&
|
|
(timeSinceLast >= PROGRESS_THROTTLE_MS || bytesSinceLast >= PROGRESS_THROTTLE_BYTES))
|
|
) {
|
|
lastProgressSentTime = now;
|
|
lastProgressSentBytes = transferred;
|
|
sender.send("netcatty:transfer:progress", { transferId, transferred, speed, totalBytes: total });
|
|
}
|
|
};
|
|
|
|
const cleanupTransfer = () => {
|
|
activeTransfers.delete(transferId);
|
|
};
|
|
|
|
const sendProgress = (transferred, total) => {
|
|
if (transfer.cancelled) return;
|
|
|
|
const now = Date.now();
|
|
|
|
let normalizedTotal = Number.isFinite(total) && total > 0 ? total : 0;
|
|
if (normalizedTotal === 0) {
|
|
normalizedTotal = lastObservedTotal || 0;
|
|
}
|
|
normalizedTotal = Math.max(normalizedTotal, lastObservedTotal, 0);
|
|
|
|
let normalizedTransferred = Number.isFinite(transferred) && transferred > 0 ? transferred : 0;
|
|
if (normalizedTotal > 0) {
|
|
normalizedTransferred = Math.min(normalizedTransferred, normalizedTotal);
|
|
}
|
|
normalizedTransferred = Math.max(normalizedTransferred, lastObservedTransferred);
|
|
|
|
lastObservedTransferred = normalizedTransferred;
|
|
lastObservedTotal = normalizedTotal;
|
|
|
|
const lastSample = speedSamples[speedSamples.length - 1];
|
|
if (!lastSample || lastSample.bytes !== normalizedTransferred || now - lastSample.time >= PROGRESS_THROTTLE_MS) {
|
|
speedSamples.push({ time: now, bytes: normalizedTransferred });
|
|
}
|
|
|
|
const speed = computeWindowSpeed(now, normalizedTransferred);
|
|
|
|
if (onProgress) {
|
|
onProgress(normalizedTransferred, normalizedTotal, speed);
|
|
}
|
|
|
|
emitProgress(now, normalizedTransferred, normalizedTotal, speed);
|
|
};
|
|
|
|
const sendComplete = () => {
|
|
sender.send("netcatty:transfer:complete", { transferId });
|
|
cleanupTransfer();
|
|
};
|
|
|
|
const sendError = (error) => {
|
|
cleanupTransfer();
|
|
sender.send("netcatty:transfer:error", { transferId, error: error.message || String(error) });
|
|
};
|
|
|
|
try {
|
|
let fileSize = totalBytes || 0;
|
|
|
|
if (!fileSize) {
|
|
if (sourceType === 'local') {
|
|
const stat = await fs.promises.stat(sourcePath);
|
|
fileSize = stat.size;
|
|
} else if (sourceType === 'sftp') {
|
|
const client = sftpClients.get(sourceSftpId);
|
|
if (!client) throw new Error("Source SFTP session not found");
|
|
await requireSftpChannel(client);
|
|
const encodedSourcePath = encodePathForSession(sourceSftpId, sourcePath, sourceEncoding);
|
|
const stat = await client.stat(encodedSourcePath);
|
|
fileSize = stat.size;
|
|
}
|
|
}
|
|
|
|
sendProgress(0, fileSize);
|
|
|
|
if (sourceType === 'local' && targetType === 'sftp') {
|
|
const client = sftpClients.get(targetSftpId);
|
|
if (!client) throw new Error("Target SFTP session not found");
|
|
|
|
const dir = path.dirname(targetPath).replace(/\\/g, '/');
|
|
try { await ensureRemoteDirForSession(targetSftpId, dir, targetEncoding); } catch { }
|
|
|
|
const encodedTargetPath = encodePathForSession(targetSftpId, targetPath, targetEncoding);
|
|
await uploadFile(sourcePath, encodedTargetPath, client, fileSize, transfer, sendProgress);
|
|
|
|
} else if (sourceType === 'sftp' && targetType === 'local') {
|
|
const client = sftpClients.get(sourceSftpId);
|
|
if (!client) throw new Error("Source SFTP session not found");
|
|
|
|
const dir = path.dirname(targetPath);
|
|
await ensureLocalDir(dir);
|
|
|
|
const encodedSourcePath = encodePathForSession(sourceSftpId, sourcePath, sourceEncoding);
|
|
await downloadFile(encodedSourcePath, targetPath, client, fileSize, transfer, sendProgress);
|
|
|
|
} else if (sourceType === 'local' && targetType === 'local') {
|
|
const dir = path.dirname(targetPath);
|
|
await ensureLocalDir(dir);
|
|
|
|
await new Promise((resolve, reject) => {
|
|
const readStream = fs.createReadStream(sourcePath, { highWaterMark: TRANSFER_CHUNK_SIZE });
|
|
const writeStream = fs.createWriteStream(targetPath, { highWaterMark: TRANSFER_CHUNK_SIZE });
|
|
let transferred = 0;
|
|
let finished = false;
|
|
|
|
transfer.readStream = readStream;
|
|
transfer.writeStream = writeStream;
|
|
|
|
const cleanup = (err) => {
|
|
if (finished) return;
|
|
finished = true;
|
|
readStream.removeAllListeners();
|
|
writeStream.removeAllListeners();
|
|
if (err) {
|
|
try { readStream.destroy(); } catch { }
|
|
try { writeStream.destroy(); } catch { }
|
|
reject(err);
|
|
} else {
|
|
resolve();
|
|
}
|
|
};
|
|
|
|
readStream.on('data', (chunk) => {
|
|
if (transfer.cancelled) { cleanup(new Error('Transfer cancelled')); return; }
|
|
transferred += chunk.length;
|
|
sendProgress(transferred, fileSize);
|
|
});
|
|
readStream.on('error', cleanup);
|
|
writeStream.on('error', cleanup);
|
|
writeStream.on('finish', () => {
|
|
if (transfer.cancelled) cleanup(new Error('Transfer cancelled'));
|
|
else cleanup(null);
|
|
});
|
|
writeStream.on('close', () => {
|
|
if (transfer.cancelled) cleanup(new Error('Transfer cancelled'));
|
|
});
|
|
readStream.pipe(writeStream);
|
|
});
|
|
|
|
} else if (sourceType === 'sftp' && targetType === 'sftp') {
|
|
const tempPath = path.join(os.tmpdir(), `netcatty-transfer-${transferId}`);
|
|
|
|
const sourceClient = sftpClients.get(sourceSftpId);
|
|
const targetClient = sftpClients.get(targetSftpId);
|
|
if (!sourceClient) throw new Error("Source SFTP session not found");
|
|
if (!targetClient) throw new Error("Target SFTP session not found");
|
|
|
|
const encodedSourcePath = encodePathForSession(sourceSftpId, sourcePath, sourceEncoding);
|
|
const downloadProgress = (transferred) => {
|
|
sendProgress(Math.floor(transferred / 2), fileSize);
|
|
};
|
|
await downloadFile(encodedSourcePath, tempPath, sourceClient, fileSize, transfer, downloadProgress);
|
|
|
|
if (transfer.cancelled) {
|
|
try { await fs.promises.unlink(tempPath); } catch { }
|
|
throw new Error('Transfer cancelled');
|
|
}
|
|
|
|
const dir = path.dirname(targetPath).replace(/\\/g, '/');
|
|
try { await ensureRemoteDirForSession(targetSftpId, dir, targetEncoding); } catch { }
|
|
|
|
const encodedTargetPath = encodePathForSession(targetSftpId, targetPath, targetEncoding);
|
|
const uploadProgress = (transferred) => {
|
|
sendProgress(Math.floor(fileSize / 2) + Math.floor(transferred / 2), fileSize);
|
|
};
|
|
await uploadFile(tempPath, encodedTargetPath, targetClient, fileSize, transfer, uploadProgress);
|
|
|
|
try { await fs.promises.unlink(tempPath); } catch { }
|
|
|
|
} else {
|
|
throw new Error("Invalid transfer configuration");
|
|
}
|
|
|
|
sendProgress(fileSize, fileSize);
|
|
sendComplete();
|
|
|
|
return { transferId, totalBytes: fileSize };
|
|
} catch (err) {
|
|
if (err.message === 'Transfer cancelled') {
|
|
cleanupTransfer();
|
|
sender.send("netcatty:transfer:cancelled", { transferId });
|
|
} else {
|
|
sendError(err);
|
|
}
|
|
return { transferId, error: err.message };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Cancel a transfer
|
|
*/
|
|
async function cancelTransfer(event, payload) {
|
|
const { transferId } = payload;
|
|
const transfer = activeTransfers.get(transferId);
|
|
if (transfer) {
|
|
transfer.cancelled = true;
|
|
if (typeof transfer.wakeWaiter === "function") {
|
|
try { transfer.wakeWaiter(); } catch { }
|
|
}
|
|
|
|
if (typeof transfer.abort === "function") {
|
|
try { transfer.abort(); } catch { }
|
|
}
|
|
|
|
// Destroy streams for stream-based fallback transfers
|
|
if (transfer.readStream) {
|
|
try { transfer.readStream.destroy(); } catch { }
|
|
}
|
|
if (transfer.writeStream) {
|
|
try { transfer.writeStream.destroy(); } catch { }
|
|
}
|
|
}
|
|
return { success: true };
|
|
}
|
|
|
|
/**
|
|
* Register IPC handlers for transfer operations
|
|
*/
|
|
function registerHandlers(ipcMain) {
|
|
ipcMain.handle("netcatty:transfer:start", startTransfer);
|
|
ipcMain.handle("netcatty:transfer:cancel", cancelTransfer);
|
|
}
|
|
|
|
module.exports = {
|
|
init,
|
|
registerHandlers,
|
|
startTransfer,
|
|
cancelTransfer,
|
|
};
|