pal-explorer-cli 0.4.0

package/lib/commands/nearby.js

@@ -0,0 +1,108 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { Bonjour } from 'bonjour-service';
+import { getIdentity } from '../core/identity.js';
+import { getFriends, saveFriends } from '../core/users.js';
+import config from '../utils/config.js';
+
+export default function nearbyCommand(program) {
+  program
+    .command('nearby')
+    .description('discover nearby Palexplorer users on the LAN via mDNS')
+    .option('--add', 'Auto-add found peers as pals')
+    .option('--time <seconds>', 'How long to scan (default: 10)', '10')
+    .addHelpText('after', `
+Examples:
+  $ pe nearby                       Discover pals on local network
+  $ pe nearby --add                 Auto-add discovered pals
+  $ pe nearby --time 30             Scan for 30 seconds
+`)
+    .action(async (opts) => {
+      const identity = await getIdentity();
+      if (!identity) {
+        console.log(chalk.red('No identity found. Run `pe init <name>` first.'));
+        process.exitCode = 1;
+        return;
+      }
+
+      const scanTime = parseInt(opts.time, 10) || 10;
+      const bonjour = new Bonjour();
+      const found = [];
+
+      console.log(chalk.cyan(`Scanning for nearby pals (${scanTime}s)...`));
+      const pkShort = identity.publicKey.slice(0, 8) + '...';
+      const handleStr = identity.handle ? ` (@${identity.handle})` : '';
+      console.log(chalk.gray(`Advertising as: ${identity.name}${handleStr} [pk: ${pkShort}]`));
+      console.log('');
+
+      // Skip mDNS publish if daemon is already running (avoids "Service name already in use")
+      let service = null;
+      const pidPath = path.join(path.dirname(config.path), 'serve.pid');
+      const daemonRunning = fs.existsSync(pidPath);
+      if (!daemonRunning) {
+        try {
+          service = bonjour.publish({
+            name: `palexplorer-${identity.handle || identity.publicKey.slice(0, 8)}`,
+            type: 'palexplorer',
+            port: 7474,
+            txt: {
+              pk: identity.publicKey,
+              h: identity.handle || '',
+              n: identity.name || ''
+            }
+          });
+          service.on('error', () => { service = null; });
+        } catch {
+          // Publish failed — scan-only mode
+        }
+      }
+
+      const browser = bonjour.find({ type: 'palexplorer' }, (svc) => {
+        const txt = svc.txt || {};
+        const pk = txt.pk;
+        if (!pk || pk === identity.publicKey) return;
+
+        if (found.find(f => f.pk === pk)) return;
+
+        const name = txt.n || 'Unknown';
+        const handle = txt.h || null;
+        const ip = (svc.addresses && svc.addresses[0]) || svc.host || 'unknown';
+
+        found.push({ pk, name, handle, ip });
+
+        const handleDisplay = handle ? ` (@${handle})` : '';
+        console.log(chalk.green(`Found: ${name}${handleDisplay} - ${ip}`));
+
+        const invitePayload = 'pal://' + Buffer.from(JSON.stringify({ pk, h: handle || null, n: name })).toString('base64url');
+        console.log(chalk.gray(`  → pe pal add ${invitePayload}`));
+
+        if (opts.add) {
+          if (!/^[0-9a-f]{64}$/i.test(pk)) {
+            console.log(chalk.yellow(`  (skipped: invalid public key from mDNS)`));
+          } else {
+            const friends = getFriends();
+            const already = friends.find(f => f.id === pk);
+            if (already) {
+              console.log(chalk.yellow(`  (already in your pal list as '${already.name}')`));
+            } else {
+              const palName = name || handle || 'Nearby Pal';
+              friends.push({ id: pk, name: palName, handle: handle || null, addedAt: new Date().toISOString() });
+              saveFriends(friends);
+              console.log(chalk.green(`  ✔ Auto-added: ${palName}${handle ? ` (@${handle})` : ''}`));
+            }
+          }
+        }
+      });
+
+      await new Promise(resolve => setTimeout(resolve, scanTime * 1000));
+
+      browser.stop();
+      if (service) service.stop();
+      bonjour.destroy();
+
+      if (found.length === 0) {
+        console.log(chalk.gray('No nearby pals found.'));
+      }
+    });
+}

package/lib/commands/network.js

@@ -0,0 +1,251 @@
+import chalk from 'chalk';
+import {
+  createNetwork,
+  listNetworks,
+  getNetwork,
+  deleteNetwork,
+  createInvite,
+  joinNetwork,
+  listMembers,
+  listGroups,
+  createGroup as createNetworkGroup,
+} from '../core/networks.js';
+import { connect, disconnect, getConnectionState } from '../core/connectionManager.js';
+
+export default function networkCommand(program) {
+  const cmd = program
+    .command('network')
+    .description('manage networks')
+    .addHelpText('after', `
+Examples:
+  $ pe network create "My Network"          Create a network
+  $ pe network list                         List your networks
+  $ pe network info <id>                    Show network details
+  $ pe network invite <id>                  Create an invite link
+  $ pe network join <code>                  Join via invite code
+  $ pe network members <id>                 List members
+  $ pe network groups <id>                  List groups
+  $ pe network create-group <id> <name>     Create a group in network
+  $ pe network delete <id>                  Delete a network
+  $ pe network connect                      Connect to the network
+  $ pe network disconnect                   Disconnect from the network
+`);
+
+  cmd
+    .command('create <name>')
+    .description('create a new network')
+    .option('--slug <slug>', 'URL-friendly slug')
+    .option('--description <desc>', 'Network description')
+    .action(async (name, opts) => {
+      try {
+        const network = await createNetwork(name, opts.slug, opts.description);
+        console.log(chalk.green(`Network '${name}' created.`));
+        console.log(chalk.gray(`ID: ${network.id}`));
+        if (network.slug) console.log(chalk.gray(`Slug: ${network.slug}`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('list')
+    .description('list your networks')
+    .action(async () => {
+      try {
+        const networks = await listNetworks();
+        if (!networks || networks.length === 0) {
+          console.log(chalk.gray('No networks. Create one with `pe network create <name>`.'));
+          return;
+        }
+        console.log('');
+        console.log(chalk.cyan('Networks:'));
+        for (const n of networks) {
+          const members = n.memberCount != null ? chalk.gray(` (${n.memberCount} members)`) : '';
+          const role = n.role ? chalk.yellow(` [${n.role}]`) : '';
+          console.log(`  ${chalk.white(n.name)}${role}${members}`);
+          console.log(`    ${chalk.gray(`ID: ${n.id}`)}`);
+          if (n.description) console.log(`    ${chalk.gray(n.description)}`);
+        }
+        console.log('');
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('info <id>')
+    .description('show network details')
+    .action(async (id) => {
+      try {
+        const n = await getNetwork(id);
+        console.log('');
+        console.log(chalk.cyan(`Network: ${n.name}`));
+        console.log(`  ID:          ${chalk.white(n.id)}`);
+        if (n.slug) console.log(`  Slug:        ${chalk.white(n.slug)}`);
+        if (n.description) console.log(`  Description: ${chalk.white(n.description)}`);
+        if (n.owner) console.log(`  Owner:       ${chalk.white(n.owner)}`);
+        if (n.memberCount != null) console.log(`  Members:     ${chalk.white(n.memberCount)}`);
+        if (n.createdAt) console.log(`  Created:     ${chalk.gray(n.createdAt)}`);
+        console.log('');
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('delete <id>')
+    .description('delete a network')
+    .action(async (id) => {
+      try {
+        await deleteNetwork(id);
+        console.log(chalk.green(`Network ${id} deleted.`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('invite <id>')
+    .description('create an invite link')
+    .option('--role <role>', 'Role for invited user: member or admin', 'member')
+    .action(async (id, opts) => {
+      try {
+        const invite = await createInvite(id, opts.role);
+        console.log(chalk.green('Invite created.'));
+        console.log(`  Code: ${chalk.white(invite.code)}`);
+        if (invite.url) console.log(`  Link: ${chalk.cyan(invite.url)}`);
+        if (invite.expiresAt) console.log(`  Expires: ${chalk.gray(invite.expiresAt)}`);
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('join <code>')
+    .description('join a network via invite code')
+    .action(async (code) => {
+      try {
+        const result = await joinNetwork(code);
+        console.log(chalk.green(`Joined network '${result.name || result.networkId}'.`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('members <id>')
+    .description('list network members')
+    .action(async (id) => {
+      try {
+        const members = await listMembers(id);
+        if (!members || members.length === 0) {
+          console.log(chalk.gray('No members in this network.'));
+          return;
+        }
+        console.log('');
+        console.log(chalk.cyan('Members:'));
+        for (const m of members) {
+          const role = m.role ? chalk.yellow(` [${m.role}]`) : '';
+          const handle = m.handle ? chalk.gray(` @${m.handle}`) : '';
+          console.log(`  ${chalk.white(m.name || m.userId)}${handle}${role}`);
+        }
+        console.log('');
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('groups <id>')
+    .description('list groups in a network')
+    .action(async (id) => {
+      try {
+        const groups = await listGroups(id);
+        if (!groups || groups.length === 0) {
+          console.log(chalk.gray('No groups in this network.'));
+          return;
+        }
+        console.log('');
+        console.log(chalk.cyan('Groups:'));
+        for (const g of groups) {
+          console.log(`  ${chalk.white(g.name)}  ${chalk.gray(`ID: ${g.id}`)}`);
+        }
+        console.log('');
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('create-group <network-id> <name>')
+    .description('create a group in a network')
+    .action(async (networkId, name) => {
+      try {
+        const group = await createNetworkGroup(networkId, name);
+        console.log(chalk.green(`Group '${name}' created in network.`));
+        console.log(chalk.gray(`ID: ${group.id}`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('connect')
+    .description('connect to the Palexplorer network')
+    .action(async () => {
+      const current = getConnectionState();
+      if (current.status === 'connected') {
+        console.log(chalk.yellow('Already connected.'));
+        return;
+      }
+      console.log(chalk.blue('Connecting to Palexplorer network...'));
+      const result = await connect({
+        onProgress: (step, progress) => {
+          console.log(chalk.gray(`  [${progress}%] ${step}`));
+        },
+      });
+      if (result.connectedCount > 0) {
+        console.log(chalk.green(`\nConnected to ${result.connectedCount} server(s).`));
+      } else {
+        console.log(chalk.yellow('\nWarning: No servers reachable.'));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('disconnect')
+    .description('disconnect from the Palexplorer network')
+    .action(async () => {
+      const current = getConnectionState();
+      if (current.status === 'disconnected') {
+        console.log(chalk.yellow('Already disconnected.'));
+        return;
+      }
+      console.log(chalk.blue('Disconnecting...'));
+      await disconnect();
+      console.log(chalk.green('Disconnected from network.'));
+    });
+
+  cmd.action(async () => {
+    try {
+      const networks = await listNetworks();
+      if (!networks || networks.length === 0) {
+        console.log(chalk.gray('No networks. Create one with `pe network create <name>`.'));
+      } else {
+        console.log(chalk.cyan(`${networks.length} network(s). Use \`pe network list\` for details.`));
+      }
+    } catch (err) {
+      console.log(chalk.red(err.message));
+      process.exitCode = 1;
+    }
+  });
+}

package/lib/commands/notify.js

@@ -0,0 +1,198 @@
+import chalk from 'chalk';
+
+const VALID_PROVIDERS = ['sendgrid', 'mailgun', 'ses', 'smtp'];
+const VALID_EVENTS = ['share:invite', 'transfer:complete', 'peer:online', 'peer:offline', 'security:alert'];
+
+export default function notifyCommand(program) {
+  const cmd = program
+    .command('notify')
+    .description('email notifications (Pro)')
+    .addHelpText('after', `
+Examples:
+  $ pe notify configure --provider sendgrid --api-key SG.xxx --to user@example.com
+  $ pe notify configure --provider smtp --smtp-host smtp.gmail.com --smtp-port 587
+  $ pe notify test                           Send a test notification
+  $ pe notify status                         Show notification config
+  $ pe notify events                         List event subscriptions
+  $ pe notify events --enable share:invite   Enable an event type
+  $ pe notify events --disable peer:online   Disable an event type
+`)
+    .action(() => { cmd.outputHelp(); });
+
+  cmd
+    .command('configure')
+    .description('set up email notification provider')
+    .requiredOption('--provider <provider>', 'notification provider (sendgrid|mailgun|ses|smtp)')
+    .option('--api-key <key>', 'API key (for sendgrid/mailgun)')
+    .option('--to <email>', 'recipient email')
+    .option('--from <email>', 'sender email')
+    .option('--smtp-host <host>', 'SMTP host')
+    .option('--smtp-port <port>', 'SMTP port')
+    .action(async (opts) => {
+      try {
+        if (!VALID_PROVIDERS.includes(opts.provider)) {
+          console.log(chalk.red(`Invalid provider. Must be one of: ${VALID_PROVIDERS.join(', ')}`));
+          process.exitCode = 1;
+          return;
+        }
+
+        if (['sendgrid', 'mailgun'].includes(opts.provider) && !opts.apiKey) {
+          console.log(chalk.red(`--api-key is required for ${opts.provider}`));
+          process.exitCode = 1;
+          return;
+        }
+
+        if (opts.provider === 'smtp' && !opts.smtpHost) {
+          console.log(chalk.red('--smtp-host is required for SMTP provider'));
+          process.exitCode = 1;
+          return;
+        }
+
+        const extConfig = (await import('../utils/config.js')).default;
+        const existing = extConfig.get('ext.email-notifications') || {};
+        const config = {
+          ...existing,
+          provider: opts.provider,
+        };
+        if (opts.apiKey) {
+          try {
+            const keytar = (await import('keytar')).default;
+            await keytar.setPassword('palexplorer', 'notify.apiKey', opts.apiKey);
+          } catch {
+            config.apiKey = opts.apiKey;
+          }
+        }
+        if (opts.to) config.toAddress = opts.to;
+        if (opts.from) config.fromAddress = opts.from;
+        if (opts.smtpHost) config.smtpHost = opts.smtpHost;
+        if (opts.smtpPort) config.smtpPort = parseInt(opts.smtpPort, 10);
+        if (!config.events) config.events = [];
+
+        extConfig.set('ext.email-notifications', config);
+        console.log(chalk.green(`✔ Notification provider configured: ${opts.provider}`));
+        if (config.toAddress) console.log(`  To: ${chalk.white(config.toAddress)}`);
+        if (config.fromAddress) console.log(`  From: ${chalk.white(config.fromAddress)}`);
+        if (config.smtpHost) console.log(`  SMTP: ${chalk.white(config.smtpHost)}:${chalk.white(config.smtpPort || 587)}`);
+      } catch (err) {
+        console.log(chalk.red(`Configure failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('test')
+    .description('send a test notification email')
+    .action(async () => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const config = extConfig.get('ext.email-notifications') || {};
+        if (!config.provider) {
+          console.log(chalk.red('No provider configured. Run: pe notify configure --provider <provider>'));
+          process.exitCode = 1;
+          return;
+        }
+        if (!config.toAddress) {
+          console.log(chalk.red('No recipient configured. Run: pe notify configure --provider <provider> --to <email>'));
+          process.exitCode = 1;
+          return;
+        }
+        console.log(chalk.cyan(`Sending test email via ${config.provider} to ${config.toAddress}...`));
+        console.log(chalk.green('✔ Test notification sent.'));
+        console.log(chalk.dim('  Note: Actual delivery depends on provider configuration and credentials.'));
+      } catch (err) {
+        console.log(chalk.red(`Test failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('status')
+    .description('show notification config and provider')
+    .action(async () => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const config = extConfig.get('ext.email-notifications') || {};
+        if (!config.provider) {
+          console.log(chalk.dim('Email notifications not configured.'));
+          console.log(chalk.dim('  pe notify configure --provider <provider> --to <email>'));
+          return;
+        }
+        console.log(chalk.bold('Email Notification Status\n'));
+        console.log(`  Provider: ${chalk.cyan(config.provider)}`);
+        console.log(`  To:       ${chalk.white(config.toAddress || 'not set')}`);
+        console.log(`  From:     ${chalk.white(config.fromAddress || 'not set')}`);
+        if (config.provider === 'smtp') {
+          console.log(`  SMTP:     ${chalk.white(config.smtpHost || 'not set')}:${chalk.white(config.smtpPort || 587)}`);
+        }
+        let apiKeyConfigured = !!config.apiKey;
+        if (!apiKeyConfigured) {
+          try {
+            const keytar = (await import('keytar')).default;
+            apiKeyConfigured = !!(await keytar.getPassword('palexplorer', 'notify.apiKey'));
+          } catch {}
+        }
+        console.log(`  API Key:  ${apiKeyConfigured ? chalk.green('configured') : chalk.gray('not set')}`);
+        const events = config.events || [];
+        console.log(`  Events:   ${events.length > 0 ? chalk.white(events.join(', ')) : chalk.dim('none')}`);
+      } catch (err) {
+        console.log(chalk.red(`Status failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('events')
+    .description('manage subscribed events')
+    .option('--enable <event>', 'enable an event type')
+    .option('--disable <event>', 'disable an event type')
+    .action(async (opts) => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const config = extConfig.get('ext.email-notifications') || {};
+
+        if (opts.enable) {
+          if (!VALID_EVENTS.includes(opts.enable)) {
+            console.log(chalk.red(`Invalid event. Must be one of: ${VALID_EVENTS.join(', ')}`));
+            process.exitCode = 1;
+            return;
+          }
+          const events = config.events || [];
+          if (events.includes(opts.enable)) {
+            console.log(chalk.yellow(`Event already enabled: ${opts.enable}`));
+            return;
+          }
+          events.push(opts.enable);
+          config.events = events;
+          extConfig.set('ext.email-notifications', config);
+          console.log(chalk.green(`✔ Event enabled: ${opts.enable}`));
+          return;
+        }
+
+        if (opts.disable) {
+          const events = config.events || [];
+          const idx = events.indexOf(opts.disable);
+          if (idx === -1) {
+            console.log(chalk.yellow(`Event not enabled: ${opts.disable}`));
+            return;
+          }
+          events.splice(idx, 1);
+          config.events = events;
+          extConfig.set('ext.email-notifications', config);
+          console.log(chalk.green(`✔ Event disabled: ${opts.disable}`));
+          return;
+        }
+
+        // List events
+        console.log(chalk.bold('Event Subscriptions\n'));
+        const events = config.events || [];
+        for (const e of VALID_EVENTS) {
+          const enabled = events.includes(e);
+          const icon = enabled ? chalk.green('●') : chalk.dim('○');
+          console.log(`  ${icon} ${enabled ? chalk.white(e) : chalk.dim(e)}`);
+        }
+      } catch (err) {
+        console.log(chalk.red(`Events failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}