@hasna/connectors 1.3.3 → 1.3.6

package/connectors/{connect-yousign → connect-namecheap}/bun.lock

@@ -3,7 +3,7 @@
   "configVersion": 1,
   "workspaces": {
     "": {
-      "name": "@hasna/connect-yousign",
+      "name": "@hasna/connect-namecheap",
       "dependencies": {
         "chalk": "^5.3.0",
         "commander": "^12.1.0",
@@ -15,11 +15,11 @@
     },
   },
   "packages": {
-    "@types/bun": ["@types/bun@1.3.10", "", { "dependencies": { "bun-types": "1.3.10" } }, "sha512-0+rlrUrOrTSskibryHbvQkDOWRJwJZqZlxrUs1u4oOoTln8+WIXBPmAuCF35SWB2z4Zl3E84Nl/D0P7803nigQ=="],
+    "@types/bun": ["@types/bun@1.3.11", "", { "dependencies": { "bun-types": "1.3.11" } }, "sha512-5vPne5QvtpjGpsGYXiFyycfpDF2ECyPcTSsFBMa0fraoxiQyMJ3SmuQIGhzPg2WJuWxVBoxWJ2kClYTcw/4fAg=="],
 
     "@types/node": ["@types/node@25.5.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw=="],
 
-    "bun-types": ["bun-types@1.3.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-tcpfCCl6XWo6nCVnpcVrxQ+9AYN1iqMIzgrSKYMB/fjLtV2eyAVEg7AxQJuCq/26R6HpKWykQXuSOq/21RYcbg=="],
+    "bun-types": ["bun-types@1.3.11", "", { "dependencies": { "@types/node": "*" } }, "sha512-1KGPpoxQWl9f6wcZh57LvrPIInQMn2TQ7jsgxqpRzg+l0QPOFvJVH7HmvHo/AiPgwXy+/Thf6Ov3EdVn1vOabg=="],
 
     "chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="],
 

package/connectors/connect-namecheap/dist/index.js

@@ -0,0 +1,431 @@
+// @bun
+// src/types/index.ts
+class ConnectorApiError extends Error {
+  statusCode;
+  errorNumber;
+  constructor(message, statusCode, errorNumber) {
+    super(message);
+    this.name = "ConnectorApiError";
+    this.statusCode = statusCode;
+    this.errorNumber = errorNumber;
+  }
+}
+
+// src/utils/xml.ts
+function extractTag(xml, tag) {
+  const regex = new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`, "i");
+  const match = xml.match(regex);
+  return match ? match[1].trim() : null;
+}
+function extractAttribute(xml, tag, attr) {
+  const regex = new RegExp(`<${tag}\\s[^>]*${attr}="([^"]*)"`, "i");
+  const match = xml.match(regex);
+  return match ? match[1] : null;
+}
+function extractAllTags(xml, tag) {
+  const regex = new RegExp(`<${tag}(?:\\s[^>]*)?\\/?>(?:([^<]*)<\\/${tag}>)?`, "gi");
+  const results = [];
+  let match;
+  while ((match = regex.exec(xml)) !== null) {
+    const fullMatch = match[0];
+    const tagNameCheck = new RegExp(`^<${tag}(?:\\s|\\/>|>)`, "i");
+    if (tagNameCheck.test(fullMatch)) {
+      results.push(fullMatch);
+    }
+  }
+  return results;
+}
+function extractAttributeFromElement(element, attr) {
+  const regex = new RegExp(`${attr}="([^"]*)"`, "i");
+  const match = element.match(regex);
+  return match ? match[1] : null;
+}
+function checkApiError(xml) {
+  const status = extractAttribute(xml, "ApiResponse", "Status");
+  if (status === "ERROR") {
+    const errorMsg = extractTag(xml, "Message") || extractTag(xml, "Err") || "Unknown Namecheap API error";
+    const errorNumber = extractAttribute(xml, "Error", "Number") || extractAttribute(xml, "Err", "Number");
+    throw new Error(`Namecheap API error${errorNumber ? ` (${errorNumber})` : ""}: ${errorMsg}`);
+  }
+}
+
+// src/api/client.ts
+var API_BASE = "https://api.namecheap.com/xml.response";
+var SANDBOX_BASE = "https://api.sandbox.namecheap.com/xml.response";
+
+class ConnectorClient {
+  apiKey;
+  username;
+  clientIp;
+  baseUrl;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!config.username) {
+      throw new Error("Username is required");
+    }
+    if (!config.clientIp) {
+      throw new Error("Client IP is required");
+    }
+    this.apiKey = config.apiKey;
+    this.username = config.username;
+    this.clientIp = config.clientIp;
+    this.baseUrl = config.sandbox ? SANDBOX_BASE : API_BASE;
+  }
+  buildUrl(command, extraParams) {
+    const params = new URLSearchParams({
+      ApiUser: this.username,
+      ApiKey: this.apiKey,
+      UserName: this.username,
+      ClientIp: this.clientIp,
+      Command: command,
+      ...extraParams
+    });
+    return `${this.baseUrl}?${params.toString()}`;
+  }
+  async request(command, extraParams) {
+    const url = this.buildUrl(command, extraParams);
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(30000),
+      headers: { "User-Agent": "connect-namecheap/0.1.0" }
+    });
+    if (!response.ok) {
+      throw new ConnectorApiError(`Namecheap API HTTP error: ${response.status} ${response.statusText}`, response.status);
+    }
+    const xml = await response.text();
+    checkApiError(xml);
+    return xml;
+  }
+  getApiKeyPreview() {
+    if (this.apiKey.length > 10) {
+      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    }
+    return "***";
+  }
+}
+
+// src/api/domains.ts
+class DomainsApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async list(options) {
+    const xml = await this.client.request("namecheap.domains.getList", {
+      PageSize: String(options?.pageSize ?? 100),
+      Page: String(options?.page ?? 1)
+    });
+    const domainElements = extractAllTags(xml, "Domain");
+    const domains = [];
+    for (const el of domainElements) {
+      const name = extractAttributeFromElement(el, "Name");
+      const expires = extractAttributeFromElement(el, "Expires");
+      const autoRenew = extractAttributeFromElement(el, "AutoRenew");
+      const isLocked = extractAttributeFromElement(el, "IsLocked");
+      if (name) {
+        domains.push({
+          domain: name,
+          expiry: expires || "",
+          autoRenew: autoRenew === "true",
+          isLocked: isLocked === "true"
+        });
+      }
+    }
+    return domains;
+  }
+  async getInfo(domain) {
+    const xml = await this.client.request("namecheap.domains.getInfo", {
+      DomainName: domain
+    });
+    const createdDate = extractTag(xml, "CreatedDate") || extractAttribute(xml, "DomainGetInfoResult", "CreatedDate") || "";
+    const expiresDate = extractTag(xml, "ExpiredDate") || extractAttribute(xml, "DomainGetInfoResult", "ExpiredDate") || "";
+    const nsSection = xml.match(/<DnsDetails[^>]*>([\s\S]*?)<\/DnsDetails>/i);
+    const nameservers = [];
+    if (nsSection) {
+      const nsElements = nsSection[1].matchAll(/<Nameserver[^>]*>([^<]*)<\/Nameserver>/gi);
+      for (const m of nsElements) {
+        if (m[1])
+          nameservers.push(m[1].trim().toLowerCase());
+      }
+    }
+    return {
+      domain,
+      registrar: "Namecheap",
+      created: createdDate,
+      expires: expiresDate,
+      nameservers
+    };
+  }
+  async renew(domain, years = 1) {
+    const xml = await this.client.request("namecheap.domains.renew", {
+      DomainName: domain,
+      Years: String(years)
+    });
+    const transactionId = extractAttribute(xml, "DomainRenewResult", "TransactionID") || undefined;
+    const chargedAmount = extractAttribute(xml, "DomainRenewResult", "ChargedAmount") || undefined;
+    const orderId = extractAttribute(xml, "DomainRenewResult", "OrderID") || undefined;
+    return {
+      domain,
+      success: true,
+      transactionId,
+      chargedAmount,
+      orderId
+    };
+  }
+  async check(domain) {
+    const xml = await this.client.request("namecheap.domains.check", {
+      DomainList: domain
+    });
+    const available = extractAttribute(xml, "DomainCheckResult", "Available");
+    return {
+      domain,
+      available: available === "true"
+    };
+  }
+}
+
+// src/api/dns.ts
+class DnsApi {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async getHosts(sld, tld) {
+    const xml = await this.client.request("namecheap.domains.dns.getHosts", {
+      SLD: sld,
+      TLD: tld
+    });
+    const hostElements = extractAllTags(xml, "host");
+    const records = [];
+    for (const el of hostElements) {
+      const type = extractAttributeFromElement(el, "Type");
+      const name = extractAttributeFromElement(el, "Name");
+      const address = extractAttributeFromElement(el, "Address");
+      const hostId = extractAttributeFromElement(el, "HostId");
+      const mxPref = extractAttributeFromElement(el, "MXPref");
+      const ttl = extractAttributeFromElement(el, "TTL");
+      if (type && name && address) {
+        records.push({
+          hostId: hostId || undefined,
+          type,
+          name,
+          address,
+          mxPref: mxPref ? parseInt(mxPref) : undefined,
+          ttl: ttl ? parseInt(ttl) : 1800
+        });
+      }
+    }
+    return records;
+  }
+  async setHosts(sld, tld, records) {
+    const params = {
+      SLD: sld,
+      TLD: tld
+    };
+    for (let i = 0;i < records.length; i++) {
+      const r = records[i];
+      const idx = i + 1;
+      params[`HostName${idx}`] = r.name;
+      params[`RecordType${idx}`] = r.type;
+      params[`Address${idx}`] = r.address;
+      params[`TTL${idx}`] = String(r.ttl);
+      if (r.mxPref !== undefined) {
+        params[`MXPref${idx}`] = String(r.mxPref);
+      }
+    }
+    await this.client.request("namecheap.domains.dns.setHosts", params);
+    return true;
+  }
+}
+
+// src/api/index.ts
+class Connector {
+  client;
+  domains;
+  dns;
+  constructor(config) {
+    this.client = new ConnectorClient(config);
+    this.domains = new DomainsApi(this.client);
+    this.dns = new DnsApi(this.client);
+  }
+  static fromEnv() {
+    const apiKey = process.env.NAMECHEAP_API_KEY;
+    const username = process.env.NAMECHEAP_USERNAME;
+    const clientIp = process.env.NAMECHEAP_CLIENT_IP;
+    if (!apiKey) {
+      throw new Error("NAMECHEAP_API_KEY environment variable is required");
+    }
+    if (!username) {
+      throw new Error("NAMECHEAP_USERNAME environment variable is required");
+    }
+    if (!clientIp) {
+      throw new Error("NAMECHEAP_CLIENT_IP environment variable is required");
+    }
+    return new Connector({
+      apiKey,
+      username,
+      clientIp,
+      sandbox: process.env.NAMECHEAP_SANDBOX === "true"
+    });
+  }
+  getApiKeyPreview() {
+    return this.client.getApiKeyPreview();
+  }
+  getClient() {
+    return this.client;
+  }
+}
+// src/utils/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONNECTOR_NAME = "connect-namecheap";
+var DEFAULT_PROFILE = "default";
+var profileOverride;
+var CONFIG_DIR = join(homedir(), ".connectors", CONNECTOR_NAME);
+var PROFILES_DIR = join(CONFIG_DIR, "profiles");
+var CURRENT_PROFILE_FILE = join(CONFIG_DIR, "current_profile");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  if (!existsSync(PROFILES_DIR)) {
+    mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+}
+function getProfilePath(profile) {
+  return join(PROFILES_DIR, `${profile}.json`);
+}
+function getCurrentProfile() {
+  if (profileOverride) {
+    return profileOverride;
+  }
+  ensureConfigDir();
+  if (existsSync(CURRENT_PROFILE_FILE)) {
+    try {
+      const profile = readFileSync(CURRENT_PROFILE_FILE, "utf-8").trim();
+      if (profile && profileExists(profile)) {
+        return profile;
+      }
+    } catch {}
+  }
+  return DEFAULT_PROFILE;
+}
+function setCurrentProfile(profile) {
+  ensureConfigDir();
+  if (!profileExists(profile) && profile !== DEFAULT_PROFILE) {
+    throw new Error(`Profile "${profile}" does not exist`);
+  }
+  writeFileSync(CURRENT_PROFILE_FILE, profile);
+}
+function profileExists(profile) {
+  return existsSync(getProfilePath(profile));
+}
+function listProfiles() {
+  ensureConfigDir();
+  if (!existsSync(PROFILES_DIR)) {
+    return [];
+  }
+  return readdirSync(PROFILES_DIR).filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", "")).sort();
+}
+function createProfile(profile, config = {}) {
+  ensureConfigDir();
+  if (profileExists(profile)) {
+    return false;
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(profile)) {
+    throw new Error("Profile name can only contain letters, numbers, hyphens, and underscores");
+  }
+  writeFileSync(getProfilePath(profile), JSON.stringify(config, null, 2));
+  return true;
+}
+function deleteProfile(profile) {
+  if (profile === DEFAULT_PROFILE) {
+    return false;
+  }
+  if (!profileExists(profile)) {
+    return false;
+  }
+  if (getCurrentProfile() === profile) {
+    setCurrentProfile(DEFAULT_PROFILE);
+  }
+  rmSync(getProfilePath(profile));
+  return true;
+}
+function loadProfile(profile) {
+  ensureConfigDir();
+  const profileName = profile || getCurrentProfile();
+  const profilePath = getProfilePath(profileName);
+  if (!existsSync(profilePath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(profilePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveProfile(config, profile) {
+  ensureConfigDir();
+  const profileName = profile || getCurrentProfile();
+  writeFileSync(getProfilePath(profileName), JSON.stringify(config, null, 2));
+}
+function getApiKey() {
+  return process.env.NAMECHEAP_API_KEY || loadProfile().apiKey;
+}
+function setApiKey(apiKey) {
+  const config = loadProfile();
+  config.apiKey = apiKey;
+  saveProfile(config);
+}
+function getUsername() {
+  return process.env.NAMECHEAP_USERNAME || loadProfile().username;
+}
+function setUsername(username) {
+  const config = loadProfile();
+  config.username = username;
+  saveProfile(config);
+}
+function getClientIp() {
+  return process.env.NAMECHEAP_CLIENT_IP || loadProfile().clientIp;
+}
+function setClientIp(clientIp) {
+  const config = loadProfile();
+  config.clientIp = clientIp;
+  saveProfile(config);
+}
+function getSandbox() {
+  return process.env.NAMECHEAP_SANDBOX === "true" || loadProfile().sandbox === true;
+}
+function setSandbox(sandbox) {
+  const config = loadProfile();
+  config.sandbox = sandbox;
+  saveProfile(config);
+}
+function clearConfig() {
+  saveProfile({});
+}
+export {
+  setUsername,
+  setSandbox,
+  setCurrentProfile,
+  setClientIp,
+  setApiKey,
+  saveProfile,
+  loadProfile,
+  listProfiles,
+  getUsername,
+  getSandbox,
+  getCurrentProfile,
+  getClientIp,
+  getApiKey,
+  deleteProfile,
+  createProfile,
+  clearConfig,
+  DomainsApi,
+  DnsApi,
+  ConnectorClient,
+  ConnectorApiError,
+  Connector
+};

package/connectors/{connect-yousign → connect-namecheap}/node_modules/@types/bun/README.md

@@ -13,7 +13,7 @@ Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree
 ````
 
 ### Additional Details
- * Last updated: Mon, 02 Mar 2026 23:04:36 GMT
+ * Last updated: Wed, 18 Mar 2026 18:18:24 GMT
  * Dependencies: [bun-types](https://npmjs.com/package/bun-types)
 
 # Credits

package/connectors/{connect-yousign → connect-namecheap}/node_modules/@types/bun/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/bun",
-    "version": "1.3.10",
+    "version": "1.3.11",
     "description": "TypeScript definitions for bun",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/bun",
     "license": "MIT",
@@ -45,9 +45,9 @@
     },
     "scripts": {},
     "dependencies": {
-        "bun-types": "1.3.10"
+        "bun-types": "1.3.11"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "c93450e885b7484ba2b76848e30088d153ff99cf09b4ea543038aac6016408b2",
+    "typesPublisherContentHash": "d67fb5981faae7c06387394252518cbf5d9fb4c492cfcb6b6c055b825ac07e95",
     "typeScriptVersion": "5.2"
 }