wedos-cli 1.0.0

package/src/lib/wapi.js

@@ -0,0 +1,323 @@
+import crypto from 'crypto';
+
+const API_URL = 'https://api.wedos.com/wapi/json';
+
+/**
+ * Generate WAPI auth string
+ * Format: sha1(username + sha1(password) + hour)
+ * Hour is 00-23 in Europe/Prague timezone
+ */
+function generateAuth(username, password) {
+  const pragueDate = new Date().toLocaleString('en-US', { timeZone: 'Europe/Prague' });
+  const hour = new Date(pragueDate).getHours().toString().padStart(2, '0');
+
+  const passwordHash = crypto.createHash('sha1').update(password).digest('hex');
+  const authString = username + passwordHash + hour;
+
+  return crypto.createHash('sha1').update(authString).digest('hex');
+}
+
+/**
+ * WAPI Client for WEDOS API
+ */
+export class WapiClient {
+  constructor(config) {
+    this.username = config.username;
+    this.password = config.password;
+    this.testMode = config.testMode || false;
+  }
+
+  /**
+   * Make API request
+   */
+  async request(command, data = {}) {
+    const auth = generateAuth(this.username, this.password);
+
+    const requestData = {
+      user: this.username,
+      auth: auth,
+      command: command,
+      clTRID: `wedos-cli-${Date.now()}`,
+      ...(this.testMode && { test: 1 }),
+      ...(Object.keys(data).length > 0 && { data })
+    };
+
+    // WEDOS API expects form-urlencoded with 'request' parameter containing JSON
+    const formData = new URLSearchParams();
+    formData.append('request', JSON.stringify({ request: requestData }));
+
+    const response = await fetch(API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: formData.toString()
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error: ${response.status}`);
+    }
+
+    const result = await response.json();
+
+    if (!result.response) {
+      throw new Error('Invalid API response');
+    }
+
+    return result.response;
+  }
+
+  // =====================
+  // Basic Commands
+  // =====================
+
+  async ping() {
+    return this.request('ping');
+  }
+
+  async pollReq() {
+    return this.request('poll-req');
+  }
+
+  async pollAck(msgid) {
+    return this.request('poll-ack', { msgid });
+  }
+
+  // =====================
+  // Domain Commands
+  // =====================
+
+  async domainsList(status = null) {
+    const data = status ? { status } : {};
+    return this.request('domains-list', data);
+  }
+
+  async domainCheck(domains) {
+    const name = Array.isArray(domains) ? domains.join(',') : domains;
+    return this.request('domain-check', { name });
+  }
+
+  async domainInfo(domains) {
+    const name = Array.isArray(domains) ? domains.join(',') : domains;
+    return this.request('domain-info', { name });
+  }
+
+  async domainCreate(options) {
+    const data = {
+      name: options.name,
+      period: options.period || 1,
+      owner_c: options.ownerContact,
+      rules: options.rules,
+    };
+
+    if (options.adminContact) {
+      data.admin_c = options.adminContact;
+    }
+
+    // DNS configuration
+    if (options.nsset) {
+      data.nsset = options.nsset;
+    } else if (options.dns) {
+      data.dns = options.dns;
+    } else {
+      // Default to WEDOS NSSET
+      data.nsset = 'WEDOS';
+    }
+
+    return this.request('domain-create', data);
+  }
+
+  async domainRenew(name, period = 1) {
+    return this.request('domain-renew', { name, period });
+  }
+
+  async domainUpdateNs(name, nsset = null, dns = null) {
+    const data = { name };
+    if (nsset) {
+      data.nsset = nsset;
+    } else if (dns) {
+      data.dns = dns;
+    }
+    return this.request('domain-update-ns', data);
+  }
+
+  async domainTransferCheck(name) {
+    return this.request('domain-transfer-check', { name });
+  }
+
+  async domainTransfer(options) {
+    const data = {
+      name: options.name,
+      auth_info: options.authInfo,
+      rules: options.rules,
+    };
+
+    if (options.ownerContact) {
+      data.owner_c = options.ownerContact;
+    }
+
+    if (options.nsset) {
+      data.nsset = options.nsset;
+    } else if (options.dns) {
+      data.dns = options.dns;
+    }
+
+    return this.request('domain-transfer', data);
+  }
+
+  async domainSendAuthInfo(name) {
+    return this.request('domain-send-auth-info', { name });
+  }
+
+  async domainTldPeriodCheck(tld, period) {
+    return this.request('domain-tld-period-check', { tld, period });
+  }
+
+  // =====================
+  // Contact Commands
+  // =====================
+
+  async contactCheck(tld, cname) {
+    return this.request('contact-check', { tld, cname });
+  }
+
+  async contactInfo(tld, cname, authInfo = null) {
+    const data = { tld, cname };
+    if (authInfo) {
+      data.auth_info = authInfo;
+    }
+    return this.request('contact-info', data);
+  }
+
+  async contactCreate(tld, contact) {
+    return this.request('contact-create', {
+      tld,
+      contact: {
+        fname: contact.firstName,
+        lname: contact.lastName,
+        email: contact.email,
+        addr_street: contact.street,
+        addr_city: contact.city,
+        addr_zip: contact.zip,
+        addr_country: contact.country,
+        phone: contact.phone,
+        ...(contact.company && { company: contact.company }),
+        ...(contact.fax && { fax: contact.fax }),
+        ...(contact.identType && { ident_type: contact.identType }),
+        ...(contact.ident && { ident: contact.ident }),
+        ...(contact.notifyEmail && { notify_email: contact.notifyEmail }),
+        ...(contact.cname && { cname: contact.cname }),
+      }
+    });
+  }
+
+  async contactUpdate(tld, cname, authInfo, contact) {
+    return this.request('contact-update', {
+      tld,
+      cname,
+      auth_info: authInfo,
+      contact
+    });
+  }
+
+  // =====================
+  // DNS Commands
+  // =====================
+
+  async dnsDomainsList(options = {}) {
+    return this.request('dns-domains-list', options);
+  }
+
+  async dnsDomainInfo(name) {
+    return this.request('dns-domain-info', { name });
+  }
+
+  async dnsDomainAdd(options) {
+    const data = {
+      name: options.name,
+      type: options.type || 'primary',
+    };
+
+    if (options.axfrEnabled !== undefined) {
+      data.axfr_enabled = options.axfrEnabled ? 1 : 0;
+    }
+
+    if (options.axfrIps) {
+      data.axfr_ips = options.axfrIps;
+    }
+
+    if (options.type === 'secondary') {
+      data.primary_ip = options.primaryIp;
+    }
+
+    return this.request('dns-domain-add', data);
+  }
+
+  async dnsDomainDelete(name) {
+    return this.request('dns-domain-delete', { name });
+  }
+
+  async dnsDomainCommit(name) {
+    return this.request('dns-domain-commit', { name });
+  }
+
+  async dnsRowsList(domain) {
+    return this.request('dns-rows-list', { domain });
+  }
+
+  async dnsRowDetail(name, rowId) {
+    return this.request('dns-row-detail', { name, row_id: rowId });
+  }
+
+  async dnsRowAdd(options) {
+    return this.request('dns-row-add', {
+      domain: options.domain,
+      name: options.name,
+      ttl: options.ttl || 3600,
+      type: options.type,
+      rdata: options.rdata,
+      ...(options.comment && { auth_comment: options.comment }),
+    });
+  }
+
+  async dnsRowUpdate(domain, rowId, options) {
+    return this.request('dns-row-update', {
+      domain,
+      row_id: rowId,
+      ttl: options.ttl,
+      rdata: options.rdata,
+    });
+  }
+
+  async dnsRowDelete(domain, rowId) {
+    return this.request('dns-row-delete', { domain, row_id: rowId });
+  }
+}
+
+/**
+ * Response code descriptions
+ */
+export const RESPONSE_CODES = {
+  1000: 'OK',
+  1001: 'Pending (async operation)',
+  2201: 'Unsupported TLD',
+  2202: 'Invalid domain name',
+  2203: 'Invalid period',
+  3002: 'Insufficient credit',
+  3201: 'Domain already registered',
+  3204: 'Domain in quarantine',
+  3205: 'Domain reserved',
+  3206: 'Domain blocked',
+  3217: 'Registry connection failed',
+  3218: 'Transfer not possible',
+  3222: 'Failed to get domain info',
+  5001: 'Internal error',
+};
+
+export function isSuccess(code) {
+  return code >= 1000 && code < 2000;
+}
+
+export function isError(code) {
+  return code >= 2000;
+}