pal-explorer-cli 0.4.0

package/lib/core/syncEngine.js

@@ -0,0 +1,264 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import logger from '../utils/logger.js';
+
+// mtime+size hash cache: skip re-hashing files that haven't changed
+const _hashCache = new Map();
+
+function getCachedHash(filePath, mtimeMs, size) {
+  const cached = _hashCache.get(filePath);
+  if (cached && cached.mtimeMs === mtimeMs && cached.size === size) {
+    return cached.hash;
+  }
+  return null;
+}
+
+function setCachedHash(filePath, mtimeMs, size, hash) {
+  _hashCache.set(filePath, { mtimeMs, size, hash });
+}
+
+const IGNORE_PATTERNS = [
+  /node_modules/,
+  /\.git\//,
+  /\.DS_Store$/,
+  /Thumbs\.db$/,
+  /\.sync-conflict-/,
+];
+
+function shouldIgnore(relativePath) {
+  return IGNORE_PATTERNS.some(p => p.test(relativePath));
+}
+
+function hashFileStream(filePath) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+    stream.on('data', (chunk) => h.update(chunk));
+    stream.on('end', () => resolve(h.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+export async function buildManifest(dirPath, cachedManifest) {
+  const cachedMap = new Map();
+  if (cachedManifest) {
+    const entries = Array.isArray(cachedManifest) ? cachedManifest : Object.values(cachedManifest);
+    for (const entry of entries) {
+      cachedMap.set(entry.relativePath, entry);
+    }
+  }
+  const absDir = path.resolve(dirPath);
+  if (!fs.existsSync(absDir)) {
+    throw new Error(`Directory not found: ${absDir}`);
+  }
+  if (!fs.statSync(absDir).isDirectory()) {
+    throw new Error(`Not a directory: ${absDir}`);
+  }
+
+  const entries = [];
+
+  async function walk(dir, relBase) {
+    let dirents;
+    try {
+      dirents = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (err) {
+      logger.warn(`Cannot read directory: ${dir} (${err.message})`);
+      return;
+    }
+
+    for (const dirent of dirents) {
+      const fullPath = path.join(dir, dirent.name);
+      const relativePath = relBase ? `${relBase}/${dirent.name}` : dirent.name;
+
+      if (shouldIgnore(relativePath)) continue;
+
+      if (dirent.isDirectory()) {
+        await walk(fullPath, relativePath);
+      } else if (dirent.isFile()) {
+        try {
+          const stat = fs.statSync(fullPath);
+          let hash = getCachedHash(fullPath, stat.mtimeMs, stat.size);
+          if (!hash) {
+            const cached = cachedMap.get(relativePath);
+            if (cached && cached.size === stat.size && Math.abs((cached.mtime || 0) - stat.mtimeMs) <= 1) {
+              hash = cached.hash;
+            }
+          }
+          if (!hash) {
+            hash = await hashFileStream(fullPath);
+            setCachedHash(fullPath, stat.mtimeMs, stat.size, hash);
+          }
+          entries.push({
+            relativePath,
+            size: stat.size,
+            hash,
+            mtime: stat.mtimeMs,
+          });
+        } catch (err) {
+          logger.warn(`Cannot read file: ${fullPath} (${err.message})`);
+        }
+      }
+    }
+  }
+
+  await walk(absDir, '');
+  return entries;
+}
+
+export function manifestToMap(manifest) {
+  const map = {};
+  for (const entry of manifest) {
+    map[entry.relativePath] = entry;
+  }
+  return map;
+}
+
+export function diffManifests(local, remote) {
+  const localMap = Array.isArray(local) ? manifestToMap(local) : local;
+  const remoteMap = Array.isArray(remote) ? manifestToMap(remote) : remote;
+
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  const unchanged = [];
+  const conflicts = [];
+
+  const allPaths = new Set([...Object.keys(localMap), ...Object.keys(remoteMap)]);
+
+  for (const filePath of allPaths) {
+    const localEntry = localMap[filePath];
+    const remoteEntry = remoteMap[filePath];
+
+    if (!localEntry && remoteEntry) {
+      added.push({ relativePath: filePath, remote: remoteEntry });
+    } else if (localEntry && !remoteEntry) {
+      deleted.push({ relativePath: filePath, local: localEntry });
+    } else if (localEntry.hash === remoteEntry.hash) {
+      unchanged.push({ relativePath: filePath });
+    } else {
+      modified.push({
+        relativePath: filePath,
+        local: localEntry,
+        remote: remoteEntry,
+      });
+    }
+  }
+
+  return { added, modified, deleted, unchanged, conflicts };
+}
+
+export function detectConflicts(localManifest, remoteManifest, baseManifest) {
+  const localMap = Array.isArray(localManifest) ? manifestToMap(localManifest) : localManifest;
+  const remoteMap = Array.isArray(remoteManifest) ? manifestToMap(remoteManifest) : remoteManifest;
+  const baseMap = Array.isArray(baseManifest) ? manifestToMap(baseManifest) : baseManifest;
+
+  const conflicts = [];
+  const safeModified = [];
+
+  const allPaths = new Set([...Object.keys(localMap), ...Object.keys(remoteMap)]);
+
+  for (const filePath of allPaths) {
+    const local = localMap[filePath];
+    const remote = remoteMap[filePath];
+    const base = baseMap[filePath];
+
+    if (!local || !remote) continue;
+    if (local.hash === remote.hash) continue;
+
+    // No base = first sync — treat as safe modification (remote wins), not conflict
+    if (!base) {
+      safeModified.push({ relativePath: filePath, local, remote });
+      continue;
+    }
+
+    const localChanged = base.hash !== local.hash;
+    const remoteChanged = base.hash !== remote.hash;
+
+    if (localChanged && remoteChanged) {
+      conflicts.push({ relativePath: filePath, local, remote, base });
+    } else {
+      safeModified.push({ relativePath: filePath, local, remote });
+    }
+  }
+
+  return { conflicts, safeModified };
+}
+
+export function applyDiff(diff, sourcePath, destPath, options = {}) {
+  const { dryRun = false } = options;
+  const results = { copied: [], deleted: [], conflicted: [], errors: [] };
+
+  for (const entry of diff.added) {
+    const src = path.join(sourcePath, entry.relativePath);
+    const dst = path.join(destPath, entry.relativePath);
+    if (dryRun) {
+      results.copied.push(entry.relativePath);
+      continue;
+    }
+    try {
+      fs.mkdirSync(path.dirname(dst), { recursive: true });
+      fs.copyFileSync(src, dst);
+      results.copied.push(entry.relativePath);
+    } catch (err) {
+      results.errors.push({ file: entry.relativePath, error: err.message });
+    }
+  }
+
+  for (const entry of diff.modified) {
+    const src = path.join(sourcePath, entry.relativePath);
+    const dst = path.join(destPath, entry.relativePath);
+    if (dryRun) {
+      results.copied.push(entry.relativePath);
+      continue;
+    }
+    try {
+      fs.mkdirSync(path.dirname(dst), { recursive: true });
+      fs.copyFileSync(src, dst);
+      results.copied.push(entry.relativePath);
+    } catch (err) {
+      results.errors.push({ file: entry.relativePath, error: err.message });
+    }
+  }
+
+  for (const entry of (diff.conflicts || [])) {
+    const src = path.join(sourcePath, entry.relativePath);
+    const dst = path.join(destPath, entry.relativePath);
+    if (dryRun) {
+      results.conflicted.push(entry.relativePath);
+      continue;
+    }
+    try {
+      const ext = path.extname(entry.relativePath);
+      const base = entry.relativePath.slice(0, -ext.length || undefined);
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const conflictName = `${base}.sync-conflict-${timestamp}${ext}`;
+      const conflictDst = path.join(destPath, conflictName);
+      fs.mkdirSync(path.dirname(conflictDst), { recursive: true });
+      fs.copyFileSync(src, conflictDst);
+      results.conflicted.push({ original: entry.relativePath, conflictFile: conflictName });
+    } catch (err) {
+      results.errors.push({ file: entry.relativePath, error: err.message });
+    }
+  }
+
+  for (const entry of diff.deleted) {
+    const dst = path.join(destPath, entry.relativePath);
+    if (dryRun) {
+      results.deleted.push(entry.relativePath);
+      continue;
+    }
+    try {
+      if (fs.existsSync(dst)) {
+        fs.unlinkSync(dst);
+        results.deleted.push(entry.relativePath);
+      }
+    } catch (err) {
+      results.errors.push({ file: entry.relativePath, error: err.message });
+    }
+  }
+
+  return results;
+}
+
+export { formatSize } from '../utils/format.js';

package/lib/core/syncState.js

@@ -0,0 +1,159 @@
+import config from '../utils/config.js';
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+
+// --- Sync Pairs ---
+
+export function getSyncPairs() {
+  return config.get('syncPairs') || [];
+}
+
+export function getSyncPair(id) {
+  return getSyncPairs().find(p => p.id === id);
+}
+
+export function findSyncPair(localPath, palId) {
+  const absPath = path.resolve(localPath);
+  return getSyncPairs().find(p => p.localPath === absPath && p.palId === palId);
+}
+
+export function addSyncPair(localPath, palId, remotePath) {
+  const pairs = getSyncPairs();
+  const absPath = path.resolve(localPath);
+
+  const existing = pairs.find(p => p.localPath === absPath && p.palId === palId);
+  if (existing) return existing;
+
+  const id = crypto.randomUUID();
+  const pair = {
+    id,
+    localPath: absPath,
+    palId,
+    remotePath,
+    lastSync: null,
+    status: 'idle',
+    createdAt: new Date().toISOString()
+  };
+  pairs.push(pair);
+  config.set('syncPairs', pairs);
+  return pair;
+}
+
+export function updateSyncPair(id, updates) {
+  const pairs = getSyncPairs();
+  const pair = pairs.find(p => p.id === id);
+  if (!pair) return null;
+  Object.assign(pair, updates);
+  config.set('syncPairs', pairs);
+  return pair;
+}
+
+export function removeSyncPair(id) {
+  const pairs = getSyncPairs().filter(p => p.id !== id);
+  config.set('syncPairs', pairs);
+  clearSyncManifest(id);
+  clearSyncHistory(id);
+}
+
+// --- Last-Synced Manifests ---
+
+function manifestKey(pairId) {
+  return `syncManifests.${pairId}`;
+}
+
+export function getSyncManifest(pairId) {
+  return config.get(manifestKey(pairId)) || null;
+}
+
+export function saveSyncManifest(pairId, manifest) {
+  config.set(manifestKey(pairId), manifest);
+}
+
+export function clearSyncManifest(pairId) {
+  config.delete(manifestKey(pairId));
+}
+
+export function getLastSyncedManifestMap(pairId) {
+  const manifest = getSyncManifest(pairId);
+  if (!manifest) return {};
+  const map = {};
+  for (const entry of manifest) {
+    map[entry.relativePath] = entry;
+  }
+  return map;
+}
+
+// --- Sync History ---
+
+function historyKey(pairId) {
+  return `syncHistory.${pairId}`;
+}
+
+const MAX_HISTORY = 50;
+
+export function getSyncHistory(pairId) {
+  return config.get(historyKey(pairId)) || [];
+}
+
+export function addSyncHistoryEntry(pairId, entry) {
+  const history = getSyncHistory(pairId);
+  history.unshift({
+    id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+    ...entry,
+  });
+  if (history.length > MAX_HISTORY) history.length = MAX_HISTORY;
+  config.set(historyKey(pairId), history);
+  return history[0];
+}
+
+export function clearSyncHistory(pairId) {
+  config.delete(historyKey(pairId));
+}
+
+// --- Legacy compat: buildFileManifest / diffManifests (used by old code) ---
+
+export function buildFileManifest(dirPath) {
+  const manifest = {};
+  function walk(dir, relBase) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      const rel = relBase ? path.join(relBase, entry.name).split(path.sep).join('/') : entry.name;
+      if (entry.isDirectory()) {
+        walk(full, rel);
+      } else if (entry.isFile()) {
+        try {
+          const stat = fs.statSync(full);
+          const hash = crypto.createHash('sha256').update(fs.readFileSync(full)).digest('hex');
+          manifest[rel] = { size: stat.size, modified: stat.mtimeMs, hash };
+        } catch {
+          // skip unreadable files
+        }
+      }
+    }
+  }
+  walk(dirPath, '');
+  return manifest;
+}
+
+export function diffManifests(local, remote) {
+  const added = [];
+  const modified = [];
+  const deleted = [];
+
+  for (const [file, info] of Object.entries(remote)) {
+    if (!local[file]) added.push(file);
+    else if (local[file].hash !== info.hash) modified.push(file);
+  }
+  for (const file of Object.keys(local)) {
+    if (!remote[file]) deleted.push(file);
+  }
+  return { added, modified, deleted };
+}

package/lib/core/transfers.js

@@ -0,0 +1,259 @@
+import Conf from 'conf';
+import crypto from 'crypto';
+import path from 'path';
+import { hooks } from './extensions.js';
+
+
+const transferStore = new Conf({
+  projectName: 'palexplorer-cli',
+  configName: 'transfers',
+  defaults: {
+    active: [],
+    history: [],
+    batches: []
+  }
+});
+
+export const getTransfers = () => transferStore.get('active');
+
+export const getTransferHistory = () => transferStore.get('history');
+
+export const trackTransfer = (magnet, name, savePath, encryptedShareKey = null) => {
+  const active = transferStore.get('active');
+  if (active.find(t => t.magnet === magnet)) return;
+
+  const entry = {
+    magnet,
+    name,
+    savePath,
+    addedAt: new Date().toISOString(),
+    status: 'downloading',
+    progress: 0,
+    paused: false
+  };
+  if (encryptedShareKey) entry.encryptedShareKey = encryptedShareKey;
+
+  active.push(entry);
+  transferStore.set('active', active);
+};
+
+export const setTransferPaused = (magnet, isPaused) => {
+  const active = transferStore.get('active');
+  const index = active.findIndex(t => t.magnet === magnet);
+  if (index !== -1) {
+    active[index].status = isPaused ? 'paused' : 'downloading';
+    active[index].paused = isPaused;
+    transferStore.set('active', active);
+  }
+};
+
+export const updateTransferProgress = (magnet, progress) => {
+  const active = transferStore.get('active');
+  const index = active.findIndex(t => t.magnet === magnet);
+  if (index !== -1) {
+    active[index].progress = progress;
+    transferStore.set('active', active);
+  }
+};
+
+export const completeTransfer = (magnet) => {
+  const active = transferStore.get('active');
+  const history = transferStore.get('history');
+
+  const index = active.findIndex(t => t.magnet === magnet);
+  if (index !== -1) {
+    const [transfer] = active.splice(index, 1);
+    transfer.status = 'completed';
+    transfer.completedAt = new Date().toISOString();
+    history.push(transfer);
+
+    transferStore.set('active', active);
+    transferStore.set('history', history);
+
+    hooks.emit('after:download:complete', {
+      filePath: transfer.savePath ? path.join(transfer.savePath, transfer.name || '') : null,
+      name: transfer.name,
+      magnet: transfer.magnet,
+      size: transfer.bytesTransferred || 0,
+      duration: transfer.startedAt && transfer.completedAt
+        ? new Date(transfer.completedAt).getTime() - new Date(transfer.startedAt).getTime()
+        : 0,
+      speed: transfer.speed || 0,
+    }).catch(() => {});
+
+  }
+};
+
+export const removeTransfer = (magnet) => {
+  const active = transferStore.get('active');
+  const index = active.findIndex(t => t.magnet === magnet);
+  if (index !== -1) {
+    active.splice(index, 1);
+    transferStore.set('active', active);
+  }
+};
+
+export const cleanStaleTransfers = (maxAgeHours = 24) => {
+  const active = transferStore.get('active');
+  const cutoff = Date.now() - (maxAgeHours * 60 * 60 * 1000);
+  const stale = active.filter(t => t.progress === 0 && t.status === 'downloading' && new Date(t.addedAt).getTime() < cutoff);
+  if (stale.length === 0) return 0;
+  const remaining = active.filter(t => !stale.includes(t));
+  const cleaned = stale.map(t => ({ ...t, status: 'failed', completedAt: new Date().toISOString(), error: 'Stale — no progress' }));
+  const history = transferStore.get('history');
+  history.push(...cleaned);
+  transferStore.set('active', remaining);
+  transferStore.set('history', history);
+  return stale.length;
+};
+
+// ── Batch operations ──
+
+const MAX_CONCURRENT_DOWNLOADS = 3;
+
+export const createBatch = (transfers) => {
+  const id = crypto.randomUUID();
+  const batch = {
+    id,
+    transfers: transfers.map(t => ({ magnet: t.magnet, name: t.name, savePath: t.savePath })),
+    status: 'active',
+    createdAt: new Date().toISOString()
+  };
+  const batches = transferStore.get('batches');
+  batches.push(batch);
+  transferStore.set('batches', batches);
+
+  for (const t of batch.transfers) {
+    trackTransfer(t.magnet, t.name, t.savePath);
+  }
+
+  return id;
+};
+
+export const getBatches = () => transferStore.get('batches');
+
+export const pauseBatch = (id) => {
+  const batches = transferStore.get('batches');
+  const batch = batches.find(b => b.id === id);
+  if (!batch) return false;
+
+  batch.status = 'paused';
+  transferStore.set('batches', batches);
+
+  for (const t of batch.transfers) {
+    setTransferPaused(t.magnet, true);
+  }
+  return true;
+};
+
+export const resumeBatch = (id) => {
+  const batches = transferStore.get('batches');
+  const batch = batches.find(b => b.id === id);
+  if (!batch) return false;
+
+  batch.status = 'active';
+  transferStore.set('batches', batches);
+
+  for (const t of batch.transfers) {
+    setTransferPaused(t.magnet, false);
+  }
+  return true;
+};
+
+export const cancelBatch = (id) => {
+  const batches = transferStore.get('batches');
+  const index = batches.findIndex(b => b.id === id);
+  if (index === -1) return false;
+
+  const [batch] = batches.splice(index, 1);
+  transferStore.set('batches', batches);
+
+  for (const t of batch.transfers) {
+    removeTransfer(t.magnet);
+  }
+  return true;
+};
+
+export const getBatchProgress = (id) => {
+  const batches = transferStore.get('batches');
+  const batch = batches.find(b => b.id === id);
+  if (!batch) return null;
+
+  const active = transferStore.get('active');
+  const history = transferStore.get('history');
+  let totalProgress = 0;
+  const count = batch.transfers.length;
+
+  for (const t of batch.transfers) {
+    const activeT = active.find(a => a.magnet === t.magnet);
+    if (activeT) {
+      totalProgress += activeT.progress;
+    } else if (history.find(h => h.magnet === t.magnet)) {
+      totalProgress += 1;
+    }
+  }
+
+  return {
+    id,
+    status: batch.status,
+    total: count,
+    progress: count > 0 ? totalProgress / count : 0
+  };
+};
+
+export const getMaxConcurrentDownloads = () => MAX_CONCURRENT_DOWNLOADS;
+
+// ── Transfer analytics ──
+
+export const updateTransferStats = (magnet, stats) => {
+  const active = transferStore.get('active');
+  const index = active.findIndex(t => t.magnet === magnet);
+  if (index !== -1) {
+    if (stats.bytesTransferred !== undefined) active[index].bytesTransferred = stats.bytesTransferred;
+    if (stats.speed !== undefined) active[index].speed = stats.speed;
+    if (!active[index].startedAt) active[index].startedAt = new Date().toISOString();
+    transferStore.set('active', active);
+  }
+};
+
+export const pruneOldHistory = (maxAgeDays = 90) => {
+  const history = transferStore.get('history');
+  const cutoff = Date.now() - maxAgeDays * 86400000;
+  const pruned = history.filter(t => {
+    const ts = t.completedAt ? new Date(t.completedAt).getTime() : 0;
+    return ts > cutoff;
+  });
+  if (pruned.length < history.length) {
+    transferStore.set('history', pruned);
+  }
+  return history.length - pruned.length;
+};
+
+export const getTransferStats = (days = 90) => {
+  const history = transferStore.get('history');
+  const cutoff = Date.now() - days * 86400000;
+  const recent = history.filter(t => {
+    const ts = t.completedAt ? new Date(t.completedAt).getTime() : 0;
+    return ts > cutoff;
+  });
+
+  let totalBytes = 0;
+  let totalDuration = 0;
+  const perDay = {};
+
+  for (const t of recent) {
+    totalBytes += t.bytesTransferred || 0;
+    if (t.startedAt && t.completedAt) {
+      totalDuration += new Date(t.completedAt).getTime() - new Date(t.startedAt).getTime();
+    }
+    const day = t.completedAt ? t.completedAt.slice(0, 10) : 'unknown';
+    perDay[day] = (perDay[day] || 0) + 1;
+  }
+
+  return {
+    totalTransfers: recent.length,
+    totalBytes,
+    avgSpeed: totalDuration > 0 ? totalBytes / (totalDuration / 1000) : 0,
+    perDay,
+  };
+};