@suzko/mcp-server 0.1.0

package/dist/src/tools/domains.js

@@ -0,0 +1,499 @@
+import { z } from "zod";
+// In-memory confirmation store (5-minute TTL)
+const pendingConfirmations = new Map();
+function createConfirmation(action, params) {
+    const id = crypto.randomUUID();
+    pendingConfirmations.set(id, {
+        action,
+        params,
+        expiresAt: Date.now() + 5 * 60 * 1000,
+    });
+    return id;
+}
+function consumeConfirmation(id, expectedAction) {
+    const entry = pendingConfirmations.get(id);
+    if (!entry)
+        return null;
+    pendingConfirmations.delete(id);
+    if (Date.now() > entry.expiresAt)
+        return null;
+    if (entry.action !== expectedAction)
+        return null;
+    return entry.params;
+}
+// Periodically clean expired confirmations
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, entry] of pendingConfirmations) {
+        if (now > entry.expiresAt)
+            pendingConfirmations.delete(id);
+    }
+}, 60_000);
+export function registerDomainTools(server, client) {
+    // 1. Search domains (batch availability check)
+    server.tool("search_domains", "Check availability and pricing for one or more domain names. Accepts up to 20 domains at once.", {
+        domains: z
+            .array(z.string())
+            .min(1)
+            .max(20)
+            .describe("Array of domain names to check (e.g. ['example.com', 'example.net'])"),
+    }, async ({ domains }) => {
+        const res = await client.post("/api/domains/check-batch", { domains });
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const results = res.data ?? [];
+        if (results.length === 0) {
+            return {
+                content: [{ type: "text", text: "No results returned for the provided domains." }],
+            };
+        }
+        const lines = results.map((r) => {
+            const status = r.available ? "✅ Available" : "❌ Taken";
+            const premium = r.premium ? " ⭐ Premium" : "";
+            const price = r.price?.register
+                ? ` — $${r.price.register}${r.price.currency ? ` ${r.price.currency}` : ""}/yr`
+                : "";
+            return `• **${r.domain}** — ${status}${premium}${price}`;
+        });
+        const available = results.filter((r) => r.available);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**Domain Search Results (${available.length}/${results.length} available):**\n\n${lines.join("\n")}`,
+                },
+            ],
+        };
+    });
+    // 2. Get TLD pricing
+    server.tool("get_tld_pricing", "Get pricing information for all available top-level domains (TLDs). Shows registration, renewal, and transfer prices.", {}, async () => {
+        const res = await client.get("/api/domains/tlds");
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const tlds = res.data ?? [];
+        if (tlds.length === 0) {
+            return {
+                content: [{ type: "text", text: "No TLD pricing data available." }],
+            };
+        }
+        const header = `| TLD | Register | Renew | Transfer |`;
+        const divider = `|-----|----------|-------|----------|`;
+        const rows = tlds.map((t) => `| .${t.tld} | ${t.register != null ? `$${t.register}` : "—"} | ${t.renew != null ? `$${t.renew}` : "—"} | ${t.transfer != null ? `$${t.transfer}` : "—"} |`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**TLD Pricing (${tlds.length} TLDs):**\n\n${header}\n${divider}\n${rows.join("\n")}`,
+                },
+            ],
+        };
+    });
+    // 3. AI domain name suggestions
+    server.tool("suggest_domain_names", "Get AI-powered domain name suggestions based on keywords. Optionally specify a preferred TLD.", {
+        keywords: z.string().describe("Keywords or description for the desired domain name"),
+        tld: z
+            .string()
+            .optional()
+            .describe("Preferred TLD (e.g. 'com', 'io', 'dev'). If omitted, suggestions span multiple TLDs."),
+    }, async ({ keywords, tld }) => {
+        const body = { keywords };
+        if (tld)
+            body.tld = tld;
+        const res = await client.post("/api/domains/suggest", body);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const suggestions = res.data ?? [];
+        if (suggestions.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No suggestions generated. Try different keywords.",
+                    },
+                ],
+            };
+        }
+        const lines = suggestions.map((s) => {
+            const availability = s.available === true
+                ? " ✅"
+                : s.available === false
+                    ? " ❌"
+                    : "";
+            const reason = s.reason ? ` — ${s.reason}` : "";
+            return `• **${s.domain}**${availability}${reason}`;
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**AI Domain Suggestions for "${keywords}":**\n\n${lines.join("\n")}`,
+                },
+            ],
+        };
+    });
+    // 4. Register domain (with confirmation)
+    server.tool("register_domain", "Register a new domain name. Returns a cost preview and confirmation token — use confirm_domain_registration to finalize. This will incur costs.", {
+        domain: z.string().describe("Full domain name to register (e.g. 'example.com')"),
+        period: z
+            .number()
+            .int()
+            .min(1)
+            .max(10)
+            .describe("Registration period in years (1-10)"),
+        nameservers: z
+            .array(z.string())
+            .optional()
+            .describe("Custom nameservers to use (e.g. ['ns1.example.com', 'ns2.example.com'])"),
+    }, async ({ domain, period, nameservers }) => {
+        // First check availability to show price
+        const checkRes = await client.post("/api/domains/check-batch", { domains: [domain] });
+        if (!checkRes.success) {
+            return {
+                content: [{ type: "text", text: `Error checking domain: ${checkRes.error}` }],
+                isError: true,
+            };
+        }
+        const domainInfo = checkRes.data?.[0];
+        if (!domainInfo) {
+            return {
+                content: [{ type: "text", text: `Could not check availability for ${domain}.` }],
+                isError: true,
+            };
+        }
+        if (!domainInfo.available) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**${domain}** is not available for registration. Try searching for alternatives with \`search_domains\` or \`suggest_domain_names\`.`,
+                    },
+                ],
+            };
+        }
+        const params = { domain, period };
+        if (nameservers)
+            params.nameservers = nameservers;
+        const confirmationId = createConfirmation("register", params);
+        const pricePerYear = domainInfo.price?.register;
+        const currency = domainInfo.price?.currency ?? "USD";
+        const totalEstimate = pricePerYear ? pricePerYear * period : null;
+        const preview = [
+            `**Register Domain — Confirmation Required**`,
+            ``,
+            `| Setting | Value |`,
+            `|---------|-------|`,
+            `| Domain | ${domain} |`,
+            `| Period | ${period} year${period > 1 ? "s" : ""} |`,
+            pricePerYear != null ? `| Price/Year | $${pricePerYear} ${currency} |` : null,
+            totalEstimate != null ? `| Estimated Total | $${totalEstimate} ${currency} |` : null,
+            domainInfo.premium ? `| Premium | ⭐ Yes |` : null,
+            nameservers ? `| Nameservers | ${nameservers.join(", ")} |` : null,
+            ``,
+            `⚠️ This will register the domain and charge your account.`,
+            ``,
+            `To confirm, call \`confirm_domain_registration\` with confirmation ID:`,
+            `\`${confirmationId}\``,
+            ``,
+            `This confirmation expires in 5 minutes.`,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        return {
+            content: [{ type: "text", text: preview }],
+        };
+    });
+    // 5. Transfer domain (with confirmation)
+    server.tool("transfer_domain", "Transfer an existing domain to your account. Returns a preview and confirmation token — use confirm_domain_transfer to finalize. This will incur costs.", {
+        domain: z.string().describe("Full domain name to transfer (e.g. 'example.com')"),
+        eppCode: z.string().describe("EPP/authorization code from the current registrar"),
+    }, async ({ domain, eppCode }) => {
+        // Check transfer pricing
+        const checkRes = await client.post("/api/domains/check-batch", { domains: [domain] });
+        const domainInfo = checkRes.success ? checkRes.data?.[0] : null;
+        const transferPrice = domainInfo?.price?.transfer;
+        const currency = domainInfo?.price?.currency ?? "USD";
+        const params = { domain, eppCode };
+        const confirmationId = createConfirmation("transfer", params);
+        const preview = [
+            `**Transfer Domain — Confirmation Required**`,
+            ``,
+            `| Setting | Value |`,
+            `|---------|-------|`,
+            `| Domain | ${domain} |`,
+            `| EPP Code | ${"•".repeat(Math.min(eppCode.length, 12))} (hidden) |`,
+            transferPrice != null ? `| Transfer Price | $${transferPrice} ${currency} |` : null,
+            ``,
+            `⚠️ This will initiate a domain transfer and charge your account.`,
+            `The transfer process typically takes 5-7 days to complete.`,
+            ``,
+            `To confirm, call \`confirm_domain_transfer\` with confirmation ID:`,
+            `\`${confirmationId}\``,
+            ``,
+            `This confirmation expires in 5 minutes.`,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        return {
+            content: [{ type: "text", text: preview }],
+        };
+    });
+    // 6. List user's domains
+    server.tool("list_domains", "List all domains owned by the authenticated user, including status and expiry dates.", {}, async () => {
+        const res = await client.get("/api/client/domains");
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const domains = res.data ?? [];
+        if (domains.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "You don't have any domains yet. Use `search_domains` to find one and `register_domain` to register it.",
+                    },
+                ],
+            };
+        }
+        const lines = domains.map((d) => {
+            const expiry = d.expiryDate
+                ? ` | Expires: ${new Date(d.expiryDate).toLocaleDateString()}`
+                : "";
+            const autoRenew = d.autoRenew ? " | Auto-renew: ✅" : "";
+            return `• **${d.domain}** (ID: ${d.id}) — Status: ${d.status}${expiry}${autoRenew}`;
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**Your Domains (${domains.length}):**\n\n${lines.join("\n")}`,
+                },
+            ],
+        };
+    });
+    // 7. Get domain details
+    server.tool("get_domain_details", "Get detailed information about a specific domain including nameservers, registration/expiry dates, and lock status.", {
+        domainId: z.number().int().describe("The domain ID (from list_domains)"),
+    }, async ({ domainId }) => {
+        const res = await client.get(`/api/client/domains/${domainId}`);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const d = res.data;
+        if (!d) {
+            return {
+                content: [{ type: "text", text: `Domain with ID ${domainId} not found.` }],
+                isError: true,
+            };
+        }
+        const info = [
+            `**Domain Details: ${d.domain}**`,
+            ``,
+            `| Field | Value |`,
+            `|-------|-------|`,
+            `| ID | ${d.id} |`,
+            `| Domain | ${d.domain} |`,
+            `| Status | ${d.status} |`,
+            d.registrationDate
+                ? `| Registered | ${new Date(d.registrationDate).toLocaleDateString()} |`
+                : null,
+            d.expiryDate
+                ? `| Expires | ${new Date(d.expiryDate).toLocaleDateString()} |`
+                : null,
+            `| Auto-Renew | ${d.autoRenew ? "Yes" : "No"} |`,
+            `| Locked | ${d.locked ? "🔒 Yes" : "🔓 No"} |`,
+            d.dnsManagement != null
+                ? `| DNS Management | ${d.dnsManagement ? "Enabled" : "Disabled"} |`
+                : null,
+            d.emailForwarding != null
+                ? `| Email Forwarding | ${d.emailForwarding ? "Enabled" : "Disabled"} |`
+                : null,
+            d.idProtection != null
+                ? `| ID Protection | ${d.idProtection ? "Enabled" : "Disabled"} |`
+                : null,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        const ns = d.nameservers && d.nameservers.length > 0
+            ? `\n\n**Nameservers:**\n${d.nameservers.map((n) => `• ${n}`).join("\n")}`
+            : "";
+        return {
+            content: [{ type: "text", text: `${info}${ns}` }],
+        };
+    });
+    // 8. Update domain nameservers
+    server.tool("update_domain_nameservers", "Update the nameservers for a domain. Provide 2-5 nameserver hostnames.", {
+        domainId: z.number().int().describe("The domain ID (from list_domains)"),
+        nameservers: z
+            .array(z.string())
+            .min(2)
+            .max(5)
+            .describe("New nameservers (e.g. ['ns1.example.com', 'ns2.example.com'])"),
+    }, async ({ domainId, nameservers }) => {
+        const res = await client.put(`/api/client/domains/${domainId}/nameservers`, { nameservers });
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✅ Nameservers updated successfully for domain ID ${domainId}:\n${nameservers.map((ns) => `• ${ns}`).join("\n")}\n\nDNS propagation may take up to 48 hours.`,
+                },
+            ],
+        };
+    });
+    // 9. Get domain lock status
+    server.tool("get_domain_lock_status", "Check whether a domain's registrar lock (transfer lock) is enabled or disabled.", {
+        domainId: z.number().int().describe("The domain ID (from list_domains)"),
+    }, async ({ domainId }) => {
+        const res = await client.get(`/api/client/domains/${domainId}/lock`);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const locked = res.data?.locked ?? false;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: locked
+                        ? `🔒 Domain ID ${domainId} is **locked**. The domain cannot be transferred to another registrar while locked.`
+                        : `🔓 Domain ID ${domainId} is **unlocked**. The domain can be transferred to another registrar. Use \`toggle_domain_lock\` to lock it.`,
+                },
+            ],
+        };
+    });
+    // 10. Toggle domain lock
+    server.tool("toggle_domain_lock", "Enable or disable the registrar lock (transfer protection) on a domain.", {
+        domainId: z.number().int().describe("The domain ID (from list_domains)"),
+        locked: z.boolean().describe("true to lock the domain, false to unlock"),
+    }, async ({ domainId, locked }) => {
+        const res = await client.put(`/api/client/domains/${domainId}/lock`, { locked });
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: locked
+                        ? `🔒 Domain ID ${domainId} has been **locked**. It is now protected from unauthorized transfers.`
+                        : `🔓 Domain ID ${domainId} has been **unlocked**. It can now be transferred to another registrar.`,
+                },
+            ],
+        };
+    });
+    // 11. Confirm domain registration
+    server.tool("confirm_domain_registration", "Confirm and execute a pending domain registration. Use the confirmation ID returned by register_domain.", {
+        confirmationId: z.string().describe("The confirmation ID from register_domain"),
+    }, async ({ confirmationId }) => {
+        const params = consumeConfirmation(confirmationId, "register");
+        if (!params) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Confirmation not found or expired. Please run `register_domain` again.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const res = await client.post("/api/domains/register", params);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Registration failed: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const d = res.data;
+        const details = [
+            `✅ **Domain registered successfully!**`,
+            ``,
+            `| Field | Value |`,
+            `|-------|-------|`,
+            d?.domain ? `| Domain | ${d.domain} |` : null,
+            d?.domainId ? `| Domain ID | ${d.domainId} |` : null,
+            d?.orderId ? `| Order ID | ${d.orderId} |` : null,
+            d?.invoiceId ? `| Invoice ID | ${d.invoiceId} |` : null,
+            d?.status ? `| Status | ${d.status} |` : null,
+            ``,
+            `Use \`get_domain_details\` to see full domain information.`,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        return {
+            content: [{ type: "text", text: details }],
+        };
+    });
+    // 12. Confirm domain transfer
+    server.tool("confirm_domain_transfer", "Confirm and execute a pending domain transfer. Use the confirmation ID returned by transfer_domain.", {
+        confirmationId: z.string().describe("The confirmation ID from transfer_domain"),
+    }, async ({ confirmationId }) => {
+        const params = consumeConfirmation(confirmationId, "transfer");
+        if (!params) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Confirmation not found or expired. Please run `transfer_domain` again.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const res = await client.post("/api/domains/transfer", params);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Transfer failed: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const d = res.data;
+        const details = [
+            `✅ **Domain transfer initiated!**`,
+            ``,
+            `| Field | Value |`,
+            `|-------|-------|`,
+            d?.domain ? `| Domain | ${d.domain} |` : null,
+            d?.domainId ? `| Domain ID | ${d.domainId} |` : null,
+            d?.orderId ? `| Order ID | ${d.orderId} |` : null,
+            d?.invoiceId ? `| Invoice ID | ${d.invoiceId} |` : null,
+            d?.status ? `| Status | ${d.status} |` : null,
+            ``,
+            `Domain transfers typically take 5-7 days to complete.`,
+            `You will receive email updates as the transfer progresses.`,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        return {
+            content: [{ type: "text", text: details }],
+        };
+    });
+}

package/dist/src/tools/server-admin.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { SuzkoClient } from "../client.js";
+export declare function registerServerAdminTools(server: McpServer, _client: SuzkoClient): void;