@hasna/domains 0.0.25 → 0.0.26

package/dist/cli/index.js

@@ -993,7 +993,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          }
+          } else {}
         };
       }
       return this;
@@ -15426,7 +15426,7 @@ var init_bowser = __esm(() => {
 
 // node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
 var require_client2 = __commonJS((exports) => {
-  var __dirname = "/home/hasna/Workspace/hasna/opensource/open-domains/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
+  var __dirname = "/home/hasna/workspace/hasna/opensource/open-domains/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
   var retry = require_retry();
   var protocols = require_protocols();
   var lambdaInvokeStore = require_invoke_store();
@@ -36170,14 +36170,19 @@ __export(exports_route53, {
   upsertRecords: () => upsertRecords,
   upsertRecord: () => upsertRecord,
   updateNameservers: () => updateNameservers2,
+  transferDomain: () => transferDomain,
+  requestTransferOutAuthCode: () => requestTransferOutAuthCode,
   registerDomain: () => registerDomain2,
+  listTldPrices: () => listTldPrices,
   listRegisteredDomains: () => listRegisteredDomains,
   listRecords: () => listRecords,
   listHostedZones: () => listHostedZones,
+  getTldPrice: () => getTldPrice,
   getRegistrationStatus: () => getRegistrationStatus,
   getHostedZone: () => getHostedZone,
   getDomainDetail: () => getDomainDetail,
   getConfig: () => getConfig2,
+  findHostedZoneByNameservers: () => findHostedZoneByNameservers,
   findHostedZoneByDomain: () => findHostedZoneByDomain,
   deleteRecord: () => deleteRecord,
   deleteHostedZone: () => deleteHostedZone,
@@ -36187,26 +36192,17 @@ __export(exports_route53, {
 });
 function getConfig2() {
   return {
-    region: process.env["AWS_REGION"] || "us-east-1",
-    accessKeyId: process.env["AWS_ACCESS_KEY_ID"],
-    secretAccessKey: process.env["AWS_SECRET_ACCESS_KEY"],
-    sessionToken: process.env["AWS_SESSION_TOKEN"]
+    region: process.env["ROUTE53_REGION"] || process.env["ROUTE53_AWS_REGION"] || process.env["AWS_REGION"] || "us-east-1",
+    accessKeyId: process.env["ROUTE53_ACCESS_KEY_ID"] || process.env["AWS_ACCESS_KEY_ID"],
+    secretAccessKey: process.env["ROUTE53_SECRET_ACCESS_KEY"] || process.env["AWS_SECRET_ACCESS_KEY"],
+    sessionToken: process.env["ROUTE53_SESSION_TOKEN"] || process.env["AWS_SESSION_TOKEN"],
+    profile: process.env["ROUTE53_AWS_PROFILE"] || process.env["AWS_PROFILE"]
   };
 }
-function checkCredentials(cfg) {
-  if (cfg.accessKeyId && cfg.secretAccessKey)
-    return;
-  const hasEnv = !!(process.env["AWS_ACCESS_KEY_ID"] && process.env["AWS_SECRET_ACCESS_KEY"]);
-  const hasProfile = !!process.env["AWS_PROFILE"];
-  if (!hasEnv && !hasProfile) {
-    throw new Error("AWS credentials not configured. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY (or AWS_PROFILE) environment variables.");
-  }
-}
 function makeClients(config2) {
   const cfg = config2 ?? getConfig2();
-  checkCredentials(cfg);
   const region = cfg.region || "us-east-1";
-  const credentials = cfg.accessKeyId && cfg.secretAccessKey ? { accessKeyId: cfg.accessKeyId, secretAccessKey: cfg.secretAccessKey, sessionToken: cfg.sessionToken } : undefined;
+  const credentials = cfg.accessKeyId && cfg.secretAccessKey ? { accessKeyId: cfg.accessKeyId, secretAccessKey: cfg.secretAccessKey, sessionToken: cfg.sessionToken } : cfg.profile ? fromIni({ profile: cfg.profile }) : undefined;
   return {
     route53: new Route53Client({ region, credentials }),
     domains: new Route53DomainsClient({ region: "us-east-1", credentials })
@@ -36217,49 +36213,106 @@ async function checkAvailability3(domain, config2) {
   const result = await domains.send(new CheckDomainAvailabilityCommand({ DomainName: domain }));
   const availability = {
     domain,
-    available: result.Availability === "AVAILABLE"
+    available: result.Availability === "AVAILABLE",
+    availability: result.Availability ?? "UNKNOWN"
   };
-  try {
-    const tld = domain.split(".").slice(1).join(".");
-    const prices = await domains.send(new ListPricesCommand({ Tld: tld, MaxItems: 1 }));
-    const price = prices.Prices?.[0];
-    if (price) {
-      availability.currency = price.RegistrationPrice?.Currency ?? price.RenewalPrice?.Currency ?? price.TransferPrice?.Currency;
-      if (price.RegistrationPrice?.Price != null)
-        availability.price = price.RegistrationPrice.Price.toString();
-      if (price.RenewalPrice?.Price != null)
-        availability.renewal_price = price.RenewalPrice.Price.toString();
-      if (price.TransferPrice?.Price != null)
-        availability.transfer_price = price.TransferPrice.Price.toString();
-    }
-  } catch {}
+  if (availability.available) {
+    try {
+      const tld = domain.split(".").slice(1).join(".");
+      const price = await getTldPrice(tld, config2);
+      if (price) {
+        availability.currency = price.currency;
+        availability.price = price.registration_price;
+        availability.renewal_price = price.renewal_price;
+        availability.transfer_price = price.transfer_price;
+      }
+    } catch {}
+  }
   return availability;
 }
-async function registerDomain2(domain, contact, durationYears = 1, autoRenew = true, config2) {
+function normalizeTld(tld) {
+  return tld.trim().replace(/^\./, "");
+}
+function priceString(value) {
+  return value == null ? undefined : value.toString();
+}
+function tldPriceFromRoute53Price(tld, price) {
+  return {
+    tld: price.Name || tld,
+    registration_price: priceString(price.RegistrationPrice?.Price),
+    renewal_price: priceString(price.RenewalPrice?.Price),
+    transfer_price: priceString(price.TransferPrice?.Price),
+    currency: price.RegistrationPrice?.Currency ?? price.RenewalPrice?.Currency ?? price.TransferPrice?.Currency
+  };
+}
+async function getTldPrice(tld, config2) {
+  const { domains } = makeClients(config2);
+  const normalized = normalizeTld(tld);
+  const prices = await domains.send(new ListPricesCommand({ Tld: normalized, MaxItems: 1 }));
+  const price = prices.Prices?.[0];
+  return price ? tldPriceFromRoute53Price(normalized, price) : null;
+}
+async function listTldPrices(config2) {
+  const { domains } = makeClients(config2);
+  const prices = [];
+  let marker;
+  do {
+    const result = await domains.send(new ListPricesCommand({ Marker: marker, MaxItems: 100 }));
+    for (const price of result.Prices ?? []) {
+      prices.push(tldPriceFromRoute53Price(price.Name || "", price));
+    }
+    marker = result.NextPageMarker;
+  } while (marker);
+  return prices;
+}
+async function registerDomain2(domain, contact, durationYears = 1, autoRenew = true, config2, options = {}) {
   const { domains } = makeClients(config2);
-  const contactDetail = {
+  const contactDetail = contactToRoute53Contact(contact);
+  const result = await domains.send(new RegisterDomainCommand({
+    DomainName: domain,
+    DurationInYears: durationYears,
+    AutoRenew: autoRenew,
+    AdminContact: contactDetail,
+    RegistrantContact: contactDetail,
+    TechContact: contactDetail,
+    PrivacyProtectAdminContact: options.privacy_protected ?? true,
+    PrivacyProtectRegistrantContact: options.privacy_protected ?? true,
+    PrivacyProtectTechContact: options.privacy_protected ?? true,
+    ...options.nameservers?.length ? { Nameservers: options.nameservers.map((Name) => ({ Name })) } : {}
+  }));
+  return { operationId: result.OperationId ?? "" };
+}
+function contactToRoute53Contact(contact) {
+  return {
     FirstName: contact.first_name,
     LastName: contact.last_name,
     Email: contact.email,
     PhoneNumber: contact.phone,
     AddressLine1: contact.address_line_1,
+    ...contact.address_line_2 ? { AddressLine2: contact.address_line_2 } : {},
     City: contact.city,
-    State: contact.state,
-    CountryCode: contact.country_code,
+    ...contact.state ? { State: contact.state } : {},
+    CountryCode: contact.country_code.toUpperCase(),
     ZipCode: contact.zip_code,
     ContactType: contact.organization_name ? "COMPANY" : "PERSON",
     ...contact.organization_name ? { OrganizationName: contact.organization_name } : {}
   };
-  const result = await domains.send(new RegisterDomainCommand({
+}
+async function transferDomain(domain, authCode, contact, durationYears = 1, autoRenew = true, config2, options = {}) {
+  const { domains } = makeClients(config2);
+  const contactDetail = contactToRoute53Contact(contact);
+  const result = await domains.send(new TransferDomainCommand({
     DomainName: domain,
+    AuthCode: authCode,
     DurationInYears: durationYears,
     AutoRenew: autoRenew,
     AdminContact: contactDetail,
     RegistrantContact: contactDetail,
     TechContact: contactDetail,
-    PrivacyProtectAdminContact: true,
-    PrivacyProtectRegistrantContact: true,
-    PrivacyProtectTechContact: true
+    PrivacyProtectAdminContact: options.privacy_protected ?? true,
+    PrivacyProtectRegistrantContact: options.privacy_protected ?? true,
+    PrivacyProtectTechContact: options.privacy_protected ?? true,
+    ...options.nameservers?.length ? { Nameservers: options.nameservers.map((Name) => ({ Name })) } : {}
   }));
   return { operationId: result.OperationId ?? "" };
 }
@@ -36274,14 +36327,60 @@ async function getRegistrationStatus(operationId, config2) {
 }
 async function getDomainDetail(domain, config2) {
   const { domains } = makeClients(config2);
-  const result = await domains.send(new GetDomainDetailCommand({ DomainName: domain }));
+  const [result, summary] = await Promise.all([
+    domains.send(new GetDomainDetailCommand({ DomainName: domain })),
+    getDomainSummary(domain, config2)
+  ]);
+  const privacy = result;
   return {
     domain: result.DomainName ?? domain,
-    expiry: result.ExpirationDate?.toISOString() ?? "",
-    auto_renew: result.AutoRenew ?? false,
-    transfer_lock: result.StatusList?.includes("TRANSFER_LOCK") ?? false,
+    expiry: result.ExpirationDate?.toISOString() ?? summary?.expiry ?? "",
+    auto_renew: result.AutoRenew ?? summary?.auto_renew ?? null,
+    transfer_lock: summary?.transfer_lock ?? (result.StatusList?.includes("TRANSFER_LOCK") ? true : null),
     created: result.CreationDate?.toISOString() ?? "",
-    nameservers: (result.Nameservers ?? []).map((ns) => ns.Name ?? "").filter(Boolean)
+    updated: result.UpdatedDate?.toISOString() ?? "",
+    nameservers: (result.Nameservers ?? []).map((ns) => ns.Name ?? "").filter(Boolean),
+    status_list: result.StatusList ?? [],
+    registrar_name: result.RegistrarName,
+    privacy_protected: privacy.RegistrantPrivacy ?? privacy.AdminPrivacy ?? privacy.TechPrivacy ?? null
+  };
+}
+async function getDomainSummary(domain, config2) {
+  let marker;
+  do {
+    const { domains } = makeClients(config2);
+    const result = await domains.send(new ListDomainsCommand({ Marker: marker, MaxItems: 100 }));
+    const summary = (result.Domains ?? []).find((item) => item.DomainName === domain);
+    if (summary) {
+      return {
+        domain: summary.DomainName ?? domain,
+        expiry: summary.Expiry?.toISOString() ?? "",
+        auto_renew: summary.AutoRenew ?? false,
+        transfer_lock: summary.TransferLock ?? false
+      };
+    }
+    marker = result.NextPageMarker;
+  } while (marker);
+  return null;
+}
+async function requestTransferOutAuthCode(domain, config2) {
+  const { domains } = makeClients(config2);
+  const detail = await getDomainDetail(domain, config2);
+  let transferLockDisabled = false;
+  let transferLockOperationId = null;
+  if (detail.transfer_lock) {
+    const result = await domains.send(new DisableDomainTransferLockCommand({ DomainName: domain }));
+    transferLockDisabled = true;
+    transferLockOperationId = result.OperationId ?? null;
+  }
+  const authCodeResult = await domains.send(new RetrieveDomainAuthCodeCommand({ DomainName: domain }));
+  if (!authCodeResult.AuthCode) {
+    throw new Error("Route53 did not return a domain transfer authorization code");
+  }
+  return {
+    auth_code: authCodeResult.AuthCode,
+    transfer_lock_disabled: transferLockDisabled,
+    transfer_lock_operation_id: transferLockOperationId
   };
 }
 async function updateNameservers2(domain, nameservers, config2, client2) {
@@ -36319,9 +36418,22 @@ function cleanZoneId(id) {
 function normalizeZoneId(id) {
   return cleanZoneId(id.trim());
 }
-async function createHostedZone(domain, comment, config2) {
+function normalizeNameserver(value) {
+  return value.trim().toLowerCase().replace(/\.$/, "");
+}
+function nameserversMatch(a4, b4) {
+  if (a4.length !== b4.length)
+    return false;
+  const left = [...new Set(a4.map(normalizeNameserver))].sort();
+  const right = [...new Set(b4.map(normalizeNameserver))].sort();
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function cleanChangeId(id) {
+  return id?.replace("/change/", "") || null;
+}
+async function createHostedZone(domain, comment, config2, options) {
   const { route53 } = makeClients(config2);
-  const callerRef = `domains-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const callerRef = options?.callerReference ?? `domains-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const result = await route53.send(new CreateHostedZoneCommand({
     Name: domain,
     CallerReference: callerRef,
@@ -36368,7 +36480,38 @@ async function getHostedZone(hostedZoneId, config2) {
 }
 async function deleteHostedZone(hostedZoneId, config2) {
   const { route53 } = makeClients(config2);
-  await route53.send(new DeleteHostedZoneCommand({ Id: normalizeZoneId(hostedZoneId) }));
+  const zoneId = normalizeZoneId(hostedZoneId);
+  const managedRecords = [];
+  let nextName;
+  let nextType;
+  let nextIdentifier;
+  do {
+    const result = await route53.send(new ListResourceRecordSetsCommand({
+      HostedZoneId: zoneId,
+      StartRecordName: nextName,
+      StartRecordType: nextType,
+      StartRecordIdentifier: nextIdentifier
+    }));
+    managedRecords.push(...result.ResourceRecordSets?.filter((record) => record.Type !== "NS" && record.Type !== "SOA") ?? []);
+    nextName = result.IsTruncated ? result.NextRecordName : undefined;
+    nextType = result.IsTruncated ? result.NextRecordType : undefined;
+    nextIdentifier = result.IsTruncated ? result.NextRecordIdentifier : undefined;
+  } while (nextName && nextType);
+  for (let index = 0;index < managedRecords.length; index += 100) {
+    const batch = managedRecords.slice(index, index + 100);
+    if (batch.length === 0)
+      continue;
+    await route53.send(new ChangeResourceRecordSetsCommand({
+      HostedZoneId: zoneId,
+      ChangeBatch: {
+        Changes: batch.map((record) => ({
+          Action: "DELETE",
+          ResourceRecordSet: record
+        }))
+      }
+    }));
+  }
+  await route53.send(new DeleteHostedZoneCommand({ Id: zoneId }));
 }
 async function findHostedZoneByDomain(domain, config2) {
   const zones = await listHostedZones(config2);
@@ -36383,6 +36526,24 @@ async function findHostedZoneByDomain(domain, config2) {
   }
   return candidates[0] ?? null;
 }
+async function findHostedZoneByNameservers(domain, nameservers, config2) {
+  if (!nameservers.length)
+    return null;
+  const { route53 } = makeClients(config2);
+  const result = await route53.send(new ListHostedZonesByNameCommand({ DNSName: domain }));
+  const zones = (result.HostedZones ?? []).filter((zone) => zone.Name?.replace(/\.$/, "") === domain && !zone.Config?.PrivateZone);
+  for (const zone of zones) {
+    const id = cleanZoneId(zone.Id ?? "");
+    if (!id)
+      continue;
+    const detail = await getHostedZone(id, config2);
+    const delegatedNameservers = detail.name_servers ?? [];
+    if (nameserversMatch(delegatedNameservers, nameservers)) {
+      return { ...detail, id, name_servers: delegatedNameservers };
+    }
+  }
+  return null;
+}
 function rrsToRecord(rrs) {
   if (rrs.AliasTarget) {
     return {
@@ -36446,36 +36607,44 @@ async function listRecords(hostedZoneId, config2) {
   } while (nextName);
   return records;
 }
-async function upsertRecord(hostedZoneId, record, config2) {
+async function upsertRecord(hostedZoneId, record, config2, options) {
   const { route53 } = makeClients(config2);
-  await route53.send(new ChangeResourceRecordSetsCommand({
+  const result = await route53.send(new ChangeResourceRecordSetsCommand({
     HostedZoneId: normalizeZoneId(hostedZoneId),
     ChangeBatch: {
+      ...options?.comment ? { Comment: options.comment } : {},
       Changes: [{ Action: "UPSERT", ResourceRecordSet: recordToRrs(record) }]
     }
   }));
+  return { changeId: cleanChangeId(result.ChangeInfo?.Id) };
 }
-async function deleteRecord(hostedZoneId, record, config2) {
+async function deleteRecord(hostedZoneId, record, config2, options) {
   const { route53 } = makeClients(config2);
-  await route53.send(new ChangeResourceRecordSetsCommand({
+  const result = await route53.send(new ChangeResourceRecordSetsCommand({
     HostedZoneId: normalizeZoneId(hostedZoneId),
     ChangeBatch: {
+      ...options?.comment ? { Comment: options.comment } : {},
       Changes: [{ Action: "DELETE", ResourceRecordSet: recordToRrs(record) }]
     }
   }));
+  return { changeId: cleanChangeId(result.ChangeInfo?.Id) };
 }
-async function upsertRecords(hostedZoneId, records, config2) {
+async function upsertRecords(hostedZoneId, records, config2, options) {
   if (records.length === 0)
-    return;
+    return { changeId: null };
   const { route53 } = makeClients(config2);
   const changes = records.map((r4) => ({
     Action: "UPSERT",
     ResourceRecordSet: recordToRrs(r4)
   }));
-  await route53.send(new ChangeResourceRecordSetsCommand({
+  const result = await route53.send(new ChangeResourceRecordSetsCommand({
     HostedZoneId: normalizeZoneId(hostedZoneId),
-    ChangeBatch: { Changes: changes }
+    ChangeBatch: {
+      ...options?.comment ? { Comment: options.comment } : {},
+      Changes: changes
+    }
   }));
+  return { changeId: cleanChangeId(result.ChangeInfo?.Id) };
 }
 function createRoute53Provider(config2) {
   const cfg = config2 ?? getConfig2();
@@ -36538,7 +36707,7 @@ function createRoute53Provider(config2) {
         expires: detail.expiry,
         nameservers: detail.nameservers,
         status: "active",
-        auto_renew: detail.auto_renew
+        auto_renew: detail.auto_renew ?? false
       };
     },
     async registerDomain(domain, contact, options = {}) {
@@ -36653,6 +36822,7 @@ function createRoute53Provider(config2) {
 var init_route53 = __esm(() => {
   init_dist_es12();
   init_dist_es13();
+  init_dist_es9();
 });
 
 // src/lib/env-aliases.ts
@@ -36689,7 +36859,16 @@ function providerEnvNames(provider) {
     case "cloudflare":
       return flattenEnvNames([CLOUDFLARE_ENV.apiToken, CLOUDFLARE_ENV.apiKey, CLOUDFLARE_ENV.email, CLOUDFLARE_ENV.accountId]);
     case "route53":
-      return ["AWS_PROFILE", "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"];
+      return flattenEnvNames([
+        ROUTE53_ENV.profile,
+        ROUTE53_ENV.accessKeyId,
+        ROUTE53_ENV.secretAccessKey,
+        ROUTE53_ENV.sessionToken,
+        ROUTE53_ENV.region,
+        ROUTE53_ENV.webIdentityTokenFile,
+        ROUTE53_ENV.roleArn,
+        ROUTE53_ENV.containerCredentials
+      ]);
     default:
       return [];
   }
@@ -36709,13 +36888,18 @@ function hasProviderCredentials(provider, env = process.env) {
       const keyMode = hasEveryEnv(env, [CLOUDFLARE_ENV.apiKey, CLOUDFLARE_ENV.email]);
       return tokenMode || keyMode;
     }
-    case "route53":
-      return !!env["AWS_PROFILE"] || hasEveryEnv(env, [["AWS_ACCESS_KEY_ID"], ["AWS_SECRET_ACCESS_KEY"]]);
+    case "route53": {
+      const profileMode = !!firstEnv(env, ROUTE53_ENV.profile);
+      const keyMode = hasEveryEnv(env, [ROUTE53_ENV.accessKeyId, ROUTE53_ENV.secretAccessKey]);
+      const webIdentityMode = hasEveryEnv(env, [ROUTE53_ENV.webIdentityTokenFile, ROUTE53_ENV.roleArn]);
+      const containerMode = !!firstEnv(env, ROUTE53_ENV.containerCredentials);
+      return profileMode || keyMode || webIdentityMode || containerMode;
+    }
     default:
       return false;
   }
 }
-var NAMECHEAP_ENV, GODADDY_ENV, BRANDSIGHT_ENV, SEDO_ENV, CLOUDFLARE_ENV;
+var NAMECHEAP_ENV, GODADDY_ENV, BRANDSIGHT_ENV, SEDO_ENV, CLOUDFLARE_ENV, ROUTE53_ENV;
 var init_env_aliases = __esm(() => {
   NAMECHEAP_ENV = {
     apiKey: ["NAMECHEAP_API_KEY"],
@@ -36745,6 +36929,19 @@ var init_env_aliases = __esm(() => {
     email: ["CLOUDFLARE_EMAIL"],
     accountId: ["CLOUDFLARE_ACCOUNT_ID"]
   };
+  ROUTE53_ENV = {
+    accessKeyId: ["ROUTE53_ACCESS_KEY_ID", "AWS_ACCESS_KEY_ID"],
+    secretAccessKey: ["ROUTE53_SECRET_ACCESS_KEY", "AWS_SECRET_ACCESS_KEY"],
+    sessionToken: ["ROUTE53_SESSION_TOKEN", "AWS_SESSION_TOKEN"],
+    profile: ["ROUTE53_AWS_PROFILE", "AWS_PROFILE"],
+    region: ["ROUTE53_REGION", "ROUTE53_AWS_REGION", "AWS_REGION"],
+    webIdentityTokenFile: ["AWS_WEB_IDENTITY_TOKEN_FILE"],
+    roleArn: ["AWS_ROLE_ARN"],
+    containerCredentials: [
+      "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI",
+      "AWS_CONTAINER_CREDENTIALS_FULL_URI"
+    ]
+  };
 });
 
 // src/lib/cloudflare-auth.ts
@@ -36774,12 +36971,12 @@ var init_cloudflare_auth = __esm(() => {
 function getConfig3() {
   return resolveCloudflareConfig();
 }
-function checkCredentials2(cfg) {
+function checkCredentials(cfg) {
   cloudflareAuthHeaders(cfg);
 }
 async function cfFetch(path, opts = {}) {
   const cfg = opts.config ?? getConfig3();
-  checkCredentials2(cfg);
+  checkCredentials(cfg);
   const res = await fetch(`${CF_BASE}${path}`, {
     method: opts.method ?? "GET",
     headers: {
@@ -37689,12 +37886,16 @@ __export(exports_sedo, {
   resolveSedoConfig: () => resolveSedoConfig,
   removeDomainFromSedo: () => removeDomainFromSedo,
   recordSedoPurchase: () => recordSedoPurchase,
+  parseSedoSearchResponse: () => parseSedoSearchResponse,
+  parseSedoFault: () => parseSedoFault,
   listSedoPortfolio: () => listSedoPortfolio,
   getSedoConfig: () => getSedoConfig,
   editDomainOnSedo: () => editDomainOnSedo,
   checkSedoStatus: () => checkSedoStatus,
   checkSedoBlacklist: () => checkSedoBlacklist,
-  addDomainToSedo: () => addDomainToSedo
+  buildSedoSearchParams: () => buildSedoSearchParams,
+  addDomainToSedo: () => addDomainToSedo,
+  SEDO_CURRENCY_CODES: () => SEDO_CURRENCY_CODES
 });
 function resolveSedoConfig(env = process.env) {
   return {
@@ -37721,17 +37922,17 @@ function sedoCapability(env = process.env) {
     notes: configured ? "Credentials present; Sedo supports marketplace search, portfolio listing, listing edits, and recorded purchases, but not registrar DNS or direct self-serve registration through this CLI." : "Not configured; Sedo is marketplace-only here, not registrar DNS."
   };
 }
-function buildXmlParams(params) {
+function buildAuthParams(config2) {
   return {
-    partnerid: params.partnerId,
-    signkey: params.signKey,
-    username: params.username,
-    password: params.password
+    partnerid: config2.partnerId,
+    signkey: config2.signKey,
+    username: config2.username,
+    password: config2.password
   };
 }
-async function sedoRequest(action, config2, extraParams = {}) {
+async function sedoRequestRaw(action, config2, extraParams = {}) {
   const params = new URLSearchParams({
-    ...buildXmlParams(config2),
+    ...buildAuthParams(config2),
     output_method: "xml",
     ...Object.fromEntries(Object.entries(extraParams).map(([k4, v2]) => [k4, String(v2)]))
   });
@@ -37740,9 +37941,23 @@ async function sedoRequest(action, config2, extraParams = {}) {
   if (!resp.ok) {
     throw new Error(`Sedo API ${action} failed: ${resp.status} ${resp.statusText}`);
   }
-  const text = await resp.text();
+  return resp.text();
+}
+async function sedoRequest(action, config2, extraParams = {}) {
+  const text = await sedoRequestRaw(action, config2, extraParams);
+  const fault = parseSedoFault(text);
+  if (fault) {
+    throw new Error(`Sedo API ${action} fault ${fault.code}: ${fault.message}`);
+  }
   return parseSedoXml(text);
 }
+function parseSedoFault(xml) {
+  if (!/<SEDOFAULT\b/i.test(xml))
+    return null;
+  const code = xml.match(/<faultcode[^>]*>([^<]*)<\/faultcode>/i)?.[1]?.trim() || "UNKNOWN";
+  const message = xml.match(/<faultstring[^>]*>([^<]*)<\/faultstring>/i)?.[1]?.trim() || code;
+  return { code, message };
+}
 function parseSedoXml(xml) {
   const result = {};
   const itemMatches = xml.match(/<item[^>]*>([\s\S]*?)<\/item>/g);
@@ -37768,11 +37983,12 @@ function parseSedoItemXml(itemXml) {
   }
   return obj;
 }
-async function searchSedoDomains(query, options = {}) {
-  const config2 = getSedoConfig();
+function buildSedoSearchParams(query, options = {}) {
   const params = {
-    searchword: query,
-    limit: options.limit || 100
+    keyword: query,
+    kwtype: options.kwtype || "C",
+    resultsize: options.limit || 100,
+    language: options.language || "en"
   };
   if (options.tld)
     params.tld = options.tld;
@@ -37780,20 +37996,35 @@ async function searchSedoDomains(query, options = {}) {
     params.price_min = options.minPrice;
   if (options.maxPrice)
     params.price_max = options.maxPrice;
-  const response = await sedoRequest("DomainSearch", config2, params);
+  return params;
+}
+function parseSedoSearchResponse(xml) {
+  const fault = parseSedoFault(xml);
+  if (fault) {
+    throw new Error(`Sedo DomainSearch fault ${fault.code}: ${fault.message}`);
+  }
+  const response = parseSedoXml(xml);
   const items = response.items || [];
-  const domains = items.map((item) => ({
-    domain: item.domain || "",
-    forSale: item.for_sale === "1" || item.for_sale === "true",
-    price: item.price ? parseFloat(item.price) : undefined,
-    currency: item.currency || undefined,
-    status: item.status || undefined,
-    isPremium: item.premium === "1" || item.premium === "true"
-  }));
-  return {
-    domains,
-    total: parseInt(response.total || "0") || items.length
-  };
+  const domains = items.map((item) => {
+    const rawPrice = item.price;
+    const price = rawPrice !== undefined ? parseFloat(rawPrice) : undefined;
+    const currencyCode = item.currency;
+    const currency = currencyCode !== undefined ? SEDO_CURRENCY_CODES[currencyCode] || currencyCode : undefined;
+    return {
+      domain: item.domain || "",
+      forSale: true,
+      price: price && price > 0 ? price : undefined,
+      currency: price && price > 0 ? currency : undefined,
+      status: item.type || undefined
+    };
+  });
+  return { domains, total: domains.length };
+}
+async function searchSedoDomains(query, options = {}) {
+  const config2 = getSedoConfig();
+  const params = buildSedoSearchParams(query, options);
+  const xml = await sedoRequestRaw("DomainSearch", config2, params);
+  return parseSedoSearchResponse(xml);
 }
 async function searchHealthDomains(options = {}) {
   return searchSedoDomains("health", { ...options, limit: options.limit || 100 });
@@ -37917,11 +38148,16 @@ function recordSedoPurchase(domain, price, orderId) {
   });
   return created;
 }
-var BASE_URL = "https://api.sedo.com/api/v1/";
+var BASE_URL = "https://api.sedo.com/api/v1/", SEDO_CURRENCY_CODES;
 var init_sedo = __esm(() => {
   init_env_aliases();
   init_domains();
   init_domain_history();
+  SEDO_CURRENCY_CODES = {
+    "0": "EUR",
+    "1": "USD",
+    "2": "GBP"
+  };
 });
 
 // src/lib/creds-check.ts
@@ -37937,12 +38173,16 @@ function missingStatus(provider, detail) {
 }
 function checkProvisioningCredentials(env = process.env) {
   const out = [];
-  const hasAwsKeys = !!(env["AWS_ACCESS_KEY_ID"] && env["AWS_SECRET_ACCESS_KEY"]);
-  const hasAwsProfile = !!env["AWS_PROFILE"];
-  if (hasAwsProfile || hasAwsKeys) {
-    out.push(configuredStatus("route53", hasAwsProfile ? `profile:${env["AWS_PROFILE"]}` : "access-keys", "AWS credentials present (Route 53 Domains API uses us-east-1)"));
+  const awsProfile = firstEnv(env, ROUTE53_ENV.profile);
+  const awsAccessKey = firstEnv(env, ROUTE53_ENV.accessKeyId);
+  const awsSecretKey = firstEnv(env, ROUTE53_ENV.secretAccessKey);
+  const hasAwsKeys = !!(awsAccessKey && awsSecretKey);
+  const hasWebIdentity = !!(firstEnv(env, ROUTE53_ENV.webIdentityTokenFile) && firstEnv(env, ROUTE53_ENV.roleArn));
+  const hasContainerCredentials = !!firstEnv(env, ROUTE53_ENV.containerCredentials);
+  if (awsProfile || hasAwsKeys || hasWebIdentity || hasContainerCredentials) {
+    out.push(configuredStatus("route53", awsProfile ? `profile:${awsProfile.value}` : hasAwsKeys ? "access-keys" : hasWebIdentity ? "web-identity" : "container-credentials", "AWS credentials present (Route 53 Domains API uses us-east-1)"));
   } else {
-    out.push(missingStatus("route53", "Set AWS_PROFILE or AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY"));
+    out.push(missingStatus("route53", "Set ROUTE53_AWS_PROFILE/AWS_PROFILE, ROUTE53_ACCESS_KEY_ID+ROUTE53_SECRET_ACCESS_KEY, or AWS provider-chain credentials"));
   }
   const cf = resolveCloudflareConfig(env);
   const cfMode = cf.apiToken ? "token" : cf.apiKey && cf.email ? "global-key" : "none";
@@ -38066,7 +38306,7 @@ function registerSedoCommand(program2) {
       }
       console.log(`Sedo marketplace \u2014 "${keyword}" (${result.total} total):`);
       for (const d4 of result.domains) {
-        const price = d4.price ? ` \u2014 $${d4.price.toLocaleString()} ${d4.currency || ""}` : "";
+        const price = d4.price ? ` \u2014 ${d4.price.toLocaleString()} ${d4.currency || ""}`.trimEnd() : " \u2014 make offer";
         const premium = d4.isPremium ? " [PREMIUM]" : "";
         console.log(`  ${d4.domain}${price}${premium}`);
       }
@@ -45780,691 +46020,6 @@ var init_interactive = __esm(() => {
   init_App();
 });
 
-// node_modules/@hasna/events/dist/commander.js
-var exports_commander = {};
-__export(exports_commander, {
-  registerWebhookCommands: () => registerWebhookCommands,
-  registerEventsCommands: () => registerEventsCommands,
-  registerEventCommands: () => registerEventCommands
-});
-import { chmod, mkdir, readFile as readFile2, rename, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
-import { createHmac, timingSafeEqual } from "crypto";
-import { randomUUID } from "crypto";
-import { spawn } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
-function getPathValue(input, path) {
-  return path.split(".").reduce((value, part) => {
-    if (value && typeof value === "object" && part in value) {
-      return value[part];
-    }
-    return;
-  }, input);
-}
-function wildcardToRegExp(pattern) {
-  const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
-}
-function matchString(value, matcher) {
-  if (matcher === undefined)
-    return true;
-  if (value === undefined)
-    return false;
-  const matchers = Array.isArray(matcher) ? matcher : [matcher];
-  return matchers.some((item) => wildcardToRegExp(item).test(value));
-}
-function matchRecord(input, matcher) {
-  if (!matcher)
-    return true;
-  return Object.entries(matcher).every(([path, expected]) => {
-    const actual = getPathValue(input, path);
-    if (typeof expected === "string" || Array.isArray(expected)) {
-      return matchString(actual === undefined ? undefined : String(actual), expected);
-    }
-    return actual === expected;
-  });
-}
-function eventMatchesFilter(event, filter) {
-  return matchString(event.source, filter.source) && matchString(event.type, filter.type) && matchString(event.subject, filter.subject) && matchString(event.severity, filter.severity) && matchRecord(event.data, filter.data) && matchRecord(event.metadata, filter.metadata);
-}
-function channelMatchesEvent(channel, event) {
-  if (!channel.enabled)
-    return false;
-  if (!channel.filters || channel.filters.length === 0)
-    return true;
-  return channel.filters.some((filter) => eventMatchesFilter(event, filter));
-}
-function getEventsDataDir(override) {
-  return override || process.env[HASNA_EVENTS_DIR_ENV] || process.env[HASNA_EVENTS_HOME_ENV] || join5(homedir5(), ".hasna", "events");
-}
-
-class JsonEventsStore {
-  dataDir;
-  channelsPath;
-  eventsPath;
-  deliveriesPath;
-  constructor(dataDir = getEventsDataDir()) {
-    this.dataDir = dataDir;
-    this.channelsPath = join5(dataDir, "channels.json");
-    this.eventsPath = join5(dataDir, "events.json");
-    this.deliveriesPath = join5(dataDir, "deliveries.json");
-  }
-  async init() {
-    await mkdir(this.dataDir, { recursive: true, mode: 448 });
-    await chmod(this.dataDir, 448).catch(() => {
-      return;
-    });
-    await this.ensureArrayFile(this.channelsPath);
-    await this.ensureArrayFile(this.eventsPath);
-    await this.ensureArrayFile(this.deliveriesPath);
-  }
-  async addChannel(channel) {
-    await this.init();
-    const channels = await this.readJson(this.channelsPath, []);
-    const index = channels.findIndex((item) => item.id === channel.id);
-    if (index >= 0) {
-      channels[index] = { ...channel, createdAt: channels[index].createdAt, updatedAt: new Date().toISOString() };
-    } else {
-      channels.push(channel);
-    }
-    await this.writeJson(this.channelsPath, channels);
-    return index >= 0 ? channels[index] : channel;
-  }
-  async listChannels() {
-    await this.init();
-    return this.readJson(this.channelsPath, []);
-  }
-  async getChannel(id) {
-    const channels = await this.listChannels();
-    return channels.find((channel) => channel.id === id);
-  }
-  async removeChannel(id) {
-    await this.init();
-    const channels = await this.readJson(this.channelsPath, []);
-    const next = channels.filter((channel) => channel.id !== id);
-    await this.writeJson(this.channelsPath, next);
-    return next.length !== channels.length;
-  }
-  async appendEvent(event) {
-    await this.init();
-    const events = await this.readJson(this.eventsPath, []);
-    events.push(event);
-    await this.writeJson(this.eventsPath, events);
-    return event;
-  }
-  async listEvents() {
-    await this.init();
-    return this.readJson(this.eventsPath, []);
-  }
-  async findEventByIdentity(identity2) {
-    const events = await this.listEvents();
-    return events.find((event) => identity2.id !== undefined && event.id === identity2.id || identity2.dedupeKey !== undefined && event.dedupeKey === identity2.dedupeKey);
-  }
-  async appendDelivery(result) {
-    await this.init();
-    const deliveries = await this.readJson(this.deliveriesPath, []);
-    deliveries.push(result);
-    await this.writeJson(this.deliveriesPath, deliveries);
-    return result;
-  }
-  async listDeliveries() {
-    await this.init();
-    return this.readJson(this.deliveriesPath, []);
-  }
-  async exportData() {
-    return {
-      channels: await this.listChannels(),
-      events: await this.listEvents(),
-      deliveries: await this.listDeliveries()
-    };
-  }
-  async ensureArrayFile(path) {
-    if (!existsSync4(path)) {
-      await writeFile2(path, `[]
-`, { encoding: "utf-8", mode: 384 });
-    }
-    await chmod(path, 384).catch(() => {
-      return;
-    });
-  }
-  async readJson(path, fallback) {
-    try {
-      const raw = await readFile2(path, "utf-8");
-      if (!raw.trim())
-        return fallback;
-      return JSON.parse(raw);
-    } catch (error) {
-      if (error.code === "ENOENT")
-        return fallback;
-      throw error;
-    }
-  }
-  async writeJson(path, value) {
-    const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile2(tempPath, `${JSON.stringify(value, null, 2)}
-`, { encoding: "utf-8", mode: 384 });
-    await rename(tempPath, path);
-    await chmod(path, 384).catch(() => {
-      return;
-    });
-  }
-}
-function buildSignatureBase(timestamp, body) {
-  return `${timestamp}.${body}`;
-}
-function signPayload(secret, timestamp, body) {
-  const digest = createHmac("sha256", secret).update(buildSignatureBase(timestamp, body)).digest("hex");
-  return `sha256=${digest}`;
-}
-function now() {
-  return new Date().toISOString();
-}
-function truncate(value, max = 4096) {
-  return value.length > max ? `${value.slice(0, max)}...` : value;
-}
-function buildWebhookRequest(event, channel) {
-  if (!channel.webhook)
-    throw new Error(`Channel ${channel.id} has no webhook config`);
-  const body = JSON.stringify(event);
-  const timestamp = event.time;
-  const headers = {
-    "Content-Type": "application/json",
-    "User-Agent": "@hasna/events",
-    "X-Hasna-Event-Id": event.id,
-    "X-Hasna-Event-Type": event.type,
-    "X-Hasna-Timestamp": timestamp,
-    ...channel.webhook.headers
-  };
-  if (channel.webhook.secret) {
-    headers["X-Hasna-Signature"] = signPayload(channel.webhook.secret, timestamp, body);
-  }
-  return { body, headers };
-}
-async function dispatchWebhook(event, channel, options = {}) {
-  if (!channel.webhook)
-    throw new Error(`Channel ${channel.id} has no webhook config`);
-  const startedAt = now();
-  const { body, headers } = buildWebhookRequest(event, channel);
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), channel.webhook.timeoutMs ?? 15000);
-  try {
-    const response = await (options.fetchImpl ?? fetch)(channel.webhook.url, {
-      method: "POST",
-      headers,
-      body,
-      signal: controller.signal
-    });
-    const responseBody = truncate(await response.text());
-    return {
-      attempt: 1,
-      status: response.ok ? "success" : "failed",
-      startedAt,
-      completedAt: now(),
-      responseStatus: response.status,
-      responseBody,
-      error: response.ok ? undefined : `Webhook returned HTTP ${response.status}`
-    };
-  } catch (error) {
-    return {
-      attempt: 1,
-      status: "failed",
-      startedAt,
-      completedAt: now(),
-      error: error instanceof Error ? error.message : String(error)
-    };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-async function dispatchCommand(event, channel) {
-  if (!channel.command)
-    throw new Error(`Channel ${channel.id} has no command config`);
-  const startedAt = now();
-  const eventJson = JSON.stringify(event);
-  const env = {
-    ...process.env,
-    ...channel.command.env,
-    HASNA_CHANNEL_ID: channel.id,
-    HASNA_EVENT_ID: event.id,
-    HASNA_EVENT_TYPE: event.type,
-    HASNA_EVENT_SOURCE: event.source,
-    HASNA_EVENT_SUBJECT: event.subject ?? "",
-    HASNA_EVENT_SEVERITY: event.severity,
-    HASNA_EVENT_TIME: event.time,
-    HASNA_EVENT_DEDUPE_KEY: event.dedupeKey ?? "",
-    HASNA_EVENT_SCHEMA_VERSION: event.schemaVersion,
-    HASNA_EVENT_JSON: eventJson
-  };
-  return new Promise((resolve3) => {
-    const child = spawn(channel.command.command, channel.command.args ?? [], {
-      cwd: channel.command.cwd,
-      env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    const timeout = setTimeout(() => child.kill("SIGTERM"), channel.command.timeoutMs ?? 15000);
-    child.stdin.end(eventJson);
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (error) => {
-      clearTimeout(timeout);
-      resolve3({
-        attempt: 1,
-        status: "failed",
-        startedAt,
-        completedAt: now(),
-        stdout: truncate(stdout),
-        stderr: truncate(stderr),
-        error: error.message
-      });
-    });
-    child.on("close", (code, signal) => {
-      clearTimeout(timeout);
-      const success = code === 0;
-      resolve3({
-        attempt: 1,
-        status: success ? "success" : "failed",
-        startedAt,
-        completedAt: now(),
-        stdout: truncate(stdout),
-        stderr: truncate(stderr),
-        error: success ? undefined : `Command exited with ${signal ? `signal ${signal}` : `code ${code}`}`
-      });
-    });
-  });
-}
-async function dispatchChannel(event, channel, options = {}) {
-  if (channel.transport === "webhook")
-    return dispatchWebhook(event, channel, options);
-  if (channel.transport === "command")
-    return dispatchCommand(event, channel);
-  return {
-    attempt: 1,
-    status: "skipped",
-    startedAt: now(),
-    completedAt: now(),
-    error: `Unsupported transport: ${channel.transport}`
-  };
-}
-function createDeliveryResult(event, channel, attempts) {
-  const status = attempts.some((attempt) => attempt.status === "success") ? "success" : attempts.every((attempt) => attempt.status === "skipped") ? "skipped" : "failed";
-  return {
-    id: randomUUID(),
-    eventId: event.id,
-    channelId: channel.id,
-    transport: channel.transport,
-    status,
-    attempts,
-    createdAt: attempts[0]?.startedAt ?? now(),
-    completedAt: attempts.at(-1)?.completedAt ?? now()
-  };
-}
-function createEvent(input) {
-  return {
-    id: input.id ?? randomUUID2(),
-    source: input.source,
-    type: input.type,
-    time: normalizeTime(input.time),
-    subject: input.subject,
-    severity: input.severity ?? "info",
-    data: input.data ?? {},
-    message: input.message,
-    dedupeKey: input.dedupeKey,
-    schemaVersion: input.schemaVersion ?? "1.0",
-    metadata: input.metadata ?? {}
-  };
-}
-
-class EventsClient {
-  store;
-  redactors;
-  transportOptions;
-  constructor(options = {}) {
-    this.store = options.store ?? new JsonEventsStore(options.dataDir);
-    this.redactors = options.redactors ?? [];
-    this.transportOptions = { fetchImpl: options.fetchImpl };
-  }
-  async addChannel(input) {
-    const timestamp = new Date().toISOString();
-    return this.store.addChannel({
-      ...input,
-      createdAt: input.createdAt ?? timestamp,
-      updatedAt: input.updatedAt ?? timestamp
-    });
-  }
-  async listChannels() {
-    return this.store.listChannels();
-  }
-  async removeChannel(id) {
-    return this.store.removeChannel(id);
-  }
-  async emit(input, options = {}) {
-    const event = options.redactSensitiveData === false ? createEvent(input) : redactSensitiveKeys(createEvent(input));
-    if (options.dedupe !== false) {
-      const existing = await this.store.findEventByIdentity({ id: input.id, dedupeKey: event.dedupeKey });
-      if (existing) {
-        return { event: existing, deliveries: [], deduped: true };
-      }
-    }
-    await this.store.appendEvent(event);
-    const deliveries = options.deliver === false ? [] : await this.deliver(event);
-    return { event, deliveries, deduped: false };
-  }
-  async listEvents() {
-    return this.store.listEvents();
-  }
-  async listDeliveries() {
-    return this.store.listDeliveries();
-  }
-  async deliver(event) {
-    const channels = await this.store.listChannels();
-    const selected = channels.filter((channel) => channelMatchesEvent(channel, event));
-    const deliveries = [];
-    for (const channel of selected) {
-      const eventForChannel = await this.applyRedaction(event, channel);
-      const result = await this.deliverWithRetry(eventForChannel, channel);
-      await this.store.appendDelivery(result);
-      deliveries.push(result);
-    }
-    return deliveries;
-  }
-  async testChannel(id, input = {}) {
-    const channel = await this.store.getChannel(id);
-    if (!channel)
-      throw new Error(`Channel not found: ${id}`);
-    const event = createEvent({
-      source: input.source ?? "hasna.events",
-      type: input.type ?? "events.test",
-      subject: input.subject ?? id,
-      severity: input.severity ?? "info",
-      data: input.data ?? { test: true },
-      message: input.message ?? "Hasna events test delivery",
-      dedupeKey: input.dedupeKey,
-      schemaVersion: input.schemaVersion,
-      metadata: input.metadata,
-      time: input.time,
-      id: input.id
-    });
-    const eventForChannel = await this.applyRedaction(event, channel);
-    const result = await this.deliverWithRetry(eventForChannel, channel);
-    await this.store.appendDelivery(result);
-    return result;
-  }
-  async replay(options = {}) {
-    const events = (await this.store.listEvents()).filter((event) => {
-      if (options.eventId && event.id !== options.eventId)
-        return false;
-      if (options.source && event.source !== options.source)
-        return false;
-      if (options.type && event.type !== options.type)
-        return false;
-      return true;
-    });
-    if (options.dryRun)
-      return { events, deliveries: [] };
-    const deliveries = [];
-    for (const event of events) {
-      deliveries.push(...await this.deliver(event));
-    }
-    return { events, deliveries };
-  }
-  async applyRedaction(event, channel) {
-    let next = redactPaths(event, channel.redact?.paths ?? [], channel.redact?.replacement ?? "[REDACTED]");
-    for (const redactor of this.redactors) {
-      next = await redactor(next, channel);
-    }
-    return next;
-  }
-  async deliverWithRetry(event, channel) {
-    const policy = normalizeRetryPolicy(channel.retry);
-    const attempts = [];
-    for (let index = 0;index < policy.maxAttempts; index += 1) {
-      const attempt = await dispatchChannel(event, channel, this.transportOptions);
-      attempt.attempt = index + 1;
-      if (attempt.status === "failed" && index + 1 < policy.maxAttempts) {
-        attempt.nextBackoffMs = Math.round(policy.backoffMs * policy.multiplier ** index);
-      }
-      attempts.push(attempt);
-      if (attempt.status !== "failed")
-        break;
-      if (attempt.nextBackoffMs)
-        await Bun.sleep(attempt.nextBackoffMs);
-    }
-    return createDeliveryResult(event, channel, attempts);
-  }
-}
-function redactPaths(event, paths, replacement = "[REDACTED]") {
-  if (paths.length === 0)
-    return event;
-  const copy = structuredClone(event);
-  for (const path of paths) {
-    setPath(copy, path, replacement);
-  }
-  return copy;
-}
-function sanitizeChannelForOutput(channel) {
-  const copy = structuredClone(channel);
-  if (copy.webhook?.secret)
-    copy.webhook.secret = "[REDACTED]";
-  if (copy.command?.env) {
-    copy.command.env = Object.fromEntries(Object.entries(copy.command.env).map(([key, value]) => [key, shouldRedactKey(key) ? "[REDACTED]" : value]));
-  }
-  return copy;
-}
-function sanitizeChannelsForOutput(channels) {
-  return channels.map(sanitizeChannelForOutput);
-}
-function redactSensitiveKeys(event, replacement = "[REDACTED]") {
-  return redactValue(event, replacement);
-}
-function shouldRedactKey(key) {
-  return /secret|token|password|api[_-]?key|authorization/i.test(key);
-}
-function redactValue(value, replacement) {
-  if (Array.isArray(value))
-    return value.map((item) => redactValue(item, replacement));
-  if (!value || typeof value !== "object")
-    return value;
-  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-    key,
-    shouldRedactKey(key) ? replacement : redactValue(item, replacement)
-  ]));
-}
-function setPath(input, path, replacement) {
-  const parts = path.split(".");
-  let cursor = input;
-  for (const part of parts.slice(0, -1)) {
-    const next = cursor[part];
-    if (!next || typeof next !== "object")
-      return;
-    cursor = next;
-  }
-  const last = parts.at(-1);
-  if (last && last in cursor)
-    cursor[last] = replacement;
-}
-function normalizeTime(value) {
-  if (!value)
-    return new Date().toISOString();
-  return value instanceof Date ? value.toISOString() : value;
-}
-function normalizeRetryPolicy(policy) {
-  return {
-    maxAttempts: Math.max(1, policy?.maxAttempts ?? 1),
-    backoffMs: Math.max(0, policy?.backoffMs ?? 250),
-    multiplier: Math.max(1, policy?.multiplier ?? 2)
-  };
-}
-function parseJsonObject(value, fallback) {
-  if (!value)
-    return fallback;
-  const parsed = JSON.parse(value);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error("Expected a JSON object");
-  }
-  return parsed;
-}
-function parseHeaders(values) {
-  if (!values?.length)
-    return;
-  const headers = {};
-  for (const value of values) {
-    const separator = value.indexOf("=");
-    if (separator === -1)
-      throw new Error(`Invalid header, expected name=value: ${value}`);
-    headers[value.slice(0, separator)] = value.slice(separator + 1);
-  }
-  return headers;
-}
-function parseFilter(options) {
-  const filter2 = {};
-  if (options.source)
-    filter2.source = options.source;
-  if (options.type)
-    filter2.type = options.type;
-  if (options.subject)
-    filter2.subject = options.subject;
-  if (options.severity)
-    filter2.severity = options.severity;
-  return Object.keys(filter2).length > 0 ? [filter2] : undefined;
-}
-function createClient(options) {
-  if (options.createClient)
-    return options.createClient();
-  return new EventsClient({ store: new JsonEventsStore(options.dataDir) });
-}
-function print(value, json, text) {
-  if (json)
-    console.log(JSON.stringify(value, null, 2));
-  else
-    console.log(text);
-}
-function registerWebhookCommands(program2, options) {
-  const webhooks = program2.command(options.webhooksCommandName ?? "webhooks").description("Manage Hasna event webhook subscriptions");
-  webhooks.command("add").description("Add or replace a webhook or command subscription").argument("<target>", "Webhook URL or command binary").requiredOption("--id <id>", "Subscription/channel identifier").option("--transport <kind>", "Transport kind: webhook or command", "webhook").option("--name <name>", "Display name").option("--type <pattern>", "Event type filter, e.g. todos.task.*").option("--source <pattern>", "Event source filter").option("--subject <pattern>", "Event subject filter").option("--severity <pattern>", "Event severity filter").option("--secret <secret>", "Webhook HMAC secret").option("--header <name=value...>", "Webhook header", collectValues, []).option("--arg <arg...>", "Command argument", collectValues, []).option("--timeout-ms <ms>", "Transport timeout in milliseconds", parseNumber).option("--retry-attempts <n>", "Maximum delivery attempts", parseNumber).option("--retry-backoff-ms <ms>", "Initial retry backoff in milliseconds", parseNumber).option("--redact <path...>", "Event field path to redact before delivery", collectValues, []).option("--disabled", "Create channel disabled", false).option("-j, --json", "Print JSON output", false).action(async (target, actionOptions) => {
-    const timestamp = new Date().toISOString();
-    const channel = {
-      id: actionOptions.id,
-      name: actionOptions.name,
-      enabled: !actionOptions.disabled,
-      transport: actionOptions.transport,
-      filters: parseFilter(actionOptions),
-      retry: actionOptions.retryAttempts || actionOptions.retryBackoffMs ? { maxAttempts: actionOptions.retryAttempts, backoffMs: actionOptions.retryBackoffMs } : undefined,
-      redact: actionOptions.redact?.length ? { paths: actionOptions.redact } : undefined,
-      createdAt: timestamp,
-      updatedAt: timestamp
-    };
-    if (actionOptions.transport === "webhook") {
-      channel.webhook = { url: target, secret: actionOptions.secret, headers: parseHeaders(actionOptions.header), timeoutMs: actionOptions.timeoutMs };
-    } else if (actionOptions.transport === "command") {
-      channel.command = { command: target, args: actionOptions.arg ?? [], timeoutMs: actionOptions.timeoutMs };
-    } else {
-      throw new Error(`Transport ${actionOptions.transport} is reserved for future use and cannot be added yet`);
-    }
-    const saved = await createClient(options).addChannel(channel);
-    print(sanitizeChannelForOutput(saved), Boolean(actionOptions.json), `Added ${saved.transport} channel ${saved.id}`);
-  });
-  webhooks.command("list").description("List configured subscriptions").option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
-    const channels = await createClient(options).listChannels();
-    if (actionOptions.json) {
-      console.log(JSON.stringify(sanitizeChannelsForOutput(channels), null, 2));
-      return;
-    }
-    if (!channels.length) {
-      console.log("No channels configured.");
-      return;
-    }
-    for (const channel of channels) {
-      console.log(`${channel.id}	${channel.enabled ? "enabled" : "disabled"}	${channel.transport}	${channel.webhook?.url ?? channel.command?.command ?? channel.transport}`);
-    }
-  });
-  webhooks.command("remove").description("Remove a subscription").argument("<id>", "Subscription/channel identifier").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions) => {
-    const removed = await createClient(options).removeChannel(id);
-    print({ removed }, Boolean(actionOptions.json), removed ? `Removed ${id}` : `Channel not found: ${id}`);
-  });
-  webhooks.command("test").description("Send a test event to one subscription").argument("<id>", "Subscription/channel identifier").option("--type <type>", "Event type", "events.test").option("--subject <subject>", "Event subject").option("--message <message>", "Event message", "Hasna events test delivery").option("--data <json>", "Event data JSON object").option("-j, --json", "Print JSON output", false).action(async (id, actionOptions) => {
-    const result = await createClient(options).testChannel(id, {
-      source: options.source,
-      type: actionOptions.type,
-      subject: actionOptions.subject ?? id,
-      message: actionOptions.message,
-      data: parseJsonObject(actionOptions.data, { test: true })
-    });
-    print(result, Boolean(actionOptions.json), `${result.status}: ${result.channelId}`);
-  });
-  return webhooks;
-}
-function registerEventCommands(program2, options) {
-  const events = program2.command(options.eventsCommandName ?? "events").description("Emit, list, and replay Hasna events");
-  events.command("emit").description("Emit an event from this app").argument("<type>", "Event type").option("--source <source>", "Event source override").option("--subject <subject>", "Event subject").option("--severity <severity>", "Event severity", "info").option("--message <message>", "Event message").option("--dedupe-key <key>", "Dedupe key").option("--data <json>", "Event data JSON object").option("--metadata <json>", "Event metadata JSON object").option("--no-deliver", "Record without delivering").option("--no-dedupe", "Allow duplicate id/dedupeKey events").option("-j, --json", "Print JSON output", false).action(async (type, actionOptions) => {
-    const result = await createClient(options).emit({
-      source: actionOptions.source ?? options.source,
-      type,
-      subject: actionOptions.subject,
-      severity: actionOptions.severity,
-      message: actionOptions.message,
-      dedupeKey: actionOptions.dedupeKey,
-      data: parseJsonObject(actionOptions.data, {}),
-      metadata: parseJsonObject(actionOptions.metadata, {})
-    }, { deliver: actionOptions.deliver, dedupe: actionOptions.dedupe });
-    print(result, Boolean(actionOptions.json), `${result.deduped ? "Deduped" : "Emitted"} ${result.event.id} to ${result.deliveries.length} channel(s)`);
-  });
-  events.command("list").description("List recorded events").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--limit <n>", "Limit results", parseNumber).option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
-    let rows = await createClient(options).listEvents();
-    if (actionOptions.source)
-      rows = rows.filter((event) => event.source === actionOptions.source);
-    if (actionOptions.type)
-      rows = rows.filter((event) => event.type === actionOptions.type);
-    if (actionOptions.limit)
-      rows = rows.slice(-actionOptions.limit);
-    if (actionOptions.json) {
-      console.log(JSON.stringify(rows, null, 2));
-      return;
-    }
-    if (!rows.length) {
-      console.log("No events recorded.");
-      return;
-    }
-    for (const event of rows)
-      console.log(`${event.time}	${event.id}	${event.source}	${event.type}	${event.severity}`);
-  });
-  events.command("replay").description("Replay recorded events").option("--id <id>", "Replay one event id").option("--source <source>", "Filter by source").option("--type <type>", "Filter by type").option("--dry-run", "Preview without delivery", false).option("-j, --json", "Print JSON output", false).action(async (actionOptions) => {
-    const result = await createClient(options).replay({
-      eventId: actionOptions.id,
-      source: actionOptions.source,
-      type: actionOptions.type,
-      dryRun: actionOptions.dryRun
-    });
-    print(result, Boolean(actionOptions.json), `Replayed ${result.events.length} event(s), ${result.deliveries.length} delivery result(s)`);
-  });
-  return events;
-}
-function registerEventsCommands(program2, options) {
-  registerWebhookCommands(program2, options);
-  registerEventCommands(program2, options);
-}
-function parseNumber(value) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed))
-    throw new Error(`Expected a number, got ${value}`);
-  return parsed;
-}
-function collectValues(value, previous) {
-  previous.push(value);
-  return previous;
-}
-var HASNA_EVENTS_DIR_ENV = "HASNA_EVENTS_DIR", HASNA_EVENTS_HOME_ENV = "HASNA_EVENTS_HOME", DEFAULT_SIGNATURE_TOLERANCE_MS;
-var init_commander = __esm(() => {
-  DEFAULT_SIGNATURE_TOLERANCE_MS = 5 * 60 * 1000;
-});
-
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -49184,7 +48739,7 @@ init_route53();
 import { readFileSync as readFileSync6 } from "fs";
 
 // src/lib/zone-setup.ts
-function nameserversMatch(a4, b4) {
+function nameserversMatch2(a4, b4) {
   const norm = (ns) => new Set(ns.map((n2) => n2.trim().toLowerCase().replace(/\.$/, "")));
   const sa = norm(a4);
   const sb = norm(b4);
@@ -49211,7 +48766,7 @@ async function setupDomainZone(domain, deps) {
   }
   let nsUpdated = false;
   const registrarNs = await deps.getRegistrarNs(domain);
-  if (!nameserversMatch(registrarNs, zone.name_servers)) {
+  if (!nameserversMatch2(registrarNs, zone.name_servers)) {
     await deps.setRegistrarNs(domain, zone.name_servers);
     nsUpdated = true;
     log("ns_aligned", { domain, zoneId: zone.id, nameservers: zone.name_servers });
@@ -49693,8 +49248,8 @@ async function registerOptionalCommands(program2, groups) {
   }
   if (groups.has("events")) {
     try {
-      const { registerEventsCommands: registerEventsCommands2 } = await Promise.resolve().then(() => (init_commander(), exports_commander));
-      registerEventsCommands2(program2, { source: "domains" });
+      const { registerEventsCommands } = await import("@hasna/events/commander");
+      registerEventsCommands(program2, { source: "domains" });
     } catch (error) {
       console.error(`Events command group is enabled but @hasna/events could not be loaded: ${error instanceof Error ? error.message : String(error)}`);
     }