@hasna/microservices 0.0.5 → 0.0.6

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

@@ -0,0 +1,355 @@
+/**
+ * Unified registrar provider system
+ *
+ * Wraps Namecheap, GoDaddy, and Brandsight into a common RegistrarProvider interface.
+ */
+
+import type { Domain, CreateDomainInput, UpdateDomainInput } from "../db/domains.js";
+import * as namecheap from "./namecheap.js";
+import * as godaddy from "./godaddy.js";
+
+// ============================================================
+// Types
+// ============================================================
+
+export interface ProviderDnsRecord {
+  type: string;
+  name: string;
+  value: string;
+  ttl: number;
+  priority?: number;
+}
+
+export interface ProviderDomainInfo {
+  domain: string;
+  registrar: string;
+  created: string;
+  expires: string;
+  nameservers: string[];
+  status: string;
+  auto_renew: boolean;
+}
+
+export interface ProviderRenewResult {
+  domain: string;
+  success: boolean;
+  orderId?: string;
+  chargedAmount?: string;
+}
+
+export interface ProviderSyncResult {
+  synced: number;
+  created: number;
+  updated: number;
+  errors: string[];
+}
+
+export interface ProviderAvailability {
+  domain: string;
+  available: boolean;
+}
+
+export type DbFunctions = {
+  getDomainByName: (name: string) => Domain | null;
+  createDomain: (input: CreateDomainInput) => Domain;
+  updateDomain: (id: string, input: UpdateDomainInput) => Domain | null;
+};
+
+export interface RegistrarProvider {
+  name: string;
+  listDomains(): Promise<ProviderDomainInfo[]>;
+  getDomainInfo(domain: string): Promise<ProviderDomainInfo>;
+  renewDomain(domain: string): Promise<ProviderRenewResult>;
+  getDnsRecords(domain: string): Promise<ProviderDnsRecord[]>;
+  setDnsRecords(domain: string, records: ProviderDnsRecord[]): Promise<boolean>;
+  checkAvailability(domain: string): Promise<ProviderAvailability>;
+  syncToLocalDb(dbFns: DbFunctions): Promise<ProviderSyncResult>;
+}
+
+export interface ProviderInfo {
+  name: string;
+  configured: boolean;
+  envVars: string[];
+}
+
+export interface SyncAllResult {
+  providers: { name: string; result: ProviderSyncResult }[];
+  totalSynced: number;
+  totalErrors: string[];
+}
+
+// ============================================================
+// Namecheap Provider Adapter
+// ============================================================
+
+function createNamecheapProvider(): RegistrarProvider {
+  return {
+    name: "namecheap",
+
+    async listDomains(): Promise<ProviderDomainInfo[]> {
+      const config = namecheap.getConfig();
+      const domains = await namecheap.listNamecheapDomains(config);
+      return domains.map((d) => ({
+        domain: d.domain,
+        registrar: "Namecheap",
+        created: "",
+        expires: d.expiry,
+        nameservers: [],
+        status: "active",
+        auto_renew: d.autoRenew,
+      }));
+    },
+
+    async getDomainInfo(domain: string): Promise<ProviderDomainInfo> {
+      const config = namecheap.getConfig();
+      const info = await namecheap.getDomainInfo(domain, config);
+      return {
+        domain: info.domain,
+        registrar: info.registrar,
+        created: info.created,
+        expires: info.expires,
+        nameservers: info.nameservers,
+        status: "active",
+        auto_renew: true,
+      };
+    },
+
+    async renewDomain(domain: string): Promise<ProviderRenewResult> {
+      const config = namecheap.getConfig();
+      const result = await namecheap.renewDomain(domain, 1, config);
+      return {
+        domain: result.domain,
+        success: result.success,
+        orderId: result.orderId,
+        chargedAmount: result.chargedAmount,
+      };
+    },
+
+    async getDnsRecords(domain: string): Promise<ProviderDnsRecord[]> {
+      const config = namecheap.getConfig();
+      const { sld, tld } = namecheap.splitDomain(domain);
+      const records = await namecheap.getDnsRecords(domain, sld, tld, config);
+      return records.map((r) => ({
+        type: r.type,
+        name: r.name,
+        value: r.address,
+        ttl: r.ttl,
+        priority: r.mxPref,
+      }));
+    },
+
+    async setDnsRecords(domain: string, records: ProviderDnsRecord[]): Promise<boolean> {
+      const config = namecheap.getConfig();
+      const { sld, tld } = namecheap.splitDomain(domain);
+      const ncRecords = records.map((r) => ({
+        type: r.type,
+        name: r.name,
+        address: r.value,
+        ttl: r.ttl,
+        mxPref: r.priority,
+      }));
+      return namecheap.setDnsRecords(domain, sld, tld, ncRecords, config);
+    },
+
+    async checkAvailability(domain: string): Promise<ProviderAvailability> {
+      const config = namecheap.getConfig();
+      const result = await namecheap.checkAvailability(domain, config);
+      return { domain: result.domain, available: result.available };
+    },
+
+    async syncToLocalDb(dbFns: DbFunctions): Promise<ProviderSyncResult> {
+      const result = await namecheap.syncToLocalDb(dbFns);
+      return {
+        synced: result.synced,
+        created: 0,
+        updated: 0,
+        errors: result.errors,
+      };
+    },
+  };
+}
+
+// ============================================================
+// GoDaddy Provider Adapter
+// ============================================================
+
+function createGoDaddyProvider(): RegistrarProvider {
+  return {
+    name: "godaddy",
+
+    async listDomains(): Promise<ProviderDomainInfo[]> {
+      const domains = await godaddy.listGoDaddyDomains();
+      return domains.map((d) => ({
+        domain: d.domain,
+        registrar: "GoDaddy",
+        created: "",
+        expires: d.expires,
+        nameservers: d.nameServers || [],
+        status: d.status.toLowerCase(),
+        auto_renew: d.renewAuto,
+      }));
+    },
+
+    async getDomainInfo(domain: string): Promise<ProviderDomainInfo> {
+      const detail = await godaddy.getDomainInfo(domain);
+      return {
+        domain: detail.domain,
+        registrar: "GoDaddy",
+        created: detail.createdAt || "",
+        expires: detail.expires,
+        nameservers: detail.nameServers || [],
+        status: detail.status.toLowerCase(),
+        auto_renew: detail.renewAuto,
+      };
+    },
+
+    async renewDomain(domain: string): Promise<ProviderRenewResult> {
+      const result = await godaddy.renewDomain(domain);
+      return {
+        domain,
+        success: true,
+        orderId: String(result.orderId),
+        chargedAmount: String(result.total),
+      };
+    },
+
+    async getDnsRecords(domain: string): Promise<ProviderDnsRecord[]> {
+      const records = await godaddy.getDnsRecords(domain);
+      return records.map((r) => ({
+        type: r.type,
+        name: r.name,
+        value: r.data,
+        ttl: r.ttl,
+        priority: r.priority,
+      }));
+    },
+
+    async setDnsRecords(domain: string, records: ProviderDnsRecord[]): Promise<boolean> {
+      const gdRecords = records.map((r) => ({
+        type: r.type,
+        name: r.name,
+        data: r.value,
+        ttl: r.ttl,
+        priority: r.priority,
+      }));
+      await godaddy.setDnsRecords(domain, gdRecords);
+      return true;
+    },
+
+    async checkAvailability(domain: string): Promise<ProviderAvailability> {
+      const result = await godaddy.checkAvailability(domain);
+      return { domain: result.domain, available: result.available };
+    },
+
+    async syncToLocalDb(dbFns: DbFunctions): Promise<ProviderSyncResult> {
+      const result = await godaddy.syncToLocalDb(dbFns);
+      return {
+        synced: result.synced,
+        created: result.created,
+        updated: result.updated,
+        errors: result.errors,
+      };
+    },
+  };
+}
+
+// ============================================================
+// Provider Factory
+// ============================================================
+
+/**
+ * Get a unified RegistrarProvider by name.
+ */
+export function getProvider(name: "namecheap" | "godaddy"): RegistrarProvider {
+  switch (name) {
+    case "namecheap":
+      return createNamecheapProvider();
+    case "godaddy":
+      return createGoDaddyProvider();
+    default:
+      throw new Error(`Unknown registrar provider: ${name}`);
+  }
+}
+
+/**
+ * Check which providers have their API keys configured.
+ */
+export function getAvailableProviders(): ProviderInfo[] {
+  const providers: ProviderInfo[] = [
+    {
+      name: "namecheap",
+      configured: !!(
+        process.env["NAMECHEAP_API_KEY"] &&
+        process.env["NAMECHEAP_USERNAME"] &&
+        process.env["NAMECHEAP_CLIENT_IP"]
+      ),
+      envVars: ["NAMECHEAP_API_KEY", "NAMECHEAP_USERNAME", "NAMECHEAP_CLIENT_IP"],
+    },
+    {
+      name: "godaddy",
+      configured: !!(
+        process.env["GODADDY_API_KEY"] &&
+        process.env["GODADDY_API_SECRET"]
+      ),
+      envVars: ["GODADDY_API_KEY", "GODADDY_API_SECRET"],
+    },
+    {
+      name: "brandsight",
+      configured: !!process.env["BRANDSIGHT_API_KEY"],
+      envVars: ["BRANDSIGHT_API_KEY"],
+    },
+  ];
+
+  return providers;
+}
+
+/**
+ * Sync domains from ALL configured registrar providers sequentially.
+ */
+export async function syncAll(dbFns: DbFunctions): Promise<SyncAllResult> {
+  const available = getAvailableProviders().filter(
+    (p) => p.configured && (p.name === "namecheap" || p.name === "godaddy")
+  );
+
+  const result: SyncAllResult = {
+    providers: [],
+    totalSynced: 0,
+    totalErrors: [],
+  };
+
+  for (const info of available) {
+    try {
+      const provider = getProvider(info.name as "namecheap" | "godaddy");
+      const syncResult = await provider.syncToLocalDb(dbFns);
+      result.providers.push({ name: info.name, result: syncResult });
+      result.totalSynced += syncResult.synced;
+      result.totalErrors.push(...syncResult.errors.map((e) => `[${info.name}] ${e}`));
+    } catch (error) {
+      const msg = `[${info.name}] Sync failed: ${error instanceof Error ? error.message : String(error)}`;
+      result.totalErrors.push(msg);
+      result.providers.push({
+        name: info.name,
+        result: { synced: 0, created: 0, updated: 0, errors: [msg] },
+      });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Auto-detect which registrar provider a domain uses based on its DB record.
+ * Returns the provider name or null if not determinable.
+ */
+export function autoDetectRegistrar(
+  domain: string,
+  getDomainByName: (name: string) => Domain | null
+): "namecheap" | "godaddy" | null {
+  const dbDomain = getDomainByName(domain);
+  if (!dbDomain || !dbDomain.registrar) return null;
+
+  const registrar = dbDomain.registrar.toLowerCase();
+  if (registrar.includes("namecheap")) return "namecheap";
+  if (registrar.includes("godaddy")) return "godaddy";
+  return null;
+}

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

@@ -31,7 +31,26 @@ import {
   validateDns,
   exportPortfolio,
   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,
+} from "../lib/registrar.js";
+import {
+  monitorBrand,
+  getSimilarDomains,
+  getThreatAssessment,
+} from "../lib/brandsight.js";
 
 const server = new McpServer({
   name: "microservice-domains",
@@ -523,6 +542,232 @@ server.registerTool(
   }
 );
 
+// --- Namecheap Integration ---
+
+server.registerTool(
+  "sync_namecheap",
+  {
+    title: "Sync Namecheap Domains",
+    description: "Sync all domains from Namecheap account to local database. Requires NAMECHEAP_API_KEY, NAMECHEAP_USERNAME, and NAMECHEAP_CLIENT_IP env vars.",
+    inputSchema: {},
+  },
+  async () => {
+    try {
+      const result = await syncToLocalDb({
+        getDomainByName,
+        createDomain,
+        updateDomain,
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error: unknown) {
+      return {
+        content: [{ type: "text", text: `Sync failed: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "renew_via_namecheap",
+  {
+    title: "Renew Domain via Namecheap",
+    description: "Renew a domain through the Namecheap API.",
+    inputSchema: {
+      domain: z.string().describe("Domain name to renew (e.g. example.com)"),
+      years: z.number().default(1).describe("Number of years to renew"),
+    },
+  },
+  async ({ domain, years }) => {
+    try {
+      const result = await namecheapRenew(domain, years);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error: unknown) {
+      return {
+        content: [{ type: "text", text: `Renewal failed: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "check_availability_namecheap",
+  {
+    title: "Check Domain Availability",
+    description: "Check if a domain name is available for registration via Namecheap.",
+    inputSchema: {
+      domain: z.string().describe("Domain name to check (e.g. example.com)"),
+    },
+  },
+  async ({ domain }) => {
+    try {
+      const result = await namecheapCheck(domain);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error: unknown) {
+      return {
+        content: [{ type: "text", text: `Check failed: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- GoDaddy Integration ---
+
+server.registerTool(
+  "sync_godaddy",
+  {
+    title: "Sync GoDaddy Domains",
+    description: "Sync all domains from GoDaddy account to local database. Requires GODADDY_API_KEY and GODADDY_API_SECRET env vars.",
+    inputSchema: {},
+  },
+  async () => {
+    try {
+      const result = await godaddySyncToLocalDb({
+        getDomainByName,
+        createDomain,
+        updateDomain,
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error: unknown) {
+      return {
+        content: [{ type: "text", text: `Sync failed: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "renew_via_godaddy",
+  {
+    title: "Renew Domain via GoDaddy",
+    description: "Renew a domain through the GoDaddy API for 1 year.",
+    inputSchema: {
+      domain: z.string().describe("Domain name to renew (e.g. example.com)"),
+    },
+  },
+  async ({ domain }) => {
+    try {
+      const result = await godaddyRenewDomain(domain);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error: unknown) {
+      return {
+        content: [{ type: "text", text: `Renewal failed: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Unified Provider Tools ---
+
+server.registerTool(
+  "sync_all_providers",
+  {
+    title: "Sync All Providers",
+    description: "Sync domains from all configured registrar providers (Namecheap, GoDaddy) to local database.",
+    inputSchema: {},
+  },
+  async () => {
+    try {
+      const result = await syncAll({
+        getDomainByName,
+        createDomain,
+        updateDomain,
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error: unknown) {
+      return {
+        content: [{ type: "text", text: `Sync failed: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "list_providers",
+  {
+    title: "List Providers",
+    description: "Show which registrar providers are configured (have API keys set).",
+    inputSchema: {},
+  },
+  async () => {
+    const providers = getAvailableProviders();
+    return { content: [{ type: "text", text: JSON.stringify(providers, null, 2) }] };
+  }
+);
+
+// --- Brandsight Tools ---
+
+server.registerTool(
+  "monitor_brand",
+  {
+    title: "Monitor Brand",
+    description: "Monitor a brand name for new domain registrations that are similar (typosquats, homoglyphs, keyword matches). Uses Brandsight API.",
+    inputSchema: {
+      brand: z.string().describe("Brand name to monitor"),
+    },
+  },
+  async ({ brand }) => {
+    try {
+      const result = await monitorBrand(brand);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error: unknown) {
+      return {
+        content: [{ type: "text", text: `Monitor failed: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "similar_domains",
+  {
+    title: "Similar Domains",
+    description: "Find typosquat/competing domains similar to the given domain. Uses Brandsight API.",
+    inputSchema: {
+      domain: z.string().describe("Domain to find similar domains for"),
+    },
+  },
+  async ({ domain }) => {
+    try {
+      const result = await getSimilarDomains(domain);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error: unknown) {
+      return {
+        content: [{ type: "text", text: `Similar domains check failed: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+server.registerTool(
+  "domain_threats",
+  {
+    title: "Domain Threats",
+    description: "Get a threat assessment for a domain including risk level, threats, and recommendation. Uses Brandsight API.",
+    inputSchema: {
+      domain: z.string().describe("Domain to assess threats for"),
+    },
+  },
+  async ({ domain }) => {
+    try {
+      const result = await getThreatAssessment(domain);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (error: unknown) {
+      return {
+        content: [{ type: "text", text: `Threat assessment failed: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // --- Start ---
 async function main() {
   const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/microservices",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Mini business apps for AI agents - invoices, contacts, bookkeeping and more, each with its own SQLite database",
   "type": "module",
   "bin": {