domain-search-mcp 1.0.0

package/src/fallbacks/whois.ts

@@ -0,0 +1,250 @@
+/**
+ * WHOIS Fallback (RFC 3912).
+ *
+ * Legacy protocol for domain lookup.
+ * Public, no authentication required.
+ * Slower than RDAP - use as last resort.
+ *
+ * Note: We use a public WHOIS API to avoid raw TCP connections
+ * which aren't well-supported in all Node.js environments.
+ */
+
+import axios, { type AxiosError } from 'axios';
+import type { DomainResult } from '../types.js';
+import { logger } from '../utils/logger.js';
+import { TimeoutError, RegistrarApiError } from '../utils/errors.js';
+
+/**
+ * WHOIS server mappings for common TLDs.
+ */
+const WHOIS_SERVERS: Record<string, string> = {
+  com: 'whois.verisign-grs.com',
+  net: 'whois.verisign-grs.com',
+  org: 'whois.pir.org',
+  io: 'whois.nic.io',
+  dev: 'whois.nic.google',
+  app: 'whois.nic.google',
+  co: 'whois.nic.co',
+  ai: 'whois.nic.ai',
+  me: 'whois.nic.me',
+  cc: 'ccwhois.verisign-grs.com',
+  xyz: 'whois.nic.xyz',
+  sh: 'whois.nic.sh',
+};
+
+/**
+ * Patterns that indicate a domain is NOT available.
+ */
+const REGISTERED_PATTERNS = [
+  /domain name:/i,
+  /registrant:/i,
+  /creation date:/i,
+  /name server:/i,
+  /status:\s*(?:active|ok|registered)/i,
+];
+
+/**
+ * Patterns that indicate a domain IS available.
+ */
+const AVAILABLE_PATTERNS = [
+  /no match/i,
+  /not found/i,
+  /no data found/i,
+  /no entries found/i,
+  /no object found/i,
+  /domain not found/i,
+  /no whois server/i,
+  /available for registration/i,
+  /is free/i,
+  /status:\s*free/i,
+];
+
+/**
+ * Parse WHOIS response to determine availability.
+ */
+function parseWhoisResponse(response: string): boolean {
+  const text = response.toLowerCase();
+
+  // Check for "available" patterns first
+  for (const pattern of AVAILABLE_PATTERNS) {
+    if (pattern.test(text)) {
+      return true;
+    }
+  }
+
+  // Check for "registered" patterns
+  for (const pattern of REGISTERED_PATTERNS) {
+    if (pattern.test(text)) {
+      return false;
+    }
+  }
+
+  // If no clear indication, assume not available (safer)
+  return false;
+}
+
+/**
+ * Check domain availability using a public WHOIS API.
+ *
+ * We use a web-based WHOIS lookup to avoid TCP connection issues.
+ * This is more reliable across different environments.
+ */
+export async function checkWhois(
+  domain: string,
+  tld: string,
+): Promise<DomainResult> {
+  const fullDomain = `${domain}.${tld}`;
+  logger.debug('WHOIS check', { domain: fullDomain });
+
+  // Use a public WHOIS API service
+  // There are several options; we'll try a few
+  const apis = [
+    {
+      url: `https://whoisjson.com/api/v1/whois`,
+      params: { domain: fullDomain },
+      parser: (data: Record<string, unknown>) => {
+        // If we get a result, domain is registered
+        if (data.domain_name || data.registrar) {
+          return false;
+        }
+        // If error or no data, domain might be available
+        return true;
+      },
+    },
+  ];
+
+  // Try each API in order
+  for (const api of apis) {
+    try {
+      const response = await axios.get(api.url, {
+        params: api.params,
+        timeout: 15000,
+        headers: {
+          Accept: 'application/json',
+        },
+        validateStatus: () => true, // Don't throw on any status
+      });
+
+      if (response.status === 200 && response.data) {
+        // Try to parse the response
+        let available: boolean;
+
+        if (typeof response.data === 'string') {
+          available = parseWhoisResponse(response.data);
+        } else {
+          available = api.parser(response.data as Record<string, unknown>);
+        }
+
+        return createWhoisResult(domain, tld, available);
+      }
+    } catch (error) {
+      logger.debug('WHOIS API failed, trying next', {
+        api: api.url,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  // If all APIs fail, try a simple text-based WHOIS lookup
+  try {
+    const available = await textBasedWhoisCheck(fullDomain, tld);
+    return createWhoisResult(domain, tld, available);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes('timeout')) {
+      throw new TimeoutError('WHOIS lookup', 15000);
+    }
+
+    throw new RegistrarApiError(
+      'whois',
+      error instanceof Error ? error.message : 'All WHOIS lookups failed',
+    );
+  }
+}
+
+/**
+ * Simple text-based WHOIS check using a web proxy.
+ */
+async function textBasedWhoisCheck(
+  fullDomain: string,
+  tld: string,
+): Promise<boolean> {
+  // Try who.is web service
+  try {
+    const response = await axios.get(`https://who.is/whois/${fullDomain}`, {
+      timeout: 15000,
+      headers: {
+        'User-Agent': 'Domain-Search-MCP/1.0',
+      },
+    });
+
+    const html = response.data as string;
+
+    // Check for "not registered" indicators in the page
+    if (
+      html.includes('is available for registration') ||
+      html.includes('No match for') ||
+      html.includes('not found')
+    ) {
+      return true;
+    }
+
+    // Check for registered indicators
+    if (
+      html.includes('Registrar:') ||
+      html.includes('Creation Date:') ||
+      html.includes('Name Server:')
+    ) {
+      return false;
+    }
+
+    // Default to not available
+    return false;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      const axiosError = error as AxiosError;
+
+      if (axiosError.code === 'ECONNABORTED') {
+        throw new Error('timeout');
+      }
+    }
+
+    throw error;
+  }
+}
+
+/**
+ * Create a standardized result from WHOIS.
+ */
+function createWhoisResult(
+  domain: string,
+  tld: string,
+  available: boolean,
+): DomainResult {
+  return {
+    domain: `${domain}.${tld}`,
+    available,
+    premium: false, // WHOIS doesn't tell us about premium status
+    price_first_year: null, // WHOIS doesn't provide pricing
+    price_renewal: null,
+    currency: 'USD',
+    privacy_included: false,
+    transfer_price: null,
+    registrar: 'unknown',
+    source: 'whois',
+    checked_at: new Date().toISOString(),
+  };
+}
+
+/**
+ * Get WHOIS server for a TLD.
+ */
+export function getWhoisServer(tld: string): string | null {
+  return WHOIS_SERVERS[tld] || null;
+}
+
+/**
+ * Check if WHOIS is available for a TLD.
+ */
+export function isWhoisAvailable(tld: string): boolean {
+  return WHOIS_SERVERS[tld] !== undefined;
+}

package/src/registrars/base.ts

@@ -0,0 +1,264 @@
+/**
+ * Base Registrar Adapter.
+ *
+ * Abstract class that all registrar adapters extend.
+ * Provides common functionality:
+ * - Rate limiting (token bucket)
+ * - Retry with exponential backoff
+ * - Error handling and logging
+ */
+
+import type { DomainResult, TLDInfo } from '../types.js';
+import { logger } from '../utils/logger.js';
+import {
+  RateLimitError,
+  RegistrarApiError,
+  TimeoutError,
+  wrapError,
+} from '../utils/errors.js';
+import { config } from '../config.js';
+
+/**
+ * Token bucket rate limiter.
+ */
+export class RateLimiter {
+  private tokens: number;
+  private readonly maxTokens: number;
+  private readonly refillRate: number; // tokens per second
+  private lastRefill: number;
+
+  constructor(maxPerMinute: number = 60) {
+    this.maxTokens = maxPerMinute;
+    this.tokens = maxPerMinute;
+    this.refillRate = maxPerMinute / 60; // Convert to per-second
+    this.lastRefill = Date.now();
+  }
+
+  /**
+   * Try to consume a token. Returns true if successful.
+   */
+  tryConsume(): boolean {
+    this.refill();
+
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Wait until a token is available.
+   */
+  async waitForToken(): Promise<void> {
+    while (!this.tryConsume()) {
+      // Calculate wait time for next token
+      const waitMs = Math.ceil(1000 / this.refillRate);
+      await sleep(waitMs);
+    }
+  }
+
+  /**
+   * Refill tokens based on elapsed time.
+   */
+  private refill(): void {
+    const now = Date.now();
+    const elapsed = (now - this.lastRefill) / 1000;
+    const refillAmount = elapsed * this.refillRate;
+
+    this.tokens = Math.min(this.maxTokens, this.tokens + refillAmount);
+    this.lastRefill = now;
+  }
+
+  /**
+   * Get seconds until next token is available.
+   */
+  getWaitSeconds(): number {
+    if (this.tokens >= 1) return 0;
+    const neededTokens = 1 - this.tokens;
+    return Math.ceil(neededTokens / this.refillRate);
+  }
+}
+
+/**
+ * Sleep helper.
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Abstract base class for registrar adapters.
+ */
+export abstract class RegistrarAdapter {
+  /** Human-readable name of the registrar */
+  abstract readonly name: string;
+
+  /** Identifier used in results */
+  abstract readonly id: string;
+
+  /** Rate limiter for this registrar */
+  protected readonly rateLimiter: RateLimiter;
+
+  /** Max retry attempts */
+  protected readonly maxRetries: number = 3;
+
+  /** Base delay for exponential backoff (ms) */
+  protected readonly baseDelayMs: number = 2000;
+
+  /** Request timeout (ms) */
+  protected readonly timeoutMs: number = 10000;
+
+  constructor(requestsPerMinute: number = 60) {
+    this.rateLimiter = new RateLimiter(requestsPerMinute);
+  }
+
+  /**
+   * Check domain availability and get pricing.
+   * This is the main method each adapter must implement.
+   */
+  abstract search(domain: string, tld: string): Promise<DomainResult>;
+
+  /**
+   * Get information about a TLD.
+   * Optional - not all registrars provide this.
+   */
+  abstract getTldInfo(tld: string): Promise<TLDInfo | null>;
+
+  /**
+   * Check if this adapter is enabled (has required credentials).
+   */
+  abstract isEnabled(): boolean;
+
+  /**
+   * Execute a function with rate limiting.
+   */
+  protected async rateLimitedCall<T>(fn: () => Promise<T>): Promise<T> {
+    // Check if we should even try (dry run mode)
+    if (config.dryRun) {
+      throw new RegistrarApiError(this.name, 'Dry run mode - no API calls made');
+    }
+
+    // Wait for rate limit
+    const waitSeconds = this.rateLimiter.getWaitSeconds();
+    if (waitSeconds > 0) {
+      logger.debug(`Rate limiting: waiting ${waitSeconds}s for ${this.name}`);
+    }
+    await this.rateLimiter.waitForToken();
+
+    return fn();
+  }
+
+  /**
+   * Execute with retry and exponential backoff.
+   */
+  protected async retryWithBackoff<T>(
+    fn: () => Promise<T>,
+    operation: string,
+  ): Promise<T> {
+    let lastError: Error | undefined;
+
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await this.rateLimitedCall(fn);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+
+        // Check if we should retry
+        const wrapped = wrapError(error);
+        if (!wrapped.retryable) {
+          throw wrapped;
+        }
+
+        // Check if it's a rate limit error with retry-after
+        if (error instanceof RateLimitError && error.retryAfter) {
+          const waitMs = error.retryAfter - Date.now();
+          if (waitMs > 0 && waitMs < 60000) {
+            logger.info(`Rate limited, waiting ${waitMs}ms`, {
+              registrar: this.name,
+              attempt,
+            });
+            await sleep(waitMs);
+            continue;
+          }
+        }
+
+        // Exponential backoff
+        if (attempt < this.maxRetries) {
+          const delay = this.baseDelayMs * Math.pow(2, attempt - 1);
+          logger.warn(`Retry ${attempt}/${this.maxRetries} for ${operation}`, {
+            registrar: this.name,
+            delay_ms: delay,
+            error: lastError.message,
+          });
+          await sleep(delay);
+        }
+      }
+    }
+
+    // All retries failed
+    throw lastError || new Error(`Failed after ${this.maxRetries} retries`);
+  }
+
+  /**
+   * Create a timeout wrapper for a promise.
+   */
+  protected withTimeout<T>(
+    promise: Promise<T>,
+    operation: string,
+    timeoutMs: number = this.timeoutMs,
+  ): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new TimeoutError(operation, timeoutMs));
+      }, timeoutMs);
+
+      promise
+        .then((result) => {
+          clearTimeout(timer);
+          resolve(result);
+        })
+        .catch((error) => {
+          clearTimeout(timer);
+          reject(error);
+        });
+    });
+  }
+
+  /**
+   * Log an error with context.
+   */
+  protected logError(error: Error, context?: Record<string, unknown>): void {
+    logger.logError(`${this.name} error`, error, {
+      registrar: this.id,
+      ...context,
+    });
+  }
+
+  /**
+   * Create a standardized DomainResult.
+   */
+  protected createResult(
+    domain: string,
+    tld: string,
+    data: Partial<DomainResult>,
+  ): DomainResult {
+    return {
+      domain: `${domain}.${tld}`,
+      available: data.available ?? false,
+      premium: data.premium ?? false,
+      price_first_year: data.price_first_year ?? null,
+      price_renewal: data.price_renewal ?? null,
+      currency: data.currency ?? 'USD',
+      privacy_included: data.privacy_included ?? false,
+      transfer_price: data.transfer_price ?? null,
+      registrar: this.id,
+      source: data.source ?? (`${this.id}_api` as DomainResult['source']),
+      checked_at: new Date().toISOString(),
+      premium_reason: data.premium_reason,
+      tld_restrictions: data.tld_restrictions,
+      score: data.score,
+    };
+  }
+}

package/src/registrars/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Registrar Exports.
+ */
+
+export { RegistrarAdapter } from './base.js';
+export { PorkbunAdapter, porkbunAdapter } from './porkbun.js';
+export { NamecheapAdapter, namecheapAdapter } from './namecheap.js';