pal-explorer-cli 0.4.0

package/lib/commands/transfers.js

@@ -0,0 +1,152 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import Conf from 'conf';
+import { removeTransfer, setTransferPaused, getTransferStats, pruneOldHistory } from '../core/transfers.js';
+import config from '../utils/config.js';
+
+const transferStore = new Conf({
+  projectName: 'palexplorer-cli',
+  configName: 'transfers',
+  defaults: { active: [], history: [] }
+});
+
+function formatProgress(t) {
+  const pct = t.progress ? `${(t.progress * 100).toFixed(1)}%` : '0%';
+  return pct;
+}
+
+function printActive(active) {
+  if (active.length === 0) {
+    console.log(chalk.gray('No active transfers. Use `pe download <magnet>` to start one.'));
+    return;
+  }
+  console.log('');
+  console.log(chalk.cyan('Active Transfers:'));
+  active.forEach(t => {
+    const status = t.paused ? chalk.yellow('paused') : chalk.blue('downloading');
+    const pct = formatProgress(t);
+    const name = t.name || 'Unknown';
+    const shortMagnet = t.magnet.slice(0, 40) + '...';
+    console.log(`  ${chalk.white(name)}  [${status}]  ${pct}`);
+    console.log(`    ${chalk.gray(t.savePath || '')}  ${chalk.gray(shortMagnet)}`);
+  });
+}
+
+export default function transfersCommand(program) {
+  const cmd = program
+    .command('transfers')
+    .description('view and manage active file transfers')
+    .option('--history', 'Show completed transfers')
+    .addHelpText('after', `
+Examples:
+  $ pe transfers                    Show active transfers
+  $ pe transfers --history          Show completed transfers
+  $ pe transfers cancel <magnet>    Cancel a transfer
+`)
+    .action((opts) => {
+      if (program.opts().json) {
+        const active = transferStore.get('active') || [];
+        const history = transferStore.get('history') || [];
+        console.log(JSON.stringify(opts.history ? { history } : { active }, null, 2));
+        return;
+      }
+      if (opts.history) {
+        const history = transferStore.get('history') || [];
+        if (history.length === 0) {
+          console.log(chalk.gray('No completed transfers.'));
+          return;
+        }
+        console.log('');
+        console.log(chalk.cyan('Completed Transfers:'));
+        history.forEach(t => {
+          console.log(`  ${chalk.white(t.name || 'Unknown')}  ${chalk.green('✔ done')}  ${chalk.gray(t.completedAt || '')}`);
+          console.log(`    ${chalk.gray(t.savePath || '')}`);
+        });
+        return;
+      }
+      const active = transferStore.get('active') || [];
+      printActive(active);
+    });
+
+  cmd
+    .command('cancel <magnet>')
+    .description('remove a transfer from tracking by its magnet URI')
+    .action((magnet) => {
+      removeTransfer(magnet);
+      console.log(chalk.green('✔ Transfer removed from tracking.'));
+    });
+
+  cmd
+    .command('pause <magnet>')
+    .description('pause a transfer')
+    .action((magnet) => {
+      const active = transferStore.get('active') || [];
+      const found = active.find(t => t.magnet === magnet);
+      if (!found) {
+        console.log(chalk.red('Transfer not found.'));
+        process.exitCode = 1; return;
+      }
+      if (found.paused) {
+        console.log(chalk.yellow('Transfer is already paused.'));
+        return;
+      }
+      setTransferPaused(magnet, true);
+      console.log(chalk.green('✔ Transfer paused.'));
+      const pidPath = path.join(path.dirname(config.path), 'serve.pid');
+      if (fs.existsSync(pidPath)) {
+        console.log(chalk.yellow('Note: Restart `pe serve` for the change to take effect on the running daemon.'));
+      }
+    });
+
+  cmd
+    .command('resume <magnet>')
+    .description('resume a paused transfer')
+    .action((magnet) => {
+      const active = transferStore.get('active') || [];
+      const found = active.find(t => t.magnet === magnet);
+      if (!found) {
+        console.log(chalk.red('Transfer not found.'));
+        process.exitCode = 1; return;
+      }
+      if (!found.paused) {
+        console.log(chalk.yellow('Transfer is not paused.'));
+        return;
+      }
+      setTransferPaused(magnet, false);
+      console.log(chalk.green('✔ Transfer resumed.'));
+      const pidPath = path.join(path.dirname(config.path), 'serve.pid');
+      if (fs.existsSync(pidPath)) {
+        console.log(chalk.yellow('Note: Restart `pe serve` for the change to take effect on the running daemon.'));
+      }
+    });
+
+  cmd
+    .command('stats')
+    .description('show transfer statistics')
+    .option('--days <n>', 'Number of days to include', '90')
+    .action((opts) => {
+      const days = parseInt(opts.days, 10) || 90;
+      pruneOldHistory(days);
+      const stats = getTransferStats(days);
+      console.log('');
+      console.log(chalk.cyan(`Transfer Stats (last ${days} days):`));
+      console.log(`  Total transfers:  ${chalk.white(stats.totalTransfers)}`);
+      console.log(`  Total data:       ${chalk.white(formatBytes(stats.totalBytes))}`);
+      console.log(`  Avg speed:        ${chalk.white(formatBytes(stats.avgSpeed) + '/s')}`);
+      if (Object.keys(stats.perDay).length > 0) {
+        console.log('');
+        console.log(chalk.cyan('  Per day:'));
+        for (const [day, count] of Object.entries(stats.perDay).sort()) {
+          console.log(`    ${day}: ${count} transfer(s)`);
+        }
+      }
+    });
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+}

package/lib/commands/uninstall.js

@@ -0,0 +1,188 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import config from '../utils/config.js';
+
+const DATA_PATHS = {
+  config: () => config.path,
+  configDir: () => path.dirname(config.path),
+  logs: () => path.join(os.homedir(), '.pal', 'logs'),
+  palDir: () => path.join(os.homedir(), '.pal'),
+  keysFile: () => path.join(os.homedir(), '.palexplorer', '.keys.json'),
+  keysDir: () => path.join(os.homedir(), '.palexplorer'),
+  pidFile: () => path.join(path.dirname(config.path), 'serve.pid'),
+};
+
+function rmSafe(p) {
+  try {
+    if (!fs.existsSync(p)) return false;
+    const stat = fs.statSync(p);
+    if (stat.isDirectory()) {
+      fs.rmSync(p, { recursive: true, force: true });
+    } else {
+      fs.unlinkSync(p);
+    }
+    return true;
+  } catch { return false; }
+}
+
+async function clearKeytar() {
+  if (process.platform !== 'win32' && process.platform !== 'darwin') return [];
+  const removed = [];
+  try {
+    const keytar = (await import('keytar')).default;
+    // Config encryption key
+    const configKey = await keytar.getPassword('pal-explorer-config', 'encryption-key');
+    if (configKey) {
+      await keytar.deletePassword('pal-explorer-config', 'encryption-key');
+      removed.push('pal-explorer-config/encryption-key');
+    }
+    // Identity private keys
+    const creds = await keytar.findCredentials('pal-explorer');
+    for (const c of creds) {
+      await keytar.deletePassword('pal-explorer', c.account);
+      removed.push(`pal-explorer/${c.account.slice(0, 16)}...`);
+    }
+  } catch {}
+  return removed;
+}
+
+export default function uninstallCommand(program) {
+  program
+    .command('uninstall')
+    .description('remove Palexplorer app data from this machine')
+    .option('--purge', 'Also remove identity, private keys, and OS credential store entries')
+    .option('--dry-run', 'Show what would be removed without deleting')
+    .addHelpText('after', `
+Examples:
+  $ pe uninstall                  Remove app data (keeps identity & keys)
+  $ pe uninstall --purge          Remove everything including identity & keys
+  $ pe uninstall --dry-run        Preview what would be removed
+`)
+    .action(async (opts) => {
+      const dryRun = opts.dryRun;
+      const purge = opts.purge;
+
+      console.log('');
+      if (dryRun) console.log(chalk.yellow('DRY RUN — nothing will be deleted\n'));
+
+      const items = [];
+
+      // Always removed
+      const configPath = DATA_PATHS.config();
+      if (fs.existsSync(configPath)) items.push({ path: configPath, label: 'Config file (shares, settings, friends)', category: 'data' });
+
+      const pidPath = DATA_PATHS.pidFile();
+      if (fs.existsSync(pidPath)) items.push({ path: pidPath, label: 'Daemon PID file', category: 'data' });
+
+      const logDir = DATA_PATHS.logs();
+      if (fs.existsSync(logDir)) items.push({ path: logDir, label: 'Log files', category: 'data' });
+
+      // Purge-only
+      if (purge) {
+        const keysFile = DATA_PATHS.keysFile();
+        if (fs.existsSync(keysFile)) items.push({ path: keysFile, label: 'Private keys file (.keys.json)', category: 'keys' });
+
+        const keysDir = DATA_PATHS.keysDir();
+        if (fs.existsSync(keysDir)) items.push({ path: keysDir, label: '~/.palexplorer directory', category: 'keys' });
+      }
+
+      // Show what will be removed
+      if (items.length === 0 && !purge) {
+        console.log(chalk.gray('No app data found to remove.'));
+        return;
+      }
+
+      console.log(chalk.cyan('Files to remove:'));
+      for (const item of items) {
+        const icon = item.category === 'keys' ? chalk.red('🔑') : chalk.yellow('📁');
+        console.log(`  ${icon} ${chalk.white(item.label)}`);
+        console.log(`     ${chalk.gray(item.path)}`);
+      }
+
+      if (purge) {
+        const keytarEntries = await clearKeytarDryRun();
+        if (keytarEntries.length > 0) {
+          console.log(`  ${chalk.red('🔑')} ${chalk.white('OS credential store entries')}`);
+          for (const entry of keytarEntries) {
+            console.log(`     ${chalk.gray(entry)}`);
+          }
+        }
+      }
+
+      console.log('');
+
+      if (!purge) {
+        console.log(chalk.gray('Identity and private keys will be kept.'));
+        console.log(chalk.gray('Use --purge to also remove identity and keys.\n'));
+      } else {
+        console.log(chalk.red('⚠  This will permanently delete your identity and private keys.'));
+        console.log(chalk.red('   Make sure you have your 24-word recovery phrase backed up!\n'));
+      }
+
+      if (dryRun) {
+        console.log(chalk.yellow('No changes made (dry run).'));
+        return;
+      }
+
+      // Perform deletion
+      let removed = 0;
+      for (const item of items) {
+        if (rmSafe(item.path)) {
+          console.log(chalk.green(`  ✔ Removed: ${item.label}`));
+          removed++;
+        }
+      }
+
+      // Clean up empty parent dirs
+      const configDir = DATA_PATHS.configDir();
+      if (fs.existsSync(configDir)) {
+        try {
+          const remaining = fs.readdirSync(configDir);
+          if (remaining.length === 0) rmSafe(configDir);
+        } catch {}
+      }
+      const palDir = DATA_PATHS.palDir();
+      if (fs.existsSync(palDir)) {
+        try {
+          const remaining = fs.readdirSync(palDir);
+          if (remaining.length === 0) rmSafe(palDir);
+        } catch {}
+      }
+
+      if (purge) {
+        const keytarRemoved = await clearKeytar();
+        for (const entry of keytarRemoved) {
+          console.log(chalk.green(`  ✔ Removed credential: ${entry}`));
+          removed++;
+        }
+      }
+
+      console.log('');
+      if (removed > 0) {
+        console.log(chalk.green(`✔ Removed ${removed} item(s).`));
+      } else {
+        console.log(chalk.gray('Nothing to remove.'));
+      }
+
+      if (!purge) {
+        console.log(chalk.gray('\nTo also remove identity and keys: pe uninstall --purge'));
+      } else {
+        console.log(chalk.gray('\nTo fully uninstall the CLI: npm rm -g pal-explorer-cli'));
+      }
+    });
+}
+
+async function clearKeytarDryRun() {
+  if (process.platform !== 'win32' && process.platform !== 'darwin') return [];
+  const entries = [];
+  try {
+    const keytar = (await import('keytar')).default;
+    const configKey = await keytar.getPassword('pal-explorer-config', 'encryption-key');
+    if (configKey) entries.push('pal-explorer-config/encryption-key');
+    const creds = await keytar.findCredentials('pal-explorer');
+    for (const c of creds) entries.push(`pal-explorer/${c.account.slice(0, 16)}...`);
+  } catch {}
+  return entries;
+}

package/lib/commands/update.js

@@ -0,0 +1,204 @@
+import chalk from 'chalk';
+import crypto from 'crypto';
+import { execSync, spawnSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { pipeline } from 'stream/promises';
+import { createWriteStream } from 'fs';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '../..');
+const pkgPath = path.join(ROOT, 'package.json');
+
+import { getPrimaryServer } from '../core/discoveryClient.js';
+const UPDATE_SERVER = getPrimaryServer();
+
+function detectPlatform() {
+  const p = os.platform();
+  if (p === 'win32') return 'win';
+  if (p === 'darwin') return 'mac';
+  if (p === 'linux') return 'linux';
+  return p;
+}
+
+export default function updateCommand(program) {
+  const cmd = program
+    .command('update')
+    .description('check for updates and install them')
+    .option('--force', 'Force update even if on latest version')
+    .addHelpText('after', `
+Examples:
+  $ pe update check     Check if a new version is available
+  $ pe update           Download and install the latest version
+  $ pe update --force   Force reinstall even if up to date
+`)
+    .action(async (opts) => {
+      console.log(chalk.cyan('Checking for updates...'));
+      const result = await checkForUpdate();
+      if (!result) {
+        console.log(chalk.gray('Could not check for updates.'));
+        return;
+      }
+      if (!result.hasUpdate && !opts.force) {
+        console.log(chalk.green(`You're on the latest version (${result.current}).`));
+        return;
+      }
+
+      if (result.hasUpdate) {
+        console.log(chalk.yellow(`Update available: ${result.current} → ${result.latest}`));
+        if (result.forced) {
+          console.log(chalk.red(`This update is required (minimum version: ${result.minVersion}).`));
+        }
+        if (result.releaseNotes) {
+          console.log(chalk.gray(result.releaseNotes));
+        }
+      }
+
+      if (!result.downloadUrl) {
+        console.log(chalk.gray('No download URL available for this platform.'));
+        return;
+      }
+
+      await installUpdate(result);
+    });
+
+  cmd
+    .command('check')
+    .description('check if a new version is available')
+    .action(async () => {
+      const result = await checkForUpdate();
+      if (!result) {
+        console.log(chalk.gray('Could not check for updates.'));
+        return;
+      }
+      if (result.hasUpdate) {
+        console.log(chalk.yellow(`Update available: ${result.current} → ${result.latest}`));
+        if (result.releaseNotes) console.log(chalk.gray(result.releaseNotes));
+      } else {
+        console.log(chalk.green(`Up to date (${result.current}).`));
+      }
+    });
+}
+
+export async function checkForUpdate() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const current = pkg.version;
+    const platform = detectPlatform();
+    const url = `${UPDATE_SERVER}/api/v1/updates/check?platform=cli&version=${current}&channel=stable`;
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(5000),
+      headers: { 'User-Agent': `palexplorer-cli/${current}` },
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return {
+      current,
+      latest: data.latestVersion || current,
+      hasUpdate: !!data.available,
+      forced: !!data.forced,
+      minVersion: data.minVersion,
+      downloadUrl: data.downloadUrl,
+      sha256: data.sha256,
+      releaseNotes: data.releaseNotes,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function installUpdate(update) {
+  const tmpDir = path.join(os.tmpdir(), `palexplorer-update-${Date.now()}`);
+  const tarballPath = path.join(tmpDir, 'update.tar.gz');
+
+  try {
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    // Download
+    console.log(chalk.cyan(`Downloading v${update.latest}...`));
+    const res = await fetch(update.downloadUrl, { signal: AbortSignal.timeout(120000) });
+    if (!res.ok) throw new Error(`Download failed: HTTP ${res.status}`);
+    await pipeline(res.body, createWriteStream(tarballPath));
+
+    const size = fs.statSync(tarballPath).size;
+    console.log(chalk.gray(`  Downloaded ${(size / 1024 / 1024).toFixed(1)} MB`));
+
+    // Verify sha256 if provided
+    if (update.sha256) {
+      const hash = crypto.createHash('sha256').update(fs.readFileSync(tarballPath)).digest('hex');
+      if (hash !== update.sha256) {
+        throw new Error(`Integrity check failed. Expected ${update.sha256}, got ${hash}`);
+      }
+      console.log(chalk.gray('  Integrity verified (sha256)'));
+    }
+
+    // Extract
+    console.log(chalk.cyan('Installing...'));
+    const extractDir = path.join(tmpDir, 'extracted');
+    fs.mkdirSync(extractDir, { recursive: true });
+    const tarResult = spawnSync('tar', ['-xzf', tarballPath, '-C', extractDir], { stdio: 'pipe' });
+    if (tarResult.status !== 0) throw new Error('Failed to extract update package');
+
+    // Find the package root inside the tarball (may be nested in a directory)
+    let sourceDir = extractDir;
+    const entries = fs.readdirSync(extractDir);
+    if (entries.length === 1 && fs.statSync(path.join(extractDir, entries[0])).isDirectory()) {
+      sourceDir = path.join(extractDir, entries[0]);
+    }
+
+    // Verify it's a valid palexplorer package
+    const newPkgPath = path.join(sourceDir, 'package.json');
+    if (!fs.existsSync(newPkgPath)) {
+      throw new Error('Invalid update package: no package.json found');
+    }
+    const newPkg = JSON.parse(fs.readFileSync(newPkgPath, 'utf8'));
+    if (newPkg.name !== 'palexplorer') {
+      throw new Error(`Invalid update package: expected palexplorer, got ${newPkg.name}`);
+    }
+
+    // Backup current version
+    const backupDir = path.join(os.tmpdir(), `palexplorer-backup-${Date.now()}`);
+    console.log(chalk.gray(`  Backing up current version to ${backupDir}`));
+    fs.mkdirSync(backupDir, { recursive: true });
+    for (const item of ['lib', 'bin', 'package.json']) {
+      const src = path.join(ROOT, item);
+      const dest = path.join(backupDir, item);
+      if (fs.existsSync(src)) {
+        fs.cpSync(src, dest, { recursive: true });
+      }
+    }
+
+    // Copy new files over current installation
+    for (const item of ['lib', 'bin', 'package.json']) {
+      const src = path.join(sourceDir, item);
+      const dest = path.join(ROOT, item);
+      if (fs.existsSync(src)) {
+        if (fs.existsSync(dest)) fs.rmSync(dest, { recursive: true, force: true });
+        fs.cpSync(src, dest, { recursive: true });
+      }
+    }
+
+    // Install dependencies if node_modules not bundled
+    const newNodeModules = path.join(sourceDir, 'node_modules');
+    if (fs.existsSync(newNodeModules)) {
+      console.log(chalk.gray('  Using bundled node_modules'));
+      fs.cpSync(newNodeModules, path.join(ROOT, 'node_modules'), { recursive: true });
+    } else {
+      console.log(chalk.gray('  Installing dependencies...'));
+      execSync('npm install --production', { cwd: ROOT, stdio: 'pipe' });
+    }
+
+    console.log(chalk.green(`\nUpdated to v${newPkg.version}!`));
+    console.log(chalk.gray(`Backup saved to: ${backupDir}`));
+    console.log(chalk.gray('Run `pe --version` to verify.'));
+
+  } catch (err) {
+    console.error(chalk.red(`Update failed: ${err.message}`));
+    console.log(chalk.gray('Your current installation is unchanged.'));
+  } finally {
+    // Clean up temp dir
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+}