Domain Portfolio Automation at Scale: Bulk WHOIS Audits and Drift Detection

// expiration-monitor.ts
// Daily bulk WHOIS audit for domain expiration tracking

interface DomainRecord {
  domain: string;
  registrar: string;
  expirationDate: string;
  lastChecked: string;
  status: 'ok' | 'warning' | 'critical' | 'expired';
}

const EXPIRY_THRESHOLDS = {
  critical: 30,  // 30 days
  warning: 90,   // 90 days
};

function classifyExpiry(expirationDate: string): DomainRecord['status'] {
  const daysUntilExpiry = Math.ceil(
    (new Date(expirationDate).getTime() - Date.now()) / (1000 * 60 * 60 * 24)
  );
  if (daysUntilExpiry <= 0) return 'expired';
  if (daysUntilExpiry <= EXPIRY_THRESHOLDS.critical) return 'critical';
  if (daysUntilExpiry <= EXPIRY_THRESHOLDS.warning) return 'warning';
  return 'ok';
}

async function auditPortfolio(domains: string[]): Promise<DomainRecord[]> {
  const API_KEY = process.env.OPS_TOOLS_API_KEY;
  const results: DomainRecord[] = [];

  // Process in batches to respect rate limits
  const batchSize = 50;
  for (let i = 0; i < domains.length; i += batchSize) {
    const batch = domains.slice(i, i + batchSize);
    const batchResults = await Promise.allSettled(
      batch.map(async (domain) => {
        const res = await fetch(
          `https://api.ops.tools/v1/whois/${domain}`,
          { headers: { 'Authorization': `Bearer ${API_KEY}` } }
        );
        const data = await res.json();
        return {
          domain,
          registrar: data.registrar ?? 'unknown',
          expirationDate: data.expirationDate,
          lastChecked: new Date().toISOString(),
          status: classifyExpiry(data.expirationDate),
        } satisfies DomainRecord;
      })
    );

    for (const result of batchResults) {
      if (result.status === 'fulfilled') {
        results.push(result.value);
      }
    }

    // Throttle between batches
    if (i + batchSize < domains.length) {
      await new Promise((resolve) => setTimeout(resolve, 1000));
    }
  }

  return results;
}

// drift-detector.ts
// Compare live DNS records against stored baseline

interface DriftResult {
  domain: string;
  recordType: string;
  expected: string[];
  actual: string[];
  driftType: 'added' | 'removed' | 'changed';
}

async function detectDnsDrift(domain: string): Promise<DriftResult[]> {
  const API_KEY = process.env.OPS_TOOLS_API_KEY;
  const recordTypes = ['A', 'AAAA', 'MX', 'CNAME', 'TXT', 'NS'];
  const drifts: DriftResult[] = [];

  for (const recordType of recordTypes) {
    const res = await fetch(
      `https://api.ops.tools/v1/dns/lookup?domain=${domain}&recordType=${recordType}`,
      { headers: { 'Authorization': `Bearer ${API_KEY}` } }
    );
    const data = await res.json();
    const actualRecords = data.records?.[recordType] ?? [];

    // Load baseline from your config store or last-known-good state
    const baseline = await getBaseline(domain, recordType);
    const expectedRecords = baseline ?? [];

    const added = actualRecords.filter((r: string) => !expectedRecords.includes(r));
    const removed = expectedRecords.filter((r: string) => !actualRecords.includes(r));

    if (added.length > 0) {
      drifts.push({ domain, recordType, expected: expectedRecords, actual: actualRecords, driftType: 'added' });
    }
    if (removed.length > 0) {
      drifts.push({ domain, recordType, expected: expectedRecords, actual: actualRecords, driftType: 'removed' });
    }
  }

  return drifts;
}

// ssl-audit.ts
// Bulk SSL certificate validation across the portfolio

interface SslAuditResult {
  domain: string;
  issuer: string;
  validFrom: string;
  validTo: string;
  daysRemaining: number;
  isExpired: boolean;
  isSelfSigned: boolean;
  status: 'valid' | 'expiring-soon' | 'expired' | 'self-signed';
}

async function auditSslCertificates(domains: string[]): Promise<SslAuditResult[]> {
  const API_KEY = process.env.OPS_TOOLS_API_KEY;
  const results: SslAuditResult[] = [];

  for (const domain of domains) {
    const res = await fetch(
      `https://api.ops.tools/v1/ssl/check?domain=${domain}`,
      { headers: { 'Authorization': `Bearer ${API_KEY}` } }
    );
    const data = await res.json();
    const daysRemaining = Math.ceil(
      (new Date(data.validTo).getTime() - Date.now()) / (1000 * 60 * 60 * 24)
    );

    let status: SslAuditResult['status'] = 'valid';
    if (data.isSelfSigned) status = 'self-signed';
    else if (daysRemaining <= 0) status = 'expired';
    else if (daysRemaining <= 30) status = 'expiring-soon';

    results.push({
      domain,
      issuer: data.issuer ?? 'unknown',
      validFrom: data.validFrom,
      validTo: data.validTo,
      daysRemaining,
      isExpired: daysRemaining <= 0,
      isSelfSigned: data.isSelfSigned ?? false,
      status,
    });
  }

  return results.sort((a, b) => a.daysRemaining - b.daysRemaining);
}

# WHOIS lookup for a single domain
curl -s "https://api.ops.tools/v1/whois/example.com" \
  -H "Authorization: Bearer YOUR_API_KEY"

# DNS record check for drift detection
curl -s "https://api.ops.tools/v1/dns/lookup?domain=example.com&recordType=A,MX,TXT,NS" \
  -H "Authorization: Bearer YOUR_API_KEY"

# SSL certificate validation
curl -s "https://api.ops.tools/v1/ssl/check?domain=example.com" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Reverse IP lookup for shared hosting detection
curl -s "https://api.ops.tools/v1/ip/reverse?ip=93.184.216.34" \
  -H "Authorization: Bearer YOUR_API_KEY"