domsniper 0.1.0

package/src/core/index.ts

@@ -0,0 +1,50 @@
+// Core modules
+export * from "./types.js";
+export * from "./validate.js";
+export * from "./db.js";
+export * from "./whois.js";
+export * from "./registrar.js";
+export * from "./theme.js";
+export * from "./paths.js";
+
+// Features
+export * from "./features/dns-details.js";
+export * from "./features/http-probe.js";
+export * from "./features/wayback.js";
+export * from "./features/domain-age.js";
+export * from "./features/scoring.js";
+export * from "./features/filter.js";
+export * from "./features/export.js";
+export * from "./features/session.js";
+export * from "./features/tld-expand.js";
+export * from "./features/variations.js";
+export * from "./features/watch.js";
+export * from "./features/config.js";
+export * from "./features/rdap.js";
+export * from "./features/ssl-check.js";
+export * from "./features/subdomain-discovery.js";
+export * from "./features/marketplace.js";
+export * from "./features/webhooks.js";
+export * from "./features/domain-suggest.js";
+export * from "./features/portfolio.js";
+export * from "./features/portfolio-monitor.js";
+export * from "./features/portfolio-bulk.js";
+export * from "./features/price-compare.js";
+export * from "./features/social-check.js";
+export * from "./features/tech-stack.js";
+export * from "./features/blacklist-check.js";
+export * from "./features/backlinks.js";
+export * from "./features/whois-history.js";
+export * from "./features/drop-catch.js";
+export * from "./features/expiring-feed.js";
+export * from "./features/port-scanner.js";
+export * from "./features/reverse-ip.js";
+export * from "./features/asn-lookup.js";
+export * from "./features/email-security.js";
+export * from "./features/zone-transfer.js";
+export * from "./features/cert-transparency.js";
+export * from "./features/takeover-detect.js";
+export * from "./features/security-headers.js";
+export * from "./features/waf-detect.js";
+export * from "./features/path-scanner.js";
+export * from "./features/cors-check.js";

package/src/core/paths.ts

@@ -0,0 +1,9 @@
+import { join } from "path";
+import { homedir } from "os";
+
+export const APP_DIR = join(homedir(), ".domain-sniper");
+export const CONFIG_FILE = join(APP_DIR, "config.json");
+export const PORTFOLIO_FILE = join(APP_DIR, "portfolio.json");
+export const SESSION_DIR = join(APP_DIR, "sessions");
+export const WHOIS_HISTORY_DIR = join(APP_DIR, "whois-history");
+export const DB_FILE = join(APP_DIR, "domain-sniper.db");

package/src/core/registrar.ts

@@ -0,0 +1,413 @@
+/**
+ * Domain registrar integrations
+ * Supports GoDaddy, Namecheap, and Cloudflare APIs
+ */
+
+export type RegistrarProvider = "godaddy" | "namecheap" | "cloudflare";
+
+interface GodaddyAvailabilityResponse {
+  available: boolean;
+  price?: number;
+  currency?: string;
+}
+
+interface GodaddyPurchaseResponse {
+  orderId?: number;
+  message?: string;
+}
+
+interface CloudflareResponse<T> {
+  success: boolean;
+  result?: T;
+  errors?: { message: string }[];
+}
+
+export interface RegistrarConfig {
+  provider: RegistrarProvider;
+  apiKey: string;
+  apiSecret?: string;
+  accountId?: string; // For Cloudflare
+  username?: string; // For Namecheap
+  clientIp?: string; // For Namecheap
+}
+
+export interface RegistrationResult {
+  success: boolean;
+  domain: string;
+  provider: RegistrarProvider;
+  message: string;
+  orderId?: string;
+  error?: string;
+}
+
+export interface AvailabilityCheckResult {
+  domain: string;
+  available: boolean;
+  price?: number;
+  currency?: string;
+  provider: RegistrarProvider;
+  error?: string;
+}
+
+// ─── GoDaddy ──────────────────────────────────────────────
+
+async function godaddyCheckAvailability(
+  domain: string,
+  config: RegistrarConfig
+): Promise<AvailabilityCheckResult> {
+  try {
+    const resp = await fetch(
+      `https://api.godaddy.com/v1/domains/available?domain=${encodeURIComponent(domain)}`,
+      {
+        headers: {
+          Authorization: `sso-key ${config.apiKey}:${config.apiSecret}`,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    const data = (await resp.json()) as GodaddyAvailabilityResponse;
+    return {
+      domain,
+      available: data.available === true,
+      price: data.price ? data.price / 1000000 : undefined,
+      currency: data.currency || "USD",
+      provider: "godaddy" as const,
+    };
+  } catch (err: unknown) {
+    return {
+      domain,
+      available: false,
+      provider: "godaddy" as const,
+      error: err instanceof Error ? err.message : "Unknown error",
+    };
+  }
+}
+
+async function godaddyRegister(
+  domain: string,
+  config: RegistrarConfig
+): Promise<RegistrationResult> {
+  try {
+    const body = {
+      domain,
+      consent: {
+        agreedAt: new Date().toISOString(),
+        agreedBy: config.clientIp || "127.0.0.1",
+        agreementKeys: ["DNRA"],
+      },
+      period: 1,
+      renewAuto: false,
+      nameServers: [],
+      privacy: false,
+    };
+
+    const resp = await fetch("https://api.godaddy.com/v1/domains/purchase", {
+      method: "POST",
+      headers: {
+        Authorization: `sso-key ${config.apiKey}:${config.apiSecret}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    const data = (await resp.json()) as GodaddyPurchaseResponse;
+    if (resp.ok) {
+      return {
+        success: true,
+        domain,
+        provider: "godaddy" as const,
+        message: `Domain ${domain} registered successfully!`,
+        orderId: data.orderId?.toString(),
+      };
+    }
+    return {
+      success: false,
+      domain,
+      provider: "godaddy" as const,
+      message: "Registration failed",
+      error: data.message || JSON.stringify(data),
+    };
+  } catch (err: unknown) {
+    return {
+      success: false,
+      domain,
+      provider: "godaddy" as const,
+      message: "Registration failed",
+      error: err instanceof Error ? err.message : "Unknown error",
+    };
+  }
+}
+
+// ─── Namecheap ────────────────────────────────────────────
+
+function parseNamecheapDomain(domain: string): { sld: string; tld: string } {
+  const parts = domain.split(".");
+  const tld = parts.slice(1).join(".");
+  const sld = parts[0] || "";
+  return { sld, tld };
+}
+
+async function namecheapCheckAvailability(
+  domain: string,
+  config: RegistrarConfig
+): Promise<AvailabilityCheckResult> {
+  try {
+    const url = new URL("https://api.namecheap.com/xml.response");
+    url.searchParams.set("ApiUser", config.username || "");
+    url.searchParams.set("ApiKey", config.apiKey);
+    url.searchParams.set("UserName", config.username || "");
+    url.searchParams.set("ClientIp", config.clientIp || "127.0.0.1");
+    url.searchParams.set("Command", "namecheap.domains.check");
+    url.searchParams.set("DomainList", domain);
+
+    const resp = await fetch(url.toString());
+    const text = await resp.text();
+
+    const available = text.includes('Available="true"');
+    return {
+      domain,
+      available,
+      provider: "namecheap" as const,
+    };
+  } catch (err: unknown) {
+    return {
+      domain,
+      available: false,
+      provider: "namecheap" as const,
+      error: err instanceof Error ? err.message : "Unknown error",
+    };
+  }
+}
+
+async function namecheapRegister(
+  domain: string,
+  config: RegistrarConfig
+): Promise<RegistrationResult> {
+  try {
+    const { sld, tld } = parseNamecheapDomain(domain);
+    const url = new URL("https://api.namecheap.com/xml.response");
+    url.searchParams.set("ApiUser", config.username || "");
+    url.searchParams.set("ApiKey", config.apiKey);
+    url.searchParams.set("UserName", config.username || "");
+    url.searchParams.set("ClientIp", config.clientIp || "127.0.0.1");
+    url.searchParams.set("Command", "namecheap.domains.create");
+    url.searchParams.set("DomainName", domain);
+    url.searchParams.set("Years", "1");
+    // Registrant info would need to be configured
+    url.searchParams.set("AuxBillingFirstName", "Domain");
+    url.searchParams.set("AuxBillingLastName", "Sniper");
+
+    const resp = await fetch(url.toString());
+    const text = await resp.text();
+
+    if (text.includes('Status="OK"') || text.includes("DomainCreated")) {
+      return {
+        success: true,
+        domain,
+        provider: "namecheap" as const,
+        message: `Domain ${domain} registered via Namecheap!`,
+      };
+    }
+
+    return {
+      success: false,
+      domain,
+      provider: "namecheap" as const,
+      message: "Registration failed",
+      error: text.match(/<Error.*?>(.*?)<\/Error>/)?.[1] || "Unknown error",
+    };
+  } catch (err: unknown) {
+    return {
+      success: false,
+      domain,
+      provider: "namecheap" as const,
+      message: "Registration failed",
+      error: err instanceof Error ? err.message : "Unknown error",
+    };
+  }
+}
+
+// ─── Cloudflare ───────────────────────────────────────────
+
+async function cloudflareCheckAvailability(
+  domain: string,
+  config: RegistrarConfig
+): Promise<AvailabilityCheckResult> {
+  try {
+    if (!config.accountId) {
+      return {
+        domain,
+        available: false,
+        provider: "cloudflare",
+        error: "Account ID required for Cloudflare",
+      };
+    }
+
+    const resp = await fetch(
+      `https://api.cloudflare.com/client/v4/accounts/${config.accountId}/registrar/domains/${domain}`,
+      {
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    const data = (await resp.json()) as CloudflareResponse<{ available?: boolean }>;
+
+    if (!data.success) {
+      return {
+        domain,
+        available: false,
+        provider: "cloudflare" as const,
+        error: data.errors?.[0]?.message || "API request failed",
+      };
+    }
+
+    if (data.result?.available) {
+      return {
+        domain,
+        available: true,
+        provider: "cloudflare" as const,
+      };
+    }
+
+    return {
+      domain,
+      available: false,
+      provider: "cloudflare" as const,
+    };
+  } catch (err: unknown) {
+    return {
+      domain,
+      available: false,
+      provider: "cloudflare" as const,
+      error: err instanceof Error ? err.message : "Unknown error",
+    };
+  }
+}
+
+async function cloudflareRegister(
+  domain: string,
+  config: RegistrarConfig
+): Promise<RegistrationResult> {
+  try {
+    if (!config.accountId) {
+      return {
+        success: false,
+        domain,
+        provider: "cloudflare" as const,
+        message: "Registration failed",
+        error: "Account ID required for Cloudflare",
+      };
+    }
+
+    const resp = await fetch(
+      `https://api.cloudflare.com/client/v4/accounts/${config.accountId}/registrar/domains/${domain}/register`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${config.apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          auto_renew: false,
+        }),
+      }
+    );
+    const data = (await resp.json()) as CloudflareResponse<{ id?: string }>;
+
+    if (data.success) {
+      return {
+        success: true,
+        domain,
+        provider: "cloudflare" as const,
+        message: `Domain ${domain} registered via Cloudflare!`,
+        orderId: data.result?.id,
+      };
+    }
+
+    return {
+      success: false,
+      domain,
+      provider: "cloudflare" as const,
+      message: "Registration failed",
+      error: data.errors?.[0]?.message || "Unknown error",
+    };
+  } catch (err: unknown) {
+    return {
+      success: false,
+      domain,
+      provider: "cloudflare" as const,
+      message: "Registration failed",
+      error: err instanceof Error ? err.message : "Unknown error",
+    };
+  }
+}
+
+// ─── Unified API ──────────────────────────────────────────
+
+export async function checkAvailabilityViaRegistrar(
+  domain: string,
+  config: RegistrarConfig
+): Promise<AvailabilityCheckResult> {
+  switch (config.provider) {
+    case "godaddy":
+      return godaddyCheckAvailability(domain, config);
+    case "namecheap":
+      return namecheapCheckAvailability(domain, config);
+    case "cloudflare":
+      return cloudflareCheckAvailability(domain, config);
+    default:
+      return {
+        domain,
+        available: false,
+        provider: config.provider,
+        error: `Unknown provider: ${config.provider}`,
+      };
+  }
+}
+
+export async function registerDomain(
+  domain: string,
+  config: RegistrarConfig
+): Promise<RegistrationResult> {
+  switch (config.provider) {
+    case "godaddy":
+      return godaddyRegister(domain, config);
+    case "namecheap":
+      return namecheapRegister(domain, config);
+    case "cloudflare":
+      return cloudflareRegister(domain, config);
+    default:
+      return {
+        success: false,
+        domain,
+        provider: config.provider,
+        message: "Unknown provider",
+        error: `Unknown provider: ${config.provider}`,
+      };
+  }
+}
+
+/**
+ * Load registrar config from environment variables
+ */
+export function loadConfigFromEnv(): RegistrarConfig | null {
+  const provider = (process.env.REGISTRAR_PROVIDER || "").toLowerCase() as RegistrarProvider;
+
+  if (!provider || !["godaddy", "namecheap", "cloudflare"].includes(provider)) {
+    return null;
+  }
+
+  const apiKey = process.env.REGISTRAR_API_KEY || "";
+  if (!apiKey) return null;
+
+  return {
+    provider,
+    apiKey,
+    apiSecret: process.env.REGISTRAR_API_SECRET || "",
+    accountId: process.env.CLOUDFLARE_ACCOUNT_ID || "",
+    username: process.env.NAMECHEAP_USERNAME || "",
+    clientIp: process.env.CLIENT_IP || "127.0.0.1",
+  };
+}

package/src/core/theme.ts

@@ -0,0 +1,140 @@
+/**
+ * Theme system inspired by OpenCode's dark theme
+ * Uses a stepped grayscale palette with accent colors
+ */
+
+export const palette = {
+  // Grayscale steps (dark to light)
+  step1: "#0a0a0a",   // Deepest background
+  step2: "#141414",   // Panel background
+  step3: "#1e1e1e",   // Elevated surface
+  step4: "#282828",   // Subtle borders
+  step5: "#323232",   // Borders
+  step6: "#3c3c3c",   // Active borders
+  step7: "#464646",   // Muted elements
+  step8: "#505050",   // Disabled text
+  step9: "#6e6e6e",   // Placeholder text
+  step10: "#8c8c8c",  // Muted text
+  step11: "#b0b0b0",  // Secondary text
+  step12: "#eeeeee",  // Primary text
+
+  // Accent colors
+  green: "#00e88f",
+  greenDim: "#0a3d2a",
+  blue: "#5c9cf5",
+  blueDim: "#1a2d4a",
+  yellow: "#f5c542",
+  yellowDim: "#3d3018",
+  red: "#f55c5c",
+  redDim: "#3d1a1a",
+  orange: "#f5955c",
+  orangeDim: "#3d2818",
+  purple: "#9d7cd8",
+  purpleDim: "#2a1f3d",
+  cyan: "#56d4dd",
+  cyanDim: "#1a3335",
+} as const;
+
+export const theme = {
+  // Backgrounds
+  background: palette.step1,
+  backgroundPanel: palette.step2,
+  backgroundElevated: palette.step3,
+
+  // Text
+  text: palette.step12,
+  textSecondary: palette.step11,
+  textMuted: palette.step10,
+  textPlaceholder: palette.step9,
+  textDisabled: palette.step8,
+
+  // Borders
+  border: palette.step5,
+  borderActive: palette.step6,
+  borderSubtle: palette.step4,
+
+  // Semantic
+  primary: palette.green,
+  primaryDim: palette.greenDim,
+  secondary: palette.blue,
+  secondaryDim: palette.blueDim,
+  warning: palette.yellow,
+  warningDim: palette.yellowDim,
+  error: palette.red,
+  errorDim: palette.redDim,
+  info: palette.cyan,
+  infoDim: palette.cyanDim,
+  accent: palette.purple,
+  accentDim: palette.purpleDim,
+  pending: palette.orange,
+  pendingDim: palette.orangeDim,
+} as const;
+
+// ─── Border characters ───────────────────────────────────
+
+export const borders = {
+  rounded: {
+    topLeft: "╭",
+    topRight: "╮",
+    bottomLeft: "╰",
+    bottomRight: "╯",
+    horizontal: "─",
+    vertical: "│",
+    topT: "┬",
+    bottomT: "┴",
+    leftT: "├",
+    rightT: "┤",
+    cross: "┼",
+  },
+  heavy: {
+    topLeft: "┏",
+    topRight: "┓",
+    bottomLeft: "┗",
+    bottomRight: "┛",
+    horizontal: "━",
+    vertical: "┃",
+    topT: "┳",
+    bottomT: "┻",
+    leftT: "┣",
+    rightT: "┫",
+    cross: "╋",
+  },
+  splitLeft: {
+    topLeft: "",
+    topRight: "",
+    bottomLeft: "",
+    bottomRight: "",
+    horizontal: " ",
+    vertical: "┃",
+    topT: "",
+    bottomT: "",
+    leftT: "",
+    rightT: "",
+    cross: "",
+  },
+} as const;
+
+// ─── Status styling ──────────────────────────────────────
+
+export type DomainStatus = "pending" | "checking" | "available" | "expired" | "taken" | "error" | "registered" | "registering";
+
+export function statusStyle(status: DomainStatus) {
+  switch (status) {
+    case "pending":
+      return { icon: "○", fg: theme.textDisabled, label: "PENDING" };
+    case "checking":
+      return { icon: "◆", fg: theme.warning, label: "CHECKING" };
+    case "available":
+      return { icon: "●", fg: theme.primary, label: "AVAILABLE" };
+    case "expired":
+      return { icon: "◈", fg: theme.pending, label: "EXPIRED" };
+    case "taken":
+      return { icon: "✕", fg: theme.error, label: "TAKEN" };
+    case "registered":
+      return { icon: "◉", fg: theme.secondary, label: "REGISTERED" };
+    case "registering":
+      return { icon: "◌", fg: theme.info, label: "REGISTERING" };
+    case "error":
+      return { icon: "!", fg: theme.error, label: "ERROR" };
+  }
+}