pal-explorer-cli 0.4.0

package/lib/commands/group.js

@@ -0,0 +1,271 @@
+import chalk from 'chalk';
+import { getFriends } from '../core/users.js';
+import config from '../utils/config.js';
+import { getIdentity } from '../core/identity.js';
+import {
+  getGroups,
+  getGroup,
+  getGroupMembers,
+  createGroup,
+  updateGroup,
+  addMemberToGroup,
+  removeMemberFromGroup,
+  deleteGroup
+} from '../core/groups.js';
+import { checkLimit } from '../core/pro.js';
+import { announceGroups } from '../core/discoveryClient.js';
+
+export default function groupCommand(program) {
+  const cmd = program
+    .command('group')
+    .description('manage sharing groups')
+    .addHelpText('after', `
+Examples:
+  $ pe group create team --public    Create a public group called "team"
+  $ pe group edit team --desc "info" Edit group description
+  $ pe group add team @alice        Add alice to the group
+  $ pe group remove team @alice     Remove alice from the group
+  $ pe group list                   List all groups
+  $ pe group announce               Announce public groups to discovery server
+  $ pe group delete team            Delete a group
+`);
+
+  cmd
+    .command('create <name>')
+    .description('create a new group')
+    .option('--public', 'Make group discoverable by others')
+    .option('--desc <description>', 'Group description')
+    .action((name, opts) => {
+      if (!name || !name.trim()) {
+        console.log(chalk.red('Group name cannot be empty.'));
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        const groups = getGroups();
+        checkLimit('maxGroups', groups.length);
+        const identity = config.get('identity');
+        const group = createGroup(name, identity?.publicKey, {
+          visibility: opts.public ? 'public' : 'private',
+          description: opts.desc || null
+        });
+        console.log(chalk.green(`Group '${name}' created.`));
+        if (opts.public) {
+          console.log(chalk.yellow('Note: Public groups are discoverable. Use `pe group announce` to publish.'));
+        }
+        console.log(chalk.gray(`ID: ${group.id}`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('edit <group>')
+    .description('edit a group (rename, description, visibility)')
+    .option('--name <name>', 'New group name')
+    .option('--desc <description>', 'Group description')
+    .option('--public', 'Make group public')
+    .option('--private', 'Make group private')
+    .action((groupName, opts) => {
+      try {
+        if (!opts.name && !opts.desc && !opts.public && !opts.private) {
+          console.log(chalk.yellow('Specify at least one option to update.'));
+          process.exitCode = 1;
+          return;
+        }
+        const identity = config.get('identity');
+        const updates = {};
+        if (opts.name) updates.name = opts.name;
+        if (opts.desc) updates.description = opts.desc;
+        if (opts.public) updates.visibility = 'public';
+        if (opts.private) updates.visibility = 'private';
+        const group = updateGroup(groupName, updates, identity?.publicKey);
+        console.log(chalk.green(`Group '${group.name}' updated.`));
+        if (group.visibility === 'public') {
+          console.log(chalk.yellow('Remember to run `pe group announce` to sync changes to discovery server.'));
+        }
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('announce')
+    .description('announce public groups to the primary discovery server')
+    .action(async () => {
+      try {
+        const groups = getGroups();
+        const publicGroups = groups.filter(g => g.visibility === 'public');
+        if (publicGroups.length === 0) {
+          console.log(chalk.yellow('No public groups to announce.'));
+          return;
+        }
+        process.stdout.write(chalk.gray(`Announcing ${publicGroups.length} public group(s)... `));
+        const res = await announceGroups(groups);
+        if (res && res.success) {
+          console.log(chalk.green('done.'));
+        } else {
+          console.log(chalk.red('failed.'));
+          process.exitCode = 1;
+        }
+      } catch (err) {
+        console.log(chalk.red(`\nError: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('add <group> <pal>')
+    .description('add a pal to a group')
+    .action((groupName, palName) => {
+      const friends = getFriends();
+      const stripped = palName.replace(/^@/, '');
+      const pal = friends.find(f =>
+        f.name === palName || f.id === palName || f.handle === palName || f.publicKey === palName ||
+        f.name === stripped || f.id === stripped || f.handle === stripped || f.publicKey === stripped
+      );
+      if (!pal) {
+        console.log(chalk.red(`Pal '${palName}' not found. Add them first with \`pe pal add\`.`));
+        process.exitCode = 1;
+        return;
+      }
+      try {
+        const members = getGroupMembers(groupName);
+        checkLimit('maxGroupMembers', members.length);
+        addMemberToGroup(groupName, pal);
+        console.log(chalk.green(`Added '${pal.name}' to '${groupName}'.`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('remove <group> <pal>')
+    .description('remove a pal from a group')
+    .action((groupName, palName) => {
+      try {
+        removeMemberFromGroup(groupName, palName);
+        console.log(chalk.green(`Removed '${palName}' from '${groupName}'.`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('delete <group>')
+    .description('delete a group')
+    .action((groupName) => {
+      const group = getGroup(groupName);
+      if (!group) {
+        console.log(chalk.red(`Group '${groupName}' not found.`));
+        process.exitCode = 1;
+        return;
+      }
+      const identity = config.get('identity');
+      deleteGroup(groupName, identity?.publicKey);
+      console.log(chalk.green(`Group '${group.name}' deleted.`));
+    });
+
+  cmd
+    .command('list')
+    .description('list all groups')
+    .action(() => {
+      const groups = getGroups();
+      if (program.opts().json) {
+        console.log(JSON.stringify({ groups }, null, 2));
+        return;
+      }
+      if (groups.length === 0) {
+        console.log(chalk.gray('No groups. Create one with `pe group create <name>`.'));
+        return;
+      }
+      console.log('');
+      console.log(chalk.cyan('Groups:'));
+      for (const g of groups) {
+        console.log(`  ${chalk.white(g.name)}  ${chalk.gray(`(${g.members.length} members)`)}`);
+        for (const m of g.members) {
+          console.log(`    - ${m.name}${m.handle ? chalk.gray(` @${m.handle}`) : ''}`);
+        }
+      }
+      console.log('');
+    });
+
+  cmd
+    .command('broadcast <group> <message>')
+    .description('send a message to all group members')
+    .action(async (groupName, message) => {
+      try {
+        const group = getGroup(groupName);
+        if (!group) {
+          console.log(chalk.red(`Group '${groupName}' not found.`));
+          process.exitCode = 1;
+          return;
+        }
+        if (group.members.length === 0) {
+          console.log(chalk.yellow(`Group '${group.name}' has no members.`));
+          return;
+        }
+        const identity = await getIdentity();
+        if (!identity?.handle) {
+          console.log(chalk.red('You must register a handle first: pe register'));
+          process.exitCode = 1;
+          return;
+        }
+        const { getPrimaryServer } = await import('../core/discoveryClient.js');
+        const discoveryUrl = config.get('settings')?.discovery_servers?.[0]
+          || config.get('settings')?.discovery_url
+          || process.env.PAL_DISCOVERY_URL
+          || getPrimaryServer();
+
+        let sent = 0;
+        let failed = 0;
+        for (const member of group.members) {
+          const handle = member.handle;
+          if (!handle) {
+            console.log(chalk.yellow(`  Skipping ${member.name} (no handle)`));
+            failed++;
+            continue;
+          }
+          try {
+            const res = await fetch(`${discoveryUrl}/api/v1/messages`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                toHandle: handle,
+                fromHandle: identity.handle,
+                fromDeviceId: identity.deviceId || null,
+                payload: { type: 'chat', text: message, timestamp: Date.now() },
+              }),
+              signal: AbortSignal.timeout(10000),
+            });
+            if (res.ok) {
+              sent++;
+            } else {
+              console.log(chalk.yellow(`  Failed to send to @${handle}`));
+              failed++;
+            }
+          } catch {
+            console.log(chalk.yellow(`  Failed to send to @${handle}`));
+            failed++;
+          }
+        }
+        console.log(chalk.green(`Broadcast to '${group.name}': ${sent} sent, ${failed} failed.`));
+      } catch (err) {
+        console.log(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd.action(() => {
+    const groups = getGroups();
+    if (groups.length === 0) {
+      console.log(chalk.gray('No groups. Create one with `pe group create <name>`.'));
+    } else {
+      console.log(chalk.cyan(`${groups.length} group(s). Use \`pe group list\` for details.`));
+    }
+  });
+}

package/lib/commands/gui-share.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default function guiShareCommand(program) {
+  program
+    .command('gui-share <path>')
+    .description('internal: Open GUI to share a specific file/folder')
+    .action((filePath) => {
+      const fullPath = path.resolve(filePath);
+      console.log(chalk.cyan(`Opening Palexplorer to share: ${fullPath}`));
+      
+      // In a real app, we'd check if Electron is already running and send an IPC message
+      // For now, we'll just launch the GUI with an environment variable or argument
+      const guiPath = path.resolve(__dirname, '../../gui');
+      
+      const child = spawn('npm', ['run', 'electron', '--', `--share=${fullPath}`], {
+        cwd: guiPath,
+        detached: true,
+        stdio: 'ignore',
+      });
+
+      child.unref();
+      process.exit(0);
+    });
+}

package/lib/commands/init.js

@@ -0,0 +1,61 @@
+import { createIdentity } from '../core/identity.js';
+import { addProfile, getProfiles, migrateToMultiUser } from '../core/users.js';
+import config from '../utils/config.js';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export default function initCommand(program) {
+  program
+    .command('init <name>')
+    .description('create a new Pal Explorer identity with a name')
+    .option('-f, --force', 'Overwrite existing identity')
+    .addHelpText('after', `
+Examples:
+  $ pe init alice                   Create identity as "alice"
+  $ pe init bob --force             Overwrite existing identity
+`)
+    .action(async (name, options) => {
+      const spinner = ora('Initializing Identity...').start();
+      try {
+        const id = await createIdentity(name, options);
+
+        // Create user profile (owner if first user, otherwise member)
+        migrateToMultiUser();
+        const profiles = getProfiles();
+        const isFirst = profiles.length === 0 || (profiles.length === 1 && profiles[0].publicKey === id.publicKey);
+        const role = isFirst ? 'owner' : 'user';
+        try {
+          addProfile(id.publicKey, null, name, role);
+        } catch {
+          // Profile may already exist from migration
+        }
+
+        spinner.succeed(chalk.green(`Identity Created for '${name}'!`));
+        console.log(chalk.cyan(`Your Public Key (ID): ${id.publicKey}`));
+        if (role === 'owner') {
+          console.log(chalk.yellow(`Role: Owner (full control)`));
+        }
+        console.log(chalk.gray('Next: Run `pe register <handle>` to claim your handle.'));
+        console.log('');
+        console.log(chalk.bgYellow.black(' RECOVERY PHRASE — WRITE THIS DOWN AND KEEP IT SAFE '));
+        console.log(chalk.yellow(id.mnemonic));
+        console.log(chalk.red('This will NOT be shown again. Use `pe recover` to restore your identity.'));
+
+        // Opt-in to error reporting (first-time setup)
+        const settings = config.get('settings') || {};
+        if (settings.errorReportingEnabled === undefined) {
+          console.log('');
+          console.log(chalk.cyan('Help improve Palexplorer?'));
+          console.log(chalk.gray('Automatically send anonymous crash reports and errors to help us fix bugs.'));
+          console.log(chalk.gray('No personal data, files, or encryption keys are ever sent.'));
+          console.log(chalk.gray('You can change this anytime: pe config set errorReportingEnabled false'));
+          settings.errorReportingEnabled = true;
+          config.set('settings', settings);
+          console.log(chalk.green('✔ Error reporting enabled (opt-out: pe config set errorReportingEnabled false)'));
+        }
+      } catch (err) {
+        spinner.fail(chalk.red('Initialization Failed'));
+        console.error(chalk.red(`Error: ${err.message}`));
+      }
+    });
+}

package/lib/commands/invite.js

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import qrcode from 'qrcode-terminal';
+import { getIdentity } from '../core/identity.js';
+
+export function encodeInvite(identity) {
+  const payload = JSON.stringify({
+    pk: identity.publicKey,
+    h: identity.handle || null,
+    n: identity.name || null
+  });
+  return 'pal://' + Buffer.from(payload).toString('base64url');
+}
+
+export function decodeInvite(url) {
+  if (!url.startsWith('pal://')) return null;
+  try {
+    const raw = Buffer.from(url.slice(6), 'base64url').toString('utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed.pk || typeof parsed.pk !== 'string') return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export default function inviteCommand(program) {
+  program
+    .command('invite')
+    .description('generate a magic invite link so others can add you as a pal')
+    .option('--qr', 'Also render the invite as a QR code in the terminal')
+    .addHelpText('after', `
+Examples:
+  $ pe invite                       Generate invite link
+  $ pe invite --qr                  Show invite as QR code
+`)
+    .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 url = encodeInvite(identity);
+
+      console.log('');
+      console.log(chalk.cyan('Your invite link:'));
+      console.log(chalk.white(url));
+      console.log('');
+      console.log(chalk.gray('Share this over any channel. Recipient runs:'));
+      console.log(chalk.white(`  pe pal add ${url}`));
+
+      if (opts.qr) {
+        console.log('');
+        console.log(chalk.cyan('QR Code:'));
+        qrcode.generate(url, { small: true });
+      }
+    });
+}

package/lib/commands/list.js

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import { listShares, getSharesByDrive } from '../core/shares.js';
+
+export default function listCommand(program) {
+  program
+    .command('list')
+    .description('list shared resources')
+    .option('--by-drive', 'Group shares by drive')
+    .addHelpText('after', `
+Examples:
+  $ pe list                         List all shared resources
+`)
+    .action((options) => {
+      const shares = listShares();
+      if (program.opts().json) {
+        const safe = shares.map(s => {
+          const { password, encryptedShareKeys, ...rest } = s;
+          return { ...rest, password: password ? '***' : undefined };
+        });
+        console.log(JSON.stringify(safe, null, 2));
+        return;
+      }
+      if (shares.length === 0) {
+        console.log(chalk.gray('No shared resources found. Use `pe share <path>` to add one.'));
+        return;
+      }
+
+      if (options.byDrive) {
+        const byDrive = getSharesByDrive();
+        Object.keys(byDrive).forEach(drive => {
+          console.log(''); // New line
+          console.log(chalk.yellow(`Drive: ${drive}`));
+          byDrive[drive].forEach(share => {
+            const vis = share.visibility || 'global';
+            const visColors = { global: 'green', public: 'green', private: 'red', group: 'blue', network: 'cyan', 'link-only': 'yellow' };
+            const visibilityStr = chalk[visColors[vis] || 'white'](`[${vis.toUpperCase()}]`);
+            const streamTag = share.streamable ? chalk.magenta(' [STREAM]') : '';
+            const expiredTag = share.expired ? chalk.red(' [EXPIRED]') : '';
+            console.log(`  - ${visibilityStr}${streamTag}${expiredTag} [${chalk.cyan(share.id)}] ${share.path} (${chalk.gray(share.type)})`);
+          });
+        });
+      } else {
+        console.log(''); // New line
+        console.log(chalk.green('Active Shares:'));
+        shares.forEach(share => {
+          const vis = share.visibility || 'global';
+          const visColors = { global: 'green', public: 'green', private: 'red', group: 'blue', network: 'cyan', 'link-only': 'yellow' };
+          const visibilityStr = chalk[visColors[vis] || 'white'](`[${vis.toUpperCase()}]`);
+          const streamTag = share.streamable ? chalk.magenta(' [STREAM]') : '';
+          const recipCount = (share.recipients || []).length;
+          const recipStr = recipCount > 0 ? chalk.gray(` → ${recipCount} recipient${recipCount > 1 ? 's' : ''}`) : '';
+          const expiredTag = share.expired ? chalk.red(' [EXPIRED]') : '';
+          const expiryStr = share.expiresAt && !share.expired ? chalk.gray(` expires ${new Date(share.expiresAt).toLocaleDateString()}`) : '';
+          const dlStr = share.maxDownloads ? chalk.gray(` ${share.downloads || 0}/${share.maxDownloads} downloads`) : '';
+          console.log(`- ${visibilityStr}${streamTag}${expiredTag} [${chalk.cyan(share.id)}] ${share.path} (${chalk.gray(share.type)})${recipStr}${expiryStr}${dlStr}`);
+        });
+      }
+    });
+}

package/lib/commands/log.js

@@ -0,0 +1,116 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const LOG_DIR = path.join(os.homedir(), '.pal', 'logs');
+const LOG_FILE = path.join(LOG_DIR, 'pal.log');
+
+function colorLevel(level) {
+  switch (level) {
+    case 'error': return chalk.red(level);
+    case 'warn': return chalk.yellow(level);
+    case 'info': return chalk.blue(level);
+    case 'debug': return chalk.gray(level);
+    default: return level;
+  }
+}
+
+function formatEntry(line) {
+  try {
+    const entry = JSON.parse(line);
+    const ts = entry.ts?.slice(11, 19) || '';
+    return `${chalk.gray(ts)} ${colorLevel(entry.level).padEnd(15)} ${entry.msg}`;
+  } catch {
+    return line;
+  }
+}
+
+export default function logCommand(program) {
+  program
+    .command('log')
+    .description('view application logs')
+    .option('--tail', 'Follow new log entries')
+    .option('--level <level>', 'Filter by level (debug/info/warn/error)')
+    .option('-n, --lines <count>', 'Number of recent lines to show', '20')
+    .option('--clear', 'Clear the log file')
+    .addHelpText('after', `
+Examples:
+  $ pe log                          Show recent log entries
+  $ pe log --tail                   Follow log in real-time
+  $ pe log --level error            Filter by log level
+  $ pe log -n 50                    Show last 50 entries
+`)
+    .action(async (opts) => {
+      try {
+      if (opts.clear) {
+        if (fs.existsSync(LOG_FILE)) {
+          fs.writeFileSync(LOG_FILE, '');
+          console.log(chalk.green('✔ Log file cleared.'));
+        } else {
+          console.log(chalk.gray('No log file to clear.'));
+        }
+        return;
+      }
+
+      if (!fs.existsSync(LOG_FILE)) {
+        console.log(chalk.gray('No log file found. Logs will appear after using commands.'));
+        return;
+      }
+
+      const content = fs.readFileSync(LOG_FILE, 'utf8').trim();
+      if (!content) {
+        console.log(chalk.gray('Log file is empty.'));
+        return;
+      }
+
+      let lines = content.split('\n');
+
+      if (opts.level) {
+        lines = lines.filter(line => {
+          try {
+            const entry = JSON.parse(line);
+            return entry.level === opts.level;
+          } catch { return true; }
+        });
+      }
+
+      const count = parseInt(opts.lines, 10) || 20;
+      lines = lines.slice(-count);
+
+      for (const line of lines) {
+        console.log(formatEntry(line));
+      }
+
+      if (opts.tail) {
+        console.log(chalk.gray('--- tailing (Ctrl+C to stop) ---'));
+        let size = fs.statSync(LOG_FILE).size;
+        const watcher = fs.watch(LOG_FILE, () => {
+          try {
+            const newSize = fs.statSync(LOG_FILE).size;
+            if (newSize <= size) { size = newSize; return; }
+            const fd = fs.openSync(LOG_FILE, 'r');
+            const buf = Buffer.alloc(newSize - size);
+            fs.readSync(fd, buf, 0, buf.length, size);
+            fs.closeSync(fd);
+            size = newSize;
+            const newLines = buf.toString().trim().split('\n');
+            for (const line of newLines) {
+              if (opts.level) {
+                try {
+                  const entry = JSON.parse(line);
+                  if (entry.level !== opts.level) continue;
+                } catch { /* show anyway */ }
+              }
+              console.log(formatEntry(line));
+            }
+          } catch { /* ignore */ }
+        });
+        await new Promise(() => {}); // block forever
+      }
+      } catch (err) {
+        console.error(chalk.red('Log viewer error:'), err.message);
+        process.exitCode = 1;
+      }
+    });
+}