pal-explorer-cli 0.4.0

package/lib/commands/user.js

@@ -0,0 +1,276 @@
+import chalk from 'chalk';
+import config from '../utils/config.js';
+import { createIdentity, getIdentity, guestLogin, guestLogout, isGuestSession } from '../core/identity.js';
+import { resolveFromServer } from '../core/discoveryClient.js';
+import { getPrimaryServer } from '../core/discoveryClient.js';
+import {
+  getProfiles,
+  getActiveUser,
+  setActiveUser,
+  addProfile,
+  removeProfile,
+  promoteProfile,
+  requireRole,
+  migrateToMultiUser,
+  addGuestProfile,
+  removeGuestProfile,
+} from '../core/users.js';
+
+export default function userCommand(program) {
+  const cmd = program.command('user').description('manage user profiles on this machine');
+
+  cmd
+    .command('list')
+    .description('list all user profiles')
+    .action(() => {
+      migrateToMultiUser();
+      const profiles = getProfiles();
+      const active = getActiveUser();
+
+      if (profiles.length === 0) {
+        console.log(chalk.gray('No profiles. Run `pe init <name>` to create one.'));
+        return;
+      }
+
+      console.log('');
+      console.log(chalk.cyan.bold('User Profiles'));
+      console.log('');
+      for (const p of profiles) {
+        const isCurrent = active?.publicKey === p.publicKey;
+        const marker = isCurrent ? chalk.green(' ← active') : '';
+        const handle = p.handle ? chalk.cyan(` @${p.handle}`) : '';
+        const role = p.role === 'owner' ? chalk.yellow(p.role)
+          : p.role === 'user' ? chalk.blue(p.role)
+          : chalk.gray(p.role);
+        console.log(`  ${isCurrent ? '●' : '○'} ${chalk.white(p.name)}${handle}  [${role}]${marker}`);
+        console.log(`    ${chalk.gray(`Key: ${p.publicKey.slice(0, 16)}...  Last: ${p.lastLogin || 'never'}`)}`);
+      }
+      console.log('');
+    });
+
+  cmd
+    .command('add [name]')
+    .description('create a new user profile on this machine (Owner only)')
+    .option('--role <role>', 'Role for the new profile (owner, user, or guest)', 'user')
+    .action(async (name, addOpts) => {
+      migrateToMultiUser();
+      try {
+        requireRole('owner');
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+        return;
+      }
+
+      const profileName = name || 'New User';
+
+      try {
+        // Store current identity, create new one
+        const currentIdentity = config.get('identity');
+        const newIdentity = await createIdentity(profileName, { force: true });
+
+        // Add as profile with specified role
+        const role = ['owner', 'user', 'guest'].includes(addOpts.role) ? addOpts.role : 'user';
+        addProfile(newIdentity.publicKey, null, profileName, role);
+
+        // Restore owner's identity as active in config
+        config.set('identity', currentIdentity);
+
+        console.log(chalk.green(`✔ Created profile: ${profileName}`));
+        console.log(chalk.gray(`  Public key: ${newIdentity.publicKey.slice(0, 16)}...`));
+        console.log(chalk.yellow(`  Mnemonic (save this!):`));
+        console.log(chalk.white(`  ${newIdentity.mnemonic}`));
+        console.log('');
+        console.log(chalk.gray(`They can login with: pe login ${profileName}`));
+        console.log(chalk.gray(`Then register a handle: pe register <handle>`));
+      } catch (err) {
+        console.log(chalk.red(`Failed to create profile: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('remove <handle>')
+    .description('remove a user profile (Owner only)')
+    .action((handle) => {
+      migrateToMultiUser();
+      try {
+        requireRole('owner');
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+        return;
+      }
+
+      const profiles = getProfiles();
+      const target = profiles.find(p => p.handle === handle || p.name === handle);
+      if (!target) {
+        console.log(chalk.red(`Profile not found: ${handle}`));
+        process.exitCode = 1;
+        return;
+      }
+
+      try {
+        removeProfile(target.publicKey);
+        console.log(chalk.green(`✔ Removed profile: ${target.name}`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('promote <handle>')
+    .description('promote a guest to user (Owner only)')
+    .option('--demote', 'Demote user back to guest')
+    .action((handle, opts) => {
+      migrateToMultiUser();
+      try {
+        requireRole('owner');
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+        return;
+      }
+
+      const profiles = getProfiles();
+      const target = profiles.find(p => p.handle === handle || p.name === handle);
+      if (!target) {
+        console.log(chalk.red(`Profile not found: ${handle}`));
+        process.exitCode = 1;
+        return;
+      }
+
+      try {
+        const newRole = opts.demote ? 'guest' : 'user';
+        promoteProfile(target.publicKey, newRole);
+        console.log(chalk.green(`✔ ${target.name} is now ${newRole}`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // pe login
+  program
+    .command('login [handle]')
+    .description('switch active user profile')
+    .option('--list', 'List available profiles')
+    .option('--guest', 'Login as guest with a recovery phrase')
+    .action(async (handle, opts) => {
+      // Guest login flow
+      if (opts.guest) {
+        const readline = (await import('readline')).default;
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (q) => new Promise(r => rl.question(q, r));
+
+        try {
+          const mnemonic = await ask('Enter 24-word recovery phrase: ');
+          rl.close();
+          const words = mnemonic.trim().split(/\s+/);
+          if (words.length !== 24) {
+            console.log(chalk.red(`Expected 24 words, got ${words.length}.`));
+            process.exitCode = 1;
+            return;
+          }
+          const guest = await guestLogin(mnemonic.trim());
+          addGuestProfile(guest.publicKey, null);
+
+          // Try to resolve handle from discovery
+          try {
+            const server = getPrimaryServer();
+            const resolved = await resolveFromServer(server, guest.publicKey.slice(0, 16));
+            if (resolved?.handle) {
+              guest.handle = resolved.handle;
+            }
+          } catch {}
+
+          console.log(chalk.green(`Logged in as guest (${guest.publicKey.slice(0, 16)}...)`));
+          console.log(chalk.gray('Guest access: browse shared-with-me, download, view pals/inbox.'));
+          console.log(chalk.gray('Cannot: share, manage users, change config.'));
+        } catch (err) {
+          rl.close();
+          console.log(chalk.red(`Guest login failed: ${err.message}`));
+          process.exitCode = 1;
+        }
+        return;
+      }
+
+      migrateToMultiUser();
+      const profiles = getProfiles();
+
+      if (profiles.length === 0) {
+        console.log(chalk.red('No profiles. Run `pe init <name>` first.'));
+        process.exitCode = 1;
+        return;
+      }
+
+      if (opts.list || !handle) {
+        const active = getActiveUser();
+        console.log('');
+        console.log(chalk.cyan('Available profiles:'));
+        for (const p of profiles) {
+          const isCurrent = active?.publicKey === p.publicKey;
+          const h = p.handle ? `@${p.handle}` : p.name;
+          console.log(`  ${isCurrent ? chalk.green('●') : '○'} ${h} [${p.role}]`);
+        }
+        if (!handle) {
+          console.log('');
+          console.log(chalk.gray('Usage: pe login <handle>'));
+        }
+        return;
+      }
+
+      const target = profiles.find(p =>
+        p.handle === handle || p.name === handle || p.handle === handle.replace(/^@/, '')
+      );
+
+      if (!target) {
+        console.log(chalk.red(`Profile not found: ${handle}`));
+        process.exitCode = 1;
+        return;
+      }
+
+      try {
+        setActiveUser(target.publicKey);
+        const identity = config.get('identity');
+        if (identity) {
+          config.set('identity', {
+            ...identity,
+            publicKey: target.publicKey,
+            handle: target.handle,
+            name: target.name,
+          });
+        }
+        console.log(chalk.green(`✔ Logged in as ${target.name}${target.handle ? ` (@${target.handle})` : ''} [${target.role}]`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // pe logout
+  program
+    .command('logout')
+    .description('end guest session and wipe keys from memory')
+    .action(() => {
+      if (!isGuestSession()) {
+        console.log(chalk.yellow('No guest session active. Regular users don\'t need to logout.'));
+        return;
+      }
+      guestLogout();
+      removeGuestProfile();
+      console.log(chalk.green('Guest session ended. Keys wiped from memory.'));
+    });
+
+  cmd.addHelpText('after', `
+${chalk.cyan('Examples:')}
+  $ pe user list                   List all profiles
+  $ pe user add "Bob"              Create a user profile
+  $ pe user remove bob             Remove a profile
+  $ pe user promote bob            Promote to user
+  $ pe user promote bob --demote   Demote to guest
+  $ pe login alice                 Switch to alice
+  $ pe login --list                Show available profiles
+`);
+}

package/lib/commands/vfs.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+import { vfs, getMountStatus } from '../core/vfs.js';
+
+export default function vfsCommand(program) {
+  const cmd = program
+    .command('vfs')
+    .description('manage the virtual filesystem drive')
+    .addHelpText('after', `
+Examples:
+  $ pe vfs mount                    Mount virtual drive at P:
+  $ pe vfs mount S                  Mount at S:
+  $ pe vfs unmount                  Unmount virtual drive
+  $ pe vfs status                   Show mount status
+`);
+
+  cmd
+    .command('mount [letter]')
+    .description('mount virtual drive (default P:)')
+    .action(async (letter = 'P') => {
+      try {
+        console.log(chalk.blue('Starting VFS server...'));
+        await vfs.start();
+        await vfs.syncShares();
+
+        console.log(chalk.blue(`Mounting drive ${letter}:...`));
+        await vfs.mount(letter);
+
+        const status = getMountStatus();
+        if (status.mounted) {
+          console.log(chalk.green(`Virtual drive mounted at ${letter}: with ${status.shareCount} share(s).`));
+        } else {
+          console.log(chalk.yellow('VFS server running but drive mount was skipped (see warnings above).'));
+          console.log(chalk.gray(`WebDAV available at http://127.0.0.1:${status.port}`));
+        }
+      } catch (err) {
+        console.error(chalk.red('Failed to mount VFS:'), err.message);
+      }
+    });
+
+  cmd
+    .command('unmount')
+    .description('unmount virtual drive')
+    .action(async () => {
+      try {
+        const status = getMountStatus();
+        if (!status?.mounted || !status?.driveLetter) {
+          console.log(chalk.yellow('No virtual drive is currently mounted.'));
+          return;
+        }
+        await vfs.unmount(status.driveLetter);
+        await vfs.stop();
+        console.log(chalk.green('Virtual drive unmounted.'));
+      } catch (err) {
+        console.error(chalk.red('Failed to unmount VFS:'), err.message);
+      }
+    });
+
+  cmd
+    .command('status')
+    .description('show mount status and listed shares')
+    .action(() => {
+      try {
+        const status = getMountStatus();
+        console.log('');
+        console.log(chalk.cyan('VFS Status:'));
+        console.log(`  Server:  ${status.running ? chalk.green('Running') : chalk.red('Stopped')}`);
+        console.log(`  Mounted: ${status.mounted ? chalk.green(`Yes (${status.driveLetter}:)`) : chalk.yellow('No')}`);
+        console.log(`  Port:    ${chalk.white(status.port)}`);
+        console.log(`  Shares:  ${chalk.white(status.shareCount)}`);
+
+        if (status.shares.length > 0) {
+          console.log('');
+          console.log(chalk.cyan('  Mounted Shares:'));
+          for (const s of status.shares) {
+            console.log(`    /${s.name} -> ${chalk.gray(s.localPath)}`);
+          }
+        }
+        console.log('');
+      } catch (err) {
+        console.error(chalk.red('VFS status error:'), err.message);
+        process.exitCode = 1;
+      }
+    });
+}

package/lib/commands/web.js

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import { exec } from 'child_process';
+import config from '../utils/config.js';
+
+export default function webCommand(program) {
+  program
+    .command('web')
+    .description('open the web dashboard in your browser')
+    .option('--port <port>', 'Web dashboard port', '8585')
+    .option('--url-only', 'Just print the URL, do not open browser')
+    .addHelpText('after', `
+Examples:
+  $ pe web                          Open web dashboard in browser
+  $ pe web --url-only               Just print the dashboard URL
+  $ pe web --port 9090              Use custom port
+`)
+    .action(async (opts) => {
+      try {
+      const token = config.get('webDashboardToken');
+      if (!token) {
+        console.log(chalk.yellow('No web dashboard token found. Start the daemon with --web first:'));
+        console.log(chalk.cyan('  pe serve --web'));
+        return;
+      }
+
+      const port = opts.port;
+      const url = `http://localhost:${port}?token=${token}`;
+
+      if (opts.urlOnly) {
+        console.log(url);
+        return;
+      }
+
+      console.log(chalk.blue('Opening web dashboard...'));
+      console.log(chalk.cyan(`  URL: ${url}`));
+      console.log(chalk.gray(`  Token: ${token}`));
+
+      const platform = process.platform;
+      const cmd = platform === 'win32' ? `start "" "${url}"` :
+                  platform === 'darwin' ? `open "${url}"` : `xdg-open "${url}"`;
+
+      exec(cmd, (err) => {
+        if (err) {
+          console.log(chalk.yellow('Could not open browser automatically. Visit the URL above.'));
+        }
+      });
+      } catch (err) {
+        console.error(chalk.red('Web dashboard error:'), err.message);
+        process.exitCode = 1;
+      }
+    });
+}

package/lib/commands/webhook.js

@@ -0,0 +1,180 @@
+import chalk from 'chalk';
+
+export default function webhookCommand(program) {
+  const cmd = program
+    .command('webhook')
+    .description('manage outgoing webhooks (Pro)')
+    .addHelpText('after', `
+Examples:
+  $ pe webhook add --name deploy --url https://hook.example.com --events share.created
+  $ pe webhook list
+  $ pe webhook test deploy
+  $ pe webhook log
+  $ pe webhook remove deploy
+`)
+    .action(() => { cmd.outputHelp(); });
+
+  cmd
+    .command('add')
+    .description('register a new webhook')
+    .requiredOption('--name <name>', 'webhook name')
+    .requiredOption('--url <url>', 'webhook delivery URL (HTTPS)')
+    .requiredOption('--events <events>', 'comma-separated event types')
+    .option('--secret <secret>', 'HMAC signing secret')
+    .action(async (opts) => {
+      try {
+        if (!opts.url.startsWith('https://')) {
+          console.log(chalk.red('Webhook URL must use HTTPS.'));
+          process.exitCode = 1;
+          return;
+        }
+        const extConfig = (await import('../utils/config.js')).default;
+        const conf = extConfig.get('ext.webhook-integrations') || {};
+        const webhooks = conf.webhooks || [];
+        if (webhooks.find(w => w.name === opts.name)) {
+          console.log(chalk.red(`Webhook "${opts.name}" already exists. Remove it first.`));
+          process.exitCode = 1;
+          return;
+        }
+        webhooks.push({
+          name: opts.name,
+          url: opts.url,
+          events: opts.events.split(',').map(e => e.trim()),
+          secret: opts.secret || '',
+          enabled: true,
+        });
+        conf.webhooks = webhooks;
+        extConfig.set('ext.webhook-integrations', conf);
+        console.log(chalk.green(`✔ Webhook "${opts.name}" added.`));
+        console.log(`  URL:    ${chalk.cyan(opts.url)}`);
+        console.log(`  Events: ${chalk.white(opts.events)}`);
+      } catch (err) {
+        console.log(chalk.red(`Failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('remove <name>')
+    .description('remove a webhook')
+    .action(async (name) => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const conf = extConfig.get('ext.webhook-integrations') || {};
+        const webhooks = conf.webhooks || [];
+        const idx = webhooks.findIndex(w => w.name === name);
+        if (idx === -1) {
+          console.log(chalk.yellow(`Webhook "${name}" not found.`));
+          process.exitCode = 1;
+          return;
+        }
+        webhooks.splice(idx, 1);
+        conf.webhooks = webhooks;
+        extConfig.set('ext.webhook-integrations', conf);
+        console.log(chalk.green(`✔ Webhook "${name}" removed.`));
+      } catch (err) {
+        console.log(chalk.red(`Failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('list')
+    .description('list all registered webhooks')
+    .action(async () => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const conf = extConfig.get('ext.webhook-integrations') || {};
+        const webhooks = conf.webhooks || [];
+        if (webhooks.length === 0) {
+          console.log(chalk.dim('No webhooks configured.'));
+          return;
+        }
+        console.log(chalk.bold(`Webhooks (${webhooks.length})\n`));
+        for (const w of webhooks) {
+          const status = w.enabled ? chalk.green('●') : chalk.red('○');
+          console.log(`  ${status} ${chalk.cyan(w.name)}`);
+          console.log(`    URL:    ${chalk.white(w.url)}`);
+          console.log(`    Events: ${chalk.dim(w.events.join(', '))}`);
+          console.log(`    Secret: ${w.secret ? chalk.dim('configured') : chalk.dim('none')}`);
+        }
+      } catch (err) {
+        console.log(chalk.red(`Failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('test <name>')
+    .description('send a test ping to a webhook')
+    .action(async (name) => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const conf = extConfig.get('ext.webhook-integrations') || {};
+        const webhooks = conf.webhooks || [];
+        const webhook = webhooks.find(w => w.name === name);
+        if (!webhook) {
+          console.log(chalk.red(`Webhook "${name}" not found.`));
+          process.exitCode = 1;
+          return;
+        }
+
+        const payload = JSON.stringify({
+          event: 'test.ping',
+          data: { message: 'Test ping from Palexplorer' },
+          timestamp: new Date().toISOString(),
+          source: 'palexplorer',
+        });
+
+        const headers = { 'Content-Type': 'application/json' };
+        if (webhook.secret) {
+          const crypto = await import('crypto');
+          const sig = crypto.createHmac('sha256', webhook.secret).update(payload).digest('hex');
+          headers['X-Palexplorer-Signature'] = `sha256=${sig}`;
+        }
+
+        console.log(chalk.dim(`Sending test ping to ${webhook.url}...`));
+        const res = await fetch(webhook.url, { method: 'POST', headers, body: payload });
+        if (res.ok) {
+          console.log(chalk.green(`✔ Test ping delivered (${res.status}).`));
+        } else {
+          console.log(chalk.yellow(`⚠ Server responded with ${res.status}.`));
+        }
+      } catch (err) {
+        console.log(chalk.red(`Test failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('log')
+    .description('show webhook delivery log')
+    .option('--limit <n>', 'number of entries', '20')
+    .option('--verbose', 'show full payload')
+    .action(async (opts) => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const store = extConfig.get('ext_store.webhook-integrations') || {};
+        const log = store.deliveryLog || [];
+        const limit = parseInt(opts.limit, 10) || 20;
+        const entries = log.slice(-limit);
+
+        if (entries.length === 0) {
+          console.log(chalk.dim('No delivery log entries.'));
+          return;
+        }
+
+        console.log(chalk.bold(`Delivery Log (last ${entries.length})\n`));
+        for (const entry of entries) {
+          const icon = entry.success ? chalk.green('✔') : chalk.red('✗');
+          console.log(`  ${icon} ${chalk.dim(entry.timestamp)} ${chalk.cyan(entry.event)} → ${entry.status || 'failed'}`);
+          if (opts.verbose && entry.payload) {
+            console.log(`    ${chalk.dim(JSON.stringify(entry.payload).slice(0, 200))}`);
+          }
+        }
+      } catch (err) {
+        console.log(chalk.red(`Failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/lib/commands/whoami.js

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import { getIdentity } from '../core/identity.js';
+import { getActiveUser, getProfiles } from '../core/users.js';
+
+export default function whoamiCommand(program) {
+  program
+    .command('whoami')
+    .description('display your current identity details')
+    .addHelpText('after', `
+Examples:
+  $ pe whoami                       Show your identity info
+`)
+    .action(async () => {
+      const identity = await getIdentity();
+
+      if (!identity) {
+        console.log(chalk.red('No identity found. Run `pe init <name>` to get started!'));
+        return;
+      }
+
+      const activeUser = getActiveUser();
+      const profiles = getProfiles();
+      const role = activeUser?.role || 'owner';
+
+      if (program.opts().json) {
+        console.log(JSON.stringify({
+          name: identity.name || 'Unknown',
+          handle: identity.handle || null,
+          role,
+          publicKey: identity.publicKey,
+          deviceName: identity.deviceName || 'Unknown',
+          deviceId: identity.deviceId || 'Unknown',
+          createdAt: identity.createdAt,
+          profileCount: profiles.length,
+        }, null, 2));
+        return;
+      }
+
+      const roleColor = role === 'owner' ? chalk.yellow : role === 'user' ? chalk.blue : chalk.gray;
+
+      console.log('');
+      console.log(chalk.cyan('Your Identity:'));
+      console.log(`  Name:       ${chalk.green(identity.name || 'Unknown')}`);
+      console.log(`  Handle:     ${chalk.green(identity.handle ? `@${identity.handle}` : 'Not registered')}`);
+      console.log(`  Role:       ${roleColor(role)}`);
+      console.log(`  Public Key: ${chalk.yellow(identity.publicKey)}`);
+      console.log(`  Device:     ${chalk.gray(identity.deviceName || 'Unknown')} ${chalk.gray(`(${identity.deviceId || 'Unknown'})`)}`);
+      console.log(`  Created At: ${chalk.gray(identity.createdAt)}`);
+      if (profiles.length > 1) {
+        console.log(`  Profiles:   ${chalk.gray(`${profiles.length} users on this machine`)}`);
+      }
+      console.log('');
+      if (!identity.handle) {
+        console.log(chalk.gray('Register a handle: pe register <handle>'));
+      } else {
+        console.log(chalk.gray('Others can add you: pe pal add @' + identity.handle));
+      }
+    });
+}