wedos-cli 1.0.0

package/src/commands/domain.js

@@ -0,0 +1,329 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import chalk from 'chalk';
+import { WapiClient, isSuccess } from '../lib/wapi.js';
+import { getCredentials, getConfig } from '../lib/config.js';
+import { formatResponse, printError, printSuccess, printWarning, printInfo } from '../lib/output.js';
+
+export function createDomainCommand() {
+  const domain = new Command('domain')
+    .description('Správa domén');
+
+  // List domains
+  domain
+    .command('list')
+    .alias('ls')
+    .description('Seznam všech domén v účtu')
+    .option('-s, --status <status>', 'Filtrovat podle stavu (active, expired, deleted)')
+    .option('--json', 'Výstup jako JSON')
+    .action(async (options) => {
+      const spinner = ora('Načítám domény...').start();
+      try {
+        const client = new WapiClient(getCredentials());
+        const response = await client.domainsList(options.status);
+        spinner.stop();
+        formatResponse(response, { format: options.json ? 'json' : undefined });
+      } catch (error) {
+        spinner.stop();
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  // Check domain availability
+  domain
+    .command('check <domains...>')
+    .description('Kontrola dostupnosti domény (lze zadat více)')
+    .option('--json', 'Výstup jako JSON')
+    .action(async (domains, options) => {
+      const spinner = ora('Kontroluji dostupnost...').start();
+      try {
+        const client = new WapiClient(getCredentials());
+        const response = await client.domainCheck(domains);
+        spinner.stop();
+
+        if (options.json) {
+          formatResponse(response, { format: 'json' });
+        } else {
+          const code = parseInt(response.code);
+          if (isSuccess(code) && response.data) {
+            console.log(chalk.bold('\nDostupnost domén:\n'));
+            for (const [domain, info] of Object.entries(response.data)) {
+              const status = info.avail === '1' || info.avail === 1;
+              const icon = status ? chalk.green('✓') : chalk.red('✗');
+              const text = status ? chalk.green('Volná') : chalk.red('Zaregistrovaná');
+              console.log(`${icon} ${domain} - ${text}`);
+            }
+          } else {
+            formatResponse(response);
+          }
+        }
+      } catch (error) {
+        spinner.stop();
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  // Get domain info
+  domain
+    .command('info <domains...>')
+    .description('Detailní informace o doméně')
+    .option('--json', 'Výstup jako JSON')
+    .action(async (domains, options) => {
+      const spinner = ora('Načítám informace o doméně...').start();
+      try {
+        const client = new WapiClient(getCredentials());
+        const response = await client.domainInfo(domains);
+        spinner.stop();
+        formatResponse(response, { format: options.json ? 'json' : undefined });
+      } catch (error) {
+        spinner.stop();
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  // Register new domain
+  domain
+    .command('register <domain>')
+    .alias('create')
+    .description('Registrace nové domény')
+    .option('-p, --period <years>', 'Délka registrace v letech', '1')
+    .option('-c, --contact <id>', 'ID kontaktu vlastníka')
+    .option('-n, --nsset <nsset>', 'Název NSSET (např. WEDOS)')
+    .option('-d, --dns <servers>', 'Vlastní DNS servery (oddělené čárkou, např. "ns1.example.com,ns2.example.com")')
+    .option('-r, --rules <name>', 'Osoba, která souhlasila s podmínkami (povinné)')
+    .option('-i, --interactive', 'Interaktivní režim')
+    .option('--json', 'Výstup jako JSON')
+    .action(async (domainName, options) => {
+      try {
+        const client = new WapiClient(getCredentials());
+        const config = getConfig();
+
+        // First check availability
+        const spinner = ora('Kontroluji dostupnost domény...').start();
+        const checkResponse = await client.domainCheck(domainName);
+        spinner.stop();
+
+        const checkCode = parseInt(checkResponse.code);
+        if (!isSuccess(checkCode)) {
+          formatResponse(checkResponse);
+          process.exit(1);
+        }
+
+        const domainData = checkResponse.data?.[domainName];
+        if (!domainData || domainData.avail !== '1') {
+          printError(`Doména ${domainName} není k dispozici pro registraci`);
+          if (domainData?.reason) {
+            printInfo(`Důvod: ${domainData.reason}`);
+          }
+          process.exit(1);
+        }
+
+        printSuccess(`Doména ${domainName} je volná!`);
+
+        // Get contact if not provided
+        let ownerContact = options.contact || config.defaultContact;
+        let rules = options.rules;
+
+        if (!ownerContact || !rules) {
+          if (!options.interactive) {
+            printError('ID kontaktu a jméno pro pravidla jsou povinné. Použij --contact a --rules, nebo --interactive');
+            console.log('\nPříklad:');
+            console.log(`  wedos domain register ${domainName} --contact MYCONTACT-CZ --rules "Jan Novák"`);
+            process.exit(1);
+          }
+
+          // Interactive mode
+          const answers = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'contact',
+              message: 'ID kontaktu vlastníka:',
+              when: !ownerContact,
+              validate: (input) => input.length > 0 || 'ID kontaktu je povinné',
+            },
+            {
+              type: 'input',
+              name: 'rules',
+              message: 'Celé jméno osoby souhlasící s podmínkami:',
+              when: !rules,
+              validate: (input) => input.length > 0 || 'Jméno je povinné',
+            },
+          ]);
+
+          ownerContact = ownerContact || answers.contact;
+          rules = rules || answers.rules;
+        }
+
+        // Register domain
+        const registerSpinner = ora('Registruji doménu...').start();
+
+        // Build DNS configuration
+        const createOptions = {
+          name: domainName,
+          period: parseInt(options.period),
+          ownerContact,
+          rules,
+        };
+
+        // Use custom DNS servers if provided, otherwise use NSSET
+        if (options.dns) {
+          // Parse comma-separated DNS servers into proper format
+          const servers = options.dns.split(',').map(s => s.trim());
+          createOptions.dns = servers.map(server => ({ name: server }));
+          printInfo(`Používám vlastní DNS: ${servers.join(', ')}`);
+        } else {
+          createOptions.nsset = options.nsset || config.defaultNsset || 'WEDOS';
+        }
+
+        const response = await client.domainCreate(createOptions);
+        registerSpinner.stop();
+
+        formatResponse(response, { format: options.json ? 'json' : undefined });
+
+        if (isSuccess(parseInt(response.code))) {
+          printSuccess(`Doména ${domainName} úspěšně zaregistrována!`);
+          if (response.data?.expiration) {
+            printInfo(`Expirace: ${response.data.expiration}`);
+          }
+        }
+      } catch (error) {
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  // Renew domain
+  domain
+    .command('renew <domain>')
+    .description('Prodloužení registrace domény')
+    .option('-p, --period <years>', 'Délka prodloužení v letech', '1')
+    .option('--json', 'Výstup jako JSON')
+    .action(async (domainName, options) => {
+      const spinner = ora('Prodlužuji doménu...').start();
+      try {
+        const client = new WapiClient(getCredentials());
+        const response = await client.domainRenew(domainName, parseInt(options.period));
+        spinner.stop();
+        formatResponse(response, { format: options.json ? 'json' : undefined });
+      } catch (error) {
+        spinner.stop();
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  // Update DNS/NSSET
+  domain
+    .command('update-ns <domain>')
+    .description('Aktualizace DNS serverů domény')
+    .option('-n, --nsset <nsset>', 'Název NSSET')
+    .option('--json', 'Výstup jako JSON')
+    .action(async (domainName, options) => {
+      if (!options.nsset) {
+        printError('NSSET je povinný. Použij --nsset <název>');
+        process.exit(1);
+      }
+
+      const spinner = ora('Aktualizuji DNS...').start();
+      try {
+        const client = new WapiClient(getCredentials());
+        const response = await client.domainUpdateNs(domainName, options.nsset);
+        spinner.stop();
+        formatResponse(response, { format: options.json ? 'json' : undefined });
+      } catch (error) {
+        spinner.stop();
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  // Transfer check
+  domain
+    .command('transfer-check <domain>')
+    .description('Kontrola možnosti transferu domény')
+    .option('--json', 'Výstup jako JSON')
+    .action(async (domainName, options) => {
+      const spinner = ora('Kontroluji možnost transferu...').start();
+      try {
+        const client = new WapiClient(getCredentials());
+        const response = await client.domainTransferCheck(domainName);
+        spinner.stop();
+        formatResponse(response, { format: options.json ? 'json' : undefined });
+      } catch (error) {
+        spinner.stop();
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  // Transfer domain
+  domain
+    .command('transfer <domain>')
+    .description('Transfer domény od jiného registrátora')
+    .requiredOption('-a, --auth <authInfo>', 'AUTH-ID domény')
+    .option('-c, --contact <id>', 'ID kontaktu vlastníka (pro non-CZ domény)')
+    .option('-n, --nsset <nsset>', 'Název NSSET')
+    .requiredOption('-r, --rules <name>', 'Osoba, která souhlasila s podmínkami')
+    .option('--json', 'Výstup jako JSON')
+    .action(async (domainName, options) => {
+      const spinner = ora('Zahajuji transfer...').start();
+      try {
+        const client = new WapiClient(getCredentials());
+        const response = await client.domainTransfer({
+          name: domainName,
+          authInfo: options.auth,
+          ownerContact: options.contact,
+          nsset: options.nsset,
+          rules: options.rules,
+        });
+        spinner.stop();
+        formatResponse(response, { format: options.json ? 'json' : undefined });
+      } catch (error) {
+        spinner.stop();
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  // Send AUTH-ID
+  domain
+    .command('send-auth <domain>')
+    .description('Odeslání AUTH-ID na e-mail vlastníka')
+    .action(async (domainName) => {
+      const spinner = ora('Odesílám AUTH-ID...').start();
+      try {
+        const client = new WapiClient(getCredentials());
+        const response = await client.domainSendAuthInfo(domainName);
+        spinner.stop();
+        formatResponse(response);
+      } catch (error) {
+        spinner.stop();
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  // Check TLD period
+  domain
+    .command('period-check <tld> <years>')
+    .description('Kontrola platnosti délky registrace pro TLD')
+    .action(async (tld, years) => {
+      const spinner = ora('Kontroluji...').start();
+      try {
+        const client = new WapiClient(getCredentials());
+        const response = await client.domainTldPeriodCheck(tld, parseInt(years));
+        spinner.stop();
+        formatResponse(response);
+      } catch (error) {
+        spinner.stop();
+        printError(error);
+        process.exit(1);
+      }
+    });
+
+  return domain;
+}

package/src/index.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+
+import { createDomainCommand } from './commands/domain.js';
+import { createDnsCommand } from './commands/dns.js';
+import { createContactCommand } from './commands/contact.js';
+import { createConfigCommand } from './commands/config.js';
+import { WapiClient, isSuccess } from './lib/wapi.js';
+import { getCredentials, hasCredentials } from './lib/config.js';
+import { formatResponse, printError, printSuccess, printInfo, printHeader, printDomainCheck, printSuccessBox, printErrorBox } from './lib/output.js';
+import { formatDateTime } from './lib/locale.js';
+import { printBanner, wedosGradient } from './lib/ui.js';
+
+const program = new Command();
+
+program
+  .name('wedos')
+  .description('CLI nástroj pro WEDOS WAPI - registrace domén, správa DNS a další')
+  .version('1.0.0')
+  .hook('preAction', (thisCommand) => {
+    // Show banner for main commands (not subcommands)
+    const commandName = thisCommand.args[0];
+    if (!commandName || ['--help', '-h', '--version', '-V'].includes(commandName)) {
+      return;
+    }
+  });
+
+// Add subcommands
+program.addCommand(createDomainCommand());
+program.addCommand(createDnsCommand());
+program.addCommand(createContactCommand());
+program.addCommand(createConfigCommand());
+
+// Ping command
+program
+  .command('ping')
+  .description('Test připojení k API a ověření autentizace')
+  .action(async () => {
+    if (!hasCredentials()) {
+      printErrorBox('Přihlašovací údaje nejsou nastaveny', 'Spusť: wedos config init');
+      process.exit(1);
+    }
+
+    printBanner();
+
+    const spinner = ora({
+      text: 'Testuji připojení k WAPI...',
+      spinner: 'dots12',
+      color: 'cyan',
+    }).start();
+
+    try {
+      const client = new WapiClient(getCredentials());
+      const response = await client.ping();
+      spinner.stop();
+
+      if (isSuccess(parseInt(response.code))) {
+        const time = formatDateTime(new Date(response.timestamp * 1000));
+
+        console.log(boxen(
+          chalk.green.bold('✓ Připojení úspěšné!\n\n') +
+          chalk.gray('Server:    ') + chalk.white('api.wedos.com\n') +
+          chalk.gray('Čas:       ') + chalk.white(time + '\n') +
+          chalk.gray('Transakce: ') + chalk.white(response.svTRID || 'N/A'),
+          {
+            padding: 1,
+            borderStyle: 'round',
+            borderColor: 'green',
+            title: '🌐 WAPI Status',
+            titleAlignment: 'center',
+          }
+        ));
+      } else {
+        formatResponse(response);
+      }
+    } catch (error) {
+      spinner.stop();
+      printError(error);
+      process.exit(1);
+    }
+  });
+
+// Poll command (for async operations)
+program
+  .command('poll')
+  .description('Kontrola čekajících notifikací')
+  .option('--ack <msgid>', 'Potvrdit notifikaci podle ID')
+  .option('--json', 'Výstup jako JSON')
+  .action(async (options) => {
+    if (!hasCredentials()) {
+      printErrorBox('Přihlašovací údaje nejsou nastaveny', 'Spusť: wedos config init');
+      process.exit(1);
+    }
+
+    const spinner = ora({
+      text: 'Kontroluji notifikace...',
+      spinner: 'dots12',
+      color: 'cyan',
+    }).start();
+
+    try {
+      const client = new WapiClient(getCredentials());
+
+      if (options.ack) {
+        const response = await client.pollAck(options.ack);
+        spinner.stop();
+        formatResponse(response, { format: options.json ? 'json' : undefined });
+      } else {
+        const response = await client.pollReq();
+        spinner.stop();
+
+        if (parseInt(response.code) === 1300) {
+          printInfo('Žádné čekající notifikace');
+        } else {
+          formatResponse(response, { format: options.json ? 'json' : undefined });
+        }
+      }
+    } catch (error) {
+      spinner.stop();
+      printError(error);
+      process.exit(1);
+    }
+  });
+
+// Quick check command (shortcut)
+program
+  .command('check <domains...>')
+  .description('Rychlá kontrola dostupnosti domény')
+  .option('--json', 'Výstup jako JSON')
+  .action(async (domains, options) => {
+    if (!hasCredentials()) {
+      printErrorBox('Přihlašovací údaje nejsou nastaveny', 'Spusť: wedos config init');
+      process.exit(1);
+    }
+
+    const spinner = ora({
+      text: `Kontroluji ${domains.length} doména(y)...`,
+      spinner: 'dots12',
+      color: 'cyan',
+    }).start();
+
+    try {
+      const client = new WapiClient(getCredentials());
+      const response = await client.domainCheck(domains);
+      spinner.stop();
+
+      if (options.json) {
+        formatResponse(response, { format: 'json' });
+      } else {
+        const code = parseInt(response.code);
+        if (isSuccess(code) && response.data) {
+          printHeader('Dostupnost domén', '🔍');
+          console.log('');
+
+          for (const [domain, info] of Object.entries(response.data)) {
+            const available = info.avail === '1' || info.avail === 1;
+            printDomainCheck(domain, available, info.reason);
+          }
+          console.log('');
+        } else {
+          formatResponse(response);
+        }
+      }
+    } catch (error) {
+      spinner.stop();
+      printError(error);
+      process.exit(1);
+    }
+  });
+
+// Quick register command (shortcut)
+program
+  .command('register <domain>')
+  .description('Rychlá registrace domény')
+  .option('-p, --period <years>', 'Délka registrace v letech', '1')
+  .option('-c, --contact <id>', 'ID kontaktu vlastníka')
+  .option('-n, --nsset <nsset>', 'Název NSSET')
+  .option('-d, --dns <servers>', 'Vlastní DNS servery (oddělené čárkou)')
+  .option('-r, --rules <name>', 'Osoba, která souhlasila s podmínkami')
+  .option('-i, --interactive', 'Interaktivní režim')
+  .action(async (domain, options) => {
+    // Delegate to domain register
+    const args = ['domain', 'register', domain];
+    if (options.period) args.push('-p', options.period);
+    if (options.contact) args.push('-c', options.contact);
+    if (options.nsset) args.push('-n', options.nsset);
+    if (options.dns) args.push('-d', options.dns);
+    if (options.rules) args.push('-r', options.rules);
+    if (options.interactive) args.push('-i');
+
+    process.argv = [process.argv[0], process.argv[1], ...args];
+    await program.parseAsync(process.argv);
+  });
+
+// Custom help
+program.configureHelp({
+  sortSubcommands: true,
+  subcommandTerm: (cmd) => chalk.cyan(cmd.name()) + (cmd.alias() ? chalk.gray(` (${cmd.alias()})`) : ''),
+});
+
+// Help with examples
+program.on('--help', () => {
+  console.log('');
+  console.log(chalk.gray('─'.repeat(55)));
+  console.log('');
+  console.log(chalk.bold.cyan('  Příklady:'));
+  console.log('');
+  console.log(chalk.gray('  # Počáteční nastavení'));
+  console.log('  $ ' + chalk.white('wedos config init'));
+  console.log('');
+  console.log(chalk.gray('  # Test připojení'));
+  console.log('  $ ' + chalk.white('wedos ping'));
+  console.log('');
+  console.log(chalk.gray('  # Kontrola dostupnosti domény'));
+  console.log('  $ ' + chalk.white('wedos check mojedomena.cz'));
+  console.log('');
+  console.log(chalk.gray('  # Seznam domén'));
+  console.log('  $ ' + chalk.white('wedos domain list'));
+  console.log('');
+  console.log(chalk.gray('  # Přidání DNS záznamu'));
+  console.log('  $ ' + chalk.white('wedos dns quick-add domena.cz -a 1.2.3.4'));
+  console.log('');
+  console.log(chalk.gray('─'.repeat(55)));
+  console.log('');
+  console.log(chalk.gray('  📖 Nápověda k příkazu: ') + chalk.cyan('wedos <příkaz> --help'));
+  console.log('');
+});
+
+// Show banner before help
+const originalHelp = program.helpInformation.bind(program);
+program.helpInformation = function() {
+  printBanner();
+  return originalHelp();
+};
+
+program.parse();

package/src/lib/config.js

@@ -0,0 +1,72 @@
+import Conf from 'conf';
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+
+const config = new Conf({
+  projectName: 'wedos-cli',
+  schema: {
+    username: { type: 'string' },
+    password: { type: 'string' },
+    testMode: { type: 'boolean', default: false },
+    defaultNsset: { type: 'string', default: 'WEDOS' },
+    defaultContact: { type: 'string' },
+    outputFormat: { type: 'string', enum: ['table', 'json'], default: 'table' },
+  }
+});
+
+// Also check for .wedosrc in home directory or current directory
+function loadRcFile() {
+  const paths = [
+    join(process.cwd(), '.wedosrc'),
+    join(homedir(), '.wedosrc'),
+  ];
+
+  for (const path of paths) {
+    if (existsSync(path)) {
+      try {
+        const content = readFileSync(path, 'utf-8');
+        return JSON.parse(content);
+      } catch {
+        // Ignore parse errors
+      }
+    }
+  }
+  return null;
+}
+
+export function getConfig() {
+  const rcConfig = loadRcFile();
+
+  return {
+    username: process.env.WEDOS_USERNAME || rcConfig?.username || config.get('username'),
+    password: process.env.WEDOS_PASSWORD || rcConfig?.password || config.get('password'),
+    testMode: process.env.WEDOS_TEST_MODE === '1' || rcConfig?.testMode || config.get('testMode'),
+    defaultNsset: rcConfig?.defaultNsset || config.get('defaultNsset'),
+    defaultContact: rcConfig?.defaultContact || config.get('defaultContact'),
+    outputFormat: rcConfig?.outputFormat || config.get('outputFormat'),
+  };
+}
+
+export function setConfig(key, value) {
+  config.set(key, value);
+}
+
+export function clearConfig() {
+  config.clear();
+}
+
+export function hasCredentials() {
+  const cfg = getConfig();
+  return !!(cfg.username && cfg.password);
+}
+
+export function getCredentials() {
+  const cfg = getConfig();
+  if (!cfg.username || !cfg.password) {
+    throw new Error('WEDOS credentials not configured. Run: wedos config --username <email> --password <wapi-password>');
+  }
+  return { username: cfg.username, password: cfg.password, testMode: cfg.testMode };
+}
+
+export default config;