pal-explorer-cli 0.4.0

package/lib/commands/file.js

@@ -0,0 +1,533 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { requireIdentity, checkPathAccess, auditLog } from '../core/permissions.js';
+import { formatSize } from '../utils/format.js';
+import { printJson } from '../utils/cli.js';
+
+function formatDate(date) {
+  return new Date(date).toLocaleString();
+}
+
+export default function fileCommand(program) {
+  const file = program
+    .command('file')
+    .description('file operations with Palexplorer permissions')
+    .addHelpText('after', `
+Examples:
+  $ pe file ls /path/to/dir           List directory contents
+  $ pe file tree /path/to/dir         Show directory tree
+  $ pe file info /path/to/file        Show file properties
+  $ pe file copy src dest             Copy file or directory
+  $ pe file move src dest             Move file or directory
+  $ pe file rename old new            Rename file or directory
+  $ pe file mkdir /path/to/dir        Create directory
+  $ pe file delete /path/to/file      Delete file or directory
+  $ pe file search pattern [dir]      Search files by name pattern
+  $ pe file open /path/to/file        Open file with OS default app
+  $ pe file reveal /path/to/file      Show file in OS file explorer
+`);
+
+  // ── ls ──────────────────────────────────────────────────────────────────
+  file
+    .command('ls [dir]')
+    .description('list directory contents')
+    .option('-a, --all', 'Show hidden files')
+    .option('-l, --long', 'Detailed list with sizes and dates')
+    .option('-s, --sort <field>', 'Sort by: name, size, date', 'name')
+    .option('--json', 'Output as JSON')
+    .action(async (dir, opts) => {
+      try {
+        requireIdentity();
+        const targetDir = path.resolve(dir || '.');
+        checkPathAccess(targetDir, 'read');
+
+        const entries = fs.readdirSync(targetDir, { withFileTypes: true });
+        let items = entries
+          .filter(e => opts.all || !e.name.startsWith('.'))
+          .map(e => {
+            const fullPath = path.join(targetDir, e.name);
+            let stat = null;
+            try { stat = fs.statSync(fullPath); } catch {}
+            return {
+              name: e.name,
+              isDirectory: e.isDirectory(),
+              size: stat?.size || 0,
+              modified: stat?.mtime?.toISOString() || null,
+            };
+          });
+
+        if (opts.sort === 'size') items.sort((a, b) => b.size - a.size);
+        else if (opts.sort === 'date') items.sort((a, b) => new Date(b.modified) - new Date(a.modified));
+        else items.sort((a, b) => a.name.localeCompare(b.name));
+
+        // Directories first
+        items.sort((a, b) => (b.isDirectory ? 1 : 0) - (a.isDirectory ? 1 : 0));
+
+        if (opts.json || program.opts().json) { printJson(items); return; }
+
+        console.log(chalk.gray(`  ${targetDir}\n`));
+
+        if (items.length === 0) {
+          console.log(chalk.dim('  (empty directory)'));
+          return;
+        }
+
+        if (opts.long) {
+          const maxNameLen = Math.max(...items.map(i => i.name.length), 4);
+          for (const item of items) {
+            const icon = item.isDirectory ? chalk.blue('DIR ') : chalk.gray('FILE');
+            const size = item.isDirectory ? chalk.dim('       -') : chalk.yellow(formatSize(item.size).padStart(8));
+            const date = item.modified ? chalk.dim(formatDate(item.modified)) : '';
+            const name = item.isDirectory ? chalk.blue.bold(item.name) : item.name;
+            console.log(`  ${icon}  ${size}  ${date}  ${name}`);
+          }
+        } else {
+          for (const item of items) {
+            const name = item.isDirectory ? chalk.blue.bold(item.name + '/') : item.name;
+            process.stdout.write('  ' + name + '\n');
+          }
+        }
+
+        const dirs = items.filter(i => i.isDirectory).length;
+        const files = items.length - dirs;
+        console.log(chalk.dim(`\n  ${dirs} folder${dirs !== 1 ? 's' : ''}, ${files} file${files !== 1 ? 's' : ''}`));
+
+        auditLog('file.ls', { path: targetDir });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── tree ────────────────────────────────────────────────────────────────
+  file
+    .command('tree [dir]')
+    .description('show directory tree')
+    .option('-d, --depth <n>', 'Max depth', '3')
+    .option('--dirs-only', 'Show only directories')
+    .action(async (dir, opts) => {
+      try {
+        requireIdentity();
+        const targetDir = path.resolve(dir || '.');
+        checkPathAccess(targetDir, 'read');
+        const maxDepth = parseInt(opts.depth, 10);
+        let fileCount = 0, dirCount = 0;
+
+        function walk(dirPath, prefix, depth) {
+          if (depth > maxDepth) return;
+          let entries;
+          try { entries = fs.readdirSync(dirPath, { withFileTypes: true }); } catch { return; }
+          entries = entries.filter(e => !e.name.startsWith('.'));
+          entries.sort((a, b) => {
+            if (a.isDirectory() !== b.isDirectory()) return b.isDirectory() ? 1 : -1;
+            return a.name.localeCompare(b.name);
+          });
+
+          if (opts.dirsOnly) entries = entries.filter(e => e.isDirectory());
+
+          entries.forEach((entry, idx) => {
+            const isLast = idx === entries.length - 1;
+            const connector = isLast ? '└── ' : '├── ';
+            const name = entry.isDirectory()
+              ? chalk.blue.bold(entry.name + '/')
+              : entry.name;
+            console.log(prefix + connector + name);
+            if (entry.isDirectory()) {
+              dirCount++;
+              walk(path.join(dirPath, entry.name), prefix + (isLast ? '    ' : '│   '), depth + 1);
+            } else {
+              fileCount++;
+            }
+          });
+        }
+
+        console.log(chalk.blue.bold(path.basename(targetDir) + '/'));
+        walk(targetDir, '', 1);
+        console.log(chalk.dim(`\n${dirCount} directories, ${fileCount} files`));
+        auditLog('file.tree', { path: targetDir });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── info ────────────────────────────────────────────────────────────────
+  file
+    .command('info <target>')
+    .description('show file or directory properties')
+    .option('--json', 'Output as JSON')
+    .action(async (target, opts) => {
+      try {
+        requireIdentity();
+        const resolved = path.resolve(target);
+        const access = checkPathAccess(resolved, 'read');
+        const stat = fs.statSync(resolved);
+
+        const props = {
+          name: path.basename(resolved),
+          path: resolved,
+          type: stat.isDirectory() ? 'directory' : 'file',
+          size: stat.size,
+          created: stat.birthtime.toISOString(),
+          modified: stat.mtime.toISOString(),
+          accessed: stat.atime.toISOString(),
+          readonly: !(stat.mode & 0o200),
+          isShared: access.isShared,
+        };
+
+        if (stat.isDirectory()) {
+          let fileCount = 0, folderCount = 0, totalSize = 0;
+          const walk = (dir) => {
+            try {
+              for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory()) { folderCount++; walk(full); }
+                else { fileCount++; try { totalSize += fs.statSync(full).size; } catch {} }
+              }
+            } catch {}
+          };
+          walk(resolved);
+          props.fileCount = fileCount;
+          props.folderCount = folderCount;
+          props.totalSize = totalSize;
+        }
+
+        if (opts.json || program.opts().json) { printJson(props); return; }
+
+        console.log(chalk.bold(`\n  ${props.name}`));
+        console.log(chalk.gray('  ' + '─'.repeat(40)));
+        console.log(`  Type:      ${props.type}`);
+        console.log(`  Path:      ${chalk.dim(props.path)}`);
+        console.log(`  Size:      ${chalk.yellow(formatSize(props.size))}`);
+        if (props.totalSize != null) {
+          console.log(`  Total:     ${chalk.yellow(formatSize(props.totalSize))} (${props.fileCount} files, ${props.folderCount} folders)`);
+        }
+        console.log(`  Created:   ${formatDate(props.created)}`);
+        console.log(`  Modified:  ${formatDate(props.modified)}`);
+        console.log(`  Read-only: ${props.readonly ? chalk.yellow('Yes') : 'No'}`);
+        console.log(`  Shared:    ${props.isShared ? chalk.green('Yes') : 'No'}`);
+        console.log();
+
+        auditLog('file.info', { path: resolved });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── copy ────────────────────────────────────────────────────────────────
+  file
+    .command('copy <source> <destination>')
+    .description('copy file or directory')
+    .option('-r, --recursive', 'Copy directories recursively (default for directories)')
+    .action(async (source, destination, opts) => {
+      try {
+        requireIdentity();
+        const src = path.resolve(source);
+        let dest = path.resolve(destination);
+        checkPathAccess(src, 'read');
+        checkPathAccess(dest, 'write');
+
+        try {
+          if (fs.statSync(dest).isDirectory()) {
+            dest = path.join(dest, path.basename(src));
+          }
+        } catch {}
+
+        const stat = fs.statSync(src);
+        if (stat.isDirectory()) {
+          fs.cpSync(src, dest, { recursive: true });
+        } else {
+          fs.mkdirSync(path.dirname(dest), { recursive: true });
+          fs.copyFileSync(src, dest);
+        }
+
+        console.log(chalk.green(`Copied ${path.basename(src)} → ${dest}`));
+        auditLog('file.copy', { source: src, destination: dest });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── move ────────────────────────────────────────────────────────────────
+  file
+    .command('move <source> <destination>')
+    .description('move file or directory')
+    .action(async (source, destination) => {
+      try {
+        requireIdentity();
+        const src = path.resolve(source);
+        let dest = path.resolve(destination);
+        checkPathAccess(src, 'move');
+        checkPathAccess(dest, 'write');
+
+        try {
+          if (fs.statSync(dest).isDirectory()) {
+            dest = path.join(dest, path.basename(src));
+          }
+        } catch {}
+
+        fs.renameSync(src, dest);
+        console.log(chalk.green(`Moved ${path.basename(src)} → ${dest}`));
+        auditLog('file.move', { source: src, destination: dest });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── rename ──────────────────────────────────────────────────────────────
+  file
+    .command('rename <target> <newName>')
+    .description('rename file or directory')
+    .action(async (target, newName) => {
+      try {
+        requireIdentity();
+        const src = path.resolve(target);
+        checkPathAccess(src, 'write');
+
+        if (newName.includes('/') || newName.includes('\\')) {
+          throw new Error('New name cannot contain path separators. Use `pe file move` instead.');
+        }
+
+        const dest = path.join(path.dirname(src), newName);
+        fs.renameSync(src, dest);
+        console.log(chalk.green(`Renamed ${path.basename(src)} → ${newName}`));
+        auditLog('file.rename', { source: src, newName });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── mkdir ───────────────────────────────────────────────────────────────
+  file
+    .command('mkdir <dir>')
+    .description('create directory')
+    .option('-p, --parents', 'Create parent directories as needed')
+    .action(async (dir, opts) => {
+      try {
+        requireIdentity();
+        const targetDir = path.resolve(dir);
+        checkPathAccess(targetDir, 'write');
+
+        fs.mkdirSync(targetDir, { recursive: !!opts.parents });
+        console.log(chalk.green(`Created ${targetDir}`));
+        auditLog('file.mkdir', { path: targetDir });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── delete ──────────────────────────────────────────────────────────────
+  file
+    .command('delete <targets...>')
+    .description('delete files or directories')
+    .option('-f, --force', 'Skip confirmation')
+    .action(async (targets, opts) => {
+      try {
+        requireIdentity();
+        const resolved = targets.map(t => path.resolve(t));
+        for (const p of resolved) checkPathAccess(p, 'delete');
+
+        if (!opts.force) {
+          const names = resolved.map(p => path.basename(p)).join(', ');
+          process.stdout.write(chalk.yellow(`Delete ${names}? [y/N] `));
+          const answer = await new Promise(resolve => {
+            process.stdin.setEncoding('utf8');
+            process.stdin.once('data', data => resolve(data.trim().toLowerCase()));
+          });
+          if (answer !== 'y' && answer !== 'yes') {
+            console.log('Cancelled.');
+            return;
+          }
+        }
+
+        for (const p of resolved) {
+          fs.rmSync(p, { recursive: true, force: true });
+          console.log(chalk.green(`Deleted ${path.basename(p)}`));
+        }
+        auditLog('file.delete', { paths: resolved });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── search ──────────────────────────────────────────────────────────────
+  file
+    .command('search <pattern> [dir]')
+    .description('search files by name pattern (glob-like)')
+    .option('-t, --type <type>', 'Filter: file, dir, all', 'all')
+    .option('-d, --depth <n>', 'Max depth', '10')
+    .option('-l, --limit <n>', 'Max results', '100')
+    .option('--json', 'Output as JSON')
+    .action(async (pattern, dir, opts) => {
+      try {
+        requireIdentity();
+        const targetDir = path.resolve(dir || '.');
+        checkPathAccess(targetDir, 'read');
+
+        const maxDepth = parseInt(opts.depth, 10);
+        const maxResults = parseInt(opts.limit, 10);
+        const regex = new RegExp(
+          pattern.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.'),
+          'i'
+        );
+        const results = [];
+
+        function walk(dirPath, depth) {
+          if (depth > maxDepth || results.length >= maxResults) return;
+          let entries;
+          try { entries = fs.readdirSync(dirPath, { withFileTypes: true }); } catch { return; }
+          for (const entry of entries) {
+            if (results.length >= maxResults) break;
+            const fullPath = path.join(dirPath, entry.name);
+            const isDir = entry.isDirectory();
+
+            if (regex.test(entry.name)) {
+              if (opts.type === 'all' || (opts.type === 'file' && !isDir) || (opts.type === 'dir' && isDir)) {
+                let size = null;
+                try { size = fs.statSync(fullPath).size; } catch {}
+                results.push({ name: entry.name, path: fullPath, isDirectory: isDir, size });
+              }
+            }
+
+            if (isDir) walk(fullPath, depth + 1);
+          }
+        }
+
+        walk(targetDir, 1);
+
+        if (opts.json || program.opts().json) { printJson(results); return; }
+
+        if (results.length === 0) {
+          console.log(chalk.dim(`No matches for "${pattern}" in ${targetDir}`));
+          return;
+        }
+
+        console.log(chalk.gray(`\n  Found ${results.length} match${results.length !== 1 ? 'es' : ''} for "${pattern}":\n`));
+        for (const r of results) {
+          const icon = r.isDirectory ? chalk.blue('DIR ') : chalk.gray('FILE');
+          const size = r.isDirectory ? '' : chalk.dim(` (${formatSize(r.size)})`);
+          const rel = path.relative(targetDir, r.path);
+          console.log(`  ${icon}  ${rel}${size}`);
+        }
+        console.log();
+
+        auditLog('file.search', { pattern, dir: targetDir, resultCount: results.length });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── open ────────────────────────────────────────────────────────────────
+  file
+    .command('open <target>')
+    .description('open file with OS default application')
+    .action(async (target) => {
+      try {
+        requireIdentity();
+        const resolved = path.resolve(target);
+        checkPathAccess(resolved, 'read');
+
+        const { execFile } = await import('child_process');
+        if (process.platform === 'win32') {
+          execFile('cmd', ['/c', 'start', '""', resolved], (err) => {
+            if (err) console.error(chalk.red(`Failed to open: ${err.message}`));
+          });
+        } else if (process.platform === 'darwin') {
+          execFile('open', [resolved], (err) => {
+            if (err) console.error(chalk.red(`Failed to open: ${err.message}`));
+          });
+        } else {
+          execFile('xdg-open', [resolved], (err) => {
+            if (err) console.error(chalk.red(`Failed to open: ${err.message}`));
+          });
+        }
+
+        auditLog('file.open', { path: resolved });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── reveal ──────────────────────────────────────────────────────────────
+  file
+    .command('reveal <target>')
+    .description('show file in OS file explorer')
+    .action(async (target) => {
+      try {
+        requireIdentity();
+        const resolved = path.resolve(target);
+        checkPathAccess(resolved, 'read');
+
+        const { execFile } = await import('child_process');
+        if (process.platform === 'win32') {
+          execFile('explorer', ['/select,', resolved], (err) => {
+            if (err) console.error(chalk.red(`Failed to reveal: ${err.message}`));
+          });
+        } else if (process.platform === 'darwin') {
+          execFile('open', ['-R', resolved], (err) => {
+            if (err) console.error(chalk.red(`Failed to reveal: ${err.message}`));
+          });
+        } else {
+          execFile('xdg-open', [path.dirname(resolved)], (err) => {
+            if (err) console.error(chalk.red(`Failed to reveal: ${err.message}`));
+          });
+        }
+
+        auditLog('file.reveal', { path: resolved });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── audit ───────────────────────────────────────────────────────────────
+  file
+    .command('audit')
+    .description('show file operation audit log')
+    .option('-n, --limit <n>', 'Number of entries', '20')
+    .option('--clear', 'Clear audit log')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        requireIdentity();
+        const { getAuditLog, clearAuditLog } = await import('../core/permissions.js');
+
+        if (opts.clear) {
+          clearAuditLog();
+          console.log(chalk.green('Audit log cleared.'));
+          return;
+        }
+
+        const entries = getAuditLog(parseInt(opts.limit, 10));
+
+        if (opts.json || program.opts().json) { printJson(entries); return; }
+
+        if (entries.length === 0) {
+          console.log(chalk.dim('No audit entries.'));
+          return;
+        }
+
+        console.log(chalk.bold('\n  File Operation Audit Log\n'));
+        for (const entry of entries) {
+          const time = chalk.dim(new Date(entry.timestamp).toLocaleString());
+          const action = chalk.cyan(entry.action.padEnd(14));
+          const user = chalk.yellow(entry.user);
+          const detail = entry.path || entry.source || '';
+          console.log(`  ${time}  ${action}  ${user}  ${chalk.gray(detail)}`);
+        }
+        console.log();
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+}