pal-explorer-cli 0.4.0

package/lib/commands/scim.js

@@ -0,0 +1,203 @@
+import chalk from 'chalk';
+
+export default function scimCommand(program) {
+  const cmd = program
+    .command('scim')
+    .description('SCIM 2.0 provisioning server (Enterprise)')
+    .addHelpText('after', `
+Examples:
+  $ pe scim configure --token myBearerToken --port 7475
+  $ pe scim start                              Start SCIM server
+  $ pe scim stop                               Stop SCIM server
+  $ pe scim status                             Show server status
+  $ pe scim users                              List provisioned users
+  $ pe scim groups                             List provisioned groups
+`)
+    .action(() => { cmd.outputHelp(); });
+
+  cmd
+    .command('configure')
+    .description('set SCIM configuration')
+    .option('--token <bearerToken>', 'bearer token for auth')
+    .option('--port <port>', 'server port', '7475')
+    .option('--endpoint <path>', 'base path', '/scim/v2')
+    .action(async (opts) => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const existing = extConfig.get('ext.scim-provisioning') || {};
+        const token = opts.token || existing.bearerToken || null;
+        const config = {
+          ...existing,
+          bearerToken: null,
+          port: parseInt(opts.port, 10) || existing.port || 7475,
+          endpoint: opts.endpoint || existing.endpoint || '/scim/v2',
+          autoDeactivate: existing.autoDeactivate ?? true,
+        };
+
+        if (token) {
+          try {
+            const keytar = (await import('keytar')).default;
+            await keytar.setPassword('palexplorer', 'scim.token', token);
+          } catch {
+            config.bearerToken = token;
+          }
+        }
+
+        extConfig.set('ext.scim-provisioning', config);
+
+        console.log(chalk.green('✔ SCIM configuration updated'));
+        console.log(`  Port:     ${chalk.white(config.port)}`);
+        console.log(`  Endpoint: ${chalk.white(config.endpoint)}`);
+        console.log(`  Token:    ${token ? chalk.gray(token.slice(0, 8) + '...') : chalk.yellow('not set')}`);
+      } catch (err) {
+        console.error(chalk.red(`Configure failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('start')
+    .description('start SCIM server')
+    .action(async () => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const config = extConfig.get('ext.scim-provisioning') || {};
+
+        let hasToken = !!config.bearerToken;
+        if (!hasToken) {
+          try {
+            const keytar = (await import('keytar')).default;
+            hasToken = !!(await keytar.getPassword('palexplorer', 'scim.token'));
+          } catch {}
+        }
+        if (!hasToken) {
+          console.error(chalk.red('No bearer token configured. Run: pe scim configure --token <token>'));
+          process.exitCode = 1;
+          return;
+        }
+
+        config.running = true;
+        extConfig.set('ext.scim-provisioning', config);
+        console.log(chalk.green(`✔ SCIM server marked as running`));
+        console.log(`  Port:     ${chalk.white(config.port || 7475)}`);
+        console.log(`  Endpoint: ${chalk.white(config.endpoint || '/scim/v2')}`);
+        console.log(chalk.gray('  Server lifecycle managed by extension on app startup.'));
+      } catch (err) {
+        console.error(chalk.red(`Start failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('stop')
+    .description('stop SCIM server')
+    .action(async () => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const config = extConfig.get('ext.scim-provisioning') || {};
+        config.running = false;
+        extConfig.set('ext.scim-provisioning', config);
+        console.log(chalk.green('✔ SCIM server marked as stopped'));
+      } catch (err) {
+        console.error(chalk.red(`Stop failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('status')
+    .description('show server status')
+    .action(async () => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const config = extConfig.get('ext.scim-provisioning') || {};
+        const store = extConfig.get('ext_store.scim-provisioning') || {};
+
+        const userCount = Object.keys(store).filter(k => k.startsWith('scim:user:')).length;
+        const groupCount = Object.keys(store).filter(k => k.startsWith('scim:group:')).length;
+
+        console.log('');
+        console.log(chalk.cyan.bold('SCIM Server Status'));
+        console.log(chalk.gray('─'.repeat(40)));
+        console.log(`  Status:   ${config.running ? chalk.green('running') : chalk.red('stopped')}`);
+        console.log(`  Port:     ${chalk.white(config.port || 7475)}`);
+        console.log(`  Endpoint: ${chalk.white(config.endpoint || '/scim/v2')}`);
+        let tokenConfigured = !!config.bearerToken;
+        if (!tokenConfigured) {
+          try {
+            const keytar = (await import('keytar')).default;
+            tokenConfigured = !!(await keytar.getPassword('palexplorer', 'scim.token'));
+          } catch {}
+        }
+        console.log(`  Token:    ${tokenConfigured ? chalk.green('configured') : chalk.yellow('not set')}`);
+        console.log(`  Users:    ${chalk.white(userCount)}`);
+        console.log(`  Groups:   ${chalk.white(groupCount)}`);
+        console.log('');
+      } catch (err) {
+        console.error(chalk.red(`Status failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('users')
+    .description('list provisioned users')
+    .action(async () => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const store = extConfig.get('ext_store.scim-provisioning') || {};
+        const users = Object.entries(store)
+          .filter(([k]) => k.startsWith('scim:user:'))
+          .map(([, v]) => v);
+
+        if (!users.length) {
+          console.log(chalk.gray('No provisioned users.'));
+          return;
+        }
+
+        console.log('');
+        console.log(chalk.cyan.bold('Provisioned Users'));
+        console.log(chalk.gray('─'.repeat(50)));
+        for (const user of users) {
+          const status = user.active !== false ? chalk.green('active') : chalk.red('deactivated');
+          console.log(`  ${chalk.white(user.displayName || user.userName || user.id)} ${status}`);
+          if (user.userName) console.log(`    Username: ${chalk.gray(user.userName)}`);
+          if (user.email) console.log(`    Email:    ${chalk.gray(user.email)}`);
+        }
+        console.log('');
+      } catch (err) {
+        console.error(chalk.red(`Users failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command('groups')
+    .description('list provisioned groups')
+    .action(async () => {
+      try {
+        const extConfig = (await import('../utils/config.js')).default;
+        const store = extConfig.get('ext_store.scim-provisioning') || {};
+        const groups = Object.entries(store)
+          .filter(([k]) => k.startsWith('scim:group:'))
+          .map(([, v]) => v);
+
+        if (!groups.length) {
+          console.log(chalk.gray('No provisioned groups.'));
+          return;
+        }
+
+        console.log('');
+        console.log(chalk.cyan.bold('Provisioned Groups'));
+        console.log(chalk.gray('─'.repeat(50)));
+        for (const group of groups) {
+          const memberCount = group.members?.length || 0;
+          console.log(`  ${chalk.white(group.displayName || group.id)} ${chalk.gray(`(${memberCount} members)`)}`);
+        }
+        console.log('');
+      } catch (err) {
+        console.error(chalk.red(`Groups failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/lib/commands/search.js

@@ -0,0 +1,181 @@
+import chalk from 'chalk';
+import { getIdentity } from '../core/identity.js';
+import { getPrimaryServer } from '../core/discoveryClient.js';
+import { formatSize } from '../utils/format.js';
+
+function truncate(str, len) {
+  if (!str) return '';
+  return str.length > len ? str.slice(0, len - 1) + '\u2026' : str;
+}
+
+export default function searchCommand(program) {
+  program
+    .command('search <query>')
+    .description('search for files, pals, or groups on the network')
+    .option('--kind <kind>', 'Search kind: files, pals, or groups', 'files')
+    .option('--scope <scope>', 'Search scope: public, group, or pal', 'public')
+    .option('--type <type>', 'File type: file or directory')
+    .option('--category <cat>', 'Category: documents, images, music, video, archives, code')
+    .option('--extension <ext>', 'Filter by file extension')
+    .option('--min-size <mb>', 'Minimum size in MB', parseFloat)
+    .option('--max-size <mb>', 'Maximum size in MB', parseFloat)
+    .option('--after <date>', 'Files shared after date (YYYY-MM-DD)')
+    .option('--before <date>', 'Files shared before date (YYYY-MM-DD)')
+    .option('--case-sensitive', 'Case-sensitive search')
+    .option('--sort <field>', 'Sort by: name, date, size, relevance', 'relevance')
+    .option('--limit <n>', 'Max results', parseInt, 20)
+    .addHelpText('after', `
+Examples:
+  $ pe search "project plans"                    Search public shares
+  $ pe search "alice" --kind pals                Search for users
+  $ pe search "linux" --kind groups              Search for groups
+  $ pe search "*.pdf" --category documents       Search for PDFs
+`)
+    .action(async (query, opts) => {
+      try {
+        const identity = await getIdentity();
+        const server = getPrimaryServer();
+        const jsonMode = program.opts().json;
+
+        if (opts.kind === 'pals') {
+          const res = await fetch(`${server}/api/v1/directory?q=${encodeURIComponent(query)}`, {
+            signal: AbortSignal.timeout(10000),
+          });
+          if (!res.ok) throw new Error(`Search failed: ${res.statusText}`);
+          const data = await res.json();
+          const results = data.results || [];
+          if (results.length === 0) {
+            if (jsonMode) { console.log(JSON.stringify({ kind: 'pals', query, results: [] }, null, 2)); return; }
+            console.log(chalk.gray(`No pals found for "${query}".`));
+            return;
+          }
+          if (jsonMode) {
+            console.log(JSON.stringify({ kind: 'pals', query, results }, null, 2));
+            return;
+          }
+          console.log('');
+          console.log(chalk.cyan('Handle'.padEnd(20) + 'Public Key'));
+          console.log(chalk.gray('-'.repeat(60)));
+          for (const r of results) {
+            console.log(`${chalk.white(`@${r.handle}`).padEnd(20)}${chalk.gray(r.publicKey)}`);
+          }
+          console.log(chalk.gray(`\n${results.length} result(s)`));
+          return;
+        }
+
+        if (opts.kind === 'groups') {
+          const res = await fetch(`${server}/api/v1/groups/search?q=${encodeURIComponent(query)}`, {
+            signal: AbortSignal.timeout(10000),
+          });
+          if (!res.ok) throw new Error(`Search failed: ${res.statusText}`);
+          const data = await res.json();
+          const results = data.results || [];
+          if (results.length === 0) {
+            if (jsonMode) { console.log(JSON.stringify({ kind: 'groups', query, results: [] }, null, 2)); return; }
+            console.log(chalk.gray(`No groups found for "${query}".`));
+            return;
+          }
+          if (jsonMode) {
+            console.log(JSON.stringify({ kind: 'groups', query, results }, null, 2));
+            return;
+          }
+          console.log('');
+          console.log(chalk.cyan('Group Name'.padEnd(30) + 'Members'.padEnd(10) + 'Owner'));
+          console.log(chalk.gray('-'.repeat(65)));
+          for (const r of results) {
+            const name = truncate(r.name, 29).padEnd(30);
+            const members = String(r.memberCount || 0).padEnd(10);
+            const owner = r.ownerHandle ? `@${r.ownerHandle}` : r.owner.slice(0, 16) + '...';
+            console.log(`${chalk.white(name)}${chalk.yellow(members)}${chalk.cyan(owner)}`);
+            if (r.description) console.log(chalk.gray(`  > ${truncate(r.description, 60)}`));
+          }
+          console.log(chalk.gray(`\n${results.length} result(s)`));
+          return;
+        }
+
+        // Default: kind === 'files'
+        const params = new URLSearchParams({ q: query });
+        if (opts.scope) params.set('scope', opts.scope);
+        if (opts.type) params.set('type', opts.type);
+        if (opts.category) params.set('category', opts.category);
+        if (opts.extension) params.set('extension', opts.extension);
+        if (opts.minSize) params.set('minSize', opts.minSize);
+        if (opts.maxSize) params.set('maxSize', opts.maxSize);
+        if (opts.after) params.set('after', opts.after);
+        if (opts.before) params.set('before', opts.before);
+        if (opts.caseSensitive) params.set('caseSensitive', 'true');
+        if (opts.sort) params.set('sort', opts.sort);
+        if (opts.limit) params.set('limit', opts.limit);
+
+        const headers = {};
+        if (identity?.publicKey) headers['X-Public-Key'] = identity.publicKey;
+        if (identity?.handle) headers['X-Handle'] = identity.handle;
+
+        const res = await fetch(`${server}/api/v1/search?${params}`, {
+          headers,
+          signal: AbortSignal.timeout(15000),
+        });
+
+        if (!res.ok) {
+          const err = await res.json().catch(() => ({}));
+          console.log(chalk.red(`Search failed: ${err.error || res.statusText}`));
+          process.exitCode = 1;
+          return;
+        }
+
+        const data = await res.json();
+        const results = data.results || data;
+
+        if (!Array.isArray(results) || results.length === 0) {
+          if (jsonMode) { console.log(JSON.stringify({ kind: 'files', query, results: [], total: 0 }, null, 2)); return; }
+          console.log(chalk.gray(`No results for "${query}".`));
+          return;
+        }
+
+        if (jsonMode) {
+          console.log(JSON.stringify({ kind: 'files', query, results, total: data.total || results.length }, null, 2));
+          return;
+        }
+
+        const nameW = 35;
+        const sizeW = 10;
+        const typeW = 10;
+        const ownerW = 15;
+        const dateW = 12;
+        const seedW = 7;
+
+        console.log('');
+        console.log(
+          chalk.cyan(
+            'Name'.padEnd(nameW) +
+            'Size'.padEnd(sizeW) +
+            'Type'.padEnd(typeW) +
+            'Owner'.padEnd(ownerW) +
+            'Date'.padEnd(dateW) +
+            'Seeders'
+          )
+        );
+        console.log(chalk.gray('-'.repeat(nameW + sizeW + typeW + ownerW + dateW + seedW)));
+
+        for (const r of results) {
+          const name = truncate(r.name || r.filename || '?', nameW - 1).padEnd(nameW);
+          const size = formatSize(r.size).padEnd(sizeW);
+          const type = (r.type || r.category || '-').padEnd(typeW);
+          const owner = truncate(r.owner || r.handle || '-', ownerW - 1).padEnd(ownerW);
+          const date = r.date || r.sharedAt ? new Date(r.date || r.sharedAt).toLocaleDateString() : '-';
+          const seeders = r.seeders != null ? String(r.seeders) : '-';
+
+          console.log(
+            `${chalk.white(name)}${chalk.yellow(size)}${chalk.gray(type)}${chalk.cyan(owner)}${chalk.gray(date.padEnd(dateW))}${chalk.green(seeders)}`
+          );
+        }
+
+        console.log('');
+        const total = data.total || results.length;
+        console.log(chalk.gray(`${results.length} result(s)${total > results.length ? ` of ${total} total` : ''}`));
+      } catch (err) {
+        console.log(chalk.red(`Error: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}