@suzko/mcp-server 0.1.0

package/dist/src/tools/dns.js

@@ -0,0 +1,313 @@
+import { z } from "zod";
+import { assertSafeDnsName, assertSafeDnsContent } from "../security.js";
+const DNS_RECORD_TYPES = [
+    "A",
+    "AAAA",
+    "CNAME",
+    "TXT",
+    "MX",
+    "NS",
+    "SRV",
+    "CAA",
+];
+const pendingDeletes = new Map();
+const CONFIRM_TTL_MS = 30 * 60 * 1000;
+function stashDelete(domainId, recordId) {
+    const id = crypto.randomUUID();
+    pendingDeletes.set(id, {
+        domainId,
+        recordId,
+        expiresAt: Date.now() + CONFIRM_TTL_MS,
+    });
+    return id;
+}
+function popDelete(id) {
+    const entry = pendingDeletes.get(id);
+    if (!entry)
+        return null;
+    pendingDeletes.delete(id);
+    if (Date.now() > entry.expiresAt)
+        return null;
+    return { domainId: entry.domainId, recordId: entry.recordId };
+}
+export function registerDnsTools(server, client) {
+    // 1. Enable DNS management
+    server.tool("enable_dns_management", "Enable DNS management for a domain. This must be enabled before you can create, update, or delete DNS records.", {
+        domainId: z.number().int().describe("The domain ID (from list_domains)"),
+    }, async ({ domainId }) => {
+        const res = await client.post(`/api/client/domains/${domainId}/dns/enable`);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✅ DNS management enabled for domain ID ${domainId}. You can now manage DNS records with \`list_dns_records\`, \`create_dns_record\`, etc.`,
+                },
+            ],
+        };
+    });
+    // 2. List DNS records
+    server.tool("list_dns_records", "List all DNS records for a domain. DNS management must be enabled first.", {
+        domainId: z.number().int().describe("The domain ID (from list_domains)"),
+    }, async ({ domainId }) => {
+        const res = await client.get(`/api/client/domains/${domainId}/dns`);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const records = res.data ?? [];
+        if (records.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No DNS records found for domain ID ${domainId}. Use \`create_dns_record\` to add one.`,
+                    },
+                ],
+            };
+        }
+        const header = `| ID | Type | Name | Content | TTL | Priority |`;
+        const divider = `|----|------|------|---------|-----|----------|`;
+        const rows = records.map((r) => `| ${r.id} | ${r.type} | ${r.name} | ${r.content} | ${r.ttl ?? "—"} | ${r.priority ?? "—"} |`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**DNS Records for domain ID ${domainId} (${records.length}):**\n\n${header}\n${divider}\n${rows.join("\n")}`,
+                },
+            ],
+        };
+    });
+    // 3. Create DNS record
+    server.tool("create_dns_record", "Create a new DNS record for a domain. Supports A, AAAA, CNAME, TXT, MX, NS, SRV, and CAA record types.", {
+        domainId: z.number().int().describe("The domain ID (from list_domains)"),
+        type: z
+            .enum(DNS_RECORD_TYPES)
+            .describe("DNS record type (A, AAAA, CNAME, TXT, MX, NS, SRV, CAA)"),
+        name: z
+            .string()
+            .describe("Record name/hostname (e.g. '@' for root, 'www', 'mail', 'sub.domain')"),
+        content: z
+            .string()
+            .describe("Record value (e.g. IP address for A/AAAA, hostname for CNAME/MX, text for TXT)"),
+        ttl: z
+            .number()
+            .int()
+            .min(60)
+            .optional()
+            .describe("Time to live in seconds (minimum 60, default varies by provider)"),
+        priority: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Record priority (required for MX and SRV records, lower = higher priority)"),
+    }, async ({ domainId, type, name, content, ttl, priority }) => {
+        try {
+            assertSafeDnsName(name);
+            assertSafeDnsContent(content);
+        }
+        catch (e) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: e instanceof Error ? e.message : String(e),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const body = { type, name, content };
+        if (ttl != null)
+            body.ttl = ttl;
+        if (priority != null)
+            body.priority = priority;
+        const res = await client.post(`/api/client/domains/${domainId}/dns`, body);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const r = res.data;
+        const details = [
+            `✅ DNS record created successfully!`,
+            ``,
+            `| Field | Value |`,
+            `|-------|-------|`,
+            r?.id != null ? `| ID | ${r.id} |` : null,
+            `| Type | ${type} |`,
+            `| Name | ${name} |`,
+            `| Content | ${content} |`,
+            ttl != null ? `| TTL | ${ttl}s |` : null,
+            priority != null ? `| Priority | ${priority} |` : null,
+            ``,
+            `DNS changes may take a few minutes to propagate.`,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        return {
+            content: [{ type: "text", text: details }],
+        };
+    });
+    // 4. Update DNS record
+    server.tool("update_dns_record", "Update an existing DNS record. Provide the record ID from list_dns_records and the fields to change.", {
+        domainId: z.number().int().describe("The domain ID (from list_domains)"),
+        recordId: z.string().describe("The DNS record ID (from list_dns_records)"),
+        type: z
+            .enum(DNS_RECORD_TYPES)
+            .optional()
+            .describe("New record type"),
+        name: z.string().optional().describe("New record name/hostname"),
+        content: z.string().optional().describe("New record value"),
+        ttl: z
+            .number()
+            .int()
+            .min(60)
+            .optional()
+            .describe("New TTL in seconds"),
+        priority: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("New priority value"),
+    }, async ({ domainId, recordId, type, name, content, ttl, priority }) => {
+        try {
+            if (name != null)
+                assertSafeDnsName(name);
+            if (content != null)
+                assertSafeDnsContent(content);
+        }
+        catch (e) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: e instanceof Error ? e.message : String(e),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const body = {};
+        if (type != null)
+            body.type = type;
+        if (name != null)
+            body.name = name;
+        if (content != null)
+            body.content = content;
+        if (ttl != null)
+            body.ttl = ttl;
+        if (priority != null)
+            body.priority = priority;
+        if (Object.keys(body).length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No fields provided to update. Specify at least one of: type, name, content, ttl, priority.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const res = await client.put(`/api/client/domains/${domainId}/dns/${recordId}`, body);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        const r = res.data;
+        const details = [
+            `✅ DNS record ${recordId} updated successfully!`,
+            ``,
+            `| Field | Value |`,
+            `|-------|-------|`,
+            r?.type ? `| Type | ${r.type} |` : null,
+            r?.name ? `| Name | ${r.name} |` : null,
+            r?.content ? `| Content | ${r.content} |` : null,
+            r?.ttl != null ? `| TTL | ${r.ttl}s |` : null,
+            r?.priority != null ? `| Priority | ${r.priority} |` : null,
+            ``,
+            `DNS changes may take a few minutes to propagate.`,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        return {
+            content: [{ type: "text", text: details }],
+        };
+    });
+    // 5. Delete DNS record (two-step — returns a confirmation token first)
+    server.tool("delete_dns_record", "Begin deletion of a DNS record. Returns a confirmation ID; pass it to confirm_delete_dns_record to actually delete. This two-step flow guards against accidental destruction by AI agents.", {
+        domainId: z.number().int().describe("The domain ID (from list_domains)"),
+        recordId: z.string().min(1).max(128).describe("The DNS record ID to delete (from list_dns_records)"),
+    }, async ({ domainId, recordId }) => {
+        // Best-effort preview lookup.
+        let preview = "";
+        try {
+            const lookup = await client.get(`/api/client/domains/${domainId}/dns`);
+            const rec = Array.isArray(lookup?.data)
+                ? lookup.data.find((r) => String(r.id) === String(recordId))
+                : null;
+            if (rec) {
+                preview = `\n| Type | ${rec.type} |\n| Name | ${rec.name} |\n| Content | ${rec.content} |`;
+            }
+        }
+        catch {
+            // Preview is best-effort.
+        }
+        const confirmId = stashDelete(domainId, recordId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**Delete DNS record — confirmation required**\n\n` +
+                        `| Field | Value |\n|-------|-------|\n| Domain ID | ${domainId} |\n| Record ID | ${recordId} |${preview}\n\n` +
+                        `⚠️ This cannot be undone. Call \`confirm_delete_dns_record\` with:\n\n\`${confirmId}\`\n\nExpires in 30 minutes.`,
+                },
+            ],
+        };
+    });
+    // 5b. Confirm DNS record deletion
+    server.tool("confirm_delete_dns_record", "Confirm and execute a pending DNS record deletion. Pass the confirmation ID returned by delete_dns_record.", {
+        confirmationId: z.string().min(1).max(128).describe("Confirmation ID from delete_dns_record"),
+    }, async ({ confirmationId }) => {
+        const entry = popDelete(confirmationId);
+        if (!entry) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Confirmation not found or expired. Call delete_dns_record again.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const res = await client.del(`/api/client/domains/${entry.domainId}/dns/${entry.recordId}`);
+        if (!res.success) {
+            return {
+                content: [{ type: "text", text: `Error: ${res.error}` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `✅ DNS record ${entry.recordId} deleted from domain ID ${entry.domainId}. Propagation may take a few minutes.`,
+                },
+            ],
+        };
+    });
+}

package/dist/src/tools/domains.d.ts

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