@hasna/domains 0.0.20 → 0.0.22

package/dist/index.js

@@ -28633,8 +28633,8 @@ class PgAdapterAsync {
     await this.pool.end();
   }
 }
-// src/db/cloud-sync.ts
-var CLOUD_TABLES = [
+// src/db/storage-sync.ts
+var STORAGE_TABLES = [
   "domains",
   "dns_records",
   "alerts",
@@ -28644,6 +28644,7 @@ var CLOUD_TABLES = [
   "domain_history",
   "domain_reputation"
 ];
+var DOMAINS_STORAGE_TABLES = STORAGE_TABLES;
 var PRIMARY_KEYS = {
   domains: ["id"],
   dns_records: ["id"],
@@ -28654,25 +28655,57 @@ var PRIMARY_KEYS = {
   domain_history: ["id"],
   domain_reputation: ["id"]
 };
-function getCloudDatabaseUrl() {
-  return process.env["HASNA_DOMAINS_CLOUD_DATABASE_URL"] ?? process.env["OPEN_DOMAINS_CLOUD_DATABASE_URL"] ?? process.env["DOMAINS_CLOUD_DATABASE_URL"] ?? null;
+var DOMAINS_STORAGE_ENV = "HASNA_DOMAINS_DATABASE_URL";
+var DOMAINS_STORAGE_FALLBACK_ENV = "DOMAINS_DATABASE_URL";
+var DOMAINS_STORAGE_MODE_ENV = "HASNA_DOMAINS_STORAGE_MODE";
+var DOMAINS_STORAGE_MODE_FALLBACK_ENV = "DOMAINS_STORAGE_MODE";
+var STORAGE_DATABASE_ENV = [DOMAINS_STORAGE_ENV, DOMAINS_STORAGE_FALLBACK_ENV];
+var STORAGE_MODE_ENV = [DOMAINS_STORAGE_MODE_ENV, DOMAINS_STORAGE_MODE_FALLBACK_ENV];
+function firstEnv(names) {
+  for (const name of names) {
+    const value = process.env[name];
+    if (value)
+      return value;
+  }
+  return null;
+}
+function normalizeStorageMode(value) {
+  if (!value)
+    return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "local" || normalized === "remote" || normalized === "hybrid")
+    return normalized;
+  return null;
+}
+function getStorageDatabaseUrl() {
+  return firstEnv(STORAGE_DATABASE_ENV);
+}
+function getStorageDatabaseEnvName() {
+  for (const name of STORAGE_DATABASE_ENV) {
+    if (process.env[name])
+      return name;
+  }
+  return null;
+}
+function getStorageMode() {
+  return normalizeStorageMode(firstEnv(STORAGE_MODE_ENV)) ?? (getStorageDatabaseUrl() ? "remote" : "local");
 }
-async function getCloudPg() {
-  const url = getCloudDatabaseUrl();
+async function getStoragePg() {
+  const url = getStorageDatabaseUrl();
   if (!url) {
-    throw new Error("Missing HASNA_DOMAINS_CLOUD_DATABASE_URL, OPEN_DOMAINS_CLOUD_DATABASE_URL, or DOMAINS_CLOUD_DATABASE_URL");
+    throw new Error("Missing HASNA_DOMAINS_DATABASE_URL or DOMAINS_DATABASE_URL");
   }
   return new PgAdapterAsync(url);
 }
-async function runCloudMigrations(remote) {
+async function runStorageMigrations(remote) {
   for (const sql of PG_MIGRATIONS)
     await remote.run(sql);
 }
-async function cloudPush(options) {
-  const remote = await getCloudPg();
+async function storagePush(options) {
+  const remote = await getStoragePg();
   const db = getDatabase();
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     const results = [];
     for (const table of resolveTables(options?.tables))
       results.push(await pushTable(db, remote, table));
@@ -28682,11 +28715,11 @@ async function cloudPush(options) {
     await remote.close();
   }
 }
-async function cloudPull(options) {
-  const remote = await getCloudPg();
+async function storagePull(options) {
+  const remote = await getStoragePg();
   const db = getDatabase();
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     const results = [];
     for (const table of resolveTables(options?.tables))
       results.push(await pullTable(remote, db, table));
@@ -28696,20 +28729,33 @@ async function cloudPull(options) {
     await remote.close();
   }
 }
-async function cloudSync(options) {
-  const pull = await cloudPull(options);
-  const push = await cloudPush(options);
+async function storageSync(options) {
+  const pull = await storagePull(options);
+  const push = await storagePush(options);
   return { pull, push };
 }
-function getSyncMetaAll() {
+function getStorageSyncMetaAll() {
   const db = getDatabase();
   ensureSyncMetaTable(db);
   return db.query("SELECT table_name, last_synced_at, direction FROM _domains_sync_meta ORDER BY table_name, direction").all();
 }
+function getStorageStatus() {
+  return {
+    configured: Boolean(getStorageDatabaseUrl()),
+    env: STORAGE_DATABASE_ENV,
+    mode: getStorageMode(),
+    service: "domains",
+    tables: STORAGE_TABLES,
+    sync: getStorageSyncMetaAll()
+  };
+}
+function getSyncMetaAll() {
+  return getStorageSyncMetaAll();
+}
 function resolveTables(tables) {
   if (!tables || tables.length === 0)
-    return [...CLOUD_TABLES];
-  const allowed = new Set(CLOUD_TABLES);
+    return [...STORAGE_TABLES];
+  const allowed = new Set(STORAGE_TABLES);
   const requested = tables.map((table) => table.trim()).filter(Boolean);
   const invalid = requested.filter((table) => !allowed.has(table));
   if (invalid.length > 0)
@@ -28943,6 +28989,61 @@ async function renewDomain(domain, years = 1, config) {
     chargedAmount: chargedAmount || undefined
   };
 }
+function namecheapContactParams(contact) {
+  const organization = contact.organization_name || "NA";
+  const base = {
+    FirstName: contact.first_name,
+    LastName: contact.last_name,
+    OrganizationName: organization,
+    Address1: contact.address_line_1,
+    City: contact.city,
+    StateProvince: contact.state,
+    PostalCode: contact.zip_code,
+    Country: contact.country_code,
+    Phone: contact.phone,
+    EmailAddress: contact.email
+  };
+  const params = {};
+  for (const prefix of ["Registrant", "Tech", "Admin", "AuxBilling"]) {
+    for (const [key, value] of Object.entries(base)) {
+      params[prefix + key] = value;
+    }
+  }
+  return params;
+}
+async function registerDomain(domain, contact, options = {}, config) {
+  const cfg = config || getConfig();
+  const params = {
+    DomainName: domain,
+    Years: String(options.years ?? 1),
+    AddFreeWhoisguard: options.whoisGuard === false ? "no" : "yes",
+    WGEnabled: options.whoisGuard === false ? "no" : "yes",
+    ...namecheapContactParams(contact)
+  };
+  if (options.premiumPrice !== undefined) {
+    params.IsPremiumDomain = "true";
+    params.PremiumPrice = String(options.premiumPrice);
+  }
+  const xml = await apiRequest(cfg, "namecheap.domains.create", params);
+  return {
+    domain,
+    success: xml.includes('Status="OK"') || xml.includes('Registered="true"'),
+    orderId: parseXmlValue(xml, "OrderId") || undefined,
+    chargedAmount: parseXmlValue(xml, "ChargedAmount") || undefined
+  };
+}
+async function updateNameservers(domain, nameservers, config) {
+  if (nameservers.length === 0)
+    throw new Error("updateNameservers requires at least one nameserver");
+  const cfg = config || getConfig();
+  const { sld, tld } = splitDomain(domain);
+  const xml = await apiRequest(cfg, "namecheap.domains.dns.setCustom", {
+    SLD: sld,
+    TLD: tld,
+    Nameservers: nameservers.join(",")
+  });
+  return xml.includes('Status="OK"') || xml.includes('Updated="true"');
+}
 async function getDnsRecords(_domain, sld, tld, config) {
   const cfg = config || getConfig();
   const xml = await apiRequest(cfg, "namecheap.domains.dns.getHosts", {
@@ -35616,7 +35717,8 @@ 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"]
+    secretAccessKey: process.env["AWS_SECRET_ACCESS_KEY"],
+    sessionToken: process.env["AWS_SESSION_TOKEN"]
   };
 }
 function checkCredentials(cfg) {
@@ -35632,7 +35734,7 @@ function makeClients(config) {
   const cfg = config ?? getConfig2();
   checkCredentials(cfg);
   const region = cfg.region || "us-east-1";
-  const credentials = cfg.accessKeyId && cfg.secretAccessKey ? { accessKeyId: cfg.accessKeyId, secretAccessKey: cfg.secretAccessKey } : undefined;
+  const credentials = cfg.accessKeyId && cfg.secretAccessKey ? { accessKeyId: cfg.accessKeyId, secretAccessKey: cfg.secretAccessKey, sessionToken: cfg.sessionToken } : undefined;
   return {
     route53: new Route53Client({ region, credentials }),
     domains: new Route53DomainsClient({ region: "us-east-1", credentials })
@@ -35661,7 +35763,7 @@ async function checkAvailability3(domain, config) {
   } catch {}
   return availability;
 }
-async function registerDomain(domain, contact, durationYears = 1, autoRenew = true, config) {
+async function registerDomain2(domain, contact, durationYears = 1, autoRenew = true, config) {
   const { domains } = makeClients(config);
   const contactDetail = {
     FirstName: contact.first_name,
@@ -35710,7 +35812,7 @@ async function getDomainDetail(domain, config) {
     nameservers: (result.Nameservers ?? []).map((ns) => ns.Name ?? "").filter(Boolean)
   };
 }
-async function updateNameservers(domain, nameservers, config, client) {
+async function updateNameservers2(domain, nameservers, config, client) {
   if (!nameservers.length) {
     throw new Error("updateNameservers requires at least one nameserver");
   }
@@ -35772,7 +35874,8 @@ async function listHostedZones(config) {
         id: cleanZoneId(z2.Id ?? ""),
         name: z2.Name ?? "",
         record_count: z2.ResourceRecordSetCount ?? 0,
-        comment: z2.Config?.Comment
+        comment: z2.Config?.Comment,
+        private_zone: z2.Config?.PrivateZone
       });
     }
     marker = result.IsTruncated ? result.NextMarker : undefined;
@@ -35787,7 +35890,8 @@ async function getHostedZone(hostedZoneId, config) {
     name: result.HostedZone?.Name ?? "",
     record_count: result.HostedZone?.ResourceRecordSetCount ?? 0,
     comment: result.HostedZone?.Config?.Comment,
-    name_servers: result.DelegationSet?.NameServers ?? []
+    name_servers: result.DelegationSet?.NameServers ?? [],
+    private_zone: result.HostedZone?.Config?.PrivateZone
   };
 }
 async function deleteHostedZone(hostedZoneId, config) {
@@ -35797,7 +35901,15 @@ async function deleteHostedZone(hostedZoneId, config) {
 async function findHostedZoneByDomain(domain, config) {
   const zones = await listHostedZones(config);
   const normalized = domain.endsWith(".") ? domain : `${domain}.`;
-  return zones.find((z2) => z2.name === normalized) ?? null;
+  const matches = zones.filter((z2) => z2.name === normalized);
+  if (matches.length === 0)
+    return null;
+  const publicMatches = matches.filter((z2) => !z2.private_zone);
+  const candidates = publicMatches.length > 0 ? publicMatches : matches;
+  if (candidates.length > 1) {
+    throw new Error(`Multiple Route 53 hosted zones found for ${domain}; specify hosted zone id`);
+  }
+  return candidates[0] ?? null;
 }
 function rrsToRecord(rrs) {
   if (rrs.AliasTarget) {
@@ -35895,19 +36007,55 @@ async function upsertRecords(hostedZoneId, records, config) {
 }
 function createRoute53Provider(config) {
   const cfg = config ?? getConfig2();
+  const registerWithRoute53 = registerDomain2;
+  const updateRoute53Nameservers = updateNameservers2;
+  async function listDomainInventory() {
+    const byDomain = new Map;
+    try {
+      const registered = await listRegisteredDomains(cfg);
+      for (const d3 of registered) {
+        byDomain.set(d3.domain, {
+          domain: d3.domain,
+          registrar: "AWS Route 53",
+          created: "",
+          expires: d3.expiry,
+          nameservers: [],
+          status: "active",
+          auto_renew: d3.auto_renew
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.includes("route53domains:ListDomains") && !message.includes("AccessDenied")) {
+        throw error;
+      }
+    }
+    const zones = await listHostedZones(cfg);
+    for (const z2 of zones) {
+      const zone = z2.name_servers?.length ? z2 : await getHostedZone(z2.id, cfg).catch(() => z2);
+      const domain = zone.name.replace(/\.$/, "");
+      const nameservers = zone.name_servers ?? [];
+      const existing = byDomain.get(domain);
+      if (existing) {
+        existing.nameservers = nameservers.length > 0 ? nameservers : existing.nameservers;
+        continue;
+      }
+      byDomain.set(domain, {
+        domain,
+        registrar: "AWS Route 53 DNS",
+        created: "",
+        expires: "",
+        nameservers,
+        status: "active",
+        auto_renew: false
+      });
+    }
+    return Array.from(byDomain.values());
+  }
   return {
     name: "route53",
     async listDomains() {
-      const domains = await listRegisteredDomains(cfg);
-      return domains.map((d3) => ({
-        domain: d3.domain,
-        registrar: "AWS Route 53",
-        created: "",
-        expires: d3.expiry,
-        nameservers: [],
-        status: "active",
-        auto_renew: d3.auto_renew
-      }));
+      return listDomainInventory();
     },
     async getDomainInfo(domain) {
       const detail = await getDomainDetail(domain, cfg);
@@ -35921,6 +36069,14 @@ function createRoute53Provider(config) {
         auto_renew: detail.auto_renew
       };
     },
+    async registerDomain(domain, contact, options = {}) {
+      const result = await registerWithRoute53(domain, contact, options.years ?? 1, options.autoRenew ?? true, cfg);
+      return { domain, success: !!result.operationId, operationId: result.operationId };
+    },
+    async updateNameservers(domain, nameservers) {
+      const result = await updateRoute53Nameservers(domain, nameservers, cfg);
+      return { domain, success: !!result.operationId, operationId: result.operationId };
+    },
     async renewDomain(_domain) {
       return { domain: _domain, success: false, orderId: undefined, chargedAmount: undefined };
     },
@@ -35968,7 +36124,7 @@ function createRoute53Provider(config) {
       };
     },
     async syncToLocalDb(dbFns) {
-      const domains = await listRegisteredDomains(cfg);
+      const domains = await listDomainInventory();
       let synced = 0;
       let created = 0;
       let updated = 0;
@@ -35977,20 +36133,39 @@ function createRoute53Provider(config) {
         try {
           const existing = dbFns.getDomainByName(d3.domain);
           if (existing) {
+            const existingRoute53 = existing.metadata["route53"];
+            const staleDnsOnlyRegistrar = d3.registrar !== "AWS Route 53" && (existing.registrar === "AWS Route 53 DNS" || existing.registrar === "AWS Route 53" && existingRoute53?.source === "route53:hosted_zones");
             dbFns.updateDomain(existing.id, {
-              registrar: "AWS Route 53",
-              expires_at: d3.expiry || undefined,
+              ...d3.registrar === "AWS Route 53" ? { registrar: "AWS Route 53" } : {},
+              ...staleDnsOnlyRegistrar ? { registrar: null } : {},
+              expires_at: d3.expires || undefined,
               auto_renew: d3.auto_renew,
+              nameservers: d3.nameservers.length > 0 ? d3.nameservers : existing.nameservers,
+              metadata: {
+                ...existing.metadata,
+                route53: {
+                  source: d3.registrar === "AWS Route 53" ? "route53domains+hosted_zones" : "route53:hosted_zones",
+                  synced_at: new Date().toISOString()
+                }
+              },
               status: "active"
             });
             updated++;
           } else {
             dbFns.createDomain({
               name: d3.domain,
-              registrar: "AWS Route 53",
-              expires_at: d3.expiry || undefined,
+              ...d3.registrar === "AWS Route 53" ? { registrar: "AWS Route 53" } : {},
+              expires_at: d3.expires || undefined,
               auto_renew: d3.auto_renew,
-              status: "active"
+              nameservers: d3.nameservers,
+              status: "active",
+              notes: d3.registrar === "AWS Route 53 DNS" ? "Discovered from Route 53 hosted zones; registrar ownership was not inferred." : undefined,
+              metadata: {
+                route53: {
+                  source: d3.registrar === "AWS Route 53" ? "route53domains+hosted_zones" : "route53:hosted_zones",
+                  synced_at: new Date().toISOString()
+                }
+              }
             });
             created++;
           }
@@ -36004,15 +36179,129 @@ function createRoute53Provider(config) {
   };
 }
 
-// src/lib/cloudflare-auth.ts
-function resolveCloudflareConfig(env = process.env) {
-  const accountId = env["CLOUDFLARE_ACCOUNT_ID"] || undefined;
-  if (env["CLOUDFLARE_API_TOKEN"]) {
-    return { apiToken: env["CLOUDFLARE_API_TOKEN"], accountId };
+// src/lib/env-aliases.ts
+function firstEnv2(env, names) {
+  for (const key of names) {
+    const value = env[key];
+    if (value)
+      return { key, value };
+  }
+  return;
+}
+function hasEveryEnv(env, groups) {
+  return groups.every((names) => !!firstEnv2(env, names));
+}
+function flattenEnvNames(groups) {
+  return Array.from(new Set(groups.flatMap((names) => [...names])));
+}
+var NAMECHEAP_ENV = {
+  apiKey: ["NAMECHEAP_API_KEY"],
+  username: ["NAMECHEAP_USERNAME"],
+  clientIp: ["NAMECHEAP_CLIENT_IP"]
+};
+var GODADDY_ENV = {
+  apiKey: ["GODADDY_API_KEY"],
+  apiSecret: ["GODADDY_API_SECRET"]
+};
+var BRANDSIGHT_ENV = {
+  apiKey: [
+    "BRANDSIGHT_API_KEY",
+    "HASNAXYZ_BRANDSIGHT_LIVE_API_KEY",
+    "HASNAXYZ_BRANDSIGHT_SANDBOX_API_KEY"
+  ],
+  apiSecret: [
+    "BRANDSIGHT_API_SECRET",
+    "HASNAXYZ_BRANDSIGHT_LIVE_API_SECRET",
+    "HASNAXYZ_BRANDSIGHT_SANDBOX_API_SECRET"
+  ],
+  customerId: [
+    "BRANDSIGHT_CUSTOMER_ID",
+    "HASNAXYZ_BRANDSIGHT_LIVE_CUSTOMER_ID",
+    "HASNAXYZ_BRANDSIGHT_SANDBOX_CUSTOMER_ID"
+  ],
+  shopperId: [
+    "BRANDSIGHT_SHOPPER_ID",
+    "HASNAXYZ_BRANDSIGHT_LIVE_SHOPPER_ID",
+    "HASNAXYZ_BRANDSIGHT_SANDBOX_SHOPPER_ID"
+  ],
+  accountId: ["BRANDSIGHT_ACCOUNT_ID", "HASNAXYZ_BRANDSIGHT_LIVE_ACCOUNT_ID"]
+};
+var SEDO_ENV = {
+  partnerId: ["SEDO_PARTNER_ID", "HASNAXYZ_SEDO_LIVE_PARTNER_ID"],
+  signKey: ["SEDO_API_KEY", "SEDO_SIGN_KEY", "HASNAXYZ_SEDO_LIVE_API_KEY"],
+  username: ["SEDO_USERNAME", "SEDO_EMAIL", "HASNAXYZ_SEDO_LIVE_USERNAME", "HASNAXYZ_SEDO_LIVE_EMAIL"],
+  password: ["SEDO_PASSWORD", "HASNAXYZ_SEDO_LIVE_PASSWORD"]
+};
+var CLOUDFLARE_ENV = {
+  apiToken: ["CLOUDFLARE_API_TOKEN", "HASNAXYZ_CLOUDFLARE_LIVE_API_TOKEN"],
+  apiKey: ["CLOUDFLARE_API_KEY", "HASNAXYZ_CLOUDFLARE_LIVE_API_KEY"],
+  email: ["CLOUDFLARE_EMAIL", "HASNAXYZ_CLOUDFLARE_LIVE_EMAIL"],
+  accountId: ["CLOUDFLARE_ACCOUNT_ID", "HASNAXYZ_CLOUDFLARE_LIVE_ACCOUNT_ID"]
+};
+var BEEPMEDIA_AWS_ENV = {
+  accessKeyId: ["HASNASTUDIO_BEEPMEDIA_AWS_LIVE_ACCESS_KEY_ID", "BEEPMEDIA_AWS_ACCESS_KEY_ID"],
+  secretAccessKey: ["HASNASTUDIO_BEEPMEDIA_AWS_LIVE_SECRET_ACCESS_KEY", "BEEPMEDIA_AWS_SECRET_ACCESS_KEY"]
+};
+function providerEnvNames(provider) {
+  switch (provider.toLowerCase()) {
+    case "namecheap":
+      return flattenEnvNames([NAMECHEAP_ENV.apiKey, NAMECHEAP_ENV.username, NAMECHEAP_ENV.clientIp]);
+    case "godaddy":
+      return flattenEnvNames([GODADDY_ENV.apiKey, GODADDY_ENV.apiSecret]);
+    case "brandsight":
+      return flattenEnvNames([
+        BRANDSIGHT_ENV.apiKey,
+        BRANDSIGHT_ENV.apiSecret,
+        BRANDSIGHT_ENV.customerId,
+        BRANDSIGHT_ENV.shopperId,
+        BRANDSIGHT_ENV.accountId
+      ]);
+    case "sedo":
+      return flattenEnvNames([SEDO_ENV.partnerId, SEDO_ENV.signKey, SEDO_ENV.username, SEDO_ENV.password]);
+    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"];
+    case "aws:beepmedia":
+      return flattenEnvNames([BEEPMEDIA_AWS_ENV.accessKeyId, BEEPMEDIA_AWS_ENV.secretAccessKey]);
+    default:
+      return [];
   }
-  if (env["CLOUDFLARE_API_KEY"] && env["CLOUDFLARE_EMAIL"]) {
-    return { apiKey: env["CLOUDFLARE_API_KEY"], email: env["CLOUDFLARE_EMAIL"], accountId };
+}
+function hasProviderCredentials(provider, env = process.env) {
+  switch (provider.toLowerCase()) {
+    case "namecheap":
+      return hasEveryEnv(env, [NAMECHEAP_ENV.apiKey, NAMECHEAP_ENV.username, NAMECHEAP_ENV.clientIp]);
+    case "godaddy":
+      return hasEveryEnv(env, [GODADDY_ENV.apiKey, GODADDY_ENV.apiSecret]);
+    case "brandsight":
+      return hasEveryEnv(env, [BRANDSIGHT_ENV.apiKey, BRANDSIGHT_ENV.apiSecret, BRANDSIGHT_ENV.customerId]);
+    case "sedo":
+      return hasEveryEnv(env, [SEDO_ENV.partnerId, SEDO_ENV.signKey, SEDO_ENV.username, SEDO_ENV.password]);
+    case "cloudflare": {
+      const tokenMode = !!firstEnv2(env, CLOUDFLARE_ENV.apiToken);
+      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 "aws:beepmedia":
+      return hasEveryEnv(env, [BEEPMEDIA_AWS_ENV.accessKeyId, BEEPMEDIA_AWS_ENV.secretAccessKey]);
+    default:
+      return false;
   }
+}
+
+// src/lib/cloudflare-auth.ts
+function resolveCloudflareConfig(env = process.env) {
+  const accountId = firstEnv2(env, CLOUDFLARE_ENV.accountId)?.value;
+  const apiToken = firstEnv2(env, CLOUDFLARE_ENV.apiToken)?.value;
+  if (apiToken)
+    return { apiToken, accountId };
+  const apiKey = firstEnv2(env, CLOUDFLARE_ENV.apiKey)?.value;
+  const email = firstEnv2(env, CLOUDFLARE_ENV.email)?.value;
+  if (apiKey && email)
+    return { apiKey, email, accountId };
   return accountId ? { accountId } : {};
 }
 function cloudflareAuthHeaders(cfg) {
@@ -36049,6 +36338,22 @@ async function cfFetch(path, opts = {}) {
   }
   return json.result;
 }
+async function listZones(config) {
+  const zones = [];
+  let page = 1;
+  while (true) {
+    const result = await cfFetch(`/zones?per_page=50&page=${page}`, { config });
+    if (!result || result.length === 0)
+      break;
+    for (const z2 of result) {
+      zones.push({ id: z2.id, name: z2.name, status: z2.status, nameservers: z2.name_servers, original_nameservers: z2.original_name_servers });
+    }
+    if (result.length < 50)
+      break;
+    page++;
+  }
+  return zones;
+}
 async function getZone(domain, config) {
   const result = await cfFetch(`/zones?name=${encodeURIComponent(domain)}`, { config });
   if (!result || result.length === 0)
@@ -36090,8 +36395,20 @@ async function listRecords2(zoneId, config) {
   }
   return records;
 }
+async function listRecordsByNameType(zoneId, type, name, config) {
+  const result = await cfFetch(`/zones/${zoneId}/dns_records?type=${encodeURIComponent(type)}&name=${encodeURIComponent(name)}`, { config });
+  return (result ?? []).map((r3) => ({
+    id: r3.id,
+    type: r3.type,
+    name: r3.name,
+    content: r3.content,
+    ttl: r3.ttl,
+    priority: r3.priority,
+    proxied: r3.proxied
+  }));
+}
 async function upsertRecord2(zoneId, record, config) {
-  const existing = await cfFetch(`/zones/${zoneId}/dns_records?type=${record.type}&name=${encodeURIComponent(record.name)}`, { config });
+  const existing = await listRecordsByNameType(zoneId, record.type, record.name, config);
   const body = {
     type: record.type,
     name: record.name,
@@ -36100,16 +36417,106 @@ async function upsertRecord2(zoneId, record, config) {
     priority: record.priority,
     proxied: record.proxied ?? false
   };
-  if (existing && existing.length > 0) {
-    await cfFetch(`/zones/${zoneId}/dns_records/${existing[0].id}`, { method: "PUT", body, config });
+  const sameRecord = existing.find((r3) => r3.content === record.content && (r3.priority ?? undefined) === (record.priority ?? undefined) && (r3.proxied ?? false) === (record.proxied ?? false));
+  if (sameRecord?.id) {
+    await cfFetch(`/zones/${zoneId}/dns_records/${sameRecord.id}`, { method: "PUT", body, config });
   } else {
     await cfFetch(`/zones/${zoneId}/dns_records`, { method: "POST", body, config });
   }
 }
+async function replaceRecordsByNameType(zoneId, records, config) {
+  if (records.length === 0)
+    return;
+  const { type, name } = records[0];
+  const existing = await listRecordsByNameType(zoneId, type, name, config);
+  for (const record of existing) {
+    if (record.id)
+      await deleteRecord2(zoneId, record.id, config);
+  }
+  for (const record of records) {
+    await cfFetch(`/zones/${zoneId}/dns_records`, {
+      method: "POST",
+      body: {
+        type: record.type,
+        name: record.name,
+        content: record.content,
+        ttl: record.ttl ?? 1,
+        priority: record.priority,
+        proxied: record.proxied ?? false
+      },
+      config
+    });
+  }
+}
+async function deleteRecord2(zoneId, recordId, config) {
+  await cfFetch(`/zones/${zoneId}/dns_records/${recordId}`, { method: "DELETE", config });
+}
+function zoneToDomainInfo(zone) {
+  return {
+    domain: zone.name,
+    registrar: "Cloudflare DNS",
+    created: "",
+    expires: "",
+    nameservers: zone.nameservers,
+    status: zone.status === "active" ? "active" : "discovered",
+    auto_renew: false
+  };
+}
+function withCloudflareMetadata(existing, zone) {
+  return {
+    ...existing,
+    cloudflare: {
+      zone_id: zone.id,
+      zone_status: zone.status,
+      source: "cloudflare:zones",
+      synced_at: new Date().toISOString()
+    }
+  };
+}
 function createCloudflareProvider(config) {
   const cfg = config ?? getConfig3();
   return {
     name: "cloudflare",
+    async listDomains() {
+      const zones = await listZones(cfg);
+      return zones.map(zoneToDomainInfo);
+    },
+    async syncToLocalDb(dbFns) {
+      const zones = await listZones(cfg);
+      let synced = 0;
+      let created = 0;
+      let updated = 0;
+      const errors = [];
+      for (const zone of zones) {
+        try {
+          const info = zoneToDomainInfo(zone);
+          const existing = dbFns.getDomainByName(zone.name);
+          if (existing) {
+            dbFns.updateDomain(existing.id, {
+              ...existing.registrar === "Cloudflare DNS" ? { registrar: null } : {},
+              status: existing.status === "discovered" && info.status === "active" ? "active" : existing.status,
+              nameservers: zone.nameservers,
+              metadata: withCloudflareMetadata(existing.metadata, zone)
+            });
+            updated++;
+          } else {
+            dbFns.createDomain({
+              name: zone.name,
+              status: info.status === "active" ? "active" : "discovered",
+              auto_renew: false,
+              nameservers: zone.nameservers,
+              notes: "Discovered from Cloudflare zones; registrar ownership was not inferred.",
+              metadata: withCloudflareMetadata({}, zone)
+            });
+            created++;
+          }
+          synced++;
+        } catch (err) {
+          errors.push(`${zone.name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      return { synced, created, updated, errors };
+    },
     async getDnsRecords(domain) {
       const zone = await getZone(domain, cfg);
       if (!zone)
@@ -36127,8 +36534,15 @@ function createCloudflareProvider(config) {
       const zone = await getZone(domain, cfg);
       if (!zone)
         throw new Error(`No Cloudflare zone found for ${domain}`);
+      const grouped = new Map;
       for (const r3 of records) {
-        await upsertRecord2(zone.id, { type: r3.type, name: r3.name, content: r3.value, ttl: r3.ttl || 1, priority: r3.priority }, cfg);
+        const key = `${r3.type}|${r3.name}`;
+        const existing = grouped.get(key) ?? [];
+        existing.push({ type: r3.type, name: r3.name, content: r3.value, ttl: r3.ttl || 1, priority: r3.priority });
+        grouped.set(key, existing);
+      }
+      for (const group of grouped.values()) {
+        await replaceRecordsByNameType(zone.id, group, cfg);
       }
       return true;
     }
@@ -36136,6 +36550,21 @@ function createCloudflareProvider(config) {
 }
 
 // src/lib/brandsight.ts
+function resolveBrandsightConfig(env = process.env) {
+  const apiKey = firstEnv2(env, BRANDSIGHT_ENV.apiKey)?.value ?? "";
+  const apiSecret = firstEnv2(env, BRANDSIGHT_ENV.apiSecret)?.value;
+  const customerId = firstEnv2(env, BRANDSIGHT_ENV.customerId)?.value;
+  const shopperId = firstEnv2(env, BRANDSIGHT_ENV.shopperId)?.value;
+  const accountId = firstEnv2(env, BRANDSIGHT_ENV.accountId)?.value;
+  return {
+    apiKey,
+    apiSecret,
+    customerId,
+    shopperId,
+    accountId,
+    baseUrl: env["BRANDSIGHT_BASE_URL"]
+  };
+}
 class BrandsightApiError extends Error {
   statusCode;
   responseBody;
@@ -36148,92 +36577,261 @@ class BrandsightApiError extends Error {
 }
 var _fetchFn = null;
 function getConfig4() {
-  return {
-    apiKey: process.env["BRANDSIGHT_API_KEY"] ?? "",
-    accountId: process.env["BRANDSIGHT_ACCOUNT_ID"]
-  };
+  return resolveBrandsightConfig();
 }
-var BRANDSIGHT_BASE = "https://api.brandsight.com/v1";
-async function apiRequest3(method, path, apiKey, body, baseUrl = BRANDSIGHT_BASE) {
-  const fetchFn = _fetchFn || globalThis.fetch;
-  const url = `${baseUrl}${path}`;
-  const headers = {
-    Authorization: `Bearer ${apiKey}`,
-    "Content-Type": "application/json",
-    Accept: "application/json",
-    "User-Agent": USER_AGENT
-  };
-  try {
-    const response = await fetchFn(url, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
-      signal: AbortSignal.timeout(15000)
-    });
-    if (!response.ok) {
-      throw new BrandsightApiError(`Brandsight API ${method} ${path} failed with status ${response.status}`, response.status, await response.text());
-    }
-    const data = await response.json();
-    return { data, stub: false };
-  } catch (error) {
-    if (error instanceof BrandsightApiError)
-      throw error;
-    return { data: null, stub: true };
+var BRANDSIGHT_DOMAIN_BASE = "https://api.godaddy.com/v2";
+function requireDomainConfig(config) {
+  const cfg = config ?? getConfig4();
+  if (!cfg.apiKey || !cfg.apiSecret || !cfg.customerId) {
+    throw new BrandsightApiError("Brandsight Domain API credentials are not configured. Set BRANDSIGHT_API_KEY, BRANDSIGHT_API_SECRET, and BRANDSIGHT_CUSTOMER_ID (or HASNAXYZ_BRANDSIGHT_LIVE_* aliases).");
   }
+  return cfg;
 }
-async function apiGet(path, apiKey, baseUrl = BRANDSIGHT_BASE) {
-  const fetchFn = _fetchFn || globalThis.fetch;
-  const url = `${baseUrl}${path}`;
-  const headers = {
-    Authorization: `Bearer ${apiKey}`,
+function domainBaseUrl(cfg) {
+  return cfg.baseUrl ?? BRANDSIGHT_DOMAIN_BASE;
+}
+function domainHeaders(cfg) {
+  return {
+    Authorization: `sso-key ${cfg.apiKey}:${cfg.apiSecret}`,
     "Content-Type": "application/json",
     Accept: "application/json",
     "User-Agent": USER_AGENT
   };
-  try {
-    const response = await fetchFn(url, {
-      method: "GET",
-      headers,
-      signal: AbortSignal.timeout(15000)
-    });
-    if (!response.ok) {
-      throw new BrandsightApiError(`Brandsight API GET ${path} failed with status ${response.status}`, response.status, await response.text());
-    }
-    const data = await response.json();
-    return { data, stub: false };
-  } catch (error) {
-    if (error instanceof BrandsightApiError)
-      throw error;
-    return { data: null, stub: true };
+}
+async function domainApiRequest(method, path, config, body) {
+  const cfg = requireDomainConfig(config);
+  const fetchFn = _fetchFn || globalThis.fetch;
+  const response = await fetchFn(`${domainBaseUrl(cfg)}${path}`, {
+    method,
+    headers: domainHeaders(cfg),
+    body: body ? JSON.stringify(body) : undefined,
+    signal: AbortSignal.timeout(30000)
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new BrandsightApiError(`Brandsight Domain API ${method} ${path} failed with status ${response.status}`, response.status, text);
   }
+  if (!text.trim())
+    return {};
+  return JSON.parse(text);
+}
+function normalizeBrandsightDomain(raw) {
+  const nameServers = raw.nameServers ?? raw.nameservers ?? [];
+  const expiresAt = raw.expiresAt ?? raw.expires ?? "";
+  const createdAt = raw.createdAt ?? raw.created ?? "";
+  const renewAuto = raw.renewAuto ?? raw.auto_renew ?? false;
+  return {
+    ...raw,
+    domain: String(raw.domain ?? ""),
+    status: String(raw.status ?? "UNKNOWN"),
+    created: createdAt,
+    expires: expiresAt,
+    auto_renew: renewAuto,
+    locked: Boolean(raw.locked),
+    nameservers: nameServers,
+    createdAt,
+    expiresAt,
+    nameServers,
+    renewAuto
+  };
+}
+function customerPath(cfg, path) {
+  return `/customers/${encodeURIComponent(cfg.customerId)}${path}`;
+}
+function domainTld(domain) {
+  const parts = domain.split(".").filter(Boolean);
+  if (parts.length < 2)
+    throw new BrandsightApiError(`Invalid domain name: ${domain}`);
+  return parts.slice(1).join(".");
+}
+function brandsightContact(contact) {
+  return {
+    addressMailing: {
+      address1: contact.address_line_1,
+      city: contact.city,
+      country: contact.country_code,
+      postalCode: contact.zip_code,
+      state: contact.state
+    },
+    email: contact.email,
+    encoding: "ASCII",
+    nameFirst: contact.first_name,
+    nameLast: contact.last_name,
+    organization: contact.organization_name,
+    phone: contact.phone
+  };
+}
+async function domainAvailability(domain, cfg, type, period = 1) {
+  const params = new URLSearchParams({
+    domain,
+    period: String(period),
+    type,
+    optimizeFor: "ACCURACY"
+  });
+  const result = await domainApiRequest("GET", `/domains/available?${params.toString()}`, cfg);
+  return {
+    domain: result.domain ?? domain,
+    available: Boolean(result.available),
+    price: result.price,
+    currency: result.currency,
+    registryPremiumPricing: result.registryPremiumPricing
+  };
 }
 async function listDomains2(config) {
-  const cfg = config ?? getConfig4();
-  const result = await apiGet("/portfolio/domains", cfg.apiKey);
-  if (result.stub)
-    return [];
-  return result.data.domains ?? [];
+  const cfg = requireDomainConfig(config);
+  const domains = [];
+  const seenMarkers = new Set;
+  let marker;
+  while (true) {
+    const params = new URLSearchParams({ limit: "500" });
+    if (marker)
+      params.set("marker", marker);
+    const batch = await domainApiRequest("GET", customerPath(cfg, `/domains?${params.toString()}`), cfg);
+    if (!Array.isArray(batch) || batch.length === 0)
+      break;
+    domains.push(...batch.map(normalizeBrandsightDomain).filter((d3) => d3.domain));
+    if (batch.length < 500)
+      break;
+    const nextMarker = String(batch[batch.length - 1]?.domain ?? "");
+    if (!nextMarker || seenMarkers.has(nextMarker))
+      break;
+    seenMarkers.add(nextMarker);
+    marker = nextMarker;
+  }
+  return domains;
 }
 async function getDomainInfo3(domain, config) {
-  const cfg = config ?? getConfig4();
-  const result = await apiGet(`/portfolio/domains/${encodeURIComponent(domain)}`, cfg.apiKey);
-  if (result.stub)
-    return null;
-  return result.data;
+  const cfg = requireDomainConfig(config);
+  const result = await domainApiRequest("GET", customerPath(cfg, `/domains/${encodeURIComponent(domain)}`), cfg);
+  return normalizeBrandsightDomain(result);
 }
 async function checkAvailability4(domain, config) {
-  const cfg = config ?? getConfig4();
-  const result = await apiGet(`/domains/check?domain=${encodeURIComponent(domain)}`, cfg.apiKey);
-  if (result.stub)
-    return { domain, available: false };
-  return result.data;
+  const cfg = requireDomainConfig(config);
+  return domainAvailability(domain, cfg, "REGISTRATION", 1);
 }
 async function renewDomain3(domain, years = 1, config) {
-  const cfg = config ?? getConfig4();
-  const result = await apiRequest3("POST", `/portfolio/domains/${encodeURIComponent(domain)}/renew`, cfg.apiKey, { years });
-  if (result.stub)
-    return { success: false };
-  return { success: true, orderId: result.data.orderId };
+  const cfg = requireDomainConfig(config);
+  const current = await getDomainInfo3(domain, cfg);
+  if (!current?.expires)
+    throw new BrandsightApiError(`Cannot renew ${domain}: current expiry is unavailable`);
+  const quote = await domainAvailability(domain, cfg, "RENEWAL", years);
+  const price = quote.price ?? current.renewal?.price;
+  const currency = quote.currency ?? current.renewal?.currency;
+  if (price == null || !currency) {
+    throw new BrandsightApiError(`Cannot renew ${domain}: renewal quote did not include an exact price and currency`);
+  }
+  const result = await domainApiRequest("POST", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/renew`), cfg, {
+    consent: {
+      agreedAt: new Date().toISOString(),
+      agreedBy: cfg.shopperId ?? "domains-cli",
+      currency,
+      price,
+      registryPremiumPricing: quote.registryPremiumPricing ?? false
+    },
+    expires: current.expires,
+    period: years
+  });
+  return { success: true, orderId: result.orderId ?? result.id };
+}
+async function getLegalAgreements(tld, privacy = false, config) {
+  const cfg = requireDomainConfig(config);
+  const params = new URLSearchParams({
+    privacy: String(privacy),
+    tlds: tld
+  });
+  return domainApiRequest("GET", customerPath(cfg, `/domains/agreements?${params.toString()}`), cfg);
+}
+async function getRegistrationSchema(tld, config) {
+  const cfg = requireDomainConfig(config);
+  return domainApiRequest("GET", customerPath(cfg, `/domains/register/schema/${encodeURIComponent(tld)}`), cfg);
+}
+async function validateRegistrationRequest(payload, config) {
+  const cfg = requireDomainConfig(config);
+  await domainApiRequest("POST", customerPath(cfg, "/domains/register/validate"), cfg, payload);
+  return true;
+}
+async function registerBrandsightDomain(domain, contact, options = {}, config) {
+  const cfg = requireDomainConfig(config);
+  const period = options.years ?? 1;
+  const availability = await domainAvailability(domain, cfg, "REGISTRATION", period);
+  if (!availability.available)
+    throw new BrandsightApiError(`${domain} is not available for registration`);
+  const price = options.premiumPrice ?? availability.price;
+  if (price == null || !availability.currency) {
+    throw new BrandsightApiError(`Cannot register ${domain}: availability quote did not include an exact price and currency`);
+  }
+  const tld = domainTld(domain);
+  const schema = await getRegistrationSchema(tld, cfg);
+  const required = Array.isArray(schema["required"]) ? schema["required"] : [];
+  if (required.includes("metadata") && !options.metadata) {
+    throw new BrandsightApiError(`Cannot register ${domain}: ${tld} requires TLD-specific metadata; pass registration metadata before validation`);
+  }
+  const privacy = options.privacy ?? false;
+  const agreements = await getLegalAgreements(tld, privacy, cfg);
+  const agreementKeys = agreements.map((a3) => a3.agreementKey).filter(Boolean);
+  const c3 = brandsightContact(contact);
+  const payload = {
+    consent: {
+      agreedAt: new Date().toISOString(),
+      agreedBy: contact.email || cfg.shopperId || "domains-cli",
+      agreementKeys,
+      currency: availability.currency,
+      price,
+      registryPremiumPricing: availability.registryPremiumPricing ?? !!options.premiumPrice
+    },
+    contacts: {
+      admin: c3,
+      billing: c3,
+      registrant: c3,
+      tech: c3
+    },
+    domain,
+    metadata: options.metadata ?? {},
+    nameServers: options.nameservers ?? [],
+    period,
+    privacy,
+    renewAuto: options.autoRenew ?? true
+  };
+  await validateRegistrationRequest(payload, cfg);
+  const result = await domainApiRequest("POST", customerPath(cfg, "/domains/register"), cfg, payload);
+  return {
+    success: true,
+    orderId: result.orderId ?? result.id,
+    operationId: result.operationId ?? result.id,
+    chargedAmount: String(price)
+  };
+}
+async function updateNameservers3(domain, nameservers, config) {
+  const cfg = requireDomainConfig(config);
+  const result = await domainApiRequest("PUT", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/nameServers`), cfg, { nameServers: nameservers });
+  return { success: true, operationId: result.operationId ?? result.id };
+}
+async function getDnsRecords3(domain, config) {
+  const cfg = requireDomainConfig(config);
+  const records = [];
+  let offset = 0;
+  const limit = 1000;
+  while (true) {
+    const batch = await domainApiRequest("GET", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/records?offset=${offset}&limit=${limit}`), cfg);
+    if (!Array.isArray(batch) || batch.length === 0)
+      break;
+    records.push(...batch);
+    if (batch.length < limit)
+      break;
+    offset++;
+  }
+  return records;
+}
+function normalizeBrandsightDnsRecord(record) {
+  return {
+    ...record,
+    ttl: Math.max(record.ttl || 600, 600)
+  };
+}
+async function setDnsRecords3(domain, records, config) {
+  const cfg = requireDomainConfig(config);
+  await domainApiRequest("PUT", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/records`), cfg, records.map(normalizeBrandsightDnsRecord));
+  return true;
 }
 async function syncToLocalDb3(dbFns, config) {
   const domains = await listDomains2(config);
@@ -36278,7 +36876,7 @@ function createBrandsightProvider(config) {
       return domains.map((d3) => ({
         domain: d3.domain,
         registrar: "Brandsight",
-        created: "",
+        created: d3.created ?? "",
         expires: d3.expires,
         nameservers: d3.nameservers,
         status: d3.status === "ACTIVE" ? "active" : d3.status.toLowerCase(),
@@ -36292,23 +36890,58 @@ function createBrandsightProvider(config) {
       return {
         domain: d3.domain,
         registrar: "Brandsight",
-        created: "",
+        created: d3.created ?? "",
         expires: d3.expires,
         nameservers: d3.nameservers,
         status: d3.status === "ACTIVE" ? "active" : d3.status.toLowerCase(),
         auto_renew: d3.auto_renew
       };
     },
-    async renewDomain(domain) {
-      const result = await renewDomain3(domain, 1, cfg);
+    async renewDomain(domain, years = 1) {
+      const result = await renewDomain3(domain, years, cfg);
       return { domain, success: result.success, orderId: result.orderId };
     },
+    async registerDomain(domain, contact, options) {
+      const result = await registerBrandsightDomain(domain, contact, options, cfg);
+      return {
+        domain,
+        success: result.success,
+        orderId: result.orderId,
+        operationId: result.operationId,
+        chargedAmount: result.chargedAmount
+      };
+    },
+    async updateNameservers(domain, nameservers) {
+      const result = await updateNameservers3(domain, nameservers, cfg);
+      return { domain, success: result.success, operationId: result.operationId };
+    },
+    async getDnsRecords(domain) {
+      const records = await getDnsRecords3(domain, cfg);
+      return records.map((r3) => ({
+        type: r3.type,
+        name: r3.name,
+        value: r3.data,
+        ttl: r3.ttl,
+        priority: r3.priority
+      }));
+    },
+    async setDnsRecords(domain, records) {
+      return setDnsRecords3(domain, records.map((r3) => ({
+        type: r3.type,
+        name: r3.name,
+        data: r3.value,
+        ttl: r3.ttl,
+        priority: r3.priority
+      })), cfg);
+    },
     async checkAvailability(domain) {
       const result = await checkAvailability4(domain, cfg);
       return {
         domain: result.domain,
         available: result.available,
-        standard_price: result.price,
+        is_premium: result.registryPremiumPricing,
+        premium_price: result.registryPremiumPricing ? result.price : undefined,
+        standard_price: result.registryPremiumPricing ? undefined : result.price,
         currency: result.currency
       };
     },
@@ -36348,9 +36981,27 @@ function createNamecheapProvider() {
         auto_renew: true
       };
     },
-    async renewDomain(domain) {
+    async registerDomain(domain, contact, options = {}) {
       const config = getConfig();
-      const result = await renewDomain(domain, 1, config);
+      const result = await registerDomain(domain, contact, {
+        years: options.years,
+        premiumPrice: options.premiumPrice
+      }, config);
+      return {
+        domain: result.domain,
+        success: result.success,
+        orderId: result.orderId,
+        chargedAmount: result.chargedAmount
+      };
+    },
+    async updateNameservers(domain, nameservers) {
+      const config = getConfig();
+      const success = await updateNameservers(domain, nameservers, config);
+      return { domain, success };
+    },
+    async renewDomain(domain, years = 1) {
+      const config = getConfig();
+      const result = await renewDomain(domain, years, config);
       return {
         domain: result.domain,
         success: result.success,
@@ -36486,8 +37137,9 @@ var providerRegistry = new Map([
       name: "namecheap",
       type: "full",
       configured: false,
-      envVars: ["NAMECHEAP_API_KEY", "NAMECHEAP_USERNAME", "NAMECHEAP_CLIENT_IP"]
+      envVars: providerEnvNames("namecheap")
     },
+    createInventory: createNamecheapProvider,
     createRegistrar: createNamecheapProvider,
     createDns: createNamecheapProvider
   }],
@@ -36496,8 +37148,9 @@ var providerRegistry = new Map([
       name: "godaddy",
       type: "full",
       configured: false,
-      envVars: ["GODADDY_API_KEY", "GODADDY_API_SECRET"]
+      envVars: providerEnvNames("godaddy")
     },
+    createInventory: createGoDaddyProvider,
     createRegistrar: createGoDaddyProvider,
     createDns: createGoDaddyProvider
   }],
@@ -36506,8 +37159,9 @@ var providerRegistry = new Map([
       name: "route53",
       type: "full",
       configured: false,
-      envVars: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"]
+      envVars: providerEnvNames("route53")
     },
+    createInventory: () => createRoute53Provider(),
     createRegistrar: () => createRoute53Provider(),
     createDns: () => createRoute53Provider()
   }],
@@ -36516,31 +37170,64 @@ var providerRegistry = new Map([
       name: "cloudflare",
       type: "dns",
       configured: false,
-      envVars: ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"]
+      envVars: providerEnvNames("cloudflare")
     },
+    createInventory: () => createCloudflareProvider(),
     createDns: createCloudflareProvider
   }],
   ["brandsight", {
     info: {
       name: "brandsight",
-      type: "registrar",
+      type: "full",
       configured: false,
-      envVars: ["BRANDSIGHT_API_KEY", "BRANDSIGHT_ACCOUNT_ID"]
+      envVars: providerEnvNames("brandsight")
     },
-    createRegistrar: createBrandsightProvider
+    createInventory: createBrandsightProvider,
+    createRegistrar: createBrandsightProvider,
+    createDns: createBrandsightProvider
+  }],
+  ["sedo", {
+    info: {
+      name: "sedo",
+      type: "marketplace",
+      configured: false,
+      envVars: providerEnvNames("sedo")
+    }
   }]
 ]);
-function isConfigured(envVars) {
-  return envVars.slice(0, 2).every((v3) => !!process.env[v3]);
+function isConfigured(providerName) {
+  return hasProviderCredentials(providerName);
 }
 function getAvailableProviders() {
   return Array.from(providerRegistry.values()).map((e3) => ({
     ...e3.info,
-    configured: isConfigured(e3.info.envVars)
+    configured: isConfigured(e3.info.name),
+    inventory: !!e3.createInventory
   }));
 }
+function getProviderInfo(name) {
+  const entry = providerRegistry.get(name.toLowerCase());
+  if (!entry)
+    return null;
+  return { ...entry.info, configured: isConfigured(entry.info.name), inventory: !!entry.createInventory };
+}
+function providerHasRegistrar(name) {
+  return !!providerRegistry.get(name.toLowerCase())?.createRegistrar;
+}
+function providerHasDns(name) {
+  return !!providerRegistry.get(name.toLowerCase())?.createDns;
+}
+function providerHasInventory(name) {
+  return !!providerRegistry.get(name.toLowerCase())?.createInventory;
+}
+function getDomainInventoryProvider(name) {
+  const entry = providerRegistry.get(name.toLowerCase());
+  if (!entry?.createInventory)
+    throw new Error(`No domain inventory provider: ${name}`);
+  return entry.createInventory();
+}
 function getRegistrarProvider(name) {
-  const entry = providerRegistry.get(name);
+  const entry = providerRegistry.get(name.toLowerCase());
   if (!entry?.createRegistrar)
     throw new Error(`No registrar provider: ${name}`);
   return entry.createRegistrar();
@@ -36549,11 +37236,11 @@ function getProvider(name) {
   return getRegistrarProvider(name);
 }
 async function syncAll(dbFns) {
-  const available = getAvailableProviders().filter((p3) => p3.configured && (p3.type === "registrar" || p3.type === "full") && p3.name !== "brandsight");
+  const available = getAvailableProviders().filter((p3) => p3.configured && providerHasInventory(p3.name));
   const result = { providers: [], totalSynced: 0, totalErrors: [] };
   for (const info of available) {
     try {
-      const provider = getRegistrarProvider(info.name);
+      const provider = getDomainInventoryProvider(info.name);
       const syncResult = await provider.syncToLocalDb(dbFns);
       result.providers.push({ name: info.name, result: syncResult });
       result.totalSynced += syncResult.synced;
@@ -36571,14 +37258,16 @@ function autoDetectRegistrar(domain, getDomainByName2) {
   if (!dbDomain?.registrar)
     return null;
   const r3 = dbDomain.registrar.toLowerCase();
+  if (r3.includes("cloudflare dns") || r3.includes("route 53 dns") || r3.includes("route53 dns"))
+    return null;
   if (r3.includes("namecheap"))
     return "namecheap";
   if (r3.includes("godaddy"))
     return "godaddy";
-  if (r3.includes("route 53") || r3.includes("route53") || r3.includes("aws"))
+  if (r3.includes("route 53") || r3.includes("route53"))
     return "route53";
   if (r3.includes("cloudflare"))
-    return "cloudflare";
+    return null;
   if (r3.includes("brandsight"))
     return "brandsight";
   return null;
@@ -36597,8 +37286,9 @@ var PROVIDER_CAPABILITIES = {
   route53: { canBuy: true, canDns: true, gated: false, notes: "Full self-serve buy + hosted zones via AWS API; primary buy path." },
   cloudflare: { canBuy: false, canDns: true, gated: false, notes: "DNS/zone management only; not a registrar. Always our DNS." },
   namecheap: { canBuy: true, canDns: true, gated: false, notes: "Buy + DNS via API; requires API access + whitelisted IP." },
-  godaddy: { canBuy: true, canDns: true, gated: true, notes: "Domains API gated behind account thresholds (>=10 / Discount Domain Club) since 2024; purchase + DNS writes unreliable." },
-  brandsight: { canBuy: true, canDns: true, gated: true, notes: "GoDaddy Corporate Domains (enterprise/contract-only); credentials issued to onboarded clients, not self-serve." }
+  godaddy: { canBuy: false, canDns: true, gated: true, notes: "Availability remains threshold-gated; this CLI supports sync/renew/DNS records where account access qualifies, but not direct automated purchase." },
+  brandsight: { canBuy: true, canDns: true, gated: true, notes: "GoDaddy Corporate Domains (enterprise/contract-only); this CLI supports portfolio, registration, renewal, nameserver, and DNS operations through the official v2 API when the account contract permits it." },
+  sedo: { canBuy: false, canDns: false, gated: true, notes: "Marketplace API only: search/portfolio/listings and recorded purchases; no registrar DNS or direct registration API in this CLI." }
 };
 var UNKNOWN = { canBuy: false, canDns: false, gated: true, notes: "Unknown provider." };
 function getCapability(name) {
@@ -36656,17 +37346,20 @@ export {
   updateDomain,
   updateDnsRecord,
   syncAll,
+  storageSync,
+  storagePush,
+  storagePull,
   selectDnsProvider,
   selectBuyRegistrar,
   searchDomains,
-  runCloudMigrations,
+  runStorageMigrations,
   resolveTables,
   resolveCloudflareConfig,
   recordDomainPurchase,
   upsertRecords as r53UpsertRecords,
   upsertRecord as r53UpsertRecord,
-  updateNameservers as r53UpdateNameservers,
-  registerDomain as r53RegisterDomain,
+  updateNameservers2 as r53UpdateNameservers,
+  registerDomain2 as r53RegisterDomain,
   listRegisteredDomains as r53ListRegisteredDomains,
   listRecords as r53ListRecords,
   listHostedZones as r53ListHostedZones,
@@ -36678,6 +37371,9 @@ export {
   deleteHostedZone as r53DeleteHostedZone,
   createHostedZone as r53CreateHostedZone,
   checkAvailability3 as r53CheckAvailability,
+  providerHasRegistrar,
+  providerHasInventory,
+  providerHasDns,
   pollRegistrationUntilDone,
   markDomainPremium,
   listSslExpiring,
@@ -36690,9 +37386,17 @@ export {
   linkDomainEmail,
   importZoneFile,
   getSyncMetaAll,
+  getStorageSyncMetaAll,
+  getStorageStatus,
+  getStoragePg,
+  getStorageMode,
+  getStorageDatabaseUrl,
+  getStorageDatabaseEnvName,
+  getProviderInfo,
   getProvider,
   getDomainStats,
   getDomainOffer,
+  getDomainInventoryProvider,
   getDomainEmailLink,
   getDomainDetails,
   getDomainByName,
@@ -36700,8 +37404,6 @@ export {
   getDomain,
   getDnsRecord,
   getDatabase,
-  getCloudPg,
-  getCloudDatabaseUrl,
   getCapability,
   getByRegistrar,
   getAvailableProviders,
@@ -36720,9 +37422,6 @@ export {
   createAlert,
   countDomains,
   cloudflareAuthHeaders,
-  cloudSync,
-  cloudPush,
-  cloudPull,
   closeDatabase,
   classifyRegistrationStatus,
   checkSsl,
@@ -36734,11 +37433,18 @@ export {
   createZone as cfCreateZone,
   canBuy,
   autoDetectRegistrar,
+  STORAGE_TABLES,
+  STORAGE_MODE_ENV,
+  STORAGE_DATABASE_ENV,
   PgAdapterAsync,
   PROVIDER_CAPABILITIES,
   PG_MIGRATIONS,
   DOMAIN_STATUSES,
   DOMAIN_OFFER_STATUSES,
   DOMAIN_EMAIL_TYPES,
-  CLOUD_TABLES
+  DOMAINS_STORAGE_TABLES,
+  DOMAINS_STORAGE_MODE_FALLBACK_ENV,
+  DOMAINS_STORAGE_MODE_ENV,
+  DOMAINS_STORAGE_FALLBACK_ENV,
+  DOMAINS_STORAGE_ENV
 };