domsniper 0.1.0

package/src/core/features/portfolio.ts

@@ -0,0 +1,98 @@
+/**
+ * Portfolio management — SQLite-backed domain portfolio tracking
+ */
+
+import {
+  addPortfolioDomain as dbAddPortfolio,
+  removePortfolioDomain as dbRemovePortfolio,
+  getPortfolioDomains,
+  getPortfolioExpiring,
+  getPortfolioStatsDb,
+} from "../db.js";
+import { isValidDomain } from "../validate.js";
+
+export interface PortfolioDomain {
+  domain: string;
+  registrar: string;
+  purchaseDate: string;
+  expiryDate: string;
+  purchasePrice: number;
+  renewalPrice: number;
+  currency: string;
+  autoRenew: boolean;
+  tags: string[];
+  notes: string;
+  addedAt: string;
+}
+
+export interface Portfolio {
+  domains: PortfolioDomain[];
+  totalSpent: number;
+  currency: string;
+}
+
+function dbRowToPortfolioDomain(row: any): PortfolioDomain {
+  return {
+    domain: row.domain,
+    registrar: row.registrar || "unknown",
+    purchaseDate: row.purchase_date || "",
+    expiryDate: row.expiry_date || "",
+    purchasePrice: row.purchase_price || 0,
+    renewalPrice: row.renewal_price || 0,
+    currency: row.currency || "USD",
+    autoRenew: !!row.auto_renew,
+    tags: (() => { try { return JSON.parse(row.tags || "[]"); } catch { return []; } })(),
+    notes: row.notes || "",
+    addedAt: row.added_at || "",
+  };
+}
+
+export function loadPortfolio(): Portfolio {
+  const rows = getPortfolioDomains();
+  const domains = rows.map(dbRowToPortfolioDomain);
+  const totalSpent = domains.reduce((sum, d) => sum + d.purchasePrice, 0);
+  return { domains, totalSpent, currency: "USD" };
+}
+
+export function savePortfolio(_portfolio: Portfolio): void {
+  // No-op: SQLite handles persistence automatically
+  // Kept for backward compatibility
+}
+
+export function addToPortfolio(
+  domain: string,
+  details: Partial<PortfolioDomain> = {}
+): Portfolio {
+  if (!isValidDomain(domain)) throw new Error(`Invalid domain: ${domain}`);
+  dbAddPortfolio(domain, {
+    registrar: details.registrar,
+    purchaseDate: details.purchaseDate,
+    expiryDate: details.expiryDate,
+    purchasePrice: details.purchasePrice,
+    renewalPrice: details.renewalPrice,
+    currency: details.currency,
+    autoRenew: details.autoRenew,
+    tags: details.tags,
+    notes: details.notes,
+  });
+  return loadPortfolio();
+}
+
+export function removeFromPortfolio(domain: string): Portfolio {
+  dbRemovePortfolio(domain);
+  return loadPortfolio();
+}
+
+export function getExpiringDomains(withinDays: number = 30): PortfolioDomain[] {
+  return getPortfolioExpiring(withinDays).map(dbRowToPortfolioDomain);
+}
+
+export function getPortfolioStats(): {
+  total: number;
+  totalSpent: number;
+  expiringIn30: number;
+  expiringIn90: number;
+  byRegistrar: Record<string, number>;
+} {
+  return getPortfolioStatsDb();
+}

package/src/core/features/price-compare.ts

@@ -0,0 +1,39 @@
+import {
+  checkAvailabilityViaRegistrar,
+  type RegistrarConfig,
+  type RegistrarProvider,
+} from "../registrar.js";
+
+export interface PriceQuote {
+  provider: RegistrarProvider;
+  available: boolean;
+  price?: number;
+  currency?: string;
+  error?: string;
+}
+
+export async function comparePrices(
+  domain: string,
+  configs: RegistrarConfig[]
+): Promise<PriceQuote[]> {
+  const results = await Promise.allSettled(
+    configs.map((config) => checkAvailabilityViaRegistrar(domain, config))
+  );
+
+  return results.map((r, i) => {
+    if (r.status === "fulfilled") {
+      return {
+        provider: r.value.provider,
+        available: r.value.available,
+        price: r.value.price,
+        currency: r.value.currency,
+        error: r.value.error,
+      };
+    }
+    return {
+      provider: configs[i]!.provider,
+      available: false,
+      error: r.reason instanceof Error ? r.reason.message : "Failed",
+    };
+  });
+}

package/src/core/features/rdap.ts

@@ -0,0 +1,128 @@
+import { assertValidDomain } from "../validate.js";
+
+export interface RdapResult {
+  domain: string;
+  status: string[];
+  registrar: string | null;
+  registrarUrl: string | null;
+  createdDate: string | null;
+  updatedDate: string | null;
+  expiryDate: string | null;
+  nameServers: string[];
+  available: boolean;
+  error: string | null;
+}
+
+interface RdapResponse {
+  handle?: string;
+  ldhName?: string;
+  status?: string[];
+  entities?: Array<{
+    roles?: string[];
+    vcardArray?: [string, ...Array<[string, Record<string, unknown>, string, string]>];
+    publicIds?: Array<{ type: string; identifier: string }>;
+  }>;
+  events?: Array<{ eventAction: string; eventDate: string }>;
+  nameservers?: Array<{ ldhName?: string }>;
+  links?: Array<{ rel?: string; href?: string }>;
+  errorCode?: number;
+}
+
+// RDAP bootstrap: resolve TLD to the correct RDAP server
+async function getRdapUrl(domain: string): Promise<string | null> {
+  try {
+    const resp = await fetch("https://data.iana.org/rdap/dns.json", {
+      signal: AbortSignal.timeout(5000),
+    });
+    const data = await resp.json() as { services: [string[], string[]][] };
+    const tld = domain.split(".").pop()?.toLowerCase() || "";
+    for (const [tlds, urls] of data.services) {
+      if (tlds.some((t) => t.toLowerCase() === tld)) {
+        return urls[0] || null;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function rdapLookup(domain: string): Promise<RdapResult> {
+  assertValidDomain(domain);
+
+  const result: RdapResult = {
+    domain, status: [], registrar: null, registrarUrl: null,
+    createdDate: null, updatedDate: null, expiryDate: null,
+    nameServers: [], available: false, error: null,
+  };
+
+  try {
+    const baseUrl = await getRdapUrl(domain);
+    if (!baseUrl) {
+      result.error = "No RDAP server for this TLD";
+      return result;
+    }
+
+    const url = `${baseUrl.replace(/\/$/, "")}/domain/${encodeURIComponent(domain)}`;
+    const resp = await fetch(url, {
+      signal: AbortSignal.timeout(10000),
+      headers: { Accept: "application/rdap+json" },
+    });
+
+    if (resp.status === 404) {
+      result.available = true;
+      return result;
+    }
+
+    if (!resp.ok) {
+      result.error = `RDAP HTTP ${resp.status}`;
+      return result;
+    }
+
+    const data = await resp.json() as RdapResponse;
+
+    // Status
+    result.status = data.status || [];
+
+    // Registrar
+    if (data.entities) {
+      for (const entity of data.entities) {
+        if (entity.roles?.includes("registrar")) {
+          if (entity.vcardArray && entity.vcardArray.length > 1) {
+            const vcard = entity.vcardArray[1];
+            if (Array.isArray(vcard)) {
+              for (const field of vcard) {
+                if (Array.isArray(field) && field[0] === "fn") {
+                  result.registrar = String(field[3] || "");
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Events (dates)
+    if (data.events) {
+      for (const event of data.events) {
+        switch (event.eventAction) {
+          case "registration": result.createdDate = event.eventDate; break;
+          case "last changed": result.updatedDate = event.eventDate; break;
+          case "expiration": result.expiryDate = event.eventDate; break;
+        }
+      }
+    }
+
+    // Nameservers
+    if (data.nameservers) {
+      result.nameServers = data.nameservers
+        .map((ns) => ns.ldhName || "")
+        .filter(Boolean);
+    }
+
+    return result;
+  } catch (err: unknown) {
+    result.error = err instanceof Error ? err.message : "RDAP lookup failed";
+    return result;
+  }
+}

package/src/core/features/reverse-ip.ts

@@ -0,0 +1,73 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { assertValidDomain } from "../validate.js";
+
+const execFileAsync = promisify(execFile);
+
+export interface ReverseIpResult {
+  domain: string;
+  ip: string | null;
+  sharedDomains: string[];
+  source: string;
+  error: string | null;
+}
+
+async function resolveIp(domain: string): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync("dig", ["+short", domain, "A"], { timeout: 5000 });
+    return stdout.trim().split("\n")[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function reverseIpLookup(domain: string): Promise<ReverseIpResult> {
+  assertValidDomain(domain);
+
+  const result: ReverseIpResult = {
+    domain,
+    ip: null,
+    sharedDomains: [],
+    source: "",
+    error: null,
+  };
+
+  try {
+    result.ip = await resolveIp(domain);
+    if (!result.ip) {
+      result.error = "Could not resolve IP";
+      return result;
+    }
+
+    // Try HackerTarget free API (50 queries/day without API key)
+    try {
+      const resp = await fetch(
+        `https://api.hackertarget.com/reverseiplookup/?q=${encodeURIComponent(result.ip)}`,
+        { signal: AbortSignal.timeout(10000) }
+      );
+      const text = await resp.text();
+      if (!text.includes("error") && !text.includes("API count exceeded")) {
+        const domains = text.trim().split("\n").filter((d) => d && d !== domain && d.includes("."));
+        result.sharedDomains = domains.slice(0, 50);
+        result.source = "HackerTarget";
+        return result;
+      }
+    } catch {}
+
+    // Fallback: PTR record lookup
+    try {
+      const reversed = result.ip.split(".").reverse().join(".");
+      const { stdout } = await execFileAsync("dig", ["+short", `${reversed}.in-addr.arpa`, "PTR"], { timeout: 5000 });
+      const ptrs = stdout.trim().split("\n").filter(Boolean);
+      if (ptrs.length > 0) {
+        result.sharedDomains = ptrs.map((p) => p.replace(/\.$/, ""));
+        result.source = "PTR";
+      }
+    } catch {}
+
+    return result;
+  } catch (err: unknown) {
+    result.error = err instanceof Error ? err.message : "Reverse IP lookup failed";
+    return result;
+  }
+}

package/src/core/features/s3-export.ts

@@ -0,0 +1,99 @@
+/**
+ * S3 export — upload scan reports and portfolio exports to cloud storage.
+ * Uses Bun's built-in S3 client. Requires S3 env vars to be set.
+ * Works with AWS S3, Cloudflare R2, DigitalOcean Spaces, MinIO.
+ */
+
+import { S3Client } from "bun";
+import { existsSync } from "fs";
+
+export function isS3Configured(): boolean {
+  return !!(
+    process.env.S3_BUCKET &&
+    (process.env.S3_ACCESS_KEY_ID || process.env.AWS_ACCESS_KEY_ID)
+  );
+}
+
+function getS3Client(): S3Client {
+  return new S3Client({
+    accessKeyId: process.env.S3_ACCESS_KEY_ID || process.env.AWS_ACCESS_KEY_ID || "",
+    secretAccessKey: process.env.S3_SECRET_ACCESS_KEY || process.env.AWS_SECRET_ACCESS_KEY || "",
+    bucket: process.env.S3_BUCKET || "",
+    endpoint: process.env.S3_ENDPOINT || undefined,
+    region: process.env.S3_REGION || process.env.AWS_REGION || "us-east-1",
+  });
+}
+
+export async function uploadToS3(
+  key: string,
+  content: string | Buffer,
+  contentType: string = "text/plain"
+): Promise<{ url: string; key: string }> {
+  const s3 = getS3Client();
+  await s3.write(key, content, { type: contentType });
+
+  const bucket = process.env.S3_BUCKET || "";
+  const endpoint = process.env.S3_ENDPOINT || `https://${bucket}.s3.amazonaws.com`;
+  const url = `${endpoint}/${key}`;
+
+  return { url, key };
+}
+
+export async function uploadFileToS3(
+  localPath: string,
+  s3Key: string,
+  contentType?: string
+): Promise<{ url: string; key: string }> {
+  if (!existsSync(localPath)) throw new Error(`File not found: ${localPath}`);
+  const fileContent = await Bun.file(localPath).text();
+  const ct =
+    contentType ||
+    (s3Key.endsWith(".json")
+      ? "application/json"
+      : s3Key.endsWith(".csv")
+        ? "text/csv"
+        : "application/octet-stream");
+  return uploadToS3(s3Key, fileContent, ct);
+}
+
+export function generatePresignedUrl(
+  key: string,
+  expiresInSec: number = 3600
+): string {
+  const s3 = getS3Client();
+  return s3.presign(key, { expiresIn: expiresInSec });
+}
+
+export async function uploadScanReport(
+  domain: string,
+  report: unknown
+): Promise<{ url: string; key: string }> {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const key = `reports/${domain}/${timestamp}.json`;
+  const content = JSON.stringify(report, null, 2);
+  return uploadToS3(key, content, "application/json");
+}
+
+export async function uploadPortfolioExport(
+  csvContent: string
+): Promise<{ url: string; key: string }> {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const key = `exports/portfolio-${timestamp}.csv`;
+  return uploadToS3(key, csvContent, "text/csv");
+}
+
+export async function listS3Exports(
+  prefix: string = "exports/"
+): Promise<Array<{ key: string; size: number; lastModified: Date }>> {
+  const s3 = getS3Client();
+  try {
+    const result = await s3.list({ prefix, maxKeys: 100 });
+    return (result.contents || []).map((obj) => ({
+      key: obj.key,
+      size: obj.size ?? 0,
+      lastModified: obj.lastModified ? new Date(obj.lastModified) : new Date(),
+    }));
+  } catch {
+    return [];
+  }
+}

package/src/core/features/scoring.ts

@@ -0,0 +1,121 @@
+/**
+ * Domain scoring — rate how "good" a domain is
+ */
+
+export interface DomainScore {
+  total: number;       // 0-100
+  length: number;      // 0-20
+  tld: number;         // 0-20
+  readability: number; // 0-20
+  brandable: number;   // 0-20
+  seo: number;         // 0-20
+  breakdown: string[];
+}
+
+// Common English words for dictionary check
+const COMMON_WORDS = new Set([
+  "app", "web", "dev", "code", "tech", "data", "cloud", "net", "hub", "lab",
+  "run", "go", "get", "my", "the", "ai", "ml", "api", "io", "bit",
+  "box", "pay", "flow", "base", "stack", "link", "fast", "snap", "bolt", "spark",
+  "fire", "sky", "star", "wave", "cool", "zen", "pro", "max", "top",
+  "open", "free", "beta", "alpha", "mega", "super", "hyper", "ultra", "meta",
+  "sync", "ship", "dash", "grid", "node", "edge", "core", "loop", "ping",
+]);
+
+const TLD_SCORES: Record<string, number> = {
+  com: 20, io: 18, dev: 17, ai: 17, app: 16, co: 15,
+  org: 14, net: 13, me: 12, sh: 12, gg: 11, so: 11,
+  xyz: 8, tech: 10, cloud: 10, run: 10, live: 8,
+  site: 6, online: 5, store: 7, cc: 7, to: 9,
+};
+
+export function scoreDomain(domain: string): DomainScore {
+  const parts = domain.split(".");
+  const name = (parts[0] || "").toLowerCase();
+  const tld = parts.slice(1).join(".");
+  const breakdown: string[] = [];
+
+  // ── Length score (shorter = better) ──
+  let length = 0;
+  if (name.length <= 3) { length = 20; breakdown.push("Ultra-short name"); }
+  else if (name.length <= 5) { length = 18; breakdown.push("Very short name"); }
+  else if (name.length <= 7) { length = 15; breakdown.push("Short name"); }
+  else if (name.length <= 10) { length = 12; breakdown.push("Medium length"); }
+  else if (name.length <= 15) { length = 8; breakdown.push("Long name"); }
+  else { length = 4; breakdown.push("Very long name"); }
+
+  // ── TLD score ──
+  const tldScore = TLD_SCORES[tld] || 5;
+  breakdown.push(`.${tld} TLD (${tldScore >= 15 ? "premium" : tldScore >= 10 ? "good" : "average"})`);
+
+  // ── Readability ──
+  let readability = 10;
+  // Pronounceable check (has vowels)
+  const vowelCount = (name.match(/[aeiou]/gi) || []).length;
+  const vowelRatio = vowelCount / name.length;
+  if (vowelRatio >= 0.25 && vowelRatio <= 0.6) {
+    readability += 5;
+    breakdown.push("Good vowel distribution");
+  }
+  // No numbers or hyphens
+  if (!/[0-9-]/.test(name)) {
+    readability += 3;
+    breakdown.push("Clean — no numbers or hyphens");
+  } else {
+    readability -= 3;
+    breakdown.push("Contains numbers/hyphens");
+  }
+  // No double consonants clusters
+  if (!/[bcdfghjklmnpqrstvwxyz]{4,}/i.test(name)) {
+    readability += 2;
+  } else {
+    readability -= 2;
+    breakdown.push("Hard consonant cluster");
+  }
+  readability = Math.max(0, Math.min(20, readability));
+
+  // ── Brandability ──
+  let brandable = 10;
+  // Contains common word
+  const containsWord = Array.from(COMMON_WORDS).some((w) => name.includes(w));
+  if (containsWord) {
+    brandable += 4;
+    breakdown.push("Contains common word");
+  }
+  // Single word (no hyphens)
+  if (!name.includes("-")) {
+    brandable += 3;
+  }
+  // Memorable length
+  if (name.length >= 4 && name.length <= 8) {
+    brandable += 3;
+    breakdown.push("Memorable length (4-8 chars)");
+  }
+  brandable = Math.max(0, Math.min(20, brandable));
+
+  // ── SEO potential ──
+  let seo = 10;
+  // .com bonus
+  if (tld === "com") { seo += 5; breakdown.push(".com SEO advantage"); }
+  else if (["io", "dev", "ai", "app"].includes(tld)) { seo += 3; }
+  // Short domain bonus
+  if (name.length <= 8) seo += 3;
+  // No weird chars
+  if (/^[a-z]+$/.test(name)) seo += 2;
+  seo = Math.max(0, Math.min(20, seo));
+
+  const total = Math.min(100, length + tldScore + readability + brandable + seo);
+
+  return { total, length, tld: tldScore, readability, brandable, seo, breakdown };
+}
+
+export function scoreGrade(score: number): { grade: string; color: string } {
+  if (score >= 85) return { grade: "A+", color: "#00e88f" };
+  if (score >= 75) return { grade: "A", color: "#00e88f" };
+  if (score >= 65) return { grade: "B+", color: "#5c9cf5" };
+  if (score >= 55) return { grade: "B", color: "#5c9cf5" };
+  if (score >= 45) return { grade: "C+", color: "#f5c542" };
+  if (score >= 35) return { grade: "C", color: "#f5c542" };
+  if (score >= 25) return { grade: "D", color: "#f5955c" };
+  return { grade: "F", color: "#f55c5c" };
+}