mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
401 lines
12 KiB
JavaScript
401 lines
12 KiB
JavaScript
/**
|
|
* File Watcher Bridge - Watches local temp files for changes to sync back to remote
|
|
*
|
|
* This bridge enables auto-sync functionality for files opened with external applications.
|
|
* When a file is downloaded to temp and opened with an external app, we watch for changes
|
|
* and automatically upload them back to the remote server.
|
|
*/
|
|
|
|
const fs = require("node:fs");
|
|
const path = require("node:path");
|
|
const crypto = require("node:crypto");
|
|
|
|
// Lazy-load encodePathForSession to avoid circular dependency issues
|
|
let encodePathForSession = null;
|
|
|
|
// Map of watchId -> { watcher, localPath, remotePath, sftpId, lastModified, lastSize }
|
|
const activeWatchers = new Map();
|
|
|
|
// Debounce map to prevent multiple rapid syncs
|
|
const debounceTimers = new Map();
|
|
|
|
// Map of sftpId -> Set<localPath> to track temp files even without watching
|
|
// This allows cleanup when SFTP session closes, regardless of auto-sync setting
|
|
const tempFilesMap = new Map();
|
|
|
|
let sftpClients = null;
|
|
let electronModule = null;
|
|
|
|
/**
|
|
* Initialize the file watcher bridge with dependencies
|
|
*/
|
|
function init(deps) {
|
|
sftpClients = deps.sftpClients;
|
|
electronModule = deps.electronModule;
|
|
}
|
|
|
|
/**
|
|
* Register a temp file for cleanup when SFTP session closes
|
|
* Called regardless of whether auto-sync is enabled
|
|
*/
|
|
function registerTempFile(sftpId, localPath) {
|
|
if (!tempFilesMap.has(sftpId)) {
|
|
tempFilesMap.set(sftpId, new Set());
|
|
}
|
|
tempFilesMap.get(sftpId).add(localPath);
|
|
console.log(`[FileWatcher] Registered temp file for cleanup: ${localPath} (session: ${sftpId})`);
|
|
}
|
|
|
|
/**
|
|
* Show a system notification for file sync events
|
|
* Works on macOS, Windows, and Linux
|
|
*/
|
|
function showSystemNotification(title, body) {
|
|
try {
|
|
if (!electronModule?.Notification) {
|
|
console.warn("[FileWatcher] Electron Notification API not available");
|
|
return;
|
|
}
|
|
|
|
const { Notification } = electronModule;
|
|
|
|
// Check if notifications are supported
|
|
if (!Notification.isSupported()) {
|
|
console.warn("[FileWatcher] System notifications not supported on this platform");
|
|
return;
|
|
}
|
|
|
|
const notification = new Notification({
|
|
title,
|
|
body,
|
|
silent: false, // Allow notification sound
|
|
});
|
|
|
|
notification.show();
|
|
} catch (err) {
|
|
console.warn("[FileWatcher] Failed to show system notification:", err.message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Start watching a local file for changes
|
|
* Returns a watchId that can be used to stop watching
|
|
*/
|
|
async function startWatching(event, { localPath, remotePath, sftpId, encoding }) {
|
|
const watchId = `watch-${crypto.randomUUID()}`;
|
|
|
|
console.log(`[FileWatcher] Starting watch: ${localPath} -> ${remotePath}`);
|
|
|
|
// Get initial file stats
|
|
let lastModified;
|
|
let lastSize;
|
|
try {
|
|
const stat = await fs.promises.stat(localPath);
|
|
lastModified = stat.mtimeMs;
|
|
lastSize = stat.size;
|
|
console.log(`[FileWatcher] Initial file stats: mtime=${lastModified}, size=${lastSize}`);
|
|
} catch (err) {
|
|
console.error(`[FileWatcher] Failed to stat file ${localPath}:`, err.message);
|
|
throw new Error(`Cannot watch file: ${err.message}`);
|
|
}
|
|
|
|
// Store webContents reference for later notifications
|
|
const webContents = event.sender;
|
|
|
|
// Use fs.watchFile (polling) instead of fs.watch for better reliability on Windows
|
|
// fs.watch can miss events when editors use atomic writes (save to temp, then rename)
|
|
// fs.watchFile polls the file system at regular intervals
|
|
const pollInterval = 1000; // Check every 1 second
|
|
|
|
fs.watchFile(localPath, { persistent: true, interval: pollInterval }, async (curr, prev) => {
|
|
console.log(`[FileWatcher] File stat change detected for ${localPath}`);
|
|
console.log(`[FileWatcher] Previous: mtime=${prev.mtimeMs}, size=${prev.size}`);
|
|
console.log(`[FileWatcher] Current: mtime=${curr.mtimeMs}, size=${curr.size}`);
|
|
|
|
// Check if file was deleted
|
|
if (curr.nlink === 0) {
|
|
console.log(`[FileWatcher] File ${localPath} was deleted, stopping watch`);
|
|
stopWatching(null, { watchId });
|
|
return;
|
|
}
|
|
|
|
// Check if file was actually modified
|
|
if (curr.mtimeMs <= prev.mtimeMs && curr.size === prev.size) {
|
|
console.log(`[FileWatcher] File unchanged, skipping`);
|
|
return;
|
|
}
|
|
|
|
// Debounce rapid changes (e.g., multiple saves in quick succession)
|
|
const existingTimer = debounceTimers.get(watchId);
|
|
if (existingTimer) {
|
|
clearTimeout(existingTimer);
|
|
}
|
|
|
|
const timer = setTimeout(async () => {
|
|
debounceTimers.delete(watchId);
|
|
await handleFileChange(watchId, webContents);
|
|
}, 500); // 500ms debounce
|
|
|
|
debounceTimers.set(watchId, timer);
|
|
});
|
|
|
|
activeWatchers.set(watchId, {
|
|
watcher: null, // fs.watchFile doesn't return a watcher object
|
|
localPath,
|
|
remotePath,
|
|
sftpId,
|
|
encoding,
|
|
lastModified,
|
|
lastSize,
|
|
webContents,
|
|
useWatchFile: true, // Flag to indicate we're using fs.watchFile
|
|
});
|
|
|
|
console.log(`[FileWatcher] Watch started with ID: ${watchId} (using fs.watchFile polling every ${pollInterval}ms)`);
|
|
return { watchId };
|
|
}
|
|
|
|
/**
|
|
* Handle file change event - sync to remote
|
|
*/
|
|
async function handleFileChange(watchId, webContents) {
|
|
const watchInfo = activeWatchers.get(watchId);
|
|
if (!watchInfo) return;
|
|
|
|
const { localPath, remotePath, sftpId, encoding, lastModified: previousModified, lastSize: previousSize } = watchInfo;
|
|
|
|
// Lazy-load encodePathForSession to avoid circular dependency
|
|
if (encodePathForSession === null) {
|
|
({ encodePathForSession } = require("./sftpBridge.cjs"));
|
|
}
|
|
|
|
// Extract file name once for notifications and logging
|
|
const fileName = path.basename(remotePath);
|
|
|
|
console.log(`[FileWatcher] File change detected: ${localPath}`);
|
|
|
|
try {
|
|
// Check if file was actually modified (compare mtime and size)
|
|
const stat = await fs.promises.stat(localPath);
|
|
|
|
// Skip if neither mtime nor size changed (prevents spurious events on some platforms)
|
|
if (stat.mtimeMs <= previousModified && stat.size === previousSize) {
|
|
console.log(`[FileWatcher] File unchanged (mtime and size same), skipping sync`);
|
|
return;
|
|
}
|
|
|
|
// Update lastModified and lastSize
|
|
watchInfo.lastModified = stat.mtimeMs;
|
|
watchInfo.lastSize = stat.size;
|
|
|
|
// Get the SFTP client
|
|
if (!sftpClients) {
|
|
throw new Error("SFTP clients not initialized");
|
|
}
|
|
|
|
const client = sftpClients.get(sftpId);
|
|
if (!client) {
|
|
throw new Error("SFTP session not found or expired");
|
|
}
|
|
|
|
// Read the local file
|
|
const content = await fs.promises.readFile(localPath);
|
|
|
|
console.log(`[FileWatcher] Syncing ${content.length} bytes to ${remotePath}`);
|
|
|
|
// Upload to remote
|
|
const encodedPath = encodePathForSession(sftpId, remotePath, encoding);
|
|
await client.put(content, encodedPath);
|
|
|
|
console.log(`[FileWatcher] Sync complete: ${remotePath}`);
|
|
|
|
// Show system notification for successful sync
|
|
showSystemNotification(
|
|
"Netcatty",
|
|
`File synced to remote: ${fileName}`
|
|
);
|
|
|
|
// Notify the renderer about successful sync
|
|
if (webContents && !webContents.isDestroyed()) {
|
|
webContents.send("netcatty:filewatch:synced", {
|
|
watchId,
|
|
localPath,
|
|
remotePath,
|
|
bytesWritten: content.length,
|
|
});
|
|
}
|
|
|
|
} catch (err) {
|
|
console.error(`[FileWatcher] Sync failed for ${localPath}:`, err.message);
|
|
|
|
// Show system notification for sync failure
|
|
showSystemNotification(
|
|
"Netcatty",
|
|
`Failed to sync ${fileName}: ${err.message}`
|
|
);
|
|
|
|
// Notify the renderer about sync failure
|
|
if (webContents && !webContents.isDestroyed()) {
|
|
webContents.send("netcatty:filewatch:error", {
|
|
watchId,
|
|
localPath,
|
|
remotePath,
|
|
error: err.message,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stop watching a file and optionally clean up the temp file
|
|
*/
|
|
function stopWatching(event, { watchId, cleanupTempFile = false }) {
|
|
const watchInfo = activeWatchers.get(watchId);
|
|
if (!watchInfo) {
|
|
console.log(`[FileWatcher] Watch ID not found: ${watchId}`);
|
|
return { success: false };
|
|
}
|
|
|
|
console.log(`[FileWatcher] Stopping watch: ${watchInfo.localPath}`);
|
|
|
|
// Clear debounce timer if any
|
|
const timer = debounceTimers.get(watchId);
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
debounceTimers.delete(watchId);
|
|
}
|
|
|
|
// Stop the watcher
|
|
try {
|
|
if (watchInfo.useWatchFile) {
|
|
// Using fs.watchFile - need to use fs.unwatchFile
|
|
fs.unwatchFile(watchInfo.localPath);
|
|
} else if (watchInfo.watcher) {
|
|
// Using fs.watch - close the watcher
|
|
watchInfo.watcher.close();
|
|
}
|
|
} catch (err) {
|
|
console.warn(`[FileWatcher] Error stopping watcher:`, err.message);
|
|
}
|
|
|
|
// Clean up temp file if requested
|
|
if (cleanupTempFile && watchInfo.localPath) {
|
|
cleanupTempFileAsync(watchInfo.localPath);
|
|
}
|
|
|
|
activeWatchers.delete(watchId);
|
|
|
|
return { success: true };
|
|
}
|
|
|
|
/**
|
|
* Asynchronously delete a temp file, logging success and silently handling failures
|
|
*/
|
|
async function cleanupTempFileAsync(filePath) {
|
|
try {
|
|
await fs.promises.unlink(filePath);
|
|
console.log(`[FileWatcher] Temp file cleaned up: ${filePath}`);
|
|
} catch (err) {
|
|
// Silently ignore deletion failures (file may be in use or already deleted)
|
|
console.log(`[FileWatcher] Could not delete temp file (may be in use): ${filePath}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stop all watchers for a specific SFTP session and clean up temp files
|
|
* Called when SFTP connection is closed
|
|
*/
|
|
function stopWatchersForSession(sftpId, cleanupTempFiles = true) {
|
|
let watcherCount = 0;
|
|
|
|
// Stop active watchers
|
|
for (const [watchId, watchInfo] of activeWatchers.entries()) {
|
|
if (watchInfo.sftpId === sftpId) {
|
|
stopWatching(null, { watchId, cleanupTempFile: cleanupTempFiles });
|
|
watcherCount++;
|
|
}
|
|
}
|
|
if (watcherCount > 0) {
|
|
console.log(`[FileWatcher] Stopped ${watcherCount} watcher(s) for SFTP session: ${sftpId}`);
|
|
}
|
|
|
|
// Clean up any registered temp files that weren't being watched
|
|
if (cleanupTempFiles && tempFilesMap.has(sftpId)) {
|
|
const tempFiles = tempFilesMap.get(sftpId);
|
|
let cleanedCount = 0;
|
|
for (const filePath of tempFiles) {
|
|
cleanupTempFileAsync(filePath);
|
|
cleanedCount++;
|
|
}
|
|
tempFilesMap.delete(sftpId);
|
|
if (cleanedCount > 0) {
|
|
console.log(`[FileWatcher] Queued cleanup for ${cleanedCount} temp file(s) for SFTP session: ${sftpId}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get list of active watchers
|
|
*/
|
|
function listWatchers() {
|
|
const watchers = [];
|
|
for (const [watchId, info] of activeWatchers.entries()) {
|
|
watchers.push({
|
|
watchId,
|
|
localPath: info.localPath,
|
|
remotePath: info.remotePath,
|
|
sftpId: info.sftpId,
|
|
});
|
|
}
|
|
return watchers;
|
|
}
|
|
|
|
function registerWorkerHandle(ipcMain, terminalWorkerManager, channel) {
|
|
ipcMain.handle(channel, (event, payload) => terminalWorkerManager.request(channel, payload, {
|
|
webContentsId: event?.sender?.id,
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* Register IPC handlers for file watching operations
|
|
*/
|
|
function registerHandlers(ipcMain, options = {}) {
|
|
console.log("[FileWatcher] Registering IPC handlers");
|
|
const terminalWorkerManager = options.terminalWorkerManager || null;
|
|
if (terminalWorkerManager) {
|
|
[
|
|
"netcatty:filewatch:start",
|
|
"netcatty:filewatch:stop",
|
|
"netcatty:filewatch:list",
|
|
"netcatty:filewatch:registerTempFile",
|
|
].forEach((channel) => registerWorkerHandle(ipcMain, terminalWorkerManager, channel));
|
|
return;
|
|
}
|
|
ipcMain.handle("netcatty:filewatch:start", (event, args) => {
|
|
console.log("[FileWatcher] IPC netcatty:filewatch:start received", args);
|
|
return startWatching(event, args);
|
|
});
|
|
ipcMain.handle("netcatty:filewatch:stop", stopWatching);
|
|
ipcMain.handle("netcatty:filewatch:list", listWatchers);
|
|
ipcMain.handle("netcatty:filewatch:registerTempFile", (_event, { sftpId, localPath }) => {
|
|
registerTempFile(sftpId, localPath);
|
|
return { success: true };
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Cleanup all watchers on shutdown
|
|
*/
|
|
function cleanup() {
|
|
console.log(`[FileWatcher] Cleaning up ${activeWatchers.size} watcher(s)`);
|
|
for (const [watchId] of activeWatchers.entries()) {
|
|
stopWatching(null, { watchId });
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
init,
|
|
registerHandlers,
|
|
stopWatchersForSession,
|
|
};
|