@hasna/microservices 0.0.5 → 0.0.6

package/microservices/microservice-domains/src/cli/index.ts

@@ -30,6 +30,26 @@ import {
   checkAllDomains,
   getDomainByName,
 } from "../db/domains.js";
+import {
+  syncToLocalDb,
+  renewDomain as namecheapRenew,
+  checkAvailability as namecheapCheck,
+} from "../lib/namecheap.js";
+import {
+  syncToLocalDb as godaddySyncToLocalDb,
+  renewDomain as godaddyRenewDomain,
+} from "../lib/godaddy.js";
+import {
+  getAvailableProviders,
+  syncAll,
+  autoDetectRegistrar,
+  getProvider,
+} from "../lib/registrar.js";
+import {
+  monitorBrand,
+  getSimilarDomains,
+  getThreatAssessment,
+} from "../lib/brandsight.js";
 import { readFileSync, writeFileSync } from "node:fs";
 
 const program = new Command();
@@ -688,4 +708,404 @@ alertCmd
     }
   });
 
+// --- Namecheap Integration ---
+
+program
+  .command("sync")
+  .description("Sync domains from a provider to local DB")
+  .requiredOption("--provider <provider>", "Provider name (namecheap, godaddy)")
+  .option("--json", "Output as JSON", false)
+  .action(async (opts) => {
+    const provider = opts.provider.toLowerCase();
+
+    if (provider === "namecheap") {
+      try {
+        const result = await syncToLocalDb({
+          getDomainByName,
+          createDomain,
+          updateDomain,
+        });
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Synced ${result.synced} domain(s) from Namecheap`);
+          for (const d of result.domains) {
+            console.log(`  ${d}`);
+          }
+          if (result.errors.length > 0) {
+            console.log("Errors:");
+            for (const e of result.errors) {
+              console.log(`  - ${e}`);
+            }
+          }
+        }
+      } catch (error: unknown) {
+        console.error(`Sync failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else if (provider === "godaddy") {
+      try {
+        const result = await godaddySyncToLocalDb({
+          getDomainByName,
+          createDomain,
+          updateDomain,
+        });
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Synced ${result.synced} domain(s) from GoDaddy (created: ${result.created}, updated: ${result.updated})`);
+          if (result.errors.length > 0) {
+            console.log("Errors:");
+            for (const e of result.errors) {
+              console.log(`  - ${e}`);
+            }
+          }
+        }
+      } catch (error: unknown) {
+        console.error(`Sync failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else {
+      console.error(`Unsupported provider: ${opts.provider}. Supported: namecheap, godaddy`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("renew")
+  .description("Renew a domain via provider")
+  .argument("<name>", "Domain name (e.g. example.com)")
+  .requiredOption("--provider <provider>", "Provider name (namecheap, godaddy)")
+  .option("--years <n>", "Number of years to renew", "1")
+  .option("--json", "Output as JSON", false)
+  .action(async (name, opts) => {
+    const provider = opts.provider.toLowerCase();
+
+    if (provider === "namecheap") {
+      try {
+        const result = await namecheapRenew(name, parseInt(opts.years));
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Renewed ${result.domain} successfully`);
+          if (result.chargedAmount) console.log(`  Charged: $${result.chargedAmount}`);
+          if (result.orderId) console.log(`  Order ID: ${result.orderId}`);
+          if (result.transactionId) console.log(`  Transaction ID: ${result.transactionId}`);
+        }
+      } catch (error: unknown) {
+        console.error(`Renewal failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else if (provider === "godaddy") {
+      try {
+        const result = await godaddyRenewDomain(name);
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Renewed ${name} successfully via GoDaddy`);
+          if (result.orderId) console.log(`  Order ID: ${result.orderId}`);
+          if (result.total) console.log(`  Total: $${(result.total / 100).toFixed(2)}`);
+        }
+      } catch (error: unknown) {
+        console.error(`Renewal failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else {
+      console.error(`Unsupported provider: ${opts.provider}. Supported: namecheap, godaddy`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("check")
+  .description("Check domain availability")
+  .argument("<name>", "Domain name (e.g. example.com)")
+  .option("--json", "Output as JSON", false)
+  .action(async (name, opts) => {
+    try {
+      const result = await namecheapCheck(name);
+
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        if (result.available) {
+          console.log(`${result.domain} is AVAILABLE`);
+        } else {
+          console.log(`${result.domain} is NOT available`);
+        }
+      }
+    } catch (error: unknown) {
+      console.error(`Availability check failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  });
+
+// --- Unified Provider Commands ---
+
+program
+  .command("providers")
+  .description("Show which registrar providers are configured")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const providers = getAvailableProviders();
+
+    if (opts.json) {
+      console.log(JSON.stringify(providers, null, 2));
+    } else {
+      console.log("Registrar Providers:");
+      for (const p of providers) {
+        const status = p.configured ? "CONFIGURED" : "not configured";
+        console.log(`  ${p.name}: ${status}`);
+        if (!p.configured) {
+          console.log(`    Missing: ${p.envVars.join(", ")}`);
+        }
+      }
+    }
+  });
+
+// Override sync command to support --all flag
+program.commands = program.commands.filter((c) => c.name() !== "sync");
+
+program
+  .command("sync")
+  .description("Sync domains from a provider to local DB")
+  .option("--provider <provider>", "Provider name (namecheap, godaddy)")
+  .option("--all", "Sync from all configured providers")
+  .option("--json", "Output as JSON", false)
+  .action(async (opts) => {
+    if (opts.all) {
+      try {
+        const result = await syncAll({
+          getDomainByName,
+          createDomain,
+          updateDomain,
+        });
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Synced ${result.totalSynced} domain(s) from ${result.providers.length} provider(s)`);
+          for (const p of result.providers) {
+            console.log(`  ${p.name}: ${p.result.synced} synced`);
+          }
+          if (result.totalErrors.length > 0) {
+            console.log("Errors:");
+            for (const e of result.totalErrors) {
+              console.log(`  - ${e}`);
+            }
+          }
+        }
+      } catch (error: unknown) {
+        console.error(`Sync failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+      return;
+    }
+
+    const provider = (opts.provider || "").toLowerCase();
+    if (!provider) {
+      console.error("Specify --provider <name> or --all");
+      process.exit(1);
+    }
+
+    if (provider === "namecheap") {
+      try {
+        const result = await syncToLocalDb({
+          getDomainByName,
+          createDomain,
+          updateDomain,
+        });
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Synced ${result.synced} domain(s) from Namecheap`);
+          for (const d of result.domains) {
+            console.log(`  ${d}`);
+          }
+          if (result.errors.length > 0) {
+            console.log("Errors:");
+            for (const e of result.errors) {
+              console.log(`  - ${e}`);
+            }
+          }
+        }
+      } catch (error: unknown) {
+        console.error(`Sync failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else if (provider === "godaddy") {
+      try {
+        const result = await godaddySyncToLocalDb({
+          getDomainByName,
+          createDomain,
+          updateDomain,
+        });
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Synced ${result.synced} domain(s) from GoDaddy (created: ${result.created}, updated: ${result.updated})`);
+          if (result.errors.length > 0) {
+            console.log("Errors:");
+            for (const e of result.errors) {
+              console.log(`  - ${e}`);
+            }
+          }
+        }
+      } catch (error: unknown) {
+        console.error(`Sync failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else {
+      console.error(`Unsupported provider: ${provider}. Supported: namecheap, godaddy`);
+      process.exit(1);
+    }
+  });
+
+// Override renew command to support auto-detect
+program.commands = program.commands.filter((c) => c.name() !== "renew");
+
+program
+  .command("renew")
+  .description("Renew a domain via provider (auto-detects registrar from DB if --provider not given)")
+  .argument("<name>", "Domain name (e.g. example.com)")
+  .option("--provider <provider>", "Provider name (namecheap, godaddy)")
+  .option("--years <n>", "Number of years to renew", "1")
+  .option("--json", "Output as JSON", false)
+  .action(async (name, opts) => {
+    let provider = (opts.provider || "").toLowerCase();
+
+    if (!provider) {
+      const detected = autoDetectRegistrar(name, getDomainByName);
+      if (!detected) {
+        console.error(`Could not auto-detect registrar for '${name}'. Use --provider.`);
+        process.exit(1);
+      }
+      provider = detected;
+      console.log(`Auto-detected registrar: ${provider}`);
+    }
+
+    if (provider === "namecheap") {
+      try {
+        const result = await namecheapRenew(name, parseInt(opts.years));
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Renewed ${result.domain} successfully via Namecheap`);
+          if (result.chargedAmount) console.log(`  Charged: $${result.chargedAmount}`);
+          if (result.orderId) console.log(`  Order ID: ${result.orderId}`);
+        }
+      } catch (error: unknown) {
+        console.error(`Renewal failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else if (provider === "godaddy") {
+      try {
+        const result = await godaddyRenewDomain(name);
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Renewed ${name} successfully via GoDaddy`);
+          if (result.orderId) console.log(`  Order ID: ${result.orderId}`);
+          if (result.total) console.log(`  Total: $${(result.total / 100).toFixed(2)}`);
+        }
+      } catch (error: unknown) {
+        console.error(`Renewal failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    } else {
+      console.error(`Unsupported provider: ${provider}. Supported: namecheap, godaddy`);
+      process.exit(1);
+    }
+  });
+
+// --- Brandsight Commands ---
+
+program
+  .command("monitor")
+  .description("Monitor a brand for similar domain registrations (Brandsight)")
+  .argument("<brand>", "Brand name to monitor")
+  .option("--json", "Output as JSON", false)
+  .action(async (brand, opts) => {
+    try {
+      const result = await monitorBrand(brand);
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        if (result.stub) console.log("(stub data — Brandsight API unreachable)");
+        console.log(`Brand monitoring for "${result.brand}":`);
+        if (result.alerts.length === 0) {
+          console.log("  No alerts.");
+        } else {
+          for (const a of result.alerts) {
+            console.log(`  [${a.type}] ${a.domain} — registered ${a.registered_at}`);
+          }
+        }
+        console.log(`\n${result.alerts.length} alert(s)`);
+      }
+    } catch (error: unknown) {
+      console.error(`Monitor failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("similar")
+  .description("Find typosquat/competing domains similar to a domain (Brandsight)")
+  .argument("<domain>", "Domain to check")
+  .option("--json", "Output as JSON", false)
+  .action(async (domain, opts) => {
+    try {
+      const result = await getSimilarDomains(domain);
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        if (result.stub) console.log("(stub data — Brandsight API unreachable)");
+        console.log(`Similar domains for ${result.domain}:`);
+        for (const d of result.similar) {
+          console.log(`  ${d}`);
+        }
+        console.log(`\n${result.similar.length} similar domain(s)`);
+      }
+    } catch (error: unknown) {
+      console.error(`Similar domains check failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("threats")
+  .description("Get threat assessment for a domain (Brandsight)")
+  .argument("<domain>", "Domain to assess")
+  .option("--json", "Output as JSON", false)
+  .action(async (domain, opts) => {
+    try {
+      const result = await getThreatAssessment(domain);
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        if (result.stub) console.log("(stub data — Brandsight API unreachable)");
+        console.log(`Threat Assessment for ${result.domain}:`);
+        console.log(`  Risk Level: ${result.risk_level}`);
+        if (result.threats.length > 0) {
+          console.log("  Threats:");
+          for (const t of result.threats) {
+            console.log(`    - ${t}`);
+          }
+        } else {
+          console.log("  Threats: none detected");
+        }
+        console.log(`  Recommendation: ${result.recommendation}`);
+      }
+    } catch (error: unknown) {
+      console.error(`Threat assessment failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);

package/microservices/microservice-domains/src/lib/brandsight.ts

@@ -0,0 +1,285 @@
+/**
+ * Brandsight API integration for brand monitoring and threat detection
+ *
+ * Requires environment variable:
+ *   BRANDSIGHT_API_KEY — API key for Brandsight
+ */
+
+// ============================================================
+// Types
+// ============================================================
+
+export interface BrandsightAlert {
+  domain: string;
+  type: "typosquat" | "homoglyph" | "keyword" | "tld_variation";
+  registered_at: string;
+}
+
+export interface BrandMonitorResult {
+  brand: string;
+  alerts: BrandsightAlert[];
+  stub: boolean;
+}
+
+export interface WhoisHistoryEntry {
+  registrant: string;
+  date: string;
+  changes: string[];
+}
+
+export interface WhoisHistoryResult {
+  domain: string;
+  history: WhoisHistoryEntry[];
+  stub: boolean;
+}
+
+export interface ThreatAssessment {
+  domain: string;
+  risk_level: "low" | "medium" | "high" | "critical";
+  threats: string[];
+  recommendation: string;
+  stub: boolean;
+}
+
+export class BrandsightApiError extends Error {
+  constructor(
+    message: string,
+    public statusCode?: number,
+    public responseBody?: string
+  ) {
+    super(message);
+    this.name = "BrandsightApiError";
+  }
+}
+
+// ============================================================
+// Configuration
+// ============================================================
+
+const API_BASE = "https://api.brandsight.com/v1";
+
+export function getApiKey(): string {
+  const key = process.env["BRANDSIGHT_API_KEY"];
+  if (!key) {
+    throw new BrandsightApiError(
+      "BRANDSIGHT_API_KEY environment variable is not set"
+    );
+  }
+  return key;
+}
+
+function getHeaders(apiKey: string): Record<string, string> {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "User-Agent": "microservice-domains/0.0.1",
+  };
+}
+
+// ============================================================
+// Internal fetch helper (allows test injection)
+// ============================================================
+
+type FetchFn = typeof globalThis.fetch;
+
+let _fetchFn: FetchFn = globalThis.fetch;
+
+/**
+ * Override the fetch implementation (for testing).
+ * Pass `null` to restore the default.
+ */
+export function _setFetch(fn: FetchFn | null): void {
+  _fetchFn = fn ?? globalThis.fetch;
+}
+
+async function apiRequest<T>(path: string, apiKey: string): Promise<{ data: T; stub: false } | { data: null; stub: true }> {
+  const url = `${API_BASE}${path}`;
+  const headers = getHeaders(apiKey);
+
+  try {
+    const response = await _fetchFn(url, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(15000),
+    });
+
+    if (!response.ok) {
+      throw new BrandsightApiError(
+        `Brandsight API GET ${path} failed with status ${response.status}`,
+        response.status,
+        await response.text()
+      );
+    }
+
+    const data = (await response.json()) as T;
+    return { data, stub: false };
+  } catch (error) {
+    if (error instanceof BrandsightApiError) throw error;
+    // API unreachable — return stub indicator
+    return { data: null, stub: true };
+  }
+}
+
+// ============================================================
+// Stub Data Generators
+// ============================================================
+
+function generateStubAlerts(brandName: string): BrandsightAlert[] {
+  const now = new Date().toISOString();
+  return [
+    {
+      domain: `${brandName}-deals.com`,
+      type: "keyword",
+      registered_at: now,
+    },
+    {
+      domain: `${brandName.replace(/a/gi, "4").replace(/e/gi, "3")}.com`,
+      type: "homoglyph",
+      registered_at: now,
+    },
+    {
+      domain: `${brandName}s.com`,
+      type: "typosquat",
+      registered_at: now,
+    },
+  ];
+}
+
+function generateStubSimilarDomains(domain: string): string[] {
+  const base = domain.replace(/\.[^.]+$/, "");
+  const tld = domain.slice(base.length);
+  return [
+    `${base}-online${tld}`,
+    `${base}s${tld}`,
+    `${base.replace(/a/gi, "4")}${tld}`,
+    `${base}-app${tld}`,
+    `get${base}${tld}`,
+  ];
+}
+
+function generateStubWhoisHistory(domain: string): WhoisHistoryEntry[] {
+  return [
+    {
+      registrant: "Privacy Proxy Service",
+      date: "2023-01-15T00:00:00Z",
+      changes: ["registrant_changed", "nameserver_changed"],
+    },
+    {
+      registrant: "Original Owner LLC",
+      date: "2020-06-01T00:00:00Z",
+      changes: ["initial_registration"],
+    },
+  ];
+}
+
+function generateStubThreatAssessment(domain: string): Omit<ThreatAssessment, "stub"> {
+  return {
+    domain,
+    risk_level: "low",
+    threats: [],
+    recommendation: "No immediate threats detected. Continue routine monitoring.",
+  };
+}
+
+// ============================================================
+// API Functions
+// ============================================================
+
+/**
+ * Monitor a brand name for new domain registrations that are similar.
+ */
+export async function monitorBrand(brandName: string): Promise<BrandMonitorResult> {
+  const apiKey = getApiKey();
+  const result = await apiRequest<{ alerts: BrandsightAlert[] }>(
+    `/brands/${encodeURIComponent(brandName)}/monitor`,
+    apiKey
+  );
+
+  if (result.stub) {
+    return {
+      brand: brandName,
+      alerts: generateStubAlerts(brandName),
+      stub: true,
+    };
+  }
+
+  return {
+    brand: brandName,
+    alerts: result.data!.alerts,
+    stub: false,
+  };
+}
+
+/**
+ * Find typosquat/competing domains similar to the given domain.
+ */
+export async function getSimilarDomains(domain: string): Promise<{ domain: string; similar: string[]; stub: boolean }> {
+  const apiKey = getApiKey();
+  const result = await apiRequest<{ similar: string[] }>(
+    `/domains/${encodeURIComponent(domain)}/similar`,
+    apiKey
+  );
+
+  if (result.stub) {
+    return {
+      domain,
+      similar: generateStubSimilarDomains(domain),
+      stub: true,
+    };
+  }
+
+  return {
+    domain,
+    similar: result.data!.similar,
+    stub: false,
+  };
+}
+
+/**
+ * Get historical WHOIS records for a domain.
+ */
+export async function getWhoisHistory(domain: string): Promise<WhoisHistoryResult> {
+  const apiKey = getApiKey();
+  const result = await apiRequest<{ history: WhoisHistoryEntry[] }>(
+    `/domains/${encodeURIComponent(domain)}/whois-history`,
+    apiKey
+  );
+
+  if (result.stub) {
+    return {
+      domain,
+      history: generateStubWhoisHistory(domain),
+      stub: true,
+    };
+  }
+
+  return {
+    domain,
+    history: result.data!.history,
+    stub: false,
+  };
+}
+
+/**
+ * Get a threat assessment for a domain.
+ */
+export async function getThreatAssessment(domain: string): Promise<ThreatAssessment> {
+  const apiKey = getApiKey();
+  const result = await apiRequest<Omit<ThreatAssessment, "stub">>(
+    `/domains/${encodeURIComponent(domain)}/threats`,
+    apiKey
+  );
+
+  if (result.stub) {
+    return {
+      ...generateStubThreatAssessment(domain),
+      stub: true,
+    };
+  }
+
+  return {
+    ...result.data!,
+    stub: false,
+  };
+}