run method

Future<void> run(List<String> arguments)

Implementation

Future<void> run(List<String> arguments) async {
  final parser = ArgParser()
    ..addFlag('verbose', abbr: 'v', help: 'Enable verbose debug output')
    ..addFlag('force', abbr: 'f', help: 'Force overwrite / ignore conflicts')
    ..addFlag('uuids', help: 'Show full UUIDs in list/search commands')
    ..addFlag('recursive', abbr: 'r', help: 'Recursive operation')
    ..addFlag('preserve-timestamps',
        abbr: 'p', help: 'Preserve file modification times')
    ..addOption('target', abbr: 't', help: 'Destination path')
    ..addOption('on-conflict',
        help: 'Action if target exists (overwrite/skip/newer)',
        allowed: ['overwrite', 'skip', 'newer'],
        defaultsTo: 'skip')
    ..addMultiOption('include', help: 'Include only files matching pattern')
    ..addMultiOption('exclude', help: 'Exclude files matching pattern')
    ..addFlag('detailed', abbr: 'd', help: 'Show detailed information')
    ..addOption('depth',
        abbr: 'l', help: 'Maximum depth for tree', defaultsTo: '3')
    ..addOption('maxdepth',
        help: 'Limit find to N levels (-1 for infinite)', defaultsTo: '-1')
    ..addFlag('background',
        abbr: 'b', help: 'Run WebDAV server in background')
    ..addFlag('daemon', hide: true, help: 'Internal: run as daemon process')
    ..addFlag('password-stdin',
        negatable: false,
        help: 'Read the password from stdin instead of prompting '
            r'(printf %s "$PW" | filen login --password-stdin)')
    ..addOption('mount-point', abbr: 'm', help: 'WebDAV mount point path')
    ..addOption('port', help: 'WebDAV server port', defaultsTo: '8080')
    ..addFlag('webdav-debug', help: 'Enable WebDAV debug logging')
    ..addOption('ssl-cert',
        help: 'Path to SSL certificate file for WebDAV HTTPS')
    ..addOption('ssl-key',
        help: 'Path to SSL private key file for WebDAV HTTPS');

  try {
    final argResults = parser.parse(arguments);
    debugMode = argResults['verbose'];
    force = argResults['force'];
    client.debugMode = debugMode;

    final commandArgs = argResults.rest;
    if (commandArgs.isEmpty) {
      printHelp();
      return;
    }

    final command = commandArgs[0];

    switch (command) {
      case 'login':
        await handleLogin(commandArgs.sublist(1),
            passwordStdin: argResults['password-stdin'] as bool);
        break;
      case 'ls':
      case 'list':
        await handleList(argResults, commandArgs.sublist(1));
        break;
      case 'mkdir':
      case 'mkdir-path':
        if (commandArgs.length < 2) _exit('Usage: mkdir <path>');
        await handleMkdir(commandArgs[1]);
        break;
      case 'upload':
      case 'up':
        await handleUpload(argResults);
        break;
      case 'download':
      case 'dl':
        if (commandArgs.length < 2) _exit('Usage: dl <file-uuid>');
        await handleDownload(argResults);
        break;
      case 'download-path':
        await handleDownloadPath(argResults);
        break;
      case 'mv':
      case 'move':
      case 'move-path':
        if (commandArgs.length < 3) _exit('Usage: mv <source> <dest>');
        await handleMove(commandArgs[1], commandArgs[2]);
        break;
      case 'cp':
      case 'copy':
        if (commandArgs.length < 3) _exit('Usage: cp <source> <dest>');
        await handleCopy(commandArgs[1], commandArgs[2]);
        break;
      case 'rm':
      case 'trash':
      case 'trash-path':
        if (commandArgs.length < 2) _exit('Usage: rm <path>');
        await handleTrash(argResults, commandArgs[1]);
        break;
      case 'delete-path':
        if (commandArgs.length < 2) _exit('Usage: delete-path <path>');
        await handleDeletePath(argResults, commandArgs[1]);
        break;
      case 'rename':
      case 'rename-path':
        if (commandArgs.length < 3) _exit('Usage: rename <path> <new_name>');
        await handleRename(commandArgs[1], commandArgs[2]);
        break;
      case 'verify':
        await handleVerify(argResults);
        break;
      case 'list-trash':
        await handleListTrash(argResults);
        break;
      case 'restore-uuid':
        await handleRestoreUuid(argResults);
        break;
      case 'restore-path':
        await handleRestorePath(argResults);
        break;
      case 'resolve':
        if (commandArgs.length < 2) _exit('Usage: resolve <path>');
        await handleResolve(commandArgs[1]);
        break;
      case 'search':
        await handleSearch(argResults);
        break;
      case 'find':
        await handleFind(argResults);
        break;
      case 'tree':
        await handleTree(argResults);
        break;
      case 'whoami':
        await handleWhoami();
        break;
      case 'logout':
        await handleLogout();
        break;
      case 'config':
        await handleConfig();
        break;
      case 'quota':
        await handleQuota();
        break;
      case 'help':
        printHelp();
        break;
      case 'mount':
      case 'webdav':
        await handleMount(argResults);
        break;
      case 'webdav-start':
        await handleWebdavStart(argResults);
        break;
      case 'webdav-stop':
        await handleWebdavStop(argResults);
        break;
      case 'webdav-status':
        await handleWebdavStatus(argResults);
        break;
      case 'webdav-test':
        await handleWebdavTest(argResults);
        break;
      case 'webdav-mount':
        await handleWebdavMount(argResults);
        break;
      case 'webdav-config':
        await handleWebdavConfig(argResults);
        break;
      default:
        _exit('Unknown command: $command');
    }
  } catch (e, stackTrace) {
    stderr.writeln('\u274c Error: $e');
    if (debugMode) stderr.writeln(stackTrace);
    exit(1);
  }
}