cli.js

#!/usr/bin/env node

const path = require('path');
const fs = require('fs');
const { 
  unlockFile, 
  deleteFile, 
  getProcessesUsingFile, 
  isRunningAsAdmin 
} = require('./lib/native-windows-api');

// Função para desbloquear ou deletar arquivo
async function unlockOrDeleteFile(filePath, options = {}) {
  try {
    if (options.deleteFile) {
      // Deletar arquivo
      const result = await deleteFile(filePath, { 
        useRecycleBin: options.useRecycleBin 
      });
      return result;
    } else {
      // Apenas desbloquear
      const result = await unlockFile(filePath, { 
        killProcesses: options.forceKill 
      });
      return result;
    }
  } catch (error) {
    return { success: false, message: error.message };
  }
}

// Função para mostrar ajuda
function showHelp() {
  console.log(`
File Unlocker - CLI

Uso: npx file-unlocker <arquivo> [opções]

Argumentos:
  arquivo                    Caminho do arquivo para desbloquear/deletar

Opções:
  -d, --delete              Deletar o arquivo após desbloquear
  -r, --recycle-bin         Mover para lixeira em vez de deletar permanentemente
  -f, --force-kill          Forçar desbloqueio matando processos se necessário
  -h, --help                Mostrar esta ajuda
  -v, --version             Mostrar versão

Exemplos:
  npx file-unlocker "arquivo.txt"                    # Apenas desbloquear
  npx file-unlocker "arquivo.txt" --delete          # Desbloquear e deletar
  npx file-unlocker "arquivo.txt" --recycle-bin     # Mover para lixeira
  npx file-unlocker "arquivo.txt" --force-kill      # Forçar desbloqueio

Verificar processos que estão usando um arquivo:
  npx file-unlocker "arquivo.txt" --check-only
`);
}

// Função para mostrar versão
function showVersion() {
  const packageJson = require('./package.json');
  console.log(`File Unlocker v${packageJson.version}`);
}

// Função principal
async function main() {
  const args = process.argv.slice(2);
  
  // Verificar se há argumentos
  if (args.length === 0) {
    console.error('Erro: Nenhum arquivo especificado');
    showHelp();
    process.exit(1);
  }

  // Parsear argumentos
  const options = {
    deleteFile: false,
    useRecycleBin: false,
    forceKill: false,
    checkOnly: false
  };

  let filePath = null;

  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    
    switch (arg) {
      case '-h':
      case '--help':
        showHelp();
        process.exit(0);
        break;
        
      case '-v':
      case '--version':
        showVersion();
        process.exit(0);
        break;
        
      case '-d':
      case '--delete':
        options.deleteFile = true;
        break;
        
      case '-r':
      case '--recycle-bin':
        options.useRecycleBin = true;
        break;
        
      case '-f':
      case '--force-kill':
        options.forceKill = true;
        break;
        
      case '--check-only':
        options.checkOnly = true;
        break;
        
      default:
        if (!filePath && !arg.startsWith('-')) {
          filePath = arg;
        } else {
          console.error(`Erro: Argumento desconhecido: ${arg}`);
          showHelp();
          process.exit(1);
        }
        break;
    }
  }

  // Verificar se o arquivo foi especificado
  if (!filePath) {
    console.error('Erro: Nenhum arquivo especificado');
    showHelp();
    process.exit(1);
  }

  // Resolver caminho absoluto
  filePath = path.resolve(filePath);

  // Verificar se o arquivo existe
  if (!fs.existsSync(filePath)) {
          console.error(`Error: File not found: ${filePath}`);
    process.exit(1);
  }

  try {
    // Verificar privilégios de administrador
    if (process.platform === 'win32' && !isRunningAsAdmin()) {
      console.warn('Aviso: Execute como administrador para melhor compatibilidade no Windows');
    }

    if (options.checkOnly) {
      // Apenas verificar processos
      const processes = await getProcessesUsingFile(filePath);
      
      if (processes.length === 0) {
        console.log('✅ Arquivo não está bloqueado');
      } else {
        console.log(`❌ Arquivo bloqueado por ${processes.length} processo(s):`);
        processes.forEach(p => {
          console.log(`   - ${p.name} (PID: ${p.pid})`);
        });
      }
    } else {
      // Executar desbloqueio/deleção
      console.log(`Processando: ${filePath}`);
      
      const result = await unlockOrDeleteFile(filePath, options);
      
      if (result.success) {
        console.log(`✅ ${result.message}`);
        process.exit(0);
      } else {
        console.error(`❌ ${result.message}`);
        process.exit(1);
      }
    }
    
  } catch (error) {
    console.error('Erro:', error.message);
    process.exit(1);
  }
}

// Executar se for o arquivo principal
if (require.main === module) {
  main().catch(error => {
    console.error('Erro fatal:', error);
    process.exit(1);
  });
}

module.exports = { main };