lovieme-mcp 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,103 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# 🤖 LovieMe MCP Server (`lovieme-mcp`)
+
+The official **Model Context Protocol (MCP)** server for [LovieMe](https://www.lovie.me) — enabling AI coding agents (Cursor, Claude Code, Antigravity, Windsurf, Devin) to autonomously check availability, claim subdomains, configure Anycast DNS records, and apply 1-click cloud hosting presets directly from chat.
+
+---
+
+## ⚡ Quickstart
+
+### Run with `npx` (Zero Installation)
+```bash
+npx lovieme-mcp
+```
+
+---
+
+## 🔑 Authentication
+
+Set your LovieMe API key as an environment variable:
+
+```bash
+export LOVIE_API_KEY="lovie_live_your_api_key_here"
+```
+
+> **Tip:** You can generate a dedicated AI Agent API token in your [LovieMe Dashboard](https://www.lovie.me/dashboard/api-keys) with granular least-privilege permissions (`subdomains:read/write`, `dns:read/write`, `profile:read`).
+
+---
+
+## 🛠️ Configuration for AI Agents
+
+### 1. Cursor (`.cursor/mcp.json`)
+Add this to your project or global Cursor MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "lovieme": {
+      "command": "npx",
+      "args": ["-y", "lovieme-mcp"],
+      "env": {
+        "LOVIE_API_KEY": "lovie_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### 2. Claude Code (`claude.json`)
+```json
+{
+  "mcpServers": {
+    "lovieme": {
+      "command": "npx",
+      "args": ["-y", "lovieme-mcp"],
+      "env": {
+        "LOVIE_API_KEY": "lovie_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### 3. Claude Desktop App (`claude_desktop_config.json`)
+* **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+* **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "lovieme": {
+      "command": "npx",
+      "args": ["-y", "lovieme-mcp"],
+      "env": {
+        "LOVIE_API_KEY": "lovie_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+---
+
+## 📋 Available MCP Tools
+
+| Tool | Description | Required Scopes |
+| :--- | :--- | :---: |
+| `lovie_check_subdomain` | Check if a `*.lovie.me` prefix is available | Public (None) |
+| `lovie_claim_subdomain` | Claim a new subdomain under your account | `subdomains:write` |
+| `lovie_list_subdomains` | List all owned subdomains and DNS record counts | `subdomains:read` |
+| `lovie_get_subdomain` | Inspect details and active DNS records of a subdomain | `subdomains:read` |
+| `lovie_delete_subdomain`| Release a subdomain and purge edge records | `subdomains:write` |
+| `lovie_list_dns_records`| List active DNS records for a given subdomain | `dns:read` |
+| `lovie_create_dns_record`| Create A, AAAA, CNAME, TXT, or MX records | `dns:write` |
+| `lovie_delete_dns_record`| Remove an existing DNS record by ID | `dns:write` |
+| `lovie_list_presets` | List 1-click presets (Vercel, Railway, Render, etc.) | Public (None) |
+| `lovie_apply_preset` | Apply a 1-click cloud hosting preset to a subdomain | `dns:write` |
+| `lovie_verify_doh` | Test propagation across Google, Cloudflare, and Quad9 | Public (None) |
+| `lovie_get_profile` | Check account tier and remaining subdomain quota | `profile:read` |
+
+---
+
+## 📄 License
+MIT © Sagar Kewat (Sagarithm)
+

package/bin/lovieme-mcp.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { main } from "../dist/index.js";
+
+main().catch((error) => {
+  console.error("Fatal error in LovieMe MCP Server:", error);
+  process.exit(1);
+});
+

package/dist/client.d.ts

@@ -0,0 +1,67 @@
+import type { LovieMeProfile, LovieMeSubdomain, LovieMeDnsRecord, CloudPreset, DoHResolutionResult } from "./types.js";
+export declare class LovieMeClient {
+    private baseUrl;
+    private apiKey;
+    constructor(apiKey?: string, baseUrl?: string);
+    setApiKey(key: string): void;
+    hasApiKey(): boolean;
+    private request;
+    checkSubdomain(name: string): Promise<{
+        available: boolean;
+        name: string;
+        fqdn: string;
+        reason?: string;
+    }>;
+    getProfile(): Promise<{
+        profile: LovieMeProfile;
+    }>;
+    listSubdomains(): Promise<{
+        subdomains: LovieMeSubdomain[];
+    }>;
+    getSubdomain(name: string): Promise<{
+        subdomain: LovieMeSubdomain;
+        dns_records: LovieMeDnsRecord[];
+    }>;
+    claimSubdomain(name: string): Promise<{
+        success: boolean;
+        message: string;
+        subdomain: LovieMeSubdomain;
+    }>;
+    deleteSubdomain(name: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    listDnsRecords(subdomain: string): Promise<{
+        dns_records: LovieMeDnsRecord[];
+    }>;
+    createDnsRecord(data: {
+        subdomain: string;
+        type: "A" | "AAAA" | "CNAME" | "TXT" | "MX";
+        name: string;
+        content: string;
+        ttl?: number;
+        priority?: number;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        record: LovieMeDnsRecord;
+    }>;
+    deleteDnsRecord(id: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    listPresets(): Promise<{
+        presets: CloudPreset[];
+    }>;
+    applyPreset(data: {
+        subdomain: string;
+        preset: string;
+        customTarget?: string;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        created_records: LovieMeDnsRecord[];
+    }>;
+    verifyDoH(domain: string, type?: string): Promise<DoHResolutionResult[]>;
+    private ensureAuth;
+}

package/dist/client.js

@@ -0,0 +1,151 @@
+import dns from "node:dns";
+try {
+    dns.setDefaultResultOrder?.("ipv4first");
+}
+catch {
+    // Ignore in environments where setDefaultResultOrder is unsupported
+}
+export class LovieMeClient {
+    baseUrl;
+    apiKey;
+    constructor(apiKey, baseUrl) {
+        this.apiKey = apiKey || process.env.LOVIE_API_KEY || "";
+        this.baseUrl = (baseUrl || process.env.LOVIE_API_URL || "https://www.lovie.me").replace(/\/+$/, "");
+    }
+    setApiKey(key) {
+        this.apiKey = key;
+    }
+    hasApiKey() {
+        return Boolean(this.apiKey && this.apiKey.trim().length > 0);
+    }
+    async request(path, options = {}) {
+        const url = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+        const headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "LovieMe-MCP-Server/0.1.1",
+            ...(options.headers || {}),
+        };
+        if (this.apiKey) {
+            headers["Authorization"] = `Bearer ${this.apiKey.trim()}`;
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+        const contentType = response.headers.get("content-type") || "";
+        const isJson = contentType.includes("application/json");
+        const payload = isJson ? await response.json() : await response.text();
+        if (!response.ok) {
+            const errorMsg = (typeof payload === "object" && payload !== null && (payload.error || payload.message)) ||
+                `HTTP ${response.status}: ${response.statusText}`;
+            throw new Error(String(errorMsg));
+        }
+        return payload;
+    }
+    // 1. Availability check (public endpoint, works without API key)
+    async checkSubdomain(name) {
+        const cleanName = name.replace(/\.lovie\.me$/i, "").trim().toLowerCase();
+        return this.request(`/api/v1/subdomains/check?name=${encodeURIComponent(cleanName)}`);
+    }
+    // 2. Profile & quota
+    async getProfile() {
+        this.ensureAuth();
+        return this.request("/api/v1/me");
+    }
+    // 3. Subdomains
+    async listSubdomains() {
+        this.ensureAuth();
+        return this.request("/api/v1/subdomains");
+    }
+    async getSubdomain(name) {
+        this.ensureAuth();
+        const cleanName = name.replace(/\.lovie\.me$/i, "").trim().toLowerCase();
+        return this.request(`/api/v1/subdomains/${encodeURIComponent(cleanName)}`);
+    }
+    async claimSubdomain(name) {
+        this.ensureAuth();
+        const cleanName = name.replace(/\.lovie\.me$/i, "").trim().toLowerCase();
+        return this.request("/api/v1/subdomains", {
+            method: "POST",
+            body: JSON.stringify({ name: cleanName }),
+        });
+    }
+    async deleteSubdomain(name) {
+        this.ensureAuth();
+        const cleanName = name.replace(/\.lovie\.me$/i, "").trim().toLowerCase();
+        return this.request(`/api/v1/subdomains/${encodeURIComponent(cleanName)}`, {
+            method: "DELETE",
+        });
+    }
+    // 4. DNS Records
+    async listDnsRecords(subdomain) {
+        this.ensureAuth();
+        const cleanSub = subdomain.replace(/\.lovie\.me$/i, "").trim().toLowerCase();
+        return this.request(`/api/v1/dns/records?subdomain=${encodeURIComponent(cleanSub)}`);
+    }
+    async createDnsRecord(data) {
+        this.ensureAuth();
+        return this.request("/api/v1/dns/records", {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+    }
+    async deleteDnsRecord(id) {
+        this.ensureAuth();
+        return this.request(`/api/v1/dns/records/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+        });
+    }
+    // 5. Presets
+    async listPresets() {
+        return this.request("/api/v1/dns/presets");
+    }
+    async applyPreset(data) {
+        this.ensureAuth();
+        return this.request("/api/v1/dns/presets", {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+    }
+    // 6. Global DoH Multi-Resolver Verification
+    async verifyDoH(domain, type = "A") {
+        const clean = domain.trim().toLowerCase();
+        const fqdn = clean === "lovie.me" || clean.endsWith(".lovie.me") ? clean : `${clean}.lovie.me`;
+        const resolvers = [
+            { name: "Google Public DNS", url: `https://dns.google/resolve?name=${encodeURIComponent(fqdn)}&type=${type}` },
+            { name: "Cloudflare (1.1.1.1)", url: `https://cloudflare-dns.com/dns-query?name=${encodeURIComponent(fqdn)}&type=${type}` },
+            { name: "AliDNS Global", url: `https://dns.alidns.com/resolve?name=${encodeURIComponent(fqdn)}&type=${type}` },
+        ];
+        const results = await Promise.allSettled(resolvers.map(async ({ name, url }) => {
+            const start = Date.now();
+            const res = await fetch(url, {
+                headers: { Accept: "application/dns-json" },
+            });
+            const latency = Date.now() - start;
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            const data = (await res.json());
+            return {
+                resolver: name,
+                status: (data.Answer && data.Answer.length > 0 ? "resolved" : "not_found"),
+                latency_ms: latency,
+                answers: data.Answer || [],
+            };
+        }));
+        return results.map((r, i) => {
+            if (r.status === "fulfilled")
+                return r.value;
+            return {
+                resolver: resolvers[i].name,
+                status: "error",
+                latency_ms: 0,
+                answers: [],
+            };
+        });
+    }
+    ensureAuth() {
+        if (!this.apiKey) {
+            throw new Error("LovieMe API key required. Set the LOVIE_API_KEY environment variable or pass an API key (format: lovie_live_...).");
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function createServer(apiKey?: string, baseUrl?: string): Server;
+export declare function main(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,34 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { LovieMeClient } from "./client.js";
+import { LOVIE_TOOLS, handleToolCall } from "./tools.js";
+export function createServer(apiKey, baseUrl) {
+    const client = new LovieMeClient(apiKey, baseUrl);
+    const server = new Server({
+        name: "lovieme-mcp",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // 1. List available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: LOVIE_TOOLS,
+        };
+    });
+    // 2. Call tool
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        return handleToolCall(name, args, client);
+    });
+    return server;
+}
+export async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("LovieMe MCP Server running on stdio");
+}

package/dist/tools.d.ts

@@ -0,0 +1,10 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { LovieMeClient } from "./client.js";
+export declare const LOVIE_TOOLS: Tool[];
+export declare function handleToolCall(name: string, args: Record<string, unknown> | undefined, client: LovieMeClient): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;

package/dist/tools.js

@@ -0,0 +1,359 @@
+export const LOVIE_TOOLS = [
+    {
+        name: "lovie_check_subdomain",
+        description: "Check whether a *.lovie.me subdomain prefix is available for registration.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Subdomain prefix to check (e.g. 'my-app' for my-app.lovie.me).",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "lovie_claim_subdomain",
+        description: "Claim and register a new *.lovie.me subdomain. Requires LOVIE_API_KEY with 'subdomains:write' scope.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Subdomain prefix to claim (alphanumeric and hyphens, 3-63 chars).",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "lovie_list_subdomains",
+        description: "List all subdomains owned by the authenticated account with their DNS records count. Requires LOVIE_API_KEY with 'subdomains:read' scope.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "lovie_get_subdomain",
+        description: "Inspect details of a specific subdomain including its active DNS records. Requires LOVIE_API_KEY with 'subdomains:read' scope.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Subdomain name or prefix to inspect.",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "lovie_delete_subdomain",
+        description: "Release and permanently delete a subdomain, purging all its DNS records from Gcore Anycast nameservers. Requires LOVIE_API_KEY with 'subdomains:write' scope.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Subdomain prefix to release (e.g. 'test-app').",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "lovie_list_dns_records",
+        description: "List all active DNS records for a given subdomain. Requires LOVIE_API_KEY with 'dns:read' scope.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                subdomain: {
+                    type: "string",
+                    description: "Subdomain prefix (e.g. 'my-app').",
+                },
+            },
+            required: ["subdomain"],
+        },
+    },
+    {
+        name: "lovie_create_dns_record",
+        description: "Create an RFC-compliant DNS record (A, AAAA, CNAME, TXT, MX) with sub-2s Gcore Anycast propagation. Requires LOVIE_API_KEY with 'dns:write' scope.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                subdomain: {
+                    type: "string",
+                    description: "Subdomain prefix where the record belongs (e.g. 'my-app').",
+                },
+                type: {
+                    type: "string",
+                    enum: ["A", "AAAA", "CNAME", "TXT", "MX"],
+                    description: "DNS record type.",
+                },
+                name: {
+                    type: "string",
+                    description: "Host label ('@' for apex of subdomain, or 'www', 'api', etc.).",
+                },
+                content: {
+                    type: "string",
+                    description: "Record destination (IPv4 for A, IPv6 for AAAA, target host for CNAME, string for TXT).",
+                },
+                ttl: {
+                    type: "number",
+                    description: "TTL in seconds (default: 300).",
+                },
+                priority: {
+                    type: "number",
+                    description: "MX record priority (required for MX, e.g. 10).",
+                },
+            },
+            required: ["subdomain", "type", "name", "content"],
+        },
+    },
+    {
+        name: "lovie_delete_dns_record",
+        description: "Delete an existing DNS record by ID, removing it from both database and Anycast edge. Requires LOVIE_API_KEY with 'dns:write' scope.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: {
+                    type: "string",
+                    description: "The unique UUID of the DNS record to delete.",
+                },
+            },
+            required: ["id"],
+        },
+    },
+    {
+        name: "lovie_list_presets",
+        description: "List all verified 1-click cloud hosting presets (Vercel, Railway, Render, GitHub Pages, Cloudflare Pages, Netlify, Fly.io).",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "lovie_apply_preset",
+        description: "Apply a 1-click cloud hosting DNS preset to your subdomain. Automatically configures tested CNAME and A records. Requires LOVIE_API_KEY with 'dns:write' scope.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                subdomain: {
+                    type: "string",
+                    description: "Subdomain prefix to apply preset to (e.g. 'my-app').",
+                },
+                preset: {
+                    type: "string",
+                    enum: ["vercel", "railway", "render", "github-pages", "cloudflare-pages", "netlify", "flyio"],
+                    description: "Target platform preset ID.",
+                },
+                customTarget: {
+                    type: "string",
+                    description: "Optional custom target required for some presets (e.g. GitHub username for github-pages, or Railway target domain).",
+                },
+            },
+            required: ["subdomain", "preset"],
+        },
+    },
+    {
+        name: "lovie_verify_doh",
+        description: "Verify live Anycast DNS propagation worldwide by parallel-querying Google (8.8.8.8), Cloudflare (1.1.1.1), and Quad9 (9.9.9.9) DoH resolvers.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                domain: {
+                    type: "string",
+                    description: "Subdomain to test (e.g. 'my-app' or 'my-app.lovie.me').",
+                },
+                type: {
+                    type: "string",
+                    enum: ["A", "AAAA", "CNAME", "TXT", "MX"],
+                    description: "Record type to verify (default: 'A').",
+                },
+            },
+            required: ["domain"],
+        },
+    },
+    {
+        name: "lovie_get_profile",
+        description: "Inspect the current user profile, plan tier (Free / Pro Lifetime / Builder Grant), and remaining subdomain quotas. Requires LOVIE_API_KEY with 'profile:read' scope.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+];
+export async function handleToolCall(name, args, client) {
+    try {
+        const p = args || {};
+        switch (name) {
+            case "lovie_check_subdomain": {
+                const result = await client.checkSubdomain(String(p.name));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_claim_subdomain": {
+                const result = await client.claimSubdomain(String(p.name));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_list_subdomains": {
+                const result = await client.listSubdomains();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_get_subdomain": {
+                const result = await client.getSubdomain(String(p.name));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_delete_subdomain": {
+                const result = await client.deleteSubdomain(String(p.name));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_list_dns_records": {
+                const result = await client.listDnsRecords(String(p.subdomain));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_create_dns_record": {
+                const result = await client.createDnsRecord({
+                    subdomain: String(p.subdomain),
+                    type: p.type,
+                    name: String(p.name),
+                    content: String(p.content),
+                    ttl: p.ttl ? Number(p.ttl) : undefined,
+                    priority: p.priority ? Number(p.priority) : undefined,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_delete_dns_record": {
+                const result = await client.deleteDnsRecord(String(p.id));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_list_presets": {
+                const result = await client.listPresets();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_apply_preset": {
+                const result = await client.applyPreset({
+                    subdomain: String(p.subdomain),
+                    preset: String(p.preset),
+                    customTarget: p.customTarget ? String(p.customTarget) : undefined,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_verify_doh": {
+                const result = await client.verifyDoH(String(p.domain), p.type ? String(p.type) : "A");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "lovie_get_profile": {
+                const result = await client.getProfile();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: `Unknown tool: ${name}`,
+                        },
+                    ],
+                };
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `Error executing ${name}: ${msg}`,
+                },
+            ],
+        };
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+export interface LovieMeProfile {
+    id: string;
+    email?: string;
+    name?: string;
+    plan: "starter" | "pro" | "grant";
+    quota: {
+        subdomains_max: number;
+        subdomains_used: number;
+        subdomains_remaining: number;
+    };
+}
+export interface LovieMeSubdomain {
+    id: string;
+    name: string;
+    fqdn: string;
+    created_at: string;
+    dns_records_count: number;
+    email_forwarder_active: boolean;
+}
+export interface LovieMeDnsRecord {
+    id: string;
+    subdomain_id: string;
+    type: "A" | "AAAA" | "CNAME" | "TXT" | "MX" | "CAA";
+    name: string;
+    content: string;
+    ttl: number;
+    priority?: number | null;
+    created_at: string;
+}
+export interface PresetTarget {
+    name: string;
+    type: "CNAME" | "A" | "TXT";
+    content: string;
+    ttl: number;
+    priority?: number;
+}
+export interface CloudPreset {
+    id: string;
+    name: string;
+    description: string;
+    records: PresetTarget[];
+    docs_url: string;
+}
+export interface DoHResolutionResult {
+    resolver: string;
+    status: "resolved" | "not_found" | "error";
+    latency_ms: number;
+    answers: Array<{
+        name: string;
+        type: number;
+        data: string;
+        TTL: number;
+    }>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,43 @@
-{
-  "name": "lovieme-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "lovieme-mcp",
+  "version": "0.1.1",
+  "description": "Official Model Context Protocol (MCP) server for LovieMe — claim free *.lovie.me subdomains, configure Anycast DNS, and wire up cloud presets directly from AI coding agents.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "lovieme-mcp": "bin/lovieme-mcp.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "lovieme",
+    "dns",
+    "subdomain",
+    "ai-agent",
+    "cursor",
+    "claude-code",
+    "antigravity"
+  ],
+  "author": "Sagar Kewat (Sagarithm)",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "typescript": "^5.8.0",
+    "vitest": "^4.1.7"
+  }
+}