domsniper 0.1.0

package/src/core/features/drop-catch.ts

@@ -0,0 +1,159 @@
+import { whoisLookup } from "../whois.js";
+import { registerDomain, type RegistrarConfig } from "../registrar.js";
+import { assertValidDomain } from "../validate.js";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+const execFileAsync = promisify(execFile);
+
+export interface DropCatchConfig {
+  domain: string;
+  registrarConfig: RegistrarConfig;
+  pollIntervalMs?: number;       // how often to check (default: 30000 = 30s)
+  maxAttempts?: number;           // max polling cycles (default: 2880 = 24h at 30s)
+  onStatus?: (status: DropCatchStatus) => void;
+  onSuccess?: (domain: string) => void;
+  onFailed?: (domain: string, error: string) => void;
+}
+
+export interface DropCatchStatus {
+  domain: string;
+  attempt: number;
+  maxAttempts: number;
+  phase: "watching" | "detected" | "registering" | "success" | "failed" | "expired_timeout";
+  message: string;
+  timestamp: string;
+}
+
+type ResolvedDropCatchConfig = DropCatchConfig & Required<Pick<DropCatchConfig, "pollIntervalMs" | "maxAttempts">>;
+
+export class DropCatcher {
+  private config: ResolvedDropCatchConfig;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private attempt = 0;
+  private _running = false;
+  private _succeeded = false;
+
+  constructor(config: DropCatchConfig) {
+    assertValidDomain(config.domain);
+    this.config = {
+      pollIntervalMs: 30000,
+      maxAttempts: 2880,
+      ...config,
+    };
+  }
+
+  get running() { return this._running; }
+  get succeeded() { return this._succeeded; }
+
+  private emit(phase: DropCatchStatus["phase"], message: string) {
+    this.config.onStatus?.({
+      domain: this.config.domain,
+      attempt: this.attempt,
+      maxAttempts: this.config.maxAttempts,
+      phase,
+      message,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  async start(): Promise<void> {
+    if (this._running) return;
+    this._running = true;
+    this.attempt = 0;
+
+    this.emit("watching", `Monitoring ${this.config.domain} for drop...`);
+
+    // Initial check
+    await this.poll();
+
+    // Set up polling
+    this.timer = setInterval(() => {
+      void this.poll();
+    }, this.config.pollIntervalMs);
+  }
+
+  stop(): void {
+    this._running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  private async poll(): Promise<void> {
+    if (!this._running) return;
+    this.attempt++;
+
+    if (this.attempt > this.config.maxAttempts) {
+      this.emit("expired_timeout", "Max attempts reached, stopping.");
+      this.stop();
+      this.config.onFailed?.(this.config.domain, "Max attempts reached");
+      return;
+    }
+
+    try {
+      // Quick DNS check first (faster than full WHOIS)
+      const dnsAvailable = await this.quickDnsCheck();
+
+      if (dnsAvailable) {
+        this.emit("detected", "Domain may be available! Verifying...");
+
+        // Verify with WHOIS
+        const whois = await whoisLookup(this.config.domain);
+
+        if (whois.available) {
+          this.emit("registering", "Domain is available! Attempting registration...");
+
+          // Attempt registration immediately
+          const result = await registerDomain(this.config.domain, this.config.registrarConfig);
+
+          if (result.success) {
+            this._succeeded = true;
+            this.emit("success", `Successfully registered ${this.config.domain}!`);
+            this.config.onSuccess?.(this.config.domain);
+            this.stop();
+          } else {
+            this.emit("failed", `Registration failed: ${result.error || "Unknown error"}`);
+            // Don't stop — keep trying in case of transient failure
+          }
+        } else {
+          this.emit("watching", `Attempt ${this.attempt}/${this.config.maxAttempts} — DNS empty but WHOIS still registered`);
+        }
+      } else {
+        if (this.attempt % 10 === 0) {
+          this.emit("watching", `Attempt ${this.attempt}/${this.config.maxAttempts} — still registered`);
+        }
+      }
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : "Unknown error";
+      this.emit("watching", `Check error: ${msg} (will retry)`);
+    }
+  }
+
+  private async quickDnsCheck(): Promise<boolean> {
+    try {
+      const { stdout } = await execFileAsync("dig", ["+short", this.config.domain, "NS"], { timeout: 5000 });
+      // Empty response = no nameservers = possibly available
+      return !stdout.trim();
+    } catch {
+      return false;
+    }
+  }
+}
+
+export function createDropCatcher(config: DropCatchConfig): DropCatcher {
+  return new DropCatcher(config);
+}
+
+export function formatDropCatchStatus(status: DropCatchStatus): string {
+  const progress = `[${status.attempt}/${status.maxAttempts}]`;
+  switch (status.phase) {
+    case "watching": return `${progress} Watching ${status.domain}...`;
+    case "detected": return `${progress} DETECTED — ${status.domain} may be dropping!`;
+    case "registering": return `${progress} REGISTERING ${status.domain}...`;
+    case "success": return `${progress} SUCCESS — ${status.domain} registered!`;
+    case "failed": return `${progress} FAILED — ${status.message}`;
+    case "expired_timeout": return `${progress} TIMEOUT — stopped monitoring`;
+  }
+}

package/src/core/features/email-security.ts

@@ -0,0 +1,112 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { assertValidDomain } from "../validate.js";
+
+const execFileAsync = promisify(execFile);
+
+export interface EmailSecurityResult {
+  domain: string;
+  spf: { found: boolean; record: string | null; issues: string[] };
+  dkim: { found: boolean; record: string | null; selector: string | null };
+  dmarc: { found: boolean; record: string | null; policy: string | null; issues: string[] };
+  grade: "A" | "B" | "C" | "D" | "F";
+  issues: string[];
+}
+
+async function digTxt(query: string): Promise<string[]> {
+  try {
+    const { stdout } = await execFileAsync("dig", ["+short", query, "TXT"], { timeout: 8000 });
+    return stdout.trim().split("\n").filter(Boolean).map((l) => l.replace(/^"|"$/g, "").replace(/"\s*"/g, ""));
+  } catch {
+    return [];
+  }
+}
+
+export async function checkEmailSecurity(domain: string): Promise<EmailSecurityResult> {
+  assertValidDomain(domain);
+
+  const result: EmailSecurityResult = {
+    domain,
+    spf: { found: false, record: null, issues: [] },
+    dkim: { found: false, record: null, selector: null },
+    dmarc: { found: false, record: null, policy: null, issues: [] },
+    grade: "F",
+    issues: [],
+  };
+
+  // SPF check
+  const txtRecords = await digTxt(domain);
+  const spfRecord = txtRecords.find((r) => r.startsWith("v=spf1"));
+  if (spfRecord) {
+    result.spf.found = true;
+    result.spf.record = spfRecord;
+    if (spfRecord.includes("+all")) {
+      result.spf.issues.push("SPF uses +all (allows anyone to send)");
+      result.issues.push("SPF +all: anyone can spoof emails from this domain");
+    }
+    if (spfRecord.includes("?all")) {
+      result.spf.issues.push("SPF uses ?all (neutral — no enforcement)");
+    }
+    if (!spfRecord.includes("-all") && !spfRecord.includes("~all")) {
+      result.spf.issues.push("SPF missing strict -all or ~all");
+    }
+    // Check for too many lookups (max 10)
+    const lookups = (spfRecord.match(/include:|redirect=|a:|mx:|ptr:/g) || []).length;
+    if (lookups > 10) {
+      result.spf.issues.push(`SPF has ${lookups} lookups (max 10 allowed)`);
+    }
+  } else {
+    result.issues.push("No SPF record found");
+  }
+
+  // DMARC check
+  const dmarcRecords = await digTxt(`_dmarc.${domain}`);
+  const dmarcRecord = dmarcRecords.find((r) => r.startsWith("v=DMARC1"));
+  if (dmarcRecord) {
+    result.dmarc.found = true;
+    result.dmarc.record = dmarcRecord;
+    const policyMatch = dmarcRecord.match(/;\s*p\s*=\s*(\w+)/);
+    result.dmarc.policy = policyMatch ? policyMatch[1]! : null;
+    if (result.dmarc.policy === "none") {
+      result.dmarc.issues.push("DMARC policy is 'none' (monitoring only, no enforcement)");
+      result.issues.push("DMARC p=none: emails failing checks are still delivered");
+    }
+    if (!dmarcRecord.includes("rua=")) {
+      result.dmarc.issues.push("No aggregate reporting URI (rua) configured");
+    }
+  } else {
+    result.issues.push("No DMARC record found");
+  }
+
+  // DKIM check — try common selectors
+  const selectors = ["default", "google", "selector1", "selector2", "k1", "s1", "s2", "dkim", "mail"];
+  for (const selector of selectors) {
+    const dkimRecords = await digTxt(`${selector}._domainkey.${domain}`);
+    const dkimRecord = dkimRecords.find((r) => r.includes("v=DKIM1") || r.includes("p="));
+    if (dkimRecord) {
+      result.dkim.found = true;
+      result.dkim.record = dkimRecord;
+      result.dkim.selector = selector;
+      break;
+    }
+  }
+  if (!result.dkim.found) {
+    result.issues.push("No DKIM record found (checked common selectors)");
+  }
+
+  // Grade calculation
+  let score = 0;
+  if (result.spf.found && result.spf.issues.length === 0) score += 3;
+  else if (result.spf.found) score += 1;
+  if (result.dmarc.found && result.dmarc.policy !== "none") score += 4;
+  else if (result.dmarc.found) score += 1;
+  if (result.dkim.found) score += 3;
+
+  if (score >= 9) result.grade = "A";
+  else if (score >= 7) result.grade = "B";
+  else if (score >= 4) result.grade = "C";
+  else if (score >= 2) result.grade = "D";
+  else result.grade = "F";
+
+  return result;
+}

package/src/core/features/expiring-feed.ts

@@ -0,0 +1,160 @@
+import { assertValidDomain } from "../validate.js";
+
+export interface ExpiringDomain {
+  domain: string;
+  expiryDate: string;
+  deleteDate: string | null;
+  registrar: string | null;
+  age: string | null;
+  source: string;
+}
+
+export interface ExpiringFeedConfig {
+  apiKey?: string;      // WhoisFreaks API key (optional)
+  tld?: string;         // Filter by TLD
+  minAge?: number;      // Minimum domain age in years
+  limit?: number;       // Max results
+}
+
+/**
+ * Fetch expiring/dropped domains from WhoisFreaks API
+ * Free tier: 100 requests/month
+ * Get a key at: https://whoisfreaks.com/
+ */
+async function fetchFromWhoisFreaks(
+  config: ExpiringFeedConfig
+): Promise<ExpiringDomain[]> {
+  if (!config.apiKey) return [];
+
+  try {
+    const params = new URLSearchParams({
+      apiKey: config.apiKey,
+      whoisType: "expiring",
+    });
+    if (config.tld) params.set("tld", config.tld);
+    if (config.limit) params.set("page_size", String(Math.min(config.limit, 100)));
+
+    const resp = await fetch(
+      `https://api.whoisfreaks.com/v1.0/whois?${params.toString()}`,
+      { signal: AbortSignal.timeout(15000) }
+    );
+
+    if (!resp.ok) return [];
+
+    const data = await resp.json() as {
+      whois_domains_list?: Array<{
+        domain_name?: string;
+        expiry_date?: string;
+        create_date?: string;
+        registrar_name?: string;
+      }>;
+    };
+
+    if (!data.whois_domains_list) return [];
+
+    return data.whois_domains_list.map((d) => ({
+      domain: d.domain_name || "",
+      expiryDate: d.expiry_date || "",
+      deleteDate: null,
+      registrar: d.registrar_name || null,
+      age: d.create_date ? calculateAge(d.create_date) : null,
+      source: "WhoisFreaks",
+    })).filter((d) => d.domain);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check a specific list of domains for pending-delete status via RDAP
+ */
+export async function checkPendingDelete(domains: string[]): Promise<ExpiringDomain[]> {
+  const results: ExpiringDomain[] = [];
+
+  for (const domain of domains) {
+    try {
+      assertValidDomain(domain);
+      const resp = await fetch(
+        `https://rdap.org/domain/${encodeURIComponent(domain)}`,
+        { signal: AbortSignal.timeout(8000) }
+      );
+
+      if (!resp.ok) continue;
+
+      const data = await resp.json() as {
+        status?: string[];
+        events?: Array<{ eventAction: string; eventDate: string }>;
+        entities?: Array<{ roles?: string[]; vcardArray?: unknown[] }>;
+      };
+
+      const status = data.status || [];
+      const isPendingDelete = status.some((s) =>
+        s.toLowerCase().includes("pending delete") ||
+        s.toLowerCase().includes("redemption period") ||
+        s.toLowerCase().includes("pendingdelete")
+      );
+
+      if (isPendingDelete) {
+        let expiryDate = "";
+        const registrar: string | null = null;
+        let createdDate: string | null = null;
+
+        if (data.events) {
+          for (const event of data.events) {
+            if (event.eventAction === "expiration") expiryDate = event.eventDate;
+            if (event.eventAction === "registration") createdDate = event.eventDate;
+          }
+        }
+
+        results.push({
+          domain,
+          expiryDate,
+          deleteDate: null, // Not always available from RDAP
+          registrar,
+          age: createdDate ? calculateAge(createdDate) : null,
+          source: "RDAP",
+        });
+      }
+
+      // Rate limit
+      await new Promise((r) => setTimeout(r, 500));
+    } catch {
+      continue;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get a feed of expiring domains
+ */
+export async function getExpiringFeed(config: ExpiringFeedConfig = {}): Promise<ExpiringDomain[]> {
+  const results: ExpiringDomain[] = [];
+
+  // Try WhoisFreaks if API key provided
+  const wfResults = await fetchFromWhoisFreaks(config);
+  results.push(...wfResults);
+
+  // Apply age filter
+  if (config.minAge && config.minAge > 0) {
+    return results.filter((d) => {
+      if (!d.age) return false;
+      const years = parseInt(d.age, 10);
+      return !isNaN(years) && years >= config.minAge!;
+    });
+  }
+
+  return results.slice(0, config.limit || 50);
+}
+
+function calculateAge(createDate: string): string | null {
+  try {
+    const created = new Date(createDate);
+    if (isNaN(created.getTime())) return null;
+    const years = Math.floor((Date.now() - created.getTime()) / (365.25 * 86400000));
+    return `${years}y`;
+  } catch {
+    return null;
+  }
+}

package/src/core/features/export.ts

@@ -0,0 +1,74 @@
+/**
+ * Export results to CSV / JSON
+ */
+
+import { writeFileSync } from "fs";
+import { scoreDomain } from "./scoring.js";
+import { safePath } from "../validate.js";
+import type { DomainEntry } from "../types.js";
+
+interface ExportEntry {
+  domain: string;
+  status: string;
+  available: boolean;
+  expired: boolean;
+  confidence: string;
+  registrar: string;
+  expiryDate: string;
+  createdDate: string;
+  nameServers: string;
+  score: number;
+  grade: string;
+  price: string;
+  registered: boolean;
+}
+
+function toExportEntry(d: DomainEntry): ExportEntry {
+  const score = scoreDomain(d.domain);
+  return {
+    domain: d.domain,
+    status: d.status,
+    available: d.status === "available",
+    expired: d.status === "expired",
+    confidence: d.verification?.confidence || "",
+    registrar: d.whois?.registrar || "",
+    expiryDate: d.whois?.expiryDate || "",
+    createdDate: d.whois?.createdDate || "",
+    nameServers: (d.whois?.nameServers || []).join("; "),
+    score: score.total,
+    grade: score.total >= 85 ? "A+" : score.total >= 75 ? "A" : score.total >= 65 ? "B+" : score.total >= 55 ? "B" : score.total >= 45 ? "C+" : score.total >= 35 ? "C" : "D",
+    price: d.registrarCheck?.price ? `${d.registrarCheck.price}` : "",
+    registered: d.status === "registered",
+  };
+}
+
+export function exportToCSV(domains: DomainEntry[], filePath: string): string {
+  if (domains.length === 0) throw new Error("No domains to export");
+  const safe = safePath(filePath, [process.cwd()]);
+  const entries = domains.map(toExportEntry);
+  const headers = Object.keys(entries[0] || {});
+  const rows = entries.map((e) =>
+    headers.map((h) => {
+      const val = String((e as any)[h] ?? "");
+      return val.includes(",") || val.includes('"') ? `"${val.replace(/"/g, '""')}"` : val;
+    }).join(",")
+  );
+  const csv = [headers.join(","), ...rows].join("\n");
+  writeFileSync(safe, csv, "utf-8");
+  return safe;
+}
+
+export function exportToJSON(domains: DomainEntry[], filePath: string): string {
+  if (domains.length === 0) throw new Error("No domains to export");
+  const safe = safePath(filePath, [process.cwd()]);
+  const entries = domains.map(toExportEntry);
+  const json = JSON.stringify({
+    exported: new Date().toISOString(),
+    total: entries.length,
+    available: entries.filter((e) => e.available).length,
+    expired: entries.filter((e) => e.expired).length,
+    domains: entries,
+  }, null, 2);
+  writeFileSync(safe, json, "utf-8");
+  return safe;
+}

package/src/core/features/filter.ts

@@ -0,0 +1,96 @@
+/**
+ * Filter & sort domain results
+ */
+
+import type { DomainScore } from "./scoring.js";
+import { scoreDomain } from "./scoring.js";
+import type { DomainEntry } from "../types.js";
+
+export type SortField = "domain" | "status" | "score" | "expiry" | "price";
+export type SortOrder = "asc" | "desc";
+export type FilterStatus = "all" | "available" | "expired" | "taken" | "registered" | "actionable";
+
+export interface FilterConfig {
+  status: FilterStatus;
+  search: string;
+  sort: SortField;
+  order: SortOrder;
+  minScore: number;
+}
+
+export const DEFAULT_FILTER: FilterConfig = {
+  status: "all",
+  search: "",
+  sort: "domain",
+  order: "asc",
+  minScore: 0,
+};
+
+export function filterDomains(domains: DomainEntry[], config: FilterConfig): DomainEntry[] {
+  let filtered = [...domains];
+
+  // Status filter
+  if (config.status !== "all") {
+    if (config.status === "actionable") {
+      filtered = filtered.filter((d) => d.status === "available" || d.status === "expired");
+    } else {
+      filtered = filtered.filter((d) => d.status === config.status);
+    }
+  }
+
+  // Search filter
+  if (config.search) {
+    const q = config.search.toLowerCase();
+    filtered = filtered.filter((d) => d.domain.toLowerCase().includes(q));
+  }
+
+  // Score filter
+  if (config.minScore > 0) {
+    filtered = filtered.filter((d) => scoreDomain(d.domain).total >= config.minScore);
+  }
+
+  // Sort
+  filtered.sort((a, b) => {
+    let cmp = 0;
+    switch (config.sort) {
+      case "domain":
+        cmp = a.domain.localeCompare(b.domain);
+        break;
+      case "status": {
+        const order: Record<string, number> = { available: 0, expired: 1, registering: 2, registered: 3, taken: 4, error: 5, pending: 6, checking: 7 };
+        cmp = (order[a.status] ?? 9) - (order[b.status] ?? 9);
+        break;
+      }
+      case "score":
+        cmp = scoreDomain(b.domain).total - scoreDomain(a.domain).total;
+        break;
+      case "expiry": {
+        const aExp = a.whois?.expiryDate ? new Date(a.whois.expiryDate).getTime() : Infinity;
+        const bExp = b.whois?.expiryDate ? new Date(b.whois.expiryDate).getTime() : Infinity;
+        cmp = aExp - bExp;
+        break;
+      }
+      case "price": {
+        const aP = a.registrarCheck?.price ?? Infinity;
+        const bP = b.registrarCheck?.price ?? Infinity;
+        cmp = aP - bP;
+        break;
+      }
+    }
+    return config.order === "desc" ? -cmp : cmp;
+  });
+
+  return filtered;
+}
+
+export function nextStatus(current: FilterStatus): FilterStatus {
+  const order: FilterStatus[] = ["all", "available", "expired", "taken", "registered", "actionable"];
+  const idx = order.indexOf(current);
+  return order[(idx + 1) % order.length]!;
+}
+
+export function nextSort(current: SortField): SortField {
+  const order: SortField[] = ["domain", "status", "score", "expiry", "price"];
+  const idx = order.indexOf(current);
+  return order[(idx + 1) % order.length]!;
+}

package/src/core/features/http-probe.ts

@@ -0,0 +1,46 @@
+import { assertValidDomain } from "../validate.js";
+import type { HttpProbeResult } from "../types.js";
+
+const PARKED_INDICATORS = [
+  "parked", "for sale", "buy this domain", "domain parking",
+  "godaddy", "sedo", "afternic", "hugedomains", "dan.com",
+  "this domain is for sale", "under construction",
+];
+
+export async function httpProbe(domain: string): Promise<HttpProbeResult> {
+  assertValidDomain(domain);
+
+  for (const scheme of ["https", "http"] as const) {
+    try {
+      const resp = await fetch(`${scheme}://${domain}`, {
+        redirect: "manual",
+        signal: AbortSignal.timeout(8000),
+        headers: { "User-Agent": "DomainSniper/2.0" },
+      });
+
+      const redirectUrl = resp.status >= 300 && resp.status < 400
+        ? resp.headers.get("location")
+        : null;
+
+      let parked = false;
+      try {
+        const body = await resp.text();
+        const lower = body.toLowerCase();
+        parked = PARKED_INDICATORS.some((ind) => lower.includes(ind));
+      } catch {}
+
+      return {
+        status: resp.status,
+        redirectUrl,
+        server: resp.headers.get("server"),
+        parked,
+        reachable: true,
+        error: null,
+      };
+    } catch {
+      continue;
+    }
+  }
+
+  return { status: null, redirectUrl: null, server: null, parked: false, reachable: false, error: "Unreachable" };
+}