pal-explorer-cli 0.4.0

package/extensions/@palexplorer/vfs/index.js

@@ -0,0 +1,167 @@
+import { v2 as webdav } from 'webdav-server';
+import { exec } from 'child_process';
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+
+let server = null;
+let token = null;
+let mounted = false;
+let shares = new Map();
+let ctx = null;
+
+export function activate(context) {
+  ctx = context;
+
+  context.hooks.on('on:app:ready', async () => {
+    const port = context.config.get('port') || 1900;
+    const autoMount = context.config.get('autoMount') !== false;
+    try {
+      await startServer(port);
+      await syncShares(context);
+      if (autoMount) {
+        const letter = context.config.get('driveLetter') || 'P';
+        await mount(letter, port);
+      }
+    } catch (err) {
+      context.logger.error('VFS startup failed:', err.message);
+    }
+  });
+
+  context.hooks.on('after:share:create', async () => {
+    if (server) await syncShares(context);
+  });
+
+  context.hooks.on('after:share:revoke', async () => {
+    if (server) await syncShares(context);
+  });
+
+  context.hooks.on('on:app:shutdown', async () => {
+    await stop();
+  });
+}
+
+export function deactivate() {
+  return stop();
+}
+
+export function getStatus() {
+  return {
+    running: !!server,
+    mounted,
+    shareCount: shares.size,
+    shares: Array.from(shares.entries()).map(([name, localPath]) => ({ name, localPath })),
+  };
+}
+
+async function startServer(port = 1900) {
+  if (server) return;
+  token = crypto.randomBytes(32).toString('hex');
+
+  const userManager = new webdav.SimpleUserManager();
+  const user = userManager.addUser('pal', token, false);
+  const privilegeManager = new webdav.SimplePathPrivilegeManager();
+  privilegeManager.setRights(user, '/', ['all']);
+
+  server = new webdav.WebDAVServer({
+    port,
+    hostname: '127.0.0.1',
+    requireAuthentification: true,
+    httpAuthentication: new webdav.HTTPBasicAuthentication(userManager, 'Palexplorer VFS'),
+    privilegeManager,
+  });
+
+  return new Promise((resolve, reject) => {
+    server.start((s) => {
+      if (s instanceof Error) return reject(s);
+      ctx?.logger.info(`WebDAV server on http://127.0.0.1:${port}`);
+      resolve();
+    });
+  });
+}
+
+async function stop() {
+  if (mounted) {
+    try { await unmount(); } catch {}
+  }
+  if (server) {
+    return new Promise((resolve) => {
+      server.stop(() => { server = null; token = null; resolve(); });
+    });
+  }
+}
+
+async function syncShares(context) {
+  const configShares = context.shares?.list() || [];
+  const activeNames = new Set();
+
+  for (const share of configShares) {
+    if (share.status !== 'active') continue;
+    const name = path.basename(share.path);
+    activeNames.add(name);
+    if (!shares.has(name)) {
+      try {
+        await new Promise((resolve, reject) => {
+          server.setFileSystem(`/${name}`, new webdav.PhysicalFileSystem(share.path), (ok) => {
+            if (ok) { shares.set(name, share.path); resolve(); }
+            else reject(new Error(`Failed to add: ${name}`));
+          });
+        });
+      } catch {}
+    }
+  }
+
+  for (const [name] of shares) {
+    if (!activeNames.has(name)) {
+      server.removeFileSystem(`/${name}`, () => { shares.delete(name); });
+    }
+  }
+}
+
+async function mount(driveLetter = 'P', port = 1900) {
+  const p = process.platform;
+  if (p === 'win32') {
+    const cmd = `net use ${driveLetter}: http://127.0.0.1:${port} /user:pal ${token} /persistent:yes`;
+    return new Promise((resolve) => {
+      exec(cmd, (err, stdout, stderr) => {
+        if (err && stderr?.includes('67')) {
+          ctx?.logger.warn('WebClient service not running, drive skipped.');
+          return resolve();
+        }
+        mounted = !err || stderr?.includes('85');
+        if (mounted) ctx?.logger.info(`Mounted at ${driveLetter}:`);
+        resolve();
+      });
+    });
+  }
+  if (p === 'darwin') {
+    const mp = '/Volumes/Palexplorer';
+    return new Promise((resolve) => {
+      exec(`mkdir -p "${mp}" && mount_webdav -s -S http://127.0.0.1:${port} "${mp}"`, (err) => {
+        mounted = !err;
+        if (mounted) ctx?.logger.info(`Mounted at ${mp}`);
+        resolve();
+      });
+    });
+  }
+  if (p === 'linux') {
+    const mp = `${process.env.HOME}/Palexplorer`;
+    return new Promise((resolve) => {
+      exec(`mkdir -p "${mp}" && mount -t davfs http://127.0.0.1:${port} "${mp}"`, (err) => {
+        mounted = !err;
+        if (mounted) ctx?.logger.info(`Mounted at ${mp}`);
+        resolve();
+      });
+    });
+  }
+}
+
+async function unmount() {
+  const p = process.platform;
+  const cmd = p === 'win32' ? `net use P: /delete /yes`
+    : p === 'darwin' ? `umount /Volumes/Palexplorer`
+    : `umount ${process.env.HOME}/Palexplorer`;
+  return new Promise((resolve) => {
+    exec(cmd, () => { mounted = false; resolve(); });
+  });
+}

package/lib/capabilities.js

@@ -0,0 +1,263 @@
+// Shared capability registry for CLI and GUI parity
+// Each capability describes an action available in the system.
+// GUI pages and CLI commands reference these to stay in sync.
+
+export const CAPABILITIES = {
+  // === Shares ===
+  'share.create': {
+    label: 'Create Share',
+    description: 'Share a file or folder with pals',
+    category: 'shares',
+    options: {
+      visibility: { type: 'enum', values: ['private', 'public'], default: 'private' },
+      recipients: { type: 'string[]', label: 'Recipients (pals or groups)' },
+      expires: { type: 'duration', label: 'Expiry duration' },
+      password: { type: 'string', label: 'Password protection' },
+      maxDownloads: { type: 'number', label: 'Max downloads', min: 1 },
+      nonRecursive: { type: 'boolean', label: 'Top-level files only', default: false },
+    },
+    cli: 'pe share <path>',
+    gui: 'ShareModal',
+    tier: 'free',
+  },
+  'share.revoke': {
+    label: 'Revoke Share',
+    description: 'Remove access to a shared file',
+    category: 'shares',
+    cli: 'pe revoke <shareId>',
+    gui: 'ShareExplorer (context menu)',
+    tier: 'free',
+  },
+  'share.list': {
+    label: 'List Shares',
+    description: 'View all active shares',
+    category: 'shares',
+    cli: 'pe list',
+    gui: 'ShareExplorer',
+    tier: 'free',
+  },
+  'share.link.create': {
+    label: 'Create Share Link',
+    description: 'Generate a web-accessible share link',
+    category: 'shares',
+    options: {
+      expires: { type: 'duration', label: 'Link expiry' },
+      password: { type: 'string', label: 'Link password' },
+      maxDownloads: { type: 'number', label: 'Max downloads', min: 1 },
+    },
+    cli: 'pe share-link create',
+    gui: 'ShareLinksPage',
+    tier: 'free',
+  },
+
+  // === Downloads ===
+  'download': {
+    label: 'Download',
+    description: 'Download from a magnet link or share',
+    category: 'transfers',
+    cli: 'pe download <magnet>',
+    gui: 'TransfersPage (drag & drop or command palette)',
+    tier: 'free',
+  },
+
+  // === Pals ===
+  'pal.add': {
+    label: 'Add Pal',
+    description: 'Add a friend by handle, public key, or invite link',
+    category: 'people',
+    options: {
+      method: { type: 'enum', values: ['handle', 'publicKey', 'inviteLink'], label: 'Add method' },
+    },
+    cli: 'pe pal add <identifier>',
+    gui: 'AddPalModal',
+    tier: 'free',
+    gaps: ['GUI does not support invite link method'],
+  },
+  'pal.remove': {
+    label: 'Remove Pal',
+    category: 'people',
+    cli: 'pe pal remove <handle>',
+    gui: 'PalsPage (context menu)',
+    tier: 'free',
+  },
+  'pal.list': {
+    label: 'List Pals',
+    category: 'people',
+    cli: 'pe pal list',
+    gui: 'PalsPage',
+    tier: 'free',
+  },
+
+  // === Groups ===
+  'group.create': {
+    label: 'Create Group',
+    category: 'people',
+    cli: 'pe group create <name>',
+    gui: 'GroupModal',
+    tier: 'free',
+  },
+  'group.list': {
+    label: 'List Groups',
+    category: 'people',
+    cli: 'pe group list',
+    gui: 'GroupsPage',
+    tier: 'free',
+  },
+
+  // === Sync ===
+  'sync.push': {
+    label: 'Push Sync',
+    description: 'Push a directory to a pal',
+    category: 'transfers',
+    options: {
+      watch: { type: 'boolean', label: 'Watch for changes', default: false },
+    },
+    cli: 'pe sync push <dir> <pal>',
+    gui: 'SyncPage',
+    tier: 'free',
+  },
+  'sync.pull': {
+    label: 'Pull Sync',
+    description: 'Pull a directory from a pal',
+    category: 'transfers',
+    cli: 'pe sync pull <dir> <pal>',
+    gui: 'SyncPage',
+    tier: 'free',
+  },
+
+  // === Chat ===
+  'chat.send': {
+    label: 'Send Message',
+    category: 'social',
+    cli: 'pe chat send <pal> <message>',
+    gui: 'ChatPage',
+    tier: 'free',
+  },
+
+  // === Invite ===
+  'invite.create': {
+    label: 'Create Invite',
+    description: 'Generate an invite link or QR code',
+    category: 'people',
+    options: {
+      qr: { type: 'boolean', label: 'Generate QR code' },
+    },
+    cli: 'pe invite --qr',
+    gui: null,
+    tier: 'free',
+    gaps: ['No QR generation in GUI'],
+  },
+
+  // === Remote Browse ===
+  'remote.browse': {
+    label: 'Browse Remote Pal',
+    description: 'Browse files on a remote pal',
+    category: 'shares',
+    cli: 'pe remote browse <pal>',
+    gui: 'RemoteBrowser (not linked from nav)',
+    tier: 'free',
+    gaps: ['RemoteBrowser exists but not accessible from nav'],
+  },
+
+  // === Stream ===
+  'stream.start': {
+    label: 'Start Stream',
+    description: 'Stream media from a share',
+    category: 'transfers',
+    cli: 'pe stream <shareId>',
+    gui: 'StreamPage',
+    tier: 'pro',
+  },
+
+  // === Identity ===
+  'identity.init': {
+    label: 'Create Identity',
+    category: 'system',
+    cli: 'pe init <name>',
+    gui: 'SetupWizard',
+    tier: 'free',
+  },
+  'identity.register': {
+    label: 'Register Handle',
+    category: 'system',
+    cli: 'pe register <handle>',
+    gui: 'SettingsPage',
+    tier: 'free',
+  },
+  'identity.recover': {
+    label: 'Recover Identity',
+    description: 'Restore from recovery phrase',
+    category: 'system',
+    cli: 'pe recover',
+    gui: null,
+    tier: 'free',
+    gaps: ['No recovery phrase restore flow in GUI'],
+  },
+
+  // === Device ===
+  'device.list': {
+    label: 'List Devices',
+    category: 'system',
+    cli: 'pe device list',
+    gui: 'SettingsPage (partial)',
+    tier: 'free',
+    gaps: ['No dedicated device management page'],
+  },
+
+  // === Billing ===
+  'billing.status': {
+    label: 'Billing Status',
+    category: 'system',
+    cli: 'pe billing status',
+    gui: 'SettingsPage (partial)',
+    tier: 'pro',
+  },
+
+  // === Extensions ===
+  'extension.install': {
+    label: 'Install Extension',
+    category: 'system',
+    cli: 'pe extension install <name>',
+    gui: 'ExtensionsPage',
+    tier: 'free',
+  },
+
+  // === Favorites ===
+  'favorite.add': {
+    label: 'Favorite Share',
+    category: 'shares',
+    cli: 'pe favorite add <shareId>',
+    gui: 'SharesPage (star UI, no filter view)',
+    tier: 'free',
+    gaps: ['No dedicated favorites view/filter'],
+  },
+
+  // === Search ===
+  'search': {
+    label: 'Search',
+    description: 'Search files, shares, and pals',
+    category: 'shares',
+    cli: 'pe search <query>',
+    gui: 'SearchPage + top bar search',
+    tier: 'free',
+  },
+};
+
+// Helpers
+export function getCapabilitiesByCategory(category) {
+  return Object.entries(CAPABILITIES)
+    .filter(([, cap]) => cap.category === category)
+    .map(([id, cap]) => ({ id, ...cap }));
+}
+
+export function getCapabilityGaps() {
+  return Object.entries(CAPABILITIES)
+    .filter(([, cap]) => cap.gaps?.length > 0)
+    .map(([id, cap]) => ({ id, label: cap.label, gaps: cap.gaps }));
+}
+
+export function getCapabilitiesByTier(tier) {
+  return Object.entries(CAPABILITIES)
+    .filter(([, cap]) => cap.tier === tier)
+    .map(([id, cap]) => ({ id, ...cap }));
+}

package/lib/commands/analytics.js

@@ -0,0 +1,175 @@
+import chalk from 'chalk';
+
+export default function analyticsCommand(program) {
+  const cmd = program
+    .command('analytics')
+    .description('transfer analytics and reporting (Pro)')
+    .addHelpText('after', `
+Examples:
+  $ pe analytics metrics                 Show transfer metrics (default: week)
+  $ pe analytics metrics --period month  Monthly metrics
+  $ pe analytics report --format csv     Generate CSV report
+  $ pe analytics top-shares              Show most downloaded shares
+  $ pe analytics storage-trends          Show 30-day storage trends
+  $ pe analytics dashboard               Open web dashboard
+`)
+    .action(() => { cmd.outputHelp(); });
+
+  cmd
+    .command('metrics')
+    .description('show transfer metrics')
+    .option('--period <period>', 'time period: day, week, month', 'week')
+    .action(async (opts) => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const store = extConfig.get('ext_store.reporting-dashboard') || {};
+        const metrics = store.reportingMetrics || {};
+        const periodMs = { day: 86400000, week: 604800000, month: 2592000000 };
+        const cutoff = Date.now() - (periodMs[opts.period] || periodMs.week);
+        const transfers = (metrics.transfers || []).filter(t => new Date(t.timestamp).getTime() > cutoff);
+
+        console.log(chalk.bold(`Transfer Metrics (${opts.period})\n`));
+        console.log(`  Total transfers:  ${chalk.white(transfers.length)}`);
+        const totalBytes = transfers.reduce((sum, t) => sum + (t.bytes || 0), 0);
+        console.log(`  Total data:       ${chalk.white(formatBytes(totalBytes))}`);
+        const avgSpeed = transfers.length > 0 ? totalBytes / transfers.reduce((sum, t) => sum + (t.duration || 1), 0) : 0;
+        console.log(`  Avg speed:        ${chalk.white(formatBytes(avgSpeed) + '/s')}`);
+        console.log(`  Shares created:   ${chalk.white((metrics.sharesCreated || []).filter(s => new Date(s.timestamp).getTime() > cutoff).length)}`);
+      } catch (err) {
+        console.log(chalk.red(`Failed to get metrics: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('report')
+    .description('generate a transfer report')
+    .option('--format <format>', 'output format: json, csv, pdf', 'json')
+    .option('-o, --output <path>', 'output file path')
+    .action(async (opts) => {
+      try {
+        const fs = await import('fs');
+        const path = await import('path');
+        const extConfig = (await import('../utils/config.js')).default;
+        const store = extConfig.get('ext_store.reporting-dashboard') || {};
+        const metrics = store.reportingMetrics || {};
+
+        const data = {
+          generatedAt: new Date().toISOString(),
+          format: opts.format,
+          transfers: metrics.transfers || [],
+          sharesCreated: metrics.sharesCreated || [],
+        };
+
+        let content;
+        if (opts.format === 'csv') {
+          const rows = (data.transfers || []).map(t => `${t.timestamp},${t.bytes},${t.duration},${t.peer || ''}`);
+          content = 'timestamp,bytes,duration,peer\n' + rows.join('\n');
+        } else {
+          content = JSON.stringify(data, null, 2);
+        }
+
+        const outPath = opts.output || `palexplorer-report-${new Date().toISOString().slice(0, 10)}.${opts.format}`;
+        const resolved = path.resolve(outPath);
+        fs.writeFileSync(resolved, content, 'utf8');
+        console.log(chalk.green(`✔ Report generated: ${resolved}`));
+      } catch (err) {
+        console.log(chalk.red(`Report failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('top-shares')
+    .description('show most downloaded shares')
+    .option('--limit <n>', 'number of shares to show', '10')
+    .action(async (opts) => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const store = extConfig.get('ext_store.reporting-dashboard') || {};
+        const metrics = store.reportingMetrics || {};
+        const shares = metrics.topShares || [];
+        const limit = parseInt(opts.limit, 10) || 10;
+
+        if (shares.length === 0) {
+          console.log(chalk.dim('No share data available yet.'));
+          return;
+        }
+
+        console.log(chalk.bold(`Top ${Math.min(limit, shares.length)} Shares\n`));
+        const sorted = shares.sort((a, b) => (b.downloads || 0) - (a.downloads || 0)).slice(0, limit);
+        for (let i = 0; i < sorted.length; i++) {
+          console.log(`  ${chalk.dim(`${i + 1}.`)} ${chalk.cyan(sorted[i].name)} — ${chalk.white(sorted[i].downloads || 0)} downloads`);
+        }
+      } catch (err) {
+        console.log(chalk.red(`Failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('storage-trends')
+    .description('show 30-day storage usage trends')
+    .option('--days <n>', 'number of days', '30')
+    .action(async (opts) => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const store = extConfig.get('ext_store.reporting-dashboard') || {};
+        const metrics = store.reportingMetrics || {};
+        const trends = metrics.storageTrends || {};
+        const days = parseInt(opts.days, 10) || 30;
+
+        const entries = Object.entries(trends).sort().slice(-days);
+        if (entries.length === 0) {
+          console.log(chalk.dim('No storage trend data available yet.'));
+          return;
+        }
+
+        console.log(chalk.bold(`Storage Trends (last ${entries.length} days)\n`));
+        for (const [date, bytes] of entries) {
+          console.log(`  ${chalk.dim(date)} ${chalk.white(formatBytes(bytes))}`);
+        }
+      } catch (err) {
+        console.log(chalk.red(`Failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('dashboard')
+    .description('open the analytics web dashboard')
+    .action(async () => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const extConf = extConfig.get('ext.reporting-dashboard') || {};
+        const port = extConf.dashboardPort;
+        if (!port) {
+          console.log(chalk.yellow('Dashboard port not configured. Set it with:'));
+          console.log(chalk.dim('  pe ext config reporting-dashboard dashboardPort 9090'));
+          process.exitCode = 1;
+          return;
+        }
+        const portNum = parseInt(port, 10);
+        if (!Number.isInteger(portNum) || portNum < 1 || portNum > 65535) {
+          console.error('Invalid analytics port');
+          return;
+        }
+        const url = `http://127.0.0.1:${portNum}`;
+        console.log(chalk.green(`Dashboard: ${chalk.cyan(url)}`));
+        const { exec } = await import('child_process');
+        const opener = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+        exec(`${opener} ${url}`);
+      } catch (err) {
+        console.log(chalk.red(`Failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}